babelgate 0.0.0 → 1.1.0

package/dist/transformers/adapters/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anthropicAdapter = exports.ollamaAdapter = exports.geminiAdapter = exports.openaiAdapter = exports.PROVIDER_PATHS = exports.PROVIDER_ROUTES = exports.adapters = void 0;
+exports.findSourceRoute = findSourceRoute;
+const openai_adapter_1 = require("./openai.adapter");
+Object.defineProperty(exports, "openaiAdapter", { enumerable: true, get: function () { return openai_adapter_1.openaiAdapter; } });
+const gemini_adapter_1 = require("./gemini.adapter");
+Object.defineProperty(exports, "geminiAdapter", { enumerable: true, get: function () { return gemini_adapter_1.geminiAdapter; } });
+const ollama_adapter_1 = require("./ollama.adapter");
+Object.defineProperty(exports, "ollamaAdapter", { enumerable: true, get: function () { return ollama_adapter_1.ollamaAdapter; } });
+const anthropic_adapter_1 = require("./anthropic.adapter");
+Object.defineProperty(exports, "anthropicAdapter", { enumerable: true, get: function () { return anthropic_adapter_1.anthropicAdapter; } });
+exports.adapters = {
+    openai: openai_adapter_1.openaiAdapter,
+    gemini: gemini_adapter_1.geminiAdapter,
+    ollama: ollama_adapter_1.ollamaAdapter,
+    anthropic: anthropic_adapter_1.anthropicAdapter,
+};
+/**
+ * The "<model>:<method>" pair carried in a gemini chat path
+ * (/v1beta/models/<model>:<method>). The method suffix is
+ * ":"-separated; the model id may be percent-encoded and may contain
+ * "/" (e.g. tunedModels/x). Undefined when the path has no such pair.
+ */
+function geminiPathParts(path) {
+    let decoded = path;
+    try {
+        decoded = decodeURIComponent(path);
+    }
+    catch {
+        // malformed escapes — fall back to the raw path
+    }
+    const prefix = "/v1beta/models/";
+    if (!decoded.startsWith(prefix))
+        return undefined;
+    const rest = decoded.slice(prefix.length);
+    const colon = rest.lastIndexOf(":");
+    if (colon === -1)
+        return undefined;
+    return { model: rest.slice(0, colon), method: rest.slice(colon + 1) };
+}
+/**
+ * Route conventions per provider. Each provider exposes routes for every
+ * endpoint kind it supports — matched by method + pathPrefix.
+ */
+exports.PROVIDER_ROUTES = {
+    openai: [
+        {
+            kind: "chat",
+            method: "POST",
+            pathPrefix: "/v1/chat/completions",
+            requestPath: () => "/v1/chat/completions",
+        },
+        {
+            kind: "models",
+            method: "GET",
+            pathPrefix: "/v1/models",
+            requestPath: () => "/v1/models",
+        },
+    ],
+    gemini: [
+        {
+            kind: "chat",
+            method: "POST",
+            pathPrefix: "/v1beta/models",
+            requestPath: (model) => `/v1beta/models/${model}:generateContent`,
+            streamRequestPath: (model) => `/v1beta/models/${model}:streamGenerateContent?alt=sse`,
+            modelFromPath: (path) => geminiPathParts(path)?.model,
+            isStreamPath: (path) => geminiPathParts(path)?.method === "streamGenerateContent",
+            // A path without a "<m>:<method>" pair isn't claimed here — it
+            // falls through to the model-from-body flow as before.
+            isSupportedPath: (path) => {
+                const method = geminiPathParts(path)?.method;
+                return (method === undefined ||
+                    method === "generateContent" ||
+                    method === "streamGenerateContent");
+            },
+        },
+        {
+            kind: "models",
+            method: "GET",
+            pathPrefix: "/v1beta/models",
+            requestPath: () => "/v1beta/models",
+        },
+    ],
+    ollama: [
+        {
+            kind: "chat",
+            method: "POST",
+            pathPrefix: "/api/chat",
+            requestPath: () => "/api/chat",
+        },
+        {
+            kind: "models",
+            method: "GET",
+            pathPrefix: "/api/tags",
+            requestPath: () => "/api/tags",
+        },
+    ],
+    anthropic: [
+        {
+            // Answered locally (spec §3.5) — must precede the /v1/messages
+            // chat route: it shares that prefix and routes match in order.
+            kind: "count_tokens",
+            method: "POST",
+            pathPrefix: "/v1/messages/count_tokens",
+            requestPath: () => "/v1/messages",
+        },
+        {
+            kind: "chat",
+            method: "POST",
+            pathPrefix: "/v1/messages",
+            requestPath: () => "/v1/messages",
+        },
+        {
+            kind: "models",
+            method: "GET",
+            pathPrefix: "/v1/models",
+            requestPath: () => "/v1/models",
+        },
+    ],
+};
+/**
+ * Match an incoming request to a route on the given source provider
+ * (method + path prefix). Used by resolve-source middleware and
+ * proxy.service.
+ */
+function findSourceRoute(source, method, path) {
+    return exports.PROVIDER_ROUTES[source].find((r) => r.method === method && path.startsWith(r.pathPrefix));
+}
+/**
+ * Back-compat view of the chat routes — chat endpoint per provider.
+ * Prefer PROVIDER_ROUTES for new code.
+ */
+exports.PROVIDER_PATHS = Object.fromEntries(Object.keys(exports.PROVIDER_ROUTES).map((provider) => {
+    const chat = exports.PROVIDER_ROUTES[provider].find((r) => r.kind === "chat");
+    return [
+        provider,
+        { pathPrefix: chat.pathPrefix, requestPath: chat.requestPath },
+    ];
+}));

