@node-llm/core 1.12.0 → 1.14.0

package/dist/providers/mistral/Moderation.d.ts

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

package/dist/providers/mistral/Moderation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Moderation.d.ts","sourceRoot":"","sources":["../../../src/providers/mistral/Moderation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAoB,MAAM,gBAAgB,CAAC;AAgBzF,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG3B,OAAO,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiDvE"}

package/dist/providers/mistral/Moderation.js

@@ -0,0 +1,49 @@
+import { handleMistralError } from "./Errors.js";
+import { logger } from "../../utils/logger.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+const DEFAULT_MODERATION_MODEL = "mistral-moderation-latest";
+export class MistralModeration {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        // Mistral's moderation API expects input as a list of conversations
+        // Each conversation is a list of messages with role and content
+        const inputs = Array.isArray(request.input) ? request.input : [request.input];
+        // Convert strings to chat message format
+        const formattedInput = inputs.map((text) => [{ role: "user", content: text }]);
+        const body = {
+            model: request.model || DEFAULT_MODERATION_MODEL,
+            input: formattedInput
+        };
+        const url = `${this.baseUrl}/chat/moderations`;
+        logger.logRequest("Mistral", "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 handleMistralError(response, request.model || DEFAULT_MODERATION_MODEL);
+        }
+        const json = (await response.json());
+        logger.logResponse("Mistral", response.status, response.statusText, json);
+        // Map Mistral's response format to our standard format
+        const results = json.results.map((result) => ({
+            flagged: Object.values(result.categories).some((v) => v === true),
+            categories: result.categories,
+            category_scores: result.category_scores
+        }));
+        return {
+            id: json.id,
+            model: json.model,
+            results
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+import { ChatRequest, ChatChunk } from "../Provider.js";
+export declare class MistralStreaming {
+    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/mistral/Streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Streaming.d.ts","sourceRoot":"","sources":["../../../src/providers/mistral/Streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAOxD,qBAAa,gBAAgB;IAEzB,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;CAgO9F"}

package/dist/providers/mistral/Streaming.js

@@ -0,0 +1,203 @@
+import { APIError } from "../../errors/index.js";
+import { logger } from "../../utils/logger.js";
+import { handleMistralError } from "./Errors.js";
+import { mapSystemMessages } from "../utils.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+export class MistralStreaming {
+    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, signal: _signal, ...rest } = request;
+        const mappedMessages = mapSystemMessages(messages, false);
+        // Sanitize messages - remove internal properties that Mistral API doesn't accept
+        const sanitizedMessages = mappedMessages.map((msg) => {
+            const m = msg;
+            const { role, content, tool_calls, tool_call_id, name } = m;
+            const clean = { role, content };
+            if (tool_calls)
+                clean.tool_calls = tool_calls;
+            if (tool_call_id)
+                clean.tool_call_id = tool_call_id;
+            if (name)
+                clean.name = name;
+            return clean;
+        });
+        const body = {
+            model,
+            messages: sanitizedMessages,
+            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;
+        let done = false;
+        // Track tool calls being built across chunks
+        const toolCallsMap = new Map();
+        try {
+            const url = `${this.baseUrl}/chat/completions`;
+            logger.logRequest("Mistral", "POST", url, body);
+            const response = await fetchWithTimeout(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                    Accept: "text/event-stream",
+                    ...request.headers
+                },
+                body: JSON.stringify(body),
+                signal: abortController.signal
+            }, requestTimeout);
+            if (!response.ok) {
+                await handleMistralError(response, model);
+            }
+            logger.debug("Mistral 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");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    let trimmed = line.trim();
+                    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
+                            };
+                        }
+                        else {
+                            yield { content: "", done: true };
+                        }
+                        break;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        const delta = choice?.delta;
+                        // Handle usage in final chunk
+                        if (parsed.usage) {
+                            yield {
+                                content: "",
+                                usage: {
+                                    input_tokens: parsed.usage.prompt_tokens ?? 0,
+                                    output_tokens: parsed.usage.completion_tokens ?? 0,
+                                    total_tokens: parsed.usage.total_tokens ?? 0
+                                },
+                                done: false
+                            };
+                            continue;
+                        }
+                        // Handle tool calls
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const index = tc.index ?? 0;
+                                let existing = toolCallsMap.get(index);
+                                if (!existing) {
+                                    existing = {
+                                        id: tc.id || "",
+                                        type: tc.type || "function",
+                                        function: {
+                                            name: tc.function?.name || "",
+                                            arguments: ""
+                                        }
+                                    };
+                                    toolCallsMap.set(index, existing);
+                                }
+                                if (tc.id)
+                                    existing.id = tc.id;
+                                if (tc.function?.name)
+                                    existing.function.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    existing.function.arguments += tc.function.arguments;
+                            }
+                            continue;
+                        }
+                        // Handle content
+                        const content = delta?.content || "";
+                        if (content) {
+                            yield {
+                                content,
+                                done: false,
+                                finish_reason: choice?.finish_reason ?? null
+                            };
+                        }
+                    }
+                    catch {
+                        // Skip malformed JSON
+                        logger.debug("Mistral streaming: failed to parse chunk", { data });
+                    }
+                }
+            }
+            // Final chunk if not already sent
+            if (!done) {
+                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
+                    };
+                }
+                else {
+                    yield { content: "", done: true };
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof APIError)
+                throw error;
+            const isAbort = error instanceof Error &&
+                (error.name === "AbortError" || error.message.includes("aborted"));
+            if (isAbort) {
+                yield { content: "", done: true };
+                return;
+            }
+            throw error;
+        }
+    }
+}

