@jaypie/llm 1.2.15 → 1.2.17

package/dist/cjs/index.d.ts

@@ -10,3 +10,4 @@ export { JaypieToolkit, toolkit, Toolkit, tools } from "./tools/index.js";
 export { extractReasoning } from "./util/extractReasoning.js";
 export { GeminiProvider } from "./providers/gemini/index.js";
 export { OpenRouterProvider } from "./providers/openrouter/index.js";
+export { XaiProvider } from "./providers/xai/index.js";

package/dist/cjs/operate/adapters/XaiAdapter.d.ts

@@ -0,0 +1,11 @@
+import { OpenAiAdapter } from "./OpenAiAdapter.js";
+/**
+ * XaiAdapter extends OpenAiAdapter since xAI (Grok) uses an OpenAI-compatible API.
+ * Only the name and default model are overridden; all request building, response parsing,
+ * error classification, tool handling, and streaming are inherited.
+ */
+export declare class XaiAdapter extends OpenAiAdapter {
+    readonly name: "xai";
+    readonly defaultModel: "grok-4-1-fast-reasoning";
+}
+export declare const xaiAdapter: XaiAdapter;

package/dist/cjs/operate/adapters/index.d.ts

@@ -4,3 +4,4 @@ export { AnthropicAdapter, anthropicAdapter } from "./AnthropicAdapter.js";
 export { GeminiAdapter, geminiAdapter } from "./GeminiAdapter.js";
 export { OpenAiAdapter, openAiAdapter } from "./OpenAiAdapter.js";
 export { OpenRouterAdapter, openRouterAdapter } from "./OpenRouterAdapter.js";
+export { XaiAdapter, xaiAdapter } from "./XaiAdapter.js";

package/dist/cjs/operate/index.d.ts

@@ -1,4 +1,4 @@
-export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, GeminiAdapter, geminiAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, } from "./adapters/index.js";
+export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, GeminiAdapter, geminiAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, XaiAdapter, xaiAdapter, } from "./adapters/index.js";
 export type { ProviderAdapter } from "./adapters/index.js";
 export { createOperateLoop, OperateLoop } from "./OperateLoop.js";
 export type { OperateLoopConfig } from "./OperateLoop.js";

package/dist/cjs/providers/xai/XaiProvider.class.d.ts

@@ -0,0 +1,21 @@
+import { JsonObject } from "@jaypie/types";
+import { LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmProvider } from "../../types/LlmProvider.interface.js";
+import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
+export declare class XaiProvider implements LlmProvider {
+    private model;
+    private _client?;
+    private _operateLoop?;
+    private _streamLoop?;
+    private apiKey?;
+    private log;
+    private conversationHistory;
+    constructor(model?: string, { apiKey }?: {
+        apiKey?: string;
+    });
+    private getClient;
+    private getOperateLoop;
+    private getStreamLoop;
+    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    operate(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
+    stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
+}

package/dist/cjs/providers/xai/index.d.ts

@@ -0,0 +1 @@
+export { XaiProvider } from "./XaiProvider.class.js";

package/dist/cjs/providers/xai/utils.d.ts

@@ -0,0 +1,5 @@
+import { OpenAI } from "openai";
+export declare const getLogger: () => any;
+export declare function initializeClient({ apiKey, }?: {
+    apiKey?: string;
+}): Promise<OpenAI>;

package/dist/cjs/types/LlmStreamChunk.interface.d.ts

@@ -16,6 +16,8 @@ export interface LlmStreamChunkToolCall {
         id: string;
         name: string;
         arguments: string;
+        /** Provider-specific metadata preserved through tool-call roundtrip */
+        metadata?: Record<string, unknown>;
     };
 }
 export interface LlmStreamChunkToolResult {

package/dist/esm/constants.d.ts

@@ -64,8 +64,20 @@ export declare const PROVIDER: {
             readonly USER: "user";
         };
     };
+    readonly XAI: {
+        readonly API_KEY: "XAI_API_KEY";
+        readonly BASE_URL: "https://api.x.ai/v1";
+        readonly MODEL: {
+            readonly DEFAULT: "grok-4-1-fast-reasoning";
+            readonly LARGE: "grok-4-1-fast-reasoning";
+            readonly SMALL: "grok-3";
+            readonly TINY: "grok-3-mini";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["grok", "xai"];
+        readonly NAME: "xai";
+    };
 };
