babelgate 1.1.1 → 1.2.0

package/dist/services/proxy.service.js

@@ -5,27 +5,15 @@ 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 plan_route_1 = require("../routing/plan-route");
 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;
-}
+const chat_service_1 = require("./chat.service");
+const chat_stream_service_1 = require("./chat-stream.service");
+const models_service_1 = require("./models.service");
 /**
  * The "<method>" in a "/v1beta/models/<m>:<method>" path — the text
  * after the last ":" of the percent-decoded path, the same parsing the
@@ -43,32 +31,14 @@ function methodFromPath(path) {
     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:
+ * Thin entry over the routing layer (spec §3.1):
  *   path match → config → canonical boundary validation →
- *   transform → upstream call → transform back.
+ *   count_tokens → planRoute → chat/chat-stream/models services.
  *
- * Returns null when the path doesn't belong to the configured source
- * provider (route should call next() → 404).
+ * The client format comes from `opts.source` (the detect-source
+ * middleware's read of the request path, spec §3.2). Returns null when
+ * it is unset or the path doesn't belong to that source provider
+ * (route should call next() → 404).
  * Throws ValidationError | UpstreamError | TransformError | ConfigurationError.
  */
 async function proxyRequest(path, method, body, requestId, opts) {
@@ -79,14 +49,15 @@ async function proxyRequest(path, method, body, requestId, opts) {
     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 sourceApi = opts?.source;
+    if (!sourceApi)
+        return null;
+    // Match the incoming path to a route on the detected 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);
+        return (0, models_service_1.proxyModelList)(sourceApi, route, config, requestId);
     }
     // Gemini paths carry a ":<method>" suffix — anything that isn't a
     // method this route serves is refused before conversion, before any
@@ -122,27 +93,37 @@ async function proxyRequest(path, method, body, requestId, opts) {
     if (modelFromPath === "") {
         throw new errors_1.ValidationError(`Malformed ${sourceApi} request path: model is empty`, { requestId });
     }
+    // The chars/4 input estimate is computed once — count_tokens answers
+    // with it (§3.5) and routing `when` conditions consume it (§3.3).
+    const estimatedInputTokens = (0, token_estimate_1.estimateInputTokens)(parsed.data);
     // §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) },
+            body: { input_tokens: estimatedInputTokens },
             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.
+    // §3.3: resolve the model to an ordered list of targets — env mode
+    // produces MODEL_MAP routes then the single default provider.
     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,
-        };
-    }
+    const plan = (0, plan_route_1.planRoute)({
+        requestedModel,
+        estimatedInputTokens,
+        routing: config.routing,
+        providerNames: new Set(config.registry.names()),
+    });
+    const input = {
+        source: sourceApi,
+        sourceBody: body,
+        canonical: parsed.data,
+        requestedModel,
+        plan,
+        config,
+        requestId,
+        opts,
+    };
     // 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
@@ -150,180 +131,7 @@ async function proxyRequest(path, method, body, requestId, opts) {
     // 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");
-        }
+        return (0, chat_stream_service_1.proxyChatStream)(input);
     }
-    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 };
+    return (0, chat_service_1.proxyChat)(input);
 }

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

@@ -181,7 +181,7 @@ function fromCanonicalRequest(request) {
             }
             if (calls.length > 0) {
                 parts = parts.filter((p) => !("text" in p && p.text === ""));
-                parts.push(...calls.map(gemini_tools_1.functionCallPart));
+                parts.push(...calls.map((call) => (0, gemini_tools_1.functionCallPart)(call)));
             }
             contents.push({ role: "model", parts });
         }
