@dbx-tools/appkit-model-gateway 0.9.36

package/lib/src/reasoning-adapt.js

@@ -0,0 +1,61 @@
+/**
+ * Reasoning-effort adaptation for gateway round trips.
+ *
+ * Proactively remaps client efforts onto the known ladder, then on a single
+ * unsupported-value 400 learns from the error and retries once with the
+ * updated ladder.
+ *
+ * @module
+ */
+import { learnReasoningLevelsFromError, modelReasoningLevelsFor, } from "@dbx-tools/model/metadata";
+import { adaptRequestReasoning, parseReasoningLevels, } from "@dbx-tools/model/reasoning-translation";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("appkit/model-gateway/reasoning");
+/** Adapt a request body onto the current known ladder for `model`. */
+export function adaptInferenceReasoning(model, body) {
+    const adapted = adaptRequestReasoning(body, modelReasoningLevelsFor(model));
+    if (adapted.changed) {
+        logger.debug("adapted reasoning effort before upstream", {
+            model,
+            effort: adapted.wireEffort,
+        });
+    }
+    return {
+        body: adapted.body,
+        wireEffort: adapted.wireEffort,
+        changed: adapted.changed,
+    };
+}
+/**
+ * On an unsupported-reasoning 400, learn once and optionally produce a
+ * remapped retry body. Returns `undefined` when no retry should occur.
+ */
+export async function learnAndAdaptReasoningRetry(input) {
+    if (input.response.ok || input.response.status !== 400)
+        return undefined;
+    let errorBody;
+    try {
+        errorBody = JSON.parse(await input.response.clone().text());
+    }
+    catch {
+        return undefined;
+    }
+    if (parseReasoningLevels(errorBody).length === 0)
+        return undefined;
+    const levels = await learnReasoningLevelsFromError(input.model, errorBody);
+    logger.info("learned reasoning levels from upstream error", {
+        model: input.model,
+        levels,
+    });
+    const adapted = adaptRequestReasoning(input.body, levels);
+    if (adapted.wireEffort === undefined || adapted.wireEffort === input.previousWireEffort) {
+        return undefined;
+    }
+    logger.info("retrying with adapted reasoning effort", {
+        model: input.model,
+        from: input.previousWireEffort,
+        to: adapted.wireEffort,
+    });
+    return adapted.body;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Request-scoped Databricks model discovery for the AppKit gateway.
+ *
+ * @module
+ */
+import { type ResolveModelInput } from "@dbx-tools/shared-model/contracts";
+import type { ModelCapabilityOverride, ModelTarget } from "@dbx-tools/shared-model-gateway";
+/** Resolution controls passed through to the model policy owner. */
+export type ModelRegistryResolveOptions = Pick<ResolveModelInput, "modelClass" | "requiresTools">;
+/** Dynamic model catalogue used by request routing and model-list responses. */
+export interface ModelRegistry {
+    list(): Promise<ModelTarget[]>;
+    search(query: string): Promise<ModelTarget[]>;
+    resolve(model: string, options?: ModelRegistryResolveOptions): Promise<ModelTarget | undefined>;
+    refresh(): Promise<void>;
+}
+/** Configuration for {@link DatabricksModelRegistry}. */
+export interface ModelRegistryOptions {
+    readonly ttlMs?: number;
+    readonly overrides?: readonly ModelCapabilityOverride[];
+}
+/** Model registry backed by the active AppKit execution context. */
+export declare class DatabricksModelRegistry implements ModelRegistry {
+    private readonly ttlMs;
+    private readonly overrides;
+    constructor(options?: ModelRegistryOptions);
+    list(): Promise<ModelTarget[]>;
+    resolve(model: string, options?: ModelRegistryResolveOptions): Promise<ModelTarget | undefined>;
+    search(query: string): Promise<ModelTarget[]>;
+    refresh(): Promise<void>;
+    private target;
+}

package/lib/src/registry.js

@@ -0,0 +1,167 @@
+/**
+ * Request-scoped Databricks model discovery for the AppKit gateway.
+ *
+ * @module
+ */
+import { getExecutionContext } from "@databricks/appkit";
+import { metadata, modelCatalog, policy, resolve as modelResolve } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
+import { ModelClass, } from "@dbx-tools/shared-model/contracts";
+const DEFAULT_CACHE_TTL_MS = 60_000;
+const logger = log.logger("appkit/model-gateway/registry");
+/** Model registry backed by the active AppKit execution context. */
+export class DatabricksModelRegistry {
+    ttlMs;
+    overrides;
+    constructor(options = {}) {
+        this.ttlMs = positiveTtl(options.ttlMs);
+        this.overrides = options.overrides ?? [];
+    }
+    async list() {
+        const context = await registryContext();
+        logger.debug("loading catalogue", { host: context.host, ttlMs: this.ttlMs });
+        const endpoints = await modelCatalog.listServingEndpoints(context.client, context.host, {
+            cacheIdentity: context.identity,
+            ttlMs: this.ttlMs,
+        });
+        const targets = endpoints.map((endpoint) => this.target(endpoint));
+        logger.debug("loaded catalogue", {
+            endpointCount: endpoints.length,
+            host: context.host,
+            targetCount: targets.length,
+        });
+        return targets;
+    }
+    async resolve(model, options = {}) {
+        const requested = unqualifiedModel(model);
+        const targets = await this.list();
+        const exact = targets.find((target) => target.aliases.some((alias) => alias.localeCompare(requested, undefined, { sensitivity: "accent" }) === 0));
+        if (exact && matchesResolveOptions(exact, options)) {
+            logger.debug("resolved exact model", { requested, resolved: exact.id });
+            return exact;
+        }
+        const endpoints = targets
+            .map((target) => target.endpoint)
+            .filter((endpoint) => endpoint !== undefined);
+        const resolved = modelResolve.resolveModel(endpoints, {
+            explicit: requested,
+            ...options,
+        });
+        const target = targets.find((candidate) => candidate.id === resolved.modelId);
+        logger.debug("resolved fuzzy model", {
+            requested,
+            resolved: target?.id,
+            source: resolved.source,
+        });
+        return target;
+    }
+    async search(query) {
+        const targets = await this.list();
+        const byId = new Map(targets.map((target) => [target.id, target]));
+        const endpoints = targets
+            .map((target) => target.endpoint)
+            .filter((endpoint) => endpoint !== undefined);
+        const ranked = [
+            ...modelResolve.lookupModels(endpoints, { search: query }),
+            ...modelResolve.lookupModels(endpoints, {
+                search: query,
+                modelClass: ModelClass.Embedding,
+            }),
+        ].sort((left, right) => (left.score ?? 0) - (right.score ?? 0));
+        return ranked
+            .map(({ endpoint }) => byId.get(endpoint.name))
+            .filter((target) => target !== undefined)
+            .filter((target, index, all) => all.findIndex((candidate) => candidate.id === target.id) === index);
+    }
+    async refresh() {
+        const context = await registryContext();
+        logger.debug("clearing catalogue", { host: context.host });
+        await modelCatalog.clearServingEndpointsCache(context.host, context.identity);
+        await modelCatalog.listServingEndpoints(context.client, context.host, {
+            cacheIdentity: context.identity,
+            ttlMs: this.ttlMs,
+        });
+        logger.debug("refreshed catalogue", { host: context.host });
+    }
+    target(endpoint) {
+        const published = metadata.modelCapabilitiesFor(endpoint);
+        const family = endpoint.family?.toLowerCase();
+        const openAiFamily = family === "gpt" || family === "openai" || endpoint.name.includes("codex");
+        const modelServiceName = normalizedModelServiceName(endpoint.modelServiceName);
+        const embeddings = endpoint.class === ModelClass.Embedding || endpoint.task === "llm/v1/embeddings";
+        const capabilities = {
+            responses: !embeddings && (openAiFamily || published.responses),
+            openResponses: !embeddings && !openAiFamily,
+            chat: !embeddings,
+            anthropic: family === "claude",
+            embeddings,
+            aiGatewayCodex: !embeddings && Boolean(modelServiceName) && family !== "claude" && family !== "gemini",
+            tools: endpoint.supportsTools === true,
+            reasoning: policy.modelReasoningEfforts(endpoint.name).length > 0,
+            streaming: true,
+            parallelTools: endpoint.supportsTools === true,
+            customTools: published.applyPatch || endpoint.name.includes("codex"),
+            structuredOutput: true,
+            webSearch: published.webSearch,
+        };
+        const aliases = new Set([
+            endpoint.name,
+            endpoint.displayName,
+            endpoint.modelServiceName,
+            modelServiceName,
+            ...Object.values(endpoint.serviceNames ?? {}),
+        ].filter((value) => Boolean(value?.trim())));
+        const override = this.overrides.find((candidate) => candidate.model === endpoint.name ||
+            [...aliases].some((alias) => alias === candidate.model));
+        return {
+            id: endpoint.name,
+            aliases: [...aliases],
+            displayName: endpoint.displayName ?? endpoint.name,
+            ...(endpoint.family ? { family: endpoint.family } : {}),
+            ...(modelServiceName ? { modelServiceName } : {}),
+            endpoint,
+            capabilities: { ...capabilities, ...override?.capabilities },
+            reasoningEfforts: endpoint.reasoningEfforts ?? [],
+        };
+    }
+}
+async function registryContext() {
+    const context = getExecutionContext();
+    const host = (await context.client.config.getHost()).toString();
+    return {
+        client: context.client,
+        host,
+        identity: "userId" in context ? context.userId : context.serviceUserId,
+    };
+}
+function unqualifiedModel(model) {
+    return model.trim().replace(/^(?:dbx|databricks)\//i, "");
+}
+function positiveTtl(value = DEFAULT_CACHE_TTL_MS) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error("Model registry ttlMs must be a positive finite number");
+    }
+    return value;
+}
+function normalizedModelServiceName(value) {
+    const normalized = value?.trim().replace(/^databricks\//, "");
+    if (!normalized)
+        return undefined;
+    if (normalized.startsWith("system.ai.databricks-")) {
+        return `system.ai.${normalized.slice("system.ai.databricks-".length)}`;
+    }
+    if (normalized.startsWith("databricks-")) {
+        return `system.ai.${normalized.slice("databricks-".length)}`;
+    }
+    return normalized;
+}
+function matchesResolveOptions(target, options) {
+    if (options.requiresTools && !target.capabilities.tools)
+        return false;
+    if (options.modelClass === ModelClass.Embedding)
+        return target.capabilities.embeddings;
+    if (options.modelClass !== undefined)
+        return target.capabilities.chat;
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Request-scoped Databricks model discovery for the AppKit gateway.\n *\n * @module\n */\n\nimport { getExecutionContext, type WorkspaceClient } from \"@databricks/appkit\";\nimport { metadata, modelCatalog, policy, resolve as modelResolve } from \"@dbx-tools/model\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  ModelClass,\n  type ResolveModelInput,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\nimport type {\n  ModelCapabilities,\n  ModelCapabilityOverride,\n  ModelTarget,\n} from \"@dbx-tools/shared-model-gateway\";\n\nconst DEFAULT_CACHE_TTL_MS = 60_000;\nconst logger = log.logger(\"appkit/model-gateway/registry\");\n\n/** Resolution controls passed through to the model policy owner. */\nexport type ModelRegistryResolveOptions = Pick<ResolveModelInput, \"modelClass\" | \"requiresTools\">;\n\n/** Dynamic model catalogue used by request routing and model-list responses. */\nexport interface ModelRegistry {\n  list(): Promise<ModelTarget[]>;\n  search(query: string): Promise<ModelTarget[]>;\n  resolve(model: string, options?: ModelRegistryResolveOptions): Promise<ModelTarget | undefined>;\n  refresh(): Promise<void>;\n}\n\n/** Configuration for {@link DatabricksModelRegistry}. */\nexport interface ModelRegistryOptions {\n  readonly ttlMs?: number;\n  readonly overrides?: readonly ModelCapabilityOverride[];\n}\n\ninterface RegistryContext {\n  readonly client: WorkspaceClient;\n  readonly host: string;\n  readonly identity: string;\n}\n\n/** Model registry backed by the active AppKit execution context. */\nexport class DatabricksModelRegistry implements ModelRegistry {\n  private readonly ttlMs: number;\n  private readonly overrides: readonly ModelCapabilityOverride[];\n\n  constructor(options: ModelRegistryOptions = {}) {\n    this.ttlMs = positiveTtl(options.ttlMs);\n    this.overrides = options.overrides ?? [];\n  }\n\n  async list(): Promise<ModelTarget[]> {\n    const context = await registryContext();\n    logger.debug(\"loading catalogue\", { host: context.host, ttlMs: this.ttlMs });\n    const endpoints = await modelCatalog.listServingEndpoints(context.client, context.host, {\n      cacheIdentity: context.identity,\n      ttlMs: this.ttlMs,\n    });\n    const targets = endpoints.map((endpoint) => this.target(endpoint));\n    logger.debug(\"loaded catalogue\", {\n      endpointCount: endpoints.length,\n      host: context.host,\n      targetCount: targets.length,\n    });\n    return targets;\n  }\n\n  async resolve(\n    model: string,\n    options: ModelRegistryResolveOptions = {},\n  ): Promise<ModelTarget | undefined> {\n    const requested = unqualifiedModel(model);\n    const targets = await this.list();\n    const exact = targets.find((target) =>\n      target.aliases.some(\n        (alias) => alias.localeCompare(requested, undefined, { sensitivity: \"accent\" }) === 0,\n      ),\n    );\n    if (exact && matchesResolveOptions(exact, options)) {\n      logger.debug(\"resolved exact model\", { requested, resolved: exact.id });\n      return exact;\n    }\n\n    const endpoints = targets\n      .map((target) => target.endpoint)\n      .filter((endpoint): endpoint is ServingEndpointSummary => endpoint !== undefined);\n    const resolved = modelResolve.resolveModel(endpoints, {\n      explicit: requested,\n      ...options,\n    });\n    const target = targets.find((candidate) => candidate.id === resolved.modelId);\n    logger.debug(\"resolved fuzzy model\", {\n      requested,\n      resolved: target?.id,\n      source: resolved.source,\n    });\n    return target;\n  }\n\n  async search(query: string): Promise<ModelTarget[]> {\n    const targets = await this.list();\n    const byId = new Map(targets.map((target) => [target.id, target]));\n    const endpoints = targets\n      .map((target) => target.endpoint)\n      .filter((endpoint): endpoint is ServingEndpointSummary => endpoint !== undefined);\n    const ranked = [\n      ...modelResolve.lookupModels(endpoints, { search: query }),\n      ...modelResolve.lookupModels(endpoints, {\n        search: query,\n        modelClass: ModelClass.Embedding,\n      }),\n    ].sort((left, right) => (left.score ?? 0) - (right.score ?? 0));\n    return ranked\n      .map(({ endpoint }) => byId.get(endpoint.name))\n      .filter((target): target is ModelTarget => target !== undefined)\n      .filter(\n        (target, index, all) => all.findIndex((candidate) => candidate.id === target.id) === index,\n      );\n  }\n\n  async refresh(): Promise<void> {\n    const context = await registryContext();\n    logger.debug(\"clearing catalogue\", { host: context.host });\n    await modelCatalog.clearServingEndpointsCache(context.host, context.identity);\n    await modelCatalog.listServingEndpoints(context.client, context.host, {\n      cacheIdentity: context.identity,\n      ttlMs: this.ttlMs,\n    });\n    logger.debug(\"refreshed catalogue\", { host: context.host });\n  }\n\n  private target(endpoint: ServingEndpointSummary): ModelTarget {\n    const published = metadata.modelCapabilitiesFor(endpoint);\n    const family = endpoint.family?.toLowerCase();\n    const openAiFamily = family === \"gpt\" || family === \"openai\" || endpoint.name.includes(\"codex\");\n    const modelServiceName = normalizedModelServiceName(endpoint.modelServiceName);\n    const embeddings =\n      endpoint.class === ModelClass.Embedding || endpoint.task === \"llm/v1/embeddings\";\n    const capabilities: ModelCapabilities = {\n      responses: !embeddings && (openAiFamily || published.responses),\n      openResponses: !embeddings && !openAiFamily,\n      chat: !embeddings,\n      anthropic: family === \"claude\",\n      embeddings,\n      aiGatewayCodex:\n        !embeddings && Boolean(modelServiceName) && family !== \"claude\" && family !== \"gemini\",\n      tools: endpoint.supportsTools === true,\n      reasoning: policy.modelReasoningEfforts(endpoint.name).length > 0,\n      streaming: true,\n      parallelTools: endpoint.supportsTools === true,\n      customTools: published.applyPatch || endpoint.name.includes(\"codex\"),\n      structuredOutput: true,\n      webSearch: published.webSearch,\n    };\n    const aliases = new Set(\n      [\n        endpoint.name,\n        endpoint.displayName,\n        endpoint.modelServiceName,\n        modelServiceName,\n        ...Object.values(endpoint.serviceNames ?? {}),\n      ].filter((value): value is string => Boolean(value?.trim())),\n    );\n    const override = this.overrides.find(\n      (candidate) =>\n        candidate.model === endpoint.name ||\n        [...aliases].some((alias) => alias === candidate.model),\n    );\n    return {\n      id: endpoint.name,\n      aliases: [...aliases],\n      displayName: endpoint.displayName ?? endpoint.name,\n      ...(endpoint.family ? { family: endpoint.family } : {}),\n      ...(modelServiceName ? { modelServiceName } : {}),\n      endpoint,\n      capabilities: { ...capabilities, ...override?.capabilities },\n      reasoningEfforts: endpoint.reasoningEfforts ?? [],\n    };\n  }\n}\n\nasync function registryContext(): Promise<RegistryContext> {\n  const context = getExecutionContext();\n  const host = (await context.client.config.getHost()).toString();\n  return {\n    client: context.client,\n    host,\n    identity: \"userId\" in context ? context.userId : context.serviceUserId,\n  };\n}\n\nfunction unqualifiedModel(model: string): string {\n  return model.trim().replace(/^(?:dbx|databricks)\\//i, \"\");\n}\n\nfunction positiveTtl(value = DEFAULT_CACHE_TTL_MS): number {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new Error(\"Model registry ttlMs must be a positive finite number\");\n  }\n  return value;\n}\n\nfunction normalizedModelServiceName(value: string | undefined): string | undefined {\n  const normalized = value?.trim().replace(/^databricks\\//, \"\");\n  if (!normalized) return undefined;\n  if (normalized.startsWith(\"system.ai.databricks-\")) {\n    return `system.ai.${normalized.slice(\"system.ai.databricks-\".length)}`;\n  }\n  if (normalized.startsWith(\"databricks-\")) {\n    return `system.ai.${normalized.slice(\"databricks-\".length)}`;\n  }\n  return normalized;\n}\n\nfunction matchesResolveOptions(target: ModelTarget, options: ModelRegistryResolveOptions): boolean {\n  if (options.requiresTools && !target.capabilities.tools) return false;\n  if (options.modelClass === ModelClass.Embedding) return target.capabilities.embeddings;\n  if (options.modelClass !== undefined) return target.capabilities.chat;\n  return true;\n}\n"]}