-export type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.GEMINI.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME;
+export type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.GEMINI.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME | typeof PROVIDER.XAI.NAME;
 export declare const DEFAULT: {
     readonly MODEL: {
         readonly BASE: "gpt-5.2";
@@ -85,9 +97,9 @@ export declare const DEFAULT: {
     };
 };
 export declare const ALL: {
-    readonly BASE: readonly ["claude-sonnet-4-5", "gemini-3-pro-preview", "gpt-5.2"];
-    readonly COMBINED: readonly ["claude-sonnet-4-5", "claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5", "gemini-3-pro-preview", "gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-3-flash-preview", "gpt-5.2", "gpt-5.2-pro", "gpt-5-mini", "gpt-5-nano"];
-    readonly LARGE: readonly ["claude-opus-4-5", "gemini-3-pro-preview", "gpt-5.2-pro"];
-    readonly SMALL: readonly ["claude-sonnet-4-5", "gemini-3-flash-preview", "gpt-5-mini"];
-    readonly TINY: readonly ["claude-haiku-4-5", "gemini-3-flash-preview", "gpt-5-nano"];
+    readonly BASE: readonly ["claude-sonnet-4-5", "gemini-3-pro-preview", "gpt-5.2", "grok-4-1-fast-reasoning"];
+    readonly COMBINED: readonly ["claude-sonnet-4-5", "claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5", "gemini-3-pro-preview", "gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-3-flash-preview", "gpt-5.2", "gpt-5.2-pro", "gpt-5-mini", "gpt-5-nano", "grok-4-1-fast-reasoning", "grok-4-1-fast-reasoning", "grok-3", "grok-3-mini"];
+    readonly LARGE: readonly ["claude-opus-4-5", "gemini-3-pro-preview", "gpt-5.2-pro", "grok-4-1-fast-reasoning"];
+    readonly SMALL: readonly ["claude-sonnet-4-5", "gemini-3-flash-preview", "gpt-5-mini", "grok-3"];
+    readonly TINY: readonly ["claude-haiku-4-5", "gemini-3-flash-preview", "gpt-5-nano", "grok-3-mini"];
 };

package/dist/esm/index.d.ts

@@ -10,3 +10,4 @@ export { JaypieToolkit, toolkit, Toolkit, tools } from "./tools/index.js";
 export { extractReasoning } from "./util/extractReasoning.js";
 export { GeminiProvider } from "./providers/gemini/index.js";
 export { OpenRouterProvider } from "./providers/openrouter/index.js";
+export { XaiProvider } from "./providers/xai/index.js";

package/dist/esm/index.js

@@ -36,6 +36,12 @@ const FIRST_CLASS_PROVIDER = {
         SMALL: "z-ai/glm-4.7",
         TINY: "z-ai/glm-4.7",
     },
+    XAI: {
+        DEFAULT: "grok-4-1-fast-reasoning",
+        LARGE: "grok-4-1-fast-reasoning",
+        SMALL: "grok-3",
+        TINY: "grok-3-mini",
+    },
 };
 const PROVIDER = {
     ANTHROPIC: {
@@ -116,6 +122,19 @@ const PROVIDER = {
             USER: "user",
         },
     },
+    XAI: {
+        // https://docs.x.ai/docs/models
+        API_KEY: "XAI_API_KEY",
+        BASE_URL: "https://api.x.ai/v1",
+        MODEL: {
+            DEFAULT: FIRST_CLASS_PROVIDER.XAI.DEFAULT,
+            LARGE: FIRST_CLASS_PROVIDER.XAI.LARGE,
+            SMALL: FIRST_CLASS_PROVIDER.XAI.SMALL,
+            TINY: FIRST_CLASS_PROVIDER.XAI.TINY,
+        },
+        MODEL_MATCH_WORDS: ["grok", "xai"],
+        NAME: "xai",
+    },
 };
 // Last: Defaults
 const DEFAULT = {
@@ -133,6 +152,7 @@ const ALL = {
         PROVIDER.ANTHROPIC.MODEL.DEFAULT,
         PROVIDER.GEMINI.MODEL.DEFAULT,
         PROVIDER.OPENAI.MODEL.DEFAULT,
+        PROVIDER.XAI.MODEL.DEFAULT,
     ],
     COMBINED: [
         PROVIDER.ANTHROPIC.MODEL.DEFAULT,
@@ -147,21 +167,28 @@ const ALL = {
         PROVIDER.OPENAI.MODEL.LARGE,
         PROVIDER.OPENAI.MODEL.SMALL,
         PROVIDER.OPENAI.MODEL.TINY,
+        PROVIDER.XAI.MODEL.DEFAULT,
+        PROVIDER.XAI.MODEL.LARGE,
+        PROVIDER.XAI.MODEL.SMALL,
+        PROVIDER.XAI.MODEL.TINY,
     ],
     LARGE: [
         PROVIDER.ANTHROPIC.MODEL.LARGE,
         PROVIDER.GEMINI.MODEL.LARGE,
         PROVIDER.OPENAI.MODEL.LARGE,
+        PROVIDER.XAI.MODEL.LARGE,
     ],
     SMALL: [
         PROVIDER.ANTHROPIC.MODEL.SMALL,
         PROVIDER.GEMINI.MODEL.SMALL,
         PROVIDER.OPENAI.MODEL.SMALL,
+        PROVIDER.XAI.MODEL.SMALL,
     ],
     TINY: [
         PROVIDER.ANTHROPIC.MODEL.TINY,
         PROVIDER.GEMINI.MODEL.TINY,
         PROVIDER.OPENAI.MODEL.TINY,
+        PROVIDER.XAI.MODEL.TINY,
     ],
 };
 
@@ -212,6 +239,12 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
+    if (input === PROVIDER.XAI.NAME) {
+        return {
+            model: PROVIDER.XAI.MODEL.DEFAULT,
+            provider: PROVIDER.XAI.NAME,
+        };
+    }
     // Check if input matches an Anthropic model exactly
     for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
         if (input === modelValue) {
@@ -248,6 +281,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check if input matches an xAI model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.XAI.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.XAI.NAME,
+            };
+        }
+    }
     // Assume OpenRouter for models containing "/" (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
     // This check must come before match words so that "openai/gpt-4" is not matched by "openai" keyword
     if (input.includes("/")) {
@@ -294,6 +336,15 @@ function determineModelProvider(input) {
             }
         }
     }
