babelgate 1.1.1 → 1.2.0

package/dist/services/chat-stream.service.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyChatStream = proxyChatStream;
+const transformers_1 = require("../transformers");
+const registry_1 = require("../routing/registry");
+const route_log_1 = require("../routing/route-log");
+const errors_1 = require("../utils/errors");
+const http_client_1 = require("./http-client");
+const stream_pipeline_1 = require("./stream-pipeline");
+const attempt_targets_1 = require("./attempt-targets");
+/**
+ * Streaming chat over a RoutePlan (spec §3.2): per target — encode the
+ * canonical copy, postStream to its stream endpoint, pipe through
+ * runStreamPipeline. The postStream call resolves on response headers,
+ * so the attempt is what the §3.4 fallback decision hangs off: once 2xx
+ * headers arrive the target is committed and mid-stream failures end in
+ * an in-stream error, never a fallback. A Gemini target uses the
+ * route's streamRequestPath (:streamGenerateContent?alt=sse); the
+ * others stream on the chat path.
+ */
+async function proxyChatStream(input) {
+    const { source, sourceBody, canonical, requestedModel, plan, config, requestId, opts, } = input;
+    const encoder = transformers_1.adapters[source].createStreamEncoder({
+        sourceRequest: sourceBody,
+        query: opts?.query ?? {},
+        requestedModel,
+    });
+    const hops = [];
+    let result;
+    try {
+        result = await (0, attempt_targets_1.attemptTargets)(plan, config.registry, async (entry, target) => {
+            const decoder = transformers_1.adapters[entry.type].createStreamDecoder(target.model);
+            const targetBody = transformers_1.adapters[entry.type].fromCanonicalRequest((0, attempt_targets_1.canonicalForTarget)(canonical, entry, target));
+            const targetRoute = transformers_1.PROVIDER_ROUTES[entry.type].find((r) => r.kind === "chat");
+            const url = `${entry.baseUrl}${targetRoute.streamRequestPath?.(target.model) ??
+                targetRoute.requestPath(target.model)}`;
+            // 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: (0, registry_1.authHeaders)(entry),
+                body: targetBody,
+                timeoutMs: entry.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
+                    ? (0, attempt_targets_1.toClientFacing)(err, entry.type)
+                    : err;
+            });
+            return { upstream, upstreamAc, decoder };
+        }, { requestId, signal: opts?.signal, hops });
+    }
+    catch (err) {
+        (0, route_log_1.logRoute)({
+            requestId,
+            sourceApi: source,
+            requestedModel,
+            reason: plan.reason,
+            hops,
+            stream: true,
+        });
+        throw err;
+    }
+    const { upstream, upstreamAc, decoder } = result.value;
+    // Watch the event stream for the route 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: result.entry.streamIdleMs ?? config.upstreamStreamIdleMs,
+                signal,
+            });
+        }
+        finally {
+            // Whatever ended the pipe — terminal event, in-stream error,
+            // client disconnect — the upstream request is done with, and the
+            // route log line goes out exactly once (spec §3.4).
+            upstreamAc.abort();
+            const last = observed.at(-1);
+            const usageEvent = observed.find((e) => e.type === "usage");
+            (0, route_log_1.logRoute)({
+                requestId,
+                sourceApi: source,
+                requestedModel,
+                reason: plan.reason,
+                hops: result.hops,
+                winner: result.target.provider,
+                stream: true,
+                inputTokens: usageEvent?.type === "usage"
+                    ? usageEvent.usage.inputTokens
+                    : undefined,
+                outputTokens: usageEvent?.type === "usage"
+                    ? usageEvent.usage.outputTokens
+                    : undefined,
+                finishReason: last?.type === "message_end" ? last.finishReason : undefined,
+            });
+        }
+    })();
+    return {
+        stream: { contentType: encoder.contentType, chunks },
+        headers: {
+            "x-babelgate-provider": result.target.provider,
+            "x-babelgate-model": result.target.model,
+            "x-babelgate-attempts": String(result.hops.length),
+        },
+    };
+}

