babelgate 0.0.0 → 1.1.0

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

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openaiAdapter = void 0;
+exports.toCanonicalRequest = toCanonicalRequest;
+exports.fromCanonicalRequest = fromCanonicalRequest;
+exports.toCanonicalResponse = toCanonicalResponse;
+exports.fromCanonicalResponse = fromCanonicalResponse;
+exports.toCanonicalModelList = toCanonicalModelList;
+exports.fromCanonicalModelList = fromCanonicalModelList;
+exports.mapToOpenaiFinishReason = mapToOpenaiFinishReason;
+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 logger_1 = require("../../utils/logger");
+const openai_stream_1 = require("./openai.stream");
+exports.openaiAdapter = {
+    toCanonicalRequest,
+    fromCanonicalRequest,
+    toCanonicalResponse,
+    fromCanonicalResponse,
+    toCanonicalModelList,
+    fromCanonicalModelList,
+    toCanonicalError,
+    fromCanonicalError,
+    createStreamDecoder: openai_stream_1.createStreamDecoder,
+    createStreamEncoder: openai_stream_1.createStreamEncoder,
+};
+// ============ REQUEST: OpenAI → Canonical ============
+function toCanonicalRequest(request) {
+    const messages = [];
+    let systemPrompt;
+    for (const msg of request.messages) {
+        if (msg.role === "system") {
+            systemPrompt = extractTextContent(msg);
+        }
+        messages.push(convertToCanonicalMessage(msg));
+    }
+    // Canonical has no field for `parallel_tool_calls` (a spec
+    // non-goal) — make the drop visible instead of silent, same as
+    // Anthropic's `disable_parallel_tool_use` (task 9).
+    if (request.parallel_tool_calls !== undefined) {
+        logger_1.logger.debug('Dropping request field "parallel_tool_calls" (no canonical equivalent)');
+    }
+    return {
+        model: request.model,
+        messages,
+        ...(systemPrompt && { systemPrompt }),
+        config: {
+            ...(request.temperature !== undefined &&
+                request.temperature !== null && { temperature: request.temperature }),
+            ...(request.max_tokens !== undefined &&
+                request.max_tokens !== null && { maxTokens: request.max_tokens }),
+            ...(request.top_p !== undefined &&
+                request.top_p !== null && { topP: request.top_p }),
+            ...(request.stop && {
+                stopSequences: Array.isArray(request.stop)
+                    ? request.stop
+                    : [request.stop],
+            }),
+            ...(request.n !== undefined &&
+                request.n !== null && { candidateCount: request.n }),
+            ...(request.seed !== undefined &&
+                request.seed !== null && { seed: request.seed }),
+            ...(request.frequency_penalty !== undefined &&
+                request.frequency_penalty !== null && {
+                frequencyPenalty: request.frequency_penalty,
+            }),
+            ...(request.presence_penalty !== undefined &&
+                request.presence_penalty !== null && {
+                presencePenalty: request.presence_penalty,
+            }),
+        },
+        ...(request.stream === true && { stream: true }),
+        ...(request.stream === false && { stream: false }),
+        ...(request.tools && { tools: toCanonicalTools(request.tools) }),
+        ...(request.tool_choice !== undefined && {
+            toolChoice: toCanonicalToolChoice(request.tool_choice),
+        }),
+    };
+}
+function toCanonicalTools(tools) {
+    return tools.map((tool) => {
+        if (tool.type !== "function" || !("function" in tool)) {
+            throw new errors_1.ValidationError(`Unsupported OpenAI tool type "${String(tool.type)}"`);
+        }
+        // `strict` has no canonical equivalent — dropped, but visibly.
+        if (tool.function.strict != null) {
+            logger_1.logger.debug('Dropping tool field "strict" (no canonical equivalent)');
+        }
+        return {
+            type: "function",
+            function: {
+                name: tool.function.name,
+                ...(tool.function.description !== undefined && {
+                    description: tool.function.description,
+                }),
+                ...(tool.function.parameters !== undefined && {
+                    parameters: tool.function.parameters,
+                }),
+            },
+        };
+    });
+}
+function toCanonicalToolChoice(choice) {
+    if (choice === "auto" || choice === "none" || choice === "required") {
+        return choice;
+    }
+    if (typeof choice === "object" &&
+        choice.type === "function" &&
+        typeof choice.function?.name === "string") {
+        return { type: "function", function: { name: choice.function.name } };
+    }
+    throw new errors_1.ValidationError(`Unsupported OpenAI tool_choice "${typeof choice === "object" ? String(choice.type) : String(choice)}"`);
+}
+function convertToCanonicalMessage(msg) {
+    const base = {
+        role: msg.role,
+        content: "",
+    };
+    if ("content" in msg && msg.content !== null) {
+        if (typeof msg.content === "string") {
+            base.content = msg.content;
+        }
+        else if (Array.isArray(msg.content)) {
+            base.content = msg.content.map(convertToCanonicalPart);
+        }
+    }
+    if ("tool_calls" in msg && msg.tool_calls) {
+        base.toolCalls = msg.tool_calls.map((tc) => {
+            if (tc.type !== "function" || !("function" in tc)) {
+                // e.g. type:"custom" — no canonical equivalent; 400 naming
+                // the type rather than silently filtering the call out.
+                throw new errors_1.ValidationError(`OpenAI tool call type "${String(tc.type)}" is not supported`);
+            }
+            return {
+                id: tc.id,
+                type: "function",
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                },
+            };
+        });
+    }
+    if ("tool_call_id" in msg && msg.tool_call_id) {
+        base.toolCallId = msg.tool_call_id;
+    }
+    if ("name" in msg && msg.name) {
+        base.name = msg.name;
+    }
+    return base;
+}
+function convertToCanonicalPart(part) {
+    if (part.type === "text" && part.text) {
+        return { type: "text", text: part.text };
+    }
+    if (part.type === "image_url" && part.image_url) {
+        const url = part.image_url.url;
+        if (url.startsWith("data:")) {
+            const [meta, data] = url.split(",");
+            const mimeType = (meta.split(":")[1]?.split(";")[0] ||
+                "image/png");
+            return {
+                type: "image",
+                image: { data, mimeType },
+            };
+        }
+        // URL-based images - store as text placeholder
+        return { type: "text", text: `[Image: ${url}]` };
+    }
+    return { type: "text", text: "" };
+}
+function extractTextContent(msg) {
+    if (!("content" in msg) || msg.content === null)
+        return "";
+    if (typeof msg.content === "string")
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n");
+    }
+    return "";
+}
+// ============ REQUEST: Canonical → OpenAI ============
+function fromCanonicalRequest(request) {
+    const messages = request.messages.map(convertFromCanonicalMessage);
+    const result = {
+        model: request.model,
+        messages,
+    };
+    if (request.config) {
+        const c = request.config;
+        if (c.temperature !== undefined)
+            result.temperature = c.temperature;
+        if (c.maxTokens !== undefined)
+            result.max_tokens = c.maxTokens;
+        if (c.topP !== undefined)
+            result.top_p = c.topP;
+        if (c.stopSequences && c.stopSequences.length > 0) {
+            result.stop = c.stopSequences;
+        }
+        if (c.candidateCount !== undefined)
+            result.n = c.candidateCount;
+        if (c.seed !== undefined)
+            result.seed = c.seed;
+        if (c.frequencyPenalty !== undefined) {
+            result.frequency_penalty = c.frequencyPenalty;
+        }
+        if (c.presencePenalty !== undefined) {
+            result.presence_penalty = c.presencePenalty;
+        }
+    }
+    if (request.tools && request.tools.length > 0) {
+        result.tools = request.tools.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.function.name,
+                ...(tool.function.description !== undefined && {
+                    description: tool.function.description,
+                }),
+                ...(tool.function.parameters !== undefined && {
+                    parameters: tool.function.parameters,
+                }),
+            },
+        }));
+    }
+    if (request.toolChoice !== undefined) {
+        result.tool_choice = request.toolChoice;
+    }
+    if (request.stream !== undefined) {
+        result.stream = request.stream;
+    }
+    if (request.stream === true) {
+        // Ask the upstream for a final usage chunk (spec §3.2).
+        result
+            .stream_options = { include_usage: true };
+    }
+    return result;
+}
+function convertFromCanonicalMessage(msg) {
+    const content = convertFromCanonicalContent(msg.content);
+    if (msg.role === "assistant") {
+        const assistantMsg = {
+            role: "assistant",
+            content: typeof content === "string" ? content : null,
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+            assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                },
+            }));
+        }
+        return assistantMsg;
+    }
+    if (msg.role === "tool") {
+        return {
+            role: "tool",
+            content: typeof content === "string" ? content : "",
+            tool_call_id: msg.toolCallId || "",
+        };
+    }
+    if (msg.role === "system") {
+        return {
+            role: "system",
+            content: typeof content === "string" ? content : "",
+        };
+    }
+    // User message
+    return { role: "user", content };
+}
+function convertFromCanonicalContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map((part) => {
+        if (part.type === "text") {
+            return { type: "text", text: part.text || "" };
+        }
+        if (part.type === "image" && part.image) {
+            return {
+                type: "image_url",
+                image_url: {
+                    url: `data:${part.image.mimeType};base64,${part.image.data}`,
+                },
+            };
+        }
+        return { type: "text", text: "" };
+    });
+}
+// ============ RESPONSE: OpenAI → Canonical ============
+function toCanonicalResponse(response, model) {
+    const choice = response.choices[0];
+    const message = {
+        role: "assistant",
+        content: choice?.message?.content ?? "",
+    };
+    if (choice?.message?.tool_calls) {
+        message.toolCalls = choice.message.tool_calls.map((tc) => {
+            if (tc.type !== "function" || !("function" in tc)) {
+                // e.g. type:"custom" — an upstream wire shape canonical
+                // cannot express; error naming the type (kind "upstream",
+                // like the stream decoder's undecodable-chunk error) rather
+                // than returning an empty toolCalls.
+                throw new errors_1.UpstreamError(`Upstream openai sent unsupported tool call type "${String(tc.type)}"`);
+            }
+            return {
+                id: tc.id,
+                type: "function",
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                },
+            };
+        });
+    }
+    return {
+        id: response.id,
+        model: model || response.model,
+        message,
+        finishReason: mapFinishReason(choice?.finish_reason),
+        usage: response.usage
+            ? {
+                inputTokens: response.usage.prompt_tokens,
+                outputTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens,
+            }
+            : undefined,
+        created: response.created,
+    };
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        case "tool_calls":
+        case "function_call":
+            return "tool_call";
+        case "content_filter":
+            return "content_filter";
+        default:
+            return "stop";
+    }
+}
+// ============ RESPONSE: Canonical → OpenAI ============
+function fromCanonicalResponse(response) {
+    const toolCalls = response.message.toolCalls?.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+        },
+    }));
+    return {
+        id: response.id || `chatcmpl-${(0, crypto_1.randomUUID)()}`,
+        object: "chat.completion",
+        created: response.created || Math.floor(Date.now() / 1000),
+        model: response.model,
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content: typeof response.message.content === "string"
+                        ? response.message.content
+                        : "",
+                    refusal: null,
+                    ...(toolCalls && { tool_calls: toolCalls }),
+                },
+                finish_reason: mapToOpenaiFinishReason(response.finishReason),
+                logprobs: null,
+            },
+        ],
+        usage: response.usage
+            ? {
+                prompt_tokens: response.usage.inputTokens,
+                completion_tokens: response.usage.outputTokens,
+                total_tokens: response.usage.totalTokens,
+            }
+            : undefined,
+    };
+}
+function toCanonicalModelList(response) {
+    const res = response;
+    return {
+        models: (res.data ?? [])
+            .filter((m) => Boolean(m.id))
+            .map((m) => ({
+            id: m.id,
+            created: m.created,
+            ownedBy: m.owned_by,
+        })),
+    };
+}
+function fromCanonicalModelList(list) {
+    return {
+        object: "list",
+        data: list.models.map((m) => ({
+            id: m.id,
+            object: "model",
+            created: m.created ?? 0,
+            owned_by: m.ownedBy ?? "babelgate",
+        })),
+    };
+}
+function mapToOpenaiFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        case "tool_call":
+            return "tool_calls";
+        case "content_filter":
+            return "content_filter";
+        default:
+            return "stop";
+    }
+}
+// ============ ERRORS ============
+const OPENAI_ERROR_TYPE = {
+    invalid_request: "invalid_request_error",
+    authentication: "authentication_error",
+    permission: "permission_error",
+    not_found: "not_found_error",
+    request_too_large: "invalid_request_error",
+    rate_limit: "rate_limit_error",
+    unsupported: "invalid_request_error",
+    upstream: "api_error",
+    unavailable: "service_unavailable_error",
+    timeout: "api_error",
+    internal: "api_error",
+};
+function toCanonicalError(status, body) {
+    const err = body?.error;
+    const message = typeof err?.message === "string" && err.message.length > 0
+        ? err.message
+        : `Upstream openai returned ${status}`;
+    return (0, canonical_error_1.makeCanonicalError)((0, canonical_error_1.kindFromStatus)(status), message);
+}
+function fromCanonicalError(err) {
+    return {
+        error: {
+            message: err.message,
+            type: OPENAI_ERROR_TYPE[err.kind],
+            param: null,
+            code: err.kind,
+        },
+    };
+}
+// Streaming lives in ./openai.stream — re-exported on the adapter above.

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

