@dbx-tools/appkit-model-gateway 0.9.201 → 0.9.203

package/lib/src/profile-fallback.js

@@ -0,0 +1,212 @@
+/**
+ * Ordered Databricks profile fallback for rate-limited model requests.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+import { fetchWorkspace } from "./transport.js";
+const logger = log.logger("appkit/model-gateway/profile-fallback");
+const GENERIC_RATE_LIMIT_COOLDOWN_MS = 15_000;
+const WORKSPACE_TOKEN_COOLDOWN_MS = 60_000;
+/** Process-local ordered profile cooldowns keyed by workspace and model. */
+export class ProfileFallback {
+    profiles;
+    cooldowns = new Map();
+    now;
+    sleep;
+    fetcher;
+    constructor(profiles, dependencies = {}) {
+        this.profiles = profiles;
+        if (profiles.length < 2) {
+            throw new TypeError("Profile fallback requires at least two profiles");
+        }
+        this.now = dependencies.now ?? Date.now;
+        this.sleep = dependencies.sleep ?? abortableSleep;
+        this.fetcher = dependencies.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    /** Primary profile used for discovery and workspace-scoped routing. */
+    get primary() {
+        return this.profiles[0];
+    }
+    /** Execute against the first available profile and cool down HTTP 429 responders. */
+    async request(model, signal, send) {
+        const attempted = new Set();
+        let waitedForExistingCooldown = false;
+        while (true) {
+            const now = this.now();
+            const profileIndex = this.availableProfile(model, attempted, now);
+            if (profileIndex === undefined) {
+                if (attempted.size > 0 || waitedForExistingCooldown) {
+                    throw new Error("Profile fallback exhausted without an upstream response");
+                }
+                const delayMs = this.nextCooldownDelay(model, now);
+                if (delayMs === undefined) {
+                    throw new Error("Profile fallback has no available profile");
+                }
+                waitedForExistingCooldown = true;
+                await this.sleep(delayMs, signal);
+                continue;
+            }
+            attempted.add(profileIndex);
+            const profile = this.profiles[profileIndex];
+            const response = await send(profile);
+            if (response.status !== 429) {
+                this.cooldowns.delete(this.key(profile.workspace, model));
+                if (profileIndex > 0) {
+                    logger.info("model request completed through fallback profile", {
+                        model,
+                        profile: profile.profile ?? "default",
+                        profileIndex,
+                    });
+                }
+                return response;
+            }
+            const rateLimit = await modelGatewayRateLimit(response, this.now());
+            this.cooldowns.set(this.key(profile.workspace, model), this.now() + rateLimit.retryAfterMs);
+            logger.warn("model profile rate limited", {
+                errorCode: rateLimit.errorCode,
+                upstreamMessage: rateLimit.message,
+                model,
+                profile: profile.profile ?? "default",
+                profileIndex,
+                retryAfterMs: rateLimit.retryAfterMs,
+                retryAfterSource: rateLimit.source,
+                workspace: profile.workspace,
+            });
+            if (this.availableProfile(model, attempted, this.now()) === undefined) {
+                return response;
+            }
+            await response.body?.cancel().catch(() => undefined);
+        }
+    }
+    /** Build an AI SDK fetch that replays a request through the ordered profile pool. */
+    createFetch(model) {
+        return (async (input, init) => {
+            const request = new Request(input, init);
+            const body = request.method === "GET" || request.method === "HEAD"
+                ? undefined
+                : await request.arrayBuffer();
+            const originalUrl = new URL(request.url);
+            const originalHeaders = new Headers(request.headers);
+            return this.request(model, request.signal, async ({ client, workspace }) => {
+                const url = new URL(`${originalUrl.pathname}${originalUrl.search}`, workspace);
+                return fetchWorkspace(client, url, {
+                    method: request.method,
+                    headers: originalHeaders,
+                    body,
+                    signal: request.signal,
+                }, this.fetcher);
+            });
+        });
+    }
+    availableProfile(model, attempted, now) {
+        for (let index = 0; index < this.profiles.length; index += 1) {
+            if (attempted.has(index))
+                continue;
+            const workspace = this.profiles[index].workspace;
+            if ((this.cooldowns.get(this.key(workspace, model)) ?? 0) <= now)
+                return index;
+        }
+        return undefined;
+    }
+    nextCooldownDelay(model, now) {
+        const cooldowns = this.profiles
+            .map((profile) => this.cooldowns.get(this.key(profile.workspace, model)))
+            .filter((until) => until !== undefined && until > now);
+        if (cooldowns.length === 0)
+            return undefined;
+        return Math.max(0, Math.min(...cooldowns) - now);
+    }
+    key(workspace, model) {
+        return `${normalizeWorkspace(workspace)}\0${model}`;
+    }
+}
+function normalizeWorkspace(workspace) {
+    const url = new URL(workspace);
+    return url.origin.toLowerCase();
+}
+/** Parse HTTP and Databricks JSON retry timing for a 429 response. */
+export async function modelGatewayRateLimit(response, now = Date.now()) {
+    const headerDelay = retryAfterHeaderMs(response.headers.get("retry-after"), now);
+    const body = await response
+        .clone()
+        .json()
+        .catch(() => undefined);
+    const details = rateLimitBody(body);
+    if (headerDelay !== undefined) {
+        return { ...details, retryAfterMs: headerDelay, source: "header" };
+    }
+    if (details.retryAfterMs !== undefined) {
+        return { ...details, retryAfterMs: details.retryAfterMs, source: "body" };
+    }
+    if (isWorkspaceTokenRateLimit(details.message)) {
+        return {
+            ...details,
+            retryAfterMs: WORKSPACE_TOKEN_COOLDOWN_MS,
+            source: "workspace-token-window",
+        };
+    }
+    return {
+        ...details,
+        retryAfterMs: GENERIC_RATE_LIMIT_COOLDOWN_MS,
+        source: "default",
+    };
+}
+function rateLimitBody(value) {
+    const root = record(value);
+    const error = record(root?.error) ?? root;
+    const retryAfter = integer(error?.retry_after ?? root?.retry_after);
+    const errorCode = text(error?.error_code ?? root?.error_code);
+    const message = text(error?.message ?? root?.message) ??
+        (typeof root?.error === "string" ? text(root.error) : undefined);
+    return {
+        ...(retryAfter !== undefined ? { retryAfterMs: retryAfter * 1_000 } : {}),
+        ...(errorCode ? { errorCode } : {}),
+        ...(message ? { message } : {}),
+    };
+}
+function retryAfterHeaderMs(value, now) {
+    const normalized = value?.trim();
+    if (!normalized)
+        return undefined;
+    const seconds = Number(normalized);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1_000;
+    const timestamp = Date.parse(normalized);
+    return Number.isFinite(timestamp) ? Math.max(0, timestamp - now) : undefined;
+}
+function isWorkspaceTokenRateLimit(message) {
+    return (message !== undefined && /exceeded workspace .*tokens per minute rate limit/i.test(message));
+}
+function integer(value) {
+    const normalized = typeof value === "string" ? value.trim().replaceAll(",", "") : value;
+    const parsed = typeof normalized === "number" ? normalized : Number(normalized);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function abortableSleep(delayMs, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const timeout = setTimeout(finish, delayMs);
+        function finish() {
+            signal.removeEventListener("abort", abort);
+            resolve();
+        }
+        function abort() {
+            clearTimeout(timeout);
+            reject(signal.reason);
+        }
+        signal.addEventListener("abort", abort, { once: true });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"profile-fallback.js","sourceRoot":"","sources":["../../src/profile-fallback.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ordered Databricks profile fallback for rate-limited model requests.\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\n\nimport { fetchWorkspace } from \"./transport.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway/profile-fallback\");\nconst GENERIC_RATE_LIMIT_COOLDOWN_MS = 15_000;\nconst WORKSPACE_TOKEN_COOLDOWN_MS = 60_000;\n\n/** One configured workspace identity in fallback order. */\nexport interface ModelGatewayProfile {\n  readonly profile?: string;\n  readonly workspace: string;\n  readonly client: WorkspaceClient;\n}\n\n/** Parsed upstream rate-limit timing and diagnostic fields. */\nexport interface ModelGatewayRateLimit {\n  readonly retryAfterMs: number;\n  readonly source: \"header\" | \"body\" | \"workspace-token-window\" | \"default\";\n  readonly errorCode?: string;\n  readonly message?: string;\n}\n\n/** Injectable time and transport boundaries for profile-fallback tests. */\nexport interface ProfileFallbackDependencies {\n  readonly now?: () => number;\n  readonly sleep?: (delayMs: number, signal: AbortSignal) => Promise<void>;\n  readonly fetch?: typeof globalThis.fetch;\n}\n\n/** Process-local ordered profile cooldowns keyed by workspace and model. */\nexport class ProfileFallback {\n  private readonly cooldowns = new Map<string, number>();\n  private readonly now: () => number;\n  private readonly sleep: (delayMs: number, signal: AbortSignal) => Promise<void>;\n  private readonly fetcher: typeof globalThis.fetch;\n\n  constructor(\n    readonly profiles: readonly ModelGatewayProfile[],\n    dependencies: ProfileFallbackDependencies = {},\n  ) {\n    if (profiles.length < 2) {\n      throw new TypeError(\"Profile fallback requires at least two profiles\");\n    }\n    this.now = dependencies.now ?? Date.now;\n    this.sleep = dependencies.sleep ?? abortableSleep;\n    this.fetcher = dependencies.fetch ?? globalThis.fetch.bind(globalThis);\n  }\n\n  /** Primary profile used for discovery and workspace-scoped routing. */\n  get primary(): ModelGatewayProfile {\n    return this.profiles[0]!;\n  }\n\n  /** Execute against the first available profile and cool down HTTP 429 responders. */\n  async request(\n    model: string,\n    signal: AbortSignal,\n    send: (profile: ModelGatewayProfile) => Promise<Response>,\n  ): Promise<Response> {\n    const attempted = new Set<number>();\n    let waitedForExistingCooldown = false;\n    while (true) {\n      const now = this.now();\n      const profileIndex = this.availableProfile(model, attempted, now);\n      if (profileIndex === undefined) {\n        if (attempted.size > 0 || waitedForExistingCooldown) {\n          throw new Error(\"Profile fallback exhausted without an upstream response\");\n        }\n        const delayMs = this.nextCooldownDelay(model, now);\n        if (delayMs === undefined) {\n          throw new Error(\"Profile fallback has no available profile\");\n        }\n        waitedForExistingCooldown = true;\n        await this.sleep(delayMs, signal);\n        continue;\n      }\n\n      attempted.add(profileIndex);\n      const profile = this.profiles[profileIndex]!;\n      const response = await send(profile);\n      if (response.status !== 429) {\n        this.cooldowns.delete(this.key(profile.workspace, model));\n        if (profileIndex > 0) {\n          logger.info(\"model request completed through fallback profile\", {\n            model,\n            profile: profile.profile ?? \"default\",\n            profileIndex,\n          });\n        }\n        return response;\n      }\n\n      const rateLimit = await modelGatewayRateLimit(response, this.now());\n      this.cooldowns.set(this.key(profile.workspace, model), this.now() + rateLimit.retryAfterMs);\n      logger.warn(\"model profile rate limited\", {\n        errorCode: rateLimit.errorCode,\n        upstreamMessage: rateLimit.message,\n        model,\n        profile: profile.profile ?? \"default\",\n        profileIndex,\n        retryAfterMs: rateLimit.retryAfterMs,\n        retryAfterSource: rateLimit.source,\n        workspace: profile.workspace,\n      });\n\n      if (this.availableProfile(model, attempted, this.now()) === undefined) {\n        return response;\n      }\n      await response.body?.cancel().catch(() => undefined);\n    }\n  }\n\n  /** Build an AI SDK fetch that replays a request through the ordered profile pool. */\n  createFetch(model: string): typeof globalThis.fetch {\n    return (async (input, init) => {\n      const request = new Request(input, init);\n      const body =\n        request.method === \"GET\" || request.method === \"HEAD\"\n          ? undefined\n          : await request.arrayBuffer();\n      const originalUrl = new URL(request.url);\n      const originalHeaders = new Headers(request.headers);\n      return this.request(model, request.signal, async ({ client, workspace }) => {\n        const url = new URL(`${originalUrl.pathname}${originalUrl.search}`, workspace);\n        return fetchWorkspace(\n          client,\n          url,\n          {\n            method: request.method,\n            headers: originalHeaders,\n            body,\n            signal: request.signal,\n          },\n          this.fetcher,\n        );\n      });\n    }) as typeof globalThis.fetch;\n  }\n\n  private availableProfile(\n    model: string,\n    attempted: ReadonlySet<number>,\n    now: number,\n  ): number | undefined {\n    for (let index = 0; index < this.profiles.length; index += 1) {\n      if (attempted.has(index)) continue;\n      const workspace = this.profiles[index]!.workspace;\n      if ((this.cooldowns.get(this.key(workspace, model)) ?? 0) <= now) return index;\n    }\n    return undefined;\n  }\n\n  private nextCooldownDelay(model: string, now: number): number | undefined {\n    const cooldowns = this.profiles\n      .map((profile) => this.cooldowns.get(this.key(profile.workspace, model)))\n      .filter((until): until is number => until !== undefined && until > now);\n    if (cooldowns.length === 0) return undefined;\n    return Math.max(0, Math.min(...cooldowns) - now);\n  }\n\n  private key(workspace: string, model: string): string {\n    return `${normalizeWorkspace(workspace)}\\0${model}`;\n  }\n}\n\nfunction normalizeWorkspace(workspace: string): string {\n  const url = new URL(workspace);\n  return url.origin.toLowerCase();\n}\n\n/** Parse HTTP and Databricks JSON retry timing for a 429 response. */\nexport async function modelGatewayRateLimit(\n  response: Response,\n  now = Date.now(),\n): Promise<ModelGatewayRateLimit> {\n  const headerDelay = retryAfterHeaderMs(response.headers.get(\"retry-after\"), now);\n  const body = await response\n    .clone()\n    .json()\n    .catch(() => undefined);\n  const details = rateLimitBody(body);\n  if (headerDelay !== undefined) {\n    return { ...details, retryAfterMs: headerDelay, source: \"header\" };\n  }\n  if (details.retryAfterMs !== undefined) {\n    return { ...details, retryAfterMs: details.retryAfterMs, source: \"body\" };\n  }\n  if (isWorkspaceTokenRateLimit(details.message)) {\n    return {\n      ...details,\n      retryAfterMs: WORKSPACE_TOKEN_COOLDOWN_MS,\n      source: \"workspace-token-window\",\n    };\n  }\n  return {\n    ...details,\n    retryAfterMs: GENERIC_RATE_LIMIT_COOLDOWN_MS,\n    source: \"default\",\n  };\n}\n\nfunction rateLimitBody(value: unknown): {\n  readonly retryAfterMs?: number;\n  readonly errorCode?: string;\n  readonly message?: string;\n} {\n  const root = record(value);\n  const error = record(root?.error) ?? root;\n  const retryAfter = integer(error?.retry_after ?? root?.retry_after);\n  const errorCode = text(error?.error_code ?? root?.error_code);\n  const message =\n    text(error?.message ?? root?.message) ??\n    (typeof root?.error === \"string\" ? text(root.error) : undefined);\n  return {\n    ...(retryAfter !== undefined ? { retryAfterMs: retryAfter * 1_000 } : {}),\n    ...(errorCode ? { errorCode } : {}),\n    ...(message ? { message } : {}),\n  };\n}\n\nfunction retryAfterHeaderMs(value: string | null, now: number): number | undefined {\n  const normalized = value?.trim();\n  if (!normalized) return undefined;\n  const seconds = Number(normalized);\n  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1_000;\n  const timestamp = Date.parse(normalized);\n  return Number.isFinite(timestamp) ? Math.max(0, timestamp - now) : undefined;\n}\n\nfunction isWorkspaceTokenRateLimit(message: string | undefined): boolean {\n  return (\n    message !== undefined && /exceeded workspace .*tokens per minute rate limit/i.test(message)\n  );\n}\n\nfunction integer(value: unknown): number | undefined {\n  const normalized = typeof value === \"string\" ? value.trim().replaceAll(\",\", \"\") : value;\n  const parsed = typeof normalized === \"number\" ? normalized : Number(normalized);\n  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined;\n}\n\nfunction text(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.trim() ? value.trim() : undefined;\n}\n\nfunction record(value: unknown): Record<string, unknown> | undefined {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\nfunction abortableSleep(delayMs: number, signal: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal.aborted) {\n      reject(signal.reason);\n      return;\n    }\n    const timeout = setTimeout(finish, delayMs);\n    function finish() {\n      signal.removeEventListener(\"abort\", abort);\n      resolve();\n    }\n    function abort() {\n      clearTimeout(timeout);\n      reject(signal.reason);\n    }\n    signal.addEventListener(\"abort\", abort, { once: true });\n  });\n}\n"]}

package/lib/src/translation.d.ts

@@ -3,6 +3,10 @@
  *
  * @module
  */
+import { type WorkspaceClient } from "@databricks/appkit";
 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>;
+export declare function translateGatewayRequest(route: GatewayRoute, body: Readonly<Record<string, unknown>>, signal: AbortSignal, options?: {
+    readonly client?: WorkspaceClient;
+    readonly fetch?: typeof globalThis.fetch;
+}): Promise<Response>;

package/lib/src/translation.js

@@ -11,7 +11,7 @@ import { log, toError } from "@dbx-tools/shared-core";
 import { streamText } from "ai";
 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) {
+export async function translateGatewayRequest(route, body, signal, options = {}) {
     const decoded = decodeGatewayRequest(route.clientProtocol, body);
     logger.debug("decoded request", {
         clientProtocol: route.clientProtocol,
@@ -20,7 +20,7 @@ export async function translateGatewayRequest(route, body, signal) {
         stream: body.stream === true,
         toolCount: Object.keys(decoded.tools).length,
     });
-    const model = await translationModel(route);
+    const model = await translationModel(route, options.client, options.fetch);
     const result = streamText({
         model,
         messages: decoded.messages,
@@ -83,8 +83,7 @@ export async function translateGatewayRequest(route, body, signal) {
         finishReason,
     }));
 }
-async function translationModel(route) {
-    const client = getExecutionContext().client;
+async function translationModel(route, client = getExecutionContext().client, fetcher) {
     const host = (await client.config.getHost()).toString();
     const headers = await invoke.authHeaders(client);
     const protocol = translationProtocol(route);
@@ -94,6 +93,7 @@ async function translationModel(route) {
         protocol,
         host,
         headers,
+        ...(fetcher ? { fetch: fetcher } : {}),
     });
 }
 function translationProtocol(route) {
@@ -103,4 +103,4 @@ function translationProtocol(route) {
         return "anthropic";
     return "chat";
 }
-//# 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 { getExecutionContext } from \"@databricks/appkit\";\nimport { invoke } from \"@dbx-tools/model\";\nimport {\n  decodeGatewayRequest,\n  encodeGatewayResponse,\n  encodeGatewayStream,\n} from \"@dbx-tools/model-protocol\";\nimport {\n  createDatabricksLanguageModel,\n  type DatabricksLanguageModelProtocol,\n} from \"@dbx-tools/model-protocol\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport type { GatewayRoute } from \"@dbx-tools/shared-model-gateway\";\nimport { streamText, type LanguageModel, type ToolSet } from \"ai\";\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\", {\n        error: toError(error),\n        model: route.target.id,\n      });\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  const protocol = translationProtocol(route);\n  logger.debug(\"selected translation provider\", { model: route.target.id, protocol });\n  return createDatabricksLanguageModel({\n    modelId: route.target.id,\n    protocol,\n    host,\n    headers,\n  });\n}\n\nfunction translationProtocol(route: GatewayRoute): DatabricksLanguageModelProtocol {\n  if (route.target.capabilities.responses) return \"responses\";\n  if (route.target.capabilities.anthropic) return \"anthropic\";\n  return \"chat\";\n}\n"]}
+//# 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 { getExecutionContext, type WorkspaceClient } from \"@databricks/appkit\";\nimport { invoke } from \"@dbx-tools/model\";\nimport {\n  decodeGatewayRequest,\n  encodeGatewayResponse,\n  encodeGatewayStream,\n} from \"@dbx-tools/model-protocol\";\nimport {\n  createDatabricksLanguageModel,\n  type DatabricksLanguageModelProtocol,\n} from \"@dbx-tools/model-protocol\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport type { GatewayRoute } from \"@dbx-tools/shared-model-gateway\";\nimport { streamText, type LanguageModel, type ToolSet } from \"ai\";\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  options: {\n    readonly client?: WorkspaceClient;\n    readonly fetch?: typeof globalThis.fetch;\n  } = {},\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, options.client, options.fetch);\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\", {\n        error: toError(error),\n        model: route.target.id,\n      });\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(\n  route: GatewayRoute,\n  client: WorkspaceClient = getExecutionContext().client,\n  fetcher?: typeof globalThis.fetch,\n): Promise<LanguageModel> {\n  const host = (await client.config.getHost()).toString();\n  const headers = await invoke.authHeaders(client);\n  const protocol = translationProtocol(route);\n  logger.debug(\"selected translation provider\", { model: route.target.id, protocol });\n  return createDatabricksLanguageModel({\n    modelId: route.target.id,\n    protocol,\n    host,\n    headers,\n    ...(fetcher ? { fetch: fetcher } : {}),\n  });\n}\n\nfunction translationProtocol(route: GatewayRoute): DatabricksLanguageModelProtocol {\n  if (route.target.capabilities.responses) return \"responses\";\n  if (route.target.capabilities.anthropic) return \"anthropic\";\n  return \"chat\";\n}\n"]}

package/lib/src/transport.d.ts

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import { type WorkspaceClient } from "@databricks/appkit";
 import { type GatewayRoute } from "@dbx-tools/shared-model-gateway";
 /** Inputs for one direct Databricks protocol request. */
 export interface DatabricksTransportRequest {
@@ -10,9 +11,12 @@ export interface DatabricksTransportRequest {
     readonly body: Readonly<Record<string, unknown>>;
     readonly headers: Headers;
     readonly signal: AbortSignal;
+    readonly client?: WorkspaceClient;
 }
 /** Execute a direct route with SDK-owned authentication and an unbuffered response body. */
 export declare function fetchDatabricks(request: DatabricksTransportRequest): Promise<Response>;
+/** Execute one authenticated workspace request and refresh a rejected credential once. */
+export declare function fetchWorkspace(client: WorkspaceClient, input: string | URL, init: RequestInit, fetcher?: typeof globalThis.fetch): Promise<Response>;
 /** Remove client compatibility fields rejected by direct Databricks protocols. */
 export declare function directDatabricksRequestBody(route: Pick<GatewayRoute, "upstreamProtocol" | "upstreamModel">, body: Readonly<Record<string, unknown>>): Record<string, unknown>;
 /** Copy only response headers that belong to the public model protocol. */

package/lib/src/transport.js

@@ -36,7 +36,7 @@ const BLOCKED_RESPONSE_HEADERS = new Set([
 ]);
 /** Execute a direct route with SDK-owned authentication and an unbuffered response body. */
 export async function fetchDatabricks(request) {
-    const client = getExecutionContext().client;
+    const client = request.client ?? getExecutionContext().client;
     const host = (await client.config.getHost()).toString();
     const headers = new Headers({ "content-type": "application/json" });
     request.headers.forEach((value, name) => {
@@ -45,7 +45,6 @@ export async function fetchDatabricks(request) {
             headers.set(name, value);
         }
     });
-    await client.config.authenticate(headers);
     const url = upstreamUrl(host, request.route);
     const startedAt = Date.now();
     const body = JSON.stringify(directDatabricksRequestBody(request.route, request.body));
@@ -56,28 +55,12 @@ export async function fetchDatabricks(request) {
         upstreamProtocol: request.route.upstreamProtocol,
     });
     try {
-        let response = await fetch(url, {
+        const response = await fetchWorkspace(client, url, {
             method: "POST",
             headers,
             body,
             signal: request.signal,
         });
-        if (response.status === 401 && (await 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,
@@ -104,6 +87,26 @@ export async function fetchDatabricks(request) {
         throw error;
     }
 }
+/** Execute one authenticated workspace request and refresh a rejected credential once. */
+export async function fetchWorkspace(client, input, init, fetcher = globalThis.fetch.bind(globalThis)) {
+    const headers = new Headers(init.headers);
+    headers.delete("authorization");
+    headers.delete("x-databricks-workspace-id");
+    await client.config.authenticate(headers);
+    let response = await fetcher(input, { ...init, headers });
+    if (response.status !== 401 || !(await refreshWorkspaceClientAuthentication(client))) {
+        return response;
+    }
+    logger.debug("retrying rejected workspace credential", {
+        path: new URL(input).pathname,
+    });
+    await response.body?.cancel();
+    headers.delete("authorization");
+    headers.delete("x-databricks-workspace-id");
+    await client.config.authenticate(headers);
+    response = await fetcher(input, { ...init, headers });
+    return response;
+}
 /** Remove client compatibility fields rejected by direct Databricks protocols. */
 export function directDatabricksRequestBody(route, body) {
     const sanitized = { ...body, model: route.upstreamModel };
@@ -160,4 +163,4 @@ async function logUpstreamFailureBody(response, details) {
         await reader.cancel().catch(() => undefined);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,oCAAoC,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAqB,MAAM,iCAAiC,CAAC;AAEjF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAC;AAC5D,MAAM,mBAAmB,GAAG,CAAC,GAAG,IAAI,CAAC;AAErC,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC;IACtC,iBAAiB;IACjB,eAAe;IACf,YAAY;IACZ,gBAAgB;IAChB,QAAQ;IACR,MAAM;IACN,qBAAqB;IACrB,mBAAmB;IACnB,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG,IAAI,GAAG,CAAC;IACvC,YAAY;IACZ,kBAAkB;IAClB,gBAAgB;IAChB,YAAY;IACZ,oBAAoB;IACpB,qBAAqB;IACrB,YAAY;IACZ,IAAI;IACJ,SAAS;IACT,mBAAmB;IACnB,SAAS;CACV,CAAC,CAAC;AAUH,4FAA4F;AAC5F,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,OAAmC;IACvE,MAAM,MAAM,GAAG,mBAAmB,EAAE,CAAC,MAAM,CAAC;IAC5C,MAAM,IAAI,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IACxD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC,CAAC;IACpE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;YACvF,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,2BAA2B,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtF,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE;QACvC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa;QAClC,IAAI,EAAE,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ;QAC3B,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,KAAK,IAAI;QACpC,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC,gBAAgB;KACjD,CAAC,CAAC;IACH,IAAI,CAAC;QACH,IAAI,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAC9B,MAAM,EAAE,MAAM;YACd,OAAO;YACP,IAAI;YACJ,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,oCAAoC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YACpF,MAAM,CAAC,KAAK,CAAC,uCAAuC,EAAE;gBACpD,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa;gBAClC,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC,gBAAgB;aACjD,CAAC,CAAC;YACH,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9B,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;YAChC,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,CAAC;YAC5C,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAC1C,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;gBAC1B,MAAM,EAAE,MAAM;gBACd,OAAO;gBACP,IAAI;gBACJ,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,OAAO,GAAG;YACd,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YACjC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa;YAClC,SAAS,EACP,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC;YACzF,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC,gBAAgB;SACjD,CAAC;QACF,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;YAChB,MAAM,CAAC,KAAK,CAAC,4BAA4B,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,OAAO,CAAC,CAAC;YACjD,KAAK,sBAAsB,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,OAAO,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE;YACpC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YACjC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC;YACrB,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa;YAClC,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC,gBAAgB;SACjD,CAAC,CAAC;QACH,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,2BAA2B,CACzC,KAA+D,EAC/D,IAAuC;IAEvC,MAAM,SAAS,GAA4B,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC;IACnF,IAAI,KAAK,CAAC,gBAAgB,KAAK,iBAAiB,EAAE,CAAC;QACjD,0BAA0B,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;SAAM,CAAC;QACN,OAAO,SAAS,CAAC,mBAAmB,CAAC;IACvC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,sBAAsB,CAAC,QAAiB;IACtD,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC/B,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAClF,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,KAAK,UAAU,sBAAsB,CACnC,QAAkB,EAClB,OAAgC;IAEhC,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC;IAC1C,IAAI,CAAC,MAAM;QAAE,OAAO;IACpB,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,CAAC;QACH,OAAO,KAAK,GAAG,mBAAmB,EAAE,CAAC;YACnC,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,IAAI;gBAAE,MAAM;YACtB,MAAM,SAAS,GAAG,mBAAmB,GAAG,KAAK,CAAC;YAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACjD,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC;YAC1B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;YACnD,IAAI,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,UAAU;gBAAE,MAAM;QACvD,CAAC;QACD,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE;YACjC,GAAG,OAAO;YACV,OAAO;YACP,SAAS,EAAE,KAAK,IAAI,mBAAmB;SACxC,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE;YACjD,GAAG,OAAO;YACV,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC;SACtB,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC","sourcesContent":["/**\n * Authenticated streaming transport for direct Databricks gateway routes.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { refreshWorkspaceClientAuthentication } from \"@dbx-tools/databricks\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport { stripUnsupportedChatFields } from \"@dbx-tools/shared-model\";\nimport { upstreamUrl, 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(directDatabricksRequestBody(request.route, request.body));\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 (response.status === 401 && (await refreshWorkspaceClientAuthentication(client))) {\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: toError(error),\n      model: request.route.upstreamModel,\n      upstreamProtocol: request.route.upstreamProtocol,\n    });\n    throw error;\n  }\n}\n\n/** Remove client compatibility fields rejected by direct Databricks protocols. */\nexport function directDatabricksRequestBody(\n  route: Pick<GatewayRoute, \"upstreamProtocol\" | \"upstreamModel\">,\n  body: Readonly<Record<string, unknown>>,\n): Record<string, unknown> {\n  const sanitized: Record<string, unknown> = { ...body, model: route.upstreamModel };\n  if (route.upstreamProtocol === \"databricks-chat\") {\n    stripUnsupportedChatFields(sanitized);\n  } else {\n    delete sanitized.parallel_tool_calls;\n  }\n  return sanitized;\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\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\", {\n      ...details,\n      error: toError(error),\n    });\n  } finally {\n    await reader.cancel().catch(() => undefined);\n  }\n}\n"]}
+//# 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, type WorkspaceClient } from \"@databricks/appkit\";\nimport { refreshWorkspaceClientAuthentication } from \"@dbx-tools/databricks\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport { stripUnsupportedChatFields } from \"@dbx-tools/shared-model\";\nimport { upstreamUrl, 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  readonly client?: WorkspaceClient;\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 = request.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  const url = upstreamUrl(host, request.route);\n  const startedAt = Date.now();\n  const body = JSON.stringify(directDatabricksRequestBody(request.route, request.body));\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    const response = await fetchWorkspace(client, url, {\n      method: \"POST\",\n      headers,\n      body,\n      signal: request.signal,\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: toError(error),\n      model: request.route.upstreamModel,\n      upstreamProtocol: request.route.upstreamProtocol,\n    });\n    throw error;\n  }\n}\n\n/** Execute one authenticated workspace request and refresh a rejected credential once. */\nexport async function fetchWorkspace(\n  client: WorkspaceClient,\n  input: string | URL,\n  init: RequestInit,\n  fetcher: typeof globalThis.fetch = globalThis.fetch.bind(globalThis),\n): Promise<Response> {\n  const headers = new Headers(init.headers);\n  headers.delete(\"authorization\");\n  headers.delete(\"x-databricks-workspace-id\");\n  await client.config.authenticate(headers);\n  let response = await fetcher(input, { ...init, headers });\n  if (response.status !== 401 || !(await refreshWorkspaceClientAuthentication(client))) {\n    return response;\n  }\n  logger.debug(\"retrying rejected workspace credential\", {\n    path: new URL(input).pathname,\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 fetcher(input, { ...init, headers });\n  return response;\n}\n\n/** Remove client compatibility fields rejected by direct Databricks protocols. */\nexport function directDatabricksRequestBody(\n  route: Pick<GatewayRoute, \"upstreamProtocol\" | \"upstreamModel\">,\n  body: Readonly<Record<string, unknown>>,\n): Record<string, unknown> {\n  const sanitized: Record<string, unknown> = { ...body, model: route.upstreamModel };\n  if (route.upstreamProtocol === \"databricks-chat\") {\n    stripUnsupportedChatFields(sanitized);\n  } else {\n    delete sanitized.parallel_tool_calls;\n  }\n  return sanitized;\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\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\", {\n      ...details,\n      error: toError(error),\n    });\n  } finally {\n    await reader.cancel().catch(() => undefined);\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/ai-decide.ts","../src/gateway.ts","../src/model-context.ts","../src/models.ts","../src/plugin.ts","../src/reasoning-adapt.ts","../src/registry.ts","../src/router.ts","../src/routes.ts","../src/smart-router.ts","../src/translation.ts","../src/transport.ts","../scripts/copy-manifest.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/ai-decide.ts","../src/gateway.ts","../src/model-context.ts","../src/models.ts","../src/plugin.ts","../src/profile-fallback.ts","../src/reasoning-adapt.ts","../src/registry.ts","../src/router.ts","../src/routes.ts","../src/smart-router.ts","../src/translation.ts","../src/transport.ts","../scripts/copy-manifest.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -27,13 +27,13 @@
   },
   "dependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/cache": "0.9.201",
-    "@dbx-tools/databricks": "0.9.201",
-    "@dbx-tools/model": "0.9.201",
-    "@dbx-tools/model-protocol": "0.9.201",
-    "@dbx-tools/shared-core": "0.9.201",
-    "@dbx-tools/shared-model": "0.9.201",
-    "@dbx-tools/shared-model-gateway": "0.9.201",
+    "@dbx-tools/cache": "0.9.203",
+    "@dbx-tools/databricks": "0.9.203",
+    "@dbx-tools/model": "0.9.203",
+    "@dbx-tools/model-protocol": "0.9.203",
+    "@dbx-tools/shared-core": "0.9.203",
+    "@dbx-tools/shared-model": "0.9.203",
+    "@dbx-tools/shared-model-gateway": "0.9.203",
     "ai": "^7.0.0",
     "js-tiktoken": "^1.0.21",
     "zod": "4.3.6"
@@ -52,7 +52,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.201",
+  "version": "0.9.203",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [