feat(contrib/modelcontextprotocol/go-sdk): skip intent capture for UI-only tools

Author: jboolean

contrib/modelcontextprotocol/go-sdk/intent_capture.go

@@ -56,6 +56,11 @@ func intentCaptureReceivingMiddleware(next mcp.MethodHandler) mcp.MethodHandler
 
 func injectToolsListResponse(res *mcp.ListToolsResult) {
 	for i := range res.Tools {
+		// UI-only tools cannot be invoked by the model, so injecting a
+		// required telemetry parameter would be useless noise.
+		if !instrmcp.IsModelCallable(res.Tools[i].Meta) {
+			continue
+		}
 		// Round-trip the input schema through map[string]any so unknown JSON
 		// Schema keywords (additionalProperties, oneOf, patternProperties, etc.)
 		// that *jsonschema.Schema does not model pass through verbatim.

contrib/modelcontextprotocol/go-sdk/intent_capture_test.go

@@ -67,6 +67,63 @@ func TestIntentCapturePreservesUnknownSchemaKeywords(t *testing.T) {
 	assert.NotNil(t, schema["oneOf"])
 }
 
+func TestIntentCaptureSkipsUIOnlyTools(t *testing.T) {
+	// Tools whose _meta.ui.visibility omits "model" cannot be model-invoked, so
+	// telemetry injection should be skipped for them.
+	tt := testTracer(t)
+	defer tt.Stop()
+	ctx := context.Background()
+
+	server := mcp.NewServer(&mcp.Implementation{Name: "test-server", Version: "1.0.0"}, nil)
+	AddTracing(server, WithIntentCapture())
+
+	addTool := func(name string, visibility []any) {
+		tool := &mcp.Tool{
+			Name:        name,
+			Description: name,
+			InputSchema: &jsonschema.Schema{Type: "object", Properties: map[string]*jsonschema.Schema{"q": {Type: "string"}}},
+		}
+		if visibility != nil {
+			tool.Meta = mcp.Meta{"ui": map[string]any{"visibility": visibility}}
+		}
+		server.AddTool(tool, func(_ context.Context, _ *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: "ok"}}}, nil
+		})
+	}
+	addTool("plain", nil)
+	addTool("ui_only", []any{"app"})
+	addTool("dual", []any{"model", "app"})
+
+	client := mcp.NewClient(&mcp.Implementation{Name: "test-client", Version: "1.0.0"}, nil)
+	clientTransport, serverTransport := mcp.NewInMemoryTransports()
+	serverSession, err := server.Connect(ctx, serverTransport, nil)
+	require.NoError(t, err)
+	defer serverSession.Close()
+	clientSession, err := client.Connect(ctx, clientTransport, nil)
+	require.NoError(t, err)
+	defer clientSession.Close()
+
+	listResult, err := clientSession.ListTools(ctx, &mcp.ListToolsParams{})
+	require.NoError(t, err)
+	props := func(name string) map[string]any {
+		for _, tl := range listResult.Tools {
+			if tl.Name != name {
+				continue
+			}
+			schema, ok := tl.InputSchema.(map[string]any)
+			if !ok {
+				return nil
+			}
+			p, _ := schema["properties"].(map[string]any)
+			return p
+		}
+		return nil
+	}
+	assert.Contains(t, props("plain"), "telemetry")
+	assert.NotContains(t, props("ui_only"), "telemetry", "UI-only tool should not have telemetry injected")
+	assert.Contains(t, props("dual"), "telemetry")
+}
+
 func TestIntentCapture(t *testing.T) {
 	tt := testTracer(t)
 	defer tt.Stop()

instrumentation/mcp/mcp.go

@@ -5,6 +5,8 @@
 
 package mcp
 
+import "slices"
+
 const TelemetryKey = "telemetry"
 
 const IntentKey = "intent"
@@ -17,3 +19,40 @@ const MCPMethodTag = "mcp_method"
 const MCPSessionIDTag = "mcp_session_id"
 const MCPClientNameTag = "client_name"
 const MCPClientVersionTag = "client_version"
+
+// IsModelCallable reports whether a tool's _meta permits the model to call it.
+// Absent _meta.ui.visibility means model-callable (MCP Apps spec default); a
+// visibility list that omits "model" means UI-only and the model should not
+// be asked to supply telemetry/intent for it.
+//
+// Callers pass the raw _meta map regardless of SDK wrapping: mark3labs/mcp-go
+// stores it as mcp.Meta.AdditionalFields; modelcontextprotocol/go-sdk uses
+// mcp.Meta directly (which is map[string]any).
+//
+// See https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/SEP-1865.md
+func IsModelCallable(meta map[string]any) bool {
+	if meta == nil {
+		return true
+	}
+	uiMap, ok := meta["ui"].(map[string]any)
+	if !ok {
+		return true
+	}
+	raw, ok := uiMap["visibility"]
+	if !ok {
+		return true
+	}
+	switch v := raw.(type) {
+	case []string:
+		return slices.Contains(v, "model")
+	case []any:
+		for _, item := range v {
+			if s, ok := item.(string); ok && s == "model" {
+				return true
+			}
+		}
+		return false
+	default:
+		return true
+	}
+}