graphlit-client 1.0.20250704001 → 1.0.20250710001

package/dist/client.d.ts

@@ -48,6 +48,7 @@ declare class Graphlit {
     private mistralClient?;
     private bedrockClient?;
     private deepseekClient?;
+    private xaiClient?;
     constructor(organizationIdOrOptions?: string | GraphlitClientOptions, environmentId?: string, jwtSecret?: string, ownerId?: string, userId?: string, apiUri?: string);
     refreshClient(): void;
     /**
@@ -95,6 +96,11 @@ declare class Graphlit {
      * @param client - OpenAI client instance configured for Deepseek (e.g., new OpenAI({ baseURL: "https://api.deepseek.com", apiKey: "..." }))
      */
     setDeepseekClient(client: any): void;
+    /**
+     * Set a custom xAI client instance for streaming
+     * @param client - OpenAI client instance configured for xAI (e.g., new OpenAI({ baseURL: "https://api.x.ai/v1", apiKey: "..." }))
+     */
+    setXaiClient(client: any): void;
     /**
      * Update retry configuration and refresh the Apollo client
      * @param retryConfig - New retry configuration
@@ -505,6 +511,7 @@ declare class Graphlit {
      * Stream with Deepseek client
      */
     private streamWithDeepseek;
+    private streamWithXai;
     private executeToolsForPromptAgent;
     private prettyPrintGraphQLError;
     private mutateAndCheckError;

package/dist/client.js

@@ -9,7 +9,7 @@ import * as dotenv from "dotenv";
 import { getServiceType, getModelName } from "./model-mapping.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
-import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, streamWithGroq, streamWithCerebras, streamWithCohere, streamWithMistral, streamWithBedrock, streamWithDeepseek, } from "./streaming/providers.js";
+import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, streamWithGroq, streamWithCerebras, streamWithCohere, streamWithMistral, streamWithBedrock, streamWithDeepseek, streamWithXai, } from "./streaming/providers.js";
 // Optional imports for streaming LLM clients
 // These are peer dependencies and may not be installed
 // We need to use createRequire for optional dependencies to avoid build errors