package/dist/services/chat.service.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyChat = proxyChat;
+const transformers_1 = require("../transformers");
+const registry_1 = require("../routing/registry");
+const route_log_1 = require("../routing/route-log");
+const canonical_schema_1 = require("../types/canonical.schema");
+const errors_1 = require("../utils/errors");
+const logger_1 = require("../utils/logger");
+const http_client_1 = require("./http-client");
+const attempt_targets_1 = require("./attempt-targets");
+/**
+ * Non-streaming chat over a RoutePlan: per target — encode with the
+ * registry provider's adapter, postJson with its URL, auth and
+ * timeouts; decode the reply → model := requestedModel → encode in the
+ * client's format (moved from proxy.service, spec §3.1). The route log
+ * line and the x-babelgate-* reply headers come from spec §3.4.
+ */
+async function proxyChat(input) {
+    const { source, canonical, requestedModel, plan, config, requestId } = input;
+    const hops = [];
+    let result;
+    try {
+        result = await (0, attempt_targets_1.attemptTargets)(plan, config.registry, async (entry, target) => {
+            const targetBody = transformers_1.adapters[entry.type].fromCanonicalRequest((0, attempt_targets_1.canonicalForTarget)(canonical, entry, target));
+            const targetRoute = transformers_1.PROVIDER_ROUTES[entry.type].find((r) => r.kind === "chat");
+            const url = `${entry.baseUrl}${targetRoute.requestPath(target.model)}`;
+            const upstream = await (0, http_client_1.postJson)({
+                url,
+                headers: (0, registry_1.authHeaders)(entry),
+                body: targetBody,
+                timeoutMs: entry.timeoutMs ?? config.upstreamTimeoutMs,
+                retries: config.upstreamRetries,
+                requestId,
+            }).catch((err) => {
+                throw err instanceof errors_1.UpstreamError
+                    ? (0, attempt_targets_1.toClientFacing)(err, entry.type)
+                    : err;
+            });
+            if (upstream.status < 200 || upstream.status >= 300) {
+                const err = new errors_1.UpstreamError(`Upstream ${entry.type} returned ${upstream.status}`, upstream.status, upstream.body);
+                err.retryAfterSeconds = upstream.retryAfterSeconds;
+                throw (0, attempt_targets_1.toClientFacing)(err, entry.type);
+            }
+            return upstream;
+        }, { requestId, signal: input.opts?.signal, hops });
+    }
+    catch (err) {
+        (0, route_log_1.logRoute)({
+            requestId,
+            sourceApi: source,
+            requestedModel,
+            reason: plan.reason,
+            hops,
+            stream: false,
+        });
+        throw err;
+    }
+    // Target → Canonical → Source. §3.5: replies carry the model name the
+    // client asked for, not the routed name sent upstream.
+    const canonicalResp = transformers_1.adapters[result.entry.type].toCanonicalResponse(result.value.body, result.target.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");
+        }
+    }
+    (0, route_log_1.logRoute)({
+        requestId,
+        sourceApi: source,
+        requestedModel,
+        reason: plan.reason,
+        hops: result.hops,
+        winner: result.target.provider,
+        stream: false,
+        inputTokens: canonicalResp.usage?.inputTokens,
+        outputTokens: canonicalResp.usage?.outputTokens,
+        finishReason: canonicalResp.finishReason,
+    });
+    return {
+        body: transformers_1.adapters[source].fromCanonicalResponse(canonicalResp),
+        headers: {
+            "x-babelgate-provider": result.target.provider,
+            "x-babelgate-model": result.target.model,
+            "x-babelgate-attempts": String(result.hops.length),
+        },
+    };
+}

