perf: optimize input validation by avoiding re-marshal step

This optimization improves the per-tool-call hot path by:

1. Adding validateSchema() that validates without re-marshaling
2. Changing the typed handler to:
   - Validate input using map (required for schema validation)
   - Unmarshal directly to struct from original JSON
   - Apply defaults to struct directly

This avoids the expensive marshal-unmarshal cycle that was previously
required to get defaults into the struct form.

Benchmarks show ~19% improvement in latency and 6% fewer allocations
for the input validation path.

Author: SamMorrowDrums

mcp/server.go

@@ -274,22 +274,32 @@ func toolForErr[In, Out any](t *Tool, h ToolHandlerFor[In, Out]) (*Tool, ToolHan
 		if req.Params.Arguments != nil {
 			input = req.Params.Arguments
 		}
-		// Validate input and apply defaults.
-		var err error
-		input, err = applySchema(input, inputResolved)
-		if err != nil {
+
+		// Validate input against schema (uses map internally for validation).
+		// This is an optimized path: we validate against the map but then
+		// unmarshal directly to struct and apply defaults to struct,
+		// avoiding an expensive re-marshal step.
+		if err := validateSchema(input, inputResolved); err != nil {
 			// TODO(#450): should this be considered a tool error? (and similar below)
 			return nil, fmt.Errorf("%w: validating \"arguments\": %v", jsonrpc2.ErrInvalidParams, err)
 		}
 
-		// Unmarshal and validate args.
+		// Unmarshal directly to typed struct.
 		var in In
 		if input != nil {
 			if err := json.Unmarshal(input, &in); err != nil {
 				return nil, fmt.Errorf("%w: %v", jsonrpc2.ErrInvalidParams, err)
 			}
 		}
 
+		// Apply defaults directly to the struct.
+		// This is more efficient than re-marshaling the map with defaults applied.
+		if inputResolved != nil {
+			if err := inputResolved.ApplyDefaults(&in); err != nil {
+				return nil, fmt.Errorf("%w: applying defaults: %v", jsonrpc2.ErrInvalidParams, err)
+			}
+		}
+
 		// Call typed handler.
 		res, out, err := h(ctx, req, in)
 		// Handle server errors appropriately:

mcp/tool.go

@@ -103,6 +103,28 @@ func applySchema(data json.RawMessage, resolved *jsonschema.Resolved) (json.RawM
 	return data, nil
 }
 
+// validateSchema validates data against the provided schema, applying defaults
+// before validation. Unlike applySchema, it does not return the modified data.
+// This is an optimization for typed handlers that can apply defaults directly
+// to structs, avoiding an expensive re-marshal step.
+func validateSchema(data json.RawMessage, resolved *jsonschema.Resolved) error {
+	if resolved == nil {
+		return nil
+	}
+	v := make(map[string]any)
+	if len(data) > 0 {
+		if err := json.Unmarshal(data, &v); err != nil {
+			return fmt.Errorf("unmarshaling arguments: %w", err)
+		}
+	}
+	// Apply defaults before validation so that default values satisfy
+	// required field constraints.
+	if err := resolved.ApplyDefaults(&v); err != nil {
+		return fmt.Errorf("applying schema defaults:\n%w", err)
+	}
+	return resolved.Validate(&v)
+}
+
 // validateToolName checks whether name is a valid tool name, reporting a
 // non-nil error if not.
 func validateToolName(name string) error {