graphlit-client 1.0.20250704001 → 1.0.20250705001

package/dist/client.js

@@ -2294,9 +2294,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [OpenAI] Sending ${openaiMessages.length} messages to LLM: ${JSON.stringify(openaiMessages)}`);
                 }
-                await this.streamWithOpenAI(specification, openaiMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithOpenAI(specification, openaiMessages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] OpenAI native streaming completed (Round ${currentRound})`);
@@ -2311,9 +2314,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Anthropic] Sending ${anthropicMessages.length} messages to LLM (system: ${system ? "yes" : "no"}): ${JSON.stringify(anthropicMessages)}`);
                 }
-                await this.streamWithAnthropic(specification, anthropicMessages, system, tools, uiAdapter, (message, calls) => {
+                await this.streamWithAnthropic(specification, anthropicMessages, system, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Anthropic native streaming completed (Round ${currentRound})`);
@@ -2330,9 +2336,12 @@ class Graphlit {
                 }
                 // Google doesn't use system prompts separately, they're incorporated into messages
                 await this.streamWithGoogle(specification, googleMessages, undefined, // systemPrompt - Google handles this differently
-                tools, uiAdapter, (message, calls) => {
+                tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Google native streaming completed (Round ${currentRound})`);
@@ -2347,9 +2356,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Groq] Sending ${groqMessages.length} messages to LLM: ${JSON.stringify(groqMessages)}`);
                 }
-                await this.streamWithGroq(specification, groqMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithGroq(specification, groqMessages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Groq native streaming completed (Round ${currentRound})`);
@@ -2364,9 +2376,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Cerebras] Sending ${cerebrasMessages.length} messages to LLM: ${JSON.stringify(cerebrasMessages)}`);
                 }
-                await this.streamWithCerebras(specification, cerebrasMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithCerebras(specification, cerebrasMessages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Cerebras native streaming completed (Round ${currentRound})`);
@@ -2381,9 +2396,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Cohere] Sending ${messages.length} messages to LLM`);
                 }
-                await this.streamWithCohere(specification, messages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithCohere(specification, messages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Cohere native streaming completed (Round ${currentRound})`);
@@ -2411,9 +2429,12 @@ class Graphlit {
                         console.log(`🔍 [Mistral] IMPORTANT: We have tool responses, should we still pass tools?`);
                     }
                 }
-                await this.streamWithMistral(specification, mistralMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithMistral(specification, mistralMessages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Mistral native streaming completed (Round ${currentRound})`);
@@ -2428,9 +2449,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Bedrock] Sending ${bedrockMessages.length} messages to LLM (system: ${system ? "yes" : "no"}): ${JSON.stringify(bedrockMessages)}`);
                 }
-                await this.streamWithBedrock(specification, bedrockMessages, system, tools, uiAdapter, (message, calls) => {
+                await this.streamWithBedrock(specification, bedrockMessages, system, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Bedrock native streaming completed (Round ${currentRound})`);
@@ -2445,9 +2469,12 @@ class Graphlit {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                     console.log(`🔍 [Deepseek] Sending ${deepseekMessages.length} messages to LLM: ${JSON.stringify(deepseekMessages)}`);
                 }
