graphlit-client 1.0.20260306001 → 1.0.20260307002

package/dist/streaming/ui-event-adapter.d.ts

@@ -31,6 +31,10 @@ export declare class UIEventAdapter {
     private reasoningFormat?;
     private reasoningSignature?;
     private isInReasoning;
+    private reasoningBuffer?;
+    private reasoningEmitTimer?;
+    private lastReasoningEmitTime;
+    private static readonly REASONING_THROTTLE_MS;
     private usageData?;
     private hasToolCallsInProgress;
     private hadToolCallsBeforeResume;
@@ -64,6 +68,8 @@ export declare class UIEventAdapter {
     private handleContextManagement;
     private handleReasoningStart;
     private handleReasoningDelta;
+    private scheduleReasoningEmission;
+    private emitReasoningUpdate;
     private handleReasoningEnd;
     /**
      * Build a ReasoningMetadata object from accumulated reasoning state.

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

@@ -30,6 +30,10 @@ export class UIEventAdapter {
     reasoningFormat;
     reasoningSignature;
     isInReasoning = false;
+    reasoningBuffer;
+    reasoningEmitTimer;
+    lastReasoningEmitTime = 0;
+    static REASONING_THROTTLE_MS = 250;
     usageData;
     hasToolCallsInProgress = false;
     hadToolCallsBeforeResume = false;
@@ -43,6 +47,10 @@ export class UIEventAdapter {
         this.conversationStartTime = Date.now(); // Capture when conversation began
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
+            // Reasoning always uses sentence-level chunking regardless of the
+            // developer's choice — thinking content is secondary UI and benefits
+            // from fewer, larger updates rather than token-by-token emission.
+            this.reasoningBuffer = new ChunkBuffer("sentence");
         }
     }
     /**
@@ -111,6 +119,14 @@ export class UIEventAdapter {
         this.reasoningFormat = undefined;
         this.reasoningSignature = undefined;
         this.isInReasoning = false;
+        this.lastReasoningEmitTime = 0;
+        if (this.reasoningEmitTimer) {
+            globalThis.clearTimeout(this.reasoningEmitTimer);
+            this.reasoningEmitTimer = undefined;
+        }
+        if (this.reasoningBuffer) {
+            this.reasoningBuffer.flush();
+        }
         // Reset tool call tracking flags
         this.hasToolCallsInProgress = false;
         this.hadToolCallsBeforeResume = false;
@@ -662,6 +678,15 @@ export class UIEventAdapter {
         this.isInReasoning = true;
         this.reasoningFormat = format;
         this.reasoningContent = "";
+        this.lastReasoningEmitTime = 0;
+        // Reset the reasoning buffer for a fresh thinking block
+        if (this.reasoningBuffer) {
+            this.reasoningBuffer.flush();
+        }
+        if (this.reasoningEmitTimer) {
+            globalThis.clearTimeout(this.reasoningEmitTimer);
+            this.reasoningEmitTimer = undefined;
+        }
     }
     handleReasoningDelta(content, format) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -669,13 +694,51 @@ export class UIEventAdapter {
         }
         this.reasoningContent += content;
         this.reasoningFormat = format;
-        // Emit reasoning update
-        this.emitUIEvent({
-            type: "reasoning_update",
-            content: this.reasoningContent,
-            format: format,
-            isComplete: false,
-        });
+        if (this.reasoningBuffer) {
+            // Feed through sentence-level buffer — only emit when a complete
+            // sentence is available. No partial-sentence heartbeat: reasoning
+            // is secondary UI and handleReasoningEnd flushes the remainder.
+            const sentences = this.reasoningBuffer.addToken(content);
+            if (sentences.length > 0) {
+                this.scheduleReasoningEmission();
+            }
+        }
+        else {
+            // No smoothing — emit every delta immediately (original behavior)
+            this.emitUIEvent({
+                type: "reasoning_update",
+                content: this.reasoningContent,
+                format: format,
+                isComplete: false,
+            });
+        }
+    }
+    scheduleReasoningEmission() {
+        if (this.reasoningEmitTimer)
+            return;
+        const now = Date.now();
+        const elapsed = now - this.lastReasoningEmitTime;
+        if (elapsed >= UIEventAdapter.REASONING_THROTTLE_MS) {
+            this.emitReasoningUpdate();
+        }
+        else {
+            const delay = UIEventAdapter.REASONING_THROTTLE_MS - elapsed;
+            this.reasoningEmitTimer = globalThis.setTimeout(() => {
+                this.emitReasoningUpdate();
+            }, delay);
+        }
+    }
+    emitReasoningUpdate() {
+        this.reasoningEmitTimer = undefined;
+        this.lastReasoningEmitTime = Date.now();
+        if (this.reasoningFormat) {
+            this.emitUIEvent({
+                type: "reasoning_update",
+                content: this.reasoningContent,
+                format: this.reasoningFormat,
+                isComplete: false,
+            });
+        }
     }
     handleReasoningEnd(fullContent, signature) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -684,6 +747,15 @@ export class UIEventAdapter {
                 console.log(`🤔 [UIEventAdapter] Reasoning signature: ${signature}`);
             }
         }
+        // Cancel any pending throttled emission
+        if (this.reasoningEmitTimer) {
+            globalThis.clearTimeout(this.reasoningEmitTimer);
+            this.reasoningEmitTimer = undefined;
+        }
+        // Flush the reasoning buffer — any remaining partial sentence
+        if (this.reasoningBuffer) {
+            this.reasoningBuffer.flush();
+        }
         this.isInReasoning = false;
         this.reasoningContent = fullContent;
         this.reasoningSignature = signature;
@@ -722,6 +794,10 @@ export class UIEventAdapter {
             globalThis.clearTimeout(this.updateTimer);
             this.updateTimer = undefined;
         }
+        if (this.reasoningEmitTimer) {
+            globalThis.clearTimeout(this.reasoningEmitTimer);
+            this.reasoningEmitTimer = undefined;
+        }
         this.activeToolCalls.clear();
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20260306001",
+  "version": "1.0.20260307002",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",