fix parsing for when items: true

Author: burmudar

cmd/src/mcp_parse.go

@@ -55,9 +55,9 @@ type SchemaObject struct {
 func (s SchemaObject) Type() string { return s.Kind }
 
 type SchemaArray struct {
-	Kind        string        `json:"type"`
-	Description string        `json:"description"`
-	Items       []SchemaValue `json:"items"`
+	Kind        string      `json:"type"`
+	Description string      `json:"description"`
+	Items       SchemaValue `json:"items,omitempty"`
 }
 
 func (s SchemaArray) Type() string { return s.Kind }
@@ -101,13 +101,19 @@ func (p *Parser) parseSchema(r *RawSchema) SchemaValue {
 			Properties:           p.parseProperties(r.Properties),
 		}
 	case "array":
-		var items []SchemaValue
+		var items SchemaValue
 		if len(r.Items) > 0 {
-			var itemRaw RawSchema
-			if err := json.Unmarshal(r.Items, &itemRaw); err == nil {
-				items = append(items, p.parseSchema(&itemRaw))
+			var boolItems bool
+			if err := json.Unmarshal(r.Items, &boolItems); err == nil {
+				// Sometimes items is defined as "items: true", so we handle it here and
+				// consider it "empty" array
 			} else {
-				p.errors = append(p.errors, fmt.Errorf("failed to unmarshal array items: %w", err))
+				var itemRaw RawSchema
+				if err := json.Unmarshal(r.Items, &itemRaw); err == nil {
+					items = p.parseSchema(&itemRaw)
+				} else {
+					p.errors = append(p.errors, fmt.Errorf("failed to unmarshal array items: %w", err))
+				}
 			}
 		}
 		return &SchemaArray{

cmd/src/mcp_parse_test.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestLoadMCPToolDefinitions(t *testing.T) {
+	toolJSON := []byte(`{
+	  "tools": [
+		{
+		  "name": "test_tool",
+		  "description": "test description",
+		  "inputSchema": {
+			"type": "object",
+			"$schema": "https://localhost/schema-draft/2025-07",
+			"properties": {
+			  "tags": {
+				"type": "array",
+				"items": {
+				  "type": "object",
+				  "properties": {
+					"key": { "type": "string" },
+					"value": { "type": "string" }
+				  }
+				}
+			  }
+			}
+		  },
+		  "outputSchema": {
+			"type": "object",
+			"$schema": "https://localhost/schema-draft/2025-07",
+			"properties": {
+			  "result": { "type": "string" }
+			}
+		  }
+		}
+	  ]
+	}`)
+
+	tools, err := LoadMCPToolDefinitions(toolJSON)
+	if err != nil {
+		t.Fatalf("Failed to load tool definitions: %v", err)
+	}
+
+	if len(tools) != 1 {
+		t.Fatalf("Expected 1 tool, got %d", len(tools))
+	}
+
+	tool := tools["test_tool"]
+	if tool == nil {
+		t.Fatal("Tool 'test_tool' not found")
+	}
+
+	if tool.Name != "test_tool" {
+		t.Errorf("Expected name 'test_tool', got '%s'", tool.Name)
+	}
+
+	inputSchema := tool.InputSchema
+	outputSchema := tool.OutputSchema
+	schemaVersion := "https://localhost/schema-draft/2025-07"
+
+	if inputSchema.Schema != schemaVersion {
+		t.Errorf("Expected input schema version %q, got %q", schemaVersion, inputSchema.Schema)
+	}
+	if outputSchema.Schema != schemaVersion {
+		t.Errorf("Expected output schema version %q, got %q", schemaVersion, outputSchema.Schema)
+	}
+
+	tagsProp, ok := inputSchema.Properties["tags"]
+	if !ok {
+		t.Fatal("Property 'tags' not found in inputSchema")
+	}
+
+	if tagsProp.Type() != "array" {
+		t.Errorf("Expected tags type 'array', got '%s'", tagsProp.Type())
+	}
+
+	arraySchema, ok := tagsProp.(*SchemaArray)
+	if !ok {
+		t.Fatal("Expected SchemaArray for tags")
+	}
+
+	if arraySchema.Items == nil {
+		t.Fatal("Expected items schema in array, got nil")
+	}
+
+	itemSchema := arraySchema.Items
+	if itemSchema.Type() != "object" {
+		t.Errorf("Expected item type 'object', got '%s'", itemSchema.Type())
+	}
+
+	objectSchema, ok := itemSchema.(*SchemaObject)
+	if !ok {
+		t.Fatal("Expected SchemaObject for item")
+	}
+
+	if _, ok := objectSchema.Properties["key"]; !ok {
+		t.Error("Property 'key' not found in item schema")
+	}
+}