babelgate 0.0.0 → 1.1.0

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

@@ -0,0 +1,341 @@
+"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 gemini_adapter_1 = require("./gemini.adapter");
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/**
+ * Gemini `streamGenerateContent?alt=sse` → canonical events (spec §3.3,
+ * ai.google.dev/api/generate-content#method:-models.streamgeneratecontent
+ * and the GenerateContentResponse/Candidate/FunctionCall/UsageMetadata
+ * references there): each `data:` frame is a GenerateContentResponse.
+ * The first frame emits `message_start` (`responseId` → id,
+ * `modelVersion` → model). `candidates[0]` text parts become
+ * `text_delta`s (empty strings — e.g. thoughtSignature-only parts —
+ * emit nothing); `functionCall` parts arrive whole — each becomes
+ * start + one delta (`JSON.stringify(args)`) + end at sequential
+ * canonical indices, keeping the wire `id` when present and drawing
+ * from `ids` otherwise. `usageMetadata` is cumulative on every frame —
+ * the last one seen is emitted once as `usage` when a `finishReason`
+ * ends the stream; a stream that ends in function calls reports
+ * `tool_call`, `MAX_TOKENS` maps to `length` via `mapFinishReason`.
+ * An `{"error":{code,message,status}}` frame maps through
+ * `toCanonicalError` and ends the stream. A payload that parses as
+ * JSON but isn't a plain object, or `candidates`/`parts` that aren't
+ * arrays, is an undecodable chunk — one `error` event and the stream
+ * is finished. A stream ending without `finishReason` ends in an
+ * `error` event.
+ */
+function createStreamDecoder(model, ids = (0, ids_1.createIdGenerator)()) {
+    const utf8 = (0, sse_1.createUtf8Decoder)();
+    const sse = (0, sse_1.createSseParser)();
+    let started = false;
+    let finished = false;
+    let nextIndex = 0;
+    let sawToolCalls = false;
+    let usage;
+    function failUndecodable(out) {
+        out.push({
+            type: "error",
+            error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream sent an undecodable stream chunk"),
+        });
+        finished = true;
+    }
+    function handleObject(obj, out) {
+        // An in-stream {"error":{code,message,status}} frame — the same
+        // failure shape as a non-streaming error body.
+        if (obj.error != null) {
+            const code = typeof obj.error?.code === "number" ? obj.error.code : 500;
+            out.push({ type: "error", error: (0, gemini_adapter_1.toCanonicalError)(code, obj) });
+            finished = true;
+            return;
+        }
+        if (obj.candidates != null &&
+            (!Array.isArray(obj.candidates) ||
+                obj.candidates.some((c) => !isObj(c)))) {
+            failUndecodable(out);
+            return;
+        }
+        if (!started) {
+            started = true;
+            out.push({
+                type: "message_start",
+                id: typeof obj.responseId === "string" ? obj.responseId : ids(),
+                model: typeof obj.modelVersion === "string" ? obj.modelVersion : model,
+            });
+        }
+        // Single candidate (§2.2 — multiple candidates are out of scope),
+        // matching toCanonicalResponse's candidates[0].
+        const candidate = obj.candidates?.[0];
+        const parts = candidate?.content?.parts;
+        if (parts != null &&
+            (!Array.isArray(parts) || parts.some((p) => !isObj(p)))) {
+            failUndecodable(out);
+            return;
+        }
+        for (const part of parts ?? []) {
+            if (typeof part?.text === "string" && part.text.length > 0) {
+                out.push({ type: "text_delta", text: part.text });
+            }
+            const fc = part?.functionCall;
+            if (fc != null) {
+                if (typeof fc !== "object") {
+                    failUndecodable(out);
+                    return;
+                }
+                sawToolCalls = true;
+                const index = nextIndex++;
+                out.push({
+                    type: "tool_call_start",
+                    index,
+                    id: typeof fc.id === "string" ? fc.id : ids(),
+                    name: typeof fc.name === "string" ? fc.name : "",
+                });
+                out.push({
+                    type: "tool_call_delta",
+                    index,
+                    argumentsDelta: JSON.stringify(fc.args ?? {}),
+                });
+                out.push({ type: "tool_call_end", index });
+            }
+        }
+        // Cumulative token counts — the last frame's values win.
+        if (obj.usageMetadata != null)
+            usage = obj.usageMetadata;
+        const finishReason = candidate?.finishReason;
+        if (typeof finishReason === "string") {
+            if (usage != null) {
+                const input = usage.promptTokenCount ?? 0;
+                const output = usage.candidatesTokenCount ?? 0;
+                out.push({
+                    type: "usage",
+                    usage: {
+                        inputTokens: input,
+                        outputTokens: output,
+                        totalTokens: usage.totalTokenCount ?? input + output,
+                    },
+                });
+            }
+            out.push({
+                type: "message_end",
+                finishReason: sawToolCalls
+                    ? "tool_call"
+                    : (0, gemini_adapter_1.mapFinishReason)(finishReason),
+            });
+            finished = true;
+        }
+    }
+    function handleEvent(data, out) {
+        if (finished)
+            return;
+        let obj;
+        try {
+            obj = JSON.parse(data);
+        }
+        catch {
+            failUndecodable(out);
+            return;
+        }
+        if (!isObj(obj)) {
+            failUndecodable(out);
+            return;
+        }
+        handleObject(obj, out);
+    }
+    function drain(events, out) {
+        for (const e of events)
+            handleEvent(e.data, out);
+    }
+    return {
+        feed(chunk) {
+            const out = [];
+            drain(sse.feed(utf8(chunk)), out);
+            return out;
+        },
+        end() {
+            const out = [];
+            drain(sse.feed(utf8(new Uint8Array(0))), out);
+            drain(sse.end(), out);
+            if (!finished) {
+                out.push({
+                    type: "error",
+                    error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream stream ended without completing"),
+                });
+                finished = true;
+            }
+            return out;
+        },
+    };
+}
+/**
+ * Canonical events → Gemini streamGenerateContent responses (spec §3.3,
+ * §3.4): `ctx.query.alt === "sse"` selects `data: <response>\r\n\r\n`
+ * frames (`text/event-stream`); anything else is the streamed JSON
+ * array (`[`, elements separated by `,\r\n`, `]`) with content type
+ * `application/json` — the `]` still closes after an error element so
+ * the body stays valid JSON. `message_start` produces no element (the
+ * wire has no start frame); its id is echoed as `responseId` and
+ * `ctx.requestedModel` as `modelVersion` on every element. Each
+ * `text_delta` is one single-part candidate element; tool calls are
+ * buffered by canonical `index` until `tool_call_end`, then written as
+ * one element whose part is `functionCall{name, args, id}` — `args`
+ * via `parseToolArguments` (`{}` for empty, `_invalid_arguments`
+ * wrapper for invalid), `id` preserved since FunctionCall.id is a
+ * documented optional field. `usage` is held into the closing
+ * element's `usageMetadata`, which also carries the `finishReason`
+ * (`mapToGeminiFinishReason`). `error` becomes an
+ * `{"error":{code,message,status}}` element via `fromCanonicalError`.
+ * Calls still open at `message_end` flush in ascending canonical
+ * index just before the final element (one `logger.warn` naming the
+ * count); before `error` they are dropped. `message_end` and `error`
+ * are terminal: any event after them encodes to nothing.
+ */
+function createStreamEncoder(ctx) {
+    const sse = ctx.query.alt === "sse";
+    let finished = false;
+    let arrayOpen = false;
+    let arrayClosed = false;
+    let responseId;
+    let usage;
+    const calls = new Map();
+    /** One wire element: SSE `data:` frame, or the next JSON-array element. */
+    function element(obj) {
+        const json = JSON.stringify(obj);
+        if (sse)
+            return `data: ${json}\r\n\r\n`;
+        const prefix = arrayOpen ? ",\r\n" : "[";
+        arrayOpen = true;
+        return prefix + json;
+    }
+    /** A GenerateContentResponse carrying one candidate. */
+    function chunk(candidate) {
+        return element({
+            candidates: [{ index: 0, ...candidate }],
+            ...(responseId !== undefined && { responseId }),
+            modelVersion: ctx.requestedModel,
+        });
+    }
+    const toolCallChunk = (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({
+            content: {
+                role: "model",
+                parts: [
+                    {
+                        functionCall: {
+                            id: call.id,
+                            name: call.name,
+                            args: parsed.args,
+                        },
+                    },
+                ],
+            },
+        });
+    };
+    const warnUnknownIndex = (type, index) => {
+        logger_1.logger.warn(`Gemini stream encoder: ${type} for unknown tool-call index ${index}; dropping`);
+    };
+    return {
+        contentType: sse ? "text/event-stream" : "application/json",
+        encode(event) {
+            if (finished)
+                return "";
+            switch (event.type) {
+                case "message_start":
+                    responseId = event.id;
+                    return "";
+                case "text_delta":
+                    return chunk({
+                        content: {
+                            role: "model",
+                            parts: [{ text: event.text }],
+                        },
+                    });
+                case "tool_call_start":
+                    if (calls.has(event.index)) {
+                        logger_1.logger.warn(`Gemini stream encoder: ${event.type} for already-open tool-call index ${event.index}; keeping the first call`);
+                        return "";
+                    }
+                    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 toolCallChunk(call);
+                }
+                case "usage":
+                    usage = event.usage;
+                    return "";
+                case "message_end": {
+                    finished = true;
+                    let out = "";
+                    if (calls.size > 0) {
+                        logger_1.logger.warn(`Gemini stream ended with ${calls.size} tool call(s) still open; flushing before finishReason`);
+                        const pending = [...calls.entries()].sort(([a], [b]) => a - b);
+                        calls.clear();
+                        for (const [, call] of pending)
+                            out += toolCallChunk(call);
+                    }
+                    return (out +
+                        element({
+                            candidates: [
+                                {
+                                    index: 0,
+                                    content: { role: "model", parts: [] },
+                                    finishReason: (0, gemini_adapter_1.mapToGeminiFinishReason)(event.finishReason),
+                                },
+                            ],
+                            ...(usage !== undefined && {
+                                usageMetadata: {
+                                    promptTokenCount: usage.inputTokens,
+                                    candidatesTokenCount: usage.outputTokens,
+                                    totalTokenCount: usage.totalTokens,
+                                },
+                            }),
+                            ...(responseId !== undefined && { responseId }),
+                            modelVersion: ctx.requestedModel,
+                        }));
+                }
+                case "error":
+                    finished = true;
+                    if (calls.size > 0) {
+                        logger_1.logger.warn(`Gemini stream ended with ${calls.size} tool call(s) still open; dropping`);
+                        calls.clear();
+                    }
+                    return element((0, gemini_adapter_1.fromCanonicalError)(event.error));
+            }
+        },
+        end() {
+            if (sse || arrayClosed)
+                return "";
+            arrayClosed = true;
+            return arrayOpen ? "]" : "[]";
+        },
+    };
+}

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunctionCallPart = isFunctionCallPart;
+exports.isFunctionResponsePart = isFunctionResponsePart;
+exports.recordCallId = recordCallId;
+exports.resolveCallId = resolveCallId;
+exports.toCanonicalToolCalls = toCanonicalToolCalls;
+exports.toCanonicalToolMessages = toCanonicalToolMessages;
+exports.toCanonicalTools = toCanonicalTools;
+exports.toCanonicalToolChoice = toCanonicalToolChoice;
+exports.functionResponseContent = functionResponseContent;
+exports.functionCallPart = functionCallPart;
+exports.functionResponsePart = functionResponsePart;
+exports.appendFunctionResponsePart = appendFunctionResponsePart;
+exports.toolResultResponse = toolResultResponse;
+exports.toGeminiTools = toGeminiTools;
+exports.toGeminiToolConfig = toGeminiToolConfig;
+const errors_1 = require("../../utils/errors");
+const logger_1 = require("../../utils/logger");
+const tool_args_1 = require("../../utils/tool-args");
+const gemini_schema_1 = require("./gemini.schema");
+function isFunctionCallPart(part) {
+    return "functionCall" in part && part.functionCall != null;
+}
+function isFunctionResponsePart(part) {
+    return "functionResponse" in part && part.functionResponse != null;
+}
+function recordCallId(pending, name, id) {
+    const queue = pending.get(name);
+    if (queue) {
+        queue.push(id);
+    }
+    else {
+        pending.set(name, [id]);
+    }
+}
+/**
+ * Resolve the call id for a functionResponse: a wire `id` wins (and is
+ * consumed so it cannot match twice); otherwise the oldest pending call
+ * id for that name.
+ */
+function resolveCallId(pending, res) {
+    const queue = pending.get(res.name) ?? [];
+    if (res.id !== undefined) {
+        const i = queue.indexOf(res.id);
+        if (i !== -1)
+            queue.splice(i, 1);
+        return res.id;
+    }
+    return queue.shift();
+}
+/** Gemini functionCall parts → canonical toolCalls (wire id or generated). */
+function toCanonicalToolCalls(parts, ids) {
+    return parts.filter(isFunctionCallPart).map((part) => {
+        const call = part.functionCall;
+        return {
+            id: call.id ?? ids(),
+            type: "function",
+            function: {
+                name: call.name,
+                arguments: JSON.stringify(call.args ?? {}),
+            },
+        };
+    });
+}
+/** Gemini functionResponse parts → canonical tool messages. */
+function toCanonicalToolMessages(parts, pending) {
+    return parts.filter(isFunctionResponsePart).map((part) => {
+        const res = part.functionResponse;
+        const toolCallId = resolveCallId(pending, res);
+        if (!toolCallId) {
+            throw new errors_1.ValidationError(`Function response "${res.name}" has no matching function call in this request`);
+        }
+        return {
+            role: "tool",
+            toolCallId,
+            content: functionResponseContent(res),
+        };
+    });
+}
+/**
+ * Gemini `tools[]` → canonical tools. Only `functionDeclarations`
+ * entries have a canonical equivalent; any other tool type
+ * (`codeExecution`, `googleSearch`, `googleSearchRetrieval`, …) →
+ * ValidationError naming the key.
+ */
+function toCanonicalTools(tools) {
+    const declarations = [];
+    for (const tool of tools ?? []) {
+        for (const key of Object.keys(tool)) {
+            if (key !== "functionDeclarations") {
+                throw new errors_1.ValidationError(`Gemini tool type "${key}" is not supported`);
+            }
+        }
+        if ("functionDeclarations" in tool) {
+            declarations.push(...(tool.functionDeclarations ?? []));
+        }
+    }
+    if (declarations.length === 0)
+        return undefined;
+    return declarations.map((decl) => ({
+        type: "function",
+        function: {
+            name: decl.name,
+            ...(decl.description !== undefined && {
+                description: decl.description,
+            }),
+            ...(decl.parameters !== undefined && {
+                parameters: decl.parameters,
+            }),
+        },
+    }));
+}
+/** Gemini `toolConfig.functionCallingConfig` → canonical toolChoice. */
+function toCanonicalToolChoice(toolConfig) {
+    const fcc = toolConfig?.functionCallingConfig;
+    if (fcc?.mode === undefined)
+        return undefined;
+    switch (fcc.mode) {
+        case "AUTO":
+        case "MODE_UNSPECIFIED":
+            return "auto";
+        case "NONE":
+            return "none";
+        case "ANY": {
+            const names = fcc.allowedFunctionNames ?? [];
+            if (names.length === 0) {
+                return "required";
+            }
+            if (names.length === 1) {
+                return {
+                    type: "function",
+                    function: { name: names[0] },
+                };
+            }
+            throw new errors_1.ValidationError("Gemini functionCallingConfig with multiple allowedFunctionNames has no canonical equivalent");
+        }
+        default:
+            throw new errors_1.ValidationError(`Gemini functionCallingConfig mode "${fcc.mode}" is not supported`);
+    }
+}
+/** Gemini functionResponse → canonical tool-message content string. */
+function functionResponseContent(res) {
+    const response = res.response;
+    if (response !== null &&
+        typeof response === "object" &&
+        !Array.isArray(response)) {
+        const keys = Object.keys(response);
+        // Unwrap the { "content": "<string>" } wrapper this adapter emits
+        if (keys.length === 1 &&
+            typeof response.content === "string") {
+            return response.content;
+        }
+        return JSON.stringify(response);
+    }
+    return JSON.stringify(response ?? {});
+}
+// ============ ENCODE: Canonical → Gemini ============
+/** Canonical tool call → Gemini functionCall part (id dropped on the wire). */
+function functionCallPart(call) {
+    const parsed = (0, tool_args_1.parseToolArguments)(call.function.arguments);
+    if (!parsed.valid) {
+        logger_1.logger.warn("Tool call arguments are not valid JSON; sending _invalid_arguments wrapper");
+    }
+    return {
+        functionCall: { name: call.function.name, args: parsed.args },
+    };
+}
+/** Canonical tool message → Gemini functionResponse part. */
+function functionResponsePart(name, content) {
+    return {
+        functionResponse: {
+            name,
+            response: toolResultResponse(content),
+        },
+    };
+}
+/**
+ * Append a functionResponse part to `contents`, sharing the previous
+ * user turn when it consists solely of functionResponses.
+ */
+function appendFunctionResponsePart(contents, part) {
+    const last = contents[contents.length - 1];
+    if (last?.role === "user" &&
+        last.parts.every(isFunctionResponsePart)) {
+        last.parts.push(part);
+    }
+    else {
+        contents.push({ role: "user", parts: [part] });
+    }
+}
+/** Canonical tool-result content → Gemini functionResponse.response object. */
+function toolResultResponse(content) {
+    const text = typeof content === "string"
+        ? content
+        : content
+            .filter((p) => p.type === "text")
+            .map((p) => p.text ?? "")
+            .join("");
+    const parsed = (0, tool_args_1.parseToolArguments)(text);
+    if (parsed.valid && text.trim() !== "") {
+        return parsed.args;
+    }
+    return { content: text };
+}
+/**
+ * Canonical tools → a single Gemini `functionDeclarations` entry;
+ * parameters filtered to Google's documented schema subset (spec §3.4).
+ */
+function toGeminiTools(tools) {
+    if (!tools?.length)
+        return undefined;
+    return [
+        {
+            functionDeclarations: tools.map((tool) => ({
+                name: tool.function.name,
+                ...(tool.function.description !== undefined && {
+                    description: tool.function.description,
+                }),
+                ...(tool.function.parameters !== undefined && {
+                    parameters: (0, gemini_schema_1.toGeminiSchema)(tool.function.parameters),
+                }),
+            })),
+        },
+    ];
+}
+/** Canonical toolChoice → Gemini toolConfig.functionCallingConfig. */
+function toGeminiToolConfig(choice) {
+    if (choice === undefined)
+        return undefined;
+    return {
+        functionCallingConfig: toFunctionCallingConfig(choice),
+    };
+}
+function toFunctionCallingConfig(choice) {
+    if (choice === "auto")
+        return { mode: "AUTO" };
+    if (choice === "none")
+        return { mode: "NONE" };
+    if (choice === "required")
+        return { mode: "ANY" };
+    return {
+        mode: "ANY",
+        allowedFunctionNames: [choice.function.name],
+    };
+}