graphlit-client 1.0.20250610005 → 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/chunk-buffer.d.ts

@@ -1,25 +1,40 @@
+/**
+ * Breaks an LLM’s streaming token deltas into character, word, or sentence
+ * chunks – or lets you plug in your own chunker.
+ *
+ * Usage
+ * -----
+ *   const buf = new ChunkBuffer('sentence');
+ *   stream.on('delta', d => buf.addToken(d).forEach(pushToUI));
+ *   stream.on('end',   () => buf.flush().forEach(pushToUI));
+ */
 export type ChunkingStrategy = "character" | "word" | "sentence" | ((text: string) => {
     chunks: string[];
     remainder: string;
 });
+export interface ChunkerOpts {
+    /** Flush “words” longer than this (default = 50 chars). */
+    maxWordLen?: number;
+    /** Force a break after this many chars with no whitespace (default = 400). */
+    maxBufferNoBreak?: number;
+}
 export declare class ChunkBuffer {
-    private buffer;
-    private static readonly MAX_WORD_LEN;
-    private static readonly MAX_BUFFER_NO_BREAK;
-    private readonly graphemeSeg;
-    private readonly wordSeg;
-    private readonly sentenceSeg;
-    private readonly customChunker?;
-    private readonly strategy;
-    constructor(strategy: ChunkingStrategy);
-    /** Feed one LLM token, receive zero-or-more flushed chunks. */
+    constructor(strategy: ChunkingStrategy, opts?: ChunkerOpts);
+    /** Feed one LLM delta; receive zero‑or‑more flushed chunks. */
     addToken(token: string): string[];
-    /** Flush whatever is left in the buffer when the stream finishes. */
+    /** Call when the stream closes to emit the final remainder. */
     flush(): string[];
+    private buffer;
+    private readonly strategy;
+    private readonly customChunker?;
+    private readonly MAX_WORD_LEN;
+    private readonly MAX_BUFFER_NO_BREAK;
+    private readonly graphemeSeg?;
+    private readonly wordSeg?;
+    private readonly sentenceSeg?;
     private flushGraphemes;
     private flushWords;
     private flushSentences;
-    /** Fallback guard to break up very long runs of text with no natural breaks. */
     private flushLongRuns;
     private flushCustom;
 }

package/dist/streaming/chunk-buffer.js

