@dbx-tools/appkit-model-gateway 0.9.175 → 0.9.177

package/README.md

@@ -51,6 +51,65 @@ The gateway supports:
 - OpenAI-compatible embeddings.
 - Codex model discovery and Responses traffic.
 
+## Use Smart Router
+
+Select the virtual `smart-router` model from any supported chat protocol:
+
+```json
+{
+  "model": "smart-router",
+  "input": "Refactor the authorization layer across the repository"
+}
+```
+
+Before returning `GET /v1/models`, the gateway makes one memoized
+`task_v3` capability request to Databricks
+`/ai-gateway/routing/v1/routes:select`. The virtual model is listed only when
+that request succeeds for the active identity and live `system.ai.*`
+candidates. Positive probes are shared for five minutes and concurrent probes
+coalesce into one request. Stale values are returned immediately while
+`@dbx-tools/cache` `refreshAfterWrite` coalesces one access-triggered background
+refresh. An explicit inference request skips this synthetic preflight because
+its real route selection is already the availability check.
+
+For inference, the gateway extracts bounded task context from Responses input,
+Chat Completions or Anthropic messages, plain text, or generic JSON objects. It
+excludes credentials, tool schemas, and tool arguments. OpenAI-shaped requests
+use the `codex` Smart Router harness policy; Anthropic Messages uses `claude`.
+The selected route must match one of the offered, protocol-compatible live
+models. There is no local tier classifier or fallback selector.
+
+The same `smart-router` id works with Responses, Chat Completions, Anthropic
+Messages, and Codex-compatible Responses traffic. Embeddings require an
+explicit model. Explicit concrete models and model-class headers continue to
+win.
+
+Smart Router selections are pinned for the logical user turn. The default store
+uses AppKit `CacheManager`, so configured Lakebase/PostgreSQL persistence is
+reused across app replicas. Supply `smartRouterStore` to use another storage
+implementation with the same `get`/`set` contract, including a SQLite-backed
+adapter. Only the selected model and bounded route metadata are stored; prompts
+and responses are not.
+
+This state is a TTL route pin, not conversation history. The gateway does not
+read Mastra `PostgresStore`: supported chat requests already carry the portable
+transcript, and coupling routing to Mastra would exclude other chat clients.
+AppKit cache persistence is also preferable to a gateway-owned file or a second
+expiring table because it already handles process-local reuse, project-scoped
+disk fallback, and configured Lakebase/PostgreSQL storage. A consumer can still
+inject a different store when its deployment needs another backend.
+
+Response headers expose the selected concrete model, returned route model,
+harness, cache source, and any `task_v3` task tier, served tier, or profiler
+status without rewriting the upstream response body's model identity.
+
+Select a model without starting the server by passing a JSON or text file, or
+`-` for standard input:
+
+```sh
+dbx model-gateway --profile PROFILE --select-model-from request.json
+```
+
 ## Discover models
 
 ```ts
@@ -92,6 +151,13 @@ discovered value.
 `Originator: codex`. Codex slugs prefer fully qualified Databricks model service
 names.
 
+Codex merges provider models with its bundled catalogue. The gateway reserves a
+separate provider priority range so bundled recommendations remain together,
+then places Smart Router before the Databricks model list. Codex-specific model
+ordering puts GPT models first and newer family versions before older versions.
+Databricks GPT labels include the `Databricks` prefix so they remain distinct
+from bundled GPT models after Codex applies its compact label formatting.
+
 Point a Codex provider at:
 
 ```text
@@ -106,6 +172,16 @@ Use `wire_api = "responses"` and `supports_websockets = false`.
 `system.ai.*` AI Gateway services for non-exact eligible requests. An exact
 serving endpoint or `system.ai.*` name still wins.
 
+Smart Router defaults to `smartRouter: "auto"` and is advertised only after its
+capability probe succeeds. Set `smartRouter: "true"` to make model discovery
+fail when the router is unavailable, or `smartRouter: "false"` to disable it.
+Configure `smartRouterTimeoutMs`,
+`smartRouterContextTokenBudget`, `smartRouterProbeTtlMs`,
+`smartRouterProbeRefreshIntervalMs`, and `smartRouterRouteTtlSeconds` to tune
+transport, context, request-driven probe expiry, background probe refresh, and
+turn-pinning behavior. A failed real selection immediately invalidates the
+positive probe.
+
 Use `overrides` when workspace metadata must be corrected for a specific model.
 For example, disable an advertised capability that the selected gateway route
 cannot use:
@@ -131,4 +207,5 @@ Overrides affect routing and the OpenAI and Codex model catalogues.
 - `gateway` handles protocol-neutral gateway requests.
 - `registry` discovers and resolves workspace models.
 - `router` selects a compatible route from model capabilities.
+- `smartRouter` builds task context, probes availability, and calls `task_v3`.
 - `transport` sends requests to Databricks model APIs.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-model-gateway";
-export const PACKAGE_VERSION = "0.9.175";
+export const PACKAGE_VERSION = "0.9.177";
 export * as gateway from "./src/gateway.ts";
 export * as models from "./src/models.ts";
 export * as plugin from "./src/plugin.ts";
@@ -11,6 +11,7 @@ export * as reasoningAdapt from "./src/reasoning-adapt.ts";
 export * as registry from "./src/registry.ts";
 export * as router from "./src/router.ts";
 export * as routes from "./src/routes.ts";
+export * as smartRouter from "./src/smart-router.ts";
 export * as translation from "./src/translation.ts";
 export * as transport from "./src/transport.ts";
 export { ModelGatewayError, ModelGateway, sanitizeInferenceBody, adaptInferenceTemperature, gatewayModelSelection } from "./src/gateway.ts";
@@ -24,6 +25,8 @@ export { DatabricksModelRegistry } from "./src/registry.ts";
 export type { ModelRegistryResolveOptions, ModelRegistry, ModelRegistryOptions } from "./src/registry.ts";
 export { UnsupportedGatewayFeatureError, resolveRoute, requestedFeatures, isCodexOriginator } from "./src/router.ts";
 export { sendHealth, sendModels, sendInference } from "./src/routes.ts";
+export { SMART_ROUTER_DEFAULT_SETTINGS, SmartRouterProbeRecordSchema, SmartRouterError, AppKitSmartRouterStore, AppKitSmartRouterProbeStore, SmartRouterService, smartRouterCandidates, SmartRouterContextBuilder, SmartModelRouter, smartRouterTurnKey } from "./src/smart-router.ts";
+export type { SmartRouterSettings, SmartRouterCandidate, SmartRouterSelection, SmartRouterStore, SmartRouterProbeRecord, SmartRouterProbeStore, SmartRouterResult, SmartRouterContext, SmartRouterSelectOptions } from "./src/smart-router.ts";
 export { translateGatewayRequest } from "./src/translation.ts";
 export { fetchDatabricks, directDatabricksRequestBody, gatewayResponseHeaders } from "./src/transport.ts";
 export type { DatabricksTransportRequest } from "./src/transport.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-model-gateway";
-export declare const PACKAGE_VERSION = "0.9.175";
+export declare const PACKAGE_VERSION = "0.9.177";
 export * as gateway from "./src/gateway.ts";
 export * as models from "./src/models.ts";
 export * as plugin from "./src/plugin.ts";
@@ -7,6 +7,7 @@ export * as reasoningAdapt from "./src/reasoning-adapt.ts";
 export * as registry from "./src/registry.ts";
 export * as router from "./src/router.ts";
 export * as routes from "./src/routes.ts";
