graphlit-client 1.0.20250613001 → 1.0.20250613003

package/dist/client.js

@@ -1851,6 +1851,12 @@ class Graphlit {
             }
             // Execute tools and prepare for next round
             if (toolHandlers && toolCalls.length > 0) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🔧 [executeStreamingAgent] Round ${currentRound}: Processing ${toolCalls.length} tool calls`);
+                    toolCalls.forEach((tc, idx) => {
+                        console.log(`  ${idx + 1}. ${tc.name} (${tc.id}) - Args length: ${tc.arguments.length}`);
+                    });
+                }
                 // Add assistant message with tool calls to conversation
                 const assistantMessage = {
                     __typename: "ConversationMessage",
@@ -1944,17 +1950,18 @@ class Graphlit {
                                 continue;
                             }
                         }
-                        // Update UI
+                        // Update UI - emit the full tool call with arguments
                         uiAdapter.handleEvent({
-                            type: "tool_call_start",
+                            type: "tool_call_complete",
                             toolCall: {
                                 id: toolCall.id,
                                 name: toolCall.name,
+                                arguments: toolCall.arguments,
                             },
                         });
                         // Execute tool
                         const result = await handler(args);
-                        // Update UI
+                        // Update UI with result
                         uiAdapter.setToolResult(toolCall.id, result);
                         // Add tool response to messages
                         messages.push({
@@ -1983,14 +1990,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/model-mapping.js

@@ -5,13 +5,10 @@ import * as Types from "./generated/graphql-types.js";
  */
 // OpenAI model mappings
 const OPENAI_MODEL_MAP = {
-    [Types.OpenAiModels.Gpt4]: "gpt-4",
     [Types.OpenAiModels.Gpt4Turbo_128K]: "gpt-4-turbo",
     [Types.OpenAiModels.Gpt4O_128K]: "gpt-4o",
     [Types.OpenAiModels.Gpt4OMini_128K]: "gpt-4o-mini",
     [Types.OpenAiModels.Gpt4OChat_128K]: "chatgpt-4o-latest",
-    [Types.OpenAiModels.Gpt35Turbo]: "gpt-3.5-turbo",
-    [Types.OpenAiModels.Gpt35Turbo_16K]: "gpt-3.5-turbo-16k",
     [Types.OpenAiModels.Gpt41_1024K]: "gpt-4.1",
     [Types.OpenAiModels.Gpt41Mini_1024K]: "gpt-4.1-mini",
     [Types.OpenAiModels.Gpt41Nano_1024K]: "gpt-4.1-nano",
@@ -36,7 +33,6 @@ const GOOGLE_MODEL_MAP = {
     [Types.GoogleModels.Gemini_1_5Flash]: "gemini-1.5-flash",
     [Types.GoogleModels.Gemini_1_5Flash_8B]: "gemini-1.5-flash-8b",
     [Types.GoogleModels.Gemini_2_0Flash]: "gemini-2.0-flash-exp",
-    [Types.GoogleModels.Gemini_2_0FlashExperimental]: "gemini-2.0-flash-exp",
     [Types.GoogleModels.Gemini_2_5FlashPreview]: "gemini-2.5-flash-preview-05-20",
     [Types.GoogleModels.Gemini_2_5ProPreview]: "gemini-2.5-pro-preview-06-05",
 };

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);
@@ -89,11 +92,23 @@ export class UIEventAdapter {
         }
     }
     handleStart(conversationId) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [UIEventAdapter] Handle start - Conversation ID: ${conversationId}`);
+            console.log(`🚀 [UIEventAdapter] Active tool calls at start: ${this.activeToolCalls.size}`);
+        }
         this.conversationId = conversationId;
         this.isStreaming = true;
         this.streamStartTime = Date.now();
         this.firstTokenTime = 0;
         this.lastTokenTime = 0;
