graphlit-client 1.0.20250610003 → 1.0.20250610006

package/README.md

@@ -223,8 +223,7 @@ await client.streamAgent(
   undefined, // tools
   undefined, // toolHandlers
   {
-    maxToolRounds: 10,        // Maximum tool calling rounds (default: 100)
-    showTokenStream: true,    // Show individual tokens (default: true)
+    maxToolRounds: 10,        // Maximum tool calling rounds (default: 1000)
     smoothingEnabled: true,   // Enable smooth streaming (default: true)
     chunkingStrategy: 'word', // 'character' | 'word' | 'sentence' (default: 'word')
     smoothingDelay: 30,       // Milliseconds between chunks (default: 30)

package/dist/client.js

@@ -31,6 +31,7 @@ try {
 catch (e) {
     // Google Generative AI not installed
 }
+const DEFAULT_MAX_TOOL_ROUNDS = 1000;
 // Provider categorization for streaming capabilities
 const STREAMING_PROVIDERS = {
     // Native streaming with dedicated SDKs
@@ -1448,7 +1449,7 @@ class Graphlit {
     async promptAgent(prompt, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
     correlationId) {
         const startTime = Date.now();
-        const maxRounds = options?.maxToolRounds || 10;
+        const maxRounds = options?.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS;
         const timeout = options?.timeout || 300000; // 5 minutes default
         // Create abort controller for timeout
         const abortController = new AbortController();
@@ -1534,7 +1535,7 @@ class Graphlit {
      */
     async streamAgent(prompt, onEvent, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
     correlationId) {
-        const maxRounds = options?.maxToolRounds || 100;
+        const maxRounds = options?.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS;
         const abortSignal = options?.abortSignal;
         let uiAdapter;
         // Check if already aborted
@@ -1567,7 +1568,6 @@ class Graphlit {
             }
             // Create UI event adapter
             uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
-                showTokenStream: options?.showTokenStream ?? true,
                 smoothingEnabled: options?.smoothingEnabled ?? true,
                 chunkingStrategy: options?.chunkingStrategy ?? "word",
                 smoothingDelay: options?.smoothingDelay ?? 30,

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

@@ -17,8 +17,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 +115,7 @@ onEvent, onComplete) {
             stream: true,
             temperature: specification.anthropic?.temperature,
             //top_p: specification.anthropic?.probability,
-            max_tokens: specification.anthropic?.completionTokenLimit,
+            max_tokens: specification.anthropic?.completionTokenLimit || 1024, // required
         };
         if (systemPrompt) {
             streamConfig.system = systemPrompt;
@@ -207,8 +211,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 +242,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/dist/streaming/ui-event-adapter.d.ts

@@ -14,12 +14,10 @@ export declare class UIEventAdapter {
     private activeToolCalls;
     private lastUpdateTime;
     private updateTimer?;
-    private showTokenStream;
     private chunkBuffer?;
     private smoothingDelay;
     private chunkQueue;
     constructor(onEvent: (event: AgentStreamEvent) => void, conversationId: string, options?: {
-        showTokenStream?: boolean;
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;
         smoothingDelay?: number;

package/dist/streaming/ui-event-adapter.js

@@ -13,14 +13,12 @@ export class UIEventAdapter {
     activeToolCalls = new Map();
     lastUpdateTime = 0;
     updateTimer;
-    showTokenStream;
     chunkBuffer;
     smoothingDelay = 30;
     chunkQueue = []; // Queue of chunks waiting to be emitted
     constructor(onEvent, conversationId, options = {}) {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
-        this.showTokenStream = options.showTokenStream ?? true;
         this.smoothingDelay = options.smoothingDelay ?? 30;
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
@@ -35,9 +33,7 @@ export class UIEventAdapter {
                 this.handleStart(event.conversationId);
                 break;
             case "token":
-                if (this.showTokenStream) {
-                    this.handleToken(event.token);
-                }
+                this.handleToken(event.token);
                 break;
             case "message":
                 this.handleMessage(event.message);

package/dist/types/agent.d.ts

@@ -11,9 +11,8 @@ export interface AgentResult {
 export interface StreamAgentOptions {
     maxToolRounds?: number;
     abortSignal?: AbortSignal;
-    showTokenStream?: boolean;
     smoothingEnabled?: boolean;
-    chunkingStrategy?: 'character' | 'word' | 'sentence';
+    chunkingStrategy?: "character" | "word" | "sentence";
     smoothingDelay?: number;
 }
 export interface ToolCallResult {

package/package.json

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