-                await this.streamWithDeepseek(specification, deepseekMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithDeepseek(specification, deepseekMessages, tools, uiAdapter, (message, calls, usage) => {
                     roundMessage = message;
                     toolCalls = calls;
+                    if (usage) {
+                        uiAdapter.setUsageData(usage);
+                    }
                 }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Deepseek native streaming completed (Round ${currentRound})`);

package/dist/streaming/providers.d.ts

@@ -5,13 +5,13 @@ import { StreamEvent } from "../types/internal.js";
  * Stream with OpenAI SDK
  */
 export declare function streamWithOpenAI(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, openaiClient: any, // OpenAI client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Anthropic SDK
  */
 type AnthropicClient = import("@anthropic-ai/sdk").default;
 export declare function streamWithAnthropic(specification: Specification, messages: AnthropicMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, anthropicClient: AnthropicClient, // Properly typed Anthropic client
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal, thinkingConfig?: {
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal, thinkingConfig?: {
     type: "enabled";
     budget_tokens: number;
 }): Promise<void>;
@@ -19,35 +19,35 @@ onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls:
  * Stream with Google SDK
  */
 export declare function streamWithGoogle(specification: Specification, messages: GoogleMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, googleClient: any, // Google GenerativeAI client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Groq SDK (OpenAI-compatible)
  */
 export declare function streamWithGroq(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, groqClient: any, // Groq client instance (OpenAI-compatible)
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cerebras SDK (OpenAI-compatible)
  */
 export declare function streamWithCerebras(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, cerebrasClient: any, // OpenAI client instance configured for Cerebras
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Deepseek SDK (OpenAI-compatible)
  */
 export declare function streamWithDeepseek(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, deepseekClient: any, // OpenAI client instance configured for Deepseek
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cohere SDK
  */
 export declare function streamWithCohere(specification: Specification, messages: ConversationMessage[], tools: ToolDefinitionInput[] | undefined, cohereClient: any, // CohereClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Mistral SDK
  */
 export declare function streamWithMistral(specification: Specification, messages: MistralMessage[], tools: ToolDefinitionInput[] | undefined, mistralClient: any, // Mistral client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Bedrock SDK (for Claude models)
  */
 export declare function streamWithBedrock(specification: Specification, messages: BedrockMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, bedrockClient: any, // BedrockRuntimeClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 export {};

package/dist/streaming/providers.js

@@ -79,6 +79,7 @@ export async function streamWithOpenAI(specification, messages, tools, openaiCli
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Performance metrics
     const startTime = Date.now();
     let firstTokenTime = 0;
@@ -110,6 +111,7 @@ onEvent, onComplete, abortSignal) {
             model: modelName,
             messages,
             stream: true,
+            stream_options: { include_usage: true },
             temperature: specification.openAI?.temperature,
             //top_p: specification.openAI?.probability,
         };
@@ -137,6 +139,13 @@ onEvent, onComplete, abortSignal) {
         });
         for await (const chunk of stream) {
             const delta = chunk.choices[0]?.delta;
+            // Capture usage data from final chunk
+            if (chunk.usage || chunk.x_groq?.usage) {
+                usageData = chunk.usage || chunk.x_groq?.usage;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[OpenAI] Usage data captured:`, usageData);
+                }
+            }
             // Debug log chunk details
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                 console.log(`[OpenAI] Chunk:`, JSON.stringify(chunk, null, 2));
@@ -351,7 +360,8 @@ onEvent, onComplete, abortSignal) {
             }
             console.log(`✅ [OpenAI] Final message (${fullMessage.length} chars): "${fullMessage}"`);
         }
-        onComplete(fullMessage, toolCalls);
+        // Pass usage data if available
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         // Handle OpenAI-specific errors
@@ -386,6 +396,7 @@ export async function streamWithAnthropic(specification, messages, systemPrompt,
 onEvent, onComplete, abortSignal, thinkingConfig) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Performance metrics
     const startTime = Date.now();
     let firstTokenTime = 0;
@@ -477,6 +488,33 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                 console.log(`[Anthropic] Received chunk type: ${chunk.type}`);
             }
