feat: deterministic param ordering and type validation for execute_code

Replace extractParamNames with extractParamSchema to fix non-deterministic
positional argument mapping (Go map iteration order). Parameters are now
ordered: required first (JSON array order), then non-required sorted
lexicographically.

Add type validation against JSON Schema before calling downstream tools.
Monty values are checked against the tool's declared parameter types and
a TypeError is raised on mismatch. Also use the Monty-passed context
(fnCtx) instead of the captured outer ctx for downstream CallTool calls.

Author: kurtisvg

internal/tools/execute_code.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"sort"
 
 	"skillful-mcp/internal/clientmanager"
 
@@ -74,33 +75,46 @@ func buildToolFunctions(ctx context.Context, mgr *clientmanager.Manager) (map[st
 
 	fns := make(map[string]monty.ExternalFunction, len(resolved))
 	for _, rt := range resolved {
-		rt := rt
 		session, err := mgr.GetSession(rt.SkillName)
 		if err != nil {
 			continue
 		}
-		paramNames := extractParamNames(rt.Tool.InputSchema)
+		params := extractParamSchema(rt.Tool.InputSchema)
+		paramByName := make(map[string]paramInfo, len(params))
+		for _, p := range params {
+			paramByName[p.Name] = p
+		}
 
-		fns[rt.ResolvedName] = func(_ context.Context, call monty.Call) (monty.Result, error) {
+		fns[rt.ResolvedName] = func(fnCtx context.Context, call monty.Call) (monty.Result, error) {
 			args := make(map[string]any)
 
-			// Map positional args to parameter names from the schema.
+			// Map positional args to parameter names from the schema, with type validation.
 			for i, val := range call.Args {
-				if i < len(paramNames) {
-					args[paramNames[i]] = montyValueToAny(val)
+				if i < len(params) {
+					if err := validateMontyValue(val, params[i]); err != nil {
+						msg := err.Error()
+						return monty.Raise(monty.Exception{Type: "TypeError", Arg: &msg}), nil
+					}
+					args[params[i].Name] = montyValueToAny(val)
 				}
 			}
 
-			// Keyword args override positional.
+			// Keyword args override positional, with type validation.
 			for _, pair := range call.Kwargs {
 				key, ok := pair.Key.Raw().(string)
 				if !ok {
 					continue
 				}
+				if pi, ok := paramByName[key]; ok {
+					if err := validateMontyValue(pair.Value, pi); err != nil {
+						msg := err.Error()
+						return monty.Raise(monty.Exception{Type: "TypeError", Arg: &msg}), nil
+					}
+				}
 				args[key] = montyValueToAny(pair.Value)
 			}
 
-			toolResult, err := session.CallTool(ctx, &mcp.CallToolParams{
+			toolResult, err := session.CallTool(fnCtx, &mcp.CallToolParams{
 				Name:      rt.OriginalName,
 				Arguments: args,
 			})
@@ -120,9 +134,16 @@ func buildToolFunctions(ctx context.Context, mgr *clientmanager.Manager) (map[st
 	return fns, nil
 }
 
-// extractParamNames extracts ordered property names from a JSON Schema input schema.
-// The InputSchema from the client is typically a map[string]any.
-func extractParamNames(schema any) []string {
+// paramInfo describes a single parameter extracted from a tool's JSON Schema.
+type paramInfo struct {
+	Name  string   // property name from JSON Schema
+	Types []string // allowed JSON Schema types, e.g. ["string"] or ["string", "null"]
+}
+
+// extractParamSchema extracts ordered parameter definitions from a JSON Schema.
+// Ordering: required params first (in JSON array order), then non-required sorted
+// lexicographically. This ensures deterministic positional argument mapping.
+func extractParamSchema(schema any) []paramInfo {
 	m, ok := schema.(map[string]any)
 	if !ok {
 		return nil
@@ -131,35 +152,103 @@ func extractParamNames(schema any) []string {
 	if !ok {
 		return nil
 	}
-	// Check for explicit ordering via "required" array (common convention).
+
+	requiredSet := make(map[string]bool)
+	var params []paramInfo
+
+	// Required params come first, in the order declared by the JSON array.
 	if required, ok := m["required"].([]any); ok {
-		names := make([]string, 0, len(required))
 		for _, r := range required {
-			if s, ok := r.(string); ok {
-				names = append(names, s)
+			if name, ok := r.(string); ok {
+				requiredSet[name] = true
+				params = append(params, paramInfo{
+					Name:  name,
+					Types: extractPropertyTypes(props[name]),
+				})
 			}
 		}
-		// Append non-required properties.
-		for name := range props {
-			found := false
-			for _, n := range names {
-				if n == name {
-					found = true
-					break
-				}
-			}
-			if !found {
-				names = append(names, name)
+	}
+
+	// Non-required params sorted lexicographically for deterministic ordering.
+	var optional []string
+	for name := range props {
+		if !requiredSet[name] {
+			optional = append(optional, name)
+		}
+	}
+	sort.Strings(optional)
+
+	for _, name := range optional {
+		params = append(params, paramInfo{
+			Name:  name,
+			Types: extractPropertyTypes(props[name]),
+		})
+	}
+
+	return params
+}
+
+// extractPropertyTypes extracts the "type" field from a JSON Schema property.
+// Handles both string ("type": "string") and array ("type": ["string", "null"]) forms.
+func extractPropertyTypes(propSchema any) []string {
+	pm, ok := propSchema.(map[string]any)
+	if !ok {
+		return nil
+	}
+	switch t := pm["type"].(type) {
+	case string:
+		return []string{t}
+	case []any:
+		types := make([]string, 0, len(t))
+		for _, item := range t {
+			if s, ok := item.(string); ok {
+				types = append(types, s)
 			}
 		}
-		return names
+		if len(types) == 0 {
+			return nil
+		}
+		return types
+	default:
+		return nil
 	}
-	// No required field — just return property names.
-	names := make([]string, 0, len(props))
-	for name := range props {
-		names = append(names, name)
+}
+
+// validateMontyValue checks that a Monty value matches the expected JSON Schema
+// types for a parameter. Returns nil if validation passes or types are unknown.
+func validateMontyValue(v monty.Value, param paramInfo) error {
+	if len(param.Types) == 0 {
+		return nil
+	}
+	kind := v.Kind()
+	for _, t := range param.Types {
+		if jsonSchemaTypeMatchesMonty(t, kind) {
+			return nil
+		}
+	}
+	return fmt.Errorf("parameter %q: expected %s, got %s", param.Name, param.Types[0], kind)
+}
+
+// jsonSchemaTypeMatchesMonty checks if a JSON Schema type is compatible with a Monty ValueKind.
+func jsonSchemaTypeMatchesMonty(schemaType string, kind monty.ValueKind) bool {
+	switch schemaType {
+	case "string":
+		return kind == "string"
+	case "integer":
+		return kind == "int" || kind == "big_int"
+	case "number":
+		return kind == "int" || kind == "big_int" || kind == "float"
+	case "boolean":
+		return kind == "bool"
+	case "array":
+		return kind == "list" || kind == "tuple"
+	case "object":
+		return kind == "dict"
+	case "null":
+		return kind == "none"
+	default:
+		return false
 	}
-	return names
 }
 
 // montyValueToAny converts a Monty Value to a Go value suitable for JSON tool arguments.