+        this.tokenCount = 0;
+        this.tokenDelays = [];
+        // Note: We only clear tool calls here if this is truly a new conversation start
+        // For multi-round tool calling, handleStart is only called once at the beginning
+        if (this.activeToolCalls.size > 0) {
+            console.log(`🚀 [UIEventAdapter] Warning: ${this.activeToolCalls.size} tool calls still active at start`);
+        }
+        this.activeToolCalls.clear();
         this.emitUIEvent({
             type: "conversation_started",
             conversationId,
@@ -107,7 +122,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)
@@ -125,6 +145,10 @@ export class UIEventAdapter {
         this.emitMessageUpdate(false);
     }
     handleToolCallStart(toolCall) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔧 [UIEventAdapter] Tool call start - ID: ${toolCall.id}, Name: ${toolCall.name}`);
+            console.log(`🔧 [UIEventAdapter] Active tool calls before: ${this.activeToolCalls.size}`);
+        }
         const conversationToolCall = {
             __typename: "ConversationToolCall",
             id: toolCall.id,
@@ -135,6 +159,9 @@ export class UIEventAdapter {
             toolCall: conversationToolCall,
             status: "preparing",
         });
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔧 [UIEventAdapter] Active tool calls after: ${this.activeToolCalls.size}`);
+        }
         this.emitUIEvent({
             type: "tool_update",
             toolCall: conversationToolCall,
@@ -142,20 +169,38 @@ export class UIEventAdapter {
         });
     }
     handleToolCallDelta(toolCallId, argumentDelta) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔧 [UIEventAdapter] Tool call delta - ID: ${toolCallId}, Delta length: ${argumentDelta.length}`);
+            console.log(`🔧 [UIEventAdapter] Delta content: ${argumentDelta.substring(0, 100)}...`);
+        }
         const toolData = this.activeToolCalls.get(toolCallId);
-        if (toolData && toolData.status === "preparing") {
+        if (toolData) {
             toolData.toolCall.arguments += argumentDelta;
-            toolData.status = "executing";
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔧 [UIEventAdapter] Tool ${toolCallId} accumulated args length: ${toolData.toolCall.arguments.length}`);
+            }
+            if (toolData.status === "preparing") {
+                toolData.status = "executing";
+            }
             this.emitUIEvent({
                 type: "tool_update",
                 toolCall: toolData.toolCall,
                 status: "executing",
             });
         }
+        else {
+            console.warn(`🔧 [UIEventAdapter] WARNING: Tool call delta for unknown tool ID: ${toolCallId}`);
+        }
     }
     handleToolCallComplete(toolCall) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔧 [UIEventAdapter] Tool call complete - ID: ${toolCall.id}, Name: ${toolCall.name}`);
+            console.log(`🔧 [UIEventAdapter] Final arguments length: ${toolCall.arguments.length}`);
+            console.log(`🔧 [UIEventAdapter] Final arguments: ${toolCall.arguments.substring(0, 200)}...`);
+        }
         const toolData = this.activeToolCalls.get(toolCall.id);
         if (toolData) {
+            // Update the arguments with the final complete version
             toolData.toolCall.arguments = toolCall.arguments;
             toolData.status = "completed";
             this.emitUIEvent({
@@ -164,8 +209,33 @@ export class UIEventAdapter {
                 status: "completed",
             });
         }
+        else {
+            // If we don't have this tool call tracked, create it now
+            console.warn(`🔧 [UIEventAdapter] Tool call complete for untracked tool ID: ${toolCall.id}, creating entry`);
+            const conversationToolCall = {
+                __typename: "ConversationToolCall",
+                id: toolCall.id,
+                name: toolCall.name,
+                arguments: toolCall.arguments,
+            };
+            this.activeToolCalls.set(toolCall.id, {
+                toolCall: conversationToolCall,
+                status: "completed",
+            });
+            this.emitUIEvent({
+                type: "tool_update",
+                toolCall: conversationToolCall,
+                status: "completed",
+            });
+        }
     }
-    handleComplete() {
+    handleComplete(tokens) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔚 [UIEventAdapter] Handle complete - Active tool calls: ${this.activeToolCalls.size}`);
+            this.activeToolCalls.forEach((toolData, id) => {
+                console.log(`🔚 [UIEventAdapter] Tool ${id}: ${toolData.toolCall.name}, Status: ${toolData.status}, Args length: ${toolData.toolCall.arguments.length}`);
+            });
+        }
         // Clear any pending updates
         if (this.updateTimer) {
             globalThis.clearTimeout(this.updateTimer);
@@ -200,7 +270,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 +292,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 +423,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.20250613003",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",