babelgate 0.0.0 → 1.1.1

package/dist/services/proxy.service.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformError = void 0;
+exports.proxyRequest = proxyRequest;
+const env_config_1 = require("../config/env-config");
+const transformers_1 = require("../transformers");
+const adapters_1 = require("../transformers/adapters");
+const http_client_1 = require("./http-client");
+const stream_pipeline_1 = require("./stream-pipeline");
+const model_map_1 = require("../utils/model-map");
+const token_estimate_1 = require("../utils/token-estimate");
+const upstream_errors_1 = require("./upstream-errors");
+const canonical_schema_1 = require("../types/canonical.schema");
+const errors_1 = require("../utils/errors");
+Object.defineProperty(exports, "TransformError", { enumerable: true, get: function () { return errors_1.TransformError; } });
+const logger_1 = require("../utils/logger");
+/**
+ * Attach the spec §3.3 client-facing rendering to an upstream failure.
+ * Only real upstream error statuses (≥ 400) go through the mapping
+ * table — timeouts, transport failures and non-JSON 2xx replies already
+ * carry their final client-facing message.
+ */
+function toClientFacing(err, target) {
+    if (err.upstreamStatus !== undefined && err.upstreamStatus >= 400) {
+        err.clientError = (0, upstream_errors_1.toClientError)(target, err.upstreamStatus, err.upstreamBody, err.retryAfterSeconds);
+    }
+    return err;
+}
+/**
+ * The "<method>" in a "/v1beta/models/<m>:<method>" path — the text
+ * after the last ":" of the percent-decoded path, the same parsing the
+ * route's isSupportedPath uses.
+ */
+function methodFromPath(path) {
+    let decoded = path;
+    try {
+        decoded = decodeURIComponent(path);
+    }
+    catch {
+        // malformed escapes — fall back to the raw path
+    }
+    const colon = decoded.lastIndexOf(":");
+    return colon === -1 ? decoded : decoded.slice(colon + 1);
+}
+/**
+ * Provider-specific auth headers.
+ */
+function buildAuthHeaders(provider, apiKey) {
+    if (!apiKey)
+        return {};
+    switch (provider) {
+        case "openai":
+            return { Authorization: `Bearer ${apiKey}` };
+        case "anthropic":
+            return {
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            };
+        case "gemini":
+            return { "x-goog-api-key": apiKey };
+        case "ollama":
+            return {};
+    }
+}
+/**
+ * Full proxy orchestration:
+ *   path match → config → canonical boundary validation →
+ *   transform → upstream call → transform back.
+ *
+ * Returns null when the path doesn't belong to the configured source
+ * provider (route should call next() → 404).
+ * Throws ValidationError | UpstreamError | TransformError | ConfigurationError.
+ */
+async function proxyRequest(path, method, body, requestId, opts) {
+    // Cheap pre-check: only recognized provider API paths are proxied.
+    const isProviderPath = Object.values(transformers_1.PROVIDER_ROUTES)
+        .flat()
+        .some((r) => r.method === method && path.startsWith(r.pathPrefix));
+    if (!isProviderPath)
+        return null;
+    const config = (0, env_config_1.getConfig)();
+    const sourceApi = config.sourceApi;
+    const targetApi = config.targetApi;
+    // Match the incoming path to a route on the configured source provider
+    const route = (0, adapters_1.findSourceRoute)(sourceApi, method, path);
+    if (!route)
+        return null;
+    if (route.kind === "models") {
+        return proxyModelList(route, config, sourceApi, targetApi, requestId);
+    }
+    // Gemini paths carry a ":<method>" suffix — anything that isn't a
+    // method this route serves is refused before conversion, before any
+    // upstream call (spec §3.2, E11).
+    if (route.isSupportedPath?.(path) === false) {
+        throw new errors_1.NotSupportedError(`${methodFromPath(path)} is not supported`);
+    }
+    // Source → Canonical. The adapter may throw on malformed input —
+    // that's a client error (400), not a server error (500).
+    let canonical;
+    try {
+        canonical = transformers_1.adapters[sourceApi].toCanonicalRequest(body);
+    }
+    catch (err) {
+        throw new errors_1.ValidationError(`Malformed ${sourceApi} request: ${err instanceof Error ? err.message : "invalid body"}`, { requestId });
+    }
+    // Boundary validation: malformed client request → 400, not 500.
+    const parsed = canonical_schema_1.canonicalRequestSchema.safeParse(canonical);
+    if (!parsed.success) {
+        throw new errors_1.ValidationError("Malformed request body", {
+            requestId,
+            issues: parsed.error.issues.map((i) => ({
+                path: i.path.join("."),
+                message: i.message,
+            })),
+        });
+    }
+    // The model comes from the source path when the provider puts it there
+    // (Gemini), otherwise from the canonical request. An explicitly empty
+    // model in the path (e.g. /v1beta/models/:generateContent) is a client
+    // error, not something to send upstream.
+    const modelFromPath = route.modelFromPath?.(path);
+    if (modelFromPath === "") {
+        throw new errors_1.ValidationError(`Malformed ${sourceApi} request path: model is empty`, { requestId });
+    }
+    // §3.5: count_tokens is answered locally — a chars/4 estimate with the
+    // estimate header, never an upstream call.
+    if (route.kind === "count_tokens") {
+        logger_1.logger.info({ requestId, sourceApi }, "count_tokens answered locally");
+        return {
+            body: { input_tokens: (0, token_estimate_1.estimateInputTokens)(parsed.data) },
+            headers: { "x-babelgate-token-estimate": "true" },
+        };
+    }
+    // §3.5: MODEL_MAP rewrites the upstream-bound model; replies and
+    // stream encoders keep the name the client asked for.
+    const requestedModel = modelFromPath ?? parsed.data.model;
+    const model = (0, model_map_1.applyModelMap)(requestedModel, config.modelMap);
+    parsed.data.model = model;
+    // §3.5: TARGET_CONTEXT_WINDOW → canonical contextWindow (Ollama num_ctx).
+    if (config.targetContextWindow !== undefined) {
+        parsed.data.config = {
+            ...parsed.data.config,
+            contextWindow: config.targetContextWindow,
+        };
+    }
+    // Streaming (spec §3.2): a `stream` body flag on the JSON-body sources,
+    // the dedicated streaming endpoint on Gemini — which carries no body
+    // flag, so canonical.stream is set here for the target adapter's
+    // own streaming marker (openai stream_options, anthropic/ollama
+    // stream:true).
+    if (parsed.data.stream === true || route.isStreamPath?.(path) === true) {
+        parsed.data.stream = true;
+        return proxyChatStream(parsed.data, body, model, requestedModel, config, sourceApi, targetApi, requestId, opts);
+    }
+    const targetBody = transformers_1.adapters[targetApi].fromCanonicalRequest(parsed.data);
+    const targetRoute = transformers_1.PROVIDER_ROUTES[targetApi].find((r) => r.kind === "chat");
+    const url = `${config.targetBaseUrl}${targetRoute.requestPath(model)}`;
+    logger_1.logger.info({ requestId, sourceApi, targetApi, url, model, requestedModel }, "Forwarding request to upstream");
+    const upstream = await (0, http_client_1.postJson)({
+        url,
+        headers: buildAuthHeaders(targetApi, config.targetApiKey),
+        body: targetBody,
+        timeoutMs: config.upstreamTimeoutMs,
+        retries: config.upstreamRetries,
+        requestId,
+    }).catch((err) => {
+        throw err instanceof errors_1.UpstreamError
+            ? toClientFacing(err, targetApi)
+            : err;
+    });
+    if (upstream.status < 200 || upstream.status >= 300) {
+        const err = new errors_1.UpstreamError(`Upstream ${targetApi} returned ${upstream.status}`, upstream.status, upstream.body);
+        err.retryAfterSeconds = upstream.retryAfterSeconds;
+        throw toClientFacing(err, targetApi);
+    }
+    // Target → Canonical → Source. §3.5: replies carry the model name the
+    // client asked for, not the mapped name sent upstream.
+    const canonicalResp = transformers_1.adapters[targetApi].toCanonicalResponse(upstream.body, model);
+    canonicalResp.model = requestedModel;
+    // Adapter bug detection (non-production only): canonical response
+    // should always be schema-valid
+    if (process.env.NODE_ENV !== "production") {
+        const respParsed = canonical_schema_1.canonicalResponseSchema.safeParse(canonicalResp);
+        if (!respParsed.success) {
+            logger_1.logger.error({ requestId, issues: respParsed.error.issues }, "Canonical response failed schema validation — adapter bug");
+        }
+    }
+    logger_1.logger.info({
+        requestId,
+        sourceApi,
+        targetApi,
+        model,
+        requestedModel,
+        inputTokens: canonicalResp.usage?.inputTokens,
+        outputTokens: canonicalResp.usage?.outputTokens,
+        finishReason: canonicalResp.finishReason,
+        upstreamDurationMs: upstream.durationMs,
+    }, "Request completed");
+    const sourceBody = transformers_1.adapters[sourceApi].fromCanonicalResponse(canonicalResp);
+    return { body: sourceBody };
+}
+/**
+ * Streaming chat flow (spec §3.2): target decoder + source encoder,
+ * postStream for upstream bytes, runStreamPipeline for the pipe.
+ * All four adapters stream since v1.1 Task 7 — the v1.0.1
+ * streaming-refusal path is gone. A Gemini target uses the route's
+ * streamRequestPath (`:streamGenerateContent?alt=sse`); the others
+ * stream on the chat path.
+ */
+async function proxyChatStream(canonical, sourceRequest, model, requestedModel, config, sourceApi, targetApi, requestId, opts) {
+    const decoder = transformers_1.adapters[targetApi].createStreamDecoder(model);
+    const encoder = transformers_1.adapters[sourceApi].createStreamEncoder({
+        sourceRequest,
+        query: opts?.query ?? {},
+        requestedModel,
+    });
+    const targetBody = transformers_1.adapters[targetApi].fromCanonicalRequest(canonical);
+    const targetRoute = transformers_1.PROVIDER_ROUTES[targetApi].find((r) => r.kind === "chat");
+    const url = `${config.targetBaseUrl}${targetRoute.streamRequestPath?.(model) ?? targetRoute.requestPath(model)}`;
+    logger_1.logger.info({ requestId, sourceApi, targetApi, url, model, requestedModel, stream: true }, "Forwarding request to upstream");
+    // Client disconnect aborts the upstream request; upstreamAc lets the
+    // pipeline's end (terminal event, failure) tear it down too — a bare
+    // body cancel doesn't reach the request on every transport.
+    const upstreamAc = new AbortController();
+    const upstream = await (0, http_client_1.postStream)({
+        url,
+        headers: buildAuthHeaders(targetApi, config.targetApiKey),
+        body: targetBody,
+        timeoutMs: config.upstreamTimeoutMs,
+        retries: config.upstreamRetries,
+        requestId,
+        signal: opts?.signal
+            ? AbortSignal.any([opts.signal, upstreamAc.signal])
+            : upstreamAc.signal,
+    }).catch((err) => {
+        throw err instanceof errors_1.UpstreamError
+            ? toClientFacing(err, targetApi)
+            : err;
+    });
+    // Watch the event stream for the completion log line — the pipeline
+    // yields only encoded bytes, so the decoder is wrapped. Chunk contents
+    // are never logged (§3.2); only usage and the finish reason are.
+    const observed = [];
+    const recordingDecoder = {
+        feed(chunk) {
+            const events = decoder.feed(chunk);
+            observed.push(...events);
+            return events;
+        },
+        end() {
+            const events = decoder.end();
+            observed.push(...events);
+            return events;
+        },
+    };
+    const signal = opts?.signal ?? new AbortController().signal;
+    const chunks = (async function* () {
+        try {
+            yield* (0, stream_pipeline_1.runStreamPipeline)({
+                upstream: upstream.body,
+                decoder: recordingDecoder,
+                encoder,
+                idleMs: config.upstreamStreamIdleMs,
+                signal,
+            });
+        }
+        finally {
+            // Whatever ended the pipe — terminal event, in-stream error,
+            // client disconnect — the upstream request is done with.
+            upstreamAc.abort();
+        }
+        const last = observed.at(-1);
+        if (last?.type === "message_end") {
+            const usageEvent = observed.find((e) => e.type === "usage");
+            logger_1.logger.info({
+                requestId,
+                sourceApi,
+                targetApi,
+                model,
+                requestedModel,
+                stream: true,
+                inputTokens: usageEvent?.type === "usage"
+                    ? usageEvent.usage.inputTokens
+                    : undefined,
+                outputTokens: usageEvent?.type === "usage"
+                    ? usageEvent.usage.outputTokens
+                    : undefined,
+                finishReason: last.finishReason,
+                upstreamDurationMs: upstream.durationMs,
+            }, "Request completed");
+        }
+    })();
+    return { stream: { contentType: encoder.contentType, chunks } };
+}
+/**
+ * GET /models flow — no request body, response transforms through
+ * canonical like chat does.
+ */
+async function proxyModelList(route, config, sourceApi, targetApi, requestId) {
+    const targetRoute = transformers_1.PROVIDER_ROUTES[targetApi].find((r) => r.kind === "models");
+    const url = `${config.targetBaseUrl}${targetRoute.requestPath()}`;
+    logger_1.logger.info({ requestId, sourceApi, targetApi, url }, "Forwarding models list request to upstream");
+    const upstream = await (0, http_client_1.getJson)({
+        url,
+        headers: buildAuthHeaders(targetApi, config.targetApiKey),
+        timeoutMs: config.upstreamTimeoutMs,
+        retries: config.upstreamRetries,
+        requestId,
+    }).catch((err) => {
+        throw err instanceof errors_1.UpstreamError
+            ? toClientFacing(err, targetApi)
+            : err;
+    });
+    if (upstream.status < 200 || upstream.status >= 300) {
+        const err = new errors_1.UpstreamError(`Upstream ${targetApi} returned ${upstream.status}`, upstream.status, upstream.body);
+        err.retryAfterSeconds = upstream.retryAfterSeconds;
+        throw toClientFacing(err, targetApi);
+    }
+    const canonical = transformers_1.adapters[targetApi].toCanonicalModelList(upstream.body);
+    if (process.env.NODE_ENV !== "production") {
+        const parsed = canonical_schema_1.canonicalModelListSchema.safeParse(canonical);
+        if (!parsed.success) {
+            logger_1.logger.error({ requestId, issues: parsed.error.issues }, "Canonical model list failed schema validation — adapter bug");
+        }
+    }
+    logger_1.logger.info({ requestId, sourceApi, targetApi, modelCount: canonical.models.length }, "Models list completed");
+    const sourceBody = transformers_1.adapters[sourceApi].fromCanonicalModelList(canonical);
+    return { body: sourceBody };
+}

