@dbx-tools/cli-model-proxy 0.3.44 → 0.4.0

package/lib/src/server.js

@@ -0,0 +1,515 @@
+/**
+ * OpenAI-compatible HTTP proxy in front of Databricks Model Serving.
+ *
+ * Databricks serving endpoints speak OpenAI wire formats, so this server is a
+ * thin pass-through: it resolves the request's (possibly fuzzy) `model` to a
+ * real endpoint id via the {@link DatabricksBackend}, stamps a fresh auth
+ * header, and forwards to the right Databricks URL:
+ *
+ *   - Chat Completions → `/serving-endpoints/<name>/invocations`, except for
+ *     Responses-only models (Codex) which are translated and sent to
+ *     `/serving-endpoints/responses`.
+ *   - Responses → native `/serving-endpoints/responses` (OpenAI-family) or
+ *     `/serving-endpoints/open-responses` (Claude/Gemini/…), body forwarded
+ *     as-is. No chat round-trip.
+ *
+ * Any OpenAI-compatible tool (iTerm, editors, the `openai` SDK, Codex CLI) can
+ * point its base URL at this server and use loose model names.
+ *
+ * Routes:
+ *   - `GET  /health`, `GET /`            liveness
+ *   - `GET  /v1/models`, `GET /models`   list resolvable endpoints. Emits the
+ *     OpenAI `{object:"list",data:[…]}` shape by default; when the request
+ *     looks like the Codex CLI (a `client_version` query param, which Codex
+ *     always sends) it emits Codex's `{models:[{slug,…}]}` shape instead, so
+ *     both standard OpenAI clients and Codex can enumerate the catalogue.
+ *   - `POST /v1/chat/completions`        proxy (also `/completions`,
+ *     `/v1/completions`, `/v1/embeddings`, and the un-prefixed variants)
+ *   - `POST /v1/responses`               OpenAI Responses API, forwarded to
+ *     Databricks' native Responses / Open Responses surface.
+ *
+ * @module
+ */
+import { createServer } from "node:http";
+import { async as asyncUtil, error, json, log } from "@dbx-tools/shared-core";
+import { classify, openaiChat, openaiResponses } from "@dbx-tools/shared-model";
+import { Agent } from "undici";
+import { DEFAULT_BIND_HOST, DEFAULT_PORT, DEFAULT_RETRY } from "./defaults.js";
+const { chatToResponsesRequest, responseToChatCompletion, sanitizeOpenResponsesRequest } = openaiResponses;
+const logger = log.logger("model-proxy/server");
+/**
+ * Dispatcher for every upstream call, with undici's inactivity timeouts
+ * DISABLED (`0`).
+ *
+ * A proxied turn is only as fast as the model behind it, and undici's
+ * defaults (300s `headersTimeout`, 300s `bodyTimeout`) are both wrong here.
+ * `bodyTimeout` is the killer: it measures the gap BETWEEN chunks, so a model
+ * that thinks for a while mid-stream - extended reasoning, a long tool round
+ * trip, a slow Genie/SQL step - trips it and undici tears the socket down
+ * with `UND_ERR_BODY_TIMEOUT`, which the client sees as a truncated stream.
+ *
+ * The proxy has no opinion on how long a model may take, so it imposes no
+ * deadline: the stream ends when the upstream ends it, or when the client
+ * hangs up (see {@link requestAbortSignal}). Callers that DO want a deadline
+ * should send one, the same as they would to OpenAI.
+ */
+const upstreamDispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
+/** POST routes forwarded to a serving endpoint (chat or Responses-only). */
+const PROXY_PATHS = new Set([
+    "/v1/chat/completions",
+    "/chat/completions",
+    "/v1/completions",
+    "/completions",
+    "/v1/embeddings",
+    "/embeddings",
+]);
+/** GET routes that list the resolvable model catalogue. */
+const MODELS_PATHS = new Set(["/v1/models", "/models"]);
+/** POST routes that carry an OpenAI Responses API body (native passthrough). */
+const RESPONSES_PATHS = new Set(["/v1/responses", "/responses"]);
+/**
+ * Extra request fields to strip before forwarding, on top of
+ * `openaiChat.UNSUPPORTED_CHAT_FIELDS`. Comma-separated in `PROXY_DROP_FIELDS`.
+ *
+ * An escape hatch: when a workspace or a new client version trips a field
+ * Databricks rejects, an operator can unblock themselves immediately instead of
+ * waiting on a release of this package.
+ */
+function extraDropFields() {
+    return (process.env.PROXY_DROP_FIELDS ?? "")
+        .split(",")
+        .map((field) => field.trim())
+        .filter((field) => field.length > 0);
+}
+/** Build (but do not start) the proxy HTTP server. */
+export function createProxyServer(backend, options = {}) {
+    const server = createServer((req, res) => {
+        void handleRequest(backend, options, req, res);
+    });
+    // Match the upstream policy on the INBOUND side: never cut a client off
+    // mid-turn. Node's defaults (300s `requestTimeout`, 60s `headersTimeout`)
+    // are sized for ordinary web traffic, not for holding a streamed model
+    // response open, and a client that hits one gets a dead socket rather than
+    // an error it can act on. `0` disables each; the turn now ends when the
+    // model is done or the client disconnects.
+    server.requestTimeout = 0;
+    server.headersTimeout = 0;
+    server.timeout = 0;
+    return server;
+}
+/**
+ * Signal that aborts when the client hangs up.
+ *
+ * Removing the timeouts means nothing else will ever end a forgotten request,
+ * so the client's own disconnect becomes the only backstop against an upstream
+ * call running on with no one to receive it. Passing this to `fetch` is what
+ * makes a cancelled turn (Ctrl-C, a closed tab, a killed CLI) release the
+ * Databricks-side stream instead of leaking it for the life of the process.
+ *
+ * Keyed off the RESPONSE, not the request: `IncomingMessage` emits `close` as
+ * soon as its body has been fully consumed, which on every POST here happens
+ * before the upstream call is even made - watching that would abort each turn
+ * instantly. `ServerResponse` emits `close` when the response finishes or the
+ * connection drops, so the `writableFinished` check separates "client left"
+ * from "we replied".
+ */
+function clientAbortSignal(res) {
+    const controller = new AbortController();
+    res.once("close", () => {
+        if (!res.writableFinished)
+            controller.abort();
+    });
+    return controller.signal;
+}
+/**
+ * POST a JSON body to a serving endpoint on the no-timeout
+ * {@link upstreamDispatcher}, cancelled via `signal`.
+ *
+ * Every upstream call goes through here so the timeout and cancellation policy
+ * is stated once. `dispatcher` is an undici extension that the DOM
+ * `RequestInit` Node compiles against does not declare, hence the local
+ * intersection type rather than a cast at each call site.
+ */
+async function upstreamFetch(url, headers, body, signal) {
+    const init = { method: "POST", headers, body, signal };
+    // `dispatcher` is an undici extension the DOM `RequestInit` doesn't declare,
+    // and it can't simply be typed on: `@types/node` pins its own `undici-types`
+    // copy, so the `Agent` from our `undici` dependency is a structurally
+    // identical but nominally different type than the one the global `fetch`
+    // signature expects. Attaching it structurally sidesteps a version skew that
+    // no cast expresses cleanly, and `fetch` reads it at runtime all the same.
+    Reflect.set(init, "dispatcher", upstreamDispatcher);
+    return fetch(url, init);
+}
+/**
+ * Delay (ms) a `429` response asks us to wait, from its `Retry-After` header,
+ * or `undefined` when absent/unparseable. Handles both header forms: an integer
+ * count of seconds, and an HTTP date to wait until (clamped to `>= 0`).
+ */
+export function parseRetryAfterMs(header, nowMs) {
+    if (!header)
+        return undefined;
+    const trimmed = header.trim();
+    if (/^\d+$/.test(trimmed))
+        return Number(trimmed) * 1000;
+    const when = Date.parse(trimmed);
+    if (Number.isNaN(when))
+        return undefined;
+    return Math.max(0, when - nowMs);
+}
+/**
+ * Backoff (ms) before retry `attempt` (0-based): exponential from
+ * `baseDelayMs`, capped at `maxDelayMs`, with up to +50% jitter so concurrent
+ * retries from one agent don't resynchronize into the next burst. A server-sent
+ * `Retry-After` wins outright (still capped), since the server knows better
+ * than our schedule when it will accept traffic again.
+ */
+export function backoffDelayMs(attempt, retry, retryAfterMs, jitter) {
+    if (retryAfterMs !== undefined)
+        return Math.min(retryAfterMs, retry.maxDelayMs);
+    const exponential = retry.baseDelayMs * 2 ** attempt;
+    const capped = Math.min(exponential, retry.maxDelayMs);
+    return Math.round(capped * (1 + jitter * 0.5));
+}
+/**
+ * {@link upstreamFetch} with in-proxy `429` handling. When `retry.enabled`, a
+ * 429 is retried up to `retry.maxRetries` times with {@link backoffDelayMs}
+ * backoff instead of being surfaced; the throttled response body is drained
+ * each time so the connection is released. The retry happens BEFORE the caller
+ * writes any status line, so it is transparent to both streaming and
+ * non-streaming paths - the client only ever sees the final response.
+ *
+ * Bails early (returning the 429) when retries are exhausted, when the client
+ * has hung up (`signal.aborted`), or when the response carries no `Retry-After`
+ * and we would otherwise loop blind past the cap.
+ */
+async function upstreamFetchRetrying(backend, url, headers, body, res, retry) {
+    const signal = clientAbortSignal(res);
+    const payload = JSON.stringify(body);
+    let response = await upstreamFetch(url, headers, payload, signal);
+    if (!retry.enabled)
+        return response;
+    for (let attempt = 0; response.status === 429 && attempt < retry.maxRetries; attempt++) {
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"), Date.now());
+        const delayMs = backoffDelayMs(attempt, retry, retryAfterMs, jitterFraction());
+        // Release the throttled response's socket before waiting; its body is an
+        // error payload we are choosing not to relay.
+        await response.body?.cancel().catch(() => { });
+        logger.warn("upstream 429; backing off", {
+            attempt: attempt + 1,
+            maxRetries: retry.maxRetries,
+            delayMs,
+            ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        });
+        try {
+            await asyncUtil.sleep(delayMs, signal);
+        }
+        catch {
+            // Client hung up mid-wait: return the last 429 rather than issue a
+            // request no one is listening for.
+            return response;
+        }
+        // Fresh auth header per attempt so a long backoff can't outlive the token.
+        const retryHeaders = { ...(await backend.authHeaders()), ...headers };
+        response = await upstreamFetch(url, retryHeaders, payload, signal);
+    }
+    return response;
+}
+/**
+ * Jitter fraction in `[0, 1)`. Split out so tests can stub determinism;
+ * `Math.random` is fine for spreading retry timing.
+ */
+function jitterFraction() {
+    return Math.random();
+}
+/**
+ * Build and start the proxy, resolving once it is accepting connections.
+ * Returns the server and its base URL (with the actually-bound port, so a
+ * `port: 0` request surfaces the OS-assigned port).
+ */
+export async function startProxyServer(backend, options = {}) {
+    const host = options.host ?? DEFAULT_BIND_HOST;
+    const port = options.port ?? DEFAULT_PORT;
+    const server = createProxyServer(backend, options);
+    await new Promise((resolve, reject) => {
+        const onError = (err) => reject(err);
+        server.once("error", onError);
+        server.listen(port, host, () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const boundPort = typeof address === "object" && address ? address.port : port;
+    return { server, url: `http://${host}:${boundPort}` };
+}
+async function handleRequest(backend, options, req, res) {
+    const rawUrl = req.url ?? "/";
+    const [path, query = ""] = rawUrl.split("?");
+    const routePath = path ?? "/";
+    try {
+        if (req.method === "GET" && (routePath === "/health" || routePath === "/")) {
+            sendJson(res, 200, { status: "ok" });
+            return;
+        }
+        if (options.apiKey && !isAuthorized(req, options.apiKey)) {
+            sendJson(res, 401, errorBody("invalid api key", "invalid_request_error"));
+            return;
+        }
+        if (req.method === "GET" && MODELS_PATHS.has(routePath)) {
+            // Codex always sends `?client_version=…`; use that to pick its list shape.
+            const wantsCodexShape = new URLSearchParams(query).has("client_version");
+            await handleModels(backend, res, wantsCodexShape);
+            return;
+        }
+        const retry = options.retry ?? DEFAULT_RETRY;
+        if (req.method === "POST" && RESPONSES_PATHS.has(routePath)) {
+            await handleResponses(backend, req, res, retry);
+            return;
+        }
+        if (req.method === "POST" && PROXY_PATHS.has(routePath)) {
+            await handleProxy(backend, req, res, retry);
+            return;
+        }
+        sendJson(res, 404, errorBody(`unsupported route ${req.method ?? "?"} ${routePath}`, "invalid_request_error"));
+    }
+    catch (err) {
+        const message = error.errorMessage(err);
+        logger.error("request failed", { path: routePath, error: message });
+        if (!res.headersSent)
+            sendJson(res, 500, errorBody(message, "proxy_error"));
+        else
+            res.end();
+    }
+}
+/**
+ * `GET /v1/models`: surface the serving catalogue. Two shapes:
+ *
+ *   - OpenAI (default): `{object:"list", data:[{id,object,created,owned_by}]}`,
+ *     what the `openai` SDK and most tools expect.
+ *   - Codex (`codexShape`): `{models:[{slug, display_name, …}]}`, the ChatGPT
+ *     backend shape the Codex CLI decodes. A response missing the top-level
+ *     `models` field makes Codex log "failed to decode models response", so it
+ *     gets its own envelope. Only chat endpoints are advertised to Codex.
+ */
+async function handleModels(backend, res, codexShape) {
+    const endpoints = await backend.models(true);
+    if (codexShape) {
+        const models = endpoints
+            .filter((endpoint) => classify.endpointCapabilities(endpoint).chat)
+            .map((endpoint) => ({
+            slug: endpoint.name,
+            display_name: endpoint.displayName ?? endpoint.name,
+            ...(endpoint.description ? { description: endpoint.description } : {}),
+            // Fields Codex's strict decoder requires on every model entry.
+            default_reasoning_level: "medium",
+            supported_reasoning_levels: [],
+            shell_type: "shell_command",
+            visibility: "list",
+            supported_in_api: true,
+        }));
+        sendJson(res, 200, { models });
+        return;
+    }
+    const data = endpoints.map((endpoint) => ({
+        id: endpoint.name,
+        object: "model",
+        created: 0,
+        owned_by: "databricks",
+    }));
+    sendJson(res, 200, { object: "list", data });
+}
+/**
+ * Resolve the request's model and forward a Chat Completions body. Responses-
+ * only models (Codex) are translated to a Responses request and posted to
+ * `/serving-endpoints/responses`; everything else goes to `/invocations`.
+ */
+async function handleProxy(backend, req, res, retry) {
+    const body = await readJsonBody(req);
+    const requested = typeof body.model === "string" ? body.model : undefined;
+    if (!requested) {
+        sendJson(res, 400, errorBody("missing 'model' in request body", "invalid_request_error"));
+        return;
+    }
+    const resolved = await backend.resolve(requested);
+    body.model = resolved.modelId;
+    if (backend.isResponsesOnly(resolved.modelId)) {
+        await proxyChatViaResponses(backend, body, requested, resolved.modelId, resolved.matched, res, retry);
+        return;
+    }
+    // This route forwards the client's body as-is, so anything Databricks refuses
+    // to parse fails the turn. Drop the known offenders rather than relaying a
+    // 400 the client can do nothing about.
+    const dropped = openaiChat.stripUnsupportedChatFields(body, extraDropFields());
+    const wantsStream = body.stream === true;
+    const headers = await backend.authHeaders();
+    headers["content-type"] = "application/json";
+    headers.accept = wantsStream ? "text/event-stream" : "application/json";
+    logger.info("proxy", {
+        requested,
+        resolved: resolved.modelId,
+        matched: resolved.matched,
+        upstream: "invocations",
+        stream: wantsStream,
+        ...(dropped.length > 0 ? { dropped } : {}),
+    });
+    const upstream = await upstreamFetchRetrying(backend, backend.invocationsUrl(resolved.modelId), headers, body, res, retry);
+    res.writeHead(upstream.status, {
+        "content-type": upstream.headers.get("content-type") ?? "application/json",
+        "x-resolved-model": resolved.modelId,
+    });
+    await streamBody(upstream, res);
+}
+/**
+ * Chat Completions client → Responses-only Databricks model: translate the
+ * request, POST to `/serving-endpoints/responses`, translate the reply back.
+ * Streaming is not translated yet - those clients should use `/v1/responses`.
+ */
+async function proxyChatViaResponses(backend, body, requested, modelId, matched, res, retry) {
+    const { responses, stream } = chatToResponsesRequest(body);
+    responses.model = modelId;
+    if (stream) {
+        sendJson(res, 400, errorBody(`model ${modelId} only supports the Responses API; use POST /v1/responses for streaming`, "invalid_request_error"));
+        return;
+    }
+    const headers = await backend.authHeaders();
+    headers["content-type"] = "application/json";
+    headers.accept = "application/json";
+    const upstreamUrl = backend.responsesUrl(modelId);
+    const forward = upstreamUrl.includes("/open-responses")
+        ? sanitizeOpenResponsesRequest(responses)
+        : responses;
+    logger.info("proxy", {
+        requested,
+        resolved: modelId,
+        matched,
+        upstream: upstreamUrl,
+        stream: false,
+    });
+    const upstream = await upstreamFetchRetrying(backend, upstreamUrl, headers, forward, res, retry);
+    if (!upstream.ok) {
+        const text = await upstream.text();
+        res.writeHead(upstream.status, { "content-type": "application/json" });
+        res.end(text || JSON.stringify(errorBody("upstream error", "proxy_error")));
+        return;
+    }
+    const responseJson = (await upstream.json());
+    sendJson(res, 200, responseToChatCompletion(responseJson, modelId));
+}
+/**
+ * `POST /v1/responses`: forward the Responses body to Databricks' native
+ * Responses / Open Responses surface (model stays in the body; URL is
+ * workspace-level). Streaming and non-streaming both pass through as-is.
+ *
+ * Open Responses (Claude/Gemini/…) only accepts `function` tools and
+ * `input_*` content part types, and rejects replayed Claude thinking
+ * blocks — so Codex's built-in tools, prior-turn `output_text`, and
+ * `redacted_thinking` / `thinking` / `reasoning` parts are rewritten or
+ * stripped there. The OpenAI `/responses` path keeps them - GPT supports
+ * those shapes.
+ */
+async function handleResponses(backend, req, res, retry) {
+    const body = await readJsonBody(req);
+    const requested = typeof body.model === "string" ? body.model : undefined;
+    if (!requested) {
+        sendJson(res, 400, errorBody("missing 'model' in request body", "invalid_request_error"));
+        return;
+    }
+    const resolved = await backend.resolve(requested);
+    body.model = resolved.modelId;
+    const upstreamUrl = backend.responsesUrl(resolved.modelId);
+    // Cross-provider Open Responses rejects non-function tools and `output_*`
+    // content parts in `input`; OpenAI `/responses` keeps Codex's native shapes.
+    const forward = upstreamUrl.includes("/open-responses")
+        ? sanitizeOpenResponsesRequest(body)
+        : body;
+    const wantsStream = forward.stream === true;
+    const headers = await backend.authHeaders();
+    headers["content-type"] = "application/json";
+    headers.accept = wantsStream ? "text/event-stream" : "application/json";
+    const stripped = Array.isArray(body.tools) &&
+        (!Array.isArray(forward.tools) || forward.tools.length !== body.tools.length);
+    logger.info("responses", {
+        requested,
+        resolved: resolved.modelId,
+        matched: resolved.matched,
+        upstream: upstreamUrl,
+        stream: wantsStream,
+        ...(stripped ? { strippedNonFunctionTools: true } : {}),
+    });
+    const upstream = await upstreamFetchRetrying(backend, upstreamUrl, headers, forward, res, retry);
+    res.writeHead(upstream.status, {
+        "content-type": upstream.headers.get("content-type") ?? "application/json",
+        "x-resolved-model": resolved.modelId,
+    });
+    await streamBody(upstream, res);
+}
+/**
+ * Pump an upstream `fetch` Response body to the Node response, chunk by chunk.
+ *
+ * A mid-stream upstream failure is logged rather than thrown: the status line
+ * and some number of chunks have already gone out, so there is no way left to
+ * turn it into an HTTP error and the only honest move is to end the response
+ * and say why in the log. Without this the read loop rejected into the caller's
+ * catch, which found `headersSent` and ended the response silently - making an
+ * upstream teardown indistinguishable from a clean finish.
+ */
+async function streamBody(upstream, res) {
+    const body = upstream.body;
+    if (!body) {
+        res.end();
+        return;
+    }
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value && !res.writableEnded)
+                res.write(Buffer.from(value));
+            if (res.writableEnded)
+                break;
+        }
+    }
+    catch (err) {
+        // An aborted request is the expected shape of a client hanging up, not a
+        // fault worth reporting at error level.
+        const aborted = res.writableEnded || !res.writable;
+        logger[aborted ? "info" : "error"]("stream ended early", {
+            error: error.errorMessage(err),
+        });
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        res.end();
+    }
+}
+/** True when the request carries the expected bearer token. */
+function isAuthorized(req, apiKey) {
+    const header = req.headers.authorization;
+    if (!header)
+        return false;
+    return header.replace(/^Bearer\s+/i, "").trim() === apiKey;
+}
+/**
+ * Drain a request body and parse it as a JSON object. An empty, malformed, or
+ * non-object body yields `{}`, which the callers reject as a missing `model`.
+ */
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return json.parseRecord(Buffer.concat(chunks).toString("utf8")) ?? {};
+}
+/** Serialize and send a JSON response. */
+function sendJson(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+/** OpenAI-shaped error envelope. */
+function errorBody(message, type) {
+    return { error: { message, type } };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAI-compatible HTTP proxy in front of Databricks Model Serving.\n *\n * Databricks serving endpoints speak OpenAI wire formats, so this server is a\n * thin pass-through: it resolves the request's (possibly fuzzy) `model` to a\n * real endpoint id via the {@link DatabricksBackend}, stamps a fresh auth\n * header, and forwards to the right Databricks URL:\n *\n *   - Chat Completions → `/serving-endpoints/<name>/invocations`, except for\n *     Responses-only models (Codex) which are translated and sent to\n *     `/serving-endpoints/responses`.\n *   - Responses → native `/serving-endpoints/responses` (OpenAI-family) or\n *     `/serving-endpoints/open-responses` (Claude/Gemini/…), body forwarded\n *     as-is. No chat round-trip.\n *\n * Any OpenAI-compatible tool (iTerm, editors, the `openai` SDK, Codex CLI) can\n * point its base URL at this server and use loose model names.\n *\n * Routes:\n *   - `GET  /health`, `GET /`            liveness\n *   - `GET  /v1/models`, `GET /models`   list resolvable endpoints. Emits the\n *     OpenAI `{object:\"list\",data:[…]}` shape by default; when the request\n *     looks like the Codex CLI (a `client_version` query param, which Codex\n *     always sends) it emits Codex's `{models:[{slug,…}]}` shape instead, so\n *     both standard OpenAI clients and Codex can enumerate the catalogue.\n *   - `POST /v1/chat/completions`        proxy (also `/completions`,\n *     `/v1/completions`, `/v1/embeddings`, and the un-prefixed variants)\n *   - `POST /v1/responses`               OpenAI Responses API, forwarded to\n *     Databricks' native Responses / Open Responses surface.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type Server, type ServerResponse } from \"node:http\";\nimport { async as asyncUtil, error, json, log } from \"@dbx-tools/shared-core\";\nimport { classify, openaiChat, openaiResponses } from \"@dbx-tools/shared-model\";\nimport { Agent } from \"undici\";\n\nimport type { DatabricksBackend } from \"./backend\";\nimport { DEFAULT_BIND_HOST, DEFAULT_PORT, DEFAULT_RETRY, type RetryConfig } from \"./defaults\";\n\nconst { chatToResponsesRequest, responseToChatCompletion, sanitizeOpenResponsesRequest } =\n  openaiResponses;\n\nconst logger = log.logger(\"model-proxy/server\");\n\n/**\n * Dispatcher for every upstream call, with undici's inactivity timeouts\n * DISABLED (`0`).\n *\n * A proxied turn is only as fast as the model behind it, and undici's\n * defaults (300s `headersTimeout`, 300s `bodyTimeout`) are both wrong here.\n * `bodyTimeout` is the killer: it measures the gap BETWEEN chunks, so a model\n * that thinks for a while mid-stream - extended reasoning, a long tool round\n * trip, a slow Genie/SQL step - trips it and undici tears the socket down\n * with `UND_ERR_BODY_TIMEOUT`, which the client sees as a truncated stream.\n *\n * The proxy has no opinion on how long a model may take, so it imposes no\n * deadline: the stream ends when the upstream ends it, or when the client\n * hangs up (see {@link requestAbortSignal}). Callers that DO want a deadline\n * should send one, the same as they would to OpenAI.\n */\nconst upstreamDispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });\n\n/** POST routes forwarded to a serving endpoint (chat or Responses-only). */\nconst PROXY_PATHS = new Set([\n  \"/v1/chat/completions\",\n  \"/chat/completions\",\n  \"/v1/completions\",\n  \"/completions\",\n  \"/v1/embeddings\",\n  \"/embeddings\",\n]);\n\n/** GET routes that list the resolvable model catalogue. */\nconst MODELS_PATHS = new Set([\"/v1/models\", \"/models\"]);\n\n/** POST routes that carry an OpenAI Responses API body (native passthrough). */\nconst RESPONSES_PATHS = new Set([\"/v1/responses\", \"/responses\"]);\n\n/**\n * Extra request fields to strip before forwarding, on top of\n * `openaiChat.UNSUPPORTED_CHAT_FIELDS`. Comma-separated in `PROXY_DROP_FIELDS`.\n *\n * An escape hatch: when a workspace or a new client version trips a field\n * Databricks rejects, an operator can unblock themselves immediately instead of\n * waiting on a release of this package.\n */\nfunction extraDropFields(): string[] {\n  return (process.env.PROXY_DROP_FIELDS ?? \"\")\n    .split(\",\")\n    .map((field) => field.trim())\n    .filter((field) => field.length > 0);\n}\n\n/** Options shared by {@link createProxyServer} and {@link startProxyServer}. */\nexport interface ProxyServerOptions {\n  /**\n   * When set, local clients must present this value as a bearer token\n   * (`Authorization: Bearer <key>`). Unset leaves the proxy open, which is fine\n   * for a loopback bind but should be paired with a key on a wider one.\n   */\n  apiKey?: string;\n  /**\n   * Policy for absorbing upstream 429s. Omitted defaults to {@link\n   * DEFAULT_RETRY} (retry on). See {@link RetryConfig}.\n   */\n  retry?: RetryConfig;\n}\n\n/** Options for {@link startProxyServer}, adding the listen address. */\nexport interface StartProxyOptions extends ProxyServerOptions {\n  host?: string;\n  port?: number;\n}\n\n/** Build (but do not start) the proxy HTTP server. */\nexport function createProxyServer(\n  backend: DatabricksBackend,\n  options: ProxyServerOptions = {},\n): Server {\n  const server = createServer((req, res) => {\n    void handleRequest(backend, options, req, res);\n  });\n  // Match the upstream policy on the INBOUND side: never cut a client off\n  // mid-turn. Node's defaults (300s `requestTimeout`, 60s `headersTimeout`)\n  // are sized for ordinary web traffic, not for holding a streamed model\n  // response open, and a client that hits one gets a dead socket rather than\n  // an error it can act on. `0` disables each; the turn now ends when the\n  // model is done or the client disconnects.\n  server.requestTimeout = 0;\n  server.headersTimeout = 0;\n  server.timeout = 0;\n  return server;\n}\n\n/**\n * Signal that aborts when the client hangs up.\n *\n * Removing the timeouts means nothing else will ever end a forgotten request,\n * so the client's own disconnect becomes the only backstop against an upstream\n * call running on with no one to receive it. Passing this to `fetch` is what\n * makes a cancelled turn (Ctrl-C, a closed tab, a killed CLI) release the\n * Databricks-side stream instead of leaking it for the life of the process.\n *\n * Keyed off the RESPONSE, not the request: `IncomingMessage` emits `close` as\n * soon as its body has been fully consumed, which on every POST here happens\n * before the upstream call is even made - watching that would abort each turn\n * instantly. `ServerResponse` emits `close` when the response finishes or the\n * connection drops, so the `writableFinished` check separates \"client left\"\n * from \"we replied\".\n */\nfunction clientAbortSignal(res: ServerResponse): AbortSignal {\n  const controller = new AbortController();\n  res.once(\"close\", () => {\n    if (!res.writableFinished) controller.abort();\n  });\n  return controller.signal;\n}\n\n/**\n * POST a JSON body to a serving endpoint on the no-timeout\n * {@link upstreamDispatcher}, cancelled via `signal`.\n *\n * Every upstream call goes through here so the timeout and cancellation policy\n * is stated once. `dispatcher` is an undici extension that the DOM\n * `RequestInit` Node compiles against does not declare, hence the local\n * intersection type rather than a cast at each call site.\n */\nasync function upstreamFetch(\n  url: string,\n  headers: Record<string, string>,\n  body: string,\n  signal: AbortSignal,\n): Promise<Response> {\n  const init: RequestInit = { method: \"POST\", headers, body, signal };\n  // `dispatcher` is an undici extension the DOM `RequestInit` doesn't declare,\n  // and it can't simply be typed on: `@types/node` pins its own `undici-types`\n  // copy, so the `Agent` from our `undici` dependency is a structurally\n  // identical but nominally different type than the one the global `fetch`\n  // signature expects. Attaching it structurally sidesteps a version skew that\n  // no cast expresses cleanly, and `fetch` reads it at runtime all the same.\n  Reflect.set(init, \"dispatcher\", upstreamDispatcher);\n  return fetch(url, init);\n}\n\n/**\n * Delay (ms) a `429` response asks us to wait, from its `Retry-After` header,\n * or `undefined` when absent/unparseable. Handles both header forms: an integer\n * count of seconds, and an HTTP date to wait until (clamped to `>= 0`).\n */\nexport function parseRetryAfterMs(header: string | null, nowMs: number): number | undefined {\n  if (!header) return undefined;\n  const trimmed = header.trim();\n  if (/^\\d+$/.test(trimmed)) return Number(trimmed) * 1000;\n  const when = Date.parse(trimmed);\n  if (Number.isNaN(when)) return undefined;\n  return Math.max(0, when - nowMs);\n}\n\n/**\n * Backoff (ms) before retry `attempt` (0-based): exponential from\n * `baseDelayMs`, capped at `maxDelayMs`, with up to +50% jitter so concurrent\n * retries from one agent don't resynchronize into the next burst. A server-sent\n * `Retry-After` wins outright (still capped), since the server knows better\n * than our schedule when it will accept traffic again.\n */\nexport function backoffDelayMs(\n  attempt: number,\n  retry: RetryConfig,\n  retryAfterMs: number | undefined,\n  jitter: number,\n): number {\n  if (retryAfterMs !== undefined) return Math.min(retryAfterMs, retry.maxDelayMs);\n  const exponential = retry.baseDelayMs * 2 ** attempt;\n  const capped = Math.min(exponential, retry.maxDelayMs);\n  return Math.round(capped * (1 + jitter * 0.5));\n}\n\n/**\n * {@link upstreamFetch} with in-proxy `429` handling. When `retry.enabled`, a\n * 429 is retried up to `retry.maxRetries` times with {@link backoffDelayMs}\n * backoff instead of being surfaced; the throttled response body is drained\n * each time so the connection is released. The retry happens BEFORE the caller\n * writes any status line, so it is transparent to both streaming and\n * non-streaming paths - the client only ever sees the final response.\n *\n * Bails early (returning the 429) when retries are exhausted, when the client\n * has hung up (`signal.aborted`), or when the response carries no `Retry-After`\n * and we would otherwise loop blind past the cap.\n */\nasync function upstreamFetchRetrying(\n  backend: DatabricksBackend,\n  url: string,\n  headers: Record<string, string>,\n  body: unknown,\n  res: ServerResponse,\n  retry: RetryConfig,\n): Promise<Response> {\n  const signal = clientAbortSignal(res);\n  const payload = JSON.stringify(body);\n  let response = await upstreamFetch(url, headers, payload, signal);\n  if (!retry.enabled) return response;\n\n  for (let attempt = 0; response.status === 429 && attempt < retry.maxRetries; attempt++) {\n    const retryAfterMs = parseRetryAfterMs(response.headers.get(\"retry-after\"), Date.now());\n    const delayMs = backoffDelayMs(attempt, retry, retryAfterMs, jitterFraction());\n    // Release the throttled response's socket before waiting; its body is an\n    // error payload we are choosing not to relay.\n    await response.body?.cancel().catch(() => {});\n    logger.warn(\"upstream 429; backing off\", {\n      attempt: attempt + 1,\n      maxRetries: retry.maxRetries,\n      delayMs,\n      ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),\n    });\n    try {\n      await asyncUtil.sleep(delayMs, signal);\n    } catch {\n      // Client hung up mid-wait: return the last 429 rather than issue a\n      // request no one is listening for.\n      return response;\n    }\n    // Fresh auth header per attempt so a long backoff can't outlive the token.\n    const retryHeaders = { ...(await backend.authHeaders()), ...headers };\n    response = await upstreamFetch(url, retryHeaders, payload, signal);\n  }\n  return response;\n}\n\n/**\n * Jitter fraction in `[0, 1)`. Split out so tests can stub determinism;\n * `Math.random` is fine for spreading retry timing.\n */\nfunction jitterFraction(): number {\n  return Math.random();\n}\n\n/**\n * Build and start the proxy, resolving once it is accepting connections.\n * Returns the server and its base URL (with the actually-bound port, so a\n * `port: 0` request surfaces the OS-assigned port).\n */\nexport async function startProxyServer(\n  backend: DatabricksBackend,\n  options: StartProxyOptions = {},\n): Promise<{ server: Server; url: string }> {\n  const host = options.host ?? DEFAULT_BIND_HOST;\n  const port = options.port ?? DEFAULT_PORT;\n  const server = createProxyServer(backend, options);\n  await new Promise<void>((resolve, reject) => {\n    const onError = (err: Error) => reject(err);\n    server.once(\"error\", onError);\n    server.listen(port, host, () => {\n      server.off(\"error\", onError);\n      resolve();\n    });\n  });\n  const address = server.address();\n  const boundPort = typeof address === \"object\" && address ? address.port : port;\n  return { server, url: `http://${host}:${boundPort}` };\n}\n\nasync function handleRequest(\n  backend: DatabricksBackend,\n  options: ProxyServerOptions,\n  req: IncomingMessage,\n  res: ServerResponse,\n): Promise<void> {\n  const rawUrl = req.url ?? \"/\";\n  const [path, query = \"\"] = rawUrl.split(\"?\");\n  const routePath = path ?? \"/\";\n  try {\n    if (req.method === \"GET\" && (routePath === \"/health\" || routePath === \"/\")) {\n      sendJson(res, 200, { status: \"ok\" });\n      return;\n    }\n    if (options.apiKey && !isAuthorized(req, options.apiKey)) {\n      sendJson(res, 401, errorBody(\"invalid api key\", \"invalid_request_error\"));\n      return;\n    }\n    if (req.method === \"GET\" && MODELS_PATHS.has(routePath)) {\n      // Codex always sends `?client_version=…`; use that to pick its list shape.\n      const wantsCodexShape = new URLSearchParams(query).has(\"client_version\");\n      await handleModels(backend, res, wantsCodexShape);\n      return;\n    }\n    const retry = options.retry ?? DEFAULT_RETRY;\n    if (req.method === \"POST\" && RESPONSES_PATHS.has(routePath)) {\n      await handleResponses(backend, req, res, retry);\n      return;\n    }\n    if (req.method === \"POST\" && PROXY_PATHS.has(routePath)) {\n      await handleProxy(backend, req, res, retry);\n      return;\n    }\n    sendJson(\n      res,\n      404,\n      errorBody(`unsupported route ${req.method ?? \"?\"} ${routePath}`, \"invalid_request_error\"),\n    );\n  } catch (err) {\n    const message = error.errorMessage(err);\n    logger.error(\"request failed\", { path: routePath, error: message });\n    if (!res.headersSent) sendJson(res, 500, errorBody(message, \"proxy_error\"));\n    else res.end();\n  }\n}\n\n/**\n * `GET /v1/models`: surface the serving catalogue. Two shapes:\n *\n *   - OpenAI (default): `{object:\"list\", data:[{id,object,created,owned_by}]}`,\n *     what the `openai` SDK and most tools expect.\n *   - Codex (`codexShape`): `{models:[{slug, display_name, …}]}`, the ChatGPT\n *     backend shape the Codex CLI decodes. A response missing the top-level\n *     `models` field makes Codex log \"failed to decode models response\", so it\n *     gets its own envelope. Only chat endpoints are advertised to Codex.\n */\nasync function handleModels(\n  backend: DatabricksBackend,\n  res: ServerResponse,\n  codexShape: boolean,\n): Promise<void> {\n  const endpoints = await backend.models(true);\n  if (codexShape) {\n    const models = endpoints\n      .filter((endpoint) => classify.endpointCapabilities(endpoint).chat)\n      .map((endpoint) => ({\n        slug: endpoint.name,\n        display_name: endpoint.displayName ?? endpoint.name,\n        ...(endpoint.description ? { description: endpoint.description } : {}),\n        // Fields Codex's strict decoder requires on every model entry.\n        default_reasoning_level: \"medium\",\n        supported_reasoning_levels: [] as string[],\n        shell_type: \"shell_command\",\n        visibility: \"list\",\n        supported_in_api: true,\n      }));\n    sendJson(res, 200, { models });\n    return;\n  }\n  const data = endpoints.map((endpoint) => ({\n    id: endpoint.name,\n    object: \"model\",\n    created: 0,\n    owned_by: \"databricks\",\n  }));\n  sendJson(res, 200, { object: \"list\", data });\n}\n\n/**\n * Resolve the request's model and forward a Chat Completions body. Responses-\n * only models (Codex) are translated to a Responses request and posted to\n * `/serving-endpoints/responses`; everything else goes to `/invocations`.\n */\nasync function handleProxy(\n  backend: DatabricksBackend,\n  req: IncomingMessage,\n  res: ServerResponse,\n  retry: RetryConfig,\n): Promise<void> {\n  const body = await readJsonBody(req);\n  const requested = typeof body.model === \"string\" ? body.model : undefined;\n  if (!requested) {\n    sendJson(res, 400, errorBody(\"missing 'model' in request body\", \"invalid_request_error\"));\n    return;\n  }\n\n  const resolved = await backend.resolve(requested);\n  body.model = resolved.modelId;\n\n  if (backend.isResponsesOnly(resolved.modelId)) {\n    await proxyChatViaResponses(\n      backend,\n      body,\n      requested,\n      resolved.modelId,\n      resolved.matched,\n      res,\n      retry,\n    );\n    return;\n  }\n\n  // This route forwards the client's body as-is, so anything Databricks refuses\n  // to parse fails the turn. Drop the known offenders rather than relaying a\n  // 400 the client can do nothing about.\n  const dropped = openaiChat.stripUnsupportedChatFields(body, extraDropFields());\n\n  const wantsStream = body.stream === true;\n  const headers = await backend.authHeaders();\n  headers[\"content-type\"] = \"application/json\";\n  headers.accept = wantsStream ? \"text/event-stream\" : \"application/json\";\n\n  logger.info(\"proxy\", {\n    requested,\n    resolved: resolved.modelId,\n    matched: resolved.matched,\n    upstream: \"invocations\",\n    stream: wantsStream,\n    ...(dropped.length > 0 ? { dropped } : {}),\n  });\n\n  const upstream = await upstreamFetchRetrying(\n    backend,\n    backend.invocationsUrl(resolved.modelId),\n    headers,\n    body,\n    res,\n    retry,\n  );\n\n  res.writeHead(upstream.status, {\n    \"content-type\": upstream.headers.get(\"content-type\") ?? \"application/json\",\n    \"x-resolved-model\": resolved.modelId,\n  });\n  await streamBody(upstream, res);\n}\n\n/**\n * Chat Completions client → Responses-only Databricks model: translate the\n * request, POST to `/serving-endpoints/responses`, translate the reply back.\n * Streaming is not translated yet - those clients should use `/v1/responses`.\n */\nasync function proxyChatViaResponses(\n  backend: DatabricksBackend,\n  body: Record<string, unknown>,\n  requested: string,\n  modelId: string,\n  matched: boolean,\n  res: ServerResponse,\n  retry: RetryConfig,\n): Promise<void> {\n  const { responses, stream } = chatToResponsesRequest(body);\n  responses.model = modelId;\n\n  if (stream) {\n    sendJson(\n      res,\n      400,\n      errorBody(\n        `model ${modelId} only supports the Responses API; use POST /v1/responses for streaming`,\n        \"invalid_request_error\",\n      ),\n    );\n    return;\n  }\n\n  const headers = await backend.authHeaders();\n  headers[\"content-type\"] = \"application/json\";\n  headers.accept = \"application/json\";\n\n  const upstreamUrl = backend.responsesUrl(modelId);\n  const forward = upstreamUrl.includes(\"/open-responses\")\n    ? sanitizeOpenResponsesRequest(responses)\n    : responses;\n\n  logger.info(\"proxy\", {\n    requested,\n    resolved: modelId,\n    matched,\n    upstream: upstreamUrl,\n    stream: false,\n  });\n\n  const upstream = await upstreamFetchRetrying(backend, upstreamUrl, headers, forward, res, retry);\n\n  if (!upstream.ok) {\n    const text = await upstream.text();\n    res.writeHead(upstream.status, { \"content-type\": \"application/json\" });\n    res.end(text || JSON.stringify(errorBody(\"upstream error\", \"proxy_error\")));\n    return;\n  }\n\n  const responseJson = (await upstream.json()) as Record<string, unknown>;\n  sendJson(res, 200, responseToChatCompletion(responseJson, modelId));\n}\n\n/**\n * `POST /v1/responses`: forward the Responses body to Databricks' native\n * Responses / Open Responses surface (model stays in the body; URL is\n * workspace-level). Streaming and non-streaming both pass through as-is.\n *\n * Open Responses (Claude/Gemini/…) only accepts `function` tools and\n * `input_*` content part types, and rejects replayed Claude thinking\n * blocks — so Codex's built-in tools, prior-turn `output_text`, and\n * `redacted_thinking` / `thinking` / `reasoning` parts are rewritten or\n * stripped there. The OpenAI `/responses` path keeps them - GPT supports\n * those shapes.\n */\nasync function handleResponses(\n  backend: DatabricksBackend,\n  req: IncomingMessage,\n  res: ServerResponse,\n  retry: RetryConfig,\n): Promise<void> {\n  const body = await readJsonBody(req);\n  const requested = typeof body.model === \"string\" ? body.model : undefined;\n  if (!requested) {\n    sendJson(res, 400, errorBody(\"missing 'model' in request body\", \"invalid_request_error\"));\n    return;\n  }\n\n  const resolved = await backend.resolve(requested);\n  body.model = resolved.modelId;\n\n  const upstreamUrl = backend.responsesUrl(resolved.modelId);\n  // Cross-provider Open Responses rejects non-function tools and `output_*`\n  // content parts in `input`; OpenAI `/responses` keeps Codex's native shapes.\n  const forward = upstreamUrl.includes(\"/open-responses\")\n    ? sanitizeOpenResponsesRequest(body)\n    : body;\n\n  const wantsStream = forward.stream === true;\n  const headers = await backend.authHeaders();\n  headers[\"content-type\"] = \"application/json\";\n  headers.accept = wantsStream ? \"text/event-stream\" : \"application/json\";\n\n  const stripped =\n    Array.isArray(body.tools) &&\n    (!Array.isArray(forward.tools) || forward.tools.length !== body.tools.length);\n\n  logger.info(\"responses\", {\n    requested,\n    resolved: resolved.modelId,\n    matched: resolved.matched,\n    upstream: upstreamUrl,\n    stream: wantsStream,\n    ...(stripped ? { strippedNonFunctionTools: true } : {}),\n  });\n\n  const upstream = await upstreamFetchRetrying(backend, upstreamUrl, headers, forward, res, retry);\n\n  res.writeHead(upstream.status, {\n    \"content-type\": upstream.headers.get(\"content-type\") ?? \"application/json\",\n    \"x-resolved-model\": resolved.modelId,\n  });\n  await streamBody(upstream, res);\n}\n\n/**\n * Pump an upstream `fetch` Response body to the Node response, chunk by chunk.\n *\n * A mid-stream upstream failure is logged rather than thrown: the status line\n * and some number of chunks have already gone out, so there is no way left to\n * turn it into an HTTP error and the only honest move is to end the response\n * and say why in the log. Without this the read loop rejected into the caller's\n * catch, which found `headersSent` and ended the response silently - making an\n * upstream teardown indistinguishable from a clean finish.\n */\nasync function streamBody(upstream: Response, res: ServerResponse): Promise<void> {\n  const body = upstream.body;\n  if (!body) {\n    res.end();\n    return;\n  }\n  const reader = body.getReader();\n  try {\n    for (;;) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (value && !res.writableEnded) res.write(Buffer.from(value));\n      if (res.writableEnded) break;\n    }\n  } catch (err) {\n    // An aborted request is the expected shape of a client hanging up, not a\n    // fault worth reporting at error level.\n    const aborted = res.writableEnded || !res.writable;\n    logger[aborted ? \"info\" : \"error\"](\"stream ended early\", {\n      error: error.errorMessage(err),\n    });\n  } finally {\n    await reader.cancel().catch(() => {});\n    res.end();\n  }\n}\n\n/** True when the request carries the expected bearer token. */\nfunction isAuthorized(req: IncomingMessage, apiKey: string): boolean {\n  const header = req.headers.authorization;\n  if (!header) return false;\n  return header.replace(/^Bearer\\s+/i, \"\").trim() === apiKey;\n}\n\n/**\n * Drain a request body and parse it as a JSON object. An empty, malformed, or\n * non-object body yields `{}`, which the callers reject as a missing `model`.\n */\nasync function readJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of req) {\n    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array));\n  }\n  return json.parseRecord(Buffer.concat(chunks).toString(\"utf8\")) ?? {};\n}\n\n/** Serialize and send a JSON response. */\nfunction sendJson(res: ServerResponse, status: number, body: unknown): void {\n  res.writeHead(status, { \"content-type\": \"application/json\" });\n  res.end(JSON.stringify(body));\n}\n\n/** OpenAI-shaped error envelope. */\nfunction errorBody(message: string, type: string): { error: { message: string; type: string } } {\n  return { error: { message, type } };\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/backend.ts","../src/cli.ts","../src/defaults.ts","../src/server.ts","../index.ts","../bin/dbx-tools-model-proxy.ts"],"version":"5.9.3"}