@@ -1,15 +1,19 @@
+/**
+ * Breaks an LLM’s streaming token deltas into character, word, or sentence
+ * chunks – or lets you plug in your own chunker.
+ *
+ * Usage
+ * -----
+ *   const buf = new ChunkBuffer('sentence');
+ *   stream.on('delta', d => buf.addToken(d).forEach(pushToUI));
+ *   stream.on('end',   () => buf.flush().forEach(pushToUI));
+ */
+const hasSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl;
 export class ChunkBuffer {
-    buffer = "";
-    // ----- Configurable Guards -----
-    static MAX_WORD_LEN = 50; // Breaks up extremely long "words" (e.g., URLs, code).
-    static MAX_BUFFER_NO_BREAK = 400; // Hard limit for any run without a natural break.
-    // --------------------------------
-    graphemeSeg;
-    wordSeg;
-    sentenceSeg;
-    customChunker;
-    strategy;
-    constructor(strategy) {
+    // ────────────────────────────────────────────────────────────────────
+    // public API
+    // ────────────────────────────────────────────────────────────────────
+    constructor(strategy, opts = {}) {
         if (typeof strategy === "function") {
             this.customChunker = strategy;
             this.strategy = "custom";
@@ -17,143 +21,152 @@ export class ChunkBuffer {
         else {
             this.strategy = strategy;
         }
-        this.graphemeSeg = new Intl.Segmenter(undefined, {
-            granularity: "grapheme",
-        });
-        this.wordSeg = new Intl.Segmenter(undefined, { granularity: "word" });
-        this.sentenceSeg = new Intl.Segmenter(undefined, {
-            granularity: "sentence",
-        });
+        this.MAX_WORD_LEN = opts.maxWordLen ?? 50;
+        this.MAX_BUFFER_NO_BREAK = opts.maxBufferNoBreak ?? 400;
+        if (hasSegmenter) {
+            this.graphemeSeg = new Intl.Segmenter(undefined, {
+                granularity: "grapheme",
+            });
+            this.wordSeg = new Intl.Segmenter(undefined, { granularity: "word" });
+            this.sentenceSeg = new Intl.Segmenter(undefined, {
+                granularity: "sentence",
+            });
+        }
     }
-    /** Feed one LLM token, receive zero-or-more flushed chunks. */
+    /** Feed one LLM delta; receive zero‑or‑more flushed chunks. */
     addToken(token) {
         this.buffer += token;
-        if (this.customChunker) {
+        if (this.customChunker)
             return this.flushCustom();
-        }
-        // Pre-emptively flush any overly long runs of text that haven't found a natural break.
-        const longRunChunks = this.flushLongRuns();
-        let newChunks = [];
-        switch (this.strategy) {
-            case "character":
-                newChunks = this.flushGraphemes();
-                break;
-            case "word":
-                newChunks = this.flushWords();
-                break;
-            case "sentence":
-                newChunks = this.flushSentences();
-                break;
-        }
-        return [...longRunChunks, ...newChunks];
+        // emergency bailout for giant uninterrupted text
+        const forced = this.flushLongRuns();
+        const fresh = this.strategy === "character"
+            ? this.flushGraphemes()
+            : this.strategy === "word"
+                ? this.flushWords()
+                : this.flushSentences();
+        return forced.concat(fresh);
     }
-    /** Flush whatever is left in the buffer when the stream finishes. */
+    /** Call when the stream closes to emit the final remainder. */
     flush() {
-        if (!this.buffer)
+        if (!this.buffer.length)
             return [];
-        let finalChunks = [];
         if (this.customChunker) {
-            // For custom chunkers, flush everything by treating the whole buffer as input.
             const { chunks, remainder } = this.customChunker(this.buffer);
-            finalChunks.push(...chunks);
-            if (remainder) {
-                finalChunks.push(remainder);
-            }
+            this.buffer = "";
+            return [...chunks, remainder].filter(Boolean);
         }
-        else {
-            // For built-in strategies, the remaining buffer is the final chunk.
-            finalChunks.push(this.buffer);
+        // Re‑use the normal strategy until nothing more flushes.
+        const out = [];
+        while (true) {
+            const next = this.strategy === "character"
+                ? this.flushGraphemes()
+                : this.strategy === "word"
+                    ? this.flushWords()
+                    : this.flushSentences();
+            if (!next.length)
+                break;
+            out.push(...next);
         }
+        if (this.buffer)
+            out.push(this.buffer);
         this.buffer = "";
-        // Ensure no empty strings are returned.
-        return finalChunks.filter((c) => c.length > 0);
+        return out;
     }
-    // ────────────────────────────────────────────────────────────────
-    //  Internals
-    // ────────────────────────────────────────────────────────────────
+    // ────────────────────────────────────────────────────────────────────
+    // internals
+    // ────────────────────────────────────────────────────────────────────
+    buffer = "";
+    strategy;
+    customChunker;
+    MAX_WORD_LEN;
+    MAX_BUFFER_NO_BREAK;
+    // These are only defined when Intl.Segmenter exists.
+    graphemeSeg;
+    wordSeg;
+    sentenceSeg;
+    // -- character ------------------------------------------------------
     flushGraphemes() {
-        const segments = Array.from(this.graphemeSeg.segment(this.buffer)).map((s) => s.segment);
-        // If there's only one segment, it might be incomplete. Wait for more.
-        if (segments.length <= 1) {
+        if (!hasSegmenter)
+            return []; // unreachable on modern runtimes
+        const segs = Array.from(this.graphemeSeg.segment(this.buffer)).map((s) => s.segment);
+        /* Strategy: always keep exactly one segment in the buffer.
+           If we only have one segment so far, we don’t know whether it’s
+           complete (could be half a surrogate pair). Wait for more. */
+        if (segs.length <= 1)
             return [];
-        }
-        // Flush all but the last segment, which becomes the new buffer.
-        const chunksToFlush = segments.slice(0, -1);
-        this.buffer = segments[segments.length - 1];
-        return chunksToFlush;
+        const emit = segs.slice(0, -1);
+        this.buffer = segs[segs.length - 1];
+        return emit;
     }
+    // -- word -----------------------------------------------------------
     flushWords() {
+        if (!hasSegmenter)
+            return []; // unreachable on modern runtimes
         const chunks = [];
-        let currentWord = ""; // Accumulates the word part (e.g., "quick")
-        let currentNonWord = ""; // Accumulates trailing spaces/punctuation (e.g., " ")
-        // Iterate through all segments of the current buffer.
-        const segments = Array.from(this.wordSeg.segment(this.buffer));
-        // Process segments to form "word + non-word" chunks.
-        for (let i = 0; i < segments.length; i++) {
-            const part = segments[i];
-            if (part.isWordLike) {
-                // If we just finished a word and accumulated non-word characters,
-                // it means the previous "word + non-word" chunk is complete.
-                if (currentWord.length > 0 && currentNonWord.length > 0) {
-                    chunks.push(currentWord + currentNonWord);
-                    currentWord = "";
-                    currentNonWord = "";
+        let leadNonWord = "";
+        let word = "";
+        let tailNonWord = "";
+        for (const s of this.wordSeg.segment(this.buffer)) {
+            if (s.isWordLike) {
+                if (word && tailNonWord) {
+                    // previous word finished
+                    chunks.push(word + tailNonWord);
+                    word = tailNonWord = "";
+                }
+                word += s.segment;
+                if (word.length > this.MAX_WORD_LEN) {
+                    // force‑break huge “word”
+                    chunks.push(word + tailNonWord);
+                    word = tailNonWord = "";
                 }
-                currentWord += part.segment;
             }
             else {
-                // This is a non-word segment (space, punctuation).
-                currentNonWord += part.segment;
-            }
-            // Guard against extremely long words (e.g., a URL) that don't have natural breaks.
-            // This flushes the accumulated word part even if it's not followed by a non-word yet.
-            if (currentWord.length > ChunkBuffer.MAX_WORD_LEN) {
-                chunks.push(currentWord + currentNonWord);
-                currentWord = "";
-                currentNonWord = "";
+                // non‑word segment (space / punctuation)
+                if (!word) {
+                    leadNonWord += s.segment; // leading whitespace
+                }
+                else {
+                    tailNonWord += s.segment; // trailing whitespace
+                }
             }
         }
-        // After the loop, whatever remains in currentWord and currentNonWord
-        // is the incomplete part of the stream. This becomes the new buffer.
-        this.buffer = currentWord + currentNonWord;
-        // Filter out any empty strings that might result from edge cases.
-        return chunks.filter((c) => c.length > 0);
+        // flush leading non‑word if present and some word followed
+        if (leadNonWord && word) {
+            chunks.push(leadNonWord);
+            leadNonWord = "";
+        }
+        this.buffer = leadNonWord + word + tailNonWord;
+        return chunks.filter(Boolean);
     }
+    // -- sentence -------------------------------------------------------
     flushSentences() {
-        // This hybrid approach is more robust for sentence-ending punctuation.
-        // 1. Use a regex to find the last definitive sentence boundary.
-        // This is more reliable than Intl.Segmenter alone for partial streams.
-        const sentenceBoundaryRegex = /.*?[.?!](\s+|$)/g;
-        let lastMatchIndex = -1;
-        let match;
-        while ((match = sentenceBoundaryRegex.exec(this.buffer)) !== null) {
-            lastMatchIndex = match.index + match[0].length;
-        }
-        if (lastMatchIndex === -1) {
-            // No definitive sentence boundary found yet.
+        if (!hasSegmenter)
+            return []; // unreachable on modern runtimes
+        // find last confirmed boundary with regex (includes CJK punctuation)
+        const boundary = /.*?[.?!。！？](\s+|$)/g; // negative‑look‑behind ellipsis left out for perf
+        let last = -1, m;
+        while ((m = boundary.exec(this.buffer)))
+            last = boundary.lastIndex;
+        if (last === -1)
             return [];
-        }
-        // 2. The text to be flushed is everything up to that boundary.
-        const textToFlush = this.buffer.substring(0, lastMatchIndex);
-        this.buffer = this.buffer.substring(lastMatchIndex);
-        // 3. Now, use Intl.Segmenter on the confirmed text to correctly split it.
-        // This handles cases where `textToFlush` contains multiple sentences.
-        return Array.from(this.sentenceSeg.segment(textToFlush))
+        const slice = this.buffer.slice(0, last);
+        this.buffer = this.buffer.slice(last);
+        return Array.from(this.sentenceSeg.segment(slice))
             .map((s) => s.segment)
-            .filter((c) => c.length > 0);
+            .filter(Boolean);
     }
-    /** Fallback guard to break up very long runs of text with no natural breaks. */
+    // -- long‑run bailout ----------------------------------------------
     flushLongRuns() {
-        const chunks = [];
-        // If the buffer is very long and contains no spaces (e.g., a single long word/URL),
-        // force a break to prevent excessive buffering.
-        if (this.buffer.length > ChunkBuffer.MAX_BUFFER_NO_BREAK &&
+        if (this.buffer.length > this.MAX_BUFFER_NO_BREAK &&
             !/\s/.test(this.buffer)) {
-            chunks.push(this.buffer.slice(0, ChunkBuffer.MAX_BUFFER_NO_BREAK));
-            this.buffer = this.buffer.slice(ChunkBuffer.MAX_BUFFER_NO_BREAK);
+            const head = this.buffer.slice(0, this.MAX_BUFFER_NO_BREAK);
+            this.buffer = this.buffer.slice(this.MAX_BUFFER_NO_BREAK);
+            return [head];
         }
-        return chunks;
+        return [];
     }
+    // -- custom ---------------------------------------------------------
     flushCustom() {
         try {
             const { chunks, remainder } = this.customChunker(this.buffer);
@@ -161,7 +174,7 @@ export class ChunkBuffer {
             return chunks;
         }
         catch (err) {
-            console.error("Custom chunker failed. Flushing entire buffer to avoid data loss.", err);
+            console.error("Custom chunker failed – flushing whole buffer to avoid data loss", err);
             const all = this.buffer;
             this.buffer = "";
             return [all];

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
  */
@@ -17,8 +29,12 @@ onEvent, onComplete) {
             stream: true,
             temperature: specification.openAI?.temperature,
             //top_p: specification.openAI?.probability,
-            max_completion_tokens: specification.openAI?.completionTokenLimit,
         };
+        // Only add max_completion_tokens if it's defined
+        if (specification.openAI?.completionTokenLimit) {
+            streamConfig.max_completion_tokens =
+                specification.openAI.completionTokenLimit;
+        }
         // Add tools if provided
         if (tools && tools.length > 0) {
             streamConfig.tools = tools.map((tool) => ({
@@ -111,7 +127,7 @@ onEvent, onComplete) {
             stream: true,
             temperature: specification.anthropic?.temperature,
             //top_p: specification.anthropic?.probability,
-            max_tokens: specification.anthropic?.completionTokenLimit,
+            max_tokens: specification.anthropic?.completionTokenLimit || 8192, // required
         };
         if (systemPrompt) {
             streamConfig.system = systemPrompt;
@@ -156,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,
@@ -168,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: {
@@ -207,8 +250,11 @@ onEvent, onComplete) {
             stream: true,
             temperature: specification.google?.temperature,
             //top_p: specification.google?.probability,
-            max_tokens: specification.google?.completionTokenLimit,
         };
+        // Only add max_tokens if it's defined
+        if (specification.google?.completionTokenLimit) {
+            streamConfig.max_tokens = specification.google.completionTokenLimit;
+        }
         if (systemPrompt) {
             streamConfig.system = systemPrompt;
         }
@@ -235,8 +281,8 @@ onEvent, onComplete) {
         const model = googleClient.getGenerativeModel({
             model: modelName,
             generationConfig: {
-                temperature: streamConfig.temperature ?? 0.1,
-                maxOutputTokens: streamConfig.max_tokens ?? 4096,
+                temperature: streamConfig.temperature,
+                maxOutputTokens: streamConfig.max_tokens,
             },
             tools: googleTools,
         });

package/package.json

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