fix(mcp): tool call without arguments does not panic (#849) (#859)

Handle the case where an MCP client omits the "arguments" field from a
tools/call JSON-RPC request. The MCP spec defines arguments as optional
(arguments?: { [key: string]: unknown }), so clients that omit it are
spec-compliant. This is an edge case since most mainstream clients always
send "arguments": {}, but custom or minimal clients may not.

The fix:
- GoSdkToolCallParamsToToolCallRequest now skips json.Unmarshal when
  Arguments is nil, returning a valid ToolCallRequest instead of an error.
- toolCallLoggingMiddleware now checks the error instead of discarding it,
  preventing a nil pointer dereference on the log line.

Also adds test.McpRawPost, a reusable helper for sending raw JSON-RPC
requests to MCP HTTP endpoints, bypassing the go-sdk client normalization.

Fixes #849

Signed-off-by: Marc Nuri <marc@marcnuri.com>

Author: manusa

internal/test/mcp.go

@@ -3,8 +3,10 @@ package test
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -250,6 +252,36 @@ func (m *McpClient) CallTool(name string, args map[string]any) (*mcp.CallToolRes
 	})
 }
 
+// CallToolRaw sends a raw JSON-RPC tools/call request bypassing the go-sdk client.
+// This allows sending requests exactly as a non-go-sdk MCP client would, without
+// the go-sdk's automatic normalization (e.g., the go-sdk always adds "arguments": {}
+// even when nil).
+// The jsonParams is the raw JSON for the "params" field of the JSON-RPC request.
+func (m *McpClient) CallToolRaw(t *testing.T, jsonParams string) *http.Response {
+	t.Helper()
+	body := fmt.Sprintf(`{"jsonrpc":"2.0","id":99,"method":"tools/call","params":%s}`, jsonParams)
+	return McpRawPost(t, m.testServer.URL+"/mcp", m.Session.ID(), body)
+}
+
+// McpRawPost sends a raw JSON-RPC request to an MCP HTTP endpoint.
+// This is useful for testing MCP protocol edge cases that can't be reproduced through
+// the go-sdk client due to its automatic normalization (e.g., always adding "arguments": {},
+// always setting clientInfo).
+// The jsonBody should be a complete JSON-RPC message.
+func McpRawPost(t *testing.T, endpoint, sessionID, jsonBody string) *http.Response {
+	t.Helper()
+	req, err := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(jsonBody))
+	require.NoError(t, err)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json, text/event-stream")
+	if sessionID != "" {
+		req.Header.Set("Mcp-Session-Id", sessionID)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	return resp
+}
+
 // ListTools helper function to list available tools
 func (m *McpClient) ListTools() (*mcp.ListToolsResult, error) {
 	return m.Session.ListTools(m.ctx, &mcp.ListToolsParams{})

pkg/mcp/gosdk.go

@@ -81,8 +81,10 @@ func GoSdkToolCallRequestToToolCallRequest(request *mcp.CallToolRequest) (*ToolC
 
 func GoSdkToolCallParamsToToolCallRequest(toolCallParams *mcp.CallToolParamsRaw) (*ToolCallRequest, error) {
 	var arguments map[string]any
-	if err := json.Unmarshal(toolCallParams.Arguments, &arguments); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal tool call arguments: %w", err)
+	if len(toolCallParams.Arguments) > 0 {
+		if err := json.Unmarshal(toolCallParams.Arguments, &arguments); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tool call arguments: %w", err)
+		}
 	}
 	return &ToolCallRequest{
 		Name:      toolCallParams.Name,

pkg/mcp/middleware.go

@@ -70,8 +70,10 @@ func toolCallLoggingMiddleware(next mcp.MethodHandler) mcp.MethodHandler {
 	return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
 		switch params := req.GetParams().(type) {
 		case *mcp.CallToolParamsRaw:
-			toolCallRequest, _ := GoSdkToolCallParamsToToolCallRequest(params)
-			klog.V(5).Infof("mcp tool call: %s(%v)", toolCallRequest.Name, toolCallRequest.GetArguments())
+			toolCallRequest, err := GoSdkToolCallParamsToToolCallRequest(params)
+			if err == nil {
+				klog.V(5).Infof("mcp tool call: %s(%v)", toolCallRequest.Name, toolCallRequest.GetArguments())
+			}
 			if req.GetExtra() != nil && req.GetExtra().Header != nil {
 				buffer := bytes.NewBuffer(make([]byte, 0))
 				if err := req.GetExtra().Header.WriteSubset(buffer, map[string]bool{"Authorization": true, "authorization": true}); err == nil {

pkg/mcp/namespaces_test.go

@@ -46,6 +46,24 @@ func (s *NamespacesSuite) TestNamespacesList() {
 	})
 }
 
+// TestNamespacesListWithoutArguments verifies that namespaces_list can be called when the
+// MCP client omits the "arguments" field from the tools/call JSON-RPC request.
+// The MCP spec defines arguments as optional (arguments?: { [key: string]: unknown }),
+// so spec-compliant clients may omit it entirely for tools with no required parameters.
+// This is an edge case because most mainstream MCP clients (Claude Desktop, Cursor, etc.)
+// always send "arguments": {}, but custom or minimal clients may not.
+// https://github.com/containers/kubernetes-mcp-server/issues/849
+func (s *NamespacesSuite) TestNamespacesListWithoutArguments() {
+	s.InitMcpClient()
+	s.Run("namespaces_list without arguments does not panic", func() {
+		// Send a raw JSON-RPC request without the "arguments" field, bypassing
+		// the go-sdk client which always normalizes nil arguments to {}.
+		resp := s.CallToolRaw(s.T(), `{"name":"namespaces_list"}`)
+		defer func() { _ = resp.Body.Close() }()
+		s.Equal(200, resp.StatusCode)
+	})
+}
+
 func (s *NamespacesSuite) TestNamespacesListDenied() {
 	s.Require().NoError(toml.Unmarshal([]byte(`
 		denied_resources = [ { version = "v1", kind = "Namespace" } ]