@compilr-dev/sdk 0.1.18 → 0.1.20

package/dist/meta-tools/registry.js

@@ -260,15 +260,17 @@ export function createMetaTools(registry) {
                     `Available tools include: ${availableTools.join(', ')}... ` +
                     `Check the Tool Index for the full list.`);
             }
-            // 2. Validate args
-            const validationError = registry.validateArgs(tool_name, args);
+            // 2. Coerce + validate args
+            const toolSchema = tool.definition.inputSchema;
+            const coercedArgs = coerceArgs(toolSchema, args);
+            const validationError = registry.validateArgs(tool_name, coercedArgs);
             if (validationError) {
                 return createErrorResult(`Invalid arguments for '${tool_name}': ${validationError}.\n` +
                     `Expected:\n${buildCompactSchema(tool)}`);
             }
             // 3. Execute the tool
             try {
-                const result = await tool.execute(args);
+                const result = await tool.execute(coercedArgs);
                 // Enhance result with clear top-level message for smaller models
                 if (result.success && typeof result.result === 'object' && result.result !== null) {
                     const innerResult = result.result;
@@ -307,15 +309,18 @@ export function createMetaTools(registry) {
                 return createErrorResult(`Tool '${name}' is not available for this agent. ` +
                     `Available tools: ${allowedTools.slice(0, 10).join(', ')}${allowedTools.length > 10 ? '...' : ''}`);
             }
+            // Coerce arguments before validation (handles LLM mistakes without guided decoding)
+            const toolSchema = tool.definition.inputSchema;
+            const coercedInput = coerceArgs(toolSchema, input);
             // Validate args
-            const validationError = registry.validateArgs(name, input);
+            const validationError = registry.validateArgs(name, coercedInput);
             if (validationError) {
                 return createErrorResult(`Invalid arguments for '${name}': ${validationError}. ` +
                     `Call get_tool_info("${name}") to get the exact parameter schema before retrying.`);
             }
             // Execute the tool
             try {
-                return await tool.execute(input);
+                return await tool.execute(coercedInput);
             }
             catch (err) {
                 const errorMessage = err instanceof Error ? err.message : String(err);
@@ -437,6 +442,26 @@ function buildCompactSchema(tool) {
                 detail += ' (required)';
             }
             paramDetails.push(detail);
+            // For array-of-objects, show item properties as indented sub-details
+            if (prop.type === 'array') {
+                const items = prop.items;
+                if (items?.type === 'object' && items.properties) {
+                    const itemProps = items.properties;
+                    const itemRequired = new Set(items.required ?? []);
+                    for (const [itemName, itemProp] of Object.entries(itemProps)) {
+                        const itemDesc = itemProp.description;
+                        const itemEnum = itemProp.enum;
+                        let itemDetail = `    - ${itemName}: ${resolveCompactType(itemProp)}`;
+                        if (itemDesc)
+                            itemDetail += ` — ${itemDesc}`;
+                        if (itemEnum)
+                            itemDetail += ` (${itemEnum.map((v) => `"${v}"`).join('|')})`;
+                        if (itemRequired.has(itemName))
+                            itemDetail += ' (required)';
+                        paramDetails.push(itemDetail);
+                    }
+                }
+            }
         }
     }
     const paramsStr = params.join(', ');
@@ -447,6 +472,45 @@ function buildCompactSchema(tool) {
     }
     return lines.join('\n');
 }
+/**
+ * Attempt to coerce arguments to match the tool schema.
+ * Handles common LLM mistakes when calling tools without guided decoding:
+ * - Single object where array expected → wraps in array
+ * - JSON string where array expected → parses it
+ */
+function coerceArgs(schema, args) {
+    const properties = schema.properties;
+    if (!properties)
+        return args;
+    let changed = false;
+    const coerced = { ...args };
+    for (const [name, prop] of Object.entries(properties)) {
+        if (prop.type === 'array' && name in coerced && !Array.isArray(coerced[name])) {
+            const value = coerced[name];
+            if (value !== null && value !== undefined) {
+                if (typeof value === 'object') {
+                    // Single object → wrap in array
+                    coerced[name] = [value];
+                    changed = true;
+                }
+                else if (typeof value === 'string') {
+                    // JSON string → try parsing
+                    try {
+                        const parsed = JSON.parse(value);
+                        if (Array.isArray(parsed)) {
+                            coerced[name] = parsed;
+                            changed = true;
+                        }
+                    }
+                    catch {
+                        // Leave as-is, will fail validation
+                    }
+                }
+            }
+        }
+    }
+    return changed ? coerced : args;
+}
 /**
  * Format AJV validation errors into a readable string.
  */

package/dist/provider.d.ts

@@ -16,6 +16,7 @@ export declare function createProviderFromType(type: ProviderType, options?: {
     apiKey?: string;
     baseUrl?: string;
     siteName?: string;
+    estimateTokens?: (text: string) => number;
 }): LLMProvider;
 /**
  * Resolve a provider from config.

package/dist/provider.js

@@ -32,29 +32,29 @@ export function detectProviderFromEnv() {
  * Create an LLM provider from a provider type string.
  */
 export function createProviderFromType(type, options) {
-    const { model, apiKey, baseUrl, siteName } = options ?? {};
+    const { model, apiKey, baseUrl, siteName, estimateTokens } = options ?? {};
     switch (type) {
         case 'claude':
-            return createClaudeProvider({ model, apiKey });
+            return createClaudeProvider({ model, apiKey, estimateTokens });
         case 'openai':
-            return createOpenAIProvider({ model, apiKey });
+            return createOpenAIProvider({ model, apiKey, estimateTokens });
         case 'gemini':
-            return createGeminiNativeProvider({ model, apiKey });
+            return createGeminiNativeProvider({ model, apiKey, estimateTokens });
         case 'ollama':
-            return createOllamaProvider({ model, baseUrl });
+            return createOllamaProvider({ model, baseUrl, estimateTokens });
         case 'together':
-            return createTogetherProvider({ model, apiKey });
+            return createTogetherProvider({ model, apiKey, estimateTokens });
         case 'groq':
-            return createGroqProvider({ model, apiKey });
+            return createGroqProvider({ model, apiKey, estimateTokens });
         case 'fireworks':
-            return createFireworksProvider({ model, apiKey });
+            return createFireworksProvider({ model, apiKey, estimateTokens });
         case 'perplexity':
-            return createPerplexityProvider({ model, apiKey });
+            return createPerplexityProvider({ model, apiKey, estimateTokens });
         case 'openrouter':
-            return createOpenRouterProvider({ model, apiKey, siteName });
+            return createOpenRouterProvider({ model, apiKey, siteName, estimateTokens });
         case 'custom':
             // Custom endpoints use OpenAI-compatible format
-            return createOpenAIProvider({ model, apiKey });
+            return createOpenAIProvider({ model, apiKey, estimateTokens });
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/sdk",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Universal agent runtime for building AI-powered applications",
   "type": "module",
   "main": "dist/index.js",