@dbx-tools/appkit-model-gateway 0.9.36

package/lib/src/routes.js

@@ -0,0 +1,158 @@
+/**
+ * Express adapters for the shared model-gateway service.
+ *
+ * @module
+ */
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { log } from "@dbx-tools/shared-core";
+import { ModelGatewayError } from "./gateway.js";
+import { UnsupportedGatewayFeatureError } from "./router.js";
+const logger = log.logger("appkit/model-gateway/http");
+/** Send the lightweight compatibility health response. */
+export function sendHealth(response) {
+    response.json({ ready: true });
+}
+/** Send the active principal's dynamic model catalogue. */
+export async function sendModels(gateway, request, response) {
+    const startedAt = Date.now();
+    logger.debug("models request", requestContext(request));
+    try {
+        const payload = await gateway.models(request.header("originator"), optionalSearch(request.query.search));
+        response.json(payload);
+        logger.debug("models response", {
+            ...requestContext(request),
+            elapsedMs: Date.now() - startedAt,
+            status: response.statusCode,
+        });
+    }
+    catch (error) {
+        logger.error("models request failed", {
+            ...requestContext(request),
+            elapsedMs: Date.now() - startedAt,
+            error,
+        });
+        sendError("openai-responses", response, error);
+    }
+}
+/** Execute and stream one model request through Express with cancellation. */
+export async function sendInference(gateway, protocol, request, response) {
+    const startedAt = Date.now();
+    const controller = new AbortController();
+    const abort = () => {
+        if (response.writableEnded)
+            return;
+        logger.debug("client disconnected", {
+            ...requestContext(request),
+            elapsedMs: Date.now() - startedAt,
+            protocol,
+        });
+        controller.abort(new Error("Model gateway client disconnected"));
+    };
+    request.once("aborted", abort);
+    response.once("close", abort);
+    try {
+        const body = record(request.body);
+        logger.debug("inference request", {
+            ...requestContext(request),
+            model: typeof body.model === "string" ? body.model : undefined,
+            protocol,
+            stream: body.stream === true,
+        });
+        const upstream = await gateway.inference(protocol, body, requestHeaders(request), controller.signal);
+        response.status(upstream.status);
+        upstream.headers.forEach((value, name) => response.setHeader(name, value));
+        if (!upstream.body) {
+            response.end();
+            logger.debug("inference response", {
+                ...requestContext(request),
+                elapsedMs: Date.now() - startedAt,
+                protocol,
+                status: upstream.status,
+                upstreamProtocol: upstream.headers.get("x-dbx-tools-upstream"),
+            });
+            return;
+        }
+        await pipeline(Readable.fromWeb(upstream.body), response);
+        logger.debug("inference stream completed", {
+            ...requestContext(request),
+            elapsedMs: Date.now() - startedAt,
+            protocol,
+            status: upstream.status,
+            upstreamProtocol: upstream.headers.get("x-dbx-tools-upstream"),
+        });
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            response.destroy();
+            return;
+        }
+        logger.error("inference request failed", {
+            ...requestContext(request),
+            elapsedMs: Date.now() - startedAt,
+            error,
+            protocol,
+        });
+        if (response.headersSent) {
+            response.destroy(error instanceof Error ? error : undefined);
+            return;
+        }
+        sendError(protocol, response, error);
+    }
+    finally {
+        request.off("aborted", abort);
+        response.off("close", abort);
+    }
+}
+function sendError(protocol, response, error) {
+    const status = error instanceof ModelGatewayError || error instanceof UnsupportedGatewayFeatureError
+        ? error.status
+        : 500;
+    const message = error instanceof Error ? error.message : "Model gateway request failed";
+    if (protocol === "anthropic-messages") {
+        response.status(status).json({
+            type: "error",
+            error: { type: status < 500 ? "invalid_request_error" : "api_error", message },
+        });
+        return;
+    }
+    response.status(status).json({
+        error: {
+            message,
+            type: status < 500 ? "invalid_request_error" : "api_error",
+            code: status,
+        },
+    });
+}
+function requestHeaders(request) {
+    const headers = new Headers();
+    for (const [name, raw] of Object.entries(request.headers)) {
+        if (typeof raw === "string")
+            headers.set(name, raw);
+        else if (Array.isArray(raw))
+            headers.set(name, raw.join(", "));
+    }
+    return headers;
+}
+function record(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    throw new ModelGatewayError(400, "Request body must be a JSON object");
+}
+function optionalSearch(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new ModelGatewayError(400, "search must be a string");
+    }
+    return value;
+}
+function requestContext(request) {
+    return {
+        method: request.method,
+        path: request.path,
+        requestId: request.header("x-request-id") ?? request.header("request-id"),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routes.js","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Express adapters for the shared model-gateway service.\n *\n * @module\n */\n\nimport { Readable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { ClientProtocol } from \"@dbx-tools/shared-model-gateway\";\nimport type express from \"express\";\n\nimport { ModelGateway, ModelGatewayError } from \"./gateway.ts\";\nimport { UnsupportedGatewayFeatureError } from \"./router.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway/http\");\n\n/** Send the lightweight compatibility health response. */\nexport function sendHealth(response: express.Response): void {\n  response.json({ ready: true });\n}\n\n/** Send the active principal's dynamic model catalogue. */\nexport async function sendModels(\n  gateway: ModelGateway,\n  request: express.Request,\n  response: express.Response,\n): Promise<void> {\n  const startedAt = Date.now();\n  logger.debug(\"models request\", requestContext(request));\n  try {\n    const payload = await gateway.models(\n      request.header(\"originator\"),\n      optionalSearch(request.query.search),\n    );\n    response.json(payload);\n    logger.debug(\"models response\", {\n      ...requestContext(request),\n      elapsedMs: Date.now() - startedAt,\n      status: response.statusCode,\n    });\n  } catch (error) {\n    logger.error(\"models request failed\", {\n      ...requestContext(request),\n      elapsedMs: Date.now() - startedAt,\n      error,\n    });\n    sendError(\"openai-responses\", response, error);\n  }\n}\n\n/** Execute and stream one model request through Express with cancellation. */\nexport async function sendInference(\n  gateway: ModelGateway,\n  protocol: ClientProtocol,\n  request: express.Request,\n  response: express.Response,\n): Promise<void> {\n  const startedAt = Date.now();\n  const controller = new AbortController();\n  const abort = () => {\n    if (response.writableEnded) return;\n    logger.debug(\"client disconnected\", {\n      ...requestContext(request),\n      elapsedMs: Date.now() - startedAt,\n      protocol,\n    });\n    controller.abort(new Error(\"Model gateway client disconnected\"));\n  };\n  request.once(\"aborted\", abort);\n  response.once(\"close\", abort);\n  try {\n    const body = record(request.body);\n    logger.debug(\"inference request\", {\n      ...requestContext(request),\n      model: typeof body.model === \"string\" ? body.model : undefined,\n      protocol,\n      stream: body.stream === true,\n    });\n    const upstream = await gateway.inference(\n      protocol,\n      body,\n      requestHeaders(request),\n      controller.signal,\n    );\n    response.status(upstream.status);\n    upstream.headers.forEach((value, name) => response.setHeader(name, value));\n    if (!upstream.body) {\n      response.end();\n      logger.debug(\"inference response\", {\n        ...requestContext(request),\n        elapsedMs: Date.now() - startedAt,\n        protocol,\n        status: upstream.status,\n        upstreamProtocol: upstream.headers.get(\"x-dbx-tools-upstream\"),\n      });\n      return;\n    }\n    await pipeline(Readable.fromWeb(upstream.body as never), response);\n    logger.debug(\"inference stream completed\", {\n      ...requestContext(request),\n      elapsedMs: Date.now() - startedAt,\n      protocol,\n      status: upstream.status,\n      upstreamProtocol: upstream.headers.get(\"x-dbx-tools-upstream\"),\n    });\n  } catch (error) {\n    if (controller.signal.aborted) {\n      response.destroy();\n      return;\n    }\n    logger.error(\"inference request failed\", {\n      ...requestContext(request),\n      elapsedMs: Date.now() - startedAt,\n      error,\n      protocol,\n    });\n    if (response.headersSent) {\n      response.destroy(error instanceof Error ? error : undefined);\n      return;\n    }\n    sendError(protocol, response, error);\n  } finally {\n    request.off(\"aborted\", abort);\n    response.off(\"close\", abort);\n  }\n}\n\nfunction sendError(protocol: ClientProtocol, response: express.Response, error: unknown): void {\n  const status =\n    error instanceof ModelGatewayError || error instanceof UnsupportedGatewayFeatureError\n      ? error.status\n      : 500;\n  const message = error instanceof Error ? error.message : \"Model gateway request failed\";\n  if (protocol === \"anthropic-messages\") {\n    response.status(status).json({\n      type: \"error\",\n      error: { type: status < 500 ? \"invalid_request_error\" : \"api_error\", message },\n    });\n    return;\n  }\n  response.status(status).json({\n    error: {\n      message,\n      type: status < 500 ? \"invalid_request_error\" : \"api_error\",\n      code: status,\n    },\n  });\n}\n\nfunction requestHeaders(request: express.Request): Headers {\n  const headers = new Headers();\n  for (const [name, raw] of Object.entries(request.headers)) {\n    if (typeof raw === \"string\") headers.set(name, raw);\n    else if (Array.isArray(raw)) headers.set(name, raw.join(\", \"));\n  }\n  return headers;\n}\n\nfunction record(value: unknown): Record<string, unknown> {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    return value as Record<string, unknown>;\n  }\n  throw new ModelGatewayError(400, \"Request body must be a JSON object\");\n}\n\nfunction optionalSearch(value: unknown): string | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\") {\n    throw new ModelGatewayError(400, \"search must be a string\");\n  }\n  return value;\n}\n\nfunction requestContext(request: express.Request): Record<string, unknown> {\n  return {\n    method: request.method,\n    path: request.path,\n    requestId: request.header(\"x-request-id\") ?? request.header(\"request-id\"),\n  };\n}\n"]}

package/lib/src/translation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Vercel AI SDK fallback translation between external gateway protocols.
+ *
+ * @module
+ */
+import type { GatewayRoute } from "@dbx-tools/shared-model-gateway";
+/** Translate one request through a provider-owned AI SDK model. */
+export declare function translateGatewayRequest(route: GatewayRoute, body: Readonly<Record<string, unknown>>, signal: AbortSignal): Promise<Response>;

package/lib/src/translation.js

@@ -0,0 +1,156 @@
+/**
+ * Vercel AI SDK fallback translation between external gateway protocols.
+ *
+ * @module
+ */
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenResponses } from "@ai-sdk/open-responses";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { getExecutionContext } from "@databricks/appkit";
+import { invoke, servingWire } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
+import { streamText } from "ai";
+import { decodeGatewayRequest } from "./protocols/decode.js";
+import { encodeGatewayResponse, encodeGatewayStream } from "./protocols/encode.js";
+const logger = log.logger("appkit/model-gateway/translation");
+/** Translate one request through a provider-owned AI SDK model. */
+export async function translateGatewayRequest(route, body, signal) {
+    const decoded = decodeGatewayRequest(route.clientProtocol, body);
+    logger.debug("decoded request", {
+        clientProtocol: route.clientProtocol,
+        messageCount: decoded.messages.length,
+        model: route.target.id,
+        stream: body.stream === true,
+        toolCount: Object.keys(decoded.tools).length,
+    });
+    const model = await translationModel(route);
+    const result = streamText({
+        model,
+        messages: decoded.messages,
+        allowSystemInMessages: true,
+        ...(Object.keys(decoded.tools).length > 0 ? { tools: decoded.tools } : {}),
+        ...(decoded.maxOutputTokens !== undefined ? { maxOutputTokens: decoded.maxOutputTokens } : {}),
+        ...(decoded.temperature !== undefined ? { temperature: decoded.temperature } : {}),
+        ...(decoded.topP !== undefined ? { topP: decoded.topP } : {}),
+        maxRetries: 0,
+        abortSignal: signal,
+        onError: ({ error }) => {
+            logger.error("stream failed", { error, model: route.target.id });
+        },
+        onAbort: () => {
+            logger.debug("translation aborted", { model: route.target.id });
+        },
+        onFinish: ({ finishReason, usage }) => {
+            logger.debug("translation finished", {
+                finishReason,
+                inputTokens: usage.inputTokens,
+                model: route.target.id,
+                outputTokens: usage.outputTokens,
+            });
+        },
+    });
+    if (body.stream === true) {
+        logger.debug("returning translated stream", {
+            clientProtocol: route.clientProtocol,
+            model: route.target.id,
+        });
+        return new Response(encodeGatewayStream(route.clientProtocol, route.target.id, result.stream), {
+            headers: {
+                "cache-control": "no-cache",
+                "content-type": "text/event-stream",
+                "x-accel-buffering": "no",
+            },
+        });
+    }
+    const [text, toolCalls, usage, finishReason] = await Promise.all([
+        result.text,
+        result.toolCalls,
+        result.usage,
+        result.finishReason,
+    ]);
+    logger.debug("returning translated response", {
+        clientProtocol: route.clientProtocol,
+        finishReason,
+        inputTokens: usage.inputTokens,
+        model: route.target.id,
+        outputTokens: usage.outputTokens,
+        toolCallCount: toolCalls.length,
+    });
+    return Response.json(encodeGatewayResponse(route.clientProtocol, route.target.id, {
+        text,
+        toolCalls: toolCalls,
+        usage,
+        finishReason,
+    }));
+}
+async function translationModel(route) {
+    const client = getExecutionContext().client;
+    const host = (await client.config.getHost()).toString();
+    const headers = await invoke.authHeaders(client);
+    if (route.target.capabilities.responses) {
+        logger.debug("selected Responses provider", { model: route.target.id });
+        return createOpenResponses({
+            name: "databricks-responses",
+            url: invoke.responsesUrl(host),
+            headers,
+        })(route.target.id);
+    }
+    if (route.target.capabilities.anthropic) {
+        logger.debug("selected Anthropic provider", { model: route.target.id });
+        return createAnthropic({
+            name: "databricks-anthropic",
+            baseURL: new URL("serving-endpoints/anthropic/v1", host).toString(),
+            authToken: bearerToken(headers),
+            headers,
+        })(route.target.id);
+    }
+    logger.debug("selected Chat provider", { model: route.target.id });
+    return createOpenAICompatible({
+        name: "databricks-chat",
+        baseURL: new URL("serving-endpoints", host).toString(),
+        headers,
+        supportsStructuredOutputs: true,
+        fetch: compatibleFetch,
+    }).chatModel(route.target.id);
+}
+async function compatibleFetch(input, init) {
+    const rewritten = await servingWire.rewriteServingRequest(input, init);
+    logger.debug("sending translated Chat request", {
+        rewritten: rewritten.input !== input || rewritten.init !== init,
+    });
+    const response = await fetch(rewritten.input, rewritten.init);
+    const responseDetails = {
+        contentType: response.headers.get("content-type"),
+        status: response.status,
+    };
+    if (response.ok)
+        logger.debug("received translated Chat response", responseDetails);
+    else
+        logger.warn("translated Chat request failed", responseDetails);
+    if (!response.body)
+        return response;
+    const headers = new Headers(response.headers);
+    if (headers.get("content-type")?.includes("text/event-stream")) {
+        return new Response(servingWire.rewriteServingResponseStream(response.body), {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    const body = servingWire.rewriteServingResponseBody(await response.text());
+    headers.delete("content-length");
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function bearerToken(headers) {
+    const authorization = headers.authorization ?? headers.Authorization;
+    const [scheme, token] = authorization?.split(/\s+/, 2) ?? [];
+    if (scheme?.toLowerCase() !== "bearer" || !token) {
+        throw new Error("Databricks authentication did not produce a bearer token");
+    }
+    return token;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.js","sourceRoot":"","sources":["../../src/translation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Vercel AI SDK fallback translation between external gateway protocols.\n *\n * @module\n */\n\nimport { createAnthropic } from \"@ai-sdk/anthropic\";\nimport { createOpenResponses } from \"@ai-sdk/open-responses\";\nimport { createOpenAICompatible } from \"@ai-sdk/openai-compatible\";\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { invoke, servingWire } from \"@dbx-tools/model\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { GatewayRoute } from \"@dbx-tools/shared-model-gateway\";\nimport { streamText, type LanguageModel, type ToolSet } from \"ai\";\n\nimport { decodeGatewayRequest } from \"./protocols/decode.ts\";\nimport { encodeGatewayResponse, encodeGatewayStream } from \"./protocols/encode.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway/translation\");\n\n/** Translate one request through a provider-owned AI SDK model. */\nexport async function translateGatewayRequest(\n  route: GatewayRoute,\n  body: Readonly<Record<string, unknown>>,\n  signal: AbortSignal,\n): Promise<Response> {\n  const decoded = decodeGatewayRequest(route.clientProtocol, body);\n  logger.debug(\"decoded request\", {\n    clientProtocol: route.clientProtocol,\n    messageCount: decoded.messages.length,\n    model: route.target.id,\n    stream: body.stream === true,\n    toolCount: Object.keys(decoded.tools).length,\n  });\n  const model = await translationModel(route);\n  const result = streamText({\n    model,\n    messages: decoded.messages,\n    allowSystemInMessages: true,\n    ...(Object.keys(decoded.tools).length > 0 ? { tools: decoded.tools } : {}),\n    ...(decoded.maxOutputTokens !== undefined ? { maxOutputTokens: decoded.maxOutputTokens } : {}),\n    ...(decoded.temperature !== undefined ? { temperature: decoded.temperature } : {}),\n    ...(decoded.topP !== undefined ? { topP: decoded.topP } : {}),\n    maxRetries: 0,\n    abortSignal: signal,\n    onError: ({ error }) => {\n      logger.error(\"stream failed\", { error, model: route.target.id });\n    },\n    onAbort: () => {\n      logger.debug(\"translation aborted\", { model: route.target.id });\n    },\n    onFinish: ({ finishReason, usage }) => {\n      logger.debug(\"translation finished\", {\n        finishReason,\n        inputTokens: usage.inputTokens,\n        model: route.target.id,\n        outputTokens: usage.outputTokens,\n      });\n    },\n  });\n\n  if (body.stream === true) {\n    logger.debug(\"returning translated stream\", {\n      clientProtocol: route.clientProtocol,\n      model: route.target.id,\n    });\n    return new Response(\n      encodeGatewayStream(\n        route.clientProtocol,\n        route.target.id,\n        result.stream as AsyncIterable<import(\"ai\").TextStreamPart<ToolSet>>,\n      ),\n      {\n        headers: {\n          \"cache-control\": \"no-cache\",\n          \"content-type\": \"text/event-stream\",\n          \"x-accel-buffering\": \"no\",\n        },\n      },\n    );\n  }\n\n  const [text, toolCalls, usage, finishReason] = await Promise.all([\n    result.text,\n    result.toolCalls,\n    result.usage,\n    result.finishReason,\n  ]);\n  logger.debug(\"returning translated response\", {\n    clientProtocol: route.clientProtocol,\n    finishReason,\n    inputTokens: usage.inputTokens,\n    model: route.target.id,\n    outputTokens: usage.outputTokens,\n    toolCallCount: toolCalls.length,\n  });\n  return Response.json(\n    encodeGatewayResponse(route.clientProtocol, route.target.id, {\n      text,\n      toolCalls: toolCalls as import(\"ai\").TypedToolCall<ToolSet>[],\n      usage,\n      finishReason,\n    }),\n  );\n}\n\nasync function translationModel(route: GatewayRoute): Promise<LanguageModel> {\n  const client = getExecutionContext().client;\n  const host = (await client.config.getHost()).toString();\n  const headers = await invoke.authHeaders(client);\n  if (route.target.capabilities.responses) {\n    logger.debug(\"selected Responses provider\", { model: route.target.id });\n    return createOpenResponses({\n      name: \"databricks-responses\",\n      url: invoke.responsesUrl(host),\n      headers,\n    })(route.target.id);\n  }\n  if (route.target.capabilities.anthropic) {\n    logger.debug(\"selected Anthropic provider\", { model: route.target.id });\n    return createAnthropic({\n      name: \"databricks-anthropic\",\n      baseURL: new URL(\"serving-endpoints/anthropic/v1\", host).toString(),\n      authToken: bearerToken(headers),\n      headers,\n    })(route.target.id);\n  }\n  logger.debug(\"selected Chat provider\", { model: route.target.id });\n  return createOpenAICompatible({\n    name: \"databricks-chat\",\n    baseURL: new URL(\"serving-endpoints\", host).toString(),\n    headers,\n    supportsStructuredOutputs: true,\n    fetch: compatibleFetch,\n  }).chatModel(route.target.id);\n}\n\nasync function compatibleFetch(\n  input: Parameters<typeof fetch>[0],\n  init?: Parameters<typeof fetch>[1],\n): Promise<Response> {\n  const rewritten = await servingWire.rewriteServingRequest(input, init);\n  logger.debug(\"sending translated Chat request\", {\n    rewritten: rewritten.input !== input || rewritten.init !== init,\n  });\n  const response = await fetch(rewritten.input, rewritten.init);\n  const responseDetails = {\n    contentType: response.headers.get(\"content-type\"),\n    status: response.status,\n  };\n  if (response.ok) logger.debug(\"received translated Chat response\", responseDetails);\n  else logger.warn(\"translated Chat request failed\", responseDetails);\n  if (!response.body) return response;\n  const headers = new Headers(response.headers);\n  if (headers.get(\"content-type\")?.includes(\"text/event-stream\")) {\n    return new Response(servingWire.rewriteServingResponseStream(response.body), {\n      status: response.status,\n      statusText: response.statusText,\n      headers,\n    });\n  }\n  const body = servingWire.rewriteServingResponseBody(await response.text());\n  headers.delete(\"content-length\");\n  return new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers,\n  });\n}\n\nfunction bearerToken(headers: Readonly<Record<string, string>>): string {\n  const authorization = headers.authorization ?? headers.Authorization;\n  const [scheme, token] = authorization?.split(/\\s+/, 2) ?? [];\n  if (scheme?.toLowerCase() !== \"bearer\" || !token) {\n    throw new Error(\"Databricks authentication did not produce a bearer token\");\n  }\n  return token;\n}\n"]}

package/lib/src/transport.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Authenticated streaming transport for direct Databricks gateway routes.
+ *
+ * @module
+ */
+import type { GatewayRoute } from "@dbx-tools/shared-model-gateway";
+/** Inputs for one direct Databricks protocol request. */
+export interface DatabricksTransportRequest {
+    readonly route: GatewayRoute;
+    readonly body: Readonly<Record<string, unknown>>;
+    readonly headers: Headers;
+    readonly signal: AbortSignal;
+}
+/** Execute a direct route with SDK-owned authentication and an unbuffered response body. */
+export declare function fetchDatabricks(request: DatabricksTransportRequest): Promise<Response>;
+/** Copy only response headers that belong to the public model protocol. */
+export declare function gatewayResponseHeaders(upstream: Headers): Headers;
+/** Resolve the exact upstream URL for a deterministic direct route. */
+export declare function upstreamUrl(host: string, route: GatewayRoute): string;

package/lib/src/transport.js

@@ -0,0 +1,168 @@
+/**
+ * Authenticated streaming transport for direct Databricks gateway routes.
+ *
+ * @module
+ */
+import { getExecutionContext } from "@databricks/appkit";
+import { workspaceClient } from "@dbx-tools/databricks";
+import { invoke } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("appkit/model-gateway/transport");
+const ERROR_PREVIEW_BYTES = 8 * 1024;
+const BLOCKED_REQUEST_HEADERS = new Set([
+    "accept-encoding",
+    "authorization",
+    "connection",
+    "content-length",
+    "cookie",
+    "host",
+    "proxy-authorization",
+    "transfer-encoding",
+    "x-api-key",
+]);
+const BLOCKED_RESPONSE_HEADERS = new Set([
+    "connection",
+    "content-encoding",
+    "content-length",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "set-cookie",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+/** Execute a direct route with SDK-owned authentication and an unbuffered response body. */
+export async function fetchDatabricks(request) {
+    const client = getExecutionContext().client;
+    const host = (await client.config.getHost()).toString();
+    const headers = new Headers({ "content-type": "application/json" });
+    request.headers.forEach((value, name) => {
+        const normalized = name.toLowerCase();
+        if (!BLOCKED_REQUEST_HEADERS.has(normalized) && !normalized.startsWith("x-forwarded-")) {
+            headers.set(name, value);
+        }
+    });
+    await client.config.authenticate(headers);
+    const url = upstreamUrl(host, request.route);
+    const startedAt = Date.now();
+    const body = JSON.stringify({ ...request.body, model: request.route.upstreamModel });
+    logger.debug("sending upstream request", {
+        model: request.route.upstreamModel,
+        path: new URL(url).pathname,
+        stream: request.body.stream === true,
+        upstreamProtocol: request.route.upstreamProtocol,
+    });
+    try {
+        let response = await fetch(url, {
+            method: "POST",
+            headers,
+            body,
+            signal: request.signal,
+        });
+        if (response.status === 401 &&
+            (await workspaceClient.refreshWorkspaceClientAuthentication(client))) {
+            logger.debug("retrying rejected upstream credential", {
+                model: request.route.upstreamModel,
+                upstreamProtocol: request.route.upstreamProtocol,
+            });
+            await response.body?.cancel();
+            headers.delete("authorization");
+            headers.delete("x-databricks-workspace-id");
+            await client.config.authenticate(headers);
+            response = await fetch(url, {
+                method: "POST",
+                headers,
+                body,
+                signal: request.signal,
+            });
+        }
+        const details = {
+            elapsedMs: Date.now() - startedAt,
+            model: request.route.upstreamModel,
+            requestId: response.headers.get("x-request-id") ?? response.headers.get("x-databricks-request-id"),
+            status: response.status,
+            upstreamProtocol: request.route.upstreamProtocol,
+        };
+        if (response.ok) {
+            logger.debug("received upstream response", details);
+        }
+        else {
+            logger.warn("upstream response failed", details);
+            void logUpstreamFailureBody(response.clone(), details);
+        }
+        return response;
+    }
+    catch (error) {
+        logger.error("upstream fetch failed", {
+            elapsedMs: Date.now() - startedAt,
+            error,
+            model: request.route.upstreamModel,
+            upstreamProtocol: request.route.upstreamProtocol,
+        });
+        throw error;
+    }
+}
+/** Copy only response headers that belong to the public model protocol. */
+export function gatewayResponseHeaders(upstream) {
+    const headers = new Headers();
+    upstream.forEach((value, name) => {
+        if (!BLOCKED_RESPONSE_HEADERS.has(name.toLowerCase()))
+            headers.set(name, value);
+    });
+    return headers;
+}
+/** Resolve the exact upstream URL for a deterministic direct route. */
+export function upstreamUrl(host, route) {
+    switch (route.upstreamProtocol) {
+        case "databricks-ai-gateway-codex":
+            return invoke.aiGatewayCodexResponsesUrl(host);
+        case "databricks-responses":
+            return invoke.responsesUrl(host);
+        case "databricks-open-responses":
+            return invoke.openResponsesUrl(host);
+        case "databricks-chat":
+            return invoke.chatCompletionsUrl(host);
+        case "databricks-anthropic":
+            return invoke.anthropicMessagesUrl(host);
+        case "databricks-embeddings":
+            return invoke.invocationsUrl(host, route.upstreamModel);
+        case "ai-sdk":
+            throw new Error("AI SDK routes do not use the direct Databricks transport");
+    }
+}
+async function logUpstreamFailureBody(response, details) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    let preview = "";
+    let bytes = 0;
+    try {
+        while (bytes < ERROR_PREVIEW_BYTES) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            const remaining = ERROR_PREVIEW_BYTES - bytes;
+            const value = chunk.value.subarray(0, remaining);
+            bytes += value.byteLength;
+            preview += decoder.decode(value, { stream: true });
+            if (value.byteLength < chunk.value.byteLength)
+                break;
+        }
+        preview += decoder.decode();
+        logger.warn("upstream error body", {
+            ...details,
+            preview,
+            truncated: bytes >= ERROR_PREVIEW_BYTES,
+        });
+    }
+    catch (error) {
+        logger.debug("could not read upstream error body", { ...details, error });
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authenticated streaming transport for direct Databricks gateway routes.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { workspaceClient } from \"@dbx-tools/databricks\";\nimport { invoke } from \"@dbx-tools/model\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { GatewayRoute } from \"@dbx-tools/shared-model-gateway\";\n\nconst logger = log.logger(\"appkit/model-gateway/transport\");\nconst ERROR_PREVIEW_BYTES = 8 * 1024;\n\nconst BLOCKED_REQUEST_HEADERS = new Set([\n  \"accept-encoding\",\n  \"authorization\",\n  \"connection\",\n  \"content-length\",\n  \"cookie\",\n  \"host\",\n  \"proxy-authorization\",\n  \"transfer-encoding\",\n  \"x-api-key\",\n]);\n\nconst BLOCKED_RESPONSE_HEADERS = new Set([\n  \"connection\",\n  \"content-encoding\",\n  \"content-length\",\n  \"keep-alive\",\n  \"proxy-authenticate\",\n  \"proxy-authorization\",\n  \"set-cookie\",\n  \"te\",\n  \"trailer\",\n  \"transfer-encoding\",\n  \"upgrade\",\n]);\n\n/** Inputs for one direct Databricks protocol request. */\nexport interface DatabricksTransportRequest {\n  readonly route: GatewayRoute;\n  readonly body: Readonly<Record<string, unknown>>;\n  readonly headers: Headers;\n  readonly signal: AbortSignal;\n}\n\n/** Execute a direct route with SDK-owned authentication and an unbuffered response body. */\nexport async function fetchDatabricks(request: DatabricksTransportRequest): Promise<Response> {\n  const client = getExecutionContext().client;\n  const host = (await client.config.getHost()).toString();\n  const headers = new Headers({ \"content-type\": \"application/json\" });\n  request.headers.forEach((value, name) => {\n    const normalized = name.toLowerCase();\n    if (!BLOCKED_REQUEST_HEADERS.has(normalized) && !normalized.startsWith(\"x-forwarded-\")) {\n      headers.set(name, value);\n    }\n  });\n  await client.config.authenticate(headers);\n  const url = upstreamUrl(host, request.route);\n  const startedAt = Date.now();\n  const body = JSON.stringify({ ...request.body, model: request.route.upstreamModel });\n  logger.debug(\"sending upstream request\", {\n    model: request.route.upstreamModel,\n    path: new URL(url).pathname,\n    stream: request.body.stream === true,\n    upstreamProtocol: request.route.upstreamProtocol,\n  });\n  try {\n    let response = await fetch(url, {\n      method: \"POST\",\n      headers,\n      body,\n      signal: request.signal,\n    });\n    if (\n      response.status === 401 &&\n      (await workspaceClient.refreshWorkspaceClientAuthentication(client))\n    ) {\n      logger.debug(\"retrying rejected upstream credential\", {\n        model: request.route.upstreamModel,\n        upstreamProtocol: request.route.upstreamProtocol,\n      });\n      await response.body?.cancel();\n      headers.delete(\"authorization\");\n      headers.delete(\"x-databricks-workspace-id\");\n      await client.config.authenticate(headers);\n      response = await fetch(url, {\n        method: \"POST\",\n        headers,\n        body,\n        signal: request.signal,\n      });\n    }\n    const details = {\n      elapsedMs: Date.now() - startedAt,\n      model: request.route.upstreamModel,\n      requestId:\n        response.headers.get(\"x-request-id\") ?? response.headers.get(\"x-databricks-request-id\"),\n      status: response.status,\n      upstreamProtocol: request.route.upstreamProtocol,\n    };\n    if (response.ok) {\n      logger.debug(\"received upstream response\", details);\n    } else {\n      logger.warn(\"upstream response failed\", details);\n      void logUpstreamFailureBody(response.clone(), details);\n    }\n    return response;\n  } catch (error) {\n    logger.error(\"upstream fetch failed\", {\n      elapsedMs: Date.now() - startedAt,\n      error,\n      model: request.route.upstreamModel,\n      upstreamProtocol: request.route.upstreamProtocol,\n    });\n    throw error;\n  }\n}\n\n/** Copy only response headers that belong to the public model protocol. */\nexport function gatewayResponseHeaders(upstream: Headers): Headers {\n  const headers = new Headers();\n  upstream.forEach((value, name) => {\n    if (!BLOCKED_RESPONSE_HEADERS.has(name.toLowerCase())) headers.set(name, value);\n  });\n  return headers;\n}\n\n/** Resolve the exact upstream URL for a deterministic direct route. */\nexport function upstreamUrl(host: string, route: GatewayRoute): string {\n  switch (route.upstreamProtocol) {\n    case \"databricks-ai-gateway-codex\":\n      return invoke.aiGatewayCodexResponsesUrl(host);\n    case \"databricks-responses\":\n      return invoke.responsesUrl(host);\n    case \"databricks-open-responses\":\n      return invoke.openResponsesUrl(host);\n    case \"databricks-chat\":\n      return invoke.chatCompletionsUrl(host);\n    case \"databricks-anthropic\":\n      return invoke.anthropicMessagesUrl(host);\n    case \"databricks-embeddings\":\n      return invoke.invocationsUrl(host, route.upstreamModel);\n    case \"ai-sdk\":\n      throw new Error(\"AI SDK routes do not use the direct Databricks transport\");\n  }\n}\n\nasync function logUpstreamFailureBody(\n  response: Response,\n  details: Record<string, unknown>,\n): Promise<void> {\n  const reader = response.body?.getReader();\n  if (!reader) return;\n  const decoder = new TextDecoder();\n  let preview = \"\";\n  let bytes = 0;\n  try {\n    while (bytes < ERROR_PREVIEW_BYTES) {\n      const chunk = await reader.read();\n      if (chunk.done) break;\n      const remaining = ERROR_PREVIEW_BYTES - bytes;\n      const value = chunk.value.subarray(0, remaining);\n      bytes += value.byteLength;\n      preview += decoder.decode(value, { stream: true });\n      if (value.byteLength < chunk.value.byteLength) break;\n    }\n    preview += decoder.decode();\n    logger.warn(\"upstream error body\", {\n      ...details,\n      preview,\n      truncated: bytes >= ERROR_PREVIEW_BYTES,\n    });\n  } catch (error) {\n    logger.debug(\"could not read upstream error body\", { ...details, error });\n  } finally {\n    await reader.cancel().catch(() => undefined);\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/gateway.ts","../src/models.ts","../src/plugin.ts","../src/reasoning-adapt.ts","../src/registry.ts","../src/router.ts","../src/routes.ts","../src/translation.ts","../src/transport.ts","../src/protocols/decode.ts","../src/protocols/encode.ts","../scripts/copy-manifest.ts","../index.ts"],"version":"5.9.3"}