go-tool-registry-schema-validation

Answer

The fix is a dedicated, extensible ToolRegistry that makes validation a single chokepoint every tool call passes through. Full code lives in internal/ai/registry.go (reconstructed and verified live at /tmp/registry-demo/internal/ai/registry.go). Three enforcement points:

1. Register — schema-shape validation + duplicate detection (fail fast, before storage)

func (r *ToolRegistry) Register(t *Tool) error {
    if t == nil { return fmt.Errorf("register: nil tool") }
    if t.Name == "" { return fmt.Errorf("register: tool name is required") }
    if _, exists := r.tools[t.Name]; exists {
        return fmt.Errorf("register: duplicate tool %q", t.Name) // dup detection first
    }
    if t.Handler == nil { return fmt.Errorf("register: tool %q has no handler", t.Name) }
    if _, err := t.schema(); err != nil {                       // Parameters() shape check
        return fmt.Errorf("register: tool %q: %w", t.Name, err)
    }
    r.tools[t.Name] = t
    return nil
}

validateSchemaShape rejects schemas that can't describe an argument object: root type != "object", missing/non-object properties, properties without a declared type, required that isn't an array, duplicates in required, or required names not declared in properties. A rejected tool is not stored.

2. Execute — gojsonschema validates raw args BEFORE the handler; handler never runs on failure

func (r *ToolRegistry) Execute(name string, rawArgs map[string]any) (any, error) {
    if errs := r.Validate(name, rawArgs); len(errs) > 0 {  // validation strictly first
        return nil, &ValidationErrors{Errs: errs}          // field-level aggregate
    }
    return r.tools[name].Handler(normalizeArgs(rawArgs))   // only reached if valid
}

Validate runs gojsonschema.Validate against the tool's schema and maps every result error to a field-level ValidationError{Field, Type, Message} — missing-required surfaces the property name as the field; wrong-type/constraint errors surface the property path (nested → address.city); unknown tools surface $tool/not_found. Nil args are normalized to {} so no-arg tools take the same path. Raw JSON tool-call payloads (jsonArgs helper) flow through identical validation.

3. MCPServer embeds *ToolRegistry — existing callers unchanged

type MCPServer struct{ *ToolRegistry }
func NewMCPServer() *MCPServer { return &MCPServer{ToolRegistry: NewToolRegistry()} }
func (s *MCPServer) CallTool(name string, raw map[string]any) (any, error) { return s.Execute(name, raw) }

Existing srv.Register(...) / srv.Execute(...) call sites work verbatim via embedding; ListTools/CallTool add the MCP transport on top with identical validation.