Flesh out MCP initialization lifecycle

client.go

@@ -25,8 +25,21 @@ func NewClient(transport transport.Transport) *Client {
 	}
 }
 
+// A bit loosey goosey, but it works for now.
+// See: https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/lifecycle/
+type InitializeRequestParams struct {
+	ProtocolVersion string                      `json:"protocolVersion"`
+	ClientInfo      InitializeRequestClientInfo `json:"clientInfo"`
+	Capabilities    map[string]interface{}      `json:"capabilities"`
+}
+
+type InitializeRequestClientInfo struct {
+	Name    string `json:"name"`
+	Version string `json:"version"`
+}
+
 // Initialize connects to the server and retrieves its capabilities
-func (c *Client) Initialize(ctx context.Context) (*InitializeResponse, error) {
+func (c *Client) Initialize(ctx context.Context, params *InitializeRequestParams) (*InitializeResponse, error) {
 	if c.initialized {
 		return nil, errors.New("client already initialized")
 	}
@@ -37,7 +50,7 @@ func (c *Client) Initialize(ctx context.Context) (*InitializeResponse, error) {
 	}
 
 	// Make initialize request to server
-	response, err := c.protocol.Request(ctx, "initialize", map[string]interface{}{}, nil)
+	response, err := c.protocol.Request(ctx, "initialize", params, nil)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to initialize")
 	}
@@ -53,8 +66,14 @@ func (c *Client) Initialize(ctx context.Context) (*InitializeResponse, error) {
 		return nil, errors.Wrap(err, "failed to unmarshal initialize response")
 	}
 
+	err = c.protocol.Notification("notifications/initialized", nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to send initialized notification")
+	}
+
 	c.capabilities = &initResult.Capabilities
 	c.initialized = true
+
 	return &initResult, nil
 }
 

examples/client/main.go

@@ -10,13 +10,18 @@ import (
 	"github.com/rvoh-emccaleb/mcp-golang/transport/stdio"
 )
 
+const (
+	ProtocolVersion = "2024-11-05"
+)
+
 func main() {
 	// Start the server process
 	cmd := exec.Command("go", "run", "./server/main.go")
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		log.Fatalf("Failed to get stdin pipe: %v", err)
 	}
+
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		log.Fatalf("Failed to get stdout pipe: %v", err)
@@ -25,12 +30,23 @@ func main() {
 	if err := cmd.Start(); err != nil {
 		log.Fatalf("Failed to start server: %v", err)
 	}
+
 	defer cmd.Process.Kill()
 
 	clientTransport := stdio.NewStdioServerTransportWithIO(stdout, stdin)
 	client := mcp_golang.NewClient(clientTransport)
 
-	if _, err := client.Initialize(context.Background()); err != nil {
+	if _, err := client.Initialize(
+		context.Background(),
+		&mcp_golang.InitializeRequestParams{
+			ClientInfo: mcp_golang.InitializeRequestClientInfo{
+				Name:    "example-client",
+				Version: "0.1.0",
+			},
+			ProtocolVersion: ProtocolVersion,
+			Capabilities:    nil,
+		},
+	); err != nil {
 		log.Fatalf("Failed to initialize client: %v", err)
 	}
 

examples/http_example/auth_example_client/main.go

@@ -9,6 +9,10 @@ import (
 	"github.com/rvoh-emccaleb/mcp-golang/transport/http"
 )
 
+const (
+	ProtocolVersion = "2024-11-05"
+)
+
 func main() {
 	// Create an HTTP transport that connects to the server
 	transport := http.NewHTTPClientTransport("/mcp")
@@ -20,7 +24,17 @@ func main() {
 	client := mcp_golang.NewClient(transport)
 
 	// Initialize the client
-	if resp, err := client.Initialize(context.Background()); err != nil {
+	if resp, err := client.Initialize(
+		context.Background(),
+		&mcp_golang.InitializeRequestParams{
+			ClientInfo: mcp_golang.InitializeRequestClientInfo{
+				Name:    "example-client",
+				Version: "0.1.0",
+			},
+			ProtocolVersion: ProtocolVersion,
+			Capabilities:    nil,
+		},
+	); err != nil {
 		log.Fatalf("Failed to initialize client: %v", err)
 	} else {
 		log.Printf("Initialized client: %v", spew.Sdump(resp))

examples/http_example/client/main.go

@@ -10,6 +10,10 @@ import (
 	"github.com/rvoh-emccaleb/mcp-golang/transport/http"
 )
 
+const (
+	ProtocolVersion = "2024-11-05"
+)
+
 func main() {
 	// Create an HTTP transport that connects to the server
 	transport := http.NewHTTPClientTransport("/mcp")
@@ -19,8 +23,19 @@ func main() {
 	client := mcp_golang.NewClient(transport)
 
 	// Initialize the client
-	if resp, err := client.Initialize(context.Background()); err != nil {
+	if resp, err := client.Initialize(
+		context.Background(),
+		&mcp_golang.InitializeRequestParams{
+			ClientInfo: mcp_golang.InitializeRequestClientInfo{
+				Name:    "example-client",
+				Version: "0.1.0",
+			},
+			ProtocolVersion: ProtocolVersion,
+			Capabilities:    nil,
+		},
+	); err != nil {
 		log.Fatalf("Failed to initialize client: %v", err)
+
 	} else {
 		log.Printf("Initialized client: %v", spew.Sdump(resp))
 	}