feat(contrib/mark3labs/mcp-go): skip telemetry injection for UI-only tools

Tools marked with _meta.ui.visibility excluding 'model' are invoked by the
app UI, not by the model. OpenAI's MCP client strictly validates tool
arguments against the advertised schema, so injecting telemetry as required
breaks UI-driven calls that legitimately omit it.

Respect the existing visibility annotation: if a tool's visibility list omits
'model', skip telemetry injection entirely. Tools with no _meta.ui.visibility
default to model-callable per the MCP Apps spec.

Ported from internal dd-source PR #420911.

Author: jboolean

contrib/mark3labs/mcp-go/intent_capture.go

@@ -32,6 +32,37 @@ func telemetrySchema() map[string]any {
 	}
 }
 
+// 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.
+func isModelCallable(meta *mcp.Meta) bool {
+	if meta == nil {
+		return true
+	}
+	uiMap, ok := meta.AdditionalFields["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
+	}
+}
+
 // Injects tracing parameters into the tool list response by mutating it.
 func injectTelemetryListToolsHook(ctx context.Context, id any, message *mcp.ListToolsRequest, result *mcp.ListToolsResult) {
 	if result == nil || result.Tools == nil {
@@ -44,6 +75,14 @@ func injectTelemetryListToolsHook(ctx context.Context, id any, message *mcp.List
 	for i := range result.Tools {
 		t := &result.Tools[i]
 
+		// UI-only tools (_meta.ui.visibility without "model") are invoked by the
+		// app UI, not by the model. OpenAI's MCP client strictly validates tool
+		// arguments against the advertised schema, so injecting telemetry as
+		// required would break UI calls that legitimately omit it.
+		if !isModelCallable(t.Meta) {
+			continue
+		}
+
 		if t.RawInputSchema != nil {
 			var schema mcp.ToolInputSchema
 			if err := json.Unmarshal(t.RawInputSchema, &schema); err != nil {

contrib/mark3labs/mcp-go/intent_capture_test.go

@@ -92,6 +92,68 @@ func TestIntentCapture(t *testing.T) {
 	assert.Equal(t, "test intent description", toolSpan.Meta["intent"])
 }
 
+func TestIntentCaptureSkipsUIOnlyTools(t *testing.T) {
+	tt := testTracer(t)
+	defer tt.Stop()
+
+	srv := server.NewMCPServer("test-server", "1.0.0", WithMCPServerTracing(&TracingConfig{IntentCaptureEnabled: true}))
+
+	modelTool := mcp.NewTool("model_tool",
+		mcp.WithDescription("model-callable"),
+		mcp.WithString("q", mcp.Required()))
+	srv.AddTool(modelTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return mcp.NewToolResultText("ok"), nil
+	})
+
+	uiTool := mcp.NewTool("ui_tool",
+		mcp.WithDescription("UI-only"),
+		mcp.WithString("q", mcp.Required()))
+	uiTool.Meta = &mcp.Meta{AdditionalFields: map[string]any{"ui": map[string]any{"visibility": []string{"app"}}}}
+	srv.AddTool(uiTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return mcp.NewToolResultText("ok"), nil
+	})
+
+	dualTool := mcp.NewTool("dual_tool",
+		mcp.WithDescription("Model and UI"),
+		mcp.WithString("q", mcp.Required()))
+	dualTool.Meta = &mcp.Meta{AdditionalFields: map[string]any{"ui": map[string]any{"visibility": []string{"app", "model"}}}}
+	srv.AddTool(dualTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		return mcp.NewToolResultText("ok"), nil
+	})
+
+	ctx := context.Background()
+	listResp := srv.HandleMessage(ctx, []byte(`{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}`))
+	var listResult map[string]interface{}
+	require.NoError(t, json.Unmarshal(mustMarshal(listResp), &listResult))
+
+	tools := listResult["result"].(map[string]interface{})["tools"].([]interface{})
+	require.Len(t, tools, 3)
+
+	byName := map[string]map[string]interface{}{}
+	for _, raw := range tools {
+		tool := raw.(map[string]interface{})
+		byName[tool["name"].(string)] = tool["inputSchema"].(map[string]interface{})
+	}
+
+	// Model-callable tools get telemetry injected.
+	for _, name := range []string{"model_tool", "dual_tool"} {
+		schema := byName[name]
+		require.NotNil(t, schema, name)
+		props := schema["properties"].(map[string]interface{})
+		assert.Contains(t, props, "telemetry", "%s should have telemetry", name)
+		assert.Contains(t, schema["required"].([]interface{}), "telemetry", "%s should require telemetry", name)
+	}
+
+	// UI-only tool does NOT.
+	uiSchema := byName["ui_tool"]
+	require.NotNil(t, uiSchema)
+	props := uiSchema["properties"].(map[string]interface{})
+	assert.NotContains(t, props, "telemetry")
+	if req, ok := uiSchema["required"].([]interface{}); ok {
+		assert.NotContains(t, req, "telemetry")
+	}
+}
+
 func TestIntentFromContext(t *testing.T) {
 	ctx := context.Background()