fix: support nested arrays wrapped in objects, more elegant implementation

Author: pottekkat

examples/structured_output/main.go

@@ -35,6 +35,17 @@ type UserRequest struct {
 	UserID string `json:"userId" jsonschema_description:"User ID"`
 }
 
+type Asset struct {
+	ID       string  `json:"id" jsonschema_description:"Asset identifier"`
+	Name     string  `json:"name" jsonschema_description:"Asset name"`
+	Value    float64 `json:"value" jsonschema_description:"Current value"`
+	Currency string  `json:"currency" jsonschema_description:"Currency code"`
+}
+
+type AssetListRequest struct {
+	Limit int `json:"limit,omitempty" jsonschema_description:"Number of assets to return"`
+}
+
 func main() {
 	s := server.NewMCPServer(
 		"Structured Output Example",
@@ -59,7 +70,15 @@ func main() {
 	)
 	s.AddTool(userTool, mcp.NewStructuredToolHandler(getUserProfileHandler))
 
-	// Example 3: Manual result creation
+	// Example 3: Array output - direct array of objects
+	assetsTool := mcp.NewTool("get_assets",
+		mcp.WithDescription("Get list of assets as array"),
+		mcp.WithOutputSchema[[]Asset](),
+		mcp.WithNumber("limit", mcp.Min(1), mcp.Max(100), mcp.DefaultNumber(10)),
+	)
+	s.AddTool(assetsTool, mcp.NewStructuredToolHandler(getAssetsHandler))
+
+	// Example 4: Manual result creation
 	manualTool := mcp.NewTool("manual_structured",
 		mcp.WithDescription("Manual structured result"),
 		mcp.WithOutputSchema[WeatherResponse](),
@@ -96,6 +115,27 @@ func getUserProfileHandler(ctx context.Context, request mcp.CallToolRequest, arg
 	}, nil
 }
 
+func getAssetsHandler(ctx context.Context, request mcp.CallToolRequest, args AssetListRequest) ([]Asset, error) {
+	limit := args.Limit
+	if limit <= 0 {
+		limit = 10
+	}
+
+	assets := []Asset{
+		{ID: "btc", Name: "Bitcoin", Value: 45000.50, Currency: "USD"},
+		{ID: "eth", Name: "Ethereum", Value: 3200.75, Currency: "USD"},
+		{ID: "ada", Name: "Cardano", Value: 0.85, Currency: "USD"},
+		{ID: "sol", Name: "Solana", Value: 125.30, Currency: "USD"},
+		{ID: "dot", Name: "Pottedot", Value: 18.45, Currency: "USD"},
+	}
+
+	if limit > len(assets) {
+		limit = len(assets)
+	}
+
+	return assets[:limit], nil
+}
+
 func manualWeatherHandler(ctx context.Context, request mcp.CallToolRequest, args WeatherRequest) (*mcp.CallToolResult, error) {
 	response := WeatherResponse{
 		Location:    args.Location,

mcp/tools.go

@@ -635,18 +635,25 @@ func WithOutputSchema[T any]() ToolOption {
 		var zero T
 
 		// Generate schema using invopop/jsonschema library
-		reflector := jsonschema.Reflector{}
+		// Configure reflector to generate clean, MCP-compatible schemas
+		reflector := jsonschema.Reflector{
+			DoNotReference:            true, // Removes $defs map, outputs entire structure inline
+			Anonymous:                 true, // Hides auto-generated Schema IDs
+			AllowAdditionalProperties: true, // Removes additionalProperties: false
+		}
 		schema := reflector.Reflect(zero)
 
-		// Extract the MCP-compatible schema (inline object schema)
-		// See how jsonschema library generates the schema: https://github.com/invopop/jsonschema#example
-		mcpSchema, err := ExtractMCPSchema(schema)
+		// Clean up schema for MCP compliance
+		schema.Version = "" // Remove $schema field
+
+		// Convert to raw JSON for MCP
+		mcpSchema, err := json.Marshal(schema)
 		if err != nil {
 			// Skip and maintain backward compatibility
 			return
 		}
 
-		t.RawOutputSchema = mcpSchema
+		t.RawOutputSchema = json.RawMessage(mcpSchema)
 	}
 }
 

mcp/utils.go

@@ -3,9 +3,7 @@ package mcp
 import (
 	"encoding/json"
 	"fmt"
-	"strings"
 
-	"github.com/invopop/jsonschema"
 	"github.com/spf13/cast"
 )
 
@@ -479,60 +477,6 @@ func FormatNumberResult(value float64) *CallToolResult {
 	return NewToolResultText(fmt.Sprintf("%.2f", value))
 }
 
-// ExtractMCPSchema converts a full JSON Schema document to the inline format expected by MCP
-func ExtractMCPSchema(schema *jsonschema.Schema) (json.RawMessage, error) {
-	schemaBytes, err := json.Marshal(schema)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal schema: %w", err)
-	}
-
-	var schemaMap map[string]any
-	if err := json.Unmarshal(schemaBytes, &schemaMap); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal schema: %w", err)
-	}
-
-	// Handle $ref case - extract the referenced definition
-	if ref, hasRef := schemaMap["$ref"].(string); hasRef {
-		if defs, hasDefs := schemaMap["$defs"].(map[string]any); hasDefs {
-			// Extract the reference name
-			refParts := strings.Split(ref, "/")
-			if len(refParts) > 0 {
-				defName := refParts[len(refParts)-1]
-				if defSchema, found := defs[defName].(map[string]any); found {
-					// Clean up the definition - remove $schema, $id, etc.
-					cleanSchema := make(map[string]any)
-
-					// Copy only type, properties, and required fields
-					if schemaType, ok := defSchema["type"]; ok {
-						cleanSchema["type"] = schemaType
-					}
-					if properties, ok := defSchema["properties"]; ok {
-						cleanSchema["properties"] = properties
-					}
-					if required, ok := defSchema["required"]; ok {
-						cleanSchema["required"] = required
-					}
-
-					return json.Marshal(cleanSchema)
-				}
-			}
-		}
-	}
-
-	// If no $ref, clean up the schema directly
-	cleanSchema := make(map[string]any)
-	if schemaType, ok := schemaMap["type"]; ok {
-		cleanSchema["type"] = schemaType
-	}
-	if properties, ok := schemaMap["properties"]; ok {
-		cleanSchema["properties"] = properties
-	}
-	if required, ok := schemaMap["required"]; ok {
-		cleanSchema["required"] = required
-	}
-
-	return json.Marshal(cleanSchema)
-}
 
 func ExtractString(data map[string]any, key string) string {
 	if value, ok := data[key]; ok {