@bolt-foundry/gambit 0.8.1 → 0.8.5-rc.10

package/esm/src/providers/ollama.js

@@ -0,0 +1,789 @@
+import * as dntShim from "../../_dnt.shims.js";
+import OpenAI from "openai";
+import { GAMBIT_TOOL_CONTEXT, GAMBIT_TOOL_INIT, } from "@bolt-foundry/gambit-core";
+const logger = console;
+export const OLLAMA_PREFIX = "ollama/";
+export const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1";
+function buildOllamaApiBase(baseURL) {
+    const url = new URL(baseURL ?? DEFAULT_OLLAMA_BASE_URL);
+    url.pathname = url.pathname.replace(/\/v1\/?$/, "/");
+    if (!url.pathname.endsWith("/")) {
+        url.pathname += "/";
+    }
+    return url;
+}
+export async function fetchOllamaTags(baseURL) {
+    const apiBase = buildOllamaApiBase(baseURL);
+    const tagsUrl = new URL("api/tags", apiBase);
+    const tagsResponse = await fetch(tagsUrl);
+    if (!tagsResponse.ok) {
+        throw new Error(`Failed to list Ollama models (${tagsResponse.status} ${tagsResponse.statusText}).`);
+    }
+    const tags = (await tagsResponse.json());
+    const models = tags.models ?? [];
+    return new Set(models
+        .map((entry) => entry.name?.trim())
+        .filter((name) => Boolean(name)));
+}
+export async function ensureOllamaModel(model, baseURL) {
+    const tags = await fetchOllamaTags(baseURL);
+    if (tags.has(model)) {
+        return;
+    }
+    logger.log(`Ollama model "${model}" not found; pulling from Ollama...`);
+    const apiBase = buildOllamaApiBase(baseURL);
+    const pullUrl = new URL("api/pull", apiBase);
+    const pullResponse = await fetch(pullUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: model }),
+    });
+    if (!pullResponse.ok || !pullResponse.body) {
+        throw new Error(`Failed to pull Ollama model "${model}" (${pullResponse.status} ${pullResponse.statusText}).`);
+    }
+    const decoder = new TextDecoder();
+    const reader = pullResponse.body.getReader();
+    let buffer = "";
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.error) {
+                    throw new Error(event.error);
+                }
+                if (event.status) {
+                    logger.log(`[ollama] ${event.status}`);
+                }
+            }
+            catch (err) {
+                throw new Error(`Failed to parse Ollama pull response: ${err.message}`);
+            }
+        }
+    }
+}
+function safeJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {};
+}
+function toJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toJsonValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined)
+                continue;
+            out[key] = toJsonValue(entry);
+        }
+        return out;
+    }
+    return String(value);
+}
+function isExtensionResponseItem(item) {
+    return item.type.includes(":");
+}
+function isAsyncIterable(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        Symbol.asyncIterator in value);
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0,
+    };
+}
+function mapStatus(status) {
+    if (!status)
+        return undefined;
+    if (status === "completed")
+        return "completed";
+    if (status === "in_progress" || status === "queued")
+        return "in_progress";
+    return "failed";
+}
+function mapReasoning(reasoning) {
+    if (!reasoning)
+        return undefined;
+    const out = {};
+    if (reasoning.effort !== undefined)
+        out.effort = reasoning.effort;
+    if (reasoning.summary !== undefined)
+        out.summary = reasoning.summary;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function stripUndefined(input) {
+    const out = { ...input };
+    for (const [key, value] of Object.entries(out)) {
+        if (value === undefined) {
+            delete out[key];
+        }
+    }
+    return out;
+}
+function mapError(error) {
+    if (!error)
+        return undefined;
+    return { code: error.code, message: error.message };
+}
+function mapTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description ?? null,
+        parameters: normalizeToolParameters(tool.function.parameters),
+        strict: false,
+    }));
+}
+function normalizeToolParameters(parameters) {
+    const normalized = structuredClone(parameters ?? {});
+    if (normalized.type !== "object") {
+        return normalized;
+    }
+    if (normalized.properties === undefined) {
+        normalized.properties = {};
+    }
+    const props = normalized.properties;
+    if (props && typeof props === "object" && !Array.isArray(props)) {
+        const requiredKeys = Array.isArray(normalized.required)
+            ? normalized.required.filter((key) => typeof key === "string" && key in props)
+            : [];
+        for (const [key, value] of Object.entries(props)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            if (!("type" in value))
+                continue;
+            if (value.type === "object" && value.additionalProperties !== false) {
+                props[key] = {
+                    ...value,
+                    additionalProperties: false,
+                };
+            }
+        }
+        if (requiredKeys.length > 0) {
+            normalized.required = requiredKeys;
+        }
+    }
+    const additional = normalized.additionalProperties;
+    if (additional !== false) {
+        normalized.additionalProperties = false;
+    }
+    return normalized;
+}
+function appendSyntheticTools(tools, input) {
+    const needed = new Set();
+    for (const item of input) {
+        if (item.type !== "function_call")
+            continue;
+        if (item.name === GAMBIT_TOOL_CONTEXT || item.name === GAMBIT_TOOL_INIT) {
+            needed.add(item.name);
+        }
+    }
+    for (const name of needed) {
+        if (tools.some((tool) => tool.name === name))
+            continue;
+        tools.push({
+            type: "function",
+            name,
+            description: "Synthetic Gambit context payload.",
+            parameters: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+                required: [],
+            },
+            strict: false,
+        });
+    }
+}
+function mapToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (toolChoice === "none" || toolChoice === "auto" ||
+        toolChoice === "required") {
+        return toolChoice;
+    }
+    if (toolChoice.type === "allowed_tools") {
+        return {
+            type: "allowed_tools",
+            tools: toolChoice.tools,
+            mode: toolChoice.mode ?? "auto",
+        };
+    }
+    return { type: "function", name: toolChoice.function.name };
+}
+function mapResponseContentPart(part) {
+    if (!part || typeof part !== "object")
+        return null;
+    if (typeof part.text !== "string")
+        return null;
+    if (part.type === "output_text") {
+        return { type: "output_text", text: part.text };
+    }
+    if (part.type === "summary_text") {
+        return { type: "summary_text", text: part.text };
+    }
+    if (part.type === "reasoning_text") {
+        return { type: "reasoning_text", text: part.text };
+    }
+    if (part.type === "input_text") {
+        return { type: "input_text", text: part.text };
+    }
+    return null;
+}
+function mapOpenAIOutputItem(item) {
+    const itemType = item.type;
+    if (itemType === "message") {
+        const message = item;
+        const content = (message.content ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        if (content.length === 0)
+            return null;
+        return {
+            type: "message",
+            role: "assistant",
+            content,
+            id: message.id,
+        };
+    }
+    if (itemType === "function_call") {
+        const call = item;
+        return {
+            type: "function_call",
+            call_id: call.call_id,
+            name: call.name,
+            arguments: call.arguments,
+            id: call.id,
+        };
+    }
+    if (itemType === "reasoning") {
+        const reasoning = item;
+        const content = (reasoning.content ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        const summary = (reasoning.summary ?? [])
+            .map((part) => mapResponseContentPart(part))
+            .filter((part) => Boolean(part));
+        return {
+            type: "reasoning",
+            id: reasoning.id,
+            content: content.length > 0 ? content : undefined,
+            summary,
+            encrypted_content: reasoning.encrypted_content,
+        };
+    }
+    if (typeof itemType === "string" && itemType.includes(":")) {
+        const raw = item;
+        const payloadEntries = Object.entries(raw).filter(([key, value]) => {
+            if (key === "type" || key === "id")
+                return false;
+            if (value === undefined)
+                return false;
+            return true;
+        });
+        let data;
+        if (payloadEntries.length === 1 && payloadEntries[0][0] === "data") {
+            data = toJsonValue(payloadEntries[0][1]);
+        }
+        else {
+            const payloadObject = {};
+            for (const [key, value] of payloadEntries) {
+                payloadObject[key] = toJsonValue(value);
+            }
+            data = payloadObject;
+        }
+        return {
+            type: itemType,
+            id: typeof raw.id === "string" ? raw.id : undefined,
+            data,
+        };
+    }
+    return null;
+}
+function normalizeOpenAIResponse(response) {
+    const outputItems = (response.output ?? [])
+        .map(mapOpenAIOutputItem)
+        .filter((item) => Boolean(item));
+    return {
+        id: response.id,
+        object: "response",
+        model: response.model,
+        created_at: response.created_at,
+        created: response.created_at,
+        completed_at: response.completed_at ??
+            null,
+        previous_response_id: response.previous_response_id ?? null,
+        instructions: response.instructions ?? null,
+        reasoning: response
+            .reasoning ?? null,
+        status: mapStatus(response.status ?? undefined),
+        output: outputItems,
+        usage: mapUsage(response.usage),
+        error: mapError(response.error) ?? null,
+        metadata: response.metadata,
+        max_output_tokens: response.max_output_tokens ?? null,
+        max_tool_calls: response.max_tool_calls ?? null,
+        parallel_tool_calls: response.parallel_tool_calls,
+        store: response.store,
+    };
+}
+function toOpenAIInputItems(items) {
+    const mapped = [];
+    for (const item of items) {
+        if (item.type === "message") {
+            const isAssistant = item.role === "assistant";
+            const content = item.content
+                .map((part) => {
+                if (part.type === "output_text") {
+                    return {
+                        type: "output_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "input_text") {
+                    return {
+                        type: isAssistant ? "output_text" : "input_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "summary_text") {
+                    return {
+                        type: "summary_text",
+                        text: part.text,
+                    };
+                }
+                if (part.type === "reasoning_text") {
+                    return {
+                        type: "reasoning_text",
+                        text: part.text,
+                    };
+                }
+                return null;
+            })
+                .filter((part) => Boolean(part));
+            if (content.length === 0)
+                continue;
+            mapped.push({
+                type: "message",
+                role: item.role,
+                content,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "function_call") {
+            mapped.push({
+                type: "function_call",
+                call_id: item.call_id,
+                name: item.name,
+                arguments: item.arguments,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "function_call_output") {
+            mapped.push({
+                type: "function_call_output",
+                call_id: item.call_id,
+                output: item.output,
+                id: item.id,
+            });
+            continue;
+        }
+        if (item.type === "reasoning") {
+            mapped.push({
+                type: "reasoning",
+                id: item.id,
+                content: (item.content ?? []).map((part) => ({
+                    type: part.type,
+                    text: part.text,
+                })),
+                summary: item.summary.map((part) => ({
+                    type: part.type,
+                    text: part.text,
+                })),
+                encrypted_content: item.encrypted_content ?? null,
+            });
+        }
+        if (isExtensionResponseItem(item)) {
+            mapped.push({
+                type: item.type,
+                id: item.id,
+                data: item.data,
+            });
+        }
+    }
+    return mapped;
+}
+function chatMessagesToResponseItems(messages) {
+    const items = [];
+    for (const message of messages) {
+        if (message.role === "tool") {
+            if (message.tool_call_id &&
+                typeof message.content === "string") {
+                items.push({
+                    type: "function_call_output",
+                    call_id: message.tool_call_id,
+                    output: message.content,
+                });
+            }
+            continue;
+        }
+        if (message.role === "system" || message.role === "user" ||
+            message.role === "assistant") {
+            const content = [];
+            if (typeof message.content === "string" && message.content.length > 0) {
+                content.push({
+                    type: message.role === "assistant" ? "output_text" : "input_text",
+                    text: message.content,
+                });
+            }
+            if (content.length > 0) {
+                items.push({
+                    type: "message",
+                    role: message.role,
+                    content,
+                });
+            }
+        }
+        if (message.role === "assistant" && message.tool_calls) {
+            for (const call of message.tool_calls) {
+                items.push({
+                    type: "function_call",
+                    call_id: call.id,
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                });
+            }
+        }
+    }
+    return items;
+}
+function responseItemsToChat(items) {
+    const textParts = [];
+    const toolCalls = [];
+    const messageToolCalls = [];
+    for (const item of items) {
+        if (item.type === "message" && item.role === "assistant") {
+            for (const part of item.content) {
+                if (part.type === "output_text") {
+                    textParts.push(part.text);
+                }
+            }
+        }
+        if (item.type === "function_call") {
+            toolCalls.push({
+                id: item.call_id,
+                name: item.name,
+                args: safeJson(item.arguments),
+            });
+            messageToolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments },
+            });
+        }
+    }
+    const content = textParts.length > 0 ? textParts.join("") : null;
+    const message = {
+        role: "assistant",
+        content,
+        tool_calls: messageToolCalls.length > 0 ? messageToolCalls : undefined,
+    };
+    return {
+        message,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+}
+async function createResponse(client, request, signal, onStreamEvent) {
+    const baseParams = {
+        model: request.model,
+        input: toOpenAIInputItems(request.input),
+        instructions: request.instructions,
+        tools: undefined,
+        tool_choice: mapToolChoice(request.tool_choice),
+        previous_response_id: request.previous_response_id,
+        reasoning: mapReasoning(request.reasoning),
+        parallel_tool_calls: request.parallel_tool_calls,
+        max_tool_calls: request.max_tool_calls,
+        store: request.store,
+        include: request.include,
+        text: request.text,
+        stream_options: request.stream_options,
+        background: request.background,
+        truncation: request.truncation,
+        service_tier: request.service_tier,
+        top_logprobs: request.top_logprobs,
+        safety_identifier: request.safety_identifier,
+        prompt_cache_key: request.prompt_cache_key,
+        temperature: request.temperature,
+        top_p: request.top_p,
+        frequency_penalty: request.frequency_penalty,
+        presence_penalty: request.presence_penalty,
+        stream: request.stream,
+        max_output_tokens: request.max_output_tokens,
+        metadata: request.metadata,
+    };
+    const mappedTools = mapTools(request.tools) ?? [];
+    appendSyntheticTools(mappedTools, request.input);
+    if (mappedTools.length > 0) {
+        baseParams.tools = mappedTools;
+    }
+    const params = { ...(request.params ?? {}), ...stripUndefined(baseParams) };
+    const debugResponses = dntShim.Deno.env.get("GAMBIT_DEBUG_RESPONSES") === "1";
+    let responseOrStream;
+    try {
+        responseOrStream = await client.responses.create(params, signal ? { signal } : undefined);
+    }
+    catch (err) {
+        if (debugResponses) {
+            logger.error("[responses-debug] request", params);
+            if (err instanceof OpenAI.APIError) {
+                logger.error("[responses-debug] error", err.error);
+            }
+            else {
+                logger.error("[responses-debug] error", err);
+            }
+        }
+        throw err;
+    }
+    if (request.stream &&
+        isAsyncIterable(responseOrStream)) {
+        let completed = null;
+        for await (const event of responseOrStream) {
+            if (!event || typeof event !== "object" || !("type" in event)) {
+                continue;
+            }
+            switch (event.type) {
+                case "response.created": {
+                    const mapped = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({
+                        type: "response.created",
+                        response: mapped,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                case "response.output_text.delta":
+                    onStreamEvent?.({
+                        type: "response.output_text.delta",
+                        output_index: event.output_index,
+                        delta: event.delta,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        sequence_number: event
+                            .sequence_number,
+                        logprobs: event.logprobs,
+                    });
+                    break;
+                case "response.output_text.done":
+                    onStreamEvent?.({
+                        type: "response.output_text.done",
+                        output_index: event.output_index,
+                        text: event.text,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.output_item.added": {
+                    const item = mapOpenAIOutputItem(event.item);
+                    if (item) {
+                        onStreamEvent?.({
+                            type: "response.output_item.added",
+                            output_index: event.output_index,
+                            item,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                }
+                case "response.output_item.done": {
+                    const item = mapOpenAIOutputItem(event.item);
+                    if (item) {
+                        onStreamEvent?.({
+                            type: "response.output_item.done",
+                            output_index: event.output_index,
+                            item,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                }
+                case "response.reasoning.delta":
+                    if (typeof event.delta === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning.delta",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            content_index: event.content_index,
+                            delta: event.delta,
+                            sequence_number: event
+                                .sequence_number,
+                            obfuscation: event.obfuscation,
+                        });
+                    }
+                    break;
+                case "response.reasoning.done":
+                    onStreamEvent?.({
+                        type: "response.reasoning.done",
+                        output_index: event.output_index,
+                        item_id: event.item_id,
+                        content_index: event.content_index,
+                        text: event.text,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.reasoning_summary_text.delta":
+                    if (typeof event.delta === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_text.delta",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            delta: event.delta,
+                            sequence_number: event
+                                .sequence_number,
+                            obfuscation: event.obfuscation,
+                        });
+                    }
+                    break;
+                case "response.reasoning_summary_text.done":
+                    onStreamEvent?.({
+                        type: "response.reasoning_summary_text.done",
+                        output_index: event.output_index,
+                        item_id: event.item_id,
+                        summary_index: event.summary_index,
+                        text: event.text,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                case "response.reasoning_summary_part.added":
+                    if (event.part && typeof event.part === "object" &&
+                        "type" in event.part &&
+                        "text" in event.part &&
+                        typeof event.part.text === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_part.added",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            part: event.part,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                case "response.reasoning_summary_part.done":
+                    if (event.part && typeof event.part === "object" &&
+                        "type" in event.part &&
+                        "text" in event.part &&
+                        typeof event.part.text === "string") {
+                        onStreamEvent?.({
+                            type: "response.reasoning_summary_part.done",
+                            output_index: event.output_index,
+                            item_id: event.item_id,
+                            summary_index: event.summary_index,
+                            part: event.part,
+                            sequence_number: event
+                                .sequence_number,
+                        });
+                    }
+                    break;
+                case "response.completed": {
+                    completed = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({
+                        type: "response.completed",
+                        response: completed,
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                case "response.failed": {
+                    const error = mapError(event.response?.error ?? undefined);
+                    onStreamEvent?.({
+                        type: "response.failed",
+                        error: error ?? {},
+                        sequence_number: event
+                            .sequence_number,
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (completed)
+            return completed;
+        throw new Error("Ollama responses stream ended without completion.");
+    }
+    return normalizeOpenAIResponse(responseOrStream);
+}
+export function createOllamaProvider(opts) {
+    const client = (opts.client ??
+        new OpenAI({
+            apiKey: opts.apiKey ?? "ollama",
+            baseURL: opts.baseURL ?? "http://localhost:11434/v1",
+        }));
+    return {
+        async responses(input) {
+            return await createResponse(client, input.request, input.signal, input.onStreamEvent);
+        },
+        async chat(input) {
+            const response = await createResponse(client, {
+                model: input.model,
+                input: chatMessagesToResponseItems(input.messages),
+                tools: input.tools,
+                stream: input.stream,
+                params: input.params ?? {},
+            }, input.signal, (event) => {
+                if (event.type === "response.output_text.delta") {
+                    input.onStreamText?.(event.delta);
+                }
+            });
+            const mapped = responseItemsToChat(response.output);
+            return {
+                message: mapped.message,
+                finishReason: mapped.toolCalls ? "tool_calls" : "stop",
+                toolCalls: mapped.toolCalls,
+                usage: response.usage,
+            };
+        },
+    };
+}