graphlit-client 1.0.20250610006 → 1.0.20250610008

package/dist/client.js

@@ -1713,7 +1713,79 @@ 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.trim();
+                                // 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) {
+                                    // Check if we're mid-value (ends with number or boolean)
+                                    if (fixedJson.match(/:\s*\d+$/) || fixedJson.match(/:\s*(true|false)$/)) {
+                                        // Complete the current property and close
+                                        fixedJson += ', "content": ""'; // Add empty content field
+                                    }
+                                    // Check if we're after a value but missing comma
+                                    else if (fixedJson.match(/"\s*:\s*[^,}\s]+$/)) {
+                                        // We have a complete value but no comma, add empty content
+                                        fixedJson += ', "content": ""';
+                                    }
+                                    // Add missing closing quote if the string ends with an unfinished string
+                                    else 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;
@@ -129,8 +141,14 @@ onEvent, onComplete) {
             }));
         }
         const stream = await anthropicClient.messages.create(streamConfig);
+        let activeContentBlock = false;
         for await (const chunk of stream) {
+            // Debug log all chunk types
+            if (process.env.DEBUG_STREAMING) {
+                console.log(`[Anthropic] Received chunk type: ${chunk.type}`);
+            }
             if (chunk.type === "content_block_start") {
+                activeContentBlock = true;
                 if (chunk.content_block.type === "tool_use") {
                     const toolCall = {
                         id: chunk.content_block.id,
@@ -160,6 +178,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,
@@ -169,9 +192,32 @@ onEvent, onComplete) {
                 }
             }
             else if (chunk.type === "content_block_stop") {
+                activeContentBlock = false;
                 // 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: {
@@ -182,8 +228,45 @@ onEvent, onComplete) {
                     });
                 }
             }
+            else if (chunk.type === "message_stop" && activeContentBlock) {
+                // Handle Anthropic bug: message_stop without content_block_stop
+                console.warn(`[Anthropic] Received message_stop without content_block_stop - handling as implicit block stop`);
+                activeContentBlock = false;
+                // Emit synthetic content_block_stop for the current tool
+                const currentTool = toolCalls[toolCalls.length - 1];
+                if (currentTool) {
+                    // Log the incomplete tool
+                    console.warn(`[Anthropic] Synthetic content_block_stop for incomplete tool ${currentTool.name} (${currentTool.arguments.length} chars)`);
+                    // Only emit tool_call_complete if we have valid JSON
+                    if (isValidJSON(currentTool.arguments)) {
+                        onEvent({
+                            type: "tool_call_complete",
+                            toolCall: {
+                                id: currentTool.id,
+                                name: currentTool.name,
+                                arguments: currentTool.arguments,
+                            },
+                        });
+                    }
+                    else {
+                        console.error(`[Anthropic] Tool ${currentTool.name} has incomplete JSON, skipping tool_call_complete event`);
+                    }
+                }
+            }
         }
-        onComplete(fullMessage, toolCalls);
+        // Final check: filter out any remaining incomplete tool calls
+        const validToolCalls = toolCalls.filter((tc, idx) => {
+            if (!isValidJSON(tc.arguments)) {
+                console.warn(`[Anthropic] Filtering out incomplete tool call ${idx} (${tc.name}) with INVALID JSON (${tc.arguments.length} chars)`);
+                return false;
+            }
+            return true;
+        });
+        if (toolCalls.length !== validToolCalls.length) {
+            console.log(`[Anthropic] Filtered out ${toolCalls.length - validToolCalls.length} incomplete tool calls`);
+            console.log(`[Anthropic] Successfully processed ${validToolCalls.length} valid tool calls`);
+        }
+        onComplete(fullMessage, validToolCalls);
     }
     catch (error) {
         onEvent({

package/package.json

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