graphlit-client 1.0.20250613004 → 1.0.20250613006

package/dist/client.js

@@ -1950,7 +1950,9 @@ class Graphlit {
                                 continue;
                             }
                         }
-                        // Update UI - emit the full tool call with arguments
+                        // Execute tool
+                        const result = await handler(args);
+                        // Update UI with complete event including result
                         uiAdapter.handleEvent({
                             type: "tool_call_complete",
                             toolCall: {
@@ -1958,11 +1960,8 @@ class Graphlit {
                                 name: toolCall.name,
                                 arguments: toolCall.arguments,
                             },
+                            result: result,
                         });
-                        // Execute tool
-                        const result = await handler(args);
-                        // Update UI with result
-                        uiAdapter.setToolResult(toolCall.id, result);
                         // Add tool response to messages
                         messages.push({
                             __typename: "ConversationMessage",
@@ -1975,8 +1974,16 @@ class Graphlit {
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : "Unknown error";
                         console.error(`Tool execution error for ${toolCall.name}:`, error);
-                        // Update UI with error
-                        uiAdapter.setToolResult(toolCall.id, undefined, errorMessage);
+                        // Update UI with complete event including error
+                        uiAdapter.handleEvent({
+                            type: "tool_call_complete",
+                            toolCall: {
+                                id: toolCall.id,
+                                name: toolCall.name,
+                                arguments: toolCall.arguments,
+                            },
+                            error: errorMessage,
+                        });
                         // Add error response
                         messages.push({
                             __typename: "ConversationMessage",
@@ -1995,9 +2002,10 @@ class Graphlit {
         if (fullMessage) {
             const completeResponse = await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
             // Extract token count from the response
-            finalTokens = completeResponse.completeConversation?.message?.tokens ?? undefined;
+            finalTokens =
+                completeResponse.completeConversation?.message?.tokens ?? undefined;
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                console.log(`📊 [completeConversation] Tokens used: ${finalTokens || 'unknown'}`);
+                console.log(`📊 [completeConversation] Tokens used: ${finalTokens || "unknown"}`);
             }
         }
         // Emit completion event with token count
@@ -2049,17 +2057,41 @@ class Graphlit {
                 return;
             const handler = toolHandlers[toolCall.name];
             if (!handler) {
-                uiAdapter.setToolResult(toolCall.id, null, `No handler for tool: ${toolCall.name}`);
+                uiAdapter.handleEvent({
+                    type: "tool_call_complete",
+                    toolCall: {
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        arguments: toolCall.arguments,
+                    },
+                    error: `No handler for tool: ${toolCall.name}`,
+                });
                 return;
             }
             try {
                 const args = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
                 const result = await handler(args);
-                uiAdapter.setToolResult(toolCall.id, result);
+                uiAdapter.handleEvent({
+                    type: "tool_call_complete",
+                    toolCall: {
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        arguments: toolCall.arguments,
+                    },
+                    result: result,
+                });
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
-                uiAdapter.setToolResult(toolCall.id, null, errorMessage);
+                uiAdapter.handleEvent({
+                    type: "tool_call_complete",
+                    toolCall: {
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        arguments: toolCall.arguments,
+                    },
+                    error: errorMessage,
+                });
             }
         });
         await Promise.all(toolPromises);

package/dist/streaming/providers.js

@@ -209,7 +209,7 @@ onEvent, onComplete) {
                 console.log(toolCall.arguments);
             }
             onEvent({
-                type: "tool_call_complete",
+                type: "tool_call_parsed",
                 toolCall: {
                     id: toolCall.id,
                     name: toolCall.name,
@@ -484,7 +484,7 @@ onEvent, onComplete) {
                         }
                     }
                     onEvent({
-                        type: "tool_call_complete",
+                        type: "tool_call_parsed",
                         toolCall: {
                             id: currentTool.id,
                             name: currentTool.name,
@@ -505,7 +505,7 @@ onEvent, onComplete) {
                     // Only emit tool_call_complete if we have valid JSON
                     if (isValidJSON(currentTool.arguments)) {
                         onEvent({
-                            type: "tool_call_complete",
+                            type: "tool_call_parsed",
                             toolCall: {
                                 id: currentTool.id,
                                 name: currentTool.name,
@@ -789,7 +789,7 @@ onEvent, onComplete) {
                                 console.log(toolCall.arguments);
                             }
                             onEvent({
-                                type: "tool_call_complete",
+                                type: "tool_call_parsed",
                                 toolCall: {
                                     id: toolCall.id,
                                     name: toolCall.name,
@@ -853,7 +853,7 @@ onEvent, onComplete) {
                             },
                         });
                         onEvent({
-                            type: "tool_call_complete",
+                            type: "tool_call_parsed",
                             toolCall: {
                                 id: toolCall.id,
                                 name: toolCall.name,

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

@@ -35,15 +35,12 @@ export declare class UIEventAdapter {
      * Process a raw streaming event and emit appropriate UI events
      */
     handleEvent(event: StreamEvent): void;
-    /**
-     * Set tool execution result directly (for tool handlers)
-     */
-    setToolResult(toolCallId: string, result: unknown, error?: string): void;
     private handleStart;
     private handleToken;
     private handleMessage;
     private handleToolCallStart;
     private handleToolCallDelta;
+    private handleToolCallParsed;
     private handleToolCallComplete;
     private handleComplete;
     private handleError;

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

@@ -54,8 +54,11 @@ export class UIEventAdapter {
             case "tool_call_delta":
                 this.handleToolCallDelta(event.toolCallId, event.argumentDelta);
                 break;
+            case "tool_call_parsed":
+                this.handleToolCallParsed(event.toolCall);
+                break;
             case "tool_call_complete":
-                this.handleToolCallComplete(event.toolCall);
+                this.handleToolCallComplete(event.toolCall, event.result, event.error);
                 break;
             case "complete":
                 this.handleComplete(event.tokens);
@@ -65,32 +68,6 @@ export class UIEventAdapter {
                 break;
         }
     }
-    /**
-     * Set tool execution result directly (for tool handlers)
-     */
-    setToolResult(toolCallId, result, error) {
-        const toolData = this.activeToolCalls.get(toolCallId);
-        if (toolData) {
-            if (error) {
-                toolData.status = "failed";
-                this.emitUIEvent({
-                    type: "tool_update",
-                    toolCall: toolData.toolCall,
-                    status: "failed",
-                    error,
-                });
-            }
-            else {
-                toolData.status = "completed";
-                this.emitUIEvent({
-                    type: "tool_update",
-                    toolCall: toolData.toolCall,
-                    status: "completed",
-                    result,
-                });
-            }
-        }
-    }
     handleStart(conversationId) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [UIEventAdapter] Handle start - Conversation ID: ${conversationId}`);
@@ -192,9 +169,9 @@ export class UIEventAdapter {
             console.warn(`🔧 [UIEventAdapter] WARNING: Tool call delta for unknown tool ID: ${toolCallId}`);
         }
     }
-    handleToolCallComplete(toolCall) {
+    handleToolCallParsed(toolCall) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-            console.log(`🔧 [UIEventAdapter] Tool call complete - ID: ${toolCall.id}, Name: ${toolCall.name}`);
+            console.log(`🔧 [UIEventAdapter] Tool call parsed - 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)}...`);
         }
@@ -202,16 +179,17 @@ export class UIEventAdapter {
         if (toolData) {
             // Update the arguments with the final complete version
             toolData.toolCall.arguments = toolCall.arguments;
-            toolData.status = "completed";
+            // Mark as ready for execution, not completed
+            toolData.status = "ready";
             this.emitUIEvent({
                 type: "tool_update",
                 toolCall: toolData.toolCall,
-                status: "completed",
+                status: "ready",
             });
         }
         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`);
+            console.warn(`🔧 [UIEventAdapter] Tool call parsed for untracked tool ID: ${toolCall.id}, creating entry`);
             const conversationToolCall = {
                 __typename: "ConversationToolCall",
                 id: toolCall.id,
@@ -220,15 +198,36 @@ export class UIEventAdapter {
             };
             this.activeToolCalls.set(toolCall.id, {
                 toolCall: conversationToolCall,
-                status: "completed",
+                status: "ready",
             });
             this.emitUIEvent({
                 type: "tool_update",
                 toolCall: conversationToolCall,
-                status: "completed",
+                status: "ready",
             });
         }
     }
+    handleToolCallComplete(toolCall, result, error) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🔧 [UIEventAdapter] Tool call complete - ID: ${toolCall.id}, Name: ${toolCall.name}`);
+            console.log(`🔧 [UIEventAdapter] Has result: ${!!result}, Has error: ${!!error}`);
+        }
+        const toolData = this.activeToolCalls.get(toolCall.id);
+        if (toolData) {
+            // Update with execution result
+            toolData.status = error ? "failed" : "completed";
+            this.emitUIEvent({
+                type: "tool_update",
+                toolCall: toolData.toolCall,
+                status: toolData.status,
+                result: result,
+                error: error,
+            });
+        }
+        else {
+            console.warn(`🔧 [UIEventAdapter] Tool call complete for unknown tool ID: ${toolCall.id}`);
+        }
+    }
     handleComplete(tokens) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🔚 [UIEventAdapter] Handle complete - Active tool calls: ${this.activeToolCalls.size}`);
@@ -244,7 +243,7 @@ export class UIEventAdapter {
         // Process any remaining chunks before completing
         if (this.chunkQueue.length > 0) {
             // Add all remaining chunks to current message
-            const remainingChunks = this.chunkQueue.join('');
+            const remainingChunks = this.chunkQueue.join("");
             const chunkCount = this.chunkQueue.length;
             this.currentMessage += remainingChunks;
             this.chunkQueue.length = 0; // Clear the queue after processing
@@ -256,7 +255,7 @@ export class UIEventAdapter {
         if (this.chunkBuffer) {
             const finalChunks = this.chunkBuffer.flush();
             if (finalChunks.length > 0) {
-                const finalContent = finalChunks.join('');
+                const finalContent = finalChunks.join("");
                 this.currentMessage += finalContent;
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`🔚 [UIEventAdapter] Flushed buffer with ${finalChunks.length} chunks: "${finalContent}"`);
@@ -278,10 +277,11 @@ export class UIEventAdapter {
         // Add final timing metadata
         if (this.streamStartTime > 0) {
             const totalTime = Date.now() - this.streamStartTime;
-            // Final throughput (chars/second)
-            finalMessage.throughput = totalTime > 0
-                ? Math.round((this.currentMessage.length / totalTime) * 1000)
-                : 0;
+            // Final throughput (chars/second) - includes entire duration
+            finalMessage.throughput =
+                totalTime > 0
+                    ? Math.round((this.currentMessage.length / totalTime) * 1000)
+                    : 0;
             // Total completion time in seconds
             finalMessage.completionTime = totalTime / 1000;
             // Add time to first token if we have it (useful metric)
@@ -296,7 +296,9 @@ export class UIEventAdapter {
         const completionTime = Date.now();
         const finalMetrics = {
             totalTime: this.streamStartTime > 0 ? completionTime - this.streamStartTime : 0,
-            conversationDuration: this.conversationStartTime > 0 ? completionTime - this.conversationStartTime : 0,
+            conversationDuration: this.conversationStartTime > 0
+                ? completionTime - this.conversationStartTime
+                : 0,
         };
         // Add TTFT if we have it
         if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
@@ -314,6 +316,13 @@ export class UIEventAdapter {
             const avgDelay = this.tokenDelays.reduce((a, b) => a + b, 0) / this.tokenDelays.length;
             finalMetrics.avgTokenDelay = Math.round(avgDelay);
         }
+        // Calculate streaming throughput (excludes TTFT)
+        if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
+            const streamingTime = completionTime - this.firstTokenTime;
+            if (streamingTime > 0) {
+                finalMetrics.streamingThroughput = Math.round((this.currentMessage.length / streamingTime) * 1000);
+            }
+        }
         this.emitUIEvent({
             type: "conversation_completed",
             message: finalMessage,

package/dist/types/internal.d.ts

@@ -25,6 +25,13 @@ export type StreamEvent = {
     type: "tool_call_delta";
     toolCallId: string;
     argumentDelta: string;
+} | {
+    type: "tool_call_parsed";
+    toolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+    };
 } | {
     type: "tool_call_complete";
     toolCall: {
@@ -32,6 +39,8 @@ export type StreamEvent = {
         name: string;
         arguments: string;
     };
+    result?: unknown;
+    error?: string;
 } | {
     type: "complete";
     messageId?: string;

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

@@ -2,7 +2,7 @@ import { ConversationMessage, ConversationToolCall } from "../generated/graphql-
 /**
  * Tool execution status for streaming
  */
-export type ToolExecutionStatus = "preparing" | "executing" | "completed" | "failed";
+export type ToolExecutionStatus = "preparing" | "executing" | "ready" | "completed" | "failed";
 /**
  * Simplified UI-focused streaming events using GraphQL types
  */

package/package.json

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