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

package/lib/src/smart-router.js

@@ -0,0 +1,700 @@
+/**
+ * Databricks Smart Router transport, context construction, probing, and turn pinning.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { CacheManager, getExecutionContext } from "@databricks/appkit";
+import { closeCache, createCache, getOrSet } from "@dbx-tools/cache";
+import { refreshWorkspaceClientAuthentication } from "@dbx-tools/databricks";
+import { isRecord, log, toError } from "@dbx-tools/shared-core";
+import { ReasoningEffortSchema } from "@dbx-tools/shared-model";
+import { SMART_ROUTER_NAME, SmartRouterObservationSchema, SmartRouterRequestSchema, SmartRouterResponseSchema, } from "@dbx-tools/shared-model-gateway";
+import { Tiktoken } from "js-tiktoken/lite";
+import o200kBase from "js-tiktoken/ranks/o200k_base";
+import { z } from "zod";
+import { resolveRoute } from "./router.js";
+const logger = log.logger("appkit/model-gateway/smart-router");
+const ROUTE_CACHE_NAMESPACE = "model-gateway-smart-router";
+const ROUTE_POLICY_VERSION = 1;
+const PROBE_CACHE_NAMESPACE = "model-gateway-smart-router-probe";
+const PROBE_CACHE_VERSION = 1;
+const PROBE_TASK = "Check whether Smart Router can select an available model.";
+const NEGATIVE_PROBE_TTL_MS = 30_000;
+const CONTEXT_ENCODING = new Tiktoken(o200kBase);
+/** Defaults shared by gateway, Mastra, and CLI Smart Router callers. */
+export const SMART_ROUTER_DEFAULT_SETTINGS = Object.freeze({
+    contextTokenBudget: 4_096,
+    probeRefreshIntervalMs: 3_600_000,
+    probeTtlMs: 300_000,
+    routeTtlSeconds: 21_600,
+    routerName: SMART_ROUTER_NAME,
+    timeoutMs: 10_000,
+});
+export const SmartRouterProbeRecordSchema = z
+    .object({
+    enabled: z.boolean().describe("Whether the live Smart Router probe succeeded."),
+    expiresAt: z.number().int().describe("Epoch milliseconds when this probe becomes stale."),
+})
+    .describe("Persisted Smart Router capability probe result.");
+/** Error carrying an HTTP status for Smart Router validation or availability failures. */
+export class SmartRouterError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "SmartRouterError";
+    }
+}
+/** AppKit cache adapter; configured Lakebase/Postgres storage remains AppKit-owned. */
+export class AppKitSmartRouterStore {
+    async get(key) {
+        const cache = await CacheManager.getInstance();
+        return cache.get(cache.generateKey([ROUTE_CACHE_NAMESPACE, ROUTE_POLICY_VERSION], key));
+    }
+    async set(key, value, ttlSeconds) {
+        const cache = await CacheManager.getInstance();
+        await cache.set(cache.generateKey([ROUTE_CACHE_NAMESPACE, ROUTE_POLICY_VERSION], key), value, {
+            ttl: ttlSeconds,
+        });
+    }
+}
+/** AppKit cache adapter for process- and persistence-backed capability probes. */
+export class AppKitSmartRouterProbeStore {
+    async get(key, client) {
+        const cache = appKitCacheManager();
+        if (!cache)
+            return undefined;
+        const identity = await smartRouterProbeIdentity(client);
+        return cache.get(cache.generateKey([PROBE_CACHE_NAMESPACE, PROBE_CACHE_VERSION], `${identity}:${key}`));
+    }
+    async set(key, value, ttlSeconds, client) {
+        const cache = appKitCacheManager();
+        if (!cache)
+            return;
+        const identity = await smartRouterProbeIdentity(client);
+        await cache.set(cache.generateKey([PROBE_CACHE_NAMESPACE, PROBE_CACHE_VERSION], `${identity}:${key}`), value, { ttl: ttlSeconds });
+    }
+}
+/**
+ * Dedicated Smart Router service for strings, request objects, message arrays,
+ * and generic JSON-like inputs.
+ */
+export class SmartRouterService {
+    invoke;
+    probeStore;
+    context;
+    settings;
+    probes = new WeakMap();
+    probeKeys = new WeakMap();
+    probeCaches = new Set();
+    constructor(settings = {}, invoke = invokeSmartRouter, probeStore = new AppKitSmartRouterProbeStore()) {
+        this.invoke = invoke;
+        this.probeStore = probeStore;
+        this.settings = { ...SMART_ROUTER_DEFAULT_SETTINGS, ...settings };
+        this.context = new SmartRouterContextBuilder(this.settings.contextTokenBudget);
+    }
+    /** Select one offered route for arbitrary input content. */
+    async select(input, candidates, options = {}) {
+        const task = this.context.build(input);
+        if (!task)
+            throw new SmartRouterError(400, "Smart Router input contains no routable text");
+        const client = options.client ?? getExecutionContext().client;
+        try {
+            const selection = await this.selectTask(task, candidates, { ...options, client });
+            this.setProbeValue(candidates, client, true);
+            return selection;
+        }
+        catch (error) {
+            this.setProbeUnavailable(candidates, client);
+            throw error;
+        }
+    }
+    /** Return a memoized live capability probe for the active identity and candidate menu. */
+    async isEnabled(candidates, client = getExecutionContext().client) {
+        const offered = uniqueCandidates(candidates);
+        if (offered.length === 0)
+            return false;
+        const cache = this.probeCache(client);
+        const key = probeKey(offered, this.settings.routerName);
+        this.rememberProbeKey(client, key);
+        const probe = await getOrSet(cache, key, () => this.loadProbe(key, offered, client), {
+            ttl: this.probeCacheTtlMs(),
+            refreshAfterWrite: (value) => this.probeRefreshAfterWrite(value.enabled),
+        });
+        return probe?.enabled ?? false;
+    }
+    /** Stop process-local probe caches after their active refreshes settle. */
+    dispose() {
+        for (const cache of this.probeCaches)
+            void closeCache(cache);
+        this.probeCaches.clear();
+    }
+    async loadProbe(key, candidates, client) {
+        const stored = await this.readStoredProbe(key, client);
+        if (stored && stored.expiresAt > Date.now())
+            return stored;
+        return this.executeProbe(key, candidates, client);
+    }
+    async executeProbe(key, candidates, client) {
+        const enabled = await this.selectTask(PROBE_TASK, candidates, { client })
+            .then(() => true)
+            .catch((error) => {
+            logger.debug("Smart Router capability probe unavailable", { error: toError(error) });
+            return false;
+        });
+        const probe = this.probeRecord(enabled);
+        void this.writeStoredProbe(key, probe, client);
+        return probe;
+    }
+    setProbeValue(candidates, client, enabled) {
+        const offered = uniqueCandidates(candidates);
+        if (offered.length === 0)
+            return;
+        const cache = this.probeCache(client);
+        const key = probeKey(offered, this.settings.routerName);
+        this.rememberProbeKey(client, key);
+        const probe = this.probeRecord(enabled);
+        void this.writeProcessProbe(cache, key, probe);
+        void this.writeStoredProbe(key, probe, client);
+    }
+    setProbeUnavailable(candidates, client) {
+        const cache = this.probeCache(client);
+        const offered = uniqueCandidates(candidates);
+        const requestedKey = probeKey(offered, this.settings.routerName);
+        this.rememberProbeKey(client, requestedKey);
+        const keys = this.probeKeys.get(client.config) ?? new Set([requestedKey]);
+        for (const key of keys) {
+            const probe = this.probeRecord(false);
+            void this.writeProcessProbe(cache, key, probe);
+            void this.writeStoredProbe(key, probe, client);
+        }
+    }
+    probeRecord(enabled) {
+        return { enabled, expiresAt: Date.now() + this.probeTtl(enabled) };
+    }
+    async readStoredProbe(key, client) {
+        try {
+            const parsed = SmartRouterProbeRecordSchema.safeParse(await this.probeStore.get(key, client));
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch (error) {
+            logger.debug("Smart Router probe cache read failed", { error: toError(error) });
+            return undefined;
+        }
+    }
+    async writeProcessProbe(cache, key, probe) {
+        try {
+            await cache.set(key, probe, { ttl: this.probeCacheTtlMs() });
+        }
+        catch (error) {
+            logger.debug("Smart Router process probe cache write failed", { error: toError(error) });
+        }
+    }
+    async writeStoredProbe(key, probe, client) {
+        try {
+            await this.probeStore.set(key, probe, Math.max(1, Math.ceil(this.probeCacheTtlMs() / 1_000)), client);
+        }
+        catch (error) {
+            logger.debug("Smart Router probe cache write failed", { error: toError(error) });
+        }
+    }
+    probeCache(client) {
+        const owner = client.config;
+        let cache = this.probes.get(owner);
+        if (!cache) {
+            cache = createCache({ maxEntries: 32, useClone: false });
+            this.probes.set(owner, cache);
+            this.probeCaches.add(cache);
+        }
+        return cache;
+    }
+    rememberProbeKey(client, key) {
+        const owner = client.config;
+        let keys = this.probeKeys.get(owner);
+        if (!keys) {
+            keys = new Set();
+            this.probeKeys.set(owner, keys);
+        }
+        keys.add(key);
+    }
+    probeCacheTtlMs() {
+        return Math.max(this.settings.probeRefreshIntervalMs, this.settings.probeTtlMs) * 2;
+    }
+    probeTtl(enabled) {
+        return enabled
+            ? this.settings.probeTtlMs
+            : Math.min(this.settings.probeTtlMs, NEGATIVE_PROBE_TTL_MS);
+    }
+    probeRefreshAfterWrite(enabled) {
+        return Math.min(this.settings.probeRefreshIntervalMs, this.probeTtl(enabled));
+    }
+    async selectTask(task, candidates, options) {
+        const offered = uniqueCandidates(candidates);
+        if (offered.length === 0) {
+            throw new SmartRouterError(400, "No compatible system models are available to Smart Router");
+        }
+        const request = SmartRouterRequestSchema.parse({
+            route_options: offered.map(({ model, harness }) => ({ model, harness })),
+            task: { prompt: task },
+            route_selector: { router_name: this.settings.routerName },
+        });
+        const client = options.client ?? getExecutionContext().client;
+        const signal = options.signal ?? new AbortController().signal;
+        const startedAt = Date.now();
+        const response = SmartRouterResponseSchema.parse(await this.invoke(client, request, signal, this.settings.timeoutMs));
+        const selection = response.route_selection[0];
+        const selected = offered.find((candidate) => normalizeRouteModel(candidate.model) ===
+            normalizeRouteModel(selection.route_option.model) &&
+            (!selection.route_option.harness || candidate.harness === selection.route_option.harness));
+        if (!selected) {
+            throw new SmartRouterError(502, `Smart Router selected an unsupported model: ${selection.route_option.model}`);
+        }
+        return {
+            value: selected.value,
+            routeModel: selection.route_option.model,
+            harness: selected.harness,
+            routerName: this.settings.routerName,
+            latencyMs: Date.now() - startedAt,
+            ...(response.rationale ? { rationale: response.rationale } : {}),
+            ...(selection.params ? { params: selection.params } : {}),
+        };
+    }
+}
+/** Build a Smart Router candidate menu from values carrying modelServiceName. */
+export function smartRouterCandidates(values, harness) {
+    return values.flatMap((value) => {
+        const model = value.modelServiceName?.trim();
+        if (!model || !model.toLowerCase().startsWith("system.ai."))
+            return [];
+        return [{ model, harness, value }];
+    });
+}
+/**
+ * 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 class SmartRouterContextBuilder {
+    tokenBudget;
+    constructor(tokenBudget = 4_096) {
+        this.tokenBudget = tokenBudget;
+    }
+    /** Return only the bounded task prompt required by routes:select. */
+    build(input) {
+        return this.analyze(input).task;
+    }
+    /** Return bounded task text plus logical-turn metadata used for pinning. */
+    analyze(input) {
+        const normalized = parseJsonString(input);
+        const events = conversationEvents(normalized);
+        if (events.length > 0)
+            return contextFromEvents(events, this.tokenBudget);
+        const values = collectTaskStrings(normalized);
+        const task = truncateText(values.join("\n"), this.tokenBudget, "start");
+        return { task, logicalTurn: task, continuation: false };
+    }
+}
+/** Smart Router orchestration shared by Responses, Chat Completions, and Messages. */
+export class SmartModelRouter {
+    store;
+    client;
+    service;
+    settings;
+    constructor(settings = {}, service = undefined, store = new AppKitSmartRouterStore(), client) {
+        this.store = store;
+        this.client = client;
+        this.settings = { ...SMART_ROUTER_DEFAULT_SETTINGS, ...settings };
+        this.service = service ?? new SmartRouterService(this.settings);
+    }
+    /** Probe whether Smart Router is usable for the current model catalogue. */
+    isEnabled(targets) {
+        const candidates = smartRouterCandidates(targets.filter((target) => target.capabilities.chat && target.capabilities.aiGatewayCodex), "codex");
+        return this.client
+            ? this.service.isEnabled(candidates, this.client)
+            : this.service.isEnabled(candidates);
+    }
+    /** Resolve one virtual smart-router request to a concrete compatible target. */
+    async resolve(input) {
+        const harness = input.protocol === "anthropic-messages" ? "claude" : "codex";
+        const explicitReasoningEffort = requestedReasoningEffort(input.body);
+        const eligibleTargets = input.targets.filter((target) => isEligibleTarget(target, { ...input, originator: input.headers.get("originator") ?? undefined }, explicitReasoningEffort, harness));
+        const candidates = smartRouterCandidates(eligibleTargets, harness);
+        if (candidates.length === 0) {
+            throw new SmartRouterError(400, "No compatible system models are available to Databricks Smart Router");
+        }
+        const context = this.service.context.analyze(input.body);
+        if (!context.task) {
+            throw new SmartRouterError(400, "Smart Router request contains no task text");
+        }
+        const key = smartRouterTurnKey(context.logicalTurn, candidates, {
+            harness,
+            protocol: input.protocol,
+            features: input.features,
+            ...(explicitReasoningEffort ? { explicitReasoningEffort } : {}),
+        });
+        const cached = context.continuation ? await this.readCached(key, eligibleTargets) : undefined;
+        if (cached) {
+            return {
+                target: eligibleTargets.find((target) => target.id === cached.selectedModel),
+                body: input.body,
+                observation: { ...cached, source: "cache" },
+            };
+        }
+        const selected = await this.service.select(context.task, candidates, {
+            signal: input.signal,
+            ...(this.client ? { client: this.client } : {}),
+        });
+        const target = selected.value;
+        const observation = SmartRouterObservationSchema.parse({
+            selectedModel: target.id,
+            routeModel: selected.routeModel,
+            harness: selected.harness,
+            routerName: selected.routerName,
+            source: "router",
+            latencyMs: selected.latencyMs,
+            ...(selected.rationale ? { rationale: selected.rationale } : {}),
+            ...(selected.params ? { params: selected.params } : {}),
+        });
+        await this.writeCached(key, observation);
+        logger.debug("selected Smart Router model", {
+            candidateCount: candidates.length,
+            harness,
+            latencyMs: observation.latencyMs,
+            model: observation.selectedModel,
+            routeModel: observation.routeModel,
+            routerName: observation.routerName,
+        });
+        return { target, body: input.body, observation };
+    }
+    async readCached(key, targets) {
+        try {
+            const parsed = SmartRouterObservationSchema.safeParse(await this.store.get(key));
+            if (!parsed.success)
+                return undefined;
+            return targets.some((target) => target.id === parsed.data.selectedModel)
+                ? parsed.data
+                : undefined;
+        }
+        catch (error) {
+            logger.debug("Smart Router cache read failed", { error: toError(error) });
+            return undefined;
+        }
+    }
+    async writeCached(key, observation) {
+        try {
+            await this.store.set(key, observation, this.settings.routeTtlSeconds);
+        }
+        catch (error) {
+            logger.debug("Smart Router cache write failed", { error: toError(error) });
+        }
+    }
+}
+/** Stable logical-turn key shared by initial requests and tool continuations. */
+export function smartRouterTurnKey(logicalTurn, candidates, context) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        logicalTurn,
+        candidates: candidates.map(({ model, harness }) => ({ model, harness })),
+        context,
+    }))
+        .digest("hex");
+}
+function isEligibleTarget(target, input, explicitReasoningEffort, harness) {
+    if (!target.endpoint || target.endpoint.status?.deprecated === true)
+        return false;
+    if (!target.modelServiceName?.toLowerCase().startsWith("system.ai."))
+        return false;
+    if (!target.capabilities.chat)
+        return false;
+    if (harness === "codex" && !target.capabilities.aiGatewayCodex)
+        return false;
+    if (harness === "claude" && !target.capabilities.anthropic)
+        return false;
+    if (input.features.tools && !target.capabilities.tools)
+        return false;
+    if (input.features.parallelTools && !target.capabilities.parallelTools)
+        return false;
+    if (input.features.customTools && !target.capabilities.customTools)
+        return false;
+    if (input.features.structuredOutput && !target.capabilities.structuredOutput)
+        return false;
+    if (input.features.webSearch && !target.capabilities.webSearch)
+        return false;
+    if (input.features.imageInput && !target.capabilities.imageInput)
+        return false;
+    if (input.features.applyPatch && !target.capabilities.applyPatch)
+        return false;
+    if (input.features.reasoning && !target.capabilities.reasoning)
+        return false;
+    if (explicitReasoningEffort &&
+        explicitReasoningEffort !== "none" &&
+        !target.reasoningEfforts.includes(explicitReasoningEffort)) {
+        return false;
+    }
+    try {
+        resolveRoute({
+            clientProtocol: input.protocol,
+            ...(input.originator ? { originator: input.originator } : {}),
+            preferSystemModels: input.preferSystemModels,
+            features: input.features,
+            target,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function requestedReasoningEffort(body) {
+    const reasoning = isRecord(body.reasoning) ? body.reasoning : undefined;
+    const outputConfig = isRecord(body.output_config) ? body.output_config : undefined;
+    const raw = body.reasoning_effort ?? reasoning?.effort ?? outputConfig?.effort;
+    if (raw === undefined || raw === null)
+        return undefined;
+    const normalized = String(raw).trim().toLowerCase().replaceAll("_", "-");
+    const parsed = ReasoningEffortSchema.safeParse(normalized === "extra-high" ? "xhigh" : normalized);
+    if (!parsed.success) {
+        throw new SmartRouterError(400, `Unsupported Smart Router reasoning effort: ${String(raw)}`);
+    }
+    return parsed.data;
+}
+function contextFromEvents(events, tokenBudget) {
+    const latestUserIndex = lastEventIndex(events, "user");
+    const taskEvent = latestUserIndex >= 0 ? events[latestUserIndex] : events.at(-1);
+    const task = truncateText(taskEvent?.text ?? "", tokenBudget, "start");
+    let remaining = Math.max(0, tokenBudget - countTokens(task));
+    const context = [];
+    for (let index = (taskEvent ? events.indexOf(taskEvent) : events.length) - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (!event || !event.text || event.role === "tool")
+            continue;
+        const value = `${event.role}: ${event.text}`;
+        const retained = truncateText(value, remaining, "end");
+        if (!retained)
+            break;
+        context.unshift(retained);
+        remaining -= countTokens(retained);
+    }
+    const combined = [...context, task].filter(Boolean).join("\n");
+    const logicalEvents = latestUserIndex >= 0 ? events.slice(0, latestUserIndex + 1) : events;
+    return {
+        task: combined,
+        logicalTurn: logicalEvents.map((event) => `${event.role}:${event.text}`).join("\n"),
+        continuation: latestUserIndex >= 0 &&
+            events.slice(latestUserIndex + 1).some((event) => event.role !== "system"),
+    };
+}
+function conversationEvents(input) {
+    if (typeof input === "string")
+        return input.trim() ? [{ role: "user", text: input.trim() }] : [];
+    if (Array.isArray(input))
+        return input.flatMap(messageEvent);
+    if (!isRecord(input))
+        return [];
+    for (const key of ["messages", "input"]) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim())
+            return [{ role: "user", text: value.trim() }];
+        if (Array.isArray(value)) {
+            const events = value.flatMap(messageEvent);
+            if (events.length > 0)
+                return events;
+        }
+    }
+    return [];
+}
+function messageEvent(value) {
+    if (typeof value === "string")
+        return value.trim() ? [{ role: "user", text: value.trim() }] : [];
+    if (!isRecord(value))
+        return [];
+    const role = messageRole(value);
+    if (!role)
+        return [];
+    const text = contentText(value.content ?? value.text ?? value.input_text ?? value.output_text);
+    return text ? [{ role, text }] : [];
+}
+function messageRole(value) {
+    if (value.role === "user" || value.role === "assistant" || value.role === "system") {
+        return value.role;
+    }
+    if (value.role === "tool" ||
+        value.type === "function_call_output" ||
+        value.type === "tool_result") {
+        return "tool";
+    }
+    if (value.type === "function_call" || value.type === "reasoning")
+        return "assistant";
+    if (value.type === "message" && value.role === undefined)
+        return "user";
+    return undefined;
+}
+function contentText(value) {
+    if (typeof value === "string")
+        return value.trim();
+    if (Array.isArray(value))
+        return value.map(contentText).filter(Boolean).join("\n");
+    if (!isRecord(value))
+        return "";
+    for (const key of ["text", "input_text", "output_text", "content"]) {
+        const text = contentText(value[key]);
+        if (text)
+            return text;
+    }
+    return "";
+}
+const TASK_KEYS = [
+    "prompt",
+    "task",
+    "query",
+    "question",
+    "request",
+    "description",
+    "message",
+    "text",
+    "input",
+];
+const IGNORED_KEYS = new Set([
+    "api_key",
+    "authorization",
+    "arguments",
+    "credentials",
+    "headers",
+    "metadata",
+    "password",
+    "secret",
+    "token",
+    "tools",
+]);
+function collectTaskStrings(input) {
+    if (typeof input === "string")
+        return input.trim() ? [input.trim()] : [];
+    const preferred = [];
+    if (isRecord(input)) {
+        for (const key of TASK_KEYS)
+            preferred.push(...stringLeaves(input[key], key, 0));
+    }
+    return preferred.length > 0 ? preferred.slice(0, 32) : stringLeaves(input, "", 0).slice(0, 32);
+}
+function stringLeaves(value, key, depth) {
+    if (depth > 6 || IGNORED_KEYS.has(key.toLowerCase()))
+        return [];
+    if (typeof value === "string")
+        return value.trim() ? [value.trim()] : [];
+    if (Array.isArray(value))
+        return value.flatMap((item) => stringLeaves(item, key, depth + 1));
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([childKey, child]) => stringLeaves(child, childKey, depth + 1));
+}
+function parseJsonString(input) {
+    if (typeof input !== "string")
+        return input;
+    const trimmed = input.trim();
+    if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("[")))
+        return input;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return input;
+    }
+}
+function countTokens(text) {
+    return CONTEXT_ENCODING.encode(text, [], []).length;
+}
+function truncateText(text, tokenBudget, edge) {
+    if (tokenBudget <= 0 || !text)
+        return "";
+    const tokens = CONTEXT_ENCODING.encode(text, [], []);
+    if (tokens.length <= tokenBudget)
+        return text;
+    return CONTEXT_ENCODING.decode(edge === "start" ? tokens.slice(0, tokenBudget) : tokens.slice(-tokenBudget));
+}
+function lastEventIndex(events, role) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index]?.role === role)
+            return index;
+    }
+    return -1;
+}
+function uniqueCandidates(candidates) {
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        const key = `${candidate.harness}:${normalizeRouteModel(candidate.model)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function normalizeRouteModel(model) {
+    let normalized = model.trim().toLowerCase().split("/").at(-1) ?? "";
+    for (const prefix of ["databricks-", "system.ai."]) {
+        if (normalized.startsWith(prefix)) {
+            normalized = normalized.slice(prefix.length);
+            break;
+        }
+    }
+    return normalized;
+}
+function probeKey(candidates, routerName) {
+    return JSON.stringify({
+        routerName,
+        candidates: candidates
+            .map(({ model, harness }) => ({ model: normalizeRouteModel(model), harness }))
+            .sort((left, right) => `${left.harness}:${left.model}`.localeCompare(`${right.harness}:${right.model}`)),
+    });
+}
+function appKitCacheManager() {
+    try {
+        return CacheManager.getInstanceSync();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function smartRouterProbeIdentity(client) {
+    const headers = new Headers();
+    const host = (await client.config.getHost()).toString();
+    await client.config.authenticate(headers);
+    return createHash("sha256")
+        .update(host)
+        .update("\0")
+        .update(headers.get("authorization") ?? "")
+        .update("\0")
+        .update(headers.get("x-databricks-workspace-id") ?? "")
+        .digest("hex");
+}
+async function invokeSmartRouter(client, body, signal, timeoutMs) {
+    const host = (await client.config.getHost()).toString();
+    const url = new URL("/ai-gateway/routing/v1/routes:select", host);
+    const headers = new Headers({ "content-type": "application/json" });
+    await client.config.authenticate(headers);
+    const combinedSignal = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+    let response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: combinedSignal,
+    });
+    if (response.status === 401 && (await refreshWorkspaceClientAuthentication(client))) {
+        await response.body?.cancel();
+        headers.delete("authorization");
+        headers.delete("x-databricks-workspace-id");
+        await client.config.authenticate(headers);
+        response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: combinedSignal,
+        });
+    }
+    if (!response.ok) {
+        const detail = (await response.text().catch(() => "")).trim().slice(0, 500);
+        throw new SmartRouterError(response.status === 404 ? 404 : 503, `Databricks Smart Router failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+    }
+    return response.json();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-router.js","sourceRoot":"","sources":["../../src/smart-router.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks Smart Router transport, context construction, probing, and turn pinning.\n *\n * @module\n */\n\nimport { createHash } from \"node:crypto\";\nimport { CacheManager, getExecutionContext, type WorkspaceClient } from \"@databricks/appkit\";\nimport { closeCache, createCache, getOrSet } from \"@dbx-tools/cache\";\nimport { refreshWorkspaceClientAuthentication } from \"@dbx-tools/databricks\";\nimport { isRecord, log, toError } from \"@dbx-tools/shared-core\";\nimport { ReasoningEffortSchema, type ReasoningEffort } from \"@dbx-tools/shared-model\";\nimport {\n  SMART_ROUTER_NAME,\n  SmartRouterObservationSchema,\n  SmartRouterRequestSchema,\n  SmartRouterResponseSchema,\n  type ClientProtocol,\n  type ModelTarget,\n  type RequestedFeatures,\n  type SmartRouterHarness,\n  type SmartRouterObservation,\n  type SmartRouterRequest,\n} from \"@dbx-tools/shared-model-gateway\";\nimport { Tiktoken } from \"js-tiktoken/lite\";\nimport o200kBase from \"js-tiktoken/ranks/o200k_base\";\nimport { z } from \"zod\";\n\nimport { resolveRoute } from \"./router.ts\";\n\nconst logger = log.logger(\"appkit/model-gateway/smart-router\");\nconst ROUTE_CACHE_NAMESPACE = \"model-gateway-smart-router\";\nconst ROUTE_POLICY_VERSION = 1;\nconst PROBE_CACHE_NAMESPACE = \"model-gateway-smart-router-probe\";\nconst PROBE_CACHE_VERSION = 1;\nconst PROBE_TASK = \"Check whether Smart Router can select an available model.\";\nconst NEGATIVE_PROBE_TTL_MS = 30_000;\nconst CONTEXT_ENCODING = new Tiktoken(o200kBase);\n\n/** Runtime settings for Smart Router. */\nexport interface SmartRouterSettings {\n  readonly contextTokenBudget: number;\n  readonly probeRefreshIntervalMs: number;\n  readonly probeTtlMs: number;\n  readonly routeTtlSeconds: number;\n  readonly routerName: string;\n  readonly timeoutMs: number;\n}\n\n/** Defaults shared by gateway, Mastra, and CLI Smart Router callers. */\nexport const SMART_ROUTER_DEFAULT_SETTINGS: SmartRouterSettings = Object.freeze({\n  contextTokenBudget: 4_096,\n  probeRefreshIntervalMs: 3_600_000,\n  probeTtlMs: 300_000,\n  routeTtlSeconds: 21_600,\n  routerName: SMART_ROUTER_NAME,\n  timeoutMs: 10_000,\n});\n\n/** One route option associated with the caller-owned value it represents. */\nexport interface SmartRouterCandidate<T> {\n  readonly harness: SmartRouterHarness;\n  readonly model: string;\n  readonly value: T;\n}\n\n/** Result returned after mapping a Databricks route back to a caller-owned value. */\nexport interface SmartRouterSelection<T> {\n  readonly harness: SmartRouterHarness;\n  readonly latencyMs: number;\n  readonly params?: Readonly<Record<string, unknown>>;\n  readonly rationale?: string;\n  readonly routeModel: string;\n  readonly routerName: string;\n  readonly value: T;\n}\n\n/** Portable persistence surface for a pinned Smart Router turn. */\nexport interface SmartRouterStore {\n  get(key: string): Promise<unknown>;\n  set(key: string, value: SmartRouterObservation, ttlSeconds: number): Promise<void>;\n}\n\nexport const SmartRouterProbeRecordSchema = z\n  .object({\n    enabled: z.boolean().describe(\"Whether the live Smart Router probe succeeded.\"),\n    expiresAt: z.number().int().describe(\"Epoch milliseconds when this probe becomes stale.\"),\n  })\n  .describe(\"Persisted Smart Router capability probe result.\");\n\nexport type SmartRouterProbeRecord = z.infer<typeof SmartRouterProbeRecordSchema>;\n\n/** Optional persistent cache for capability probes. */\nexport interface SmartRouterProbeStore {\n  get(key: string, client: WorkspaceClient): Promise<unknown>;\n  set(\n    key: string,\n    value: SmartRouterProbeRecord,\n    ttlSeconds: number,\n    client: WorkspaceClient,\n  ): Promise<void>;\n}\n\n/** Result applied to one concrete gateway request. */\nexport interface SmartRouterResult {\n  readonly body: Readonly<Record<string, unknown>>;\n  readonly observation: SmartRouterObservation;\n  readonly target: ModelTarget;\n}\n\n/** Bounded task context extracted from an arbitrary supported input shape. */\nexport interface SmartRouterContext {\n  readonly continuation: boolean;\n  readonly logicalTurn: string;\n  readonly task: string;\n}\n\n/** Error carrying an HTTP status for Smart Router validation or availability failures. */\nexport class SmartRouterError extends Error {\n  constructor(\n    readonly status: number,\n    message: string,\n  ) {\n    super(message);\n    this.name = \"SmartRouterError\";\n  }\n}\n\n/** AppKit cache adapter; configured Lakebase/Postgres storage remains AppKit-owned. */\nexport class AppKitSmartRouterStore implements SmartRouterStore {\n  async get(key: string): Promise<unknown> {\n    const cache = await CacheManager.getInstance();\n    return cache.get(cache.generateKey([ROUTE_CACHE_NAMESPACE, ROUTE_POLICY_VERSION], key));\n  }\n\n  async set(key: string, value: SmartRouterObservation, ttlSeconds: number): Promise<void> {\n    const cache = await CacheManager.getInstance();\n    await cache.set(cache.generateKey([ROUTE_CACHE_NAMESPACE, ROUTE_POLICY_VERSION], key), value, {\n      ttl: ttlSeconds,\n    });\n  }\n}\n\n/** AppKit cache adapter for process- and persistence-backed capability probes. */\nexport class AppKitSmartRouterProbeStore implements SmartRouterProbeStore {\n  async get(key: string, client: WorkspaceClient): Promise<unknown> {\n    const cache = appKitCacheManager();\n    if (!cache) return undefined;\n    const identity = await smartRouterProbeIdentity(client);\n    return cache.get(\n      cache.generateKey([PROBE_CACHE_NAMESPACE, PROBE_CACHE_VERSION], `${identity}:${key}`),\n    );\n  }\n\n  async set(\n    key: string,\n    value: SmartRouterProbeRecord,\n    ttlSeconds: number,\n    client: WorkspaceClient,\n  ): Promise<void> {\n    const cache = appKitCacheManager();\n    if (!cache) return;\n    const identity = await smartRouterProbeIdentity(client);\n    await cache.set(\n      cache.generateKey([PROBE_CACHE_NAMESPACE, PROBE_CACHE_VERSION], `${identity}:${key}`),\n      value,\n      { ttl: ttlSeconds },\n    );\n  }\n}\n\ntype SmartRouterProbeCache = ReturnType<typeof createCache>;\n\n/** Optional identity and cancellation inputs for one Smart Router call. */\nexport interface SmartRouterSelectOptions {\n  readonly client?: WorkspaceClient;\n  readonly signal?: AbortSignal;\n}\n\ntype SmartRouterInvoker = (\n  client: WorkspaceClient,\n  request: SmartRouterRequest,\n  signal: AbortSignal,\n  timeoutMs: number,\n) => Promise<unknown>;\n\n/**\n * Dedicated Smart Router service for strings, request objects, message arrays,\n * and generic JSON-like inputs.\n */\nexport class SmartRouterService {\n  readonly context: SmartRouterContextBuilder;\n  private readonly settings: SmartRouterSettings;\n  private readonly probes = new WeakMap<object, SmartRouterProbeCache>();\n  private readonly probeKeys = new WeakMap<object, Set<string>>();\n  private readonly probeCaches = new Set<SmartRouterProbeCache>();\n\n  constructor(\n    settings: Partial<SmartRouterSettings> = {},\n    private readonly invoke: SmartRouterInvoker = invokeSmartRouter,\n    private readonly probeStore: SmartRouterProbeStore = new AppKitSmartRouterProbeStore(),\n  ) {\n    this.settings = { ...SMART_ROUTER_DEFAULT_SETTINGS, ...settings };\n    this.context = new SmartRouterContextBuilder(this.settings.contextTokenBudget);\n  }\n\n  /** Select one offered route for arbitrary input content. */\n  async select<T>(\n    input: unknown,\n    candidates: readonly SmartRouterCandidate<T>[],\n    options: SmartRouterSelectOptions = {},\n  ): Promise<SmartRouterSelection<T>> {\n    const task = this.context.build(input);\n    if (!task) throw new SmartRouterError(400, \"Smart Router input contains no routable text\");\n    const client = options.client ?? getExecutionContext().client;\n    try {\n      const selection = await this.selectTask(task, candidates, { ...options, client });\n      this.setProbeValue(candidates, client, true);\n      return selection;\n    } catch (error) {\n      this.setProbeUnavailable(candidates, client);\n      throw error;\n    }\n  }\n\n  /** Return a memoized live capability probe for the active identity and candidate menu. */\n  async isEnabled<T>(\n    candidates: readonly SmartRouterCandidate<T>[],\n    client = getExecutionContext().client,\n  ): Promise<boolean> {\n    const offered = uniqueCandidates(candidates);\n    if (offered.length === 0) return false;\n    const cache = this.probeCache(client);\n    const key = probeKey(offered, this.settings.routerName);\n    this.rememberProbeKey(client, key);\n    const probe = await getOrSet(\n      cache,\n      key,\n      () => this.loadProbe(key, offered, client),\n      {\n        ttl: this.probeCacheTtlMs(),\n        refreshAfterWrite: (value) => this.probeRefreshAfterWrite(value.enabled),\n      },\n    );\n    return probe?.enabled ?? false;\n  }\n\n  /** Stop process-local probe caches after their active refreshes settle. */\n  dispose(): void {\n    for (const cache of this.probeCaches) void closeCache(cache);\n    this.probeCaches.clear();\n  }\n\n  private async loadProbe<T>(\n    key: string,\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n  ): Promise<SmartRouterProbeRecord> {\n    const stored = await this.readStoredProbe(key, client);\n    if (stored && stored.expiresAt > Date.now()) return stored;\n    return this.executeProbe(key, candidates, client);\n  }\n\n  private async executeProbe<T>(\n    key: string,\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n  ): Promise<SmartRouterProbeRecord> {\n    const enabled = await this.selectTask(PROBE_TASK, candidates, { client })\n      .then(() => true)\n      .catch((error) => {\n        logger.debug(\"Smart Router capability probe unavailable\", { error: toError(error) });\n        return false;\n      });\n    const probe = this.probeRecord(enabled);\n    void this.writeStoredProbe(key, probe, client);\n    return probe;\n  }\n\n  private setProbeValue<T>(\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n    enabled: boolean,\n  ): void {\n    const offered = uniqueCandidates(candidates);\n    if (offered.length === 0) return;\n    const cache = this.probeCache(client);\n    const key = probeKey(offered, this.settings.routerName);\n    this.rememberProbeKey(client, key);\n    const probe = this.probeRecord(enabled);\n    void this.writeProcessProbe(cache, key, probe);\n    void this.writeStoredProbe(key, probe, client);\n  }\n\n  private setProbeUnavailable<T>(\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n  ): void {\n    const cache = this.probeCache(client);\n    const offered = uniqueCandidates(candidates);\n    const requestedKey = probeKey(offered, this.settings.routerName);\n    this.rememberProbeKey(client, requestedKey);\n    const keys = this.probeKeys.get(client.config as object) ?? new Set([requestedKey]);\n    for (const key of keys) {\n      const probe = this.probeRecord(false);\n      void this.writeProcessProbe(cache, key, probe);\n      void this.writeStoredProbe(key, probe, client);\n    }\n  }\n\n  private probeRecord(enabled: boolean): SmartRouterProbeRecord {\n    return { enabled, expiresAt: Date.now() + this.probeTtl(enabled) };\n  }\n\n  private async readStoredProbe(\n    key: string,\n    client: WorkspaceClient,\n  ): Promise<SmartRouterProbeRecord | undefined> {\n    try {\n      const parsed = SmartRouterProbeRecordSchema.safeParse(await this.probeStore.get(key, client));\n      return parsed.success ? parsed.data : undefined;\n    } catch (error) {\n      logger.debug(\"Smart Router probe cache read failed\", { error: toError(error) });\n      return undefined;\n    }\n  }\n\n  private async writeProcessProbe(\n    cache: SmartRouterProbeCache,\n    key: string,\n    probe: SmartRouterProbeRecord,\n  ): Promise<void> {\n    try {\n      await cache.set(key, probe, { ttl: this.probeCacheTtlMs() });\n    } catch (error) {\n      logger.debug(\"Smart Router process probe cache write failed\", { error: toError(error) });\n    }\n  }\n\n  private async writeStoredProbe(\n    key: string,\n    probe: SmartRouterProbeRecord,\n    client: WorkspaceClient,\n  ): Promise<void> {\n    try {\n      await this.probeStore.set(\n        key,\n        probe,\n        Math.max(1, Math.ceil(this.probeCacheTtlMs() / 1_000)),\n        client,\n      );\n    } catch (error) {\n      logger.debug(\"Smart Router probe cache write failed\", { error: toError(error) });\n    }\n  }\n\n  private probeCache(client: WorkspaceClient): SmartRouterProbeCache {\n    const owner = client.config as object;\n    let cache = this.probes.get(owner);\n    if (!cache) {\n      cache = createCache({ maxEntries: 32, useClone: false });\n      this.probes.set(owner, cache);\n      this.probeCaches.add(cache);\n    }\n    return cache;\n  }\n\n  private rememberProbeKey(client: WorkspaceClient, key: string): void {\n    const owner = client.config as object;\n    let keys = this.probeKeys.get(owner);\n    if (!keys) {\n      keys = new Set();\n      this.probeKeys.set(owner, keys);\n    }\n    keys.add(key);\n  }\n\n  private probeCacheTtlMs(): number {\n    return Math.max(this.settings.probeRefreshIntervalMs, this.settings.probeTtlMs) * 2;\n  }\n\n  private probeTtl(enabled: boolean): number {\n    return enabled\n      ? this.settings.probeTtlMs\n      : Math.min(this.settings.probeTtlMs, NEGATIVE_PROBE_TTL_MS);\n  }\n\n  private probeRefreshAfterWrite(enabled: boolean): number {\n    return Math.min(this.settings.probeRefreshIntervalMs, this.probeTtl(enabled));\n  }\n\n  private async selectTask<T>(\n    task: string,\n    candidates: readonly SmartRouterCandidate<T>[],\n    options: SmartRouterSelectOptions,\n  ): Promise<SmartRouterSelection<T>> {\n    const offered = uniqueCandidates(candidates);\n    if (offered.length === 0) {\n      throw new SmartRouterError(400, \"No compatible system models are available to Smart Router\");\n    }\n    const request = SmartRouterRequestSchema.parse({\n      route_options: offered.map(({ model, harness }) => ({ model, harness })),\n      task: { prompt: task },\n      route_selector: { router_name: this.settings.routerName },\n    });\n    const client = options.client ?? getExecutionContext().client;\n    const signal = options.signal ?? new AbortController().signal;\n    const startedAt = Date.now();\n    const response = SmartRouterResponseSchema.parse(\n      await this.invoke(client, request, signal, this.settings.timeoutMs),\n    );\n    const selection = response.route_selection[0]!;\n    const selected = offered.find(\n      (candidate) =>\n        normalizeRouteModel(candidate.model) ===\n          normalizeRouteModel(selection.route_option.model) &&\n        (!selection.route_option.harness || candidate.harness === selection.route_option.harness),\n    );\n    if (!selected) {\n      throw new SmartRouterError(\n        502,\n        `Smart Router selected an unsupported model: ${selection.route_option.model}`,\n      );\n    }\n    return {\n      value: selected.value,\n      routeModel: selection.route_option.model,\n      harness: selected.harness,\n      routerName: this.settings.routerName,\n      latencyMs: Date.now() - startedAt,\n      ...(response.rationale ? { rationale: response.rationale } : {}),\n      ...(selection.params ? { params: selection.params } : {}),\n    };\n  }\n}\n\n/** Build a Smart Router candidate menu from values carrying modelServiceName. */\nexport function smartRouterCandidates<T extends { readonly modelServiceName?: string }>(\n  values: readonly T[],\n  harness: SmartRouterHarness,\n): SmartRouterCandidate<T>[] {\n  return values.flatMap((value) => {\n    const model = value.modelServiceName?.trim();\n    if (!model || !model.toLowerCase().startsWith(\"system.ai.\")) return [];\n    return [{ model, harness, value }];\n  });\n}\n\n/**\n * Context extractor shared by the gateway, Mastra, and the file/stdin CLI.\n * It favors conversation/task fields and ignores credentials, tool schemas,\n * and tool arguments.\n */\nexport class SmartRouterContextBuilder {\n  constructor(private readonly tokenBudget = 4_096) {}\n\n  /** Return only the bounded task prompt required by routes:select. */\n  build(input: unknown): string {\n    return this.analyze(input).task;\n  }\n\n  /** Return bounded task text plus logical-turn metadata used for pinning. */\n  analyze(input: unknown): SmartRouterContext {\n    const normalized = parseJsonString(input);\n    const events = conversationEvents(normalized);\n    if (events.length > 0) return contextFromEvents(events, this.tokenBudget);\n    const values = collectTaskStrings(normalized);\n    const task = truncateText(values.join(\"\\n\"), this.tokenBudget, \"start\");\n    return { task, logicalTurn: task, continuation: false };\n  }\n}\n\n/** Smart Router orchestration shared by Responses, Chat Completions, and Messages. */\nexport class SmartModelRouter {\n  readonly service: SmartRouterService;\n  private readonly settings: SmartRouterSettings;\n\n  constructor(\n    settings: Partial<SmartRouterSettings> = {},\n    service: SmartRouterService | undefined = undefined,\n    private readonly store: SmartRouterStore = new AppKitSmartRouterStore(),\n    private readonly client?: WorkspaceClient,\n  ) {\n    this.settings = { ...SMART_ROUTER_DEFAULT_SETTINGS, ...settings };\n    this.service = service ?? new SmartRouterService(this.settings);\n  }\n\n  /** Probe whether Smart Router is usable for the current model catalogue. */\n  isEnabled(targets: readonly ModelTarget[]): Promise<boolean> {\n    const candidates = smartRouterCandidates(\n      targets.filter((target) => target.capabilities.chat && target.capabilities.aiGatewayCodex),\n      \"codex\",\n    );\n    return this.client\n      ? this.service.isEnabled(candidates, this.client)\n      : this.service.isEnabled(candidates);\n  }\n\n  /** Resolve one virtual smart-router request to a concrete compatible target. */\n  async resolve(input: {\n    readonly body: Readonly<Record<string, unknown>>;\n    readonly features: RequestedFeatures;\n    readonly headers: Headers;\n    readonly preferSystemModels: boolean;\n    readonly protocol: Exclude<ClientProtocol, \"openai-embeddings\">;\n    readonly signal: AbortSignal;\n    readonly targets: readonly ModelTarget[];\n  }): Promise<SmartRouterResult> {\n    const harness: SmartRouterHarness =\n      input.protocol === \"anthropic-messages\" ? \"claude\" : \"codex\";\n    const explicitReasoningEffort = requestedReasoningEffort(input.body);\n    const eligibleTargets = input.targets.filter((target) =>\n      isEligibleTarget(\n        target,\n        { ...input, originator: input.headers.get(\"originator\") ?? undefined },\n        explicitReasoningEffort,\n        harness,\n      ),\n    );\n    const candidates = smartRouterCandidates(eligibleTargets, harness);\n    if (candidates.length === 0) {\n      throw new SmartRouterError(\n        400,\n        \"No compatible system models are available to Databricks Smart Router\",\n      );\n    }\n\n    const context = this.service.context.analyze(input.body);\n    if (!context.task) {\n      throw new SmartRouterError(400, \"Smart Router request contains no task text\");\n    }\n    const key = smartRouterTurnKey(context.logicalTurn, candidates, {\n      harness,\n      protocol: input.protocol,\n      features: input.features,\n      ...(explicitReasoningEffort ? { explicitReasoningEffort } : {}),\n    });\n    const cached = context.continuation ? await this.readCached(key, eligibleTargets) : undefined;\n    if (cached) {\n      return {\n        target: eligibleTargets.find((target) => target.id === cached.selectedModel)!,\n        body: input.body,\n        observation: { ...cached, source: \"cache\" },\n      };\n    }\n\n    const selected = await this.service.select(context.task, candidates, {\n      signal: input.signal,\n      ...(this.client ? { client: this.client } : {}),\n    });\n    const target = selected.value;\n    const observation = SmartRouterObservationSchema.parse({\n      selectedModel: target.id,\n      routeModel: selected.routeModel,\n      harness: selected.harness,\n      routerName: selected.routerName,\n      source: \"router\",\n      latencyMs: selected.latencyMs,\n      ...(selected.rationale ? { rationale: selected.rationale } : {}),\n      ...(selected.params ? { params: selected.params } : {}),\n    });\n    await this.writeCached(key, observation);\n    logger.debug(\"selected Smart Router model\", {\n      candidateCount: candidates.length,\n      harness,\n      latencyMs: observation.latencyMs,\n      model: observation.selectedModel,\n      routeModel: observation.routeModel,\n      routerName: observation.routerName,\n    });\n    return { target, body: input.body, observation };\n  }\n\n  private async readCached(\n    key: string,\n    targets: readonly ModelTarget[],\n  ): Promise<SmartRouterObservation | undefined> {\n    try {\n      const parsed = SmartRouterObservationSchema.safeParse(await this.store.get(key));\n      if (!parsed.success) return undefined;\n      return targets.some((target) => target.id === parsed.data.selectedModel)\n        ? parsed.data\n        : undefined;\n    } catch (error) {\n      logger.debug(\"Smart Router cache read failed\", { error: toError(error) });\n      return undefined;\n    }\n  }\n\n  private async writeCached(key: string, observation: SmartRouterObservation): Promise<void> {\n    try {\n      await this.store.set(key, observation, this.settings.routeTtlSeconds);\n    } catch (error) {\n      logger.debug(\"Smart Router cache write failed\", { error: toError(error) });\n    }\n  }\n}\n\n/** Stable logical-turn key shared by initial requests and tool continuations. */\nexport function smartRouterTurnKey(\n  logicalTurn: string,\n  candidates: readonly SmartRouterCandidate<unknown>[],\n  context: Readonly<Record<string, unknown>>,\n): string {\n  return createHash(\"sha256\")\n    .update(\n      JSON.stringify({\n        logicalTurn,\n        candidates: candidates.map(({ model, harness }) => ({ model, harness })),\n        context,\n      }),\n    )\n    .digest(\"hex\");\n}\n\nfunction isEligibleTarget(\n  target: ModelTarget,\n  input: {\n    readonly features: RequestedFeatures;\n    readonly originator?: string;\n    readonly preferSystemModels: boolean;\n    readonly protocol: Exclude<ClientProtocol, \"openai-embeddings\">;\n  },\n  explicitReasoningEffort: ReasoningEffort | undefined,\n  harness: SmartRouterHarness,\n): boolean {\n  if (!target.endpoint || target.endpoint.status?.deprecated === true) return false;\n  if (!target.modelServiceName?.toLowerCase().startsWith(\"system.ai.\")) return false;\n  if (!target.capabilities.chat) return false;\n  if (harness === \"codex\" && !target.capabilities.aiGatewayCodex) return false;\n  if (harness === \"claude\" && !target.capabilities.anthropic) return false;\n  if (input.features.tools && !target.capabilities.tools) return false;\n  if (input.features.parallelTools && !target.capabilities.parallelTools) return false;\n  if (input.features.customTools && !target.capabilities.customTools) return false;\n  if (input.features.structuredOutput && !target.capabilities.structuredOutput) return false;\n  if (input.features.webSearch && !target.capabilities.webSearch) return false;\n  if (input.features.imageInput && !target.capabilities.imageInput) return false;\n  if (input.features.applyPatch && !target.capabilities.applyPatch) return false;\n  if (input.features.reasoning && !target.capabilities.reasoning) return false;\n  if (\n    explicitReasoningEffort &&\n    explicitReasoningEffort !== \"none\" &&\n    !target.reasoningEfforts.includes(explicitReasoningEffort)\n  ) {\n    return false;\n  }\n  try {\n    resolveRoute({\n      clientProtocol: input.protocol,\n      ...(input.originator ? { originator: input.originator } : {}),\n      preferSystemModels: input.preferSystemModels,\n      features: input.features,\n      target,\n    });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction requestedReasoningEffort(\n  body: Readonly<Record<string, unknown>>,\n): ReasoningEffort | undefined {\n  const reasoning = isRecord(body.reasoning) ? body.reasoning : undefined;\n  const outputConfig = isRecord(body.output_config) ? body.output_config : undefined;\n  const raw = body.reasoning_effort ?? reasoning?.effort ?? outputConfig?.effort;\n  if (raw === undefined || raw === null) return undefined;\n  const normalized = String(raw).trim().toLowerCase().replaceAll(\"_\", \"-\");\n  const parsed = ReasoningEffortSchema.safeParse(\n    normalized === \"extra-high\" ? \"xhigh\" : normalized,\n  );\n  if (!parsed.success) {\n    throw new SmartRouterError(400, `Unsupported Smart Router reasoning effort: ${String(raw)}`);\n  }\n  return parsed.data;\n}\n\ninterface ConversationEvent {\n  readonly role: \"assistant\" | \"system\" | \"tool\" | \"user\";\n  readonly text: string;\n}\n\nfunction contextFromEvents(\n  events: readonly ConversationEvent[],\n  tokenBudget: number,\n): SmartRouterContext {\n  const latestUserIndex = lastEventIndex(events, \"user\");\n  const taskEvent = latestUserIndex >= 0 ? events[latestUserIndex] : events.at(-1);\n  const task = truncateText(taskEvent?.text ?? \"\", tokenBudget, \"start\");\n  let remaining = Math.max(0, tokenBudget - countTokens(task));\n  const context: string[] = [];\n  for (\n    let index = (taskEvent ? events.indexOf(taskEvent) : events.length) - 1;\n    index >= 0;\n    index -= 1\n  ) {\n    const event = events[index];\n    if (!event || !event.text || event.role === \"tool\") continue;\n    const value = `${event.role}: ${event.text}`;\n    const retained = truncateText(value, remaining, \"end\");\n    if (!retained) break;\n    context.unshift(retained);\n    remaining -= countTokens(retained);\n  }\n  const combined = [...context, task].filter(Boolean).join(\"\\n\");\n  const logicalEvents = latestUserIndex >= 0 ? events.slice(0, latestUserIndex + 1) : events;\n  return {\n    task: combined,\n    logicalTurn: logicalEvents.map((event) => `${event.role}:${event.text}`).join(\"\\n\"),\n    continuation:\n      latestUserIndex >= 0 &&\n      events.slice(latestUserIndex + 1).some((event) => event.role !== \"system\"),\n  };\n}\n\nfunction conversationEvents(input: unknown): ConversationEvent[] {\n  if (typeof input === \"string\") return input.trim() ? [{ role: \"user\", text: input.trim() }] : [];\n  if (Array.isArray(input)) return input.flatMap(messageEvent);\n  if (!isRecord(input)) return [];\n  for (const key of [\"messages\", \"input\"] as const) {\n    const value = input[key];\n    if (typeof value === \"string\" && value.trim()) return [{ role: \"user\", text: value.trim() }];\n    if (Array.isArray(value)) {\n      const events = value.flatMap(messageEvent);\n      if (events.length > 0) return events;\n    }\n  }\n  return [];\n}\n\nfunction messageEvent(value: unknown): ConversationEvent[] {\n  if (typeof value === \"string\") return value.trim() ? [{ role: \"user\", text: value.trim() }] : [];\n  if (!isRecord(value)) return [];\n  const role = messageRole(value);\n  if (!role) return [];\n  const text = contentText(value.content ?? value.text ?? value.input_text ?? value.output_text);\n  return text ? [{ role, text }] : [];\n}\n\nfunction messageRole(\n  value: Readonly<Record<string, unknown>>,\n): ConversationEvent[\"role\"] | undefined {\n  if (value.role === \"user\" || value.role === \"assistant\" || value.role === \"system\") {\n    return value.role;\n  }\n  if (\n    value.role === \"tool\" ||\n    value.type === \"function_call_output\" ||\n    value.type === \"tool_result\"\n  ) {\n    return \"tool\";\n  }\n  if (value.type === \"function_call\" || value.type === \"reasoning\") return \"assistant\";\n  if (value.type === \"message\" && value.role === undefined) return \"user\";\n  return undefined;\n}\n\nfunction contentText(value: unknown): string {\n  if (typeof value === \"string\") return value.trim();\n  if (Array.isArray(value)) return value.map(contentText).filter(Boolean).join(\"\\n\");\n  if (!isRecord(value)) return \"\";\n  for (const key of [\"text\", \"input_text\", \"output_text\", \"content\"] as const) {\n    const text = contentText(value[key]);\n    if (text) return text;\n  }\n  return \"\";\n}\n\nconst TASK_KEYS = [\n  \"prompt\",\n  \"task\",\n  \"query\",\n  \"question\",\n  \"request\",\n  \"description\",\n  \"message\",\n  \"text\",\n  \"input\",\n] as const;\nconst IGNORED_KEYS = new Set([\n  \"api_key\",\n  \"authorization\",\n  \"arguments\",\n  \"credentials\",\n  \"headers\",\n  \"metadata\",\n  \"password\",\n  \"secret\",\n  \"token\",\n  \"tools\",\n]);\n\nfunction collectTaskStrings(input: unknown): string[] {\n  if (typeof input === \"string\") return input.trim() ? [input.trim()] : [];\n  const preferred: string[] = [];\n  if (isRecord(input)) {\n    for (const key of TASK_KEYS) preferred.push(...stringLeaves(input[key], key, 0));\n  }\n  return preferred.length > 0 ? preferred.slice(0, 32) : stringLeaves(input, \"\", 0).slice(0, 32);\n}\n\nfunction stringLeaves(value: unknown, key: string, depth: number): string[] {\n  if (depth > 6 || IGNORED_KEYS.has(key.toLowerCase())) return [];\n  if (typeof value === \"string\") return value.trim() ? [value.trim()] : [];\n  if (Array.isArray(value)) return value.flatMap((item) => stringLeaves(item, key, depth + 1));\n  if (!isRecord(value)) return [];\n  return Object.entries(value).flatMap(([childKey, child]) =>\n    stringLeaves(child, childKey, depth + 1),\n  );\n}\n\nfunction parseJsonString(input: unknown): unknown {\n  if (typeof input !== \"string\") return input;\n  const trimmed = input.trim();\n  if (!trimmed || (!trimmed.startsWith(\"{\") && !trimmed.startsWith(\"[\"))) return input;\n  try {\n    return JSON.parse(trimmed) as unknown;\n  } catch {\n    return input;\n  }\n}\n\nfunction countTokens(text: string): number {\n  return CONTEXT_ENCODING.encode(text, [], []).length;\n}\n\nfunction truncateText(text: string, tokenBudget: number, edge: \"start\" | \"end\"): string {\n  if (tokenBudget <= 0 || !text) return \"\";\n  const tokens = CONTEXT_ENCODING.encode(text, [], []);\n  if (tokens.length <= tokenBudget) return text;\n  return CONTEXT_ENCODING.decode(\n    edge === \"start\" ? tokens.slice(0, tokenBudget) : tokens.slice(-tokenBudget),\n  );\n}\n\nfunction lastEventIndex(\n  events: readonly ConversationEvent[],\n  role: ConversationEvent[\"role\"],\n): number {\n  for (let index = events.length - 1; index >= 0; index -= 1) {\n    if (events[index]?.role === role) return index;\n  }\n  return -1;\n}\n\nfunction uniqueCandidates<T>(\n  candidates: readonly SmartRouterCandidate<T>[],\n): SmartRouterCandidate<T>[] {\n  const seen = new Set<string>();\n  return candidates.filter((candidate) => {\n    const key = `${candidate.harness}:${normalizeRouteModel(candidate.model)}`;\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n\nfunction normalizeRouteModel(model: string): string {\n  let normalized = model.trim().toLowerCase().split(\"/\").at(-1) ?? \"\";\n  for (const prefix of [\"databricks-\", \"system.ai.\"] as const) {\n    if (normalized.startsWith(prefix)) {\n      normalized = normalized.slice(prefix.length);\n      break;\n    }\n  }\n  return normalized;\n}\n\nfunction probeKey<T>(candidates: readonly SmartRouterCandidate<T>[], routerName: string): string {\n  return JSON.stringify({\n    routerName,\n    candidates: candidates\n      .map(({ model, harness }) => ({ model: normalizeRouteModel(model), harness }))\n      .sort((left, right) =>\n        `${left.harness}:${left.model}`.localeCompare(`${right.harness}:${right.model}`),\n      ),\n  });\n}\n\nfunction appKitCacheManager(): CacheManager | undefined {\n  try {\n    return CacheManager.getInstanceSync();\n  } catch {\n    return undefined;\n  }\n}\n\nasync function smartRouterProbeIdentity(client: WorkspaceClient): Promise<string> {\n  const headers = new Headers();\n  const host = (await client.config.getHost()).toString();\n  await client.config.authenticate(headers);\n  return createHash(\"sha256\")\n    .update(host)\n    .update(\"\\0\")\n    .update(headers.get(\"authorization\") ?? \"\")\n    .update(\"\\0\")\n    .update(headers.get(\"x-databricks-workspace-id\") ?? \"\")\n    .digest(\"hex\");\n}\n\nasync function invokeSmartRouter(\n  client: WorkspaceClient,\n  body: SmartRouterRequest,\n  signal: AbortSignal,\n  timeoutMs: number,\n): Promise<unknown> {\n  const host = (await client.config.getHost()).toString();\n  const url = new URL(\"/ai-gateway/routing/v1/routes:select\", host);\n  const headers = new Headers({ \"content-type\": \"application/json\" });\n  await client.config.authenticate(headers);\n  const combinedSignal = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);\n  let response = await fetch(url, {\n    method: \"POST\",\n    headers,\n    body: JSON.stringify(body),\n    signal: combinedSignal,\n  });\n  if (response.status === 401 && (await refreshWorkspaceClientAuthentication(client))) {\n    await response.body?.cancel();\n    headers.delete(\"authorization\");\n    headers.delete(\"x-databricks-workspace-id\");\n    await client.config.authenticate(headers);\n    response = await fetch(url, {\n      method: \"POST\",\n      headers,\n      body: JSON.stringify(body),\n      signal: combinedSignal,\n    });\n  }\n  if (!response.ok) {\n    const detail = (await response.text().catch(() => \"\")).trim().slice(0, 500);\n    throw new SmartRouterError(\n      response.status === 404 ? 404 : 503,\n      `Databricks Smart Router failed with HTTP ${response.status}${detail ? `: ${detail}` : \"\"}`,\n    );\n  }\n  return response.json();\n}\n"]}