graphlit-client 1.0.20250610006 → 1.0.20250610007

package/dist/client.js

@@ -1713,7 +1713,69 @@ class Graphlit {
                         continue;
                     }
                     try {
-                        const args = JSON.parse(toolCall.arguments);
+                        let args;
+                        try {
+                            args = JSON.parse(toolCall.arguments);
+                        }
+                        catch (parseError) {
+                            console.error(`Failed to parse tool arguments for ${toolCall.name}:`);
+                            console.error(`Arguments (${toolCall.arguments.length} chars):`, toolCall.arguments);
+                            console.error(`Parse error:`, parseError);
+                            // Check for common truncation patterns
+                            const lastChars = toolCall.arguments.slice(-20);
+                            let isTruncated = false;
+                            if (!toolCall.arguments.includes('}') || !lastChars.includes('}')) {
+                                console.error(`Possible truncation detected - arguments don't end with '}': ...${lastChars}`);
+                                isTruncated = true;
+                            }
+                            // Try to fix truncated JSON by adding missing closing braces
+                            if (isTruncated) {
+                                let fixedJson = toolCall.arguments;
+                                // Count open braces vs close braces to determine how many we need
+                                const openBraces = (fixedJson.match(/\{/g) || []).length;
+                                const closeBraces = (fixedJson.match(/\}/g) || []).length;
+                                const missingBraces = openBraces - closeBraces;
+                                if (missingBraces > 0) {
+                                    // Add missing closing quote if the string ends with an unfinished string
+                                    if (fixedJson.endsWith('"') === false && fixedJson.includes('"')) {
+                                        const lastQuoteIndex = fixedJson.lastIndexOf('"');
+                                        const afterLastQuote = fixedJson.slice(lastQuoteIndex + 1);
+                                        if (!afterLastQuote.includes('"')) {
+                                            fixedJson += '"';
+                                        }
+                                    }
+                                    // Add missing closing braces
+                                    fixedJson += '}'.repeat(missingBraces);
+                                    console.log(`Attempting to fix truncated JSON by adding ${missingBraces} closing brace(s):`);
+                                    console.log(fixedJson);
+                                    try {
+                                        args = JSON.parse(fixedJson);
+                                        console.log(`✅ Successfully fixed truncated JSON for ${toolCall.name}`);
+                                    }
+                                    catch (fixError) {
+                                        console.error(`❌ Failed to fix truncated JSON: ${fixError}`);
+                                        // Fall through to error handling below
+                                    }
+                                }
+                            }
+                            // If we couldn't parse or fix the JSON, log details and continue
+                            if (!args) {
+                                // Log position mentioned in error if available
+                                const errorMsg = parseError instanceof Error ? parseError.message : '';
+                                const posMatch = errorMsg.match(/position (\d+)/);
+                                if (posMatch) {
+                                    const pos = parseInt(posMatch[1]);
+                                    const context = toolCall.arguments.slice(Math.max(0, pos - 20), pos + 20);
+                                    console.error(`Error context around position ${pos}: ...${context}...`);
+                                }
+                                // Update UI with error - use StreamEvent error type
+                                uiAdapter.handleEvent({
+                                    type: "error",
+                                    error: `Tool ${toolCall.name} failed: Invalid JSON arguments: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`,
+                                });
+                                continue;
+                            }
+                        }
                         // Update UI
                         uiAdapter.handleEvent({
                             type: "tool_call_start",

package/dist/streaming/providers.js

@@ -1,4 +1,16 @@
 import { getModelName } from "../model-mapping.js";
+/**
+ * Helper to check if a string is valid JSON
+ */
+function isValidJSON(str) {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Stream with OpenAI SDK
  */
@@ -115,7 +127,7 @@ onEvent, onComplete) {
             stream: true,
             temperature: specification.anthropic?.temperature,
             //top_p: specification.anthropic?.probability,
-            max_tokens: specification.anthropic?.completionTokenLimit || 1024, // required
+            max_tokens: specification.anthropic?.completionTokenLimit || 8192, // required
         };
         if (systemPrompt) {
             streamConfig.system = systemPrompt;
@@ -160,6 +172,11 @@ onEvent, onComplete) {
                     const currentTool = toolCalls[toolCalls.length - 1];
                     if (currentTool) {
                         currentTool.arguments += chunk.delta.partial_json;
+                        // Debug logging for partial JSON accumulation
+                        if (process.env.DEBUG_STREAMING) {
+                            console.log(`[Anthropic] Tool ${currentTool.name} - Partial JSON chunk: "${chunk.delta.partial_json}"`);
+                            console.log(`[Anthropic] Tool ${currentTool.name} - Total accumulated: ${currentTool.arguments.length} chars`);
+                        }
                         onEvent({
                             type: "tool_call_delta",
                             toolCallId: currentTool.id,
@@ -172,6 +189,28 @@ onEvent, onComplete) {
                 // Tool call complete
                 const currentTool = toolCalls[toolCalls.length - 1];
                 if (currentTool) {
+                    // Log the final JSON for debugging
+                    if (process.env.DEBUG_STREAMING ||
+                        !isValidJSON(currentTool.arguments)) {
+                        console.log(`[Anthropic] Tool ${currentTool.name} complete with arguments (${currentTool.arguments.length} chars):`);
+                        console.log(currentTool.arguments);
+                        // Check if JSON appears truncated
+                        const lastChars = currentTool.arguments.slice(-10);
+                        if (!lastChars.includes("}") &&
+                            currentTool.arguments.length > 100) {
+                            console.warn(`[Anthropic] WARNING: JSON may be truncated - doesn't end with '}': ...${lastChars}`);
+                        }
+                        // Validate JSON
+                        try {
+                            JSON.parse(currentTool.arguments);
+                            if (process.env.DEBUG_STREAMING) {
+                                console.log(`[Anthropic] ✅ Valid JSON for ${currentTool.name}`);
+                            }
+                        }
+                        catch (e) {
+                            console.error(`[Anthropic] ❌ Invalid JSON for ${currentTool.name}: ${e}`);
+                        }
+                    }
                     onEvent({
                         type: "tool_call_complete",
                         toolCall: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250610006",
+  "version": "1.0.20250610007",
   "description": "Graphlit API Client for TypeScript",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",