package/dist/services/stream-pipeline.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStreamPipeline = runStreamPipeline;
+const canonical_error_1 = require("../utils/canonical-error");
+/**
+ * upstream bytes → decoder → canonical events → encoder → client bytes
+ * (spec §3.2). Provider-agnostic; the adapters own all dialect knowledge.
+ *
+ * Termination rules: an upstream read error, undecodable data or an idle
+ * gap longer than `idleMs` ends the stream with the source dialect's
+ * in-stream error form (kind `timeout` for idle, `upstream` otherwise) —
+ * the client never sees a truncated message followed by silence. An
+ * encoded `message_end` or `error` event is terminal: the encoder's tail
+ * is written, the upstream read is cancelled and the pipe ends, even
+ * when the upstream keeps its body open. Aborting `signal` cancels the
+ * upstream read and ends the pipe quietly.
+ */
+async function* runStreamPipeline(opts) {
+    const { upstream, decoder, encoder, idleMs, signal } = opts;
+    const reader = upstream.getReader();
+    const cancel = () => {
+        reader.cancel().catch(() => { });
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    /** Terminal events never produce empty output — the encoder writes the
+     * provider's in-stream error form, then the stream ends. */
+    function* fail(kind, message) {
+        yield encoder.encode({
+            type: "error",
+            error: (0, canonical_error_1.makeCanonicalError)(kind, message),
+        });
+        const tail = encoder.end();
+        if (tail !== "")
+            yield tail;
+    }
+    /** Yields encoded bytes; returns true at the first terminal event
+     * (message_end or error — nothing may be encoded after it). */
+    function* encodeAll(events) {
+        for (const event of events) {
+            const encoded = encoder.encode(event);
+            if (encoded !== "")
+                yield encoded;
+            if (event.type === "message_end" || event.type === "error") {
+                return true;
+            }
+        }
+        return false;
+    }
+    try {
+        for (;;) {
+            if (signal.aborted) {
+                cancel();
+                return;
+            }
+            let timer;
+            let chunk;
+            try {
+                chunk = await Promise.race([
+                    reader.read(),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve("idle"), idleMs);
+                    }),
+                ]);
+            }
+            catch {
+                clearTimeout(timer);
+                cancel();
+                yield* fail("upstream", "Upstream stream read failed");
+                return;
+            }
+            clearTimeout(timer);
+            if (signal.aborted) {
+                cancel();
+                return;
+            }
+            if (chunk === "idle") {
+                cancel();
+                yield* fail("timeout", `Upstream stream idle for over ${idleMs}ms`);
+                return;
+            }
+            let events;
+            if (chunk.done) {
+                try {
+                    events = decoder.end();
+                }
+                catch {
+                    yield* fail("upstream", "Upstream sent a malformed stream");
+                    return;
+                }
+                yield* encodeAll(events);
+                const tail = encoder.end();
+                if (tail !== "")
+                    yield tail;
+                return;
+            }
+            try {
+                events = decoder.feed(chunk.value);
+            }
+            catch {
+                cancel();
+                yield* fail("upstream", "Upstream sent undecodable stream data");
+                return;
+            }
+            if (yield* encodeAll(events)) {
+                // Terminal event: end now even if the upstream keeps the body
+                // open — nothing may follow message_end or error.
+                const tail = encoder.end();
+                if (tail !== "")
+                    yield tail;
+                cancel();
+                return;
+            }
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", cancel);
+        cancel();
+    }
+}