+export * as smartRouter from "./src/smart-router.ts";
 export * as translation from "./src/translation.ts";
 export * as transport from "./src/transport.ts";
 export { ModelGatewayError, ModelGateway, sanitizeInferenceBody, adaptInferenceTemperature, gatewayModelSelection } from "./src/gateway.ts";
@@ -20,6 +21,8 @@ export { DatabricksModelRegistry } from "./src/registry.ts";
 export type { ModelRegistryResolveOptions, ModelRegistry, ModelRegistryOptions } from "./src/registry.ts";
 export { UnsupportedGatewayFeatureError, resolveRoute, requestedFeatures, isCodexOriginator } from "./src/router.ts";
 export { sendHealth, sendModels, sendInference } from "./src/routes.ts";
+export { SMART_ROUTER_DEFAULT_SETTINGS, SmartRouterProbeRecordSchema, SmartRouterError, AppKitSmartRouterStore, AppKitSmartRouterProbeStore, SmartRouterService, smartRouterCandidates, SmartRouterContextBuilder, SmartModelRouter, smartRouterTurnKey } from "./src/smart-router.ts";
+export type { SmartRouterSettings, SmartRouterCandidate, SmartRouterSelection, SmartRouterStore, SmartRouterProbeRecord, SmartRouterProbeStore, SmartRouterResult, SmartRouterContext, SmartRouterSelectOptions } from "./src/smart-router.ts";
 export { translateGatewayRequest } from "./src/translation.ts";
 export { fetchDatabricks, directDatabricksRequestBody, gatewayResponseHeaders } from "./src/transport.ts";
 export type { DatabricksTransportRequest } from "./src/transport.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-model-gateway";
-export const PACKAGE_VERSION = "0.9.175";
+export const PACKAGE_VERSION = "0.9.177";
 export * as gateway from "./src/gateway.js";
 export * as models from "./src/models.js";
 export * as plugin from "./src/plugin.js";
@@ -10,6 +10,7 @@ export * as reasoningAdapt from "./src/reasoning-adapt.js";
 export * as registry from "./src/registry.js";
 export * as router from "./src/router.js";
 export * as routes from "./src/routes.js";
+export * as smartRouter from "./src/smart-router.js";
 export * as translation from "./src/translation.js";
 export * as transport from "./src/transport.js";
 export { ModelGatewayError, ModelGateway, sanitizeInferenceBody, adaptInferenceTemperature, gatewayModelSelection } from "./src/gateway.js";
@@ -19,6 +20,7 @@ export { adaptInferenceReasoning, learnAndAdaptReasoningRetry } from "./src/reas
 export { DatabricksModelRegistry } from "./src/registry.js";
 export { UnsupportedGatewayFeatureError, resolveRoute, requestedFeatures, isCodexOriginator } from "./src/router.js";
 export { sendHealth, sendModels, sendInference } from "./src/routes.js";
+export { SMART_ROUTER_DEFAULT_SETTINGS, SmartRouterProbeRecordSchema, SmartRouterError, AppKitSmartRouterStore, AppKitSmartRouterProbeStore, SmartRouterService, smartRouterCandidates, SmartRouterContextBuilder, SmartModelRouter, smartRouterTurnKey } from "./src/smart-router.js";
 export { translateGatewayRequest } from "./src/translation.js";
 export { fetchDatabricks, directDatabricksRequestBody, gatewayResponseHeaders } from "./src/transport.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/gateway.d.ts

@@ -4,11 +4,20 @@
  * @module
  */
 import { type ServingEndpointSummary, type ModelClass as ModelClassType } from "@dbx-tools/shared-model";
-import type { ClientProtocol, ModelCapabilityOverride, ModelListResponse } from "@dbx-tools/shared-model-gateway";
+import type { ClientProtocol, ModelCapabilityOverride, ModelListResponse, SmartRouterMode } from "@dbx-tools/shared-model-gateway";
 import { type ModelRegistry } from "./registry.ts";
