Merge branch 'main' into http-sampling-improvements and resolve conflicts

Author: ezynda3

.github/workflows/release.yml

@@ -12,6 +12,7 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Create GitHub Release
+        id: create_release
         uses: actions/create-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -20,3 +21,38 @@ jobs:
           release_name: Release ${{ github.ref }}
           draft: false
           prerelease: false
+
+      - name: Send Discord Notification
+        if: success()
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.RELEASES_WEBHOOK }}
+          TAG_NAME: ${{ github.ref_name }}
+          RELEASE_URL: ${{ steps.create_release.outputs.html_url }}
+        run: |
+          curl -H "Content-Type: application/json" \
+            -X POST \
+            -d "{
+              \"embeds\": [{
+                \"title\": \"🚀 New Release: $TAG_NAME\",
+                \"description\": \"A new version of mcp-go has been released!\",
+                \"color\": 5814783,
+                \"fields\": [
+                  {
+                    \"name\": \"Version\",
+                    \"value\": \"$TAG_NAME\",
+                    \"inline\": true
+                  },
+                  {
+                    \"name\": \"Repository\",
+                    \"value\": \"[mcp-go](https://github.com/${{ github.repository }})\",
+                    \"inline\": true
+                  }
+                ],
+                \"footer\": {
+                  \"text\": \"Released via GitHub Actions\"
+                },
+                \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%S.000Z)\",
+                \"url\": \"$RELEASE_URL\"
+              }]
+            }" \
+            $DISCORD_WEBHOOK

client/client.go

@@ -3,7 +3,6 @@ package client
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"slices"
 	"sync"
@@ -25,6 +24,7 @@ type Client struct {
 	serverCapabilities mcp.ServerCapabilities
 	protocolVersion    string
 	samplingHandler    SamplingHandler
+	elicitationHandler ElicitationHandler
 }
 
 type ClientOption func(*Client)
@@ -44,6 +44,14 @@ func WithSamplingHandler(handler SamplingHandler) ClientOption {
 	}
 }
 
+// WithElicitationHandler sets the elicitation handler for the client.
+// When set, the client will declare elicitation capability during initialization.
+func WithElicitationHandler(handler ElicitationHandler) ClientOption {
+	return func(c *Client) {
+		c.elicitationHandler = handler
+	}
+}
+
 // WithSession assumes a MCP Session has already been initialized
 func WithSession() ClientOption {
 	return func(c *Client) {
@@ -77,9 +85,16 @@ func (c *Client) Start(ctx context.Context) error {
 	if c.transport == nil {
 		return fmt.Errorf("transport is nil")
 	}
-	err := c.transport.Start(ctx)
-	if err != nil {
-		return err
+
+	if _, ok := c.transport.(*transport.Stdio); !ok {
+		// the stdio transport from NewStdioMCPClientWithOptions
+		// is already started, dont start again.
+		//
+		// Start the transport for other transport types
+		err := c.transport.Start(ctx)
+		if err != nil {
+			return err
+		}
 	}
 
 	c.transport.SetNotificationHandler(func(notification mcp.JSONRPCNotification) {
@@ -150,7 +165,7 @@ func (c *Client) sendRequest(
 	}
 
 	if response.Error != nil {
-		return nil, errors.New(response.Error.Message)
+		return nil, response.Error.AsError()
 	}
 
 	return &response.Result, nil
@@ -167,6 +182,10 @@ func (c *Client) Initialize(
 	if c.samplingHandler != nil {
 		capabilities.Sampling = &struct{}{}
 	}
+	// Add elicitation capability if handler is configured
+	if c.elicitationHandler != nil {
+		capabilities.Elicitation = &struct{}{}
+	}
 
 	// Ensure we send a params object with all required fields
 	params := struct {
@@ -451,11 +470,15 @@ func (c *Client) Complete(
 }
 
 // handleIncomingRequest processes incoming requests from the server.
-// This is the main entry point for server-to-client requests like sampling.
+// This is the main entry point for server-to-client requests like sampling and elicitation.
 func (c *Client) handleIncomingRequest(ctx context.Context, request transport.JSONRPCRequest) (*transport.JSONRPCResponse, error) {
 	switch request.Method {
 	case string(mcp.MethodSamplingCreateMessage):
 		return c.handleSamplingRequestTransport(ctx, request)
+	case string(mcp.MethodElicitationCreate):
+		return c.handleElicitationRequestTransport(ctx, request)
+	case string(mcp.MethodPing):
+		return c.handlePingRequestTransport(ctx, request)
 	default:
 		return nil, fmt.Errorf("unsupported request method: %s", request.Method)
 	}
@@ -516,14 +539,60 @@ func (c *Client) handleSamplingRequestTransport(ctx context.Context, request tra
 	}
 
 	// Create the transport response
-	response := &transport.JSONRPCResponse{
-		JSONRPC: mcp.JSONRPC_VERSION,
-		ID:      request.ID,
-		Result:  json.RawMessage(resultBytes),
+	response := transport.NewJSONRPCResultResponse(request.ID, json.RawMessage(resultBytes))
+
+	return response, nil
+}
+
+// handleElicitationRequestTransport handles elicitation requests at the transport level.
+func (c *Client) handleElicitationRequestTransport(ctx context.Context, request transport.JSONRPCRequest) (*transport.JSONRPCResponse, error) {
+	if c.elicitationHandler == nil {
+		return nil, fmt.Errorf("no elicitation handler configured")
 	}
 
+	// Parse the request parameters
+	var params mcp.ElicitationParams
+	if request.Params != nil {
+		paramsBytes, err := json.Marshal(request.Params)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal params: %w", err)
+		}
+		if err := json.Unmarshal(paramsBytes, &params); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal params: %w", err)
+		}
+	}
+
+	// Create the MCP request
+	mcpRequest := mcp.ElicitationRequest{
+		Request: mcp.Request{
+			Method: string(mcp.MethodElicitationCreate),
+		},
+		Params: params,
+	}
+
+	// Call the elicitation handler
+	result, err := c.elicitationHandler.Elicit(ctx, mcpRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	// Marshal the result
+	resultBytes, err := json.Marshal(result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal result: %w", err)
+	}
+
+	// Create the transport response
+	response := transport.NewJSONRPCResultResponse(request.ID, resultBytes)
+
 	return response, nil
 }
+
+func (c *Client) handlePingRequestTransport(ctx context.Context, request transport.JSONRPCRequest) (*transport.JSONRPCResponse, error) {
+	b, _ := json.Marshal(&mcp.EmptyResult{})
+	return transport.NewJSONRPCResultResponse(request.ID, b), nil
+}
+
 func listByPage[T any](
 	ctx context.Context,
 	client *Client,

client/elicitation.go

@@ -0,0 +1,19 @@
+package client
+
+import (
+	"context"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// ElicitationHandler defines the interface for handling elicitation requests from servers.
+// Clients can implement this interface to request additional information from users.
+type ElicitationHandler interface {
+	// Elicit handles an elicitation request from the server and returns the user's response.
+	// The implementation should:
+	// 1. Present the request message to the user
+	// 2. Validate input against the requested schema
+	// 3. Allow the user to accept, decline, or cancel
+	// 4. Return the appropriate response
+	Elicit(ctx context.Context, request mcp.ElicitationRequest) (*mcp.ElicitationResult, error)
+}