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

@@ -44,6 +44,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
+		}
+
 		// mcp.ToolInputSchema only models type/properties/required/$defs;
 		// for tools defined with NewToolWithRawSchema we mutate the raw
 		// JSON via a generic map so keywords like additionalProperties,

contrib/mark3labs/mcp-go/intent_capture_test.go

@@ -100,6 +100,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()
 

contrib/mark3labs/mcp-go/tool_meta.go

@@ -0,0 +1,43 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2025 Datadog, Inc.
+
+package mcpgo
+
+import (
+	"slices"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// 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
+	}
+}