package/dist/transformers/adapters/ollama.adapter.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ollamaAdapter = void 0;
+exports.toCanonicalRequest = toCanonicalRequest;
+exports.fromCanonicalRequest = fromCanonicalRequest;
+exports.toCanonicalResponse = toCanonicalResponse;
+exports.fromCanonicalResponse = fromCanonicalResponse;
+exports.toCanonicalModelList = toCanonicalModelList;
+exports.fromCanonicalModelList = fromCanonicalModelList;
+exports.toCanonicalError = toCanonicalError;
+exports.fromCanonicalError = fromCanonicalError;
+const crypto_1 = require("crypto");
+const canonical_error_1 = require("../../utils/canonical-error");
+const errors_1 = require("../../utils/errors");
+const ids_1 = require("../../utils/ids");
+const ollama_stream_1 = require("./ollama.stream");
+const ollama_tools_1 = require("./ollama.tools");
+exports.ollamaAdapter = {
+    toCanonicalRequest,
+    fromCanonicalRequest,
+    toCanonicalResponse,
+    fromCanonicalResponse,
+    toCanonicalModelList,
+    fromCanonicalModelList,
+    toCanonicalError,
+    fromCanonicalError,
+    createStreamDecoder: ollama_stream_1.createStreamDecoder,
+    createStreamEncoder: ollama_stream_1.createStreamEncoder,
+};
+// ============ REQUEST: Ollama → Canonical ============
+function toCanonicalRequest(request) {
+    // Wire ids are kept when present; id-less calls draw call_0, call_1,…
+    // (docs/decisions.md "v1.1 Task 3" convention).
+    const ids = (0, ids_1.sequentialIds)();
+    // Tool results carry only `tool_name` on the wire (docs.ollama.com
+    // api.md "Chat request (With history, with tools)"); pair each one
+    // with the earliest unconsumed earlier call of that name (FIFO).
+    const pendingByName = new Map();
+    const messages = (request.messages || []).map((m) => {
+        const out = {
+            role: m.role,
+            content: extractContent(m),
+        };
+        const wireCalls = m.tool_calls;
+        if (wireCalls && wireCalls.length > 0) {
+            out.toolCalls = (0, ollama_tools_1.toCanonicalToolCalls)(wireCalls, ids);
+            for (const tc of out.toolCalls) {
+                (0, ollama_tools_1.recordCallId)(pendingByName, tc.function.name, tc.id);
+            }
+        }
+        if (typeof m.tool_name === "string" && m.tool_name.length > 0) {
+            out.toolCallId = (0, ollama_tools_1.resolveCallId)(pendingByName, m.tool_name) ?? m.tool_name;
+        }
+        return out;
+    });
+    // Extract system prompt from first system message
+    const systemMsg = messages.find((m) => m.role === "system");
+    const systemPrompt = typeof systemMsg?.content === "string" ? systemMsg.content : undefined;
+    const result = {
+        model: request.model,
+        messages,
+        ...(systemPrompt && { systemPrompt }),
+    };
+    // Convert options to config
+    if (request.options) {
+        const opts = request.options;
+        result.config = {
+            ...(opts.temperature !== undefined && { temperature: opts.temperature }),
+            ...(opts.num_predict !== undefined && { maxTokens: opts.num_predict }),
+            ...(opts.top_p !== undefined && { topP: opts.top_p }),
+            ...(opts.top_k !== undefined && { topK: opts.top_k }),
+            ...(opts.stop && { stopSequences: opts.stop }),
+            ...(opts.seed !== undefined && { seed: opts.seed }),
+        };
+    }
+    // Canonical treats absent and stream:false identically — only an
+    // explicit true survives, keeping the request round-trip idempotent.
+    if (request.stream === true) {
+        result.stream = true;
+    }
+    if (request.tools && request.tools.length > 0) {
+        result.tools = (0, ollama_tools_1.toCanonicalTools)(request.tools);
+    }
+    return result;
+}
+function extractContent(message) {
+    if (!message.images || message.images.length === 0) {
+        return message.content;
+    }
+    // Has images - return multipart
+    const parts = [
+        { type: "text", text: message.content },
+    ];
+    for (const img of message.images) {
+        // Ollama images can be string (base64) or Uint8Array
+        const data = typeof img === "string" ? img : Buffer.from(img).toString("base64");
+        parts.push({
+            type: "image",
+            image: {
+                data,
+                mimeType: "image/png", // Ollama doesn't specify mime type
+            },
+        });
+    }
+    return parts;
+}
+// ============ REQUEST: Canonical → Ollama ============
+function fromCanonicalRequest(request) {
+    // Ollama has no tool_choice parameter (api.md "Tool calling"); auto
+    // (or absent) is its only behaviour. Anything else → 400.
+    if (request.toolChoice !== undefined && request.toolChoice !== "auto") {
+        const value = typeof request.toolChoice === "string"
+            ? request.toolChoice
+            : JSON.stringify(request.toolChoice);
+        throw new errors_1.ValidationError(`Ollama does not support tool_choice "${value}"`);
+    }
+    // `tool_name` on a result is looked up from the matching assistant
+    // call in the same request (Ollama carries names, not call ids).
+    // The lookup is built while walking the messages, so a tool message
+    // resolves only against calls that come BEFORE it.
+    const callNameById = new Map();
+    const messages = request.messages.map((m) => {
+        const out = convertToOllamaMessage(m, callNameById);
+        for (const tc of m.toolCalls ?? []) {
+            callNameById.set(tc.id, tc.function.name);
+        }
+        return out;
+    });
+    const result = {
+        model: request.model,
+        messages,
+    };
+    if (request.tools && request.tools.length > 0) {
+        result.tools = (0, ollama_tools_1.toOllamaTools)(request.tools);
+    }
+    // Convert config to options
+    if (request.config) {
+        const c = request.config;
+        const options = {};
+        if (c.temperature !== undefined)
+            options.temperature = c.temperature;
+        if (c.maxTokens !== undefined)
+            options.num_predict = c.maxTokens;
+        if (c.topP !== undefined)
+            options.top_p = c.topP;
+        if (c.topK !== undefined)
+            options.top_k = c.topK;
+        if (c.stopSequences)
+            options.stop = c.stopSequences;
+        if (c.seed !== undefined)
+            options.seed = c.seed;
+        if (c.contextWindow !== undefined)
+            options.num_ctx = c.contextWindow;
+        if (Object.keys(options).length > 0) {
+            result.options = options;
+        }
+    }
+    // Ollama streams NDJSON by default; send stream:false unless the
+    // canonical request explicitly asked for streaming.
+    result.stream = request.stream ?? false;
+    return result;
+}
+function convertToOllamaMessage(msg, callNameById) {
+    const result = {
+        role: msg.role,
+        content: "",
+    };
+    if (typeof msg.content === "string") {
+        result.content = msg.content;
+    }
+    else if (Array.isArray(msg.content)) {
+        // Extract text and images
+        const textParts = msg.content
+            .filter((p) => p.type === "text")
+            .map((p) => p.text || "")
+            .join("\n");
+        const images = msg.content
+            .filter((p) => p.type === "image" && p.image)
+            .map((p) => p.image.data);
+        result.content = textParts;
+        if (images.length > 0) {
+            result.images = images;
+        }
+    }
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
+        result.tool_calls = (0, ollama_tools_1.toOllamaToolCalls)(msg.toolCalls);
+    }
+    if (msg.role === "tool") {
+        result.tool_name = (0, ollama_tools_1.resolveToolName)(callNameById, msg.toolCallId);
+    }
+    return result;
+}
+// ============ RESPONSE: Ollama → Canonical ============
+function toCanonicalResponse(response, model, ids = (0, ids_1.createIdGenerator)()) {
+    const message = {
+        role: "assistant",
+        content: response.message?.content ?? "",
+    };
+    const wireCalls = response.message?.tool_calls;
+    if (wireCalls && wireCalls.length > 0) {
+        message.toolCalls = (0, ollama_tools_1.toCanonicalToolCalls)(wireCalls, ids);
+    }
+    return {
+        id: `ollama-${(0, crypto_1.randomUUID)()}`,
+        model,
+        message,
+        // A reply ending in tool calls is a "tool_call" finish — the same
+        // rule the stream decoder applies (docs/decisions.md "v1.1 Task 6").
+        finishReason: message.toolCalls
+            ? "tool_call"
+            : response.done
+                ? "stop"
+                : "unknown",
+        usage: {
+            inputTokens: response.prompt_eval_count ?? 0,
+            outputTokens: response.eval_count ?? 0,
+            totalTokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+        },
+    };
+}
+// ============ RESPONSE: Canonical → Ollama ============
+function fromCanonicalResponse(response) {
+    const content = typeof response.message.content === "string"
+        ? response.message.content
+        : "";
+    const toolCalls = response.message.toolCalls;
+    // "stop" covers canonical "tool_call": recorded Ollama answers that
+    // end in tool calls report done_reason "stop".
+    const stopped = response.finishReason === "stop" ||
+        response.finishReason === "tool_call";
+    return {
+        model: response.model,
+        created_at: new Date(),
+        message: {
+            role: "assistant",
+            content,
+            ...(toolCalls &&
+                toolCalls.length > 0 && {
+                tool_calls: (0, ollama_tools_1.toOllamaToolCalls)(toolCalls),
+            }),
+        },
+        done: stopped,
+        done_reason: stopped ? "stop" : "length",
+        total_duration: 0,
+        load_duration: 0,
+        prompt_eval_count: response.usage?.inputTokens ?? 0,
+        prompt_eval_duration: 0,
+        eval_count: response.usage?.outputTokens ?? 0,
+        eval_duration: 0,
+    };
+}
+function toCanonicalModelList(response) {
+    const res = response;
+    return {
+        models: (res.models ?? [])
+            .filter((m) => Boolean(m.name ?? m.model))
+            .map((m) => ({
+            id: (m.name ?? m.model),
+            // ISO timestamp → Unix seconds
+            created: m.modified_at
+                ? Math.floor(Date.parse(m.modified_at) / 1000)
+                : undefined,
+        })),
+    };
+}
+function fromCanonicalModelList(list) {
+    return {
+        models: list.models.map((m) => ({
+            name: m.id,
+            model: m.id,
+            modified_at: m.created
+                ? new Date(m.created * 1000).toISOString()
+                : undefined,
+        })),
+    };
+}
+// ============ ERRORS ============
+function toCanonicalError(status, body) {
+    const err = body?.error;
+    const message = typeof err === "string" && err.length > 0
+        ? err
+        : `Upstream ollama returned ${status}`;
+    return (0, canonical_error_1.makeCanonicalError)((0, canonical_error_1.kindFromStatus)(status), message);
+}
+function fromCanonicalError(err) {
+    return { error: err.message };
+}
+// Streaming lives in ./ollama.stream — re-exported on the adapter above.