package/lib/src/router.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pure capability-driven route selection for model-gateway requests.
+ *
+ * @module
+ */
+import type { GatewayRoute, RequestedFeatures, ResolveRouteInput } from "@dbx-tools/shared-model-gateway";
+/** Error returned when preserving a requested protocol feature is impossible. */
+export declare class UnsupportedGatewayFeatureError extends Error {
+    readonly features: readonly string[];
+    readonly status = 400;
+    constructor(features: readonly string[]);
+}
+/** Select the lowest-overhead upstream that preserves the client contract. */
+export declare function resolveRoute(input: ResolveRouteInput): GatewayRoute;
+/** Detect route-affecting features from an OpenAI or Anthropic request body. */
+export declare function requestedFeatures(body: Readonly<Record<string, unknown>>): RequestedFeatures;
+/** Return whether an Originator header selects Codex compatibility behavior. */
+export declare function isCodexOriginator(originator: string | undefined): boolean;

package/lib/src/router.js

@@ -0,0 +1,139 @@
+/**
+ * Pure capability-driven route selection for model-gateway requests.
+ *
+ * @module
+ */
+/** Error returned when preserving a requested protocol feature is impossible. */
+export class UnsupportedGatewayFeatureError extends Error {
+    features;
+    status = 400;
+    constructor(features) {
+        super(`The selected model cannot preserve requested features: ${features.join(", ")}`);
+        this.features = features;
+        this.name = "UnsupportedGatewayFeatureError";
+    }
+}
+/** Select the lowest-overhead upstream that preserves the client contract. */
+export function resolveRoute(input) {
+    const { clientProtocol, requestedModel, features, target } = input;
+    if (clientProtocol === "openai-embeddings") {
+        if (!target.capabilities.embeddings) {
+            throw new UnsupportedGatewayFeatureError(["embeddings"]);
+        }
+        return directRoute(input, "databricks-embeddings", target.id);
+    }
+    if (clientProtocol === "openai-responses") {
+        rejectStatefulResponses(features);
+        if (isCodexOriginator(input.originator) &&
+            targetsModelService(requestedModel, target) &&
+            target.capabilities.aiGatewayCodex &&
+            supportsDirectResponses(target, features)) {
+            return directRoute(input, "databricks-ai-gateway-codex", target.modelServiceName);
+        }
+        if (target.capabilities.responses && supportsDirectResponses(target, features)) {
+            return directRoute(input, "databricks-responses", target.id);
+        }
+        if (target.capabilities.aiGatewayCodex &&
+            target.modelServiceName &&
+            supportsDirectResponses(target, features)) {
+            return directRoute(input, "databricks-ai-gateway-codex", target.modelServiceName);
+        }
+        if (target.capabilities.openResponses && supportsOpenResponses(target, features)) {
+            return directRoute(input, "databricks-open-responses", target.id);
+        }
+        return translatedRoute(input);
+    }
+    if (clientProtocol === "openai-chat") {
+        if (target.capabilities.chat && supportsTools(target, features)) {
+            return directRoute(input, "databricks-chat", target.id);
+        }
+        return translatedRoute(input);
+    }
+    if (target.capabilities.anthropic && supportsTools(target, features)) {
+        return directRoute(input, "databricks-anthropic", target.id);
+    }
+    return translatedRoute(input);
+}
+/** Detect route-affecting features from an OpenAI or Anthropic request body. */
+export function requestedFeatures(body) {
+    const tools = Array.isArray(body.tools) ? body.tools : [];
+    const toolTypes = tools
+        .filter((tool) => isRecord(tool))
+        .map((tool) => tool.type);
+    const text = isRecord(body.text) ? body.text : {};
+    const format = isRecord(text.format) ? text.format.type : text.format;
+    return {
+        background: body.background === true,
+        customTools: toolTypes.some((type) => type === "custom"),
+        parallelTools: body.parallel_tool_calls === true,
+        previousResponse: typeof body.previous_response_id === "string" && body.previous_response_id.length > 0,
+        reasoning: isRecord(body.reasoning) || body.reasoning_effort !== undefined,
+        storage: body.store === true,
+        structuredOutput: format !== undefined && format !== "text",
+        tools: tools.length > 0,
+        unsupportedOpenResponsesTools: toolTypes.some((type) => type !== "function" && type !== "web_search" && type !== "web_search_preview"),
+        webSearch: toolTypes.some((type) => type === "web_search" || type === "web_search_preview"),
+    };
+}
+/** Return whether an Originator header selects Codex compatibility behavior. */
+export function isCodexOriginator(originator) {
+    return originator?.toLowerCase().includes("codex") === true;
+}
+function directRoute(input, upstreamProtocol, upstreamModel) {
+    return {
+        clientProtocol: input.clientProtocol,
+        upstreamProtocol,
+        target: input.target,
+        upstreamModel,
+        translateRequest: false,
+        translateResponse: false,
+    };
+}
+function translatedRoute(input) {
+    return {
+        clientProtocol: input.clientProtocol,
+        upstreamProtocol: "ai-sdk",
+        target: input.target,
+        upstreamModel: input.target.id,
+        translateRequest: true,
+        translateResponse: true,
+    };
+}
+function supportsDirectResponses(target, features) {
+    return (supportsTools(target, features) &&
+        (!features.customTools || target.capabilities.customTools) &&
+        (!features.structuredOutput || target.capabilities.structuredOutput));
+}
+function supportsOpenResponses(target, features) {
+    return (supportsTools(target, features) &&
+        !features.customTools &&
+        !features.previousResponse &&
+        !features.storage &&
+        !features.background &&
+        !features.unsupportedOpenResponsesTools &&
+        (!features.webSearch || target.capabilities.webSearch) &&
+        (!features.structuredOutput || target.capabilities.structuredOutput));
+}
+function supportsTools(target, features) {
+    return ((!features.tools || target.capabilities.tools) &&
+        (!features.parallelTools || target.capabilities.parallelTools));
+}
+function rejectStatefulResponses(features) {
+    const unsupported = [
+        ...(features.previousResponse ? ["previous_response_id"] : []),
+        ...(features.storage ? ["store"] : []),
+        ...(features.background ? ["background"] : []),
+    ];
+    if (unsupported.length > 0)
+        throw new UnsupportedGatewayFeatureError(unsupported);
+}
+function targetsModelService(requestedModel, target) {
+    if (!target.modelServiceName)
+        return false;
+    const unqualified = requestedModel.trim().replace(/^(?:dbx|databricks)\//i, "");
+    return unqualified === target.modelServiceName;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.js","sourceRoot":"","sources":["../../src/router.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure capability-driven route selection for model-gateway requests.\n *\n * @module\n */\n\nimport type {\n  GatewayRoute,\n  ModelTarget,\n  RequestedFeatures,\n  ResolveRouteInput,\n  UpstreamProtocol,\n} from \"@dbx-tools/shared-model-gateway\";\n\n/** Error returned when preserving a requested protocol feature is impossible. */\nexport class UnsupportedGatewayFeatureError extends Error {\n  readonly status = 400;\n\n  constructor(readonly features: readonly string[]) {\n    super(`The selected model cannot preserve requested features: ${features.join(\", \")}`);\n    this.name = \"UnsupportedGatewayFeatureError\";\n  }\n}\n\n/** Select the lowest-overhead upstream that preserves the client contract. */\nexport function resolveRoute(input: ResolveRouteInput): GatewayRoute {\n  const { clientProtocol, requestedModel, features, target } = input;\n  if (clientProtocol === \"openai-embeddings\") {\n    if (!target.capabilities.embeddings) {\n      throw new UnsupportedGatewayFeatureError([\"embeddings\"]);\n    }\n    return directRoute(input, \"databricks-embeddings\", target.id);\n  }\n  if (clientProtocol === \"openai-responses\") {\n    rejectStatefulResponses(features);\n    if (\n      isCodexOriginator(input.originator) &&\n      targetsModelService(requestedModel, target) &&\n      target.capabilities.aiGatewayCodex &&\n      supportsDirectResponses(target, features)\n    ) {\n      return directRoute(input, \"databricks-ai-gateway-codex\", target.modelServiceName!);\n    }\n    if (target.capabilities.responses && supportsDirectResponses(target, features)) {\n      return directRoute(input, \"databricks-responses\", target.id);\n    }\n    if (\n      target.capabilities.aiGatewayCodex &&\n      target.modelServiceName &&\n      supportsDirectResponses(target, features)\n    ) {\n      return directRoute(input, \"databricks-ai-gateway-codex\", target.modelServiceName);\n    }\n    if (target.capabilities.openResponses && supportsOpenResponses(target, features)) {\n      return directRoute(input, \"databricks-open-responses\", target.id);\n    }\n    return translatedRoute(input);\n  }\n\n  if (clientProtocol === \"openai-chat\") {\n    if (target.capabilities.chat && supportsTools(target, features)) {\n      return directRoute(input, \"databricks-chat\", target.id);\n    }\n    return translatedRoute(input);\n  }\n\n  if (target.capabilities.anthropic && supportsTools(target, features)) {\n    return directRoute(input, \"databricks-anthropic\", target.id);\n  }\n  return translatedRoute(input);\n}\n\n/** Detect route-affecting features from an OpenAI or Anthropic request body. */\nexport function requestedFeatures(body: Readonly<Record<string, unknown>>): RequestedFeatures {\n  const tools = Array.isArray(body.tools) ? body.tools : [];\n  const toolTypes = tools\n    .filter((tool): tool is Record<string, unknown> => isRecord(tool))\n    .map((tool) => tool.type);\n  const text = isRecord(body.text) ? body.text : {};\n  const format = isRecord(text.format) ? text.format.type : text.format;\n  return {\n    background: body.background === true,\n    customTools: toolTypes.some((type) => type === \"custom\"),\n    parallelTools: body.parallel_tool_calls === true,\n    previousResponse:\n      typeof body.previous_response_id === \"string\" && body.previous_response_id.length > 0,\n    reasoning: isRecord(body.reasoning) || body.reasoning_effort !== undefined,\n    storage: body.store === true,\n    structuredOutput: format !== undefined && format !== \"text\",\n    tools: tools.length > 0,\n    unsupportedOpenResponsesTools: toolTypes.some(\n      (type) => type !== \"function\" && type !== \"web_search\" && type !== \"web_search_preview\",\n    ),\n    webSearch: toolTypes.some((type) => type === \"web_search\" || type === \"web_search_preview\"),\n  };\n}\n\n/** Return whether an Originator header selects Codex compatibility behavior. */\nexport function isCodexOriginator(originator: string | undefined): boolean {\n  return originator?.toLowerCase().includes(\"codex\") === true;\n}\n\nfunction directRoute(\n  input: ResolveRouteInput,\n  upstreamProtocol: Exclude<UpstreamProtocol, \"ai-sdk\">,\n  upstreamModel: string,\n): GatewayRoute {\n  return {\n    clientProtocol: input.clientProtocol,\n    upstreamProtocol,\n    target: input.target,\n    upstreamModel,\n    translateRequest: false,\n    translateResponse: false,\n  };\n}\n\nfunction translatedRoute(input: ResolveRouteInput): GatewayRoute {\n  return {\n    clientProtocol: input.clientProtocol,\n    upstreamProtocol: \"ai-sdk\",\n    target: input.target,\n    upstreamModel: input.target.id,\n    translateRequest: true,\n    translateResponse: true,\n  };\n}\n\nfunction supportsDirectResponses(target: ModelTarget, features: RequestedFeatures): boolean {\n  return (\n    supportsTools(target, features) &&\n    (!features.customTools || target.capabilities.customTools) &&\n    (!features.structuredOutput || target.capabilities.structuredOutput)\n  );\n}\n\nfunction supportsOpenResponses(target: ModelTarget, features: RequestedFeatures): boolean {\n  return (\n    supportsTools(target, features) &&\n    !features.customTools &&\n    !features.previousResponse &&\n    !features.storage &&\n    !features.background &&\n    !features.unsupportedOpenResponsesTools &&\n    (!features.webSearch || target.capabilities.webSearch) &&\n    (!features.structuredOutput || target.capabilities.structuredOutput)\n  );\n}\n\nfunction supportsTools(target: ModelTarget, features: RequestedFeatures): boolean {\n  return (\n    (!features.tools || target.capabilities.tools) &&\n    (!features.parallelTools || target.capabilities.parallelTools)\n  );\n}\n\nfunction rejectStatefulResponses(features: RequestedFeatures): void {\n  const unsupported = [\n    ...(features.previousResponse ? [\"previous_response_id\"] : []),\n    ...(features.storage ? [\"store\"] : []),\n    ...(features.background ? [\"background\"] : []),\n  ];\n  if (unsupported.length > 0) throw new UnsupportedGatewayFeatureError(unsupported);\n}\n\nfunction targetsModelService(requestedModel: string, target: ModelTarget): boolean {\n  if (!target.modelServiceName) return false;\n  const unqualified = requestedModel.trim().replace(/^(?:dbx|databricks)\\//i, \"\");\n  return unqualified === target.modelServiceName;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"]}

package/lib/src/routes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Express adapters for the shared model-gateway service.
+ *
+ * @module
+ */
+import type { ClientProtocol } from "@dbx-tools/shared-model-gateway";
+import type express from "express";
+import { ModelGateway } from "./gateway.ts";
+/** Send the lightweight compatibility health response. */
+export declare function sendHealth(response: express.Response): void;
+/** Send the active principal's dynamic model catalogue. */
+export declare function sendModels(gateway: ModelGateway, request: express.Request, response: express.Response): Promise<void>;
+/** Execute and stream one model request through Express with cancellation. */
+export declare function sendInference(gateway: ModelGateway, protocol: ClientProtocol, request: express.Request, response: express.Response): Promise<void>;