package/dist/providers/mistral/Transcription.d.ts

@@ -0,0 +1,9 @@
+import { TranscriptionRequest, TranscriptionResponse } from "../Provider.js";
+export declare class MistralTranscription {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+    private getMimeType;
+}
+//# sourceMappingURL=Transcription.d.ts.map

package/dist/providers/mistral/Transcription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcription.d.ts","sourceRoot":"","sources":["../../../src/providers/mistral/Transcription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAwB,MAAM,gBAAgB,CAAC;AAqBnG,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;IAG3B,OAAO,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA2D5E,OAAO,CAAC,WAAW;CAmBpB"}

package/dist/providers/mistral/Transcription.js

@@ -0,0 +1,76 @@
+import { handleMistralError } from "./Errors.js";
+import { AudioUtils } from "../../utils/audio.js";
+import { logger } from "../../utils/logger.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+const DEFAULT_TRANSCRIPTION_MODEL = "voxtral-mini-latest";
+export class MistralTranscription {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const formData = new FormData();
+        const { data, fileName, duration: estimatedDuration } = await AudioUtils.load(request.file);
+        const mimeType = this.getMimeType(fileName);
+        const file = new File([data], fileName, { type: mimeType });
+        formData.append("file", file);
+        formData.append("model", request.model || DEFAULT_TRANSCRIPTION_MODEL);
+        formData.append("response_format", "verbose_json");
+        if (request.prompt) {
+            formData.append("prompt", request.prompt);
+        }
+        if (request.language) {
+            formData.append("language", request.language);
+        }
+        const url = `${this.baseUrl}/audio/transcriptions`;
+        logger.logRequest("Mistral", "POST", url, {
+            model: request.model || DEFAULT_TRANSCRIPTION_MODEL,
+            file: fileName
+        });
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: formData
+        }, request.requestTimeout);
+        if (!response.ok) {
+            await handleMistralError(response, request.model || DEFAULT_TRANSCRIPTION_MODEL);
+        }
+        const json = (await response.json());
+        logger.logResponse("Mistral", response.status, response.statusText, json);
+        const segments = json.segments?.map((s) => ({
+            id: s.id,
+            start: s.start,
+            end: s.end,
+            text: s.text
+        }));
+        return {
+            text: json.text,
+            model: json.model || request.model || DEFAULT_TRANSCRIPTION_MODEL,
+            duration: json.duration || estimatedDuration,
+            segments
+        };
+    }
+    getMimeType(fileName) {
+        const ext = fileName.toLowerCase().split(".").pop();
+        switch (ext) {
+            case "wav":
+                return "audio/wav";
+            case "mp3":
+                return "audio/mpeg";
+            case "m4a":
+                return "audio/mp4";
+            case "flac":
+                return "audio/flac";
+            case "ogg":
+                return "audio/ogg";
+            case "webm":
+                return "audio/webm";
+            default:
+                return "audio/mpeg";
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+export * from "./MistralProvider.js";
+export * from "./Chat.js";
+export * from "./Models.js";
+export * from "./Capabilities.js";
+export * from "./Embedding.js";
+export * from "./Transcription.js";
+export * from "./Moderation.js";
+export declare function registerMistralProvider(): void;
+export declare const ensureMistralRegistered: typeof registerMistralProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/mistral/index.ts"],"names":[],"mappings":"AAIA,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAIhC,wBAAgB,uBAAuB,SAkBtC;AAED,eAAO,MAAM,uBAAuB,gCAA0B,CAAC"}

package/dist/providers/mistral/index.js

@@ -0,0 +1,26 @@
+import { config as globalConfig } from "../../config.js";
+import { providerRegistry } from "../registry.js";
+import { MistralProvider } from "./MistralProvider.js";
+export * from "./MistralProvider.js";
+export * from "./Chat.js";
+export * from "./Models.js";
+export * from "./Capabilities.js";
+export * from "./Embedding.js";
+export * from "./Transcription.js";
+export * from "./Moderation.js";
+let registered = false;
+export function registerMistralProvider() {
+    if (registered)
+        return;
+    providerRegistry.register("mistral", (config) => {
+        const cfg = config || globalConfig;
+        const apiKey = cfg.mistralApiKey;
+        const baseUrl = cfg.mistralApiBase;
+        if (!apiKey) {
+            throw new Error("mistral_api_key is not set in config or MISTRAL_API_KEY environment variable");
+        }
+        return new MistralProvider({ apiKey, baseUrl });
+    });
+    registered = true;
+}
+export const ensureMistralRegistered = registerMistralProvider;

package/dist/providers/registry.d.ts

@@ -6,6 +6,8 @@ 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 { registerMistralProvider } from "./mistral/index.js";
 import { NodeLLMConfig } from "../config.js";
 type ProviderFactory = (config?: NodeLLMConfig) => Provider;
 export type ProviderInterceptor = (provider: Provider) => Provider;
@@ -46,5 +48,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, registerMistralProvider };
 //# 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;AACrD,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,EACvB,mBAAmB,EACnB,uBAAuB,EACxB,CAAC"}

package/dist/providers/registry.js

@@ -5,6 +5,8 @@ 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 { registerMistralProvider } from "./mistral/index.js";
 class ProviderRegistry {
     providers = new Map();
     globalInterceptor;
@@ -64,4 +66,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, registerMistralProvider };

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