@k2b/nessi 0.10.0-rc.0

package/ai/providers/mistral.js

@@ -0,0 +1,287 @@
+import { formatConnectionError, normalizeHttpError } from "../shared/errors.js";
+import { assertOnlySupportedFiles, buildAssistantMessage } from "../shared/messages.js";
+import { ensureRecord, safeJsonParse, stringifyJson } from "../shared/json.js";
+import { openSSEStream } from "../shared/stream-helpers.js";
+import { normalizeProviderStream } from "../shared/tool-stream-normalizer.js";
+import { createStrictToolCallIdFactory } from "../shared/tool-call-ids.js";
+import { toOpenAITools } from "../shared/tools.js";
+import { applyCredits, makeUsage } from "../shared/usage.js";
+const usageFromChunk = (chunk, options) => {
+    if (!chunk.usage)
+        return undefined;
+    return applyCredits(makeUsage(chunk.usage.prompt_tokens ?? 0, chunk.usage.completion_tokens ?? 0), options?.creditsPerInputToken, options?.creditsPerOutputToken);
+};
+const convertMessages = (messages, systemPrompt, options) => {
+    const out = [];
+    const pendingToolIds = new Map();
+    const makeStrictId = options?.normalizeToolCallIds === "strict9" ? createStrictToolCallIdFactory() : null;
+    if (systemPrompt)
+        out.push({ role: "system", content: systemPrompt });
+    for (const message of messages) {
+        if (message.role === "user") {
+            assertOnlySupportedFiles(message.content, true, "mistral");
+            const parts = message.content.map((part) => {
+                if (typeof part === "string")
+                    return { type: "text", text: part };
+                if (part.type === "text")
+                    return { type: "text", text: part.text };
+                return { type: "image_url", image_url: { url: `data:${part.mediaType};base64,${part.data}` } };
+            });
+            if (parts.length === 1 && parts[0]?.type === "text")
+                out.push({ role: "user", content: parts[0].text });
+            else
+                out.push({ role: "user", content: parts });
+            continue;
+        }
+        if (message.role === "assistant") {
+            let text = "";
+            const toolCalls = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    text += block.text;
+                else if (block.type === "tool_call") {
+                    const mappedId = makeStrictId ? makeStrictId(block.id) : block.id;
+                    if (makeStrictId) {
+                        const queue = pendingToolIds.get(block.id) ?? [];
+                        queue.push(mappedId);
+                        pendingToolIds.set(block.id, queue);
+                    }
+                    toolCalls.push({
+                        id: mappedId,
+                        type: "function",
+                        function: { name: block.name, arguments: stringifyJson(block.args) },
+                    });
+                }
+            }
+            const next = { role: "assistant", content: text || null };
+            if (toolCalls.length > 0)
+                next.tool_calls = toolCalls;
+            out.push(next);
+            continue;
+        }
+        const queue = pendingToolIds.get(message.callId);
+        const mappedId = makeStrictId ? queue?.shift() : message.callId;
+        if (!mappedId)
+            continue;
+        if (makeStrictId && queue && queue.length === 0)
+            pendingToolIds.delete(message.callId);
+        out.push({
+            role: "tool",
+            content: stringifyJson(message.result),
+            name: message.name,
+            tool_call_id: mappedId,
+        });
+    }
+    return out;
+};
+const mapFinishReason = (reason, hasTools) => {
+    if (reason === "tool_calls")
+        return "tool_use";
+    if (reason === "length")
+        return "max_tokens";
+    if (hasTools)
+        return "tool_use";
+    return "stop";
+};
+const responseFormatName = (name) => {
+    const safe = (name ?? "structured_output").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+    return safe || "structured_output";
+};
+const applyResponseFormat = (body, request) => {
+    if (!request.responseFormat)
+        return;
+    body.response_format = {
+        type: "json_schema",
+        json_schema: {
+            name: responseFormatName(request.responseFormat.name),
+            schema: request.responseFormat.schema,
+            strict: true,
+        },
+    };
+};
+export const mistral = (model, options) => {
+    const baseURL = (options?.baseURL ?? "https://api.mistral.ai/v1").replace(/\/+$/, "");
+    const resolveTemperature = (request) => request.temperature ?? options?.temperature;
+    return {
+        name: "mistral",
+        family: "mistral",
+        model,
+        contextWindow: options?.contextWindow ?? 128_000,
+        capabilities: {
+            streaming: true,
+            tools: true,
+            images: true,
+            thinking: false,
+            usage: true,
+            structuredOutput: true,
+        },
+        async complete(request) {
+            const body = {
+                model,
+                messages: convertMessages(request.messages, request.systemPrompt, options),
+                stream: false,
+            };
+            if (request.tools?.length) {
+                body.tools = toOpenAITools(request.tools);
+                body.parallel_tool_calls = true;
+            }
+            applyResponseFormat(body, request);
+            const temperature = resolveTemperature(request);
+            if (temperature !== undefined)
+                body.temperature = temperature;
+            if (request.maxOutputTokens !== undefined)
+                body.max_tokens = request.maxOutputTokens;
+            const response = await fetch(`${baseURL}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${options?.apiKey ?? globalThis.process?.env?.MISTRAL_API_KEY ?? ""}`,
+                },
+                body: JSON.stringify(body),
+                signal: request.signal,
+            }).catch((error) => {
+                throw new Error(formatConnectionError("mistral", error));
+            });
+            if (!response.ok) {
+                const normalized = await normalizeHttpError("mistral", response);
+                throw new Error(normalized.error);
+            }
+            const payload = safeJsonParse(await response.text());
+            if (!payload)
+                throw new Error("mistral returned invalid JSON.");
+            const choice = payload.choices?.[0];
+            const toolCalls = (choice?.message?.tool_calls ?? []).map((call, index) => ({
+                type: "tool_call",
+                id: call.id ?? `mistral-${index}`,
+                name: call.function?.name ?? "",
+                args: ensureRecord(safeJsonParse(call.function?.arguments ?? "{}")),
+            }));
+            const usage = usageFromChunk(payload, options);
+            const finishReason = mapFinishReason(choice?.finish_reason, toolCalls.length > 0);
+            return {
+                message: buildAssistantMessage(model, choice?.message?.content ?? "", "", toolCalls, usage, finishReason),
+                usage,
+                finishReason,
+                providerMeta: { model },
+            };
+        },
+        stream(request) {
+            const raw = async function* () {
+                const body = {
+                    model,
+                    messages: convertMessages(request.messages, request.systemPrompt, options),
+                    stream: true,
+                };
+                if (request.tools?.length) {
+                    body.tools = toOpenAITools(request.tools);
+                    body.parallel_tool_calls = true;
+                }
+                applyResponseFormat(body, request);
+                const temperature = resolveTemperature(request);
+                if (temperature !== undefined)
+                    body.temperature = temperature;
+                if (request.maxOutputTokens !== undefined)
+                    body.max_tokens = request.maxOutputTokens;
+                const result = await openSSEStream(`${baseURL}/chat/completions`, {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${options?.apiKey ?? globalThis.process?.env?.MISTRAL_API_KEY ?? ""}`,
+                }, body, "mistral", request.signal, undefined, options?.timeouts);
+                if (!result.ok) {
+                    yield result.error;
+                    return;
+                }
+                const buffers = new Map();
+                let latestUsage;
+                let latestFinishReason;
+                const startToolCall = function* (buffer) {
+                    if (buffer.started || !buffer.name.trim())
+                        return;
+                    buffer.started = true;
+                    yield { type: "tool_start", callId: buffer.callId, name: buffer.name };
+                    if (buffer.argsBuffer)
+                        yield { type: "tool_delta", callId: buffer.callId, argsDelta: buffer.argsBuffer };
+                };
+                const flush = function* () {
+                    for (const [, buffer] of buffers) {
+                        yield* startToolCall(buffer);
+                        yield {
+                            type: "tool_call",
+                            callId: buffer.callId,
+                            name: buffer.name,
+                            args: ensureRecord(safeJsonParse(buffer.argsBuffer || "{}")),
+                        };
+                    }
+                    buffers.clear();
+                };
+                for await (const event of result.events) {
+                    if (event.data === "[DONE]")
+                        break;
+                    const chunk = safeJsonParse(event.data);
+                    if (!chunk)
+                        continue;
+                    const choice = chunk.choices?.[0];
+                    const usage = usageFromChunk(chunk, options);
+                    if (!choice) {
+                        if (usage) {
+                            latestUsage = usage;
+                            yield { type: "usage", usage };
+                        }
+                        continue;
+                    }
+                    if (choice.delta.content)
+                        yield { type: "text", delta: choice.delta.content };
+                    if (choice.delta.tool_calls) {
+                        for (const toolCall of choice.delta.tool_calls) {
+                            const existing = buffers.get(toolCall.index);
+                            if (!existing) {
+                                const callId = toolCall.id ?? `mistral-${toolCall.index}`;
+                                const name = toolCall.function?.name ?? "";
+                                const argsDelta = toolCall.function?.arguments ?? "";
+                                const buffer = {
+                                    callId,
+                                    name,
+                                    argsBuffer: argsDelta,
+                                    started: false,
+                                };
+                                buffers.set(toolCall.index, buffer);
+                                yield* startToolCall(buffer);
+                            }
+                            else {
+                                if (toolCall.function?.name)
+                                    existing.name = toolCall.function.name;
+                                const argsDelta = toolCall.function?.arguments ?? "";
+                                if (argsDelta)
+                                    existing.argsBuffer += argsDelta;
+                                const wasStarted = existing.started;
+                                yield* startToolCall(existing);
+                                if (wasStarted && argsDelta) {
+                                    yield { type: "tool_delta", callId: existing.callId, argsDelta };
+                                }
+                            }
+                        }
+                    }
+                    if (choice.finish_reason === "tool_calls") {
+                        yield* flush();
+                    }
+                    latestFinishReason = mapFinishReason(choice.finish_reason, false);
+                    if (usage) {
+                        latestUsage = usage;
+                        yield { type: "usage", usage };
+                    }
+                }
+                if (buffers.size > 0) {
+                    latestFinishReason = "tool_use";
+                    yield* flush();
+                }
+                if (latestFinishReason) {
+                    yield {
+                        type: "usage",
+                        usage: latestUsage ?? makeUsage(),
+                        finishReason: latestFinishReason,
+                    };
+                }
+            };
+            return normalizeProviderStream(raw(), { suppressTextAfterMalformedTool: true });
+        },
+    };
+};

package/ai/providers/ollama.d.ts

@@ -0,0 +1,10 @@
+import type { Provider, ProviderTimeouts } from "../types.js";
+export type OllamaOptions = {
+    baseURL?: string;
+    contextWindow?: number;
+    temperature?: number;
+    creditsPerInputToken?: number;
+    creditsPerOutputToken?: number;
+    timeouts?: ProviderTimeouts;
+};
+export declare const ollama: (model: string, options?: OllamaOptions) => Provider;

package/ai/providers/ollama.js

@@ -0,0 +1,241 @@
+import { formatConnectionError, normalizeHttpError } from "../shared/errors.js";
+import { assertOnlySupportedFiles, buildAssistantMessage } from "../shared/messages.js";
+import { parseNDJSON } from "../shared/ndjson.js";
+import { ensureRecord, safeJsonParse, stringifyJson } from "../shared/json.js";
+import { normalizeProviderStream } from "../shared/tool-stream-normalizer.js";
+import { toOllamaTools } from "../shared/tools.js";
+import { applyCredits, makeUsage } from "../shared/usage.js";
+const convertMessages = (messages, systemPrompt) => {
+    const out = [];
+    if (systemPrompt)
+        out.push({ role: "system", content: systemPrompt });
+    for (const message of messages) {
+        if (message.role === "user") {
+            assertOnlySupportedFiles(message.content, true, "ollama");
+            let text = "";
+            const images = [];
+            for (const part of message.content) {
+                if (typeof part === "string")
+                    text += part;
+                else if (part.type === "text")
+                    text += part.text;
+                else
+                    images.push(part.data);
+            }
+            const next = { role: "user", content: text };
+            if (images.length > 0)
+                next.images = images;
+            out.push(next);
+        }
+        else if (message.role === "assistant") {
+            let text = "";
+            const toolCalls = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    text += block.text;
+                else if (block.type === "tool_call") {
+                    toolCalls.push({ function: { name: block.name, arguments: block.args } });
+                }
+            }
+            const next = { role: "assistant", content: text };
+            if (toolCalls.length > 0)
+                next.tool_calls = toolCalls;
+            out.push(next);
+        }
+        else {
+            out.push({
+                role: "tool",
+                name: message.name,
+                tool_call_id: message.callId,
+                content: stringifyJson({
+                    tool_call_id: message.callId,
+                    name: message.name,
+                    result: message.result,
+                }),
+            });
+        }
+    }
+    return out;
+};
+const usageFromResponse = (response, options) => applyCredits(makeUsage(response.prompt_eval_count ?? 0, response.eval_count ?? 0), options?.creditsPerInputToken, options?.creditsPerOutputToken);
+const toolCallsFromResponse = (response) => (response.message?.tool_calls ?? []).map((toolCall, index) => ({
+    type: "tool_call",
+    id: `ollama-${index}`,
+    name: toolCall.function.name,
+    args: toolCall.function.arguments,
+}));
+export const ollama = (model, options) => {
+    const baseURL = (options?.baseURL ?? "http://localhost:11434").replace(/\/+$/, "");
+    const contextWindow = options?.contextWindow ?? 128_000;
+    const resolveTemperature = (request) => request.temperature ?? options?.temperature;
+    return {
+        name: "ollama",
+        family: "ollama",
+        model,
+        contextWindow,
+        capabilities: {
+            streaming: true,
+            tools: true,
+            images: true,
+            thinking: false,
+            usage: true,
+            structuredOutput: true,
+        },
+        async complete(request) {
+            const body = {
+                model,
+                messages: convertMessages(request.messages, request.systemPrompt),
+                stream: false,
+            };
+            if (request.tools?.length)
+                body.tools = toOllamaTools(request.tools);
+            if (request.responseFormat)
+                body.format = request.responseFormat.schema;
+            const temperature = resolveTemperature(request);
+            if (temperature !== undefined)
+                body.options = { temperature };
+            const response = await fetch(`${baseURL}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: request.signal,
+            }).catch((error) => {
+                throw new Error(formatConnectionError("ollama", error));
+            });
+            if (!response.ok) {
+                const normalized = await normalizeHttpError("ollama", response);
+                throw new Error(normalized.error);
+            }
+            const payload = safeJsonParse(await response.text());
+            if (!payload)
+                throw new Error("ollama returned invalid JSON.");
+            const usage = usageFromResponse(payload, options);
+            const toolCalls = toolCallsFromResponse(payload);
+            const finishReason = toolCalls.length > 0 ? "tool_use" : "stop";
+            return {
+                message: buildAssistantMessage(model, payload.message?.content ?? "", "", toolCalls, usage, finishReason),
+                usage,
+                finishReason,
+                providerMeta: { model },
+            };
+        },
+        stream(request) {
+            const raw = async function* () {
+                const body = {
+                    model,
+                    messages: convertMessages(request.messages, request.systemPrompt),
+                    stream: true,
+                };
+                if (request.tools?.length)
+                    body.tools = toOllamaTools(request.tools);
+                if (request.responseFormat)
+                    body.format = request.responseFormat.schema;
+                const temperature = resolveTemperature(request);
+                if (temperature !== undefined)
+                    body.options = { temperature };
+                let response;
+                const controller = new AbortController();
+                const abortExternal = () => controller.abort(request.signal?.reason);
+                const cleanupExternalAbort = () => {
+                    if (request.signal)
+                        request.signal.removeEventListener("abort", abortExternal);
+                };
+                if (request.signal) {
+                    if (request.signal.aborted)
+                        controller.abort(request.signal.reason);
+                    else
+                        request.signal.addEventListener("abort", abortExternal, { once: true });
+                }
+                let firstByteTimeout;
+                const firstByteDeadline = options?.timeouts?.firstByteMs && options.timeouts.firstByteMs > 0
+                    ? Date.now() + options.timeouts.firstByteMs
+                    : undefined;
+                try {
+                    response = await Promise.race([
+                        fetch(`${baseURL}/api/chat`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify(body),
+                            signal: controller.signal,
+                        }),
+                        new Promise((_, reject) => {
+                            if (!options?.timeouts?.firstByteMs || options.timeouts.firstByteMs <= 0)
+                                return;
+                            firstByteTimeout = setTimeout(() => {
+                                controller.abort();
+                                reject({
+                                    scope: "provider_first_byte",
+                                    message: `ollama first byte timeout after ${options.timeouts.firstByteMs}ms.`,
+                                });
+                            }, options.timeouts.firstByteMs);
+                        }),
+                    ]);
+                }
+                catch (error) {
+                    cleanupExternalAbort();
+                    if (error && typeof error === "object" && error.scope === "provider_first_byte") {
+                        yield {
+                            type: "timeout",
+                            scope: "provider_first_byte",
+                            message: String(error.message ?? "ollama first byte timeout"),
+                            retryable: true,
+                        };
+                        return;
+                    }
+                    yield {
+                        type: "error",
+                        error: formatConnectionError("ollama", error),
+                        retryable: true,
+                    };
+                    return;
+                }
+                finally {
+                    if (firstByteTimeout)
+                        clearTimeout(firstByteTimeout);
+                }
+                if (!response.ok) {
+                    const normalized = await normalizeHttpError("ollama", response);
+                    cleanupExternalAbort();
+                    yield { type: "error", ...normalized };
+                    return;
+                }
+                const reader = response.body?.getReader();
+                if (!reader) {
+                    cleanupExternalAbort();
+                    yield { type: "error", error: "ollama response body missing", retryable: false };
+                    return;
+                }
+                let toolCounter = 0;
+                const streamTimeouts = options?.timeouts ? { ...options.timeouts } : undefined;
+                if (firstByteDeadline && streamTimeouts) {
+                    streamTimeouts.firstByteMs = Math.max(1, firstByteDeadline - Date.now());
+                }
+                try {
+                    for await (const chunk of parseNDJSON(reader, streamTimeouts)) {
+                        if (chunk.message?.content)
+                            yield { type: "text", delta: chunk.message.content };
+                        for (const toolCall of chunk.message?.tool_calls ?? []) {
+                            const callId = `ollama-${toolCounter++}`;
+                            yield { type: "tool_start", callId, name: toolCall.function.name };
+                            yield {
+                                type: "tool_call",
+                                callId,
+                                name: toolCall.function.name,
+                                args: ensureRecord(toolCall.function.arguments),
+                            };
+                        }
+                        if (chunk.done) {
+                            yield { type: "usage", usage: usageFromResponse(chunk, options) };
+                        }
+                    }
+                }
+                finally {
+                    cleanupExternalAbort();
+                    controller.abort();
+                    await reader.cancel().catch(() => { });
+                }
+            };
+            return normalizeProviderStream(raw(), { suppressTextAfterMalformedTool: true });
+        },
+    };
+};

package/ai/providers/openai-compatible.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAICompatibleConfig, Provider } from "../types.js";
+export declare const openAICompatible: (config: OpenAICompatibleConfig) => Provider;