+            // Capture usage data from various message events
+            // Prioritize message_start.message usage data as it's more complete
+            if (chunk.type === "message_start" && chunk.message?.usage) {
+                usageData = chunk.message.usage;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Anthropic] Usage data captured from message_start.message:`, usageData);
+                }
+            }
+            else if (chunk.type === "message_delta" && chunk.usage && !usageData?.input_tokens) {
+                // Only use message_delta if we don't have input_tokens yet
+                usageData = chunk.usage;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Anthropic] Usage data captured from ${chunk.type}:`, usageData);
+                }
+            }
+            else if ((chunk.type === "message_delta" || chunk.type === "message_start") && chunk.usage) {
+                // Merge usage data if we have partial data
+                if (usageData) {
+                    usageData = { ...usageData, ...chunk.usage };
+                }
+                else {
+                    usageData = chunk.usage;
+                }
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Anthropic] Usage data merged from ${chunk.type}:`, usageData);
+                }
+            }
             if (chunk.type === "content_block_start") {
                 activeContentBlock = true;
                 currentContentBlockIndex = chunk.index;
@@ -799,7 +837,7 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                 console.log(`🧠 [Anthropic] Including thinking content (${completeThinkingContent.length} chars) and signature (${completeThinkingSignature.length} chars) in conversation history`);
             }
         }
-        onComplete(finalMessage, validToolCalls);
+        onComplete(finalMessage, validToolCalls, usageData);
     }
     catch (error) {
         // Handle Anthropic-specific errors
@@ -837,6 +875,7 @@ export async function streamWithGoogle(specification, messages, systemPrompt, to
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Performance metrics
     const startTime = Date.now();
     let firstTokenTime = 0;
@@ -1176,7 +1215,24 @@ onEvent, onComplete, abortSignal) {
             }
             console.log(`✅ [Google] Final message (${fullMessage.length} chars): "${fullMessage}"`);
         }
-        onComplete(fullMessage, toolCalls);
+        // Try to capture usage data from final response
+        try {
+            const response = await result.response;
+            if (response.usageMetadata) {
+                usageData = {
+                    prompt_tokens: response.usageMetadata.promptTokenCount,
+                    completion_tokens: response.usageMetadata.candidatesTokenCount,
+                    total_tokens: response.usageMetadata.totalTokenCount,
+                };
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Google] Usage data captured:`, usageData);
+                }
+            }
+        }
+        catch (e) {
+            // Ignore errors capturing usage data
+        }
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         // Don't emit error event here - let the client handle it to avoid duplicates
@@ -1317,6 +1373,7 @@ export async function streamWithDeepseek(specification, messages, tools, deepsee
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Reasoning detection state
     let reasoningLines = [];
     let currentLine = "";
@@ -1405,6 +1462,13 @@ onEvent, onComplete, abortSignal) {
             const delta = chunk.choices[0]?.delta;
             if (!delta)
                 continue;
+            // Check for usage data in the chunk (OpenAI-compatible format)
+            if (chunk.usage) {
+                usageData = chunk.usage;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Deepseek] Usage data captured:`, usageData);
+                }
+            }
             const currentTime = Date.now();
             // Track first token time
             if (firstTokenTime === 0) {
@@ -1599,7 +1663,7 @@ onEvent, onComplete, abortSignal) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`✅ [Deepseek] Stream completed: ${fullMessage.length} chars, ${validToolCalls.length} tools`);
         }
-        onComplete(fullMessage, validToolCalls);
+        onComplete(fullMessage, validToolCalls, usageData);
     }
     catch (error) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -1619,6 +1683,7 @@ export async function streamWithCohere(specification, messages, tools, cohereCli
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Performance metrics
     const startTime = Date.now();
     let firstTokenTime = 0;
@@ -1867,10 +1932,17 @@ onEvent, onComplete, abortSignal) {
                 }
             }
             else if (chunk.type === "message-end") {
-                // Handle message end event
+                // Handle message end event and capture usage data
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`[Cohere] Message end event received`, chunk);
                 }
+                // Capture usage data from message-end event
+                if (chunk.delta?.usage || chunk.usage) {
+                    usageData = chunk.delta?.usage || chunk.usage;
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`[Cohere] Usage data captured:`, usageData);
+                    }
+                }
             }
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -1881,7 +1953,7 @@ onEvent, onComplete, abortSignal) {
             type: "complete",
             tokens: tokenCount,
         });
-        onComplete(fullMessage, toolCalls);
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -1906,6 +1978,7 @@ export async function streamWithMistral(specification, messages, tools, mistralC
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Performance metrics
     const startTime = Date.now();
     let firstTokenTime = 0;
@@ -2042,6 +2115,13 @@ onEvent, onComplete, abortSignal) {
                 console.log(`[Mistral] Raw chunk:`, JSON.stringify(chunk, null, 2));
             }
             const delta = chunk.data.choices[0]?.delta;
+            // Check for usage data in the chunk
+            if (chunk.data.usage) {
+                usageData = chunk.data.usage;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Mistral] Usage data captured:`, usageData);
+                }
+            }
             if (delta?.content) {
                 fullMessage += delta.content;
                 tokenCount++;
@@ -2122,7 +2202,9 @@ onEvent, onComplete, abortSignal) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`✅ [Mistral] Complete. Chunks: ${chunkCount} | Tokens: ${tokenCount} | Message length: ${fullMessage.length} | Tool calls: ${toolCalls.length}`);
         }
-        onComplete(fullMessage, toolCalls);
+        // Check if we captured usage data during streaming
+        // Note: Mistral SDK may provide usage data differently than other providers
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -2150,6 +2232,7 @@ export async function streamWithBedrock(specification, messages, systemPrompt, t
 onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
+    let usageData = null;
     // Map contentBlockIndex to tool calls for proper correlation
     const toolCallsByIndex = new Map();
     // Performance metrics
@@ -2393,6 +2476,17 @@ onEvent, onComplete, abortSignal) {
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                         console.log(`📊 [Bedrock] Metadata:`, event.metadata);
                     }