+    // Check xAI match words
+    for (const matchWord of PROVIDER.XAI.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.XAI.NAME,
+            };
+        }
+    }
     // Check OpenRouter match words
     for (const matchWord of PROVIDER.OPENROUTER.MODEL_MATCH_WORDS) {
         if (lowerInput.includes(matchWord)) {
@@ -505,8 +556,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$4 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
-const log$1 = getLogger$4();
+const getLogger$5 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const log$1 = getLogger$5();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -1628,6 +1679,11 @@ class GeminiAdapter extends BaseProviderAdapter {
                             name: functionCall.name || "",
                             arguments: functionCall.args || {},
                         };
+                        // Preserve thoughtSignature for Gemini 3 models
+                        // Required to maintain tool call context between turns
+                        const metadata = part.thoughtSignature
+                            ? { thoughtSignature: part.thoughtSignature }
+                            : undefined;
                         // Emit the function call immediately
                         yield {
                             type: LlmStreamChunkType.ToolCall,
@@ -1635,6 +1691,7 @@ class GeminiAdapter extends BaseProviderAdapter {
                                 id: currentFunctionCall.id,
                                 name: currentFunctionCall.name,
                                 arguments: JSON.stringify(currentFunctionCall.arguments),
+                                metadata,
                             },
                         };
                         currentFunctionCall = null;
@@ -2321,6 +2378,9 @@ class OpenAiAdapter extends BaseProviderAdapter {
                             id: currentFunctionCall.callId,
                             name: currentFunctionCall.name,
                             arguments: currentFunctionCall.arguments,
+                            // Preserve the item ID (fc_...) separately from call_id (call_...)
+                            // OpenAI Responses API requires both with correct prefixes
+                            metadata: { itemId: currentFunctionCall.id },
                         },
                     };
                     currentFunctionCall = null;
@@ -3147,6 +3207,23 @@ class OpenRouterAdapter extends BaseProviderAdapter {
 // Export singleton instance
 const openRouterAdapter = new OpenRouterAdapter();
 
+/**
+ * XaiAdapter extends OpenAiAdapter since xAI (Grok) uses an OpenAI-compatible API.
+ * Only the name and default model are overridden; all request building, response parsing,
+ * error classification, tool handling, and streaming are inherited.
+ */
+class XaiAdapter extends OpenAiAdapter {
+    constructor() {
+        super(...arguments);
+        // @ts-expect-error Narrowing override: xAI name differs from parent's literal "openai"
+        this.name = PROVIDER.XAI.NAME;
+        // @ts-expect-error Narrowing override: xAI default model differs from parent's literal
+        this.defaultModel = PROVIDER.XAI.MODEL.DEFAULT;
+    }
+}
+// Export singleton instance
+const xaiAdapter = new XaiAdapter();
+
 const DEFAULT_TOOL_TYPE = "function";
 const log = log$2.lib({ lib: JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
@@ -4723,13 +4800,22 @@ class StreamLoop {
         if (collectedToolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
             // Add tool calls to history
             for (const toolCall of collectedToolCalls) {
-                state.currentInput.push({
+                // Extract provider-specific metadata from the stream chunk
+                const metadata = toolCall.raw?.metadata;
+                const historyItem = {
                     type: LlmMessageType.FunctionCall,
                     name: toolCall.name,
                     arguments: toolCall.arguments,
                     call_id: toolCall.callId,
-                    id: toolCall.callId,
-                });
+                    // Use provider item ID if available (e.g., OpenAI fc_... prefix),
+                    // otherwise fall back to callId
+                    id: metadata?.itemId || toolCall.callId,
+                };
+                // Preserve provider-specific fields (e.g., Gemini thoughtSignature)
+                if (metadata?.thoughtSignature) {
+                    historyItem.thoughtSignature = metadata.thoughtSignature;
+                }
+                state.currentInput.push(historyItem);
             }
             return { shouldContinue: true, toolCalls: collectedToolCalls };
         }
@@ -4865,10 +4951,10 @@ async function loadSdk$2() {
     }
 }
 // Logger
-const getLogger$3 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$4 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$3({ apiKey, } = {}) {
-    const logger = getLogger$3();
+async function initializeClient$4({ apiKey, } = {}) {
+    const logger = getLogger$4();
     const resolvedApiKey = apiKey || (await getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
@@ -4894,7 +4980,7 @@ function formatUserMessage$3(message, { data, placeholders: placeholders$1 } = {
     };
 }
 function prepareMessages$3(message, { data, placeholders } = {}) {
-    const logger = getLogger$3();
+    const logger = getLogger$4();
     const messages = [];
     // Add user message (necessary for all requests)
     const userMessage = formatUserMessage$3(message, { data, placeholders });
@@ -4983,7 +5069,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$3();
+        this.log = getLogger$4();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -4992,7 +5078,7 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$3({ apiKey: this.apiKey });
+        this._client = await initializeClient$4({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5081,10 +5167,10 @@ async function loadSdk$1() {
     }
 }
 // Logger
-const getLogger$2 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$3 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$2({ apiKey, } = {}) {
-    const logger = getLogger$2();
+async function initializeClient$3({ apiKey, } = {}) {
+    const logger = getLogger$3();
     const resolvedApiKey = apiKey || (await getEnvSecret("GEMINI_API_KEY"));
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
@@ -5104,7 +5190,7 @@ function formatUserMessage$2(message, { data, placeholders: placeholders$1 } = {
     };
 }
 function prepareMessages$2(message, { data, placeholders } = {}) {
-    const logger = getLogger$2();
+    const logger = getLogger$3();
     const messages = [];
     let systemInstruction;
     // Note: Gemini handles system prompts differently via systemInstruction config
@@ -5118,7 +5204,7 @@ function prepareMessages$2(message, { data, placeholders } = {}) {
 
 class GeminiProvider {
     constructor(model = PROVIDER.GEMINI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$2();
+        this.log = getLogger$3();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5127,7 +5213,7 @@ class GeminiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$2({ apiKey: this.apiKey });
+        this._client = await initializeClient$3({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5232,10 +5318,10 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger$1 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$2 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$1({ apiKey, } = {}) {
-    const logger = getLogger$1();
+async function initializeClient$2({ apiKey, } = {}) {
+    const logger = getLogger$2();
     const resolvedApiKey = apiKey || (await getEnvSecret("OPENAI_API_KEY"));
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
@@ -5263,7 +5349,7 @@ function formatUserMessage$1(message, { data, placeholders: placeholders$1 } = {
     };
 }
 function prepareMessages$1(message, { system, data, placeholders } = {}) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     const messages = [];
     if (system) {
         const systemMessage = formatSystemMessage$1(system, { data, placeholders });
@@ -5277,7 +5363,7 @@ function prepareMessages$1(message, { system, data, placeholders } = {}) {
 }
 // Completion requests
 async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     logger.trace("Using structured output");
     const zodSchema = responseSchema instanceof z.ZodType
         ? responseSchema
@@ -5308,7 +5394,7 @@ async function createStructuredCompletion(client, { messages, responseSchema, mo
     return completion.choices[0].message.parsed;
 }
 async function createTextCompletion(client, { messages, model, }) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     logger.trace("Using text output (unstructured)");
     const completion = await client.chat.completions.create({
         messages,
@@ -5320,7 +5406,7 @@ async function createTextCompletion(client, { messages, model, }) {
 
 class OpenAiProvider {
     constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$1();
+        this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5329,7 +5415,7 @@ class OpenAiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$1({ apiKey: this.apiKey });
+        this._client = await initializeClient$2({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5416,10 +5502,10 @@ async function loadSdk() {
     }
 }
 // Logger
-const getLogger = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$1 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient({ apiKey, } = {}) {
-    const logger = getLogger();
+async function initializeClient$1({ apiKey, } = {}) {
+    const logger = getLogger$1();
     const resolvedApiKey = apiKey || (await getEnvSecret("OPENROUTER_API_KEY"));
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
@@ -5452,7 +5538,7 @@ function formatUserMessage(message, { data, placeholders: placeholders$1 } = {})
     };
 }
 function prepareMessages(message, { system, data, placeholders } = {}) {
-    const logger = getLogger();
+    const logger = getLogger$1();
     const messages = [];
     if (system) {
         const systemMessage = formatSystemMessage(system, { data, placeholders });
@@ -5467,7 +5553,7 @@ function prepareMessages(message, { system, data, placeholders } = {}) {
 
 class OpenRouterProvider {
     constructor(model = getDefaultModel(), { apiKey } = {}) {
-        this.log = getLogger();
+        this.log = getLogger$1();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5476,7 +5562,7 @@ class OpenRouterProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient({ apiKey: this.apiKey });
+        this._client = await initializeClient$1({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5564,6 +5650,107 @@ class OpenRouterProvider {
     }
 }
 
+// Logger
+const getLogger = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await getEnvSecret(PROVIDER.XAI.API_KEY));
+    if (!resolvedApiKey) {
+        throw new ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new OpenAI({
+        apiKey: resolvedApiKey,
+        baseURL: PROVIDER.XAI.BASE_URL,
+    });
+    logger.trace("Initialized xAI client");
+    return client;
+}
+
+class XaiProvider {
+    constructor(model = PROVIDER.XAI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger$2();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: xaiAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: xaiAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages$1(message, options || {});
+        const modelToUse = options?.model || this.model;
+        if (options?.response) {
+            return createStructuredCompletion(client, {
+                messages,
+                responseSchema: options.response,
+                model: modelToUse,
+            });
+        }
+        return createTextCompletion(client, {
+            messages,
+            model: modelToUse,
+        });
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            // If options.history exists, merge with instance history, otherwise use instance history
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
+}
+
 class Llm {
     constructor(providerName = DEFAULT.PROVIDER.NAME, options = {}) {
         const { fallback, model } = options;
@@ -5625,6 +5812,10 @@ class Llm {
                 return new OpenRouterProvider(model || PROVIDER.OPENROUTER.MODEL.DEFAULT, {
                     apiKey,
                 });
+            case PROVIDER.XAI.NAME:
+                return new XaiProvider(model || PROVIDER.XAI.MODEL.DEFAULT, {
+                    apiKey,
+                });
             default:
                 throw new ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -6063,5 +6254,5 @@ const toolkit = new JaypieToolkit(tools);
     [LlmMessageRole.Developer]: "user",
 });
 
-export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
+export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
 //# sourceMappingURL=index.js.map