@node-llm/core 1.12.0 → 1.14.0

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"}

package/dist/providers/xai/XAIProvider.js

@@ -0,0 +1,66 @@
+import { BaseProvider } from "../BaseProvider.js";
+import { DEFAULT_XAI_BASE_URL } from "../../constants.js";
+import { XAIChat } from "./Chat.js";
+import { XAIModels } from "./Models.js";
+import { XAIStreaming } from "./Streaming.js";
+import { Capabilities } from "./Capabilities.js";
+import { XAIImage } from "./Image.js";
+export class XAIProvider extends BaseProvider {
+    options;
+    baseUrl;
+    chatHandler;
+    streamingHandler;
+    modelsHandler;
+    imageHandler;
+    capabilities = {
+        supportsVision: (model) => Capabilities.supportsVision(model),
+        supportsTools: (model) => Capabilities.supportsTools(model),
+        supportsStructuredOutput: (model) => Capabilities.supportsStructuredOutput(model),
+        supportsEmbeddings: (model) => Capabilities.supportsEmbeddings(model),
+        supportsImageGeneration: (model) => Capabilities.supportsImageGeneration(model),
+        supportsTranscription: (model) => Capabilities.supportsTranscription(model),
+        supportsModeration: (model) => Capabilities.supportsModeration(model),
+        supportsReasoning: (model) => Capabilities.supportsReasoning(model),
+        supportsDeveloperRole: (_model) => false,
+        getContextWindow: (model) => Capabilities.getContextWindow(model)
+    };
+    constructor(options) {
+        super();
+        this.options = options;
+        this.baseUrl = options.baseUrl ?? DEFAULT_XAI_BASE_URL;
+        this.chatHandler = new XAIChat(this.baseUrl, options.apiKey);
+        this.streamingHandler = new XAIStreaming(this.baseUrl, options.apiKey);
+        this.modelsHandler = new XAIModels(this.baseUrl, options.apiKey);
+        this.imageHandler = new XAIImage(this.baseUrl, options.apiKey);
+    }
+    get id() {
+        return "xai";
+    }
+    apiBase() {
+        return this.baseUrl;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.options.apiKey}`,
+            "Content-Type": "application/json"
+        };
+    }
+    providerName() {
+        return "xAI";
+    }
+    defaultModel(_feature) {
+        return "grok-2";
+    }
+    async chat(request) {
+        return this.chatHandler.execute(request);
+    }
+    async *stream(request) {
+        yield* this.streamingHandler.execute(request);
+    }
+    async listModels() {
+        return this.modelsHandler.execute();
+    }
+    async paint(request) {
+        return this.imageHandler.execute(request);
+    }
+}

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

@@ -0,0 +1,7 @@
+import { NodeLLMConfig } from "../../config.js";
+export * from "./XAIProvider.js";
+/**
+ * Register the xAI provider.
+ */
+export declare function registerXAIProvider(config?: NodeLLMConfig): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/xai/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,cAAc,kBAAkB,CAAC;AAEjC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,aAAa,QAgBzD"}

package/dist/providers/xai/index.js

@@ -0,0 +1,19 @@
+import { providerRegistry } from "../registry.js";
+import { XAIProvider } from "./XAIProvider.js";
+export * from "./XAIProvider.js";
+/**
+ * Register the xAI provider.
+ */
+export function registerXAIProvider(config) {
+    providerRegistry.register("xai", (cfg) => {
+        const activeConfig = cfg || config;
+        const apiKey = activeConfig?.xaiApiKey;
+        if (!apiKey) {
+            throw new Error("xAI API key not found. Please provide 'xaiApiKey' in config or set XAI_API_KEY environment variable.");
+        }
+        return new XAIProvider({
+            apiKey,
+            baseUrl: activeConfig?.xaiApiBase
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@node-llm/core",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",