@node-llm/core 1.12.0 → 1.13.0

package/dist/providers/registry.d.ts

@@ -6,6 +6,7 @@ import { registerDeepSeekProvider } from "./deepseek/index.js";
 import { registerOllamaProvider } from "./ollama/index.js";
 import { registerOpenRouterProvider } from "./openrouter/index.js";
 import { registerBedrockProvider } from "./bedrock/index.js";
+import { registerXAIProvider } from "./xai/index.js";
 import { NodeLLMConfig } from "../config.js";
 type ProviderFactory = (config?: NodeLLMConfig) => Provider;
 export type ProviderInterceptor = (provider: Provider) => Provider;
@@ -46,5 +47,5 @@ declare class ProviderRegistry {
  * ```
  */
 export declare const providerRegistry: ProviderRegistry;
-export { registerOpenAIProvider as ensureOpenAIRegistered, registerOpenAIProvider, registerAnthropicProvider, registerGeminiProvider, registerDeepSeekProvider, registerOllamaProvider, registerOpenRouterProvider, registerBedrockProvider };
+export { registerOpenAIProvider as ensureOpenAIRegistered, registerOpenAIProvider, registerAnthropicProvider, registerGeminiProvider, registerDeepSeekProvider, registerOllamaProvider, registerOpenRouterProvider, registerBedrockProvider, registerXAIProvider };
 //# sourceMappingURL=registry.d.ts.map

package/dist/providers/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,KAAK,eAAe,GAAG,CAAC,MAAM,CAAC,EAAE,aAAa,KAAK,QAAQ,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,QAAQ,KAAK,QAAQ,CAAC;AAEnE,cAAM,gBAAgB;IACpB,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAEzC,cAAc,CAAC,WAAW,EAAE,mBAAmB,GAAG,SAAS;IAIlE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe;IAO/C;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,QAAQ;IAgBvD;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;CAGjB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC;AAGvD,OAAO,EACL,sBAAsB,IAAI,sBAAsB,EAChD,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACxB,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,KAAK,eAAe,GAAG,CAAC,MAAM,CAAC,EAAE,aAAa,KAAK,QAAQ,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,QAAQ,KAAK,QAAQ,CAAC;AAEnE,cAAM,gBAAgB;IACpB,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAEzC,cAAc,CAAC,WAAW,EAAE,mBAAmB,GAAG,SAAS;IAIlE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe;IAO/C;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,QAAQ;IAgBvD;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;CAGjB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC;AAGvD,OAAO,EACL,sBAAsB,IAAI,sBAAsB,EAChD,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,mBAAmB,EACpB,CAAC"}

package/dist/providers/registry.js

@@ -5,6 +5,7 @@ import { registerDeepSeekProvider } from "./deepseek/index.js";
 import { registerOllamaProvider } from "./ollama/index.js";
 import { registerOpenRouterProvider } from "./openrouter/index.js";
 import { registerBedrockProvider } from "./bedrock/index.js";
+import { registerXAIProvider } from "./xai/index.js";
 class ProviderRegistry {
     providers = new Map();
     globalInterceptor;
@@ -64,4 +65,4 @@ class ProviderRegistry {
  */
 export const providerRegistry = new ProviderRegistry();
 // Exported registration functions (delegates to provider-specific index files)
-export { registerOpenAIProvider as ensureOpenAIRegistered, registerOpenAIProvider, registerAnthropicProvider, registerGeminiProvider, registerDeepSeekProvider, registerOllamaProvider, registerOpenRouterProvider, registerBedrockProvider };
+export { registerOpenAIProvider as ensureOpenAIRegistered, registerOpenAIProvider, registerAnthropicProvider, registerGeminiProvider, registerDeepSeekProvider, registerOllamaProvider, registerOpenRouterProvider, registerBedrockProvider, registerXAIProvider };

package/dist/providers/xai/Capabilities.d.ts

@@ -0,0 +1,12 @@
+export declare class Capabilities {
+    static supportsVision(model: string): boolean;
+    static supportsTools(model: string): boolean;
+    static supportsStructuredOutput(model: string): boolean;
+    static supportsEmbeddings(model: string): boolean;
+    static supportsImageGeneration(model: string): boolean;
+    static supportsTranscription(model: string): boolean;
+    static supportsModeration(model: string): boolean;
+    static supportsReasoning(model: string): boolean;
+    static getContextWindow(model: string): number;
+}
+//# sourceMappingURL=Capabilities.d.ts.map

package/dist/providers/xai/Capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Capabilities.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Capabilities.ts"],"names":[],"mappings":"AAsBA,qBAAa,YAAY;IACvB,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAO7C,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAS5C,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IASvD,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOjD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOtD,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOpD,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOjD,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOhD,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAM/C"}

package/dist/providers/xai/Capabilities.js

@@ -0,0 +1,79 @@
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+const VISION_MODELS = [
+    "grok-2-vision-1212",
+    "grok-4-0709",
+    "grok-4-fast-non-reasoning",
+    "grok-4-fast-reasoning",
+    "grok-4.1-fast-non-reasoning",
+    "grok-4.1-fast-reasoning",
+    "grok-4-1-fast-non-reasoning",
+    "grok-4-1-fast-reasoning"
+];
+const REASONING_MODELS = [
+    "grok-3-mini",
+    "grok-4-0709",
+    "grok-4-fast-reasoning",
+    "grok-4.1-fast-reasoning",
+    "grok-4-1-fast-reasoning",
+    "grok-code-fast-1"
+];
+export class Capabilities {
+    static supportsVision(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("vision"))
+            return true;
+        return model.includes("vision") || VISION_MODELS.includes(model);
+    }
+    static supportsTools(model) {
+        if (this.supportsImageGeneration(model))
+            return false;
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("tools"))
+            return true;
+        return true;
+    }
+    static supportsStructuredOutput(model) {
+        if (this.supportsImageGeneration(model))
+            return false;
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("structured_output"))
+            return true;
+        return true;
+    }
+    static supportsEmbeddings(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("embeddings"))
+            return true;
+        return false;
+    }
+    static supportsImageGeneration(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("image_generation"))
+            return true;
+        return model.includes("image") || model.includes("imagine");
+    }
+    static supportsTranscription(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("transcription"))
+            return true;
+        return false;
+    }
+    static supportsModeration(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("moderation"))
+            return true;
+        return false;
+    }
+    static supportsReasoning(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.capabilities.includes("reasoning"))
+            return true;
+        return model.includes("reasoning") || REASONING_MODELS.includes(model);
+    }
+    static getContextWindow(model) {
+        const registryModel = ModelRegistry.find(model, "xai");
+        if (registryModel?.context_window)
+            return registryModel.context_window;
+        return 128000;
+    }
+}

package/dist/providers/xai/Chat.d.ts

@@ -0,0 +1,8 @@
+import { ChatRequest, ChatResponse } from "../Provider.js";
+export declare class XAIChat {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ChatRequest): Promise<ChatResponse>;
+}
+//# sourceMappingURL=Chat.d.ts.map

package/dist/providers/xai/Chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAS,MAAM,gBAAgB,CAAC;AAiClE,qBAAa,OAAO;IAEhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG3B,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CAgF3D"}

package/dist/providers/xai/Chat.js

@@ -0,0 +1,69 @@
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+import { logger } from "../../utils/logger.js";
+import { handleXAIError } from "./Errors.js";
+import { mapSystemMessages } from "../utils.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+export class XAIChat {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const { model, messages, tools, max_tokens, response_format, thinking: _thinking, headers: _headers, requestTimeout, ...rest } = request;
+        const mappedMessages = mapSystemMessages(messages, false);
+        const body = {
+            model,
+            messages: mappedMessages,
+            ...rest
+        };
+        if (max_tokens)
+            body.max_tokens = max_tokens;
+        if (tools && tools.length > 0)
+            body.tools = tools;
+        if (response_format)
+            body.response_format = response_format;
+        const url = `${this.baseUrl}/chat/completions`;
+        logger.logRequest("xAI", "POST", url, body);
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+                ...request.headers
+            },
+            body: JSON.stringify(body)
+        }, requestTimeout);
+        if (!response.ok) {
+            await handleXAIError(response, model);
+        }
+        const json = (await response.json());
+        logger.logResponse("xAI", response.status, response.statusText, json);
+        const message = json.choices[0]?.message;
+        const content = message?.content ?? null;
+        const usage = {
+            input_tokens: json.usage.prompt_tokens,
+            output_tokens: json.usage.completion_tokens,
+            total_tokens: json.usage.total_tokens
+        };
+        const toolCalls = message?.tool_calls?.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+                name: tc.function.name,
+                arguments: tc.function.arguments
+            }
+        }));
+        if (!content && (!toolCalls || toolCalls.length === 0)) {
+            throw new Error("xAI returned empty response");
+        }
+        // Cost calculation if registered in ModelRegistry
+        const calculatedUsage = ModelRegistry.calculateCost(usage, model, "xai");
+        return {
+            content,
+            usage: calculatedUsage,
+            tool_calls: toolCalls
+        };
+    }
+}

package/dist/providers/xai/Errors.d.ts

@@ -0,0 +1,2 @@
+export declare function handleXAIError(response: Response, model?: string): Promise<never>;
+//# sourceMappingURL=Errors.d.ts.map

package/dist/providers/xai/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Errors.ts"],"names":[],"mappings":"AASA,wBAAsB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAiCvF"}

package/dist/providers/xai/Errors.js

@@ -0,0 +1,33 @@
+import { APIError, AuthenticationError, BadRequestError, RateLimitError, ServerError, NotFoundError } from "../../errors/index.js";
+export async function handleXAIError(response, model) {
+    const status = response.status;
+    let errorMessage = `xAI API identification failed with status ${status}`;
+    let errorData = {};
+    try {
+        const text = await response.text();
+        console.error("XAI ERROR RESPONSE:", text);
+        errorData = JSON.parse(text);
+        errorMessage = errorData.error?.message || errorMessage;
+    }
+    catch (_e) {
+        // Ignore JSON parsing errors
+    }
+    const provider = "xai";
+    switch (status) {
+        case 401:
+            throw new AuthenticationError(errorMessage, status, errorData, provider);
+        case 400:
+            throw new BadRequestError(errorMessage, errorData, provider, model);
+        case 404:
+            throw new NotFoundError(errorMessage, status, errorData, provider, model);
+        case 429:
+            throw new RateLimitError(errorMessage, errorData, provider, model);
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            throw new ServerError(errorMessage, status, errorData, provider, model);
+        default:
+            throw new APIError(errorMessage, status, errorData, provider, model);
+    }
+}

package/dist/providers/xai/Image.d.ts

@@ -0,0 +1,8 @@
+import { ImageRequest, ImageResponse } from "../Provider.js";
+export declare class XAIImage {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ImageRequest): Promise<ImageResponse>;
+}
+//# sourceMappingURL=Image.d.ts.map

package/dist/providers/xai/Image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAY7D,qBAAa,QAAQ;IAEjB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG3B,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;CA6C7D"}

package/dist/providers/xai/Image.js

@@ -0,0 +1,47 @@
+import { handleXAIError } from "./Errors.js";
+import { logger } from "../../utils/logger.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+export class XAIImage {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const body = {
+            model: request.model || "grok-imagine-image",
+            prompt: request.prompt
+        };
+        if (request.size)
+            body.size = request.size;
+        if (request.n)
+            body.n = request.n;
+        if (request.quality)
+            body.quality = request.quality;
+        const url = `${this.baseUrl}/images/generations`;
+        logger.logRequest("xAI", "POST", url, body);
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+        }, request.requestTimeout);
+        if (!response.ok) {
+            await handleXAIError(response, request.model);
+        }
+        const json = (await response.json());
+        logger.logResponse("xAI", response.status, response.statusText, json);
+        const data = json.data?.[0];
+        if (!data) {
+            throw new Error("xAI returned empty image response");
+        }
+        return {
+            url: data.url,
+            revised_prompt: data.revised_prompt,
+            mime_type: "image/png"
+        };
+    }
+}

package/dist/providers/xai/Models.d.ts

@@ -0,0 +1,8 @@
+import { ModelInfo } from "../Provider.js";
+export declare class XAIModels {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(): Promise<ModelInfo[]>;
+}
+//# sourceMappingURL=Models.d.ts.map

package/dist/providers/xai/Models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Models.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAa3C,qBAAa,SAAS;IAElB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG3B,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;CAoCtC"}

package/dist/providers/xai/Models.js

@@ -0,0 +1,47 @@
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { handleXAIError } from "./Errors.js";
+import { Capabilities } from "./Capabilities.js";
+export class XAIModels {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute() {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetchWithTimeout(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json"
+            }
+        });
+        if (!response.ok) {
+            await handleXAIError(response);
+        }
+        const json = (await response.json());
+        return json.data.map((m) => {
+            const caps = [];
+            if (Capabilities.supportsVision(m.id))
+                caps.push("vision");
+            if (Capabilities.supportsTools(m.id))
+                caps.push("tools");
+            if (Capabilities.supportsStructuredOutput(m.id))
+                caps.push("structured_output");
+            if (Capabilities.supportsReasoning(m.id))
+                caps.push("reasoning");
+            return {
+                id: m.id,
+                name: m.id,
+                provider: "xai",
+                family: "grok",
+                context_window: Capabilities.getContextWindow(m.id),
+                max_output_tokens: null,
+                modalities: { input: ["text", "image"], output: ["text"] },
+                capabilities: caps,
+                pricing: {}
+            };
+        });
+    }
+}

package/dist/providers/xai/Streaming.d.ts

@@ -0,0 +1,8 @@
+import { ChatRequest, ChatChunk } from "../Provider.js";
+export declare class XAIStreaming {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ChatRequest, controller?: AbortController): AsyncGenerator<ChatChunk>;
+}
+//# sourceMappingURL=Streaming.d.ts.map

package/dist/providers/xai/Streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Streaming.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/Streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAOxD,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG1B,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,SAAS,CAAC;CA2L9F"}

package/dist/providers/xai/Streaming.js

@@ -0,0 +1,167 @@
+import { APIError } from "../../errors/index.js";
+import { logger } from "../../utils/logger.js";
+import { handleXAIError } from "./Errors.js";
+import { mapSystemMessages } from "../utils.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+export class XAIStreaming {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async *execute(request, controller) {
+        const abortController = controller || new AbortController();
+        const { model, messages, tools, max_tokens, response_format, thinking: _thinking, headers: _headers, requestTimeout, ...rest } = request;
+        const mappedMessages = mapSystemMessages(messages, false);
+        const body = {
+            model,
+            messages: mappedMessages,
+            stream: true,
+            ...rest
+        };
+        if (max_tokens)
+            body.max_tokens = max_tokens;
+        if (tools && tools.length > 0)
+            body.tools = tools;
+        if (response_format)
+            body.response_format = response_format;
+        // xAI supports include_usage
+        body.stream_options = { include_usage: true };
+        let done = false;
+        // Track tool calls being built across chunks
+        const toolCallsMap = new Map();
+        try {
+            const url = `${this.baseUrl}/chat/completions`;
+            logger.logRequest("xAI", "POST", url, body);
+            const response = await fetchWithTimeout(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                    ...request.headers
+                },
+                body: JSON.stringify(body),
+                signal: abortController.signal
+            }, requestTimeout);
+            if (!response.ok) {
+                await handleXAIError(response, model);
+            }
+            logger.debug("xAI streaming started", {
+                status: response.status,
+                statusText: response.statusText
+            });
+            if (!response.body) {
+                throw new Error("No response body for streaming");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { value, done: readerDone } = await reader.read();
+                if (readerDone)
+                    break;
+                const chunk = decoder.decode(value, { stream: true });
+                buffer += chunk;
+                const lines = buffer.split("\n\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    let trimmed = line.trim();
+                    // Handle carriage returns
+                    if (trimmed.endsWith("\r")) {
+                        trimmed = trimmed.substring(0, trimmed.length - 1);
+                    }
+                    if (!trimmed.startsWith("data: "))
+                        continue;
+                    const data = trimmed.replace("data: ", "").trim();
+                    if (data === "[DONE]") {
+                        done = true;
+                        // Yield final tool calls if any were accumulated
+                        if (toolCallsMap.size > 0) {
+                            const toolCalls = Array.from(toolCallsMap.values()).map((tc) => ({
+                                id: tc.id,
+                                type: "function",
+                                function: {
+                                    name: tc.function.name,
+                                    arguments: tc.function.arguments
+                                }
+                            }));
+                            yield { content: "", tool_calls: toolCalls, done: true };
+                        }
+                        return;
+                    }
+                    try {
+                        const json = JSON.parse(data);
+                        // Check for errors in the data
+                        if (json.error) {
+                            throw new APIError("xAI", response.status, json.error.message || "Stream error");
+                        }
+                        const delta = json.choices?.[0]?.delta;
+                        const deltaContent = delta?.content;
+                        if (deltaContent) {
+                            yield {
+                                content: deltaContent || ""
+                            };
+                        }
+                        // Handle tool calls delta
+                        if (delta?.tool_calls) {
+                            for (const toolCallDelta of delta.tool_calls) {
+                                const index = toolCallDelta.index;
+                                if (!toolCallsMap.has(index)) {
+                                    toolCallsMap.set(index, {
+                                        id: toolCallDelta.id || "",
+                                        type: "function",
+                                        function: {
+                                            name: toolCallDelta.function?.name || "",
+                                            arguments: toolCallDelta.function?.arguments || ""
+                                        }
+                                    });
+                                }
+                                else {
+                                    const existing = toolCallsMap.get(index);
+                                    if (toolCallDelta.id)
+                                        existing.id = toolCallDelta.id;
+                                    if (toolCallDelta.function?.name) {
+                                        existing.function.name += toolCallDelta.function.name;
+                                    }
+                                    if (toolCallDelta.function?.arguments) {
+                                        existing.function.arguments += toolCallDelta.function.arguments;
+                                    }
+                                }
+                            }
+                        }
+                        // Handle usage
+                        if (json.usage) {
+                            const usage = {
+                                input_tokens: json.usage.prompt_tokens,
+                                output_tokens: json.usage.completion_tokens,
+                                total_tokens: json.usage.total_tokens
+                            };
+                            yield { content: "", usage };
+                        }
+                    }
+                    catch (e) {
+                        // Re-throw APIError
+                        if (e instanceof APIError)
+                            throw e;
+                        // Ignore other parse errors
+                    }
+                }
+            }
+            done = true;
+        }
+        catch (e) {
+            // Graceful exit on abort
+            if (e instanceof Error && e.name === "AbortError") {
+                return;
+            }
+            throw e;
+        }
+        finally {
+            // Cleanup: abort if user breaks early
+            if (!done) {
+                abortController.abort();
+            }
+        }
+    }
+}

package/dist/providers/xai/XAIProvider.d.ts

@@ -0,0 +1,37 @@
+import { Provider, ChatRequest, ChatResponse, ModelInfo, ChatChunk, ImageRequest, ImageResponse } from "../Provider.js";
+import { BaseProvider } from "../BaseProvider.js";
+export interface XAIProviderOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+export declare class XAIProvider extends BaseProvider implements Provider {
+    private readonly options;
+    private readonly baseUrl;
+    private readonly chatHandler;
+    private readonly streamingHandler;
+    private readonly modelsHandler;
+    private readonly imageHandler;
+    capabilities: {
+        supportsVision: (model: string) => boolean;
+        supportsTools: (model: string) => boolean;
+        supportsStructuredOutput: (model: string) => boolean;
+        supportsEmbeddings: (model: string) => boolean;
+        supportsImageGeneration: (model: string) => boolean;
+        supportsTranscription: (model: string) => boolean;
+        supportsModeration: (model: string) => boolean;
+        supportsReasoning: (model: string) => boolean;
+        supportsDeveloperRole: (_model: string) => boolean;
+        getContextWindow: (model: string) => number;
+    };
+    constructor(options: XAIProviderOptions);
+    get id(): string;
+    apiBase(): string;
+    headers(): Record<string, string>;
+    protected providerName(): string;
+    defaultModel(_feature?: string): string;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: ChatRequest): AsyncGenerator<ChatChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    paint(request: ImageRequest): Promise<ImageResponse>;
+}
+//# sourceMappingURL=XAIProvider.d.ts.map

package/dist/providers/xai/XAIProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XAIProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/XAIProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,SAAS,EACT,SAAS,EACT,YAAY,EACZ,aAAa,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAQlD,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,WAAY,SAAQ,YAAa,YAAW,QAAQ;IAoBnD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAnBpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAe;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAW;IAEjC,YAAY;gCACO,MAAM;+BACP,MAAM;0CACK,MAAM;oCACZ,MAAM;yCACD,MAAM;uCACR,MAAM;oCACT,MAAM;mCACP,MAAM;wCACD,MAAM;kCACZ,MAAM;MAChC;gBAE2B,OAAO,EAAE,kBAAkB;IASxD,IAAW,EAAE,IAAI,MAAM,CAEtB;IAEM,OAAO,IAAI,MAAM;IAIjB,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAOxC,SAAS,CAAC,YAAY,IAAI,MAAM;IAIhB,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAIjD,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAIhD,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC,SAAS,CAAC;IAIxD,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAIlC,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;CAG3D"}