@jaypie/llm 1.2.14 → 1.2.16

package/dist/cjs/index.cjs

@@ -38,6 +38,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: {
@@ -118,6 +124,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 = {
@@ -135,6 +154,7 @@ const ALL = {
         PROVIDER.ANTHROPIC.MODEL.DEFAULT,
         PROVIDER.GEMINI.MODEL.DEFAULT,
         PROVIDER.OPENAI.MODEL.DEFAULT,
+        PROVIDER.XAI.MODEL.DEFAULT,
     ],
     COMBINED: [
         PROVIDER.ANTHROPIC.MODEL.DEFAULT,
@@ -149,21 +169,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,
     ],
 };
 
@@ -214,6 +241,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) {
@@ -250,6 +283,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("/")) {
@@ -296,6 +338,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)) {
@@ -507,8 +558,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$4 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
-const log$1 = getLogger$4();
+const getLogger$5 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const log$1 = getLogger$5();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -3149,6 +3200,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.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
@@ -3957,73 +4025,91 @@ class RetryExecutor {
      */
     async execute(operation, options) {
         let attempt = 0;
-        while (true) {
-            const controller = new AbortController();
-            try {
-                const result = await operation(controller.signal);
-                if (attempt > 0) {
-                    log$1.debug(`API call succeeded after ${attempt} retries`);
+        // Persistent guard against stale socket errors (TypeError: terminated).
+        // Installed after the first abort and kept alive through subsequent attempts
+        // so that asynchronous undici socket teardown errors that fire between
+        // sleep completion and the next operation's await are caught.
+        let staleGuard;
+        const installGuard = () => {
+            if (staleGuard)
+                return;
+            staleGuard = (reason) => {
+                if (isTransientNetworkError(reason)) {
+                    log$1.trace("Suppressed stale socket error during retry");
                 }
-                return result;
+            };
+            process.on("unhandledRejection", staleGuard);
+        };
+        const removeGuard = () => {
+            if (staleGuard) {
+                process.removeListener("unhandledRejection", staleGuard);
+                staleGuard = undefined;
             }
-            catch (error) {
-                // Abort the previous request to kill lingering socket callbacks
-                controller.abort("retry");
-                // Check if we've exhausted retries
-                if (!this.policy.shouldRetry(attempt)) {
-                    log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
-                        input: options.context.input,
-                        options: options.context.options,
-                        providerRequest: options.context.providerRequest,
-                        error,
-                    });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
+        };
+        try {
+            while (true) {
+                const controller = new AbortController();
+                try {
+                    const result = await operation(controller.signal);
+                    if (attempt > 0) {
+                        log$1.debug(`API call succeeded after ${attempt} retries`);
+                    }
+                    return result;
                 }
-                // Check if error is not retryable
-                if (!this.errorClassifier.isRetryable(error)) {
-                    log$1.error("API call failed with non-retryable error");
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                catch (error) {
+                    // Abort the previous request to kill lingering socket callbacks
+                    controller.abort("retry");
+                    // Install the guard immediately after abort — stale socket errors
+                    // can fire on any subsequent microtask boundary (during hook calls,
+                    // sleep, or the next operation attempt)
+                    installGuard();
+                    // Check if we've exhausted retries
+                    if (!this.policy.shouldRetry(attempt)) {
+                        log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
+                        log$1.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Check if error is not retryable
+                    if (!this.errorClassifier.isRetryable(error)) {
+                        log$1.error("API call failed with non-retryable error");
+                        log$1.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Warn if this is an unknown error type
+                    if (!this.errorClassifier.isKnownError(error)) {
+                        log$1.warn("API returned unknown error type, will retry");
+                        log$1.var({ error });
+                    }
+                    const delay = this.policy.getDelayForAttempt(attempt);
+                    log$1.warn(`API call failed. Retrying in ${delay}ms...`);
+                    await this.hookRunner.runOnRetryableError(options.hooks, {
                         input: options.context.input,
                         options: options.context.options,
                         providerRequest: options.context.providerRequest,
                         error,
                     });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
-                }
-                // Warn if this is an unknown error type
-                if (!this.errorClassifier.isKnownError(error)) {
-                    log$1.warn("API returned unknown error type, will retry");
-                    log$1.var({ error });
-                }
-                const delay = this.policy.getDelayForAttempt(attempt);
-                log$1.warn(`API call failed. Retrying in ${delay}ms...`);
-                await this.hookRunner.runOnRetryableError(options.hooks, {
-                    input: options.context.input,
-                    options: options.context.options,
-                    providerRequest: options.context.providerRequest,
-                    error,
-                });
-                // Guard against stale socket errors that fire during sleep
-                const staleHandler = (reason) => {
-                    if (isTransientNetworkError(reason)) {
-                        log$1.trace("Suppressed stale socket error during retry sleep");
-                    }
-                };
-                process.on("unhandledRejection", staleHandler);
-                try {
                     await kit.sleep(delay);
+                    attempt++;
                 }
-                finally {
-                    process.removeListener("unhandledRejection", staleHandler);
-                }
-                attempt++;
             }
         }
+        finally {
+            removeGuard();
+        }
     }
 }
 
@@ -4597,89 +4683,103 @@ class StreamLoop {
         // Retry loop for connection-level failures
         let attempt = 0;
         let chunksYielded = false;
-        while (true) {
-            const controller = new AbortController();
-            try {
-                // Execute streaming request
-                const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest, controller.signal);
-                for await (const chunk of streamGenerator) {
-                    // Pass through text chunks
-                    if (chunk.type === exports.LlmStreamChunkType.Text) {
-                        chunksYielded = true;
-                        yield chunk;
+        // Persistent guard against stale socket errors (TypeError: terminated).
+        // Installed after the first abort and kept alive through subsequent attempts.
+        let staleGuard;
+        const installGuard = () => {
+            if (staleGuard)
+                return;
+            staleGuard = (reason) => {
+                if (isTransientNetworkError(reason)) {
+                    log$1.trace("Suppressed stale socket error during retry");
+                }
+            };
+            process.on("unhandledRejection", staleGuard);
+        };
+        const removeGuard = () => {
+            if (staleGuard) {
+                process.removeListener("unhandledRejection", staleGuard);
+                staleGuard = undefined;
+            }
+        };
+        try {
+            while (true) {
+                const controller = new AbortController();
+                try {
+                    // Execute streaming request
+                    const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest, controller.signal);
+                    for await (const chunk of streamGenerator) {
+                        // Pass through text chunks
+                        if (chunk.type === exports.LlmStreamChunkType.Text) {
+                            chunksYielded = true;
+                            yield chunk;
+                        }
+                        // Collect tool calls
+                        if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
+                            chunksYielded = true;
+                            collectedToolCalls.push({
+                                callId: chunk.toolCall.id,
+                                name: chunk.toolCall.name,
+                                arguments: chunk.toolCall.arguments,
+                                raw: chunk.toolCall,
+                            });
+                            yield chunk;
+                        }
+                        // Track usage from done chunk (but don't yield it yet - we'll emit our own)
+                        if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
+                            state.usageItems.push(...chunk.usage);
+                        }
+                        // Pass through error chunks
+                        if (chunk.type === exports.LlmStreamChunkType.Error) {
+                            chunksYielded = true;
+                            yield chunk;
+                        }
                     }
-                    // Collect tool calls
-                    if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
-                        chunksYielded = true;
-                        collectedToolCalls.push({
-                            callId: chunk.toolCall.id,
-                            name: chunk.toolCall.name,
-                            arguments: chunk.toolCall.arguments,
-                            raw: chunk.toolCall,
-                        });
-                        yield chunk;
+                    // Stream completed successfully
+                    if (attempt > 0) {
+                        log$1.debug(`Stream request succeeded after ${attempt} retries`);
                     }
-                    // Track usage from done chunk (but don't yield it yet - we'll emit our own)
-                    if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
-                        state.usageItems.push(...chunk.usage);
+                    break;
+                }
+                catch (error) {
+                    // Abort the previous request to kill lingering socket callbacks
+                    controller.abort("retry");
+                    // Install the guard immediately after abort
+                    installGuard();
+                    // If chunks were already yielded, we can't transparently retry
+                    if (chunksYielded) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        log$1.error("Stream failed after partial data was delivered");
+                        log$1.var({ error });
+                        yield {
+                            type: exports.LlmStreamChunkType.Error,
+                            error: {
+                                detail: errorMessage,
+                                status: 502,
+                                title: "Stream Error",
+                            },
+                        };
+                        return { shouldContinue: false };
                     }
-                    // Pass through error chunks
-                    if (chunk.type === exports.LlmStreamChunkType.Error) {
-                        chunksYielded = true;
-                        yield chunk;
+                    // Check if we've exhausted retries or error is not retryable
+                    if (!this.retryPolicy.shouldRetry(attempt) ||
+                        !this.adapter.isRetryableError(error)) {
+                        log$1.error(`Stream request failed after ${this.retryPolicy.maxRetries} retries`);
+                        log$1.var({ error });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
                     }
-                }
-                // Stream completed successfully
-                if (attempt > 0) {
-                    log$1.debug(`Stream request succeeded after ${attempt} retries`);
-                }
-                break;
-            }
-            catch (error) {
-                // Abort the previous request to kill lingering socket callbacks
-                controller.abort("retry");
-                // If chunks were already yielded, we can't transparently retry
-                if (chunksYielded) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    log$1.error("Stream failed after partial data was delivered");
-                    log$1.var({ error });
-                    yield {
-                        type: exports.LlmStreamChunkType.Error,
-                        error: {
-                            detail: errorMessage,
-                            status: 502,
-                            title: "Stream Error",
-                        },
-                    };
-                    return { shouldContinue: false };
-                }
-                // Check if we've exhausted retries or error is not retryable
-                if (!this.retryPolicy.shouldRetry(attempt) ||
-                    !this.adapter.isRetryableError(error)) {
-                    log$1.error(`Stream request failed after ${this.retryPolicy.maxRetries} retries`);
+                    const delay = this.retryPolicy.getDelayForAttempt(attempt);
+                    log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
                     log$1.var({ error });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
-                }
-                const delay = this.retryPolicy.getDelayForAttempt(attempt);
-                log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
-                log$1.var({ error });
-                // Guard against stale socket errors that fire during sleep
-                const staleHandler = (reason) => {
-                    if (isTransientNetworkError(reason)) {
-                        log$1.trace("Suppressed stale socket error during retry sleep");
-                    }
-                };
-                process.on("unhandledRejection", staleHandler);
-                try {
                     await kit.sleep(delay);
+                    attempt++;
                 }
-                finally {
-                    process.removeListener("unhandledRejection", staleHandler);
-                }
-                attempt++;
             }
         }
+        finally {
+            removeGuard();
+        }
         // Execute afterEachModelResponse hook
         await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
             content: "",
@@ -4835,10 +4935,10 @@ async function loadSdk$2() {
     }
 }
 // Logger
-const getLogger$3 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$4 = () => log$2.log.lib({ lib: kit.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 aws.getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
@@ -4864,7 +4964,7 @@ function formatUserMessage$3(message, { data, placeholders } = {}) {
     };
 }
 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 });
@@ -4953,7 +5053,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;
@@ -4962,7 +5062,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() {
@@ -5051,10 +5151,10 @@ async function loadSdk$1() {
     }
 }
 // Logger
-const getLogger$2 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$3 = () => log$2.log.lib({ lib: kit.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 aws.getEnvSecret("GEMINI_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -5074,7 +5174,7 @@ function formatUserMessage$2(message, { data, placeholders } = {}) {
     };
 }
 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
@@ -5088,7 +5188,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;
@@ -5097,7 +5197,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() {
@@ -5202,10 +5302,10 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger$1 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$2 = () => log$2.log.lib({ lib: kit.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 aws.getEnvSecret("OPENAI_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -5233,7 +5333,7 @@ function formatUserMessage$1(message, { data, placeholders } = {}) {
     };
 }
 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 });
@@ -5247,7 +5347,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 v4.z.ZodType
         ? responseSchema
@@ -5278,7 +5378,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,
@@ -5290,7 +5390,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;
@@ -5299,7 +5399,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() {
@@ -5386,10 +5486,10 @@ async function loadSdk() {
     }
 }
 // Logger
-const getLogger = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$1 = () => log$2.log.lib({ lib: kit.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 aws.getEnvSecret("OPENROUTER_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -5422,7 +5522,7 @@ function formatUserMessage(message, { data, placeholders } = {}) {
     };
 }
 function prepareMessages(message, { system, data, placeholders } = {}) {
-    const logger = getLogger();
+    const logger = getLogger$1();
     const messages = [];
     if (system) {
         const systemMessage = formatSystemMessage(system, { data, placeholders });
@@ -5437,7 +5537,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;
@@ -5446,7 +5546,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() {
@@ -5534,6 +5634,107 @@ class OpenRouterProvider {
     }
 }
 
+// Logger
+const getLogger = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret(PROVIDER.XAI.API_KEY));
+    if (!resolvedApiKey) {
+        throw new errors.ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new openai.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;
@@ -5595,6 +5796,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 errors.ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -6039,6 +6244,7 @@ exports.LLM = constants;
 exports.Llm = Llm;
 exports.OpenRouterProvider = OpenRouterProvider;
 exports.Toolkit = Toolkit;
+exports.XaiProvider = XaiProvider;
 exports.extractReasoning = extractReasoning;
 exports.isLlmOperateInput = isLlmOperateInput;
 exports.isLlmOperateInputContent = isLlmOperateInputContent;