@@ -326,9 +326,10 @@ function fromCanonicalResponse(response) {
         ? response.message.content
         : "";
     const toolCalls = response.message.toolCalls ?? [];
+    const callPart = (call) => (0, gemini_tools_1.functionCallPart)(call, { includeId: true });
     const parts = toolCalls.length > 0 && content === ""
-        ? toolCalls.map(gemini_tools_1.functionCallPart)
-        : [{ text: content }, ...toolCalls.map(gemini_tools_1.functionCallPart)];
+        ? toolCalls.map(callPart)
+        : [{ text: content }, ...toolCalls.map(callPart)];
     return {
         candidates: [
             {
@@ -340,6 +341,9 @@ function fromCanonicalResponse(response) {
                 index: 0,
             },
         ],
+        // §3.3: replies carry the requested model name — on the wire that's
+        // modelVersion, matching the stream encoder.
+        modelVersion: response.model,
         usageMetadata: response.usage
             ? {
                 promptTokenCount: response.usage.inputTokens,

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

@@ -156,14 +156,24 @@ function functionResponseContent(res) {
     return JSON.stringify(response ?? {});
 }
 // ============ ENCODE: Canonical → Gemini ============
-/** Canonical tool call → Gemini functionCall part (id dropped on the wire). */
-function functionCallPart(call) {
+/**
+ * Canonical tool call → Gemini functionCall part. `functionCall.id`
+ * is a documented optional field: the request encoder drops it
+ * (default — requests stay byte-identical), while the response
+ * encoder passes `includeId` so the client can echo
+ * `functionResponse.id` back, matching the stream encoder's shape.
+ */
+function functionCallPart(call, opts = {}) {
     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 },
+        functionCall: {
+            ...(opts.includeId === true && { id: call.id }),
+            name: call.function.name,
+            args: parsed.args,
+        },
     };
 }
 /** Canonical tool message → Gemini functionResponse part. */

package/dist/transformers/adapters/index.js

@@ -122,8 +122,7 @@ exports.PROVIDER_ROUTES = {
 };
 /**
  * Match an incoming request to a route on the given source provider
- * (method + path prefix). Used by resolve-source middleware and
- * proxy.service.
+ * (method + path prefix). Used by proxy.service.
  */
 function findSourceRoute(source, method, path) {
     return exports.PROVIDER_ROUTES[source].find((r) => r.method === method && path.startsWith(r.pathPrefix));

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

@@ -73,9 +73,12 @@ function toCanonicalRequest(request) {
             ...(opts.seed !== undefined && { seed: opts.seed }),
         };
     }
-    // Canonical treats absent and stream:false identically — only an
-    // explicit true survives, keeping the request round-trip idempotent.
-    if (request.stream === true) {
+    // Ollama's /api/chat streams NDJSON unless the client sends
+    // stream:false (api.md: "stream ... if false the response will be
+    // returned as a single response object"; default true) — so an
+    // omitted flag maps to canonical stream:true and only an explicit
+    // false opts out.
+    if (request.stream !== false) {
         result.stream = true;
     }
     if (request.tools && request.tools.length > 0) {

package/dist/utils/errors.js

@@ -6,6 +6,12 @@ class ProxyError extends Error {
     statusCode;
     code;
     context;
+    /**
+     * Extra response headers the error-handler sets before rendering —
+     * e.g. `x-babelgate-attempts` on errors after upstream attempts
+     * (spec §3.4).
+     */
+    responseHeaders;
     constructor(message, statusCode = 500, code = "PROXY_ERROR", context) {
         super(message);
         this.statusCode = statusCode;

package/dist/utils/model-map.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.globMatch = void 0;
 exports.parseModelMap = parseModelMap;
 exports.applyModelMap = applyModelMap;
 const errors_1 = require("./errors");
-/** `*` matches any run of characters; every other character is literal. */
-function globToRegExp(pattern) {
-    const escaped = pattern
-        .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
-        .replace(/\*/g, ".*");
-    return new RegExp(`^${escaped}$`);
-}
+const rules_1 = require("../routing/rules");
+// The glob matcher moved to routing/rules.ts with the routing layer;
+// re-exported so existing model-map imports keep working.
+var rules_2 = require("../routing/rules");
+Object.defineProperty(exports, "globMatch", { enumerable: true, get: function () { return rules_2.globMatch; } });
 /**
  * Comma-separated `glob=model` entries → ordered rules. An entry that
  * isn't `glob=model` (empty pattern or model, no `=`) is a configuration
@@ -32,7 +31,7 @@ function parseModelMap(value) {
 /** First matching rule wins; no match leaves the model unchanged. */
 function applyModelMap(model, rules) {
     for (const rule of rules) {
-        if (globToRegExp(rule.pattern).test(model))
+        if ((0, rules_1.globMatch)(rule.pattern, model))
             return rule.model;
     }
     return model;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelgate",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "bin": {
     "babelgate": "dist/cli.js"
   },
@@ -47,6 +47,7 @@
     "express": "^5.1.0",
     "pino": "^10.4.0",
     "pino-http": "^11.0.0",
+    "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },
   "engines": {