Files
coder/coderd/mcp/mcp_test.go
T
Hugo Dutka 150c680a4b fix: return MCP server tool execution errors as tool results (#29051)
Coder's MCP server currently sends most tool execution failures as
top-level JSON-RPC errors. The underlying error text is transmitted like
this:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32603,
    "message": "workspace name cannot be empty"
  }
}
```


Not all clients handle it well, and some may return a generic "MCP tool
request failed." to the model instead of passing the details as tool
output.

This PR starts returning execution failures as tool results with
`isError: true` and descriptive content like this:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "isError": true,
    "content": [
      {
        "type": "text",
        "text": "workspace name cannot be empty"
      }
    ]
  }
}
```

This should make the MCP server work better across a broader range of
MCP clients.
2026-09-08 17:28:46 +00:00

361 lines
11 KiB
Go

package mcp_test
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/coder/aisdk-go"
mcpserver "github.com/coder/coder/v2/coderd/mcp"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/toolsdk"
"github.com/coder/coder/v2/testutil"
)
func TestMCPServer_Creation(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
require.NotNil(t, server)
}
func TestMCPServer_Handler(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
// Test that server implements http.Handler interface
var handler http.Handler = server
require.NotNil(t, handler)
}
func TestMCPHTTP_InitializeRequest(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
// Use server directly as http.Handler
handler := server
// Create initialize request
initRequest := map[string]any{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": map[string]any{
"protocolVersion": "2025-06-18",
"capabilities": map[string]any{},
"clientInfo": map[string]any{
"name": "test-client",
"version": "1.0.0",
},
},
}
body, err := json.Marshal(initRequest)
require.NoError(t, err)
req := httptest.NewRequest(http.MethodPost, "/", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/json,text/event-stream")
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
if recorder.Code != http.StatusOK {
t.Logf("Response body: %s", recorder.Body.String())
}
assert.Equal(t, http.StatusOK, recorder.Code)
sessionID := recorder.Header().Get("Mcp-Session-Id")
assert.Empty(t, sessionID)
// Parse response
var response map[string]any
err = json.Unmarshal(recorder.Body.Bytes(), &response)
require.NoError(t, err)
assert.Equal(t, "2.0", response["jsonrpc"])
assert.Equal(t, float64(1), response["id"])
result, ok := response["result"].(map[string]any)
require.True(t, ok)
assert.Equal(t, "2025-06-18", result["protocolVersion"])
assert.Contains(t, result, "capabilities")
assert.Contains(t, result, "serverInfo")
}
func TestMCPHTTP_ToolRegistration(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
// Test registering tools with nil client should return error
err = server.RegisterTools(nil)
require.Error(t, err)
require.Contains(t, err.Error(), "client cannot be nil", "Should reject nil client with appropriate error message")
// Test registering tools with valid client should succeed
client := codersdk.New(testutil.MustURL(t, "http://not-used"))
err = server.RegisterTools(client)
require.NoError(t, err)
// Verify that all expected tools are available in the toolsdk
expectedToolCount := len(toolsdk.All)
require.Greater(t, expectedToolCount, 0, "Should have some tools available")
// Verify specific tools are present by checking tool names
toolNames := make([]string, len(toolsdk.All))
for i, tool := range toolsdk.All {
toolNames[i] = tool.Name
}
require.Contains(t, toolNames, toolsdk.ToolNameReportTask, "Should include ReportTask (UserClientOptional)")
require.Contains(t, toolNames, toolsdk.ToolNameGetAuthenticatedUser, "Should include GetAuthenticatedUser (requires auth)")
}
func TestMCPHTTP_ModernProtocol(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
client := codersdk.New(testutil.MustURL(t, "http://not-used"))
err = server.RegisterTools(client)
require.NoError(t, err)
ts := httptest.NewServer(server)
defer ts.Close()
ctx := testutil.Context(t, testutil.WaitShort)
mcpClient := sdkmcp.NewClient(&sdkmcp.Implementation{Name: "test-client", Version: "1.0.0"}, nil)
session, err := mcpClient.Connect(ctx, &sdkmcp.StreamableClientTransport{
Endpoint: ts.URL,
}, nil)
require.NoError(t, err)
defer session.Close()
init := session.InitializeResult()
require.Equal(t, "2026-07-28", init.ProtocolVersion)
require.Equal(t, mcpserver.MCPServerName, init.ServerInfo.Name)
require.Equal(t, mcpserver.MCPServerInstructions, init.Instructions)
tools, err := session.ListTools(ctx, nil)
require.NoError(t, err)
require.NotEmpty(t, tools.Tools)
}
func TestMCPHTTP_ToolArgumentValidation(t *testing.T) {
t.Parallel()
server, err := mcpserver.NewServer(testutil.Logger(t))
require.NoError(t, err)
require.NoError(t, server.RegisterTools(codersdk.New(testutil.MustURL(t, "http://not-used"))))
ts := httptest.NewServer(server)
t.Cleanup(ts.Close)
connectCtx := testutil.Context(t, testutil.WaitShort)
mcpClient := sdkmcp.NewClient(&sdkmcp.Implementation{Name: "test-client", Version: "1.0.0"}, nil)
session, err := mcpClient.Connect(connectCtx, &sdkmcp.StreamableClientTransport{Endpoint: ts.URL}, nil)
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, session.Close())
})
tests := []struct {
name string
arguments map[string]any
keyword string
property string
}{
{
name: "MissingRequiredProperty",
arguments: map[string]any{
"user": "me",
"rich_parameters": map[string]any{},
},
keyword: "required:",
property: "name",
},
{
name: "IncorrectPropertyType",
arguments: map[string]any{
"user": false,
"name": "example",
"rich_parameters": map[string]any{},
},
keyword: "type:",
property: "user",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
result, err := session.CallTool(ctx, &sdkmcp.CallToolParams{
Name: toolsdk.ToolNameCreateWorkspace,
Arguments: test.arguments,
})
require.NoError(t, err)
require.True(t, result.IsError)
require.Len(t, result.Content, 1)
content, ok := result.Content[0].(*sdkmcp.TextContent)
require.True(t, ok, "expected TextContent, got %T", result.Content[0])
var payload struct {
Error string `json:"error"`
ExpectedSchema map[string]any `json:"expectedSchema"`
}
require.NoError(t, json.Unmarshal([]byte(content.Text), &payload))
require.Contains(t, payload.Error, "invalid arguments: $:")
require.Contains(t, payload.Error, test.keyword)
require.Contains(t, payload.Error, test.property)
require.Equal(t, "object", payload.ExpectedSchema["type"])
require.Equal(t, false, payload.ExpectedSchema["additionalProperties"])
properties, ok := payload.ExpectedSchema["properties"].(map[string]any)
require.True(t, ok)
require.Contains(t, properties, test.property)
})
}
}
func TestRegisterSDKTool(t *testing.T) {
t.Parallel()
type arguments struct {
Fail bool `json:"fail"`
Value string `json:"value"`
}
type response struct {
Value string `json:"value"`
}
tool := toolsdk.Tool[arguments, response]{
Tool: aisdk.Tool{
Name: "test_typed_tool",
Schema: aisdk.Schema{
Properties: map[string]any{
"fail": map[string]any{"type": "boolean"},
"value": map[string]any{"type": "string"},
},
Required: []string{"value"},
},
},
Handler: func(_ context.Context, _ toolsdk.Deps, args arguments) (response, error) {
if args.Fail {
return response{}, assert.AnError
}
return response{Value: args.Value}, nil
},
}.Generic()
server := sdkmcp.NewServer(&sdkmcp.Implementation{Name: "test-server", Version: "1.0.0"}, nil)
mcpserver.RegisterSDKTool(server, tool, toolsdk.Deps{})
serverTransport, clientTransport := sdkmcp.NewInMemoryTransports()
ctx := testutil.Context(t, testutil.WaitShort)
serverSession, err := server.Connect(ctx, serverTransport, nil)
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, serverSession.Close())
})
client := sdkmcp.NewClient(&sdkmcp.Implementation{Name: "test-client", Version: "1.0.0"}, nil)
clientSession, err := client.Connect(ctx, clientTransport, nil)
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, clientSession.Close())
})
result, err := clientSession.CallTool(ctx, &sdkmcp.CallToolParams{
Name: tool.Name,
Arguments: map[string]any{"value": "hello"},
})
require.NoError(t, err)
require.False(t, result.IsError)
require.Len(t, result.Content, 1)
content, ok := result.Content[0].(*sdkmcp.TextContent)
require.True(t, ok)
require.JSONEq(t, `{"value":"hello"}`, content.Text)
result, err = clientSession.CallTool(ctx, &sdkmcp.CallToolParams{
Name: tool.Name,
Arguments: map[string]any{"fail": true, "value": "hello"},
})
require.NoError(t, err)
require.True(t, result.IsError)
require.Len(t, result.Content, 1)
content, ok = result.Content[0].(*sdkmcp.TextContent)
require.True(t, ok)
require.Equal(t, assert.AnError.Error(), content.Text)
}
func TestMCPHTTP_UnsupportedProtocolVersion(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
body := `{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{"_meta":{` +
`"io.modelcontextprotocol/protocolVersion":"2099-01-01",` +
`"io.modelcontextprotocol/clientInfo":{"name":"test","version":"1.0"},` +
`"io.modelcontextprotocol/clientCapabilities":{}}}}`
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/json,text/event-stream")
req.Header.Set("MCP-Protocol-Version", "2099-01-01")
req.Header.Set("Mcp-Method", "tools/list")
recorder := httptest.NewRecorder()
server.ServeHTTP(recorder, req)
var response struct {
Error struct {
Code int `json:"code"`
Message string `json:"message"`
} `json:"error"`
}
require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &response), "body: %s", recorder.Body.String())
require.Equal(t, -32022, response.Error.Code)
}
func TestMCPHTTP_TransportMethods(t *testing.T) {
t.Parallel()
logger := testutil.Logger(t)
server, err := mcpserver.NewServer(logger)
require.NoError(t, err)
for _, method := range []string{http.MethodGet, http.MethodDelete} {
req := httptest.NewRequest(method, "/", nil)
if method == http.MethodGet {
req.Header.Set("Accept", "text/event-stream")
}
recorder := httptest.NewRecorder()
server.ServeHTTP(recorder, req)
require.Equal(t, http.StatusMethodNotAllowed, recorder.Code, "method %s", method)
}
}