babelgate 0.0.0 → 1.1.1

package/dist/utils/sse.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Stream wire utilities (spec §3.1, §3.3): incremental UTF-8 decoding,
+ * Server-Sent Events parsing/formatting and NDJSON line splitting.
+ * All are pure, stateful factories — one instance per request.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUtf8Decoder = createUtf8Decoder;
+exports.createSseParser = createSseParser;
+exports.formatSse = formatSse;
+exports.createLineSplitter = createLineSplitter;
+/**
+ * Incremental UTF-8 decoder: byte chunks may split a multi-byte character
+ * anywhere; strings pass through. Feeding an empty Uint8Array flushes any
+ * bytes left over at end-of-stream (a truncated trailing character becomes
+ * U+FFFD) and resets the decoder.
+ */
+function createUtf8Decoder() {
+    const decoder = new TextDecoder("utf-8");
+    return (chunk) => {
+        if (typeof chunk === "string")
+            return chunk;
+        return chunk.byteLength === 0
+            ? decoder.decode()
+            : decoder.decode(chunk, { stream: true });
+    };
+}
+/**
+ * Take the complete lines out of `buffer`, keyed on "\n" (a trailing "\r"
+ * is stripped, so "\r\n" split across chunks is handled). With `flush`,
+ * a final unterminated line is emitted too.
+ */
+function takeLines(buffer, flush) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] === "\n") {
+            let line = buffer.slice(start, i);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            lines.push(line);
+            start = i + 1;
+        }
+    }
+    let rest = buffer.slice(start);
+    if (flush && rest !== "") {
+        if (rest.endsWith("\r"))
+            rest = rest.slice(0, -1);
+        if (rest !== "")
+            lines.push(rest);
+        rest = "";
+    }
+    return { lines, rest };
+}
+/**
+ * Incremental SSE parser. Handles "\n" and "\r\n" endings, multi-line
+ * `data:` fields, and comment lines starting with ":"; `id:`, `retry:`
+ * and unknown fields are ignored. Events are dispatched on blank lines;
+ * one still buffered at end() is dispatched there. An event with no
+ * `data:` field is dropped.
+ */
+function createSseParser() {
+    let buffer = "";
+    let dataLines = [];
+    let hasData = false;
+    let eventType;
+    function dispatch(out) {
+        if (hasData) {
+            out.push({
+                ...(eventType !== undefined && { event: eventType }),
+                data: dataLines.join("\n"),
+            });
+        }
+        dataLines = [];
+        hasData = false;
+        eventType = undefined;
+    }
+    function processLines(lines, flush) {
+        const out = [];
+        for (const line of lines) {
+            if (line === "") {
+                dispatch(out);
+                continue;
+            }
+            if (line.startsWith(":"))
+                continue; // comment
+            const colon = line.indexOf(":");
+            const field = colon === -1 ? line : line.slice(0, colon);
+            let value = colon === -1 ? "" : line.slice(colon + 1);
+            if (value.startsWith(" "))
+                value = value.slice(1);
+            if (field === "data") {
+                dataLines.push(value);
+                hasData = true;
+            }
+            else if (field === "event") {
+                eventType = value;
+            }
+        }
+        if (flush)
+            dispatch(out);
+        return out;
+    }
+    return {
+        feed(text) {
+            buffer += text;
+            const taken = takeLines(buffer, false);
+            buffer = taken.rest;
+            return processLines(taken.lines, false);
+        },
+        end() {
+            const taken = takeLines(buffer, true);
+            buffer = taken.rest;
+            return processLines(taken.lines, true);
+        },
+    };
+}
+/** Render one SSE event: optional `event:` line, one `data:` per line. */
+function formatSse(data, event) {
+    const dataLines = data
+        .split("\n")
+        .map((line) => `data: ${line}`)
+        .join("\n");
+    return `${event !== undefined ? `event: ${event}\n` : ""}${dataLines}\n\n`;
+}
+/**
+ * Incremental splitter for line-delimited bodies (Ollama NDJSON).
+ * Returns non-empty lines only; a trailing partial line is held until
+ * it completes or end() flushes it.
+ */
+function createLineSplitter() {
+    let buffer = "";
+    function take(flush) {
+        const taken = takeLines(buffer, flush);
+        buffer = taken.rest;
+        return taken.lines.filter((line) => line !== "");
+    }
+    return {
+        feed(text) {
+            buffer += text;
+            return take(false);
+        },
+        end() {
+            return take(true);
+        },
+    };
+}

