@k2b/nessi 0.10.0-rc.0

package/ai/providers/anthropic.js

@@ -0,0 +1,266 @@
+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 { toAnthropicTools } from "../shared/tools.js";
+import { applyCredits, makeUsage } from "../shared/usage.js";
+const mapFinishReason = (reason, hasTools) => {
+    if (reason === "tool_use")
+        return "tool_use";
+    if (reason === "max_tokens")
+        return "max_tokens";
+    if (hasTools)
+        return "tool_use";
+    return "stop";
+};
+const pushMessage = (messages, next) => {
+    const last = messages[messages.length - 1];
+    if (last?.role === next.role) {
+        last.content.push(...next.content);
+        return;
+    }
+    messages.push(next);
+};
+const convertMessages = (messages) => {
+    const out = [];
+    for (const message of messages) {
+        if (message.role === "user") {
+            assertOnlySupportedFiles(message.content, true, "anthropic");
+            const content = [];
+            for (const part of message.content) {
+                if (typeof part === "string")
+                    content.push({ type: "text", text: part });
+                else if (part.type === "text")
+                    content.push({ type: "text", text: part.text });
+                else
+                    content.push({
+                        type: "image",
+                        source: { type: "base64", media_type: part.mediaType, data: part.data },
+                    });
+            }
+            pushMessage(out, { role: "user", content });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const content = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    content.push({ type: "text", text: block.text });
+                else if (block.type === "tool_call") {
+                    content.push({
+                        type: "tool_use",
+                        id: block.id,
+                        name: block.name,
+                        input: block.args,
+                    });
+                }
+            }
+            pushMessage(out, { role: "assistant", content });
+            continue;
+        }
+        pushMessage(out, {
+            role: "user",
+            content: [{
+                    type: "tool_result",
+                    tool_use_id: message.callId,
+                    content: stringifyJson(message.result),
+                    is_error: message.isError,
+                }],
+        });
+    }
+    return out;
+};
+const resolveTemperature = (request, options) => request.temperature ?? options?.temperature;
+const usageFromValue = (usage, options) => applyCredits(makeUsage(usage?.input_tokens ?? 0, usage?.output_tokens ?? 0), options?.creditsPerInputToken, options?.creditsPerOutputToken);
+const mergeUsage = (current, usage, options) => {
+    if (!usage)
+        return current;
+    return applyCredits(makeUsage(usage.input_tokens ?? current.input, usage.output_tokens ?? current.output), options?.creditsPerInputToken, options?.creditsPerOutputToken);
+};
+const applyResponseFormat = (body, request) => {
+    if (!request.responseFormat)
+        return;
+    body.output_config = {
+        format: {
+            type: "json_schema",
+            schema: request.responseFormat.schema,
+        },
+    };
+};
+export const anthropic = (model, options) => {
+    const baseURL = (options?.baseURL ?? "https://api.anthropic.com").replace(/\/+$/, "");
+    const apiVersion = options?.apiVersion ?? "2023-06-01";
+    const maxOutputTokens = options?.maxOutputTokens ?? 1024;
+    return {
+        name: "anthropic",
+        family: "anthropic",
+        model,
+        contextWindow: options?.contextWindow ?? 200_000,
+        capabilities: {
+            streaming: true,
+            tools: true,
+            images: true,
+            thinking: false,
+            usage: true,
+            structuredOutput: true,
+        },
+        async complete(request) {
+            const body = {
+                model,
+                system: request.systemPrompt,
+                messages: convertMessages(request.messages),
+                max_tokens: request.maxOutputTokens ?? maxOutputTokens,
+            };
+            if (request.tools?.length)
+                body.tools = toAnthropicTools(request.tools);
+            applyResponseFormat(body, request);
+            const temperature = resolveTemperature(request, options);
+            if (temperature !== undefined)
+                body.temperature = temperature;
+            const response = await fetch(`${baseURL}/v1/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": options?.apiKey ?? globalThis.process?.env?.ANTHROPIC_API_KEY ?? "",
+                    "anthropic-version": apiVersion,
+                },
+                body: JSON.stringify(body),
+                signal: request.signal,
+            }).catch((error) => {
+                throw new Error(formatConnectionError("anthropic", error));
+            });
+            if (!response.ok) {
+                const normalized = await normalizeHttpError("anthropic", response);
+                throw new Error(normalized.error);
+            }
+            const payload = safeJsonParse(await response.text());
+            if (!payload)
+                throw new Error("anthropic returned invalid JSON.");
+            const text = (payload.content ?? [])
+                .filter((block) => block.type === "text")
+                .map((block) => block.text ?? "")
+                .join("");
+            const toolCalls = (payload.content ?? [])
+                .filter((block) => block.type === "tool_use")
+                .map((block) => ({
+                type: "tool_call",
+                id: block.id,
+                name: block.name,
+                args: block.input ?? {},
+            }));
+            const usage = usageFromValue(payload.usage, options);
+            const finishReason = mapFinishReason(payload.stop_reason, toolCalls.length > 0);
+            return {
+                message: buildAssistantMessage(model, text, "", toolCalls, usage, finishReason),
+                usage,
+                finishReason,
+                providerMeta: { model, requestId: payload.id },
+            };
+        },
+        stream(request) {
+            const raw = async function* () {
+                const body = {
+                    model,
+                    system: request.systemPrompt,
+                    messages: convertMessages(request.messages),
+                    max_tokens: request.maxOutputTokens ?? maxOutputTokens,
+                    stream: true,
+                };
+                if (request.tools?.length)
+                    body.tools = toAnthropicTools(request.tools);
+                applyResponseFormat(body, request);
+                const temperature = resolveTemperature(request, options);
+                if (temperature !== undefined)
+                    body.temperature = temperature;
+                const result = await openSSEStream(`${baseURL}/v1/messages`, {
+                    "Content-Type": "application/json",
+                    "x-api-key": options?.apiKey ?? globalThis.process?.env?.ANTHROPIC_API_KEY ?? "",
+                    "anthropic-version": apiVersion,
+                }, body, "anthropic", request.signal, undefined, options?.timeouts);
+                if (!result.ok) {
+                    yield result.error;
+                    return;
+                }
+                const toolBuffers = new Map();
+                let latestUsage = makeUsage();
+                let latestFinishReason;
+                let syntheticIndex = 0;
+                let sawToolCall = false;
+                for await (const event of result.events) {
+                    if (event.data === "[DONE]")
+                        break;
+                    const payload = safeJsonParse(event.data);
+                    if (!payload)
+                        continue;
+                    if (event.event === "message_start" && payload.message?.usage) {
+                        latestUsage = mergeUsage(latestUsage, payload.message.usage, options);
+                    }
+                    if (event.event === "content_block_start" && payload.content_block?.type === "tool_use") {
+                        const index = typeof payload.index === "number" ? payload.index : syntheticIndex++;
+                        const startInput = payload.content_block.input;
+                        const argsBuffer = startInput && Object.keys(startInput).length > 0 ? JSON.stringify(startInput) : "";
+                        toolBuffers.set(index, {
+                            callId: payload.content_block.id ?? `anthropic-${index}`,
+                            name: payload.content_block.name ?? "",
+                            argsBuffer,
+                        });
+                        sawToolCall = true;
+                        yield {
+                            type: "tool_start",
+                            callId: payload.content_block.id ?? `anthropic-${index}`,
+                            name: payload.content_block.name ?? "",
+                        };
+                        if (argsBuffer) {
+                            yield {
+                                type: "tool_delta",
+                                callId: payload.content_block.id ?? `anthropic-${index}`,
+                                argsDelta: argsBuffer,
+                            };
+                        }
+                    }
+                    if (event.event === "content_block_delta") {
+                        if (payload.delta?.type === "text_delta" && payload.delta.text) {
+                            yield { type: "text", delta: payload.delta.text };
+                        }
+                        else if (payload.delta?.type === "input_json_delta") {
+                            if (typeof payload.index !== "number")
+                                continue;
+                            const index = payload.index;
+                            const existing = toolBuffers.get(index);
+                            if (existing && payload.delta.partial_json) {
+                                existing.argsBuffer += payload.delta.partial_json;
+                                yield { type: "tool_delta", callId: existing.callId, argsDelta: payload.delta.partial_json };
+                            }
+                        }
+                    }
+                    if (event.event === "content_block_stop") {
+                        if (typeof payload.index !== "number")
+                            continue;
+                        const index = payload.index;
+                        const existing = toolBuffers.get(index);
+                        if (existing) {
+                            yield {
+                                type: "tool_call",
+                                callId: existing.callId,
+                                name: existing.name,
+                                args: ensureRecord(safeJsonParse(existing.argsBuffer || "{}")),
+                            };
+                            toolBuffers.delete(index);
+                        }
+                    }
+                    if (event.event === "message_delta" && payload.usage) {
+                        latestUsage = mergeUsage(latestUsage, payload.usage, options);
+                    }
+                    if (event.event === "message_delta" && payload.delta?.stop_reason) {
+                        latestFinishReason = mapFinishReason(payload.delta.stop_reason, sawToolCall || toolBuffers.size > 0);
+                    }
+                }
+                if (latestUsage.total > 0 || latestFinishReason) {
+                    yield { type: "usage", usage: latestUsage, finishReason: latestFinishReason };
+                }
+            };
+            return normalizeProviderStream(raw(), { suppressTextAfterMalformedTool: true });
+        },
+    };
+};

package/ai/providers/gemini.d.ts

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

package/ai/providers/gemini.js

@@ -0,0 +1,192 @@
+import { formatConnectionError, normalizeHttpError } from "../shared/errors.js";
+import { assertOnlySupportedFiles, buildAssistantMessage } from "../shared/messages.js";
+import { ensureRecord, safeJsonParse } from "../shared/json.js";
+import { openSSEStream } from "../shared/stream-helpers.js";
+import { normalizeProviderStream } from "../shared/tool-stream-normalizer.js";
+import { toGeminiTools } from "../shared/tools.js";
+import { applyCredits, makeUsage } from "../shared/usage.js";
+const convertMessages = (messages) => {
+    const out = [];
+    for (const message of messages) {
+        if (message.role === "user") {
+            assertOnlySupportedFiles(message.content, true, "gemini");
+            out.push({
+                role: "user",
+                parts: message.content.map((part) => {
+                    if (typeof part === "string")
+                        return { text: part };
+                    if (part.type === "text")
+                        return { text: part.text };
+                    return { inlineData: { mimeType: part.mediaType, data: part.data } };
+                }),
+            });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const parts = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    parts.push({ text: block.text });
+                else if (block.type === "tool_call") {
+                    parts.push({ functionCall: { name: block.name, args: block.args } });
+                }
+            }
+            out.push({ role: "model", parts });
+            continue;
+        }
+        out.push({
+            role: "user",
+            parts: [{
+                    functionResponse: {
+                        name: message.name,
+                        response: ensureRecord(message.result),
+                    },
+                }],
+        });
+    }
+    return out;
+};
+const usageFromResponse = (response, options) => applyCredits(makeUsage(response.usageMetadata?.promptTokenCount ?? 0, response.usageMetadata?.candidatesTokenCount ?? 0), options?.creditsPerInputToken, options?.creditsPerOutputToken);
+const mapFinishReason = (reason, hasTools) => {
+    if (reason === "MAX_TOKENS")
+        return "max_tokens";
+    if (hasTools)
+        return "tool_use";
+    return "stop";
+};
+const createRequestId = () => globalThis.crypto?.randomUUID?.() ?? `gemini-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+export const gemini = (model, options) => {
+    const baseURL = (options?.baseURL ?? "https://generativelanguage.googleapis.com/v1beta/models").replace(/\/+$/, "");
+    const apiKey = options?.apiKey ?? globalThis.process?.env?.GEMINI_API_KEY ?? globalThis.process?.env?.GOOGLE_API_KEY;
+    const urlFor = (path) => {
+        const key = apiKey ? `?key=${encodeURIComponent(apiKey)}` : "";
+        const alt = path === "streamGenerateContent" ? `${key ? "&" : "?"}alt=sse` : "";
+        return `${baseURL}/${model}:${path}${key}${alt}`;
+    };
+    const buildBody = (request) => {
+        const body = {
+            contents: convertMessages(request.messages),
+        };
+        if (request.systemPrompt) {
+            body.systemInstruction = { parts: [{ text: request.systemPrompt }] };
+        }
+        if (request.tools?.length)
+            body.tools = toGeminiTools(request.tools);
+        const generationConfig = {};
+        const temperature = request.temperature ?? options?.temperature;
+        if (temperature !== undefined)
+            generationConfig.temperature = temperature;
+        const maxOutputTokens = request.maxOutputTokens ?? options?.maxOutputTokens;
+        if (maxOutputTokens !== undefined)
+            generationConfig.maxOutputTokens = maxOutputTokens;
+        if (request.disableReasoning)
+            generationConfig.thinkingConfig = { thinkingBudget: 0 };
+        if (request.responseFormat) {
+            generationConfig.responseMimeType = "application/json";
+            generationConfig.responseJsonSchema = request.responseFormat.schema;
+        }
+        if (Object.keys(generationConfig).length > 0)
+            body.generationConfig = generationConfig;
+        return body;
+    };
+    return {
+        name: "gemini",
+        family: "gemini",
+        model,
+        contextWindow: options?.contextWindow ?? 1_000_000,
+        capabilities: {
+            streaming: true,
+            tools: true,
+            images: true,
+            thinking: false,
+            usage: true,
+            structuredOutput: true,
+        },
+        async complete(request) {
+            const requestId = createRequestId();
+            const response = await fetch(urlFor("generateContent"), {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(buildBody(request)),
+                signal: request.signal,
+            }).catch((error) => {
+                throw new Error(formatConnectionError("gemini", error));
+            });
+            if (!response.ok) {
+                const normalized = await normalizeHttpError("gemini", response);
+                throw new Error(normalized.error);
+            }
+            const payload = safeJsonParse(await response.text());
+            if (!payload)
+                throw new Error("gemini returned invalid JSON.");
+            const candidate = payload.candidates?.[0];
+            const parts = candidate?.content?.parts ?? [];
+            const text = parts.map((part) => part.text ?? "").join("");
+            const toolCalls = parts
+                .filter((part) => Boolean(part.functionCall))
+                .map((part, index) => ({
+                type: "tool_call",
+                id: `${requestId}-${index}`,
+                name: part.functionCall.name,
+                args: part.functionCall.args ?? {},
+            }));
+            const usage = usageFromResponse(payload, options);
+            const finishReason = mapFinishReason(candidate?.finishReason, toolCalls.length > 0);
+            return {
+                message: buildAssistantMessage(model, text, "", toolCalls, usage, finishReason),
+                usage,
+                finishReason,
+                providerMeta: { model },
+            };
+        },
+        stream(request) {
+            const raw = async function* () {
+                const result = await openSSEStream(urlFor("streamGenerateContent"), { "Content-Type": "application/json" }, buildBody(request), "gemini", request.signal, undefined, options?.timeouts);
+                if (!result.ok) {
+                    yield result.error;
+                    return;
+                }
+                let toolCounter = 0;
+                const requestId = createRequestId();
+                let latestUsage;
+                let latestFinishReason;
+                for await (const event of result.events) {
+                    if (event.data === "[DONE]")
+                        break;
+                    const payload = safeJsonParse(event.data);
+                    if (!payload)
+                        continue;
+                    const candidate = payload.candidates?.[0];
+                    const parts = candidate?.content?.parts ?? [];
+                    latestFinishReason = mapFinishReason(candidate?.finishReason, parts.some((part) => Boolean(part.functionCall)));
+                    for (const part of parts) {
+                        if (part.text)
+                            yield { type: "text", delta: part.text };
+                        if (part.functionCall) {
+                            const callId = `${requestId}-${toolCounter++}`;
+                            yield { type: "tool_start", callId, name: part.functionCall.name };
+                            yield {
+                                type: "tool_call",
+                                callId,
+                                name: part.functionCall.name,
+                                args: part.functionCall.args ?? {},
+                            };
+                        }
+                    }
+                    const usage = usageFromResponse(payload, options);
+                    latestUsage = usage;
+                    if (usage.total > 0)
+                        yield { type: "usage", usage };
+                }
+                if (latestFinishReason) {
+                    yield {
+                        type: "usage",
+                        usage: latestUsage ?? makeUsage(),
+                        finishReason: latestFinishReason,
+                    };
+                }
+            };
+            return normalizeProviderStream(raw(), { suppressTextAfterMalformedTool: true });
+        },
+    };
+};

package/ai/providers/mistral.d.ts

@@ -0,0 +1,12 @@
+import type { Provider, ProviderTimeouts } from "../types.js";
+export type MistralOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    contextWindow?: number;
+    temperature?: number;
+    normalizeToolCallIds?: "strict9" | "never";
+    creditsPerInputToken?: number;
+    creditsPerOutputToken?: number;
+    timeouts?: ProviderTimeouts;
+};
+export declare const mistral: (model: string, options?: MistralOptions) => Provider;