[test] Add tests for mcp.Connection.callTool (#10937)

# Test Coverage Improvement: `callTool`

## Function Analyzed

- **Package**: `internal/mcp`
- **Function**: `Connection.callTool` (in `connection_methods.go`)
- **Previous Coverage**: 20.0%
- **New Coverage**: 100.0%
- **Complexity**: Medium (nil-defaulting branch, SDK dispatch, error
propagation)

## Why This Function?

`callTool` is the gateway's core `tools/call` dispatch path — it
normalizes nil `arguments` to an empty map (a hard MCP protocol
requirement) before invoking the backend SDK session's `CallTool`. It
had only 20% statement coverage: existing tests exercised argument
marshaling/unmarshaling at the HTTP JSON layer and nil-session error
paths, but never exercised the real SDK call path (the `if p.Arguments
== nil` branch and the successful `getSDKSession().CallTool(...)` call
were both untested).

## Tests Added

- ✅ `TestCallTool_NilArgumentsDefaultsToEmptyMap` — verifies omitted
`arguments` becomes an empty map at the backend
- ✅ `TestCallTool_ArgumentsForwarded` — verifies provided arguments are
forwarded unmodified
- ✅ `TestCallTool_BackendHandlerError` — verifies a Go error from the
backend tool handler surfaces as an error
- ✅ `TestCallTool_UnknownToolName` — verifies an unknown tool name
produces an error

All four tests spin up a **real** `sdk.NewStreamableHTTPHandler`-backed
`httptest.Server` (rather than mocking JSON-RPC at the HTTP layer), so
they exercise the actual `callSDKMethod → callParamMethod →
sdk.ClientSession.CallTool` dispatch path end-to-end.

## Coverage Report

```
Before: internal/mcp package 97.6%, callTool 20.0%
After:  internal/mcp package 98.4%, callTool 100.0%
Improvement: +0.8% package, +80% for the target function
```

## Test Execution

```
=== RUN   TestCallTool_NilArgumentsDefaultsToEmptyMap
--- PASS: TestCallTool_NilArgumentsDefaultsToEmptyMap (0.00s)
=== RUN   TestCallTool_ArgumentsForwarded
--- PASS: TestCallTool_ArgumentsForwarded (0.00s)
=== RUN   TestCallTool_BackendHandlerError
--- PASS: TestCallTool_BackendHandlerError (0.00s)
=== RUN   TestCallTool_UnknownToolName
--- PASS: TestCallTool_UnknownToolName (0.00s)
PASS
ok  	github.com/github/gh-aw-mcpg/internal/mcp	0.028s
```

`gofmt` and `go vet` are clean on the new file.

---
*Generated by Test Coverage Improver*
*Next run will target the next most complex under-tested function*

> Generated by [Test Coverage
Improver](https://github.com/github/gh-aw-mcpg/actions/runs/31324128354)
· auto · 131.6 AIC · ⊞ 10.1K ·
[◷](https://github.com/search?q=repo%3Agithub%2Fgh-aw-mcpg+%22gh-aw-workflow-id%3A+test-coverage-improver%22&type=pullrequests)

<!-- gh-aw-agentic-workflow: Test Coverage Improver, engine: copilot,
model: auto, id: 31324128354, workflow_id: test-coverage-improver, run:
https://github.com/github/gh-aw-mcpg/actions/runs/31324128354 -->

<!-- gh-aw-workflow-id: test-coverage-improver -->
<!-- gh-aw-workflow-call-id: github/gh-aw-mcpg/test-coverage-improver
-->

Author: lpcox

internal/mcp/call_tool_test.go

@@ -0,0 +1,153 @@
+package mcp
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+
+	sdk "github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// newCallToolTestBackend spins up a real SDK streamable HTTP MCP server with a
+// single tool ("echo_tool") that records the arguments it receives via
+// req.Params.Arguments (the SDK-native path, not the gateway's own JSON
+// parsing). This lets tests exercise Connection.callTool's real SDK dispatch
+// (via callSDKMethod → callParamMethod → sdk.ClientSession.CallTool) end to
+// end, rather than mocking at the HTTP JSON-RPC layer.
+func newCallToolTestBackend(t *testing.T) (*httptest.Server, *sync.Map) {
+	t.Helper()
+	received := &sync.Map{} // toolName -> map[string]any arguments
+
+	impl := &sdk.Implementation{Name: "call-tool-test-backend", Version: "1.0.0"}
+	mcpServer := sdk.NewServer(impl, nil)
+	mcpServer.AddTool(&sdk.Tool{
+		Name:        "echo_tool",
+		Description: "Echoes back the arguments it receives",
+		InputSchema: map[string]interface{}{"type": "object"},
+	}, func(_ context.Context, req *sdk.CallToolRequest) (*sdk.CallToolResult, error) {
+		args, err := ParseToolArguments(req)
+		if err != nil {
+			return &sdk.CallToolResult{
+				IsError: true,
+				Content: []sdk.Content{&sdk.TextContent{Text: err.Error()}},
+			}, nil
+		}
+		received.Store("echo_tool", args)
+		return &sdk.CallToolResult{
+			Content: []sdk.Content{&sdk.TextContent{Text: "ok"}},
+		}, nil
+	})
+	mcpServer.AddTool(&sdk.Tool{
+		Name:        "failing_tool",
+		Description: "Always returns a Go error from the handler",
+		InputSchema: map[string]interface{}{"type": "object"},
+	}, func(_ context.Context, _ *sdk.CallToolRequest) (*sdk.CallToolResult, error) {
+		return nil, assert.AnError
+	})
+
+	handler := sdk.NewStreamableHTTPHandler(func(_ *http.Request) *sdk.Server {
+		return mcpServer
+	}, &sdk.StreamableHTTPOptions{Stateless: false})
+
+	mux := http.NewServeMux()
+	mux.Handle("/mcp", handler)
+	mux.Handle("/mcp/", handler)
+
+	return httptest.NewServer(mux), received
+}
+
+// TestCallTool_NilArgumentsDefaultsToEmptyMap verifies that callTool (invoked
+// via the real SDK dispatch path) defaults a nil Arguments map to an empty
+// map before forwarding the call to the backend, per the MCP protocol
+// requirement that "arguments" always be present.
+func TestCallTool_NilArgumentsDefaultsToEmptyMap(t *testing.T) {
+	srv, received := newCallToolTestBackend(t)
+	defer srv.Close()
+
+	conn, err := NewHTTPConnection(context.Background(), "test-server", srv.URL+"/mcp", nil, nil, "", 0, 0)
+	require.NoError(t, err)
+	defer conn.Close()
+
+	// Explicitly omit "arguments" so p.Arguments unmarshals to nil.
+	params := map[string]interface{}{"name": "echo_tool"}
+	resp, err := conn.SendRequestWithServerID(context.Background(), "tools/call", params, "test-server")
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.Nil(t, resp.Error)
+
+	val, ok := received.Load("echo_tool")
+	require.True(t, ok, "backend should have recorded the call")
+	args, ok := val.(map[string]any)
+	require.True(t, ok)
+	assert.Empty(t, args, "nil arguments should be normalized to an empty map")
+}
+
+// TestCallTool_ArgumentsForwarded verifies that when arguments are provided,
+// callTool forwards them unmodified to the backend through the real SDK
+// dispatch path.
+func TestCallTool_ArgumentsForwarded(t *testing.T) {
+	srv, received := newCallToolTestBackend(t)
+	defer srv.Close()
+
+	conn, err := NewHTTPConnection(context.Background(), "test-server", srv.URL+"/mcp", nil, nil, "", 0, 0)
+	require.NoError(t, err)
+	defer conn.Close()
+
+	params := map[string]interface{}{
+		"name": "echo_tool",
+		"arguments": map[string]interface{}{
+			"query": "hello",
+			"count": float64(3),
+		},
+	}
+	resp, err := conn.SendRequestWithServerID(context.Background(), "tools/call", params, "test-server")
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.Nil(t, resp.Error)
+
+	val, ok := received.Load("echo_tool")
+	require.True(t, ok)
+	args, ok := val.(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, "hello", args["query"])
+	assert.Equal(t, float64(3), args["count"])
+}
+
+// TestCallTool_BackendHandlerError verifies that when the backend tool
+// handler returns a Go error (not a CallToolResult with IsError), callTool
+// surfaces that as an error through the real SDK dispatch path.
+func TestCallTool_BackendHandlerError(t *testing.T) {
+	srv, _ := newCallToolTestBackend(t)
+	defer srv.Close()
+
+	conn, err := NewHTTPConnection(context.Background(), "test-server", srv.URL+"/mcp", nil, nil, "", 0, 0)
+	require.NoError(t, err)
+	defer conn.Close()
+
+	params := map[string]interface{}{"name": "failing_tool"}
+	resp, err := conn.SendRequestWithServerID(context.Background(), "tools/call", params, "test-server")
+	require.Error(t, err)
+	assert.Nil(t, resp)
+}
+
+// TestCallTool_UnknownToolName verifies that calling a tool name unknown to
+// the backend surfaces an error via the real SDK dispatch path (exercises the
+// non-nil-session branch differently from the "unsupported method" cases
+// covered elsewhere).
+func TestCallTool_UnknownToolName(t *testing.T) {
+	srv, _ := newCallToolTestBackend(t)
+	defer srv.Close()
+
+	conn, err := NewHTTPConnection(context.Background(), "test-server", srv.URL+"/mcp", nil, nil, "", 0, 0)
+	require.NoError(t, err)
+	defer conn.Close()
+
+	params := map[string]interface{}{"name": "does_not_exist"}
+	resp, err := conn.SendRequestWithServerID(context.Background(), "tools/call", params, "test-server")
+	require.Error(t, err)
+	assert.Nil(t, resp)
+}