@@ -132,6 +132,7 @@ class Graphlit {
     mistralClient;
     bedrockClient;
     deepseekClient;
+    xaiClient;
     constructor(organizationIdOrOptions, environmentId, jwtSecret, ownerId, userId, apiUri) {
         // Handle both old constructor signature and new options object
         let options;
@@ -331,6 +332,13 @@ class Graphlit {
     setDeepseekClient(client) {
         this.deepseekClient = client;
     }
+    /**
+     * Set a custom xAI client instance for streaming
+     * @param client - OpenAI client instance configured for xAI (e.g., new OpenAI({ baseURL: "https://api.x.ai/v1", apiKey: "..." }))
+     */
+    setXaiClient(client) {
+        this.xaiClient = client;
+    }
     /**
      * Update retry configuration and refresh the Apollo client
      * @param retryConfig - New retry configuration
@@ -1823,6 +1831,8 @@ class Graphlit {
                     return hasBedrockClient;
                 case Types.ModelServiceTypes.Deepseek:
                     return OpenAI !== undefined || this.deepseekClient !== undefined;
+                case Types.ModelServiceTypes.Xai:
+                    return OpenAI !== undefined || this.xaiClient !== undefined;
                 default:
                     return false;
             }
@@ -1839,6 +1849,8 @@ class Graphlit {
             this.cohereClient !== undefined;
         const hasMistral = Mistral !== undefined || this.mistralClient !== undefined;
         const hasBedrock = BedrockRuntimeClient !== undefined || this.bedrockClient !== undefined;
+        const hasDeepseek = OpenAI !== undefined || this.deepseekClient !== undefined;
+        const hasXai = OpenAI !== undefined || this.xaiClient !== undefined;
         return (hasOpenAI ||
             hasAnthropic ||
             hasGoogle ||
@@ -1846,7 +1858,9 @@ class Graphlit {
             hasCerebras ||
             hasCohere ||
             hasMistral ||
-            hasBedrock);
+            hasBedrock ||
+            hasDeepseek ||
+            hasXai);
     }
     /**
      * Execute an agent with non-streaming response
@@ -2294,9 +2308,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 +2328,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 +2350,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 +2370,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 +2390,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 +2410,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 +2443,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 +2463,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,14 +2483,37 @@ 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})`);
                 }
             }
+            else if (serviceType === Types.ModelServiceTypes.Xai &&
+                (OpenAI || this.xaiClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using xAI native streaming (Round ${currentRound})`);
+                }
+                const xaiMessages = formatMessagesForOpenAI(messages); // xAI uses OpenAI format
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [xAI] Sending ${xaiMessages.length} messages to LLM: ${JSON.stringify(xaiMessages)}`);
+                }
+                await this.streamWithXai(specification, xaiMessages, 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] xAI native streaming completed (Round ${currentRound})`);
+                }
+            }
             else {
                 // Fallback to non-streaming
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -2994,6 +3055,27 @@ class Graphlit {
         }
         await streamWithDeepseek(specification, messages, tools, deepseekClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
+    async streamWithXai(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
+        // Check if we have either the OpenAI module or a provided xAI client
+        if (!OpenAI && !this.xaiClient) {
+            throw new Error("xAI client not available (requires OpenAI SDK)");
+        }
+        // Use provided client or create a new one with xAI base URL
+        const xaiClient = this.xaiClient ||
+            (OpenAI
+                ? new OpenAI({
+                    baseURL: "https://api.x.ai/v1",
+                    apiKey: process.env.XAI_API_KEY || "",
+                })
+                : null);
+        if (!xaiClient) {
+            throw new Error("Failed to create xAI client");
+        }
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to xAI streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithXai(specification, messages, tools, xaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
+    }
     // Helper method to execute tools for promptAgent
     async executeToolsForPromptAgent(toolCalls, toolHandlers, allToolCalls, signal) {
         const responses = [];

package/dist/generated/graphql-documents.js

@@ -9223,6 +9223,16 @@ export const GetSpecification = gql `
       temperature
       probability
     }
+    xai {
+      tokenLimit
+      completionTokenLimit
+      model
+      key
+      modelName
+      endpoint
+      temperature
+      probability
+    }
     groq {
       tokenLimit
       completionTokenLimit
@@ -9583,6 +9593,16 @@ export const QuerySpecifications = gql `
         temperature
         probability
       }
+      xai {
+        tokenLimit
+        completionTokenLimit
+        model
+        key
+        modelName
+        endpoint
+        temperature
+        probability
+      }
       groq {
         tokenLimit
         completionTokenLimit

package/dist/generated/graphql-types.d.ts

@@ -399,13 +399,13 @@ export declare enum AnthropicModels {
     Claude_3Haiku = "CLAUDE_3_HAIKU",
     /** Claude 3 Haiku (03-07-2024 version) */
     Claude_3Haiku_20240307 = "CLAUDE_3_HAIKU_20240307",
-    /** Claude 3 Opus (Latest) */
+    /** @deprecated Use Claude 4 Opus instead. */
     Claude_3Opus = "CLAUDE_3_OPUS",
     /** Claude 3 Opus (02-29-2024 version) */
     Claude_3Opus_20240229 = "CLAUDE_3_OPUS_20240229",
-    /** Claude 3 Sonnet (Latest) */
+    /** @deprecated Use Claude 4 Sonnet instead. */
     Claude_3Sonnet = "CLAUDE_3_SONNET",
-    /** Claude 3 Sonnet (02-29-2024 version) */
+    /** @deprecated Use Claude 4 Sonnet instead. */
     Claude_3Sonnet_20240229 = "CLAUDE_3_SONNET_20240229",
     /** Claude 4 Opus (Latest) */
     Claude_4Opus = "CLAUDE_4_OPUS",
@@ -8460,7 +8460,9 @@ export declare enum ModelServiceTypes {
     /** Replicate */
     Replicate = "REPLICATE",
     /** Voyage */
-    Voyage = "VOYAGE"
+    Voyage = "VOYAGE",
+    /** xAI */
+    Xai = "XAI"
 }
 /** Represents an LLM text entity extraction connector. */
 export type ModelTextExtractionProperties = {
@@ -13803,6 +13805,8 @@ export type Specification = {
     type?: Maybe<SpecificationTypes>;
     /** The Voyage model properties. */
     voyage?: Maybe<VoyageModelProperties>;
+    /** The xAI model properties. */
+    xai?: Maybe<XaiModelProperties>;
 };
 /** Represents a filter for LLM specifications. */
 export type SpecificationFilter = {
@@ -13889,6 +13893,8 @@ export type SpecificationInput = {
     type?: InputMaybe<SpecificationTypes>;
     /** The Voyage model properties. */
     voyage?: InputMaybe<VoyageModelPropertiesInput>;
+    /** The XAI model properties. */
+    xai?: InputMaybe<XaiModelPropertiesInput>;
 };
 /** Represents LLM specification query results. */
 export type SpecificationResults = {
@@ -13973,6 +13979,8 @@ export type SpecificationUpdateInput = {
     type?: InputMaybe<SpecificationTypes>;
     /** The Voyage model properties. */
     voyage?: InputMaybe<VoyageModelPropertiesUpdateInput>;
+    /** The XAI model properties. */
+    xai?: InputMaybe<XaiModelPropertiesUpdateInput>;
 };
 /** Represents the storage policy. */
 export type StoragePolicy = {
@@ -14894,6 +14902,75 @@ export type WorkflowUpdateInput = {
     /** The storage stage of the content workflow. */
     storage?: InputMaybe<StorageWorkflowStageInput>;
 };
+/** Represents xAI model properties. */
+export type XaiModelProperties = {
+    __typename?: 'XAIModelProperties';
+    /** The limit of tokens generated by prompt completion. */
+    completionTokenLimit?: Maybe<Scalars['Int']['output']>;
+    /** The xAI API endpoint, if using developer's own account. */
+    endpoint?: Maybe<Scalars['URL']['output']>;
+    /** The xAI API key, if using developer's own account. */
+    key?: Maybe<Scalars['String']['output']>;
+    /** The xAI model, or custom, when using developer's own account. */
+    model: XaiModels;
+    /** The xAI model name, if using developer's own account. */
+    modelName?: Maybe<Scalars['String']['output']>;
+    /** The model token probability. */
+    probability?: Maybe<Scalars['Float']['output']>;
+    /** The model temperature. */
+    temperature?: Maybe<Scalars['Float']['output']>;
+    /** The number of tokens which can provided to the xAI model, if using developer's own account. */
+    tokenLimit?: Maybe<Scalars['Int']['output']>;
+};
+/** Represents xAI model properties. */
+export type XaiModelPropertiesInput = {
+    /** The limit of tokens generated by prompt completion. */
+    completionTokenLimit?: InputMaybe<Scalars['Int']['input']>;
+    /** The xAI API endpoint, if using developer's own account. */
+    endpoint?: InputMaybe<Scalars['URL']['input']>;
+    /** The xAI API key, if using developer's own account. */
+    key?: InputMaybe<Scalars['String']['input']>;
+    /** The xAI model, or custom, when using developer's own account. */
+    model: XaiModels;
+    /** The xAI model name, if using developer's own account. */
+    modelName?: InputMaybe<Scalars['String']['input']>;
+    /** The model token probability. */
+    probability?: InputMaybe<Scalars['Float']['input']>;
+    /** The model temperature. */
+    temperature?: InputMaybe<Scalars['Float']['input']>;
+    /** The number of tokens which can provided to the xAI model, if using developer's own account. */
+    tokenLimit?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Represents xAI model properties. */
+export type XaiModelPropertiesUpdateInput = {
+    /** The limit of tokens generated by prompt completion. */
+    completionTokenLimit?: InputMaybe<Scalars['Int']['input']>;
+    /** The xAI API endpoint, if using developer's own account. */
+    endpoint?: InputMaybe<Scalars['URL']['input']>;
+    /** The xAI API key, if using developer's own account. */
+    key?: InputMaybe<Scalars['String']['input']>;
+    /** The xAI model, or custom, when using developer's own account. */
+    model?: InputMaybe<XaiModels>;
+    /** The xAI model name, if using developer's own account. */
+    modelName?: InputMaybe<Scalars['String']['input']>;
+    /** The model token probability. */
+    probability?: InputMaybe<Scalars['Float']['input']>;
+    /** The model temperature. */
+    temperature?: InputMaybe<Scalars['Float']['input']>;
+    /** The number of tokens which can provided to the xAI model, if using developer's own account. */
+    tokenLimit?: InputMaybe<Scalars['Int']['input']>;
+};
+/** xAI model type */
+export declare enum XaiModels {
+    /** Developer-specified model */
+    Custom = "CUSTOM",
+    /** Grok 3 (Latest) */
+    Grok_3 = "GROK_3",
+    /** Grok 3 Mini (Latest) */
+    Grok_3Mini = "GROK_3_MINI",
+    /** Grok 4 (Latest) */
+    Grok_4 = "GROK_4"
+}
 /** Represents YouTube feed properties. */
 export type YouTubeFeedProperties = {
     __typename?: 'YouTubeFeedProperties';
@@ -25878,6 +25955,17 @@ export type GetSpecificationQuery = {
             temperature?: number | null;
             probability?: number | null;
         } | null;
+        xai?: {
+            __typename?: 'XAIModelProperties';
+            tokenLimit?: number | null;
+            completionTokenLimit?: number | null;
+            model: XaiModels;
+            key?: string | null;
+            modelName?: string | null;
+            endpoint?: any | null;
+            temperature?: number | null;
+            probability?: number | null;
+        } | null;
         groq?: {
             __typename?: 'GroqModelProperties';
             tokenLimit?: number | null;
@@ -26283,6 +26371,17 @@ export type QuerySpecificationsQuery = {
                 temperature?: number | null;
                 probability?: number | null;
             } | null;
+            xai?: {
+                __typename?: 'XAIModelProperties';
+                tokenLimit?: number | null;
+                completionTokenLimit?: number | null;
+                model: XaiModels;
+                key?: string | null;
+                modelName?: string | null;
+                endpoint?: any | null;
+                temperature?: number | null;
+                probability?: number | null;
+            } | null;
             groq?: {
                 __typename?: 'GroqModelProperties';
                 tokenLimit?: number | null;

package/dist/generated/graphql-types.js

@@ -31,13 +31,13 @@ export var AnthropicModels;
     AnthropicModels["Claude_3Haiku"] = "CLAUDE_3_HAIKU";
     /** Claude 3 Haiku (03-07-2024 version) */
     AnthropicModels["Claude_3Haiku_20240307"] = "CLAUDE_3_HAIKU_20240307";
-    /** Claude 3 Opus (Latest) */
+    /** @deprecated Use Claude 4 Opus instead. */
     AnthropicModels["Claude_3Opus"] = "CLAUDE_3_OPUS";
     /** Claude 3 Opus (02-29-2024 version) */
     AnthropicModels["Claude_3Opus_20240229"] = "CLAUDE_3_OPUS_20240229";
-    /** Claude 3 Sonnet (Latest) */
+    /** @deprecated Use Claude 4 Sonnet instead. */
     AnthropicModels["Claude_3Sonnet"] = "CLAUDE_3_SONNET";
-    /** Claude 3 Sonnet (02-29-2024 version) */
+    /** @deprecated Use Claude 4 Sonnet instead. */
     AnthropicModels["Claude_3Sonnet_20240229"] = "CLAUDE_3_SONNET_20240229";
     /** Claude 4 Opus (Latest) */
     AnthropicModels["Claude_4Opus"] = "CLAUDE_4_OPUS";
@@ -1469,6 +1469,8 @@ export var ModelServiceTypes;
     ModelServiceTypes["Replicate"] = "REPLICATE";
     /** Voyage */
     ModelServiceTypes["Voyage"] = "VOYAGE";
+    /** xAI */
+    ModelServiceTypes["Xai"] = "XAI";
 })(ModelServiceTypes || (ModelServiceTypes = {}));
 /** Model type */
 export var ModelTypes;
@@ -2246,6 +2248,18 @@ export var VoyageModels;
     /** Voyage Multilingual 2.0 */
     VoyageModels["VoyageMultilingual_2_0"] = "VOYAGE_MULTILINGUAL_2_0";
 })(VoyageModels || (VoyageModels = {}));
+/** xAI model type */
+export var XaiModels;
+(function (XaiModels) {
+    /** Developer-specified model */
+    XaiModels["Custom"] = "CUSTOM";
+    /** Grok 3 (Latest) */
+    XaiModels["Grok_3"] = "GROK_3";
+    /** Grok 3 Mini (Latest) */
+    XaiModels["Grok_3Mini"] = "GROK_3_MINI";
+    /** Grok 4 (Latest) */
+    XaiModels["Grok_4"] = "GROK_4";
+})(XaiModels || (XaiModels = {}));
 export var YouTubeTypes;
 (function (YouTubeTypes) {
     /** YouTube Channel */

package/dist/model-mapping.js

@@ -136,6 +136,12 @@ const DEEPSEEK_MODEL_MAP = {
     [Types.DeepseekModels.Chat]: "deepseek-chat",
     [Types.DeepseekModels.Reasoner]: "deepseek-reasoner",
 };
+// xAI model mappings
+const XAI_MODEL_MAP = {
+    [Types.XaiModels.Grok_4]: "grok-4",
+    [Types.XaiModels.Grok_3]: "grok-3",
+    [Types.XaiModels.Grok_3Mini]: "grok-3-mini",
+};
 /**
  * Get the actual model name for a given specification
  * @param specification - The Graphlit specification object
@@ -171,6 +177,9 @@ export function getModelName(specification) {
     if (specification?.deepseek?.modelName) {
         return specification.deepseek.modelName;
     }
+    if (specification?.xai?.modelName) {
+        return specification.xai.modelName;
+    }
     // Map based on service type and model enum
     switch (serviceType) {
         case Types.ModelServiceTypes.OpenAi:
@@ -201,6 +210,9 @@ export function getModelName(specification) {
         case Types.ModelServiceTypes.Deepseek:
             const deepseekModel = specification?.deepseek?.model;
             return deepseekModel ? DEEPSEEK_MODEL_MAP[deepseekModel] : undefined;
+        case Types.ModelServiceTypes.Xai:
+            const xaiModel = specification?.xai?.model;
+            return xaiModel ? XAI_MODEL_MAP[xaiModel] : undefined;
         default:
             return undefined;
     }
@@ -221,6 +233,7 @@ export function isStreamingSupported(serviceType) {
         Types.ModelServiceTypes.Mistral,
         Types.ModelServiceTypes.Bedrock,
         Types.ModelServiceTypes.Deepseek,
+        Types.ModelServiceTypes.Xai,
     ];
     return streamingServices.includes(serviceType);
 }

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,37 @@ 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 declare function streamWithXai(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, xaiClient: any, // OpenAI client instance configured for xAI
+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) {
@@ -2432,3 +2526,31 @@ onEvent, onComplete, abortSignal) {
         throw error;
     }
 }
+export async function streamWithXai(specification, messages, tools, xaiClient, // OpenAI client instance configured for xAI
+onEvent, onComplete, abortSignal) {
+    try {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [xAI] Starting stream | Model: ${getModelName(specification)} | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        // xAI uses the same API as OpenAI, so we can reuse the OpenAI streaming logic
+        return await streamWithOpenAI(specification, messages, tools, xaiClient, onEvent, onComplete, abortSignal);
+    }
+    catch (error) {
+        // Handle xAI-specific errors if any
+        const errorMessage = error.message || error.toString();
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`⚠️ [xAI] Error: ${errorMessage}`);
+        }
+        // Check for rate limit errors
+        if (error.status === 429 || error.statusCode === 429) {
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`⚠️ [xAI] Rate limit hit (429)`);
+            }
+            // Re-throw with proper status code for retry logic
+            const rateLimitError = new Error("xAI rate limit exceeded");
+            rateLimitError.statusCode = 429;
+            throw rateLimitError;
+        }
+        throw error;
+    }
+}

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.20250710001",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",