platform

mcp/tool.go

@@ -0,0 +1,51 @@
+package mcp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Tool is one MCP tool: its advertised schema plus the Invoke func that parses
+// arguments, does the work, and returns a JSON-encodable payload. Invoke's error
+// is surfaced to the client as a tool error (isError: true), not a protocol
+// error. The context carries request scope (deadline, cancellation, trace span);
+// it flows from the HTTP request through to Invoke.
+type Tool struct {
+	Name        string                                                       `json:"name"`
+	Description string                                                       `json:"description"`
+	InputSchema json.RawMessage                                              `json:"inputSchema"`
+	Invoke      func(ctx context.Context, args json.RawMessage) (any, error) `json:"-"`
+}
+
+// Text wraps a payload as a successful tools/call result: one JSON text block.
+func Text(v any) any {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return ErrorResult(err)
+	}
+	return map[string]any{
+		"content": []map[string]any{{"type": "text", "text": string(b)}},
+	}
+}
+
+// ErrorResult wraps an operational error as an isError tools/call result (a tool
+// failure the model can read, not a JSON-RPC protocol error).
+func ErrorResult(err error) any {
+	return map[string]any{
+		"isError": true,
+		"content": []map[string]any{{"type": "text", "text": err.Error()}},
+	}
+}
+
+// Decode unmarshals tool arguments into v, treating empty/null args as a no-op
+// (zero value). Returns a wrapped error suitable for returning from Invoke.
+func Decode(args json.RawMessage, v any) error {
+	if len(args) == 0 || string(args) == "null" {
+		return nil
+	}
+	if err := json.Unmarshal(args, v); err != nil {
+		return fmt.Errorf("invalid arguments: %w", err)
+	}
+	return nil
+}