@dbx-tools/appkit-model-gateway 0.9.174 → 0.9.176

package/lib/tsconfig.tsbuildinfo

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

package/package.json

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

package/src/gateway.ts

@@ -4,8 +4,8 @@
  * @module
  */
 
-import { log } from "@dbx-tools/shared-core";
 import { modelTemperatureSupportFor } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
 import {
   ModelClass,
   ModelClassSchema,
@@ -17,6 +17,20 @@ import type {
   GatewayRoute,
   ModelCapabilityOverride,
   ModelListResponse,
+  SmartRouterObservation,
+  SmartRouterMode,
+} from "@dbx-tools/shared-model-gateway";
+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.ts";
@@ -27,6 +41,11 @@ import {
   type ModelRegistryOptions,
 } from "./registry.ts";
 import { isCodexOriginator, requestedFeatures, resolveRoute } from "./router.ts";
+import {
+  SmartModelRouter,
+  type SmartRouterService,
+  type SmartRouterStore,
+} from "./smart-router.ts";
 import { translateGatewayRequest } from "./translation.ts";
 import { fetchDatabricks, gatewayResponseHeaders } from "./transport.ts";
 
@@ -37,6 +56,14 @@ const DATABRICKS_TEMPERATURE_MAX = 2;
 /** 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;
@@ -57,6 +84,8 @@ export class ModelGatewayError extends Error {
 /** AppKit-scoped model gateway with dynamic model discovery and streaming inference. */
 export class ModelGateway {
   private readonly registry: ModelRegistry;
+  private readonly smartRouter?: SmartModelRouter;
+  private readonly smartRouterMode: SmartRouterMode;
   private readonly model?: string;
   private readonly modelClass?: ModelClassType;
   private readonly preferSystemModels: boolean;
@@ -70,9 +99,30 @@ 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. */
@@ -80,14 +130,33 @@ export class ModelGateway {
     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(
+    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. */
@@ -108,6 +177,7 @@ export class ModelGateway {
       protocol,
     );
     logger.debug("resolving request", {
+      smartRouter: selection.smartRouter === true,
       clientProtocol: protocol,
       model: selection.model,
       modelClass: selection.modelClass,
@@ -115,11 +185,31 @@ 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 as Exclude<ClientProtocol, "openai-embeddings">,
+            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,
@@ -130,7 +220,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,
@@ -144,7 +234,7 @@ export class ModelGateway {
 
     const temperatureBody = adaptInferenceTemperature(
       target.endpoint ?? target.id,
-      sanitizedBody,
+      smartRouter?.body ?? sanitizedBody,
     );
     const adapted = adaptInferenceReasoning(target.id, temperatureBody);
     let response = await this.forward(route, adapted.body, headers, signal);
@@ -162,10 +252,14 @@ 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,
@@ -234,7 +328,11 @@ export function gatewayModelSelection(
   headers: Headers,
   defaults: { readonly model?: string; readonly modelClass?: ModelClassType } = {},
   protocol?: ClientProtocol,
-): { readonly model?: string; readonly modelClass?: ModelClassType } {
+): {
+  readonly smartRouter?: boolean;
+  readonly model?: string;
+  readonly modelClass?: ModelClassType;
+} {
   const model = typeof body.model === "string" && body.model.trim() ? body.model.trim() : undefined;
   const header = headers.get("x-dbx-tools-model-class")?.trim();
   const parsedClass = header ? ModelClassSchema.safeParse(header) : undefined;
@@ -244,14 +342,54 @@ export function gatewayModelSelection(
   if (model && parsedClass?.data) {
     throw new ModelGatewayError(400, "Model and model class are mutually exclusive");
   }
-  if (model) return { model };
+  if (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: Headers,
+  observation: SmartRouterObservation,
+): void {
+  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: Readonly<Record<string, unknown>> | undefined,
+  key: string,
+): string | undefined {
+  const value = params?.[key];
+  return typeof value === "string" && value ? value : undefined;
+}
+
+function onlySmartRouter(payload: ModelListResponse): ModelListResponse {
+  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: string, model: string, response: Response): void {
   const details = {
     contentType: response.headers.get("content-type"),

package/src/models.ts

@@ -4,10 +4,22 @@
  * @module
  */
 
-import { isChatClass, modelFamily, modelFamilyRank } from "@dbx-tools/model";
+import {
+  CHAT_CLASS_ORDER,
+  compareVersionTuples,
+  isChatClass,
+  isOpenWeightsGpt,
+  ModelFamily,
+  modelFamily,
+  modelFamilyRank,
+  versionTuple,
+} from "@dbx-tools/model";
+import { ModelClass, ReasoningEffort } from "@dbx-tools/shared-model";
+import { SMART_ROUTER_MODEL_ID } from "@dbx-tools/shared-model-gateway";
 import type {
   CodexModel,
   CodexModelListResponse,
+  ModelCapabilities,
   ModelListResponse,
   ModelTarget,
   OpenAIModel,
@@ -16,6 +28,12 @@ import type {
 
 const CODEX_BASE_INSTRUCTIONS =
   "You are a coding agent. Follow the user's instructions and use the available tools to work in the current repository.";
+const CODEX_SMART_ROUTER_PRIORITY = 9_000;
+const CODEX_MODEL_PRIORITY_BASE = 10_000;
+const CODEX_FAMILY_ORDER = [
+  ModelFamily.Gpt,
+  ...Object.values(ModelFamily).filter((family) => family !== ModelFamily.Gpt),
+] as const;
 
 const REASONING_DESCRIPTIONS: Readonly<Record<string, string>> = {
   none: "Disable explicit reasoning",
@@ -33,36 +51,56 @@ export function listModelsPayload(
   includeCodex: true,
   preserveOrder?: boolean,
   preferSystemModels?: boolean,
+  includeSmartRouter?: boolean,
 ): CodexModelListResponse;
 export function listModelsPayload(
   targets: readonly ModelTarget[],
   includeCodex: false,
   preserveOrder?: boolean,
   preferSystemModels?: boolean,
+  includeSmartRouter?: boolean,
 ): OpenAIModelListResponse;
 export function listModelsPayload(
   targets: readonly ModelTarget[],
   includeCodex: boolean,
   preserveOrder?: boolean,
   preferSystemModels?: boolean,
+  includeSmartRouter?: boolean,
 ): ModelListResponse;
 export function listModelsPayload(
   targets: readonly ModelTarget[],
   includeCodex: boolean,
   preserveOrder = false,
   preferSystemModels = false,
+  includeSmartRouter = false,
 ): ModelListResponse {
   const available = targets
     .filter((target) => target.endpoint?.status?.deprecated !== true)
     .filter((target) => !includeCodex || hasChatClass(target));
   if (!preserveOrder) {
-    available.sort((left, right) =>
-      compareCatalogueTargets(left, right, (target) => target.displayName),
+    available.sort(
+      includeCodex
+        ? compareCodexCatalogueTargets
+        : (left, right) =>
+            compareCatalogueTargets(left, right, (target) => target.displayName),
     );
   }
+  const smartRouterCandidates = available.filter((target) => target.capabilities.chat);
+  if (includeSmartRouter && smartRouterCandidates.length > 0) {
+    available.unshift(smartRouterModelTarget(smartRouterCandidates));
+  }
   if (includeCodex) {
+    let modelIndex = 0;
     return {
-      models: available.map((target, index) => codexModel(target, index + 1, preferSystemModels)),
+      models: available.map((target) =>
+        codexModel(
+          target,
+          target.id === SMART_ROUTER_MODEL_ID
+            ? CODEX_SMART_ROUTER_PRIORITY
+            : CODEX_MODEL_PRIORITY_BASE + modelIndex++,
+          preferSystemModels,
+        ),
+      ),
     };
   }
   return {
@@ -81,6 +119,7 @@ function openAiModel(target: ModelTarget): OpenAIModel {
     task: target.endpoint?.task,
     status: target.endpoint?.status ?? { deprecated: false },
     capabilities: {
+      smart_router: target.id === SMART_ROUTER_MODEL_ID,
       tools: target.capabilities.tools,
       reasoning: target.reasoningEfforts,
       responses: target.capabilities.responses,
@@ -90,10 +129,52 @@ function openAiModel(target: ModelTarget): OpenAIModel {
       ai_gateway_codex: target.capabilities.aiGatewayCodex,
       streaming: target.capabilities.streaming,
       web_search: target.capabilities.webSearch,
+      image_input: target.capabilities.imageInput,
+      apply_patch: target.capabilities.applyPatch,
     },
   };
 }
 
+function smartRouterModelTarget(candidates: readonly ModelTarget[]): ModelTarget {
+  const has = (capability: keyof ModelCapabilities) =>
+    candidates.some((target) => target.capabilities[capability]);
+  const reasoningEfforts = Object.values(ReasoningEffort).filter((effort) =>
+    candidates.some((target) => target.reasoningEfforts.includes(effort)),
+  );
+  return {
+    id: SMART_ROUTER_MODEL_ID,
+    aliases: [SMART_ROUTER_MODEL_ID],
+    displayName: "Smart Router",
+    endpoint: {
+      name: SMART_ROUTER_MODEL_ID,
+      displayName: "Smart Router",
+      description:
+        "Uses Databricks task_v3 Smart Router to select a compatible system model for each turn.",
+      task: "llm/v1/chat",
+      class: ModelClass.ChatBalanced,
+      status: { deprecated: false },
+    },
+    capabilities: {
+      responses: true,
+      openResponses: true,
+      chat: true,
+      anthropic: true,
+      embeddings: false,
+      aiGatewayCodex: true,
+      tools: has("tools"),
+      reasoning: reasoningEfforts.length > 0,
+      streaming: true,
+      parallelTools: has("parallelTools"),
+      customTools: has("customTools"),
+      structuredOutput: has("structuredOutput"),
+      webSearch: has("webSearch"),
+      imageInput: has("imageInput"),
+      applyPatch: has("applyPatch"),
+    },
+    reasoningEfforts,
+  };
+}
+
 /** Codex `/v1/models` slug: the `system.ai.*` service when preferred, else the endpoint id. */
 export function codexModelSlug(target: ModelTarget, preferSystemModels: boolean): string {
   const model =
@@ -111,7 +192,7 @@ function codexModel(
   const efforts = target.reasoningEfforts;
   return {
     slug: codexModelSlug(target, preferSystemModels),
-    display_name: target.displayName,
+    display_name: codexDisplayName(target),
     description: target.endpoint?.description ?? "Databricks model service",
     base_instructions: CODEX_BASE_INSTRUCTIONS,
     status: target.endpoint?.status ?? { deprecated: false },
@@ -141,6 +222,48 @@ function codexModel(
   };
 }
 
+function codexDisplayName(target: ModelTarget): string {
+  if (catalogueFamily(target) !== ModelFamily.Gpt) return target.displayName;
+  const displayName = target.displayName.replace(/^gpt(?=[\s._-])/i, "GPT");
+  return `Databricks ${displayName}`;
+}
+
+function compareCodexCatalogueTargets(left: ModelTarget, right: ModelTarget): number {
+  const familyOrder = codexFamilyRank(left) - codexFamilyRank(right);
+  if (familyOrder !== 0) return familyOrder;
+  const modelKindOrder = codexModelKindRank(left) - codexModelKindRank(right);
+  if (modelKindOrder !== 0) return modelKindOrder;
+  const versionOrder = compareVersionTuples(codexVersion(right), codexVersion(left));
+  if (versionOrder !== 0) return versionOrder;
+  const classOrder = codexClassRank(left) - codexClassRank(right);
+  if (classOrder !== 0) return classOrder;
+  return compareCatalogueLabel(left.displayName, right.displayName);
+}
+
+function codexModelKindRank(target: ModelTarget): number {
+  return [target.displayName, target.id, target.modelServiceName].some(
+    (identity) => identity && isOpenWeightsGpt(identity),
+  )
+    ? 1
+    : 0;
+}
+
+function codexFamilyRank(target: ModelTarget): number {
+  const family = catalogueFamily(target);
+  const index = family ? CODEX_FAMILY_ORDER.indexOf(family as ModelFamily) : -1;
+  return index >= 0 ? index : CODEX_FAMILY_ORDER.length;
+}
+
+function codexVersion(target: ModelTarget): readonly number[] {
+  return versionTuple(target.displayName);
+}
+
+function codexClassRank(target: ModelTarget): number {
+  const modelClass = target.endpoint?.class;
+  const index = modelClass ? CHAT_CLASS_ORDER.indexOf(modelClass) : -1;
+  return index >= 0 ? index : CHAT_CLASS_ORDER.length;
+}
+
 /**
  * Order listed models in three groups: major-provider chat families, the
  * remaining chat models, then embeddings. Families keep a fixed provider

package/src/plugin.ts

@@ -29,15 +29,7 @@ export class ModelGatewayPlugin extends Plugin<ModelGatewayPluginConfig> {
 
   constructor(config: ModelGatewayPluginConfig = {}) {
     super(config);
-    this.gateway = new ModelGateway({
-      ...(config.cacheTtlMs !== undefined ? { cacheTtlMs: config.cacheTtlMs } : {}),
-      ...(config.overrides ? { overrides: config.overrides } : {}),
-      ...(config.model ? { model: config.model } : {}),
-      ...(config.modelClass ? { modelClass: config.modelClass } : {}),
-      ...(config.preferSystemModels !== undefined
-        ? { preferSystemModels: config.preferSystemModels }
-        : {}),
-    });
+    this.gateway = new ModelGateway(config);
   }
 
   override injectRoutes(router: IAppRouter): void {

package/src/registry.ts

@@ -202,6 +202,8 @@ export class DatabricksModelRegistry implements ModelRegistry {
       customTools: published.applyPatch || endpoint.name.includes("codex"),
       structuredOutput: true,
       webSearch: published.webSearch,
+      imageInput: published.imageInput,
+      applyPatch: published.applyPatch,
     };
     const aliases = new Set(
       [

package/src/router.ts

@@ -74,18 +74,31 @@ export function resolveRoute(input: ResolveRouteInput): GatewayRoute {
 /** Detect route-affecting features from an OpenAI or Anthropic request body. */
 export function requestedFeatures(body: Readonly<Record<string, unknown>>): RequestedFeatures {
   const tools = Array.isArray(body.tools) ? body.tools : [];
-  const toolTypes = tools
-    .filter((tool): tool is Record<string, unknown> => isRecord(tool))
-    .map((tool) => tool.type);
+  const toolRecords = tools.filter((tool): tool is Record<string, unknown> => isRecord(tool));
+  const toolTypes = toolRecords.map((tool) => tool.type);
+  const toolNames = toolRecords
+    .map((tool) =>
+      typeof tool.name === "string"
+        ? tool.name
+        : isRecord(tool.function) && typeof tool.function.name === "string"
+          ? tool.function.name
+          : undefined,
+    )
+    .filter((name): name is string => name !== undefined);
   const text = isRecord(body.text) ? body.text : {};
   const format = isRecord(text.format) ? text.format.type : text.format;
+  const outputConfig = isRecord(body.output_config) ? body.output_config : {};
   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,
+    reasoning:
+      isRecord(body.reasoning) ||
+      body.reasoning_effort !== undefined ||
+      isRecord(body.thinking) ||
+      outputConfig.effort !== undefined,
     storage: body.store === true,
     structuredOutput: format !== undefined && format !== "text",
     tools: tools.length > 0,
@@ -93,6 +106,8 @@ export function requestedFeatures(body: Readonly<Record<string, unknown>>): Requ
       (type) => type !== "function" && type !== "web_search" && type !== "web_search_preview",
     ),
     webSearch: toolTypes.some((type) => type === "web_search" || type === "web_search_preview"),
+    imageInput: containsImageInput(body.input) || containsImageInput(body.messages),
+    applyPatch: toolNames.some((name) => /^apply[_-]?patch$/i.test(name)),
   };
 }
 
@@ -170,3 +185,13 @@ function canUseAiGatewayCodex(target: ModelTarget, features: RequestedFeatures):
     supportsDirectResponses(target, features)
   );
 }
+
+function containsImageInput(value: unknown): boolean {
+  if (Array.isArray(value)) return value.some(containsImageInput);
+  if (!isRecord(value)) return false;
+  const type = typeof value.type === "string" ? value.type.toLowerCase() : "";
+  if (type.includes("image")) return true;
+  return Object.entries(value).some(
+    ([key, nested]) => key !== "arguments" && key !== "input" && containsImageInput(nested),
+  );
+}

package/src/routes.ts

@@ -12,6 +12,7 @@ import type express from "express";
 
 import { ModelGateway, ModelGatewayError } from "./gateway.ts";
 import { UnsupportedGatewayFeatureError } from "./router.ts";
+import { SmartRouterError } from "./smart-router.ts";
 
 const logger = log.logger("appkit/model-gateway/http");
 
@@ -128,7 +129,9 @@ export async function sendInference(
 
 function sendError(protocol: ClientProtocol, response: express.Response, error: unknown): void {
   const status =
-    error instanceof ModelGatewayError || error instanceof UnsupportedGatewayFeatureError
+    error instanceof ModelGatewayError ||
+    error instanceof SmartRouterError ||
+    error instanceof UnsupportedGatewayFeatureError
       ? error.status
       : 500;
   const message = error instanceof Error ? error.message : "Model gateway request failed";