+import { type SmartRouterService, type SmartRouterStore } from "./smart-router.ts";
 /** Model gateway runtime configuration. */
 export interface ModelGatewayOptions {
     readonly cacheTtlMs?: number;
+    readonly smartRouter?: SmartRouterMode;
+    readonly smartRouterContextTokenBudget?: number;
+    readonly smartRouterProbeRefreshIntervalMs?: number;
+    readonly smartRouterProbeTtlMs?: number;
+    readonly smartRouterRouteTtlSeconds?: number;
+    readonly smartRouterTimeoutMs?: number;
+    readonly smartRouterService?: SmartRouterService;
+    readonly smartRouterStore?: SmartRouterStore;
     readonly overrides?: readonly ModelCapabilityOverride[];
     readonly model?: string;
     readonly modelClass?: ModelClassType;
@@ -22,6 +31,8 @@ export declare class ModelGatewayError extends Error {
 /** AppKit-scoped model gateway with dynamic model discovery and streaming inference. */
 export declare class ModelGateway {
     private readonly registry;
+    private readonly smartRouter?;
+    private readonly smartRouterMode;
     private readonly model?;
     private readonly modelClass?;
     private readonly preferSystemModels;
@@ -43,6 +54,7 @@ export declare function gatewayModelSelection(body: Readonly<Record<string, unkn
     readonly model?: string;
     readonly modelClass?: ModelClassType;
 }, protocol?: ClientProtocol): {
+    readonly smartRouter?: boolean;
     readonly model?: string;
     readonly modelClass?: ModelClassType;
 };

package/lib/src/gateway.js

@@ -3,13 +3,15 @@
  *
  * @module
  */
-import { log } from "@dbx-tools/shared-core";
 import { modelTemperatureSupportFor } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
 import { ModelClass, ModelClassSchema, } from "@dbx-tools/shared-model";
+import { MODEL_GATEWAY_DEFAULTS, SMART_ROUTER_HARNESS_HEADER, SMART_ROUTER_MODEL_ID, SMART_ROUTER_PROFILER_STATUS_HEADER, SMART_ROUTER_ROUTE_MODEL_HEADER, SMART_ROUTER_SELECTED_MODEL_HEADER, SMART_ROUTER_SERVED_TIER_HEADER, SMART_ROUTER_SOURCE_HEADER, SMART_ROUTER_TASK_TIER_HEADER, isSmartRouterModelId, } from "@dbx-tools/shared-model-gateway";
 import { listModelsPayload } from "./models.js";
 import { adaptInferenceReasoning, learnAndAdaptReasoningRetry } from "./reasoning-adapt.js";
 import { DatabricksModelRegistry, } from "./registry.js";
 import { isCodexOriginator, requestedFeatures, resolveRoute } from "./router.js";
+import { SmartModelRouter, } from "./smart-router.js";
 import { translateGatewayRequest } from "./translation.js";
 import { fetchDatabricks, gatewayResponseHeaders } from "./transport.js";
 const logger = log.logger("appkit/model-gateway");
@@ -27,6 +29,8 @@ export class ModelGatewayError extends Error {
 /** AppKit-scoped model gateway with dynamic model discovery and streaming inference. */
 export class ModelGateway {
     registry;
+    smartRouter;
+    smartRouterMode;
     model;
     modelClass;
     preferSystemModels;
@@ -39,18 +43,42 @@ export class ModelGateway {
                 : {}),
         };
         this.registry = registry ?? new DatabricksModelRegistry(registryOptions);
+        this.smartRouterMode = options.smartRouter ?? MODEL_GATEWAY_DEFAULTS.smartRouter;
+        if (this.smartRouterMode !== "false") {
+            this.smartRouter = new SmartModelRouter({
+                contextTokenBudget: options.smartRouterContextTokenBudget ??
+                    MODEL_GATEWAY_DEFAULTS.smartRouterContextTokenBudget,
+                probeRefreshIntervalMs: options.smartRouterProbeRefreshIntervalMs ??
+                    MODEL_GATEWAY_DEFAULTS.smartRouterProbeRefreshIntervalMs,
+                probeTtlMs: options.smartRouterProbeTtlMs ?? MODEL_GATEWAY_DEFAULTS.smartRouterProbeTtlMs,
+                routeTtlSeconds: options.smartRouterRouteTtlSeconds ?? MODEL_GATEWAY_DEFAULTS.smartRouterRouteTtlSeconds,
+                routerName: "task_v3",
+                timeoutMs: options.smartRouterTimeoutMs ?? MODEL_GATEWAY_DEFAULTS.smartRouterTimeoutMs,
+            }, options.smartRouterService, options.smartRouterStore);
+        }
         this.model = options.model;
         this.modelClass = options.modelClass;
-        this.preferSystemModels = options.preferSystemModels ?? false;
+        this.preferSystemModels =
+            options.preferSystemModels ?? MODEL_GATEWAY_DEFAULTS.preferSystemModels;
     }
     /** Return the live OpenAI model list, including Codex metadata when requested. */
     async models(originator, search) {
         const codex = isCodexOriginator(originator);
         logger.debug("listing models", { codex, search });
         const query = search?.trim();
-        const targets = query ? await this.registry.search(query) : await this.registry.list();
+        const smartRouterSearch = query !== undefined && SMART_ROUTER_MODEL_ID.includes(query.toLowerCase());
+        const targets = query && !smartRouterSearch ? await this.registry.search(query) : await this.registry.list();
+        const smartRouterTargets = this.smartRouterMode === "true" && query && !smartRouterSearch
+            ? await this.registry.list()
+            : targets;
+        const shouldProbeSmartRouter = Boolean(this.smartRouter) && (this.smartRouterMode === "true" || !query || smartRouterSearch);
+        const smartRouterEnabled = shouldProbeSmartRouter && (await this.smartRouter.isEnabled(smartRouterTargets));
+        if (this.smartRouterMode === "true" && !smartRouterEnabled) {
+            throw new ModelGatewayError(503, "Databricks Smart Router is required but unavailable for the active workspace identity");
+        }
         logger.debug("listed models", { codex, count: targets.length });
-        return listModelsPayload(targets, codex, query !== undefined && query.length > 0, this.preferSystemModels);
+        const payload = listModelsPayload(targets, codex, query !== undefined && query.length > 0, this.preferSystemModels, smartRouterEnabled && (!query || smartRouterSearch));
+        return smartRouterSearch ? onlySmartRouter(payload) : payload;
     }
     /** Resolve and execute one inference request. */
     async inference(protocol, body, headers, signal) {
@@ -60,6 +88,7 @@ export class ModelGateway {
             modelClass: this.modelClass,
         }, protocol);
         logger.debug("resolving request", {
+            smartRouter: selection.smartRouter === true,
             clientProtocol: protocol,
             model: selection.model,
             modelClass: selection.modelClass,
@@ -67,11 +96,29 @@ export class ModelGateway {
             stream: sanitizedBody.stream === true,
         });
         const features = requestedFeatures(sanitizedBody);
-        const target = await this.registry.resolve(selection.model, {
-            ...(protocol === "openai-embeddings" ? { modelClass: ModelClass.Embedding } : {}),
-            ...(selection.modelClass ? { modelClass: selection.modelClass } : {}),
-            ...(features.tools ? { requiresTools: true } : {}),
-        });
+        if (selection.smartRouter && protocol === "openai-embeddings") {
+            throw new ModelGatewayError(400, "Model smart-router is available only for chat requests");
+        }
+        const smartRouter = selection.smartRouter && this.smartRouter
+            ? await this.smartRouter.resolve({
+                protocol: protocol,
+                body: sanitizedBody,
+                headers,
+                features,
+                targets: await this.registry.list(),
+                preferSystemModels: this.preferSystemModels,
+                signal,
+            })
+            : undefined;
+        if (selection.smartRouter && !smartRouter) {
+            throw new ModelGatewayError(404, "Databricks Smart Router is disabled");
+        }
+        const target = smartRouter?.target ??
+            (await this.registry.resolve(selection.model, {
+                ...(protocol === "openai-embeddings" ? { modelClass: ModelClass.Embedding } : {}),
+                ...(selection.modelClass ? { modelClass: selection.modelClass } : {}),
+                ...(features.tools ? { requiresTools: true } : {}),
+            }));
         if (!target) {
             throw new ModelGatewayError(404, selection.model
                 ? `Model not found: ${selection.model}`
@@ -79,7 +126,7 @@ export class ModelGateway {
         }
         const route = resolveRoute({
             clientProtocol: protocol,
-            ...(selection.model ? { requestedModel: selection.model } : {}),
+            ...(!smartRouter && selection.model ? { requestedModel: selection.model } : {}),
             originator: headers.get("originator") ?? undefined,
             preferSystemModels: this.preferSystemModels,
             features,
@@ -90,7 +137,7 @@ export class ModelGateway {
             model: target.id,
             upstreamProtocol: route.upstreamProtocol,
         });
-        const temperatureBody = adaptInferenceTemperature(target.endpoint ?? target.id, sanitizedBody);
+        const temperatureBody = adaptInferenceTemperature(target.endpoint ?? target.id, smartRouter?.body ?? sanitizedBody);
         const adapted = adaptInferenceReasoning(target.id, temperatureBody);
         let response = await this.forward(route, adapted.body, headers, signal);
         const retryBody = await learnAndAdaptReasoningRetry({
@@ -106,10 +153,15 @@ export class ModelGateway {
         logResponse(route.upstreamProtocol, target.id, response);
         if (route.upstreamProtocol === "ai-sdk") {
             response.headers.set("x-dbx-tools-upstream", route.upstreamProtocol);
+            if (smartRouter) {
+                applySmartRouterObservationHeaders(response.headers, smartRouter.observation);
+            }
             return response;
         }
         const forwarded = gatewayResponseHeaders(response.headers);
         forwarded.set("x-dbx-tools-upstream", route.upstreamProtocol);
+        if (smartRouter)
+            applySmartRouterObservationHeaders(forwarded, smartRouter.observation);
         return new Response(response.body, {
             status: response.status,
             statusText: response.statusText,
@@ -169,17 +221,48 @@ export function gatewayModelSelection(body, headers, defaults = {}, protocol) {
         throw new ModelGatewayError(400, "Model and model class are mutually exclusive");
     }
     if (model)
-        return { model };
+        return isSmartRouterModelId(model) ? { smartRouter: true } : { model };
     if (parsedClass?.data)
         return { modelClass: parsedClass.data };
-    if (defaults.model)
-        return { model: defaults.model };
+    if (defaults.model) {
+        return isSmartRouterModelId(defaults.model) ? { smartRouter: true } : { model: defaults.model };
+    }
     if (defaults.modelClass)
         return { modelClass: defaults.modelClass };
     if (protocol === "openai-embeddings")
         return { modelClass: ModelClass.Embedding };
     return {};
 }
+function applySmartRouterObservationHeaders(headers, observation) {
+    headers.set(SMART_ROUTER_SELECTED_MODEL_HEADER, observation.selectedModel);
+    headers.set(SMART_ROUTER_ROUTE_MODEL_HEADER, observation.routeModel);
+    headers.set(SMART_ROUTER_HARNESS_HEADER, observation.harness);
+    headers.set(SMART_ROUTER_SOURCE_HEADER, observation.source);
+    const taskTier = stringParam(observation.params, "task_tier");
+    const servedTier = stringParam(observation.params, "served_tier");
+    const profilerStatus = stringParam(observation.params, "profiler_status");
+    if (taskTier)
+        headers.set(SMART_ROUTER_TASK_TIER_HEADER, taskTier);
+    if (servedTier)
+        headers.set(SMART_ROUTER_SERVED_TIER_HEADER, servedTier);
+    if (profilerStatus)
+        headers.set(SMART_ROUTER_PROFILER_STATUS_HEADER, profilerStatus);
+}
+function stringParam(params, key) {
+    const value = params?.[key];
+    return typeof value === "string" && value ? value : undefined;
+}
+function onlySmartRouter(payload) {
+    if ("models" in payload) {
+        return {
+            models: payload.models.filter((model) => model.slug.toLowerCase().endsWith(`/${SMART_ROUTER_MODEL_ID}`)),
+        };
+    }
+    return {
+        object: "list",
+        data: payload.data.filter((model) => model.id === SMART_ROUTER_MODEL_ID),
+    };
+}
 function logResponse(upstreamProtocol, model, response) {
     const details = {
         contentType: response.headers.get("content-type"),
@@ -192,4 +275,4 @@ function logResponse(upstreamProtocol, model, response) {
     else
         logger.warn("upstream request failed", details);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../src/gateway.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,UAAU,EACV,gBAAgB,GAGjB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EACL,uBAAuB,GAGxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAEzE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAClD,MAAM,0BAA0B,GAAG,CAAC,CAAC;AACrC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAWrC,+DAA+D;AAC/D,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAE/B;IADX,YACW,MAAc,EACvB,OAAe;QAEf,KAAK,CAAC,OAAO,CAAC,CAAC;QAHN,WAAM,GAAN,MAAM,CAAQ;QAIvB,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AAED,wFAAwF;AACxF,MAAM,OAAO,YAAY;IACN,QAAQ,CAAgB;IACxB,KAAK,CAAU;IACf,UAAU,CAAkB;IAC5B,kBAAkB,CAAU;IAE7C,YAAY,UAA+B,EAAE,EAAE,QAAwB;QACrE,MAAM,eAAe,GAAyB;YAC5C,GAAG,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9D,GAAG,CAAC,OAAO,CAAC,kBAAkB,KAAK,SAAS;gBAC1C,CAAC,CAAC,EAAE,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,EAAE;gBACpD,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,IAAI,uBAAuB,CAAC,eAAe,CAAC,CAAC;QACzE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,IAAI,KAAK,CAAC;IAChE,CAAC;IAED,kFAAkF;IAClF,KAAK,CAAC,MAAM,CAAC,UAAmB,EAAE,MAAe;QAC/C,MAAM,KAAK,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5C,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAClD,MAAM,KAAK,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACvF,MAAM,CAAC,KAAK,CAAC,eAAe,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAChE,OAAO,iBAAiB,CACtB,OAAO,EACP,KAAK,EACL,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EACvC,IAAI,CAAC,kBAAkB,CACxB,CAAC;IACJ,CAAC;IAED,iDAAiD;IACjD,KAAK,CAAC,SAAS,CACb,QAAwB,EACxB,IAAuC,EACvC,OAAgB,EAChB,MAAmB;QAEnB,MAAM,aAAa,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,SAAS,GAAG,qBAAqB,CACrC,aAAa,EACb,OAAO,EACP;YACE,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,EACD,QAAQ,CACT,CAAC;QACF,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE;YAChC,cAAc,EAAE,QAAQ;YACxB,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,UAAU,EAAE,SAAS,CAAC,UAAU;YAChC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,SAAS;YAClD,MAAM,EAAE,aAAa,CAAC,MAAM,KAAK,IAAI;SACtC,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,EAAE;YAC1D,GAAG,CAAC,QAAQ,KAAK,mBAAmB,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACjF,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnD,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,iBAAiB,CACzB,GAAG,EACH,SAAS,CAAC,KAAK;gBACb,CAAC,CAAC,oBAAoB,SAAS,CAAC,KAAK,EAAE;gBACvC,CAAC,CAAC,sCAAsC,CAC3C,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,GAAG,YAAY,CAAC;YACzB,cAAc,EAAE,QAAQ;YACxB,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,SAAS;YAClD,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,QAAQ;YACR,MAAM;SACP,CAAC,CAAC;QACH,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE;YACrB,cAAc,EAAE,QAAQ;YACxB,KAAK,EAAE,MAAM,CAAC,EAAE;YAChB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;SACzC,CAAC,CAAC;QAEH,MAAM,eAAe,GAAG,yBAAyB,CAC/C,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,EAAE,EAC5B,aAAa,CACd,CAAC;QACF,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,CAAC;QACpE,IAAI,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QACxE,MAAM,SAAS,GAAG,MAAM,2BAA2B,CAAC;YAClD,KAAK,EAAE,MAAM,CAAC,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,QAAQ;YACR,kBAAkB,EAAE,OAAO,CAAC,UAAU;SACvC,CAAC,CAAC;QACH,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACrD,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QACnE,CAAC;QAED,WAAW,CAAC,KAAK,CAAC,gBAAgB,EAAE,MAAM,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,KAAK,CAAC,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YACxC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;YACrE,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,MAAM,SAAS,GAAG,sBAAsB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC3D,SAAS,CAAC,GAAG,CAAC,sBAAsB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC9D,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE;YACjC,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,OAAO,EAAE,SAAS;SACnB,CAAC,CAAC;IACL,CAAC;IAED,sDAAsD;IACtD,OAAO;QACL,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;IACjC,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,KAAmB,EACnB,IAAuC,EACvC,OAAgB,EAChB,MAAmB;QAEnB,IAAI,KAAK,CAAC,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YACxC,OAAO,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,eAAe,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3D,CAAC;CACF;AAED,qEAAqE;AACrE,MAAM,UAAU,qBAAqB,CACnC,IAAuC;IAEvC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;QAC9B,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/E,MAAM,IAAI,iBAAiB,CAAC,GAAG,EAAE,uDAAuD,CAAC,CAAC;QAC5F,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC;IAC9B,OAAO,SAAS,CAAC,WAAW,CAAC;IAC7B,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,yBAAyB,CACvC,KAAsC,EACtC,IAAuC;IAEvC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC7F,MAAM,SAAS,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACzC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC;QAC5B,OAAO,OAAO,CAAC,WAAW,CAAC;QAC3B,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAC1B,0BAA0B,EAC1B,IAAI,CAAC,GAAG,CAAC,0BAA0B,EAAE,IAAI,CAAC,WAAW,CAAC,CACvD,CAAC;IACF,OAAO,WAAW,KAAK,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,CAAC;AAC5E,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,qBAAqB,CACnC,IAAuC,EACvC,OAAgB,EAChB,WAA8E,EAAE,EAChF,QAAyB;IAEzB,MAAM,KAAK,GAAG,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAClG,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,EAAE,IAAI,EAAE,CAAC;IAC9D,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,IAAI,WAAW,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QACxC,MAAM,IAAI,iBAAiB,CAAC,GAAG,EAAE,wBAAwB,MAAM,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,IAAI,KAAK,IAAI,WAAW,EAAE,IAAI,EAAE,CAAC;QAC/B,MAAM,IAAI,iBAAiB,CAAC,GAAG,EAAE,8CAA8C,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,IAAI,WAAW,EAAE,IAAI;QAAE,OAAO,EAAE,UAAU,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC;IAC/D,IAAI,QAAQ,CAAC,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;IACrD,IAAI,QAAQ,CAAC,UAAU;QAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;IACpE,IAAI,QAAQ,KAAK,mBAAmB;QAAE,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC,SAAS,EAAE,CAAC;IAClF,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,SAAS,WAAW,CAAC,gBAAwB,EAAE,KAAa,EAAE,QAAkB;IAC9E,MAAM,OAAO,GAAG;QACd,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QACjD,KAAK;QACL,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,gBAAgB;KACjB,CAAC;IACF,IAAI,QAAQ,CAAC,EAAE;QAAE,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,OAAO,CAAC,CAAC;;QACvD,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC","sourcesContent":["/**\n * Protocol-independent gateway service used by plugin and standalone routes.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport { modelTemperatureSupportFor } from \"@dbx-tools/model\";\nimport {\n  ModelClass,\n  ModelClassSchema,\n  type ServingEndpointSummary,\n  type ModelClass as ModelClassType,\n} from \"@dbx-tools/shared-model\";\nimport type {\n  ClientProtocol,\n  GatewayRoute,\n  ModelCapabilityOverride,\n  ModelListResponse,\n} from \"@dbx-tools/shared-model-gateway\";\n\nimport { listModelsPayload } from \"./models.ts\";\nimport { adaptInferenceReasoning, learnAndAdaptReasoningRetry } from \"./reasoning-adapt.ts\";\nimport {\n  DatabricksModelRegistry,\n  type ModelRegistry,\n  type ModelRegistryOptions,\n} from \"./registry.ts\";\nimport { isCodexOriginator, requestedFeatures, resolveRoute } from \"./router.ts\";\nimport { translateGatewayRequest } from \"./translation.ts\";\nimport { fetchDatabricks, gatewayResponseHeaders } from \"./transport.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway\");\nconst DATABRICKS_TEMPERATURE_MIN = 0;\nconst DATABRICKS_TEMPERATURE_MAX = 2;\n\n/** Model gateway runtime configuration. */\nexport interface ModelGatewayOptions {\n  readonly cacheTtlMs?: number;\n  readonly overrides?: readonly ModelCapabilityOverride[];\n  readonly model?: string;\n  readonly modelClass?: ModelClassType;\n  readonly preferSystemModels?: boolean;\n}\n\n/** Error carrying an HTTP status and protocol-safe message. */\nexport class ModelGatewayError extends Error {\n  constructor(\n    readonly status: number,\n    message: string,\n  ) {\n    super(message);\n    this.name = \"ModelGatewayError\";\n  }\n}\n\n/** AppKit-scoped model gateway with dynamic model discovery and streaming inference. */\nexport class ModelGateway {\n  private readonly registry: ModelRegistry;\n  private readonly model?: string;\n  private readonly modelClass?: ModelClassType;\n  private readonly preferSystemModels: boolean;\n\n  constructor(options: ModelGatewayOptions = {}, registry?: ModelRegistry) {\n    const registryOptions: ModelRegistryOptions = {\n      ...(options.cacheTtlMs !== undefined ? { ttlMs: options.cacheTtlMs } : {}),\n      ...(options.overrides ? { overrides: options.overrides } : {}),\n      ...(options.preferSystemModels !== undefined\n        ? { preferSystemModels: options.preferSystemModels }\n        : {}),\n    };\n    this.registry = registry ?? new DatabricksModelRegistry(registryOptions);\n    this.model = options.model;\n    this.modelClass = options.modelClass;\n    this.preferSystemModels = options.preferSystemModels ?? false;\n  }\n\n  /** Return the live OpenAI model list, including Codex metadata when requested. */\n  async models(originator?: string, search?: string): Promise<ModelListResponse> {\n    const codex = isCodexOriginator(originator);\n    logger.debug(\"listing models\", { codex, search });\n    const query = search?.trim();\n    const targets = query ? await this.registry.search(query) : await this.registry.list();\n    logger.debug(\"listed models\", { codex, count: targets.length });\n    return listModelsPayload(\n      targets,\n      codex,\n      query !== undefined && query.length > 0,\n      this.preferSystemModels,\n    );\n  }\n\n  /** Resolve and execute one inference request. */\n  async inference(\n    protocol: ClientProtocol,\n    body: Readonly<Record<string, unknown>>,\n    headers: Headers,\n    signal: AbortSignal,\n  ): Promise<Response> {\n    const sanitizedBody = sanitizeInferenceBody(body);\n    const selection = gatewayModelSelection(\n      sanitizedBody,\n      headers,\n      {\n        model: this.model,\n        modelClass: this.modelClass,\n      },\n      protocol,\n    );\n    logger.debug(\"resolving request\", {\n      clientProtocol: protocol,\n      model: selection.model,\n      modelClass: selection.modelClass,\n      originator: headers.get(\"originator\") ?? undefined,\n      stream: sanitizedBody.stream === true,\n    });\n    const features = requestedFeatures(sanitizedBody);\n    const target = await this.registry.resolve(selection.model, {\n      ...(protocol === \"openai-embeddings\" ? { modelClass: ModelClass.Embedding } : {}),\n      ...(selection.modelClass ? { modelClass: selection.modelClass } : {}),\n      ...(features.tools ? { requiresTools: true } : {}),\n    });\n    if (!target) {\n      throw new ModelGatewayError(\n        404,\n        selection.model\n          ? `Model not found: ${selection.model}`\n          : \"No model matches the requested class\",\n      );\n    }\n    const route = resolveRoute({\n      clientProtocol: protocol,\n      ...(selection.model ? { requestedModel: selection.model } : {}),\n      originator: headers.get(\"originator\") ?? undefined,\n      preferSystemModels: this.preferSystemModels,\n      features,\n      target,\n    });\n    logger.debug(\"routed\", {\n      clientProtocol: protocol,\n      model: target.id,\n      upstreamProtocol: route.upstreamProtocol,\n    });\n\n    const temperatureBody = adaptInferenceTemperature(\n      target.endpoint ?? target.id,\n      sanitizedBody,\n    );\n    const adapted = adaptInferenceReasoning(target.id, temperatureBody);\n    let response = await this.forward(route, adapted.body, headers, signal);\n    const retryBody = await learnAndAdaptReasoningRetry({\n      model: target.id,\n      body: temperatureBody,\n      response,\n      previousWireEffort: adapted.wireEffort,\n    });\n    if (retryBody) {\n      await response.body?.cancel().catch(() => undefined);\n      response = await this.forward(route, retryBody, headers, signal);\n    }\n\n    logResponse(route.upstreamProtocol, target.id, response);\n    if (route.upstreamProtocol === \"ai-sdk\") {\n      response.headers.set(\"x-dbx-tools-upstream\", route.upstreamProtocol);\n      return response;\n    }\n    const forwarded = gatewayResponseHeaders(response.headers);\n    forwarded.set(\"x-dbx-tools-upstream\", route.upstreamProtocol);\n    return new Response(response.body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers: forwarded,\n    });\n  }\n\n  /** Refresh the active principal's model catalogue. */\n  refresh(): Promise<void> {\n    logger.debug(\"refreshing model catalogue\");\n    return this.registry.refresh();\n  }\n\n  private async forward(\n    route: GatewayRoute,\n    body: Readonly<Record<string, unknown>>,\n    headers: Headers,\n    signal: AbortSignal,\n  ): Promise<Response> {\n    if (route.upstreamProtocol === \"ai-sdk\") {\n      return translateGatewayRequest(route, body, signal);\n    }\n    return fetchDatabricks({ route, body, headers, signal });\n  }\n}\n\n/** Remove null temperature and reject explicit nonnumeric values. */\nexport function sanitizeInferenceBody(\n  body: Readonly<Record<string, unknown>>,\n): Readonly<Record<string, unknown>> {\n  if (!Object.hasOwn(body, \"temperature\")) return body;\n  if (body.temperature !== null) {\n    if (typeof body.temperature !== \"number\" || !Number.isFinite(body.temperature)) {\n      throw new ModelGatewayError(400, \"temperature must be a finite number, null, or omitted\");\n    }\n    return body;\n  }\n  const sanitized = { ...body };\n  delete sanitized.temperature;\n  return sanitized;\n}\n\n/** Apply published Databricks temperature support and range policy. */\nexport function adaptInferenceTemperature(\n  model: string | ServingEndpointSummary,\n  body: Readonly<Record<string, unknown>>,\n): Readonly<Record<string, unknown>> {\n  if (!Object.hasOwn(body, \"temperature\") || typeof body.temperature !== \"number\") return body;\n  const supported = modelTemperatureSupportFor(model);\n  if (supported === undefined) return body;\n  if (!supported) {\n    const adapted = { ...body };\n    delete adapted.temperature;\n    return adapted;\n  }\n  const temperature = Math.min(\n    DATABRICKS_TEMPERATURE_MAX,\n    Math.max(DATABRICKS_TEMPERATURE_MIN, body.temperature),\n  );\n  return temperature === body.temperature ? body : { ...body, temperature };\n}\n\n/** Resolve request, header, configured, and protocol model-selection inputs. */\nexport function gatewayModelSelection(\n  body: Readonly<Record<string, unknown>>,\n  headers: Headers,\n  defaults: { readonly model?: string; readonly modelClass?: ModelClassType } = {},\n  protocol?: ClientProtocol,\n): { readonly model?: string; readonly modelClass?: ModelClassType } {\n  const model = typeof body.model === \"string\" && body.model.trim() ? body.model.trim() : undefined;\n  const header = headers.get(\"x-dbx-tools-model-class\")?.trim();\n  const parsedClass = header ? ModelClassSchema.safeParse(header) : undefined;\n  if (parsedClass && !parsedClass.success) {\n    throw new ModelGatewayError(400, `Invalid model class: ${header}`);\n  }\n  if (model && parsedClass?.data) {\n    throw new ModelGatewayError(400, \"Model and model class are mutually exclusive\");\n  }\n  if (model) return { model };\n  if (parsedClass?.data) return { modelClass: parsedClass.data };\n  if (defaults.model) return { model: defaults.model };\n  if (defaults.modelClass) return { modelClass: defaults.modelClass };\n  if (protocol === \"openai-embeddings\") return { modelClass: ModelClass.Embedding };\n  return {};\n}\n\nfunction logResponse(upstreamProtocol: string, model: string, response: Response): void {\n  const details = {\n    contentType: response.headers.get(\"content-type\"),\n    model,\n    status: response.status,\n    upstreamProtocol,\n  };\n  if (response.ok) logger.debug(\"upstream response\", details);\n  else logger.warn(\"upstream request failed\", details);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../src/gateway.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Protocol-independent gateway service used by plugin and standalone routes.\n *\n * @module\n */\n\nimport { modelTemperatureSupportFor } from \"@dbx-tools/model\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  ModelClass,\n  ModelClassSchema,\n  type ServingEndpointSummary,\n  type ModelClass as ModelClassType,\n} from \"@dbx-tools/shared-model\";\nimport type {\n  ClientProtocol,\n  GatewayRoute,\n  ModelCapabilityOverride,\n  ModelListResponse,\n  SmartRouterObservation,\n  SmartRouterMode,\n} from \"@dbx-tools/shared-model-gateway\";\nimport {\n  MODEL_GATEWAY_DEFAULTS,\n  SMART_ROUTER_HARNESS_HEADER,\n  SMART_ROUTER_MODEL_ID,\n  SMART_ROUTER_PROFILER_STATUS_HEADER,\n  SMART_ROUTER_ROUTE_MODEL_HEADER,\n  SMART_ROUTER_SELECTED_MODEL_HEADER,\n  SMART_ROUTER_SERVED_TIER_HEADER,\n  SMART_ROUTER_SOURCE_HEADER,\n  SMART_ROUTER_TASK_TIER_HEADER,\n  isSmartRouterModelId,\n} from \"@dbx-tools/shared-model-gateway\";\n\nimport { listModelsPayload } from \"./models.ts\";\nimport { adaptInferenceReasoning, learnAndAdaptReasoningRetry } from \"./reasoning-adapt.ts\";\nimport {\n  DatabricksModelRegistry,\n  type ModelRegistry,\n  type ModelRegistryOptions,\n} from \"./registry.ts\";\nimport { isCodexOriginator, requestedFeatures, resolveRoute } from \"./router.ts\";\nimport {\n  SmartModelRouter,\n  type SmartRouterService,\n  type SmartRouterStore,\n} from \"./smart-router.ts\";\nimport { translateGatewayRequest } from \"./translation.ts\";\nimport { fetchDatabricks, gatewayResponseHeaders } from \"./transport.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway\");\nconst DATABRICKS_TEMPERATURE_MIN = 0;\nconst DATABRICKS_TEMPERATURE_MAX = 2;\n\n/** Model gateway runtime configuration. */\nexport interface ModelGatewayOptions {\n  readonly cacheTtlMs?: number;\n  readonly smartRouter?: SmartRouterMode;\n  readonly smartRouterContextTokenBudget?: number;\n  readonly smartRouterProbeRefreshIntervalMs?: number;\n  readonly smartRouterProbeTtlMs?: number;\n  readonly smartRouterRouteTtlSeconds?: number;\n  readonly smartRouterTimeoutMs?: number;\n  readonly smartRouterService?: SmartRouterService;\n  readonly smartRouterStore?: SmartRouterStore;\n  readonly overrides?: readonly ModelCapabilityOverride[];\n  readonly model?: string;\n  readonly modelClass?: ModelClassType;\n  readonly preferSystemModels?: boolean;\n}\n\n/** Error carrying an HTTP status and protocol-safe message. */\nexport class ModelGatewayError extends Error {\n  constructor(\n    readonly status: number,\n    message: string,\n  ) {\n    super(message);\n    this.name = \"ModelGatewayError\";\n  }\n}\n\n/** AppKit-scoped model gateway with dynamic model discovery and streaming inference. */\nexport class ModelGateway {\n  private readonly registry: ModelRegistry;\n  private readonly smartRouter?: SmartModelRouter;\n  private readonly smartRouterMode: SmartRouterMode;\n  private readonly model?: string;\n  private readonly modelClass?: ModelClassType;\n  private readonly preferSystemModels: boolean;\n\n  constructor(options: ModelGatewayOptions = {}, registry?: ModelRegistry) {\n    const registryOptions: ModelRegistryOptions = {\n      ...(options.cacheTtlMs !== undefined ? { ttlMs: options.cacheTtlMs } : {}),\n      ...(options.overrides ? { overrides: options.overrides } : {}),\n      ...(options.preferSystemModels !== undefined\n        ? { preferSystemModels: options.preferSystemModels }\n        : {}),\n    };\n    this.registry = registry ?? new DatabricksModelRegistry(registryOptions);\n    this.smartRouterMode = options.smartRouter ?? MODEL_GATEWAY_DEFAULTS.smartRouter;\n    if (this.smartRouterMode !== \"false\") {\n      this.smartRouter = new SmartModelRouter(\n        {\n          contextTokenBudget:\n            options.smartRouterContextTokenBudget ??\n            MODEL_GATEWAY_DEFAULTS.smartRouterContextTokenBudget,\n          probeRefreshIntervalMs:\n            options.smartRouterProbeRefreshIntervalMs ??\n            MODEL_GATEWAY_DEFAULTS.smartRouterProbeRefreshIntervalMs,\n          probeTtlMs: options.smartRouterProbeTtlMs ?? MODEL_GATEWAY_DEFAULTS.smartRouterProbeTtlMs,\n          routeTtlSeconds:\n            options.smartRouterRouteTtlSeconds ?? MODEL_GATEWAY_DEFAULTS.smartRouterRouteTtlSeconds,\n          routerName: \"task_v3\",\n          timeoutMs: options.smartRouterTimeoutMs ?? MODEL_GATEWAY_DEFAULTS.smartRouterTimeoutMs,\n        },\n        options.smartRouterService,\n        options.smartRouterStore,\n      );\n    }\n    this.model = options.model;\n    this.modelClass = options.modelClass;\n    this.preferSystemModels =\n      options.preferSystemModels ?? MODEL_GATEWAY_DEFAULTS.preferSystemModels;\n  }\n\n  /** Return the live OpenAI model list, including Codex metadata when requested. */\n  async models(originator?: string, search?: string): Promise<ModelListResponse> {\n    const codex = isCodexOriginator(originator);\n    logger.debug(\"listing models\", { codex, search });\n    const query = search?.trim();\n    const smartRouterSearch =\n      query !== undefined && SMART_ROUTER_MODEL_ID.includes(query.toLowerCase());\n    const targets =\n      query && !smartRouterSearch ? await this.registry.search(query) : await this.registry.list();\n    const smartRouterTargets =\n      this.smartRouterMode === \"true\" && query && !smartRouterSearch\n        ? await this.registry.list()\n        : targets;\n    const shouldProbeSmartRouter =\n      Boolean(this.smartRouter) && (this.smartRouterMode === \"true\" || !query || smartRouterSearch);\n    const smartRouterEnabled =\n      shouldProbeSmartRouter && (await this.smartRouter!.isEnabled(smartRouterTargets));\n    if (this.smartRouterMode === \"true\" && !smartRouterEnabled) {\n      throw new ModelGatewayError(\n        503,\n        \"Databricks Smart Router is required but unavailable for the active workspace identity\",\n      );\n    }\n    logger.debug(\"listed models\", { codex, count: targets.length });\n    const payload = listModelsPayload(\n      targets,\n      codex,\n      query !== undefined && query.length > 0,\n      this.preferSystemModels,\n      smartRouterEnabled && (!query || smartRouterSearch),\n    );\n    return smartRouterSearch ? onlySmartRouter(payload) : payload;\n  }\n\n  /** Resolve and execute one inference request. */\n  async inference(\n    protocol: ClientProtocol,\n    body: Readonly<Record<string, unknown>>,\n    headers: Headers,\n    signal: AbortSignal,\n  ): Promise<Response> {\n    const sanitizedBody = sanitizeInferenceBody(body);\n    const selection = gatewayModelSelection(\n      sanitizedBody,\n      headers,\n      {\n        model: this.model,\n        modelClass: this.modelClass,\n      },\n      protocol,\n    );\n    logger.debug(\"resolving request\", {\n      smartRouter: selection.smartRouter === true,\n      clientProtocol: protocol,\n      model: selection.model,\n      modelClass: selection.modelClass,\n      originator: headers.get(\"originator\") ?? undefined,\n      stream: sanitizedBody.stream === true,\n    });\n    const features = requestedFeatures(sanitizedBody);\n    if (selection.smartRouter && protocol === \"openai-embeddings\") {\n      throw new ModelGatewayError(400, \"Model smart-router is available only for chat requests\");\n    }\n    const smartRouter =\n      selection.smartRouter && this.smartRouter\n        ? await this.smartRouter.resolve({\n            protocol: protocol as Exclude<ClientProtocol, \"openai-embeddings\">,\n            body: sanitizedBody,\n            headers,\n            features,\n            targets: await this.registry.list(),\n            preferSystemModels: this.preferSystemModels,\n            signal,\n          })\n        : undefined;\n    if (selection.smartRouter && !smartRouter) {\n      throw new ModelGatewayError(404, \"Databricks Smart Router is disabled\");\n    }\n    const target =\n      smartRouter?.target ??\n      (await this.registry.resolve(selection.model, {\n        ...(protocol === \"openai-embeddings\" ? { modelClass: ModelClass.Embedding } : {}),\n        ...(selection.modelClass ? { modelClass: selection.modelClass } : {}),\n        ...(features.tools ? { requiresTools: true } : {}),\n      }));\n    if (!target) {\n      throw new ModelGatewayError(\n        404,\n        selection.model\n          ? `Model not found: ${selection.model}`\n          : \"No model matches the requested class\",\n      );\n    }\n    const route = resolveRoute({\n      clientProtocol: protocol,\n      ...(!smartRouter && selection.model ? { requestedModel: selection.model } : {}),\n      originator: headers.get(\"originator\") ?? undefined,\n      preferSystemModels: this.preferSystemModels,\n      features,\n      target,\n    });\n    logger.debug(\"routed\", {\n      clientProtocol: protocol,\n      model: target.id,\n      upstreamProtocol: route.upstreamProtocol,\n    });\n\n    const temperatureBody = adaptInferenceTemperature(\n      target.endpoint ?? target.id,\n      smartRouter?.body ?? sanitizedBody,\n    );\n    const adapted = adaptInferenceReasoning(target.id, temperatureBody);\n    let response = await this.forward(route, adapted.body, headers, signal);\n    const retryBody = await learnAndAdaptReasoningRetry({\n      model: target.id,\n      body: temperatureBody,\n      response,\n      previousWireEffort: adapted.wireEffort,\n    });\n    if (retryBody) {\n      await response.body?.cancel().catch(() => undefined);\n      response = await this.forward(route, retryBody, headers, signal);\n    }\n\n    logResponse(route.upstreamProtocol, target.id, response);\n    if (route.upstreamProtocol === \"ai-sdk\") {\n      response.headers.set(\"x-dbx-tools-upstream\", route.upstreamProtocol);\n      if (smartRouter) {\n        applySmartRouterObservationHeaders(response.headers, smartRouter.observation);\n      }\n      return response;\n    }\n    const forwarded = gatewayResponseHeaders(response.headers);\n    forwarded.set(\"x-dbx-tools-upstream\", route.upstreamProtocol);\n    if (smartRouter) applySmartRouterObservationHeaders(forwarded, smartRouter.observation);\n    return new Response(response.body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers: forwarded,\n    });\n  }\n\n  /** Refresh the active principal's model catalogue. */\n  refresh(): Promise<void> {\n    logger.debug(\"refreshing model catalogue\");\n    return this.registry.refresh();\n  }\n\n  private async forward(\n    route: GatewayRoute,\n    body: Readonly<Record<string, unknown>>,\n    headers: Headers,\n    signal: AbortSignal,\n  ): Promise<Response> {\n    if (route.upstreamProtocol === \"ai-sdk\") {\n      return translateGatewayRequest(route, body, signal);\n    }\n    return fetchDatabricks({ route, body, headers, signal });\n  }\n}\n\n/** Remove null temperature and reject explicit nonnumeric values. */\nexport function sanitizeInferenceBody(\n  body: Readonly<Record<string, unknown>>,\n): Readonly<Record<string, unknown>> {\n  if (!Object.hasOwn(body, \"temperature\")) return body;\n  if (body.temperature !== null) {\n    if (typeof body.temperature !== \"number\" || !Number.isFinite(body.temperature)) {\n      throw new ModelGatewayError(400, \"temperature must be a finite number, null, or omitted\");\n    }\n    return body;\n  }\n  const sanitized = { ...body };\n  delete sanitized.temperature;\n  return sanitized;\n}\n\n/** Apply published Databricks temperature support and range policy. */\nexport function adaptInferenceTemperature(\n  model: string | ServingEndpointSummary,\n  body: Readonly<Record<string, unknown>>,\n): Readonly<Record<string, unknown>> {\n  if (!Object.hasOwn(body, \"temperature\") || typeof body.temperature !== \"number\") return body;\n  const supported = modelTemperatureSupportFor(model);\n  if (supported === undefined) return body;\n  if (!supported) {\n    const adapted = { ...body };\n    delete adapted.temperature;\n    return adapted;\n  }\n  const temperature = Math.min(\n    DATABRICKS_TEMPERATURE_MAX,\n    Math.max(DATABRICKS_TEMPERATURE_MIN, body.temperature),\n  );\n  return temperature === body.temperature ? body : { ...body, temperature };\n}\n\n/** Resolve request, header, configured, and protocol model-selection inputs. */\nexport function gatewayModelSelection(\n  body: Readonly<Record<string, unknown>>,\n  headers: Headers,\n  defaults: { readonly model?: string; readonly modelClass?: ModelClassType } = {},\n  protocol?: ClientProtocol,\n): {\n  readonly smartRouter?: boolean;\n  readonly model?: string;\n  readonly modelClass?: ModelClassType;\n} {\n  const model = typeof body.model === \"string\" && body.model.trim() ? body.model.trim() : undefined;\n  const header = headers.get(\"x-dbx-tools-model-class\")?.trim();\n  const parsedClass = header ? ModelClassSchema.safeParse(header) : undefined;\n  if (parsedClass && !parsedClass.success) {\n    throw new ModelGatewayError(400, `Invalid model class: ${header}`);\n  }\n  if (model && parsedClass?.data) {\n    throw new ModelGatewayError(400, \"Model and model class are mutually exclusive\");\n  }\n  if (model) return isSmartRouterModelId(model) ? { smartRouter: true } : { model };\n  if (parsedClass?.data) return { modelClass: parsedClass.data };\n  if (defaults.model) {\n    return isSmartRouterModelId(defaults.model) ? { smartRouter: true } : { model: defaults.model };\n  }\n  if (defaults.modelClass) return { modelClass: defaults.modelClass };\n  if (protocol === \"openai-embeddings\") return { modelClass: ModelClass.Embedding };\n  return {};\n}\n\nfunction applySmartRouterObservationHeaders(\n  headers: Headers,\n  observation: SmartRouterObservation,\n): void {\n  headers.set(SMART_ROUTER_SELECTED_MODEL_HEADER, observation.selectedModel);\n  headers.set(SMART_ROUTER_ROUTE_MODEL_HEADER, observation.routeModel);\n  headers.set(SMART_ROUTER_HARNESS_HEADER, observation.harness);\n  headers.set(SMART_ROUTER_SOURCE_HEADER, observation.source);\n  const taskTier = stringParam(observation.params, \"task_tier\");\n  const servedTier = stringParam(observation.params, \"served_tier\");\n  const profilerStatus = stringParam(observation.params, \"profiler_status\");\n  if (taskTier) headers.set(SMART_ROUTER_TASK_TIER_HEADER, taskTier);\n  if (servedTier) headers.set(SMART_ROUTER_SERVED_TIER_HEADER, servedTier);\n  if (profilerStatus) headers.set(SMART_ROUTER_PROFILER_STATUS_HEADER, profilerStatus);\n}\n\nfunction stringParam(\n  params: Readonly<Record<string, unknown>> | undefined,\n  key: string,\n): string | undefined {\n  const value = params?.[key];\n  return typeof value === \"string\" && value ? value : undefined;\n}\n\nfunction onlySmartRouter(payload: ModelListResponse): ModelListResponse {\n  if (\"models\" in payload) {\n    return {\n      models: payload.models.filter((model) =>\n        model.slug.toLowerCase().endsWith(`/${SMART_ROUTER_MODEL_ID}`),\n      ),\n    };\n  }\n  return {\n    object: \"list\",\n    data: payload.data.filter((model) => model.id === SMART_ROUTER_MODEL_ID),\n  };\n}\n\nfunction logResponse(upstreamProtocol: string, model: string, response: Response): void {\n  const details = {\n    contentType: response.headers.get(\"content-type\"),\n    model,\n    status: response.status,\n    upstreamProtocol,\n  };\n  if (response.ok) logger.debug(\"upstream response\", details);\n  else logger.warn(\"upstream request failed\", details);\n}\n"]}

package/lib/src/models.d.ts

@@ -5,8 +5,8 @@
  */
 import type { CodexModelListResponse, ModelListResponse, ModelTarget, OpenAIModelListResponse } from "@dbx-tools/shared-model-gateway";
 /** Build the combined OpenAI and optional Codex model catalogue. */
-export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: true, preserveOrder?: boolean, preferSystemModels?: boolean): CodexModelListResponse;
-export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: false, preserveOrder?: boolean, preferSystemModels?: boolean): OpenAIModelListResponse;
-export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: boolean, preserveOrder?: boolean, preferSystemModels?: boolean): ModelListResponse;
+export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: true, preserveOrder?: boolean, preferSystemModels?: boolean, includeSmartRouter?: boolean): CodexModelListResponse;
+export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: false, preserveOrder?: boolean, preferSystemModels?: boolean, includeSmartRouter?: boolean): OpenAIModelListResponse;
+export declare function listModelsPayload(targets: readonly ModelTarget[], includeCodex: boolean, preserveOrder?: boolean, preferSystemModels?: boolean, includeSmartRouter?: boolean): ModelListResponse;
 /** Codex `/v1/models` slug: the `system.ai.*` service when preferred, else the endpoint id. */
 export declare function codexModelSlug(target: ModelTarget, preferSystemModels: boolean): string;