@bolt-foundry/gambit 0.8.1 → 0.8.3

package/script/src/providers/ollama.js

@@ -0,0 +1,551 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OLLAMA_BASE_URL = exports.OLLAMA_PREFIX = void 0;
+exports.fetchOllamaTags = fetchOllamaTags;
+exports.ensureOllamaModel = ensureOllamaModel;
+exports.createOllamaProvider = createOllamaProvider;
+const dntShim = __importStar(require("../../_dnt.shims.js"));
+const openai_1 = __importDefault(require("openai"));
+const gambit_core_1 = require("@bolt-foundry/gambit-core");
+const logger = console;
+exports.OLLAMA_PREFIX = "ollama/";
+exports.DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1";
+function buildOllamaApiBase(baseURL) {
+    const url = new URL(baseURL ?? exports.DEFAULT_OLLAMA_BASE_URL);
+    url.pathname = url.pathname.replace(/\/v1\/?$/, "/");
+    if (!url.pathname.endsWith("/")) {
+        url.pathname += "/";
+    }
+    return url;
+}
+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)));
+}
+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 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 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_core_1.GAMBIT_TOOL_CONTEXT || item.name === gambit_core_1.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 === "auto" || toolChoice === "required")
+        return toolChoice;
+    return { type: "function", name: toolChoice.function.name };
+}
+function mapOpenAIOutputItem(item) {
+    const itemType = item.type;
+    if (itemType === "message") {
+        const message = item;
+        const content = [];
+        for (const part of message.content ?? []) {
+            if (part.type === "output_text") {
+                content.push({ type: "output_text", text: part.text });
+            }
+        }
+        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,
+        };
+    }
+    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: response.created_at,
+        status: mapStatus(response.status ?? undefined),
+        output: outputItems,
+        usage: mapUsage(response.usage),
+        error: mapError(response.error),
+    };
+}
+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,
+                    };
+                }
+                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,
+            });
+        }
+    }
+    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, onStreamEvent) {
+    const baseParams = {
+        model: request.model,
+        input: toOpenAIInputItems(request.input),
+        instructions: request.instructions,
+        tools: undefined,
+        tool_choice: mapToolChoice(request.tool_choice),
+        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 ?? {}), ...baseParams };
+    const debugResponses = dntShim.Deno.env.get("GAMBIT_DEBUG_RESPONSES") === "1";
+    let responseOrStream;
+    try {
+        responseOrStream = await client.responses.create(params);
+    }
+    catch (err) {
+        if (debugResponses) {
+            logger.error("[responses-debug] request", params);
+            if (err instanceof openai_1.default.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 });
+                    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,
+                    });
+                    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,
+                    });
+                    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,
+                        });
+                    }
+                    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,
+                        });
+                    }
+                    break;
+                }
+                case "response.completed": {
+                    completed = normalizeOpenAIResponse(event.response);
+                    onStreamEvent?.({ type: "response.completed", response: completed });
+                    break;
+                }
+                case "response.failed": {
+                    const error = mapError(event.response?.error ?? undefined);
+                    onStreamEvent?.({
+                        type: "response.failed",
+                        error: error ?? {},
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if (completed)
+            return completed;
+        throw new Error("Ollama responses stream ended without completion.");
+    }
+    return normalizeOpenAIResponse(responseOrStream);
+}
+function createOllamaProvider(opts) {
+    const client = (opts.client ??
+        new openai_1.default({
+            apiKey: opts.apiKey ?? "ollama",
+            baseURL: opts.baseURL ?? "http://localhost:11434/v1",
+        }));
+    return {
+        async responses(input) {
+            return await createResponse(client, input.request, 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 ?? {},
+            }, (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,
+            };
+        },
+    };
+}

package/script/src/providers/openrouter.d.ts

@@ -0,0 +1,22 @@
+import type { ModelProvider } from "@bolt-foundry/gambit-core";
+export declare const OPENROUTER_PREFIX = "openrouter/";
+type OpenAIClient = {
+    chat: {
+        completions: {
+            create: (params: unknown) => Promise<unknown>;
+        };
+    };
+    responses: {
+        create: (params: unknown) => Promise<unknown>;
+    };
+};
+export declare function createOpenRouterProvider(opts: {
+    apiKey: string;
+    baseURL?: string;
+    referer?: string;
+    title?: string;
+    enableResponses?: boolean;
+    client?: OpenAIClient;
+}): ModelProvider;
+export {};
+//# sourceMappingURL=openrouter.d.ts.map

package/script/src/providers/openrouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter.d.ts","sourceRoot":"","sources":["../../../src/src/providers/openrouter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAKV,aAAa,EAOd,MAAM,2BAA2B,CAAC;AAOnC,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAE/C,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE;QACJ,WAAW,EAAE;YACX,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;SAC/C,CAAC;KACH,CAAC;IACF,SAAS,EAAE;QACT,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;KAC/C,CAAC;CACH,CAAC;AA8eF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,GAAG,aAAa,CA8MhB"}