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

package/lib/src/smart-router.js

@@ -0,0 +1,753 @@
+/**
+ * Databricks Smart Router transport, context construction, probing, and turn pinning.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { CacheManager, getExecutionContext } from "@databricks/appkit";
+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);
+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 {
+    settings;
+    invoke;
+    probeStore;
+    context;
+    probes = new WeakMap();
+    probeEntries = new Set();
+    probeRefreshTimer;
+    constructor(settings, invoke = invokeSmartRouter, probeStore = new AppKitSmartRouterProbeStore()) {
+        this.settings = settings;
+        this.invoke = invoke;
+        this.probeStore = probeStore;
+        this.context = new SmartRouterContextBuilder(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);
+        const now = Date.now();
+        const cached = cache.get(key);
+        if (cached) {
+            if (cached.value === undefined)
+                return cached.refresh;
+            if (cached.expiresAt <= now && !cached.refresh)
+                void this.refreshProbe(cached);
+            return cached.value;
+        }
+        const entry = this.createProbeEntry(cache, key, offered, client);
+        return this.initializeProbe(entry);
+    }
+    /** Stop this service's unref'd background probe refresh timer. */
+    dispose() {
+        if (this.probeRefreshTimer)
+            clearInterval(this.probeRefreshTimer);
+        this.probeRefreshTimer = undefined;
+        this.probeEntries.clear();
+    }
+    createProbeEntry(cache, key, candidates, client) {
+        const entry = {
+            cache,
+            candidates,
+            client: new WeakRef(client),
+            key,
+            expiresAt: 0,
+        };
+        this.replaceProbe(cache, key, entry);
+        return entry;
+    }
+    initializeProbe(entry) {
+        const client = entry.client.deref();
+        if (!client)
+            return Promise.resolve(false);
+        let refresh;
+        refresh = this.readStoredProbe(entry, client)
+            .then((stored) => {
+            if (stored && stored.expiresAt > Date.now()) {
+                entry.value = stored.enabled;
+                entry.expiresAt = stored.expiresAt;
+                return stored.enabled;
+            }
+            return this.executeProbe(entry, client);
+        })
+            .finally(() => {
+            if (entry.refresh === refresh)
+                entry.refresh = undefined;
+        });
+        entry.refresh = refresh;
+        return refresh;
+    }
+    refreshProbe(entry) {
+        if (entry.refresh)
+            return entry.refresh;
+        const client = entry.client.deref();
+        if (!client)
+            return Promise.resolve(false);
+        let refresh;
+        refresh = this.executeProbe(entry, client).finally(() => {
+            if (entry.refresh === refresh)
+                entry.refresh = undefined;
+        });
+        entry.refresh = refresh;
+        return refresh;
+    }
+    async executeProbe(entry, client) {
+        const enabled = await this.selectTask(PROBE_TASK, entry.candidates, { client })
+            .then(() => true)
+            .catch((error) => {
+            logger.debug("Smart Router capability probe unavailable", { error: toError(error) });
+            return false;
+        });
+        if (entry.cache.get(entry.key) === entry) {
+            this.updateProbeEntry(entry, enabled);
+            void this.writeStoredProbe(entry, enabled, client);
+        }
+        return enabled;
+    }
+    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);
+        const entry = cache.get(key) ?? this.createProbeEntry(cache, key, offered, client);
+        this.updateProbeEntry(entry, enabled);
+        void this.writeStoredProbe(entry, enabled, client);
+    }
+    setProbeUnavailable(candidates, client) {
+        const cache = this.probeCache(client);
+        for (const cached of cache.values()) {
+            this.updateProbeEntry(cached, false);
+            void this.writeStoredProbe(cached, false, client);
+        }
+        this.setProbeValue(candidates, client, false);
+    }
+    updateProbeEntry(entry, enabled) {
+        entry.value = enabled;
+        entry.expiresAt = Date.now() + this.probeTtl(enabled);
+    }
+    async readStoredProbe(entry, client) {
+        try {
+            const parsed = SmartRouterProbeRecordSchema.safeParse(await this.probeStore.get(entry.key, client));
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch (error) {
+            logger.debug("Smart Router probe cache read failed", { error: toError(error) });
+            return undefined;
+        }
+    }
+    async writeStoredProbe(entry, enabled, client) {
+        try {
+            await this.probeStore.set(entry.key, { enabled, expiresAt: entry.expiresAt }, Math.max(1, Math.ceil((Math.max(this.settings.probeRefreshIntervalMs, this.settings.probeTtlMs) * 2) / 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 = new Map();
+            this.probes.set(owner, cache);
+        }
+        return cache;
+    }
+    replaceProbe(cache, key, entry) {
+        const previous = cache.get(key);
+        if (previous)
+            this.probeEntries.delete(previous);
+        cache.set(key, entry);
+        this.probeEntries.add(entry);
+        this.ensureProbeRefreshTimer();
+    }
+    probeTtl(enabled) {
+        return enabled
+            ? this.settings.probeTtlMs
+            : Math.min(this.settings.probeTtlMs, NEGATIVE_PROBE_TTL_MS);
+    }
+    ensureProbeRefreshTimer() {
+        if (this.probeRefreshTimer)
+            return;
+        this.probeRefreshTimer = setInterval(() => {
+            void this.refreshProbes();
+        }, this.settings.probeRefreshIntervalMs);
+        this.probeRefreshTimer.unref();
+    }
+    async refreshProbes() {
+        const refreshes = [];
+        for (const entry of [...this.probeEntries]) {
+            if (entry.cache.get(entry.key) !== entry) {
+                this.probeEntries.delete(entry);
+                continue;
+            }
+            const client = entry.client.deref();
+            if (!client) {
+                entry.cache.delete(entry.key);
+                this.probeEntries.delete(entry);
+                continue;
+            }
+            if (!entry.refresh)
+                refreshes.push(this.refreshProbe(entry));
+        }
+        await Promise.allSettled(refreshes);
+    }
+    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 {
+    settings;
+    store;
+    client;
+    service;
+    constructor(settings, service = new SmartRouterService(settings), store = new AppKitSmartRouterStore(), client) {
+        this.settings = settings;
+        this.store = store;
+        this.client = client;
+        this.service = service;
+    }
+    /** 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();
+}
+/** 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,
+});
+//# 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 { 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/** 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\ninterface ProbeEntry {\n  readonly cache: Map<string, ProbeEntry>;\n  readonly candidates: readonly SmartRouterCandidate<unknown>[];\n  readonly client: WeakRef<WorkspaceClient>;\n  readonly key: string;\n  expiresAt: number;\n  refresh?: Promise<boolean>;\n  value?: boolean;\n}\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 probes = new WeakMap<object, Map<string, ProbeEntry>>();\n  private readonly probeEntries = new Set<ProbeEntry>();\n  private probeRefreshTimer?: NodeJS.Timeout;\n\n  constructor(\n    private readonly settings: SmartRouterSettings,\n    private readonly invoke: SmartRouterInvoker = invokeSmartRouter,\n    private readonly probeStore: SmartRouterProbeStore = new AppKitSmartRouterProbeStore(),\n  ) {\n    this.context = new SmartRouterContextBuilder(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    const now = Date.now();\n    const cached = cache.get(key);\n    if (cached) {\n      if (cached.value === undefined) return cached.refresh!;\n      if (cached.expiresAt <= now && !cached.refresh) void this.refreshProbe(cached);\n      return cached.value;\n    }\n    const entry = this.createProbeEntry(cache, key, offered, client);\n    return this.initializeProbe(entry);\n  }\n\n  /** Stop this service's unref'd background probe refresh timer. */\n  dispose(): void {\n    if (this.probeRefreshTimer) clearInterval(this.probeRefreshTimer);\n    this.probeRefreshTimer = undefined;\n    this.probeEntries.clear();\n  }\n\n  private createProbeEntry<T>(\n    cache: Map<string, ProbeEntry>,\n    key: string,\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n  ): ProbeEntry {\n    const entry: ProbeEntry = {\n      cache,\n      candidates,\n      client: new WeakRef(client),\n      key,\n      expiresAt: 0,\n    };\n    this.replaceProbe(cache, key, entry);\n    return entry;\n  }\n\n  private initializeProbe(entry: ProbeEntry): Promise<boolean> {\n    const client = entry.client.deref();\n    if (!client) return Promise.resolve(false);\n    let refresh!: Promise<boolean>;\n    refresh = this.readStoredProbe(entry, client)\n      .then((stored) => {\n        if (stored && stored.expiresAt > Date.now()) {\n          entry.value = stored.enabled;\n          entry.expiresAt = stored.expiresAt;\n          return stored.enabled;\n        }\n        return this.executeProbe(entry, client);\n      })\n      .finally(() => {\n        if (entry.refresh === refresh) entry.refresh = undefined;\n      });\n    entry.refresh = refresh;\n    return refresh;\n  }\n\n  private refreshProbe(entry: ProbeEntry): Promise<boolean> {\n    if (entry.refresh) return entry.refresh;\n    const client = entry.client.deref();\n    if (!client) return Promise.resolve(false);\n    let refresh!: Promise<boolean>;\n    refresh = this.executeProbe(entry, client).finally(() => {\n      if (entry.refresh === refresh) entry.refresh = undefined;\n    });\n    entry.refresh = refresh;\n    return refresh;\n  }\n\n  private async executeProbe(entry: ProbeEntry, client: WorkspaceClient): Promise<boolean> {\n    const enabled = await this.selectTask(PROBE_TASK, entry.candidates, { client })\n      .then(() => true)\n      .catch((error) => {\n        logger.debug(\"Smart Router capability probe unavailable\", { error: toError(error) });\n        return false;\n      });\n    if (entry.cache.get(entry.key) === entry) {\n      this.updateProbeEntry(entry, enabled);\n      void this.writeStoredProbe(entry, enabled, client);\n    }\n    return enabled;\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    const entry = cache.get(key) ?? this.createProbeEntry(cache, key, offered, client);\n    this.updateProbeEntry(entry, enabled);\n    void this.writeStoredProbe(entry, enabled, client);\n  }\n\n  private setProbeUnavailable<T>(\n    candidates: readonly SmartRouterCandidate<T>[],\n    client: WorkspaceClient,\n  ): void {\n    const cache = this.probeCache(client);\n    for (const cached of cache.values()) {\n      this.updateProbeEntry(cached, false);\n      void this.writeStoredProbe(cached, false, client);\n    }\n    this.setProbeValue(candidates, client, false);\n  }\n\n  private updateProbeEntry(entry: ProbeEntry, enabled: boolean): void {\n    entry.value = enabled;\n    entry.expiresAt = Date.now() + this.probeTtl(enabled);\n  }\n\n  private async readStoredProbe(\n    entry: ProbeEntry,\n    client: WorkspaceClient,\n  ): Promise<SmartRouterProbeRecord | undefined> {\n    try {\n      const parsed = SmartRouterProbeRecordSchema.safeParse(\n        await this.probeStore.get(entry.key, client),\n      );\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 writeStoredProbe(\n    entry: ProbeEntry,\n    enabled: boolean,\n    client: WorkspaceClient,\n  ): Promise<void> {\n    try {\n      await this.probeStore.set(\n        entry.key,\n        { enabled, expiresAt: entry.expiresAt },\n        Math.max(\n          1,\n          Math.ceil(\n            (Math.max(this.settings.probeRefreshIntervalMs, this.settings.probeTtlMs) * 2) / 1_000,\n          ),\n        ),\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): Map<string, ProbeEntry> {\n    const owner = client.config as object;\n    let cache = this.probes.get(owner);\n    if (!cache) {\n      cache = new Map();\n      this.probes.set(owner, cache);\n    }\n    return cache;\n  }\n\n  private replaceProbe(cache: Map<string, ProbeEntry>, key: string, entry: ProbeEntry): void {\n    const previous = cache.get(key);\n    if (previous) this.probeEntries.delete(previous);\n    cache.set(key, entry);\n    this.probeEntries.add(entry);\n    this.ensureProbeRefreshTimer();\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 ensureProbeRefreshTimer(): void {\n    if (this.probeRefreshTimer) return;\n    this.probeRefreshTimer = setInterval(() => {\n      void this.refreshProbes();\n    }, this.settings.probeRefreshIntervalMs);\n    this.probeRefreshTimer.unref();\n  }\n\n  private async refreshProbes(): Promise<void> {\n    const refreshes: Promise<boolean>[] = [];\n    for (const entry of [...this.probeEntries]) {\n      if (entry.cache.get(entry.key) !== entry) {\n        this.probeEntries.delete(entry);\n        continue;\n      }\n      const client = entry.client.deref();\n      if (!client) {\n        entry.cache.delete(entry.key);\n        this.probeEntries.delete(entry);\n        continue;\n      }\n      if (!entry.refresh) refreshes.push(this.refreshProbe(entry));\n    }\n    await Promise.allSettled(refreshes);\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\n  constructor(\n    private readonly settings: SmartRouterSettings,\n    service = new SmartRouterService(settings),\n    private readonly store: SmartRouterStore = new AppKitSmartRouterStore(),\n    private readonly client?: WorkspaceClient,\n  ) {\n    this.service = service;\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\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"]}