@@ -0,0 +1,229 @@
+"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 sse_1 = require("../../utils/sse");
+const openai_adapter_1 = require("./openai.adapter");
+const OPENAI_FINISH = {
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_call",
+    function_call: "tool_call",
+    content_filter: "content_filter",
+};
+/**
+ * OpenAI SSE → canonical events (spec §3.3): every `data:` line carries a
+ * complete chat.completion.chunk JSON payload, `data: [DONE]` ends the
+ * stream. Lines are handled individually — the blank-line event
+ * separators real OpenAI sends are just ignored, so recordings without
+ * them decode identically. Tool calls are re-keyed from wire
+ * `tool_calls[].index` to canonical indices in first-appearance order; a
+ * call closes when the finish chunk arrives (or at end-of-stream). The
+ * `choices: []` usage chunk is the usage event. A stream that ends
+ * without `[DONE]` 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 finish;
+    let usage;
+    let nextIndex = 0;
+    const callsByWire = new Map();
+    const openCalls = [];
+    function closeAll(out) {
+        for (const index of openCalls.splice(0)) {
+            out.push({ type: "tool_call_end", index });
+        }
+    }
+    function handleChunk(chunk, out) {
+        if (chunk.error) {
+            // In-stream error object (spec §3.3): ends the stream.
+            out.push({ type: "error", error: (0, openai_adapter_1.toCanonicalError)(502, chunk) });
+            finished = true;
+            return;
+        }
+        if (!started) {
+            started = true;
+            out.push({
+                type: "message_start",
+                id: typeof chunk.id === "string" ? chunk.id : ids(),
+                model: typeof chunk.model === "string" ? chunk.model : model,
+            });
+        }
+        for (const choice of chunk.choices ?? []) {
+            const delta = choice?.delta;
+            if (typeof delta?.content === "string" && delta.content.length > 0) {
+                out.push({ type: "text_delta", text: delta.content });
+            }
+            for (const tc of delta?.tool_calls ?? []) {
+                const wireIndex = typeof tc.index === "number" ? tc.index : 0;
+                let index = callsByWire.get(wireIndex);
+                if (index === undefined) {
+                    index = nextIndex++;
+                    callsByWire.set(wireIndex, index);
+                    openCalls.push(index);
+                    out.push({
+                        type: "tool_call_start",
+                        index,
+                        id: typeof tc.id === "string" ? tc.id : ids(),
+                        name: tc.function?.name ?? "",
+                    });
+                }
+                if (typeof tc.function?.arguments === "string" &&
+                    tc.function.arguments.length > 0) {
+                    out.push({
+                        type: "tool_call_delta",
+                        index,
+                        argumentsDelta: tc.function.arguments,
+                    });
+                }
+            }
+            if (choice?.finish_reason && finish === undefined) {
+                finish = OPENAI_FINISH[choice.finish_reason] ?? "unknown";
+                closeAll(out);
+            }
+        }
+        if (chunk.usage && usage === undefined) {
+            usage = {
+                inputTokens: chunk.usage.prompt_tokens ?? 0,
+                outputTokens: chunk.usage.completion_tokens ?? 0,
+                totalTokens: chunk.usage.total_tokens ??
+                    (chunk.usage.prompt_tokens ?? 0) +
+                        (chunk.usage.completion_tokens ?? 0),
+            };
+        }
+    }
+    function handleLine(line, out) {
+        if (finished || !line.startsWith("data:"))
+            return;
+        const data = line.slice(5).replace(/^ /, "");
+        if (data === "[DONE]") {
+            finished = true;
+            closeAll(out);
+            if (usage)
+                out.push({ type: "usage", usage });
+            out.push({ type: "message_end", finishReason: finish ?? "unknown" });
+            return;
+        }
+        if (data === "")
+            return;
+        let chunk;
+        try {
+            chunk = JSON.parse(data);
+        }
+        catch {
+            out.push({
+                type: "error",
+                error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream sent an undecodable stream chunk"),
+            });
+            finished = true;
+            return;
+        }
+        handleChunk(chunk, 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) {
+                closeAll(out);
+                out.push({
+                    type: "error",
+                    error: (0, canonical_error_1.makeCanonicalError)("upstream", "Upstream stream ended without completing"),
+                });
+            }
+            return out;
+        },
+    };
+}
+/**
+ * Canonical events → OpenAI SSE (spec §3.3): text deltas and tool-call
+ * pieces become chat.completion.chunk data lines; a usage event becomes
+ * the `choices: []` usage chunk, but only when the client asked for it
+ * (`stream_options.include_usage`); an error event is a
+ * `data: {"error":{…}}` line. `end()` writes `data: [DONE]`.
+ */
+function createStreamEncoder(ctx) {
+    const includeUsage = ctx.sourceRequest.stream_options?.include_usage === true;
+    const created = Math.floor(Date.now() / 1000);
+    let id = "chatcmpl-babelgate";
+    const chunk = (delta, finishReason = null) => (0, sse_1.formatSse)(JSON.stringify({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model: ctx.requestedModel,
+        choices: [
+            { index: 0, delta, logprobs: null, finish_reason: finishReason },
+        ],
+    }));
+    return {
+        contentType: "text/event-stream",
+        encode(event) {
+            switch (event.type) {
+                case "message_start":
+                    id = event.id;
+                    return chunk({ role: "assistant", content: "" });
+                case "text_delta":
+                    return chunk({ content: event.text });
+                case "tool_call_start":
+                    return chunk({
+                        tool_calls: [
+                            {
+                                index: event.index,
+                                id: event.id,
+                                type: "function",
+                                function: { name: event.name, arguments: "" },
+                            },
+                        ],
+                    });
+                case "tool_call_delta":
+                    return chunk({
+                        tool_calls: [
+                            {
+                                index: event.index,
+                                function: { arguments: event.argumentsDelta },
+                            },
+                        ],
+                    });
+                case "tool_call_end":
+                    return "";
+                case "usage":
+                    if (!includeUsage)
+                        return "";
+                    return (0, sse_1.formatSse)(JSON.stringify({
+                        id,
+                        object: "chat.completion.chunk",
+                        created,
+                        model: ctx.requestedModel,
+                        choices: [],
+                        usage: {
+                            prompt_tokens: event.usage.inputTokens,
+                            completion_tokens: event.usage.outputTokens,
+                            total_tokens: event.usage.totalTokens,
+                        },
+                    }));
+                case "message_end":
+                    return chunk({}, (0, openai_adapter_1.mapToOpenaiFinishReason)(event.finishReason));
+                case "error":
+                    return (0, sse_1.formatSse)(JSON.stringify((0, openai_adapter_1.fromCanonicalError)(event.error)));
+            }
+        },
+        end() {
+            return (0, sse_1.formatSse)("[DONE]");
+        },
+    };
+}