package/dist/services/models.service.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelListCache = createModelListCache;
+exports.resetModelListCache = resetModelListCache;
+exports.proxyModelList = proxyModelList;
+const transformers_1 = require("../transformers");
+const registry_1 = require("../routing/registry");
+const fallback_1 = require("../routing/fallback");
+const canonical_schema_1 = require("../types/canonical.schema");
+const errors_1 = require("../utils/errors");
+const logger_1 = require("../utils/logger");
+const http_client_1 = require("./http-client");
+const attempt_targets_1 = require("./attempt-targets");
+/** spec §3.6: each provider's model list is cached in memory for 60 s. */
+const MODEL_LIST_TTL_MS = 60_000;
+function createModelListCache(ttlMs = MODEL_LIST_TTL_MS, now = Date.now) {
+    const entries = new Map();
+    return {
+        get(provider, baseUrl) {
+            const hit = entries.get(`${provider} ${baseUrl}`);
+            if (hit === undefined || now() - hit.fetchedAt >= ttlMs) {
+                return undefined;
+            }
+            return hit.list;
+        },
+        set(provider, baseUrl, list) {
+            entries.set(`${provider} ${baseUrl}`, { list, fetchedAt: now() });
+        },
+        clear() {
+            entries.clear();
+        },
+    };
+}
+const sharedCache = createModelListCache();
+/** Tests reset the process-wide cache between cases. */
+function resetModelListCache() {
+    sharedCache.clear();
+}
+/**
+ * One provider's model list, decoded by that provider's own adapter
+ * into canonical. Non-2xx upstream replies become an UpstreamError
+ * carrying upstreamStatus, exactly as the v1.1 single-provider flow.
+ */
+async function fetchProviderModels(entry, source, config, requestId) {
+    const targetRoute = transformers_1.PROVIDER_ROUTES[entry.type].find((r) => r.kind === "models");
+    const url = `${entry.baseUrl}${targetRoute.requestPath()}`;
+    logger_1.logger.info({
+        requestId,
+        sourceApi: source,
+        provider: entry.name,
+        targetApi: entry.type,
+        url,
+    }, "Forwarding models list request to upstream");
+    const upstream = await (0, http_client_1.getJson)({
+        url,
+        headers: (0, registry_1.authHeaders)(entry),
+        timeoutMs: entry.timeoutMs ?? config.upstreamTimeoutMs,
+        retries: config.upstreamRetries,
+        requestId,
+    });
+    if (upstream.status < 200 || upstream.status >= 300) {
+        const err = new errors_1.UpstreamError(`Upstream ${entry.type} returned ${upstream.status}`, upstream.status, upstream.body);
+        err.retryAfterSeconds = upstream.retryAfterSeconds;
+        throw err;
+    }
+    return transformers_1.adapters[entry.type].toCanonicalModelList(upstream.body);
+}
+/**
+ * GET /models flow, spec §3.6: every registered provider's list is
+ * fetched in parallel (60 s cache, successful fetches only), merged
+ * and encoded once in the client's format. Order: aliases as bare
+ * names; the default provider's models bare (the v1.1 list); every
+ * other provider's models as <provider>/<model>. First occurrence
+ * wins on a duplicate id. A failed provider is omitted with a warn
+ * and x-babelgate-partial: true; if every provider fails, the default
+ * provider's error is returned exactly as v1.1 did.
+ */
+async function proxyModelList(source, route, config, requestId) {
+    const names = config.registry.names();
+    const defaultName = config.routing.defaultProvider;
+    const fetchCached = async (entry) => {
+        const cached = sharedCache.get(entry.name, entry.baseUrl);
+        if (cached !== undefined)
+            return cached;
+        const list = await fetchProviderModels(entry, source, config, requestId);
+        sharedCache.set(entry.name, entry.baseUrl, list);
+        return list;
+    };
+    const settled = await Promise.allSettled(names.map((name) => fetchCached(config.registry.get(name))));
+    const failed = settled
+        .map((r, i) => r.status === "rejected" ? { name: names[i], reason: r.reason } : null)
+        .filter((f) => f !== null);
+    if (failed.length === names.length) {
+        const reason = settled[names.indexOf(defaultName)].reason;
+        const entry = config.registry.get(defaultName);
+        throw reason instanceof errors_1.UpstreamError
+            ? (0, attempt_targets_1.toClientFacing)(reason, entry.type)
+            : reason;
+    }
+    // One warn per failed provider: name and status/outcome only —
+    // never a key or a response body.
+    for (const f of failed) {
+        const err = f.reason;
+        logger_1.logger.warn({
+            requestId,
+            provider: f.name,
+            outcome: err instanceof errors_1.UpstreamError
+                ? ((0, fallback_1.hopOutcome)(err) ?? "error")
+                : "error",
+            ...(err instanceof errors_1.UpstreamError &&
+                err.upstreamStatus !== undefined
+                ? { status: err.upstreamStatus }
+                : {}),
+        }, "Model list fetch failed; provider omitted");
+    }
+    const seen = new Set();
+    const merged = [];
+    const push = (model, id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        merged.push({ ...model, id });
+    };
+    for (const alias of Object.keys(config.routing.aliases)) {
+        push({ id: alias }, alias);
+    }
+    const pushProvider = (name, prefix) => {
+        const r = settled[names.indexOf(name)];
+        if (r?.status !== "fulfilled")
+            return;
+        for (const m of r.value.models) {
+            push(m, prefix ? `${name}/${m.id}` : m.id);
+        }
+    };
+    pushProvider(defaultName, false);
+    for (const name of names) {
+        if (name !== defaultName)
+            pushProvider(name, true);
+    }
+    const mergedList = { models: merged };
+    if (process.env.NODE_ENV !== "production") {
+        const parsed = canonical_schema_1.canonicalModelListSchema.safeParse(mergedList);
+        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: source,
+        modelCount: merged.length,
+        ...(failed.length > 0 ? { partial: true } : {}),
+    }, "Models list completed");
+    const result = {
+        body: transformers_1.adapters[source].fromCanonicalModelList(mergedList),
+    };
+    if (failed.length > 0) {
+        result.headers = { "x-babelgate-partial": "true" };
+    }
+    return result;
+}