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

package/lib/src/routes.js

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

package/lib/src/smart-router.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Databricks Smart Router transport, context construction, probing, and turn pinning.
+ *
+ * @module
+ */
+import { type WorkspaceClient } from "@databricks/appkit";
+import { type ClientProtocol, type ModelTarget, type RequestedFeatures, type SmartRouterHarness, type SmartRouterObservation, type SmartRouterRequest } from "@dbx-tools/shared-model-gateway";
+import { z } from "zod";
+/** Runtime settings for Smart Router. */
+export interface SmartRouterSettings {
+    readonly contextTokenBudget: number;
+    readonly probeRefreshIntervalMs: number;
+    readonly probeTtlMs: number;
+    readonly routeTtlSeconds: number;
+    readonly routerName: string;
+    readonly timeoutMs: number;
+}
+/** One route option associated with the caller-owned value it represents. */
+export interface SmartRouterCandidate<T> {
+    readonly harness: SmartRouterHarness;
+    readonly model: string;
+    readonly value: T;
+}
+/** Result returned after mapping a Databricks route back to a caller-owned value. */
+export interface SmartRouterSelection<T> {
+    readonly harness: SmartRouterHarness;
+    readonly latencyMs: number;
+    readonly params?: Readonly<Record<string, unknown>>;
+    readonly rationale?: string;
+    readonly routeModel: string;
+    readonly routerName: string;
+    readonly value: T;
+}
+/** Portable persistence surface for a pinned Smart Router turn. */
+export interface SmartRouterStore {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: SmartRouterObservation, ttlSeconds: number): Promise<void>;
+}
+export declare const SmartRouterProbeRecordSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+export type SmartRouterProbeRecord = z.infer<typeof SmartRouterProbeRecordSchema>;
+/** Optional persistent cache for capability probes. */
+export interface SmartRouterProbeStore {
+    get(key: string, client: WorkspaceClient): Promise<unknown>;
+    set(key: string, value: SmartRouterProbeRecord, ttlSeconds: number, client: WorkspaceClient): Promise<void>;
+}
+/** Result applied to one concrete gateway request. */
+export interface SmartRouterResult {
+    readonly body: Readonly<Record<string, unknown>>;
+    readonly observation: SmartRouterObservation;
+    readonly target: ModelTarget;
+}
+/** Bounded task context extracted from an arbitrary supported input shape. */
+export interface SmartRouterContext {
+    readonly continuation: boolean;
+    readonly logicalTurn: string;
+    readonly task: string;
+}
+/** Error carrying an HTTP status for Smart Router validation or availability failures. */
+export declare class SmartRouterError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** AppKit cache adapter; configured Lakebase/Postgres storage remains AppKit-owned. */
+export declare class AppKitSmartRouterStore implements SmartRouterStore {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: SmartRouterObservation, ttlSeconds: number): Promise<void>;
+}
+/** AppKit cache adapter for process- and persistence-backed capability probes. */
+export declare class AppKitSmartRouterProbeStore implements SmartRouterProbeStore {
+    get(key: string, client: WorkspaceClient): Promise<unknown>;
+    set(key: string, value: SmartRouterProbeRecord, ttlSeconds: number, client: WorkspaceClient): Promise<void>;
+}
+/** Optional identity and cancellation inputs for one Smart Router call. */
+export interface SmartRouterSelectOptions {
+    readonly client?: WorkspaceClient;
+    readonly signal?: AbortSignal;
+}
+type SmartRouterInvoker = (client: WorkspaceClient, request: SmartRouterRequest, signal: AbortSignal, timeoutMs: number) => Promise<unknown>;
+/**
+ * Dedicated Smart Router service for strings, request objects, message arrays,
+ * and generic JSON-like inputs.
+ */
+export declare class SmartRouterService {
+    private readonly settings;
+    private readonly invoke;
+    private readonly probeStore;
+    readonly context: SmartRouterContextBuilder;
+    private readonly probes;
+    private readonly probeEntries;
+    private probeRefreshTimer?;
+    constructor(settings: SmartRouterSettings, invoke?: SmartRouterInvoker, probeStore?: SmartRouterProbeStore);
+    /** Select one offered route for arbitrary input content. */
+    select<T>(input: unknown, candidates: readonly SmartRouterCandidate<T>[], options?: SmartRouterSelectOptions): Promise<SmartRouterSelection<T>>;
+    /** Return a memoized live capability probe for the active identity and candidate menu. */
+    isEnabled<T>(candidates: readonly SmartRouterCandidate<T>[], client?: WorkspaceClient): Promise<boolean>;
+    /** Stop this service's unref'd background probe refresh timer. */
+    dispose(): void;
+    private createProbeEntry;
+    private initializeProbe;
+    private refreshProbe;
+    private executeProbe;
+    private setProbeValue;
+    private setProbeUnavailable;
+    private updateProbeEntry;
+    private readStoredProbe;
+    private writeStoredProbe;
+    private probeCache;
+    private replaceProbe;
+    private probeTtl;
+    private ensureProbeRefreshTimer;
+    private refreshProbes;
+    private selectTask;
+}
+/** Build a Smart Router candidate menu from values carrying modelServiceName. */
+export declare function smartRouterCandidates<T extends {
+    readonly modelServiceName?: string;
+}>(values: readonly T[], harness: SmartRouterHarness): SmartRouterCandidate<T>[];
+/**
+ * Context extractor shared by the gateway, Mastra, and the file/stdin CLI.
+ * It favors conversation/task fields and ignores credentials, tool schemas,
+ * and tool arguments.
+ */
+export declare class SmartRouterContextBuilder {
+    private readonly tokenBudget;
+    constructor(tokenBudget?: number);
+    /** Return only the bounded task prompt required by routes:select. */
+    build(input: unknown): string;
+    /** Return bounded task text plus logical-turn metadata used for pinning. */
+    analyze(input: unknown): SmartRouterContext;
+}
+/** Smart Router orchestration shared by Responses, Chat Completions, and Messages. */
+export declare class SmartModelRouter {
+    private readonly settings;
+    private readonly store;
+    private readonly client?;
+    readonly service: SmartRouterService;
+    constructor(settings: SmartRouterSettings, service?: SmartRouterService, store?: SmartRouterStore, client?: WorkspaceClient | undefined);
+    /** Probe whether Smart Router is usable for the current model catalogue. */
+    isEnabled(targets: readonly ModelTarget[]): Promise<boolean>;
+    /** Resolve one virtual smart-router request to a concrete compatible target. */
+    resolve(input: {
+        readonly body: Readonly<Record<string, unknown>>;
+        readonly features: RequestedFeatures;
+        readonly headers: Headers;
+        readonly preferSystemModels: boolean;
+        readonly protocol: Exclude<ClientProtocol, "openai-embeddings">;
+        readonly signal: AbortSignal;
+        readonly targets: readonly ModelTarget[];
+    }): Promise<SmartRouterResult>;
+    private readCached;
+    private writeCached;
+}
+/** Stable logical-turn key shared by initial requests and tool continuations. */
+export declare function smartRouterTurnKey(logicalTurn: string, candidates: readonly SmartRouterCandidate<unknown>[], context: Readonly<Record<string, unknown>>): string;
+/** Defaults shared by gateway, Mastra, and CLI Smart Router callers. */
+export declare const SMART_ROUTER_DEFAULT_SETTINGS: SmartRouterSettings;
+export {};