+                    // Capture usage data from metadata
+                    if (event.metadata.usage) {
+                        usageData = {
+                            prompt_tokens: event.metadata.usage.inputTokens,
+                            completion_tokens: event.metadata.usage.outputTokens,
+                            total_tokens: event.metadata.usage.totalTokens,
+                        };
+                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                            console.log(`[Bedrock] Usage data captured:`, usageData);
+                        }
+                    }
                 }
             }
         }
@@ -2403,7 +2497,7 @@ onEvent, onComplete, abortSignal) {
             type: "complete",
             tokens: tokenCount,
         });
-        onComplete(fullMessage, toolCalls);
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {

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

@@ -30,6 +30,7 @@ export declare class UIEventAdapter {
     private reasoningFormat?;
     private reasoningSignature?;
     private isInReasoning;
+    private usageData?;
     constructor(onEvent: (event: AgentStreamEvent) => void, conversationId: string, options?: {
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;
@@ -75,4 +76,8 @@ export declare class UIEventAdapter {
      * Get the throughput in tokens per second
      */
     getThroughput(): number | undefined;
+    /**
+     * Set usage data from native provider
+     */
+    setUsageData(usage: any): void;
 }

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

@@ -29,6 +29,7 @@ export class UIEventAdapter {
     reasoningFormat;
     reasoningSignature;
     isInReasoning = false;
+    usageData;
     constructor(onEvent, conversationId, options = {}) {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
@@ -352,6 +353,17 @@ export class UIEventAdapter {
         if (this.contextWindowUsage) {
             event.contextWindow = this.contextWindowUsage;
         }
+        // Add native provider usage data if available
+        if (this.usageData) {
+            event.usage = {
+                promptTokens: this.usageData.prompt_tokens || this.usageData.promptTokens || this.usageData.input_tokens || 0,
+                completionTokens: this.usageData.completion_tokens || this.usageData.completionTokens || this.usageData.output_tokens || 0,
+                totalTokens: this.usageData.total_tokens || this.usageData.totalTokens ||
+                    ((this.usageData.input_tokens || 0) + (this.usageData.output_tokens || 0)) || 0,
+                model: this.model,
+                provider: this.modelService,
+            };
+        }
         this.emitUIEvent(event);
     }
     handleError(error) {
@@ -575,4 +587,13 @@ export class UIEventAdapter {
     getThroughput() {
         return this.finalMetrics?.streamingThroughput;
     }
+    /**
+     * Set usage data from native provider
+     */
+    setUsageData(usage) {
+        this.usageData = usage;
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`📊 [UIEventAdapter] Usage data set:`, usage);
+        }
+    }
 }

package/dist/types/internal.d.ts

@@ -46,6 +46,13 @@ export type StreamEvent = {
     messageId?: string;
     conversationId?: string;
     tokens?: number;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        model?: string;
+        provider?: string;
+    };
 } | {
     type: "error";
     error: string;

package/dist/types/token-usage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Token usage information from streaming providers
+ */
+export interface TokenUsage {
+    /** Number of tokens in the prompt/input */
+    promptTokens: number;
+    /** Number of tokens in the completion/output */
+    completionTokens: number;
+    /** Total tokens (prompt + completion) */
+    totalTokens: number;
+    /** Provider-specific model identifier */
+    model?: string;
+    /** Provider name (OpenAI, Anthropic, etc.) */
+    provider?: string;
+    /** Additional provider-specific usage data */
+    metadata?: Record<string, any>;
+}
+/**
+ * Extended token usage with timing information
+ */
+export interface ExtendedTokenUsage extends TokenUsage {
+    /** Time to generate the completion (ms) */
+    completionTime?: number;
+    /** Time to process the prompt (ms) */
+    promptTime?: number;
+    /** Queue time before processing (ms) */
+    queueTime?: number;
+    /** Tokens per second throughput */
+    tokensPerSecond?: number;
+}

package/dist/types/token-usage.js

@@ -0,0 +1 @@
+export {};

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

@@ -71,6 +71,13 @@ export type AgentStreamEvent = {
         percentage: number;
         remainingTokens: number;
     };
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        model?: string;
+        provider?: string;
+    };
 } | {
     type: "error";
     error: {

package/package.json

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