graphlit-client 1.0.20250613001 → 1.0.20250613002

package/dist/client.js

@@ -1983,14 +1983,21 @@ class Graphlit {
             }
             currentRound++;
         }
-        // Complete the conversation
+        // Complete the conversation and get token count
+        let finalTokens;
         if (fullMessage) {
-            await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
+            const completeResponse = await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
+            // Extract token count from the response
+            finalTokens = completeResponse.completeConversation?.message?.tokens ?? undefined;
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`📊 [completeConversation] Tokens used: ${finalTokens || 'unknown'}`);
+            }
         }
-        // Emit completion event
+        // Emit completion event with token count
         uiAdapter.handleEvent({
             type: "complete",
             conversationId,
+            tokens: finalTokens,
         });
     }
     /**

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

@@ -13,9 +13,11 @@ export declare class UIEventAdapter {
     private tokenCount;
     private currentMessage;
     private isStreaming;
+    private conversationStartTime;
     private streamStartTime;
     private firstTokenTime;
     private lastTokenTime;
+    private tokenDelays;
     private activeToolCalls;
     private lastUpdateTime;
     private updateTimer?;

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

@@ -12,9 +12,11 @@ export class UIEventAdapter {
     tokenCount = 0;
     currentMessage = "";
     isStreaming = false;
-    streamStartTime = 0;
+    conversationStartTime = 0; // When user sent the message
+    streamStartTime = 0; // When streaming actually began
     firstTokenTime = 0;
     lastTokenTime = 0;
+    tokenDelays = [];
     activeToolCalls = new Map();
     lastUpdateTime = 0;
     updateTimer;
@@ -27,6 +29,7 @@ export class UIEventAdapter {
         this.smoothingDelay = options.smoothingDelay ?? 30;
         this.model = options.model;
         this.modelService = options.modelService;
+        this.conversationStartTime = Date.now(); // Capture when conversation began
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
         }
@@ -55,7 +58,7 @@ export class UIEventAdapter {
                 this.handleToolCallComplete(event.toolCall);
                 break;
             case "complete":
-                this.handleComplete();
+                this.handleComplete(event.tokens);
                 break;
             case "error":
                 this.handleError(event.error);
@@ -94,6 +97,8 @@ export class UIEventAdapter {
         this.streamStartTime = Date.now();
         this.firstTokenTime = 0;
         this.lastTokenTime = 0;
+        this.tokenCount = 0;
+        this.tokenDelays = [];
         this.emitUIEvent({
             type: "conversation_started",
             conversationId,
@@ -107,7 +112,12 @@ export class UIEventAdapter {
         if (this.firstTokenTime === 0) {
             this.firstTokenTime = now;
         }
+        // Track inter-token delays
+        if (this.lastTokenTime > 0) {
+            this.tokenDelays.push(now - this.lastTokenTime);
+        }
         this.lastTokenTime = now;
+        this.tokenCount++;
         if (this.chunkBuffer) {
             const chunks = this.chunkBuffer.addToken(token);
             // Add chunks to queue for all chunking modes (character, word, sentence)
@@ -165,7 +175,7 @@ export class UIEventAdapter {
             });
         }
     }
-    handleComplete() {
+    handleComplete(tokens) {
         // Clear any pending updates
         if (this.updateTimer) {
             globalThis.clearTimeout(this.updateTimer);
@@ -200,7 +210,7 @@ export class UIEventAdapter {
             role: ConversationRoleTypes.Assistant,
             message: this.currentMessage,
             timestamp: new Date().toISOString(),
-            tokens: undefined, // Will be set by caller if available
+            tokens: tokens, // Now we have the actual LLM token count!
             toolCalls: Array.from(this.activeToolCalls.values()).map((t) => t.toolCall),
             model: this.model,
             modelService: this.modelService,
@@ -222,9 +232,32 @@ export class UIEventAdapter {
                 }
             }
         }
+        // Build final metrics
+        const completionTime = Date.now();
+        const finalMetrics = {
+            totalTime: this.streamStartTime > 0 ? completionTime - this.streamStartTime : 0,
+            conversationDuration: this.conversationStartTime > 0 ? completionTime - this.conversationStartTime : 0,
+        };
+        // Add TTFT if we have it
+        if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
+            finalMetrics.ttft = this.firstTokenTime - this.streamStartTime;
+        }
+        // Add token counts
+        if (this.tokenCount > 0) {
+            finalMetrics.tokenCount = this.tokenCount; // Streaming chunks
+        }
+        if (tokens) {
+            finalMetrics.llmTokens = tokens; // Actual LLM tokens used
+        }
+        // Calculate average token delay
+        if (this.tokenDelays.length > 0) {
+            const avgDelay = this.tokenDelays.reduce((a, b) => a + b, 0) / this.tokenDelays.length;
+            finalMetrics.avgTokenDelay = Math.round(avgDelay);
+        }
         this.emitUIEvent({
             type: "conversation_completed",
             message: finalMessage,
+            metrics: finalMetrics,
         });
     }
     handleError(error) {
@@ -330,10 +363,30 @@ export class UIEventAdapter {
                 message.completionTime = elapsedTime / 1000;
             }
         }
+        // Build metrics object
+        const now = Date.now();
+        const metrics = {
+            elapsedTime: this.streamStartTime > 0 ? now - this.streamStartTime : 0,
+            conversationDuration: this.conversationStartTime > 0 ? now - this.conversationStartTime : 0,
+        };
+        // Add TTFT if we have it
+        if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
+            metrics.ttft = this.firstTokenTime - this.streamStartTime;
+        }
+        // Add token count if available
+        if (this.tokenCount > 0) {
+            metrics.tokenCount = this.tokenCount;
+        }
+        // Calculate average token delay
+        if (this.tokenDelays.length > 0) {
+            const avgDelay = this.tokenDelays.reduce((a, b) => a + b, 0) / this.tokenDelays.length;
+            metrics.avgTokenDelay = Math.round(avgDelay);
+        }
         this.emitUIEvent({
             type: "message_update",
             message,
             isStreaming,
+            metrics,
         });
     }
     emitUIEvent(event) {

package/dist/types/internal.d.ts

@@ -36,6 +36,7 @@ export type StreamEvent = {
     type: "complete";
     messageId?: string;
     conversationId?: string;
+    tokens?: number;
 } | {
     type: "error";
     error: string;

package/dist/types/ui-events.d.ts

@@ -17,6 +17,13 @@ export type AgentStreamEvent = {
         message: string;
     };
     isStreaming: boolean;
+    metrics?: {
+        ttft?: number;
+        elapsedTime: number;
+        conversationDuration: number;
+        tokenCount?: number;
+        avgTokenDelay?: number;
+    };
 } | {
     type: "tool_update";
     toolCall: ConversationToolCall;
@@ -26,6 +33,14 @@ export type AgentStreamEvent = {
 } | {
     type: "conversation_completed";
     message: ConversationMessage;
+    metrics?: {
+        ttft?: number;
+        totalTime: number;
+        conversationDuration: number;
+        tokenCount?: number;
+        llmTokens?: number;
+        avgTokenDelay?: number;
+    };
 } | {
     type: "error";
     error: {

package/package.json

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