package/dist/utils/stream-reassemble.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reassembleStream = reassembleStream;
+const errors_1 = require("./errors");
+/**
+ * Fold a canonical event stream back into a CanonicalResponse — the inverse
+ * of streaming, used to compare streams against their non-streaming twins.
+ * Throws TransformError when the events break the spec §3.1 stream rules;
+ * an `error` event throws a ProxyError carrying that event's kind/status.
+ */
+function reassembleStream(events) {
+    let started = false;
+    let done = false;
+    let id = "";
+    let model = "";
+    let text = "";
+    let usage;
+    let finishReason;
+    const calls = new Map();
+    let nextIndex = 0;
+    function fail(why) {
+        throw new errors_1.TransformError(`Invalid canonical stream: ${why}`);
+    }
+    for (const event of events) {
+        if (done)
+            fail(`event "${event.type}" after the stream ended`);
+        if (!started && event.type !== "message_start") {
+            fail(`event "${event.type}" before message_start`);
+        }
+        switch (event.type) {
+            case "message_start":
+                if (started)
+                    fail("duplicate message_start");
+                started = true;
+                id = event.id;
+                model = event.model;
+                break;
+            case "text_delta":
+                text += event.text;
+                break;
+            case "tool_call_start":
+                if (event.index !== nextIndex) {
+                    fail(`tool_call_start index ${event.index}, expected ${nextIndex}`);
+                }
+                calls.set(event.index, {
+                    id: event.id,
+                    name: event.name,
+                    args: "",
+                    ended: false,
+                });
+                nextIndex++;
+                break;
+            case "tool_call_delta": {
+                const call = calls.get(event.index);
+                if (!call || call.ended) {
+                    fail(`tool_call_delta for index ${event.index} with no open call`);
+                }
+                call.args += event.argumentsDelta;
+                break;
+            }
+            case "tool_call_end": {
+                const call = calls.get(event.index);
+                if (!call || call.ended) {
+                    fail(`tool_call_end for index ${event.index} with no open call`);
+                }
+                call.ended = true;
+                break;
+            }
+            case "usage":
+                if (usage)
+                    fail("duplicate usage event");
+                usage = event.usage;
+                break;
+            case "message_end":
+                finishReason = event.finishReason;
+                done = true;
+                break;
+            case "error":
+                done = true;
+                throw new errors_1.ProxyError(event.error.message, event.error.status, event.error.kind.toUpperCase());
+        }
+    }
+    if (!done)
+        fail("stream ended without message_end or error");
+    const toolCalls = [...calls.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([, c]) => ({
+        id: c.id,
+        type: "function",
+        function: { name: c.name, arguments: c.args },
+    }));
+    return {
+        id,
+        model,
+        message: {
+            role: "assistant",
+            content: text,
+            ...(toolCalls.length > 0 && { toolCalls }),
+        },
+        // done without throwing ⇒ a message_end set finishReason
+        finishReason: finishReason,
+        ...(usage && { usage }),
+    };
+}

package/dist/utils/token-estimate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateInputTokens = estimateInputTokens;
+/**
+ * Local input-token estimate (spec §3.5): ceil(chars / 4) over the system
+ * prompt, message text, tool-call arguments, tool-result content and
+ * JSON.stringify(tools). A rough count — used for the locally answered
+ * count_tokens endpoint and the Anthropic message_start estimate, never
+ * billed against a real tokenizer.
+ */
+function estimateInputTokens(req) {
+    // Adapters keep the system text in BOTH systemPrompt and a system-role
+    // message — count it once, via whichever field carries it.
+    let chars = req.systemPrompt?.length ?? 0;
+    const systemInPrompt = req.systemPrompt !== undefined;
+    for (const message of req.messages) {
+        if (message.role === "system" && systemInPrompt) {
+            // duplicates req.systemPrompt — already counted
+        }
+        else if (typeof message.content === "string") {
+            chars += message.content.length;
+        }
+        else {
+            for (const part of message.content) {
+                if (part.type === "text" && part.text)
+                    chars += part.text.length;
+            }
+        }
+        for (const call of message.toolCalls ?? []) {
+            chars += call.function.arguments.length;
+        }
+    }
+    if (req.tools)
+        chars += JSON.stringify(req.tools).length;
+    return Math.ceil(chars / 4);
+}

package/dist/utils/tool-args.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToolArguments = parseToolArguments;
+/**
+ * Tool-call argument parsing (spec §3.4). Canonical arguments are the JSON
+ * string exactly as the provider sent it; encoders that need an object
+ * call this. On failure the raw string is preserved under
+ * `_invalid_arguments` so no information is lost.
+ */
+function parseToolArguments(json) {
+    if (json.trim() === "") {
+        return { args: {}, valid: true };
+    }
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            !Array.isArray(parsed)) {
+            return { args: parsed, valid: true };
+        }
+    }
+    catch {
+        // fall through to the invalid wrapper
+    }
+    return { args: { _invalid_arguments: json }, valid: false };
+}

package/package.json

@@ -1,13 +1,61 @@
 {
   "name": "babelgate",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "1.1.1",
+  "bin": {
+    "babelgate": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "node dist/index.js",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "nodemon --watch src --ext ts --exec \"ts-node -r dotenv/config src/index.ts\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "record:streams": "ts-node -r dotenv/config scripts/record-streams.ts",
+    "test:live": "vitest run --config vitest.live.config.ts",
+    "test:watch": "vitest",
+    "prepublishOnly": "./scripts/check.sh"
   },
   "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "commonjs"
+  "author": "Dorrabb Khan",
+  "license": "Apache-2.0",
+  "description": "babelgate — proxy that translates between LLM API formats (OpenAI, Gemini, Ollama, Anthropic) via a canonical intermediate format",
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.132.1",
+    "@google/generative-ai": "^0.24.1",
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.1.0",
+    "@types/pino": "^7.0.4",
+    "@types/supertest": "^7.2.1",
+    "msw": "^2.15.0",
+    "nodemon": "^3.1.10",
+    "ollama": "^0.6.4",
+    "openai": "^7.30.1",
+    "pino-pretty": "^13.2.0",
+    "supertest": "^7.3.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.1",
+    "express": "^5.1.0",
+    "pino": "^10.4.0",
+    "pino-http": "^11.0.0",
+    "zod": "^4.6.5"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dorrabbkhan/babelgate.git"
+  },
+  "bugs": "https://github.com/dorrabbkhan/babelgate/issues",
+  "homepage": "https://github.com/dorrabbkhan/babelgate#readme"
 }