babelgate 0.0.0 → 1.1.1

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

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamDecoder = createStreamDecoder;
+exports.createStreamEncoder = createStreamEncoder;
+const ids_1 = require("../../utils/ids");
+const canonical_error_1 = require("../../utils/canonical-error");
+const tool_args_1 = require("../../utils/tool-args");
+const sse_1 = require("../../utils/sse");
+const logger_1 = require("../../utils/logger");
+const ollama_adapter_1 = require("./ollama.adapter");
+// `done_reason` on the wire is "stop" or "length" (docs.ollama.com/api/chat);
+// anything else has no canonical equivalent.
+const OLLAMA_DONE_REASON = {
+    stop: "stop",
+    length: "length",
+};
+/**
+ * Ollama NDJSON → canonical events (spec §3.3, docs.ollama.com/api/chat
+ * and github.com/ollama/ollama docs/api.md "Chat request (Streaming)").
+ * Each line is one complete chat response object: `message.content`
+ * fragments become text deltas (empty content emits nothing, as does
+ * `message.thinking`); `message.tool_calls` arrive whole — each call
+ * (arguments already an object) becomes start + one delta +
+ * end at sequential canonical indices, keeping the wire `id` when
+ * present and drawing from `ids` otherwise. The first line emits
+ * `message_start` with a generated id (Ollama has no message id). The
+ * `done: true` line carries usage (`prompt_eval_count`, `eval_count`)
+ * and `done_reason` — a stream that ended in tool calls reports
+ * `tool_call` as Ollama itself means it, `length` maps to `length`.
+ * `function.arguments` is normally an object (stringified into the
+ * canonical delta); a string passes through verbatim. A mid-stream
+ * `{"error":"…"}` line (docs.ollama.com/api/errors) maps
+ * through `toCanonicalError` — the wire carries no status, so the same
+ * failure returned pre-stream (HTTP 500 → `internal`) applies. A
+ * line that isn't a plain object, or a `tool_calls` that isn't an
+ * array, is an undecodable chunk — one `error` event and the stream
+ * is finished. A stream ending without `done: true` ends in an
+ * `error` event.
+ */
+function createStreamDecoder(model, ids = (0, ids_1.createIdGenerator)()) {
+    const utf8 = (0, sse_1.createUtf8Decoder)();
+    const lines = (0, sse_1.createLineSplitter)();
+    let started = false;
+    let finished = false;
+    let nextIndex = 0;
+    let sawToolCalls = false;
+    function handleObject(obj, out) {
+        if (typeof obj.error === "string") {
+            out.push({ type: "error", error: (0, ollama_adapter_1.toCanonicalError)(500, obj) });
+            finished = true;
+            return;
+        }
+        if (!started) {
+            started = true;
+            out.push({
+                type: "message_start",
+                id: ids(),
+                model: typeof obj.model === "string" ? obj.model : model,
+            });
+        }
+        const message = obj.message;
+        if (typeof message?.content === "string" &&
+            message.content.length > 0) {
+            out.push({ type: "text_delta", text: message.content });
+        }
+        const toolCalls = message?.tool_calls;
+        if (toolCalls != null && !Array.isArray(toolCalls)) {
+            failUndecodable(out);
+            return;
+        }
+        for (const tc of toolCalls ?? []) {
+            sawToolCalls = true;
+            const index = nextIndex++;
+            out.push({
+                type: "tool_call_start",
+                index,
+                id: typeof tc?.id === "string" ? tc.id : ids(),
+                name: tc?.function?.name ?? "",
+            });
+            // `arguments` is normally an object (JSON.stringify it); a string
+            // is already the JSON encoding and passes through verbatim.
+            const args = tc?.function?.arguments;
+            out.push({
+                type: "tool_call_delta",
+                index,
+                argumentsDelta: typeof args === "string" ? args : JSON.stringify(args ?? {}),
+            });
+            out.push({ type: "tool_call_end", index });
+        }
+        if (obj.done === true) {
+            const input = obj.prompt_eval_count ?? 0;
+            const output = obj.eval_count ?? 0;
+            out.push({
+                type: "usage",
+                usage: {
+                    inputTokens: input,
+                    outputTokens: output,
+                    totalTokens: input + output,
+                },
+            });
+            out.push({
+                type: "message_end",
+                finishReason: sawToolCalls
+                    ? "tool_call"
+                    : (OLLAMA_DONE_REASON[obj.done_reason] ?? "unknown"),
+            });
+            finished = true;
+        }
+    }
+    function failUndecodable(out) {
+        out.push({
+            type: "error",
+            error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream sent an undecodable stream chunk"),
+        });
+        finished = true;
+    }
+    function handleLine(line, out) {
+        if (finished)
+            return;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            failUndecodable(out);
+            return;
+        }
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+            failUndecodable(out);
+            return;
+        }
+        handleObject(obj, out);
+    }
+    function drain(completed, out) {
+        for (const line of completed)
+            handleLine(line, out);
+    }
+    return {
+        feed(chunk) {
+            const out = [];
+            drain(lines.feed(utf8(chunk)), out);
+            return out;
+        },
+        end() {
+            const out = [];
+            drain(lines.feed(utf8(new Uint8Array(0))), out);
+            drain(lines.end(), out);
+            if (!finished) {
+                out.push({
+                    type: "error",
+                    error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream stream ended without completing"),
+                });
+            }
+            return out;
+        },
+    };
+}
+/**
+ * Canonical events → Ollama NDJSON (spec §3.3, §3.4): `message_start`
+ * produces nothing — Ollama opens its stream with the first content
+ * line. Each `text_delta` is one `done:false` line; a tool call's
+ * arguments are buffered by canonical `index` until `tool_call_end`
+ * (§3.1 rule 5), then written as one `message.tool_calls` line with
+ * the call `id` and `function.index` as recorded Ollama 0.40.11 sends
+ * them and the parsed arguments object (or the `_invalid_arguments`
+ * wrapper). `message_end` is the `done:true` line with `done_reason`
+ * (canonical `tool_call` → "stop", which is what Ollama itself reports
+ * for a tool-call answer) and the held usage counts; `error` is one
+ * `{"error":"…"}` line. Calls still open when `message_end` arrives
+ * flush in ascending canonical index as `message.tool_calls` lines
+ * just before the `done:true` line (one `logger.warn` naming the
+ * count); before `error` they are dropped — the error is terminal.
+ * A `tool_call_delta`/`tool_call_end` for an index that never had
+ * `tool_call_start` logs a warning instead of dropping silently.
+ * `message_end` and `error` are terminal: any event after them
+ * encodes to nothing.
+ */
+function createStreamEncoder(ctx) {
+    const createdAt = new Date().toISOString();
+    let finished = false;
+    let usage;
+    const calls = new Map();
+    const line = (obj) => `${JSON.stringify(obj)}\n`;
+    const chunk = (message) => line({
+        model: ctx.requestedModel,
+        created_at: createdAt,
+        message,
+        done: false,
+    });
+    const toolCallLine = (index, call) => {
+        const parsed = (0, tool_args_1.parseToolArguments)(call.args);
+        if (!parsed.valid) {
+            logger_1.logger.warn("Tool call arguments are not valid JSON; sending _invalid_arguments wrapper");
+        }
+        return chunk({
+            role: "assistant",
+            content: "",
+            tool_calls: [
+                {
+                    id: call.id,
+                    function: {
+                        index,
+                        name: call.name,
+                        arguments: parsed.args,
+                    },
+                },
+            ],
+        });
+    };
+    const warnUnknownIndex = (type, index) => {
+        logger_1.logger.warn(`Ollama stream encoder: ${type} for unknown tool-call index ${index}; dropping`);
+    };
+    return {
+        contentType: "application/x-ndjson",
+        encode(event) {
+            if (finished)
+                return "";
+            switch (event.type) {
+                case "message_start":
+                    return "";
+                case "text_delta":
+                    return chunk({
+                        role: "assistant",
+                        content: event.text,
+                    });
+                case "tool_call_start":
+                    calls.set(event.index, {
+                        id: event.id,
+                        name: event.name,
+                        args: "",
+                    });
+                    return "";
+                case "tool_call_delta": {
+                    const call = calls.get(event.index);
+                    if (call) {
+                        call.args += event.argumentsDelta;
+                    }
+                    else {
+                        warnUnknownIndex(event.type, event.index);
+                    }
+                    return "";
+                }
+                case "tool_call_end": {
+                    const call = calls.get(event.index);
+                    if (!call) {
+                        warnUnknownIndex(event.type, event.index);
+                        return "";
+                    }
+                    calls.delete(event.index);
+                    return toolCallLine(event.index, call);
+                }
+                case "usage":
+                    usage = event.usage;
+                    return "";
+                case "message_end": {
+                    finished = true;
+                    let out = "";
+                    if (calls.size > 0) {
+                        logger_1.logger.warn(`Ollama stream ended with ${calls.size} tool call(s) still open; flushing before done`);
+                        const pending = [...calls.entries()].sort(([a], [b]) => a - b);
+                        calls.clear();
+                        for (const [index, call] of pending) {
+                            out += toolCallLine(index, call);
+                        }
+                    }
+                    out += line({
+                        model: ctx.requestedModel,
+                        created_at: createdAt,
+                        message: { role: "assistant", content: "" },
+                        done: true,
+                        done_reason: event.finishReason === "length" ? "length" : "stop",
+                        total_duration: 0,
+                        load_duration: 0,
+                        prompt_eval_count: usage?.inputTokens ?? 0,
+                        prompt_eval_duration: 0,
+                        eval_count: usage?.outputTokens ?? 0,
+                        eval_duration: 0,
+                    });
+                    return out;
+                }
+                case "error":
+                    finished = true;
+                    if (calls.size > 0) {
+                        logger_1.logger.warn(`Ollama stream ended with ${calls.size} tool call(s) still open; dropping`);
+                        calls.clear();
+                    }
+                    return line((0, ollama_adapter_1.fromCanonicalError)(event.error));
+            }
+        },
+        end() {
+            return "";
+        },
+    };
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalToolCalls = toCanonicalToolCalls;
+exports.toCanonicalTools = toCanonicalTools;
+exports.recordCallId = recordCallId;
+exports.resolveCallId = resolveCallId;
+exports.toOllamaToolCalls = toOllamaToolCalls;
+exports.toOllamaTools = toOllamaTools;
+exports.resolveToolName = resolveToolName;
+const errors_1 = require("../../utils/errors");
+const logger_1 = require("../../utils/logger");
+const tool_args_1 = require("../../utils/tool-args");
+// ============ DECODE: Ollama → Canonical ============
+function toCanonicalToolCalls(toolCalls, ids) {
+    return toolCalls.map((tc) => {
+        const args = tc?.function?.arguments;
+        return {
+            id: typeof tc?.id === "string" ? tc.id : ids(),
+            type: "function",
+            function: {
+                name: tc?.function?.name ?? "",
+                // `arguments` is normally an object (JSON.stringify it); a
+                // string is already the JSON encoding and passes through
+                // verbatim — same rule as the stream decoder.
+                arguments: typeof args === "string" ? args : JSON.stringify(args ?? {}),
+            },
+        };
+    });
+}
+/** Ollama `tools[]` → canonical tools; any non-`function` type →
+ * ValidationError naming it rather than a silent drop. */
+function toCanonicalTools(tools) {
+    return tools.map((t) => {
+        if (t.type !== "function") {
+            throw new errors_1.ValidationError(`Unsupported Ollama tool type "${String(t.type)}"`);
+        }
+        return {
+            type: "function",
+            function: {
+                name: t.function?.name ?? "",
+                ...(t.function?.description !== undefined && {
+                    description: t.function.description,
+                }),
+                ...(t.function?.parameters !== undefined && {
+                    parameters: t.function.parameters,
+                }),
+            },
+        };
+    });
+}
+function recordCallId(pending, name, id) {
+    const queue = pending.get(name);
+    if (queue) {
+        queue.push(id);
+    }
+    else {
+        pending.set(name, [id]);
+    }
+}
+/** Consume the oldest pending call id for `tool_name`. */
+function resolveCallId(pending, name) {
+    return pending.get(name)?.shift();
+}
+// ============ ENCODE: Canonical → Ollama ============
+function toOllamaToolCalls(toolCalls) {
+    return toolCalls.map((tc, index) => {
+        const parsed = (0, tool_args_1.parseToolArguments)(tc.function.arguments);
+        if (!parsed.valid) {
+            logger_1.logger.warn("Tool call arguments are not valid JSON; sending _invalid_arguments wrapper");
+        }
+        return {
+            id: tc.id,
+            function: {
+                index,
+                name: tc.function.name,
+                arguments: parsed.args,
+            },
+        };
+    });
+}
+/** Canonical tools → Ollama `tools[]` (definitions pass through). */
+function toOllamaTools(tools) {
+    if (!tools?.length)
+        return undefined;
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.function.name,
+            ...(t.function.description !== undefined && {
+                description: t.function.description,
+            }),
+            ...(t.function.parameters !== undefined && {
+                parameters: t.function.parameters,
+            }),
+        },
+    }));
+}
+/** The `tool_name` for a canonical tool message: the name of the
+ * matching earlier assistant call, else a ValidationError naming
+ * the id only (Ollama carries names, not call ids). */
+function resolveToolName(callNameById, toolCallId) {
+    const name = toolCallId !== undefined ? callNameById.get(toolCallId) : undefined;
+    if (name === undefined) {
+        throw new errors_1.ValidationError(`Ollama tool message has no matching tool call for tool_call_id "${toolCallId ?? ""}"`);
+    }
+    return name;
+}