package/dist/services/upstream-errors.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toClientError = toClientError;
+const transformers_1 = require("../transformers");
+const canonical_error_1 = require("../utils/canonical-error");
+/**
+ * The spec §3.3 upstream → client mapping, applied row by row.
+ *
+ * The *target* adapter parses the upstream body for its kind and message
+ * (`toCanonicalError` never throws; unrecognised bodies get the fallback
+ * message). This function then decides what the client sees:
+ *
+ * - authentication/permission → 502 "upstream" with the credentials
+ *   message (D1: the upstream rejected the *proxy's* key — a 401 would
+ *   wrongly tell the client its own key is bad). Decided on the parsed
+ *   kind, not the raw status, because e.g. Gemini reports a bad key as
+ *   400 + API_KEY_INVALID.
+ * - 400/422 → 400 invalid_request, 404 → not_found, 413 →
+ *   request_too_large, 429 → rate_limit, 503/529 → unavailable — the
+ *   message passes through, `Retry-After` too when present.
+ * - every other 5xx → 502 upstream (kindFromStatus calls a bare 500
+ *   "internal", but for the client it is an upstream condition, not a
+ *   proxy bug).
+ */
+function toClientError(target, upstreamStatus, upstreamBody, retryAfterSeconds) {
+    const upstream = transformers_1.adapters[target].toCanonicalError(upstreamStatus, upstreamBody);
+    if (upstream.kind === "authentication" || upstream.kind === "permission") {
+        return (0, canonical_error_1.makeCanonicalError)("upstream", `Upstream ${target} rejected the proxy's credentials (${upstreamStatus})`);
+    }
+    const kind = upstreamStatus >= 500 && upstream.kind !== "unavailable"
+        ? "upstream"
+        : upstream.kind;
+    return (0, canonical_error_1.makeCanonicalError)(kind, upstream.message, retryAfterSeconds);
+}