@dbx-tools/model 0.9.32 → 0.9.37

package/lib/src/reasoning-translation.js

@@ -0,0 +1,444 @@
+/**
+ * Generic reasoning-budget translation for Model Serving and gateway callers.
+ *
+ * Provider wires disagree on effort labels (`xhigh`, `ultra`, `med`, `none`, …).
+ * This module owns one industry-shaped ladder and two parsers:
+ *
+ * - {@link parseReasoning}: fuzzy-match one label onto {@link ReasoningLevel}
+ * - {@link parseReasoningLevels}: unwrap nested / double-encoded error bodies
+ * - {@link remapReasoning} / {@link adaptRequestReasoning}: map a request onto a
+ *   supported ladder and rewrite `reasoning_effort` / `reasoning.effort`
+ *
+ * Documented model ladders come from the committed HTML snapshot refreshed by
+ * `bun run --filter '@dbx-tools/model' metadata` (same cache path as
+ * capabilities / rate limits). Error-body parsing is never cached; callers
+ * persist learned ladders via the metadata module.
+ *
+ * Error bodies arrive as complete HTTP JSON whether the request asked for
+ * streaming or not (Databricks rejects unsupported efforts with 400 before SSE
+ * starts), so {@link parseReasoningLevels} applies to both paths.
+ *
+ * @module
+ */
+import { json } from "@dbx-tools/shared-core";
+import { isRecord } from "@dbx-tools/shared-core/object";
+import * as stringUtils from "@dbx-tools/shared-core/string-utils";
+import Fuse from "fuse.js";
+import { modelFamily, modelSearchQuery } from "./policy.js";
+/** Runtime values for {@link ReasoningLevel}. */
+export const ReasoningLevel = {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    ExtraHigh: "extra-high",
+    Max: "max",
+};
+/** Canonical ladder order used when sorting or ranking remaps. */
+export const REASONING_LEVELS = [
+    ReasoningLevel.Low,
+    ReasoningLevel.Medium,
+    ReasoningLevel.High,
+    ReasoningLevel.ExtraHigh,
+    ReasoningLevel.Max,
+];
+const STANDARD = [
+    ReasoningLevel.Low,
+    ReasoningLevel.Medium,
+    ReasoningLevel.High,
+];
+const WITH_EXTRA_HIGH = [
+    ReasoningLevel.Low,
+    ReasoningLevel.Medium,
+    ReasoningLevel.High,
+    ReasoningLevel.ExtraHigh,
+];
+const WITH_MAX = [
+    ReasoningLevel.Low,
+    ReasoningLevel.Medium,
+    ReasoningLevel.High,
+    ReasoningLevel.ExtraHigh,
+    ReasoningLevel.Max,
+];
+const GPT_5_5_PRO = [
+    ReasoningLevel.Medium,
+    ReasoningLevel.High,
+    ReasoningLevel.ExtraHigh,
+];
+/**
+ * Alias table for exact / near-exact labels. Keys are {@link normalizeReasoningToken}
+ * results. Provider wires (`xhigh`) and plain English (`ultra`, `med`) both land
+ * on the generic ladder.
+ */
+const ALIASES = {
+    low: ReasoningLevel.Low,
+    l: ReasoningLevel.Low,
+    none: ReasoningLevel.Low,
+    off: ReasoningLevel.Low,
+    disable: ReasoningLevel.Low,
+    disabled: ReasoningLevel.Low,
+    zero: ReasoningLevel.Low,
+    minimal: ReasoningLevel.Low,
+    min: ReasoningLevel.Low,
+    tiny: ReasoningLevel.Low,
+    light: ReasoningLevel.Low,
+    medium: ReasoningLevel.Medium,
+    med: ReasoningLevel.Medium,
+    mid: ReasoningLevel.Medium,
+    moderate: ReasoningLevel.Medium,
+    default: ReasoningLevel.Medium,
+    normal: ReasoningLevel.Medium,
+    balanced: ReasoningLevel.Medium,
+    high: ReasoningLevel.High,
+    hi: ReasoningLevel.High,
+    heavy: ReasoningLevel.High,
+    "extra-high": ReasoningLevel.ExtraHigh,
+    extrahigh: ReasoningLevel.ExtraHigh,
+    xhigh: ReasoningLevel.ExtraHigh,
+    xh: ReasoningLevel.ExtraHigh,
+    ultra: ReasoningLevel.ExtraHigh,
+    "ultra-high": ReasoningLevel.ExtraHigh,
+    ultrahigh: ReasoningLevel.ExtraHigh,
+    max: ReasoningLevel.Max,
+    maximum: ReasoningLevel.Max,
+    highest: ReasoningLevel.Max,
+    full: ReasoningLevel.Max,
+};
+const SUPPORTED_VALUES_PATTERN = /supported\s+values?\s+are\s*:?\s*(.+?)(?:\.?\s*(?:param|type|code)\b|$)/is;
+const TOKEN_PATTERN = /'([^']+)'|"([^"]+)"|`([^`]+)`|\b([a-z][a-z0-9_-]*)\b/gi;
+const MAX_JSON_UNWRAP_DEPTH = 8;
+const aliasDocuments = Object.entries(ALIASES).map(([token, level]) => ({ token, level }));
+const aliasFuse = new Fuse(aliasDocuments, {
+    keys: ["token"],
+    includeScore: true,
+    threshold: 0.35,
+    ignoreLocation: true,
+});
+/**
+ * Fuzzy-match one reasoning label onto {@link ReasoningLevel}.
+ *
+ * Returns `undefined` when the input is empty or cannot be mapped confidently.
+ */
+export function parseReasoning(value) {
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+        return undefined;
+    }
+    const normalized = normalizeReasoningToken(String(value));
+    if (!normalized)
+        return undefined;
+    const exact = ALIASES[normalized] ?? ALIASES[normalized.replace(/-/g, "")];
+    if (exact)
+        return exact;
+    const [match] = aliasFuse.search(normalized);
+    if (!match || (match.score ?? 1) > 0.35)
+        return undefined;
+    return match.item.level;
+}
+/**
+ * Extract supported reasoning levels from an upstream error body.
+ *
+ * Accepts raw response text, already-parsed JSON, or Databricks envelopes that
+ * nest JSON strings several times. Returns `[]` when no supported-values list
+ * can be recovered. Results are not cached.
+ */
+export function parseReasoningLevels(body) {
+    const levels = [];
+    const seen = new Set();
+    for (const text of collectTextLeaves(body)) {
+        for (const token of extractSupportedTokens(text)) {
+            const level = parseReasoning(token);
+            if (!level || seen.has(level))
+                continue;
+            seen.add(level);
+            levels.push(level);
+        }
+    }
+    return levels;
+}
+/**
+ * Look up documented levels for a model identity inside a catalogue.
+ *
+ * Matches exact catalogue keys and suffix identities.
+ */
+export function documentedReasoningLevels(model, catalogue) {
+    const keys = catalogueKeysFor(model);
+    for (const key of keys) {
+        const levels = catalogue[key];
+        if (levels?.length)
+            return [...levels];
+    }
+    for (const [key, levels] of Object.entries(catalogue)) {
+        if (keys.some((candidate) => key.endsWith(candidate) || candidate.endsWith(key))) {
+            return [...levels];
+        }
+    }
+    return undefined;
+}
+/**
+ * Hard-coded family defaults used when documentation has no entry.
+ *
+ * Unknown families return the standard low/medium/high ladder.
+ */
+export function defaultReasoningLevels(model) {
+    const family = modelFamily(model)?.toLowerCase();
+    const normalized = model.toLowerCase();
+    if (family === "grok" || normalized.includes("grok"))
+        return [...WITH_EXTRA_HIGH];
+    if (family === "gemini" || normalized.includes("gemini"))
+        return [...STANDARD];
+    if (family === "claude" || normalized.includes("claude"))
+        return [...WITH_MAX];
+    if (family === "glm" || normalized.includes("glm")) {
+        return [ReasoningLevel.High, ReasoningLevel.Max];
+    }
+    if (family === "deepseek" ||
+        normalized.includes("deepseek") ||
+        family === "kimi" ||
+        normalized.includes("kimi")) {
+        return [ReasoningLevel.Low, ReasoningLevel.High, ReasoningLevel.Max];
+    }
+    if (family === "inkling" || normalized.includes("inkling"))
+        return [...WITH_MAX];
+    if (family === "gpt" || normalized.includes("gpt") || normalized.includes("codex")) {
+        if (normalized.includes("oss"))
+            return [...STANDARD];
+        if (/(?:^|[-_.])5[-_.]?5(?:[-_.]|$)/.test(normalized) && normalized.includes("pro")) {
+            return [...GPT_5_5_PRO];
+        }
+        if (/(?:^|[-_.])5[-_.]?6(?:[-_.]|$)/.test(normalized) ||
+            /(?:^|[-_.])6(?:[-_.]|$)/.test(normalized)) {
+            return [...WITH_MAX];
+        }
+        return [...STANDARD];
+    }
+    if (/(?:^|[-_./])o(?:1|3|4)(?:[-_./]|$)/.test(model) || normalized.includes("codex")) {
+        return [...STANDARD];
+    }
+    return [...STANDARD];
+}
+/**
+ * Prefer a documentation catalogue when provided, otherwise
+ * {@link defaultReasoningLevels}.
+ */
+export function reasoningLevelsFor(model, catalogue) {
+    if (catalogue) {
+        const documented = documentedReasoningLevels(model, catalogue);
+        if (documented?.length)
+            return documented;
+    }
+    return defaultReasoningLevels(model);
+}
+/**
+ * Map a generic level onto the most common provider wire token.
+ *
+ * `extra-high` becomes `xhigh` because that is what Databricks / OpenAI error
+ * messages advertise today.
+ */
+export function formatReasoning(level) {
+    return level === ReasoningLevel.ExtraHigh ? "xhigh" : level;
+}
+/** Wire tokens that mean "do not reason" rather than "use a low budget". */
+const DISABLED_REASONING_TOKENS = new Set(["none", "off", "disable", "disabled"]);
+/**
+ * Remap a requested effort onto the nearest supported {@link ReasoningLevel}.
+ *
+ * `none` / `off` (and disable aliases) are not a low budget: when the model
+ * requires reasoning, they snap to the supported level closest to
+ * {@link ReasoningLevel.Medium}. Other requests prefer the highest allowed
+ * level at or below the request, otherwise the lowest allowed level.
+ *
+ * Returns `undefined` when the request cannot be parsed or `levels` is empty.
+ */
+export function remapReasoning(requested, levels) {
+    if (levels.length === 0)
+        return undefined;
+    if (isDisabledReasoningToken(requested)) {
+        return nearestReasoning(ReasoningLevel.Medium, levels);
+    }
+    const parsed = parseReasoning(requested);
+    if (!parsed)
+        return undefined;
+    if (levels.includes(parsed))
+        return parsed;
+    const requestedIndex = REASONING_LEVELS.indexOf(parsed);
+    let best;
+    let bestIndex = Number.NEGATIVE_INFINITY;
+    for (const level of levels) {
+        const index = REASONING_LEVELS.indexOf(level);
+        if (index <= requestedIndex && index > bestIndex) {
+            best = level;
+            bestIndex = index;
+        }
+    }
+    return best ?? levels[0];
+}
+function isDisabledReasoningToken(value) {
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+        return false;
+    }
+    return DISABLED_REASONING_TOKENS.has(normalizeReasoningToken(String(value)));
+}
+/** Closest supported level to `target`; ties prefer the higher budget. */
+function nearestReasoning(target, levels) {
+    if (levels.length === 0)
+        return undefined;
+    if (levels.includes(target))
+        return target;
+    const targetIndex = REASONING_LEVELS.indexOf(target);
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const level of levels) {
+        const distance = Math.abs(REASONING_LEVELS.indexOf(level) - targetIndex);
+        if (distance < bestDistance ||
+            (distance === bestDistance &&
+                REASONING_LEVELS.indexOf(level) > REASONING_LEVELS.indexOf(best ?? level))) {
+            best = level;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+/**
+ * Rewrite `reasoning_effort` / `reasoning.effort` onto a supported ladder.
+ *
+ * Model-agnostic: callers supply the allowed levels (learned, documented, or
+ * defaults). Bodies without reasoning fields are returned unchanged.
+ */
+export function adaptRequestReasoning(body, levels) {
+    if (levels.length === 0)
+        return { body, changed: false };
+    const topLevel = body.reasoning_effort;
+    const reasoning = isRecord(body.reasoning) ? body.reasoning : undefined;
+    const nested = reasoning?.effort;
+    const requested = topLevel ?? nested;
+    if (requested === undefined)
+        return { body, changed: false };
+    const remapped = remapReasoning(requested, levels);
+    if (!remapped)
+        return { body, changed: false };
+    const wire = formatReasoning(remapped);
+    let changed = false;
+    let next = { ...body };
+    if (typeof topLevel === "string" || typeof topLevel === "number") {
+        if (String(topLevel) !== wire) {
+            next = { ...next, reasoning_effort: wire };
+            changed = true;
+        }
+    }
+    if (reasoning && (typeof nested === "string" || typeof nested === "number")) {
+        if (String(nested) !== wire) {
+            next = { ...next, reasoning: { ...reasoning, effort: wire } };
+            changed = true;
+        }
+    }
+    return changed ? { body: next, changed: true, wireEffort: wire } : { body, changed: false, wireEffort: wire };
+}
+/** Normalize labels for alias lookup (`Extra High` → `extra-high`). */
+export function normalizeReasoningToken(value) {
+    return (stringUtils
+        .trimToNull(value)
+        ?.toLowerCase()
+        .replace(/[_\s]+/g, "-")
+        .replace(/[^a-z0-9-]/g, "")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "") ?? "");
+}
+/** Deduplicate levels while preserving first-seen order. */
+export function uniqueReasoningLevels(levels) {
+    const seen = new Set();
+    const ordered = [];
+    for (const level of levels) {
+        if (seen.has(level))
+            continue;
+        seen.add(level);
+        ordered.push(level);
+    }
+    return ordered;
+}
+function extractSupportedTokens(text) {
+    const match = SUPPORTED_VALUES_PATTERN.exec(text);
+    if (!match?.[1])
+        return [];
+    return tokensFromFragment(match[1]);
+}
+function catalogueKeysFor(model) {
+    const keys = new Set();
+    const direct = modelCatalogueKey(model);
+    if (direct)
+        keys.add(direct);
+    const stripped = model
+        .toLowerCase()
+        .replace(/^databricks\//, "")
+        .replace(/^system\.ai\./, "")
+        .replace(/^databricks-/, "");
+    const strippedKey = modelCatalogueKey(stripped);
+    if (strippedKey)
+        keys.add(strippedKey);
+    const withPrefix = modelCatalogueKey(`databricks-${stripped}`);
+    if (withPrefix)
+        keys.add(withPrefix);
+    return [...keys];
+}
+function modelCatalogueKey(name) {
+    const trimmed = stringUtils.trimToNull(name);
+    if (!trimmed)
+        return undefined;
+    return (modelSearchQuery(trimmed)?.replaceAll(" ", "-") ??
+        trimmed
+            .toLowerCase()
+            .replace(/^databricks-/, "")
+            .replace(/[^a-z0-9._-]+/g, "-"));
+}
+function tokensFromFragment(fragment) {
+    const tokens = [];
+    for (const part of fragment.matchAll(TOKEN_PATTERN)) {
+        const token = part[1] ?? part[2] ?? part[3] ?? part[4];
+        if (!token || token === "and" || token === "or" || token === "of")
+            continue;
+        tokens.push(token.replace(/^["'`]+|["'`]+$/g, ""));
+    }
+    return tokens;
+}
+/**
+ * Walk a value tree, unwrapping nested JSON strings, and collect text leaves
+ * that may contain a supported-values sentence.
+ */
+function collectTextLeaves(value, depth = 0) {
+    if (value == null || depth > MAX_JSON_UNWRAP_DEPTH)
+        return [];
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return [];
+        const parsed = tryUnwrapJson(trimmed);
+        if (parsed !== undefined && parsed !== trimmed) {
+            return collectTextLeaves(parsed, depth + 1);
+        }
+        return [trimmed];
+    }
+    if (typeof value === "number" || typeof value === "boolean")
+        return [String(value)];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => collectTextLeaves(entry, depth + 1));
+    }
+    if (!isRecord(value))
+        return [];
+    return Object.values(value).flatMap((entry) => collectTextLeaves(entry, depth + 1));
+}
+function tryUnwrapJson(text) {
+    const asRecord = json.parseRecord(text);
+    if (asRecord)
+        return asRecord;
+    const parsed = json.parse(text);
+    if (parsed !== undefined)
+        return parsed;
+    if (text.includes('\\"') || text.includes("\\n")) {
+        const unescaped = text.replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\\\/g, "\\");
+        if (unescaped !== text) {
+            const nested = json.parse(unescaped);
+            if (nested !== undefined)
+                return nested;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reasoning-translation.js","sourceRoot":"","sources":["../../src/reasoning-translation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,KAAK,WAAW,MAAM,qCAAqC,CAAC;AACnE,OAAO,IAAI,MAAM,SAAS,CAAC;AAE3B,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAK5D,iDAAiD;AACjD,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,SAAS,EAAE,YAAY;IACvB,GAAG,EAAE,KAAK;CACuC,CAAC;AAEpD,kEAAkE;AAClE,MAAM,CAAC,MAAM,gBAAgB,GAA8B;IACzD,cAAc,CAAC,GAAG;IAClB,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,IAAI;IACnB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,GAAG;CACnB,CAAC;AAKF,MAAM,QAAQ,GAA8B;IAC1C,cAAc,CAAC,GAAG;IAClB,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,IAAI;CACpB,CAAC;AAEF,MAAM,eAAe,GAA8B;IACjD,cAAc,CAAC,GAAG;IAClB,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,IAAI;IACnB,cAAc,CAAC,SAAS;CACzB,CAAC;AAEF,MAAM,QAAQ,GAA8B;IAC1C,cAAc,CAAC,GAAG;IAClB,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,IAAI;IACnB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,GAAG;CACnB,CAAC;AAEF,MAAM,WAAW,GAA8B;IAC7C,cAAc,CAAC,MAAM;IACrB,cAAc,CAAC,IAAI;IACnB,cAAc,CAAC,SAAS;CACzB,CAAC;AAEF;;;;GAIG;AACH,MAAM,OAAO,GAA6C;IACxD,GAAG,EAAE,cAAc,CAAC,GAAG;IACvB,CAAC,EAAE,cAAc,CAAC,GAAG;IACrB,IAAI,EAAE,cAAc,CAAC,GAAG;IACxB,GAAG,EAAE,cAAc,CAAC,GAAG;IACvB,OAAO,EAAE,cAAc,CAAC,GAAG;IAC3B,QAAQ,EAAE,cAAc,CAAC,GAAG;IAC5B,IAAI,EAAE,cAAc,CAAC,GAAG;IACxB,OAAO,EAAE,cAAc,CAAC,GAAG;IAC3B,GAAG,EAAE,cAAc,CAAC,GAAG;IACvB,IAAI,EAAE,cAAc,CAAC,GAAG;IACxB,KAAK,EAAE,cAAc,CAAC,GAAG;IACzB,MAAM,EAAE,cAAc,CAAC,MAAM;IAC7B,GAAG,EAAE,cAAc,CAAC,MAAM;IAC1B,GAAG,EAAE,cAAc,CAAC,MAAM;IAC1B,QAAQ,EAAE,cAAc,CAAC,MAAM;IAC/B,OAAO,EAAE,cAAc,CAAC,MAAM;IAC9B,MAAM,EAAE,cAAc,CAAC,MAAM;IAC7B,QAAQ,EAAE,cAAc,CAAC,MAAM;IAC/B,IAAI,EAAE,cAAc,CAAC,IAAI;IACzB,EAAE,EAAE,cAAc,CAAC,IAAI;IACvB,KAAK,EAAE,cAAc,CAAC,IAAI;IAC1B,YAAY,EAAE,cAAc,CAAC,SAAS;IACtC,SAAS,EAAE,cAAc,CAAC,SAAS;IACnC,KAAK,EAAE,cAAc,CAAC,SAAS;IAC/B,EAAE,EAAE,cAAc,CAAC,SAAS;IAC5B,KAAK,EAAE,cAAc,CAAC,SAAS;IAC/B,YAAY,EAAE,cAAc,CAAC,SAAS;IACtC,SAAS,EAAE,cAAc,CAAC,SAAS;IACnC,GAAG,EAAE,cAAc,CAAC,GAAG;IACvB,OAAO,EAAE,cAAc,CAAC,GAAG;IAC3B,OAAO,EAAE,cAAc,CAAC,GAAG;IAC3B,IAAI,EAAE,cAAc,CAAC,GAAG;CACzB,CAAC;AAEF,MAAM,wBAAwB,GAC5B,2EAA2E,CAAC;AAC9E,MAAM,aAAa,GAAG,wDAAwD,CAAC;AAC/E,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAOhC,MAAM,cAAc,GAA6B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAC1E,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CACvC,CAAC;AAEF,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,cAAc,EAAE;IACzC,IAAI,EAAE,CAAC,OAAO,CAAC;IACf,YAAY,EAAE,IAAI;IAClB,SAAS,EAAE,IAAI;IACf,cAAc,EAAE,IAAI;CACrB,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QACzF,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,UAAU,GAAG,uBAAuB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1D,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAC;IAClC,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3E,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC7C,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI;QAAE,OAAO,SAAS,CAAC;IAC1D,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAa;IAChD,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,KAAK,MAAM,KAAK,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE,CAAC;YACjD,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;YACpC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,SAAS;YACxC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAa,EACb,SAAkC;IAElC,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,MAAM,EAAE,MAAM;YAAE,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;IACzC,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACtD,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACjF,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa;IAClD,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IACjD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IACvC,IAAI,MAAM,KAAK,MAAM,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAClF,IAAI,MAAM,KAAK,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;IAC/E,IAAI,MAAM,KAAK,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;IAC/E,IAAI,MAAM,KAAK,KAAK,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACnD,CAAC;IACD,IACE,MAAM,KAAK,UAAU;QACrB,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC/B,MAAM,KAAK,MAAM;QACjB,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAC3B,CAAC;QACD,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,MAAM,KAAK,SAAS,IAAI,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;IACjF,IAAI,MAAM,KAAK,KAAK,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACnF,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;QACrD,IAAI,gCAAgC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACpF,OAAO,CAAC,GAAG,WAAW,CAAC,CAAC;QAC1B,CAAC;QACD,IACE,gCAAgC,CAAC,IAAI,CAAC,UAAU,CAAC;YACjD,yBAAyB,CAAC,IAAI,CAAC,UAAU,CAAC,EAC1C,CAAC;YACD,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;QACvB,CAAC;QACD,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;IACvB,CAAC;IACD,IAAI,oCAAoC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACrF,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;IACvB,CAAC;IACD,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAa,EACb,SAAmC;IAEnC,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,UAAU,GAAG,yBAAyB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC/D,IAAI,UAAU,EAAE,MAAM;YAAE,OAAO,UAAU,CAAC;IAC5C,CAAC;IACD,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,KAAqB;IACnD,OAAO,KAAK,KAAK,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;AAC9D,CAAC;AAED,4EAA4E;AAC5E,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAElF;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,SAAkB,EAClB,MAAiC;IAEjC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,IAAI,wBAAwB,CAAC,SAAS,CAAC,EAAE,CAAC;QACxC,OAAO,gBAAgB,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IACD,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IAC3C,MAAM,cAAc,GAAG,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACxD,IAAI,IAAgC,CAAC;IACrC,IAAI,SAAS,GAAG,MAAM,CAAC,iBAAiB,CAAC;IACzC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,KAAK,IAAI,cAAc,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;YACjD,IAAI,GAAG,KAAK,CAAC;YACb,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAc;IAC9C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QACzF,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,yBAAyB,CAAC,GAAG,CAAC,uBAAuB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED,0EAA0E;AAC1E,SAAS,gBAAgB,CACvB,MAAsB,EACtB,MAAiC;IAEjC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IAC3C,MAAM,WAAW,GAAG,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,IAAI,IAAgC,CAAC;IACrC,IAAI,YAAY,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAC5C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC;QACzE,IACE,QAAQ,GAAG,YAAY;YACvB,CAAC,QAAQ,KAAK,YAAY;gBACxB,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAC,EAC5E,CAAC;YACD,IAAI,GAAG,KAAK,CAAC;YACb,YAAY,GAAG,QAAQ,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAYD;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAuC,EACvC,MAAiC;IAEjC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAEzD,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC;IACvC,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,MAAM,MAAM,GAAG,SAAS,EAAE,MAAM,CAAC;IACjC,MAAM,SAAS,GAAG,QAAQ,IAAI,MAAM,CAAC;IACrC,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAE7D,MAAM,QAAQ,GAAG,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACnD,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC/C,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IAEvC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,IAAI,GAA4B,EAAE,GAAG,IAAI,EAAE,CAAC;IAEhD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjE,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC;YAC9B,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC;YAC3C,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IACD,IAAI,SAAS,IAAI,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC5E,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;YAC5B,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,EAAE,GAAG,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC;YAC9D,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAChH,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,uBAAuB,CAAC,KAAa;IACnD,OAAO,CACL,WAAW;SACR,UAAU,CAAC,KAAK,CAAC;QAClB,EAAE,WAAW,EAAE;SACd,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;SACvB,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;SAC1B,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,EAAE,CAC/B,CAAC;AACJ,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,qBAAqB,CAAC,MAAiC;IACrE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,MAAM,OAAO,GAAqB,EAAE,CAAC;IACrC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,SAAS;QAC9B,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,sBAAsB,CAAC,IAAY;IAC1C,MAAM,KAAK,GAAG,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClD,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3B,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAa;IACrC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACxC,IAAI,MAAM;QAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,MAAM,QAAQ,GAAG,KAAK;SACnB,WAAW,EAAE;SACb,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC;SAC5B,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC;SAC5B,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IAC/B,MAAM,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAChD,IAAI,WAAW;QAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IACvC,MAAM,UAAU,GAAG,iBAAiB,CAAC,cAAc,QAAQ,EAAE,CAAC,CAAC;IAC/D,IAAI,UAAU;QAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACrC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;AACnB,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAY;IACrC,MAAM,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,OAAO,CACL,gBAAgB,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;QAC/C,OAAO;aACJ,WAAW,EAAE;aACb,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC;aAC3B,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAClC,CAAC;AACJ,CAAC;AAED,SAAS,kBAAkB,CAAC,QAAgB;IAC1C,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI;YAAE,SAAS;QAC5E,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,SAAS,iBAAiB,CAAC,KAAc,EAAE,KAAK,GAAG,CAAC;IAClD,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,GAAG,qBAAqB;QAAE,OAAO,EAAE,CAAC;IAC9D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;YAC/C,OAAO,iBAAiB,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACpF,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAChC,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,SAAS,aAAa,CAAC,IAAY;IACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzF,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACvB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YACrC,IAAI,MAAM,KAAK,SAAS;gBAAE,OAAO,MAAM,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n * Generic reasoning-budget translation for Model Serving and gateway callers.\n *\n * Provider wires disagree on effort labels (`xhigh`, `ultra`, `med`, `none`, …).\n * This module owns one industry-shaped ladder and two parsers:\n *\n * - {@link parseReasoning}: fuzzy-match one label onto {@link ReasoningLevel}\n * - {@link parseReasoningLevels}: unwrap nested / double-encoded error bodies\n * - {@link remapReasoning} / {@link adaptRequestReasoning}: map a request onto a\n *   supported ladder and rewrite `reasoning_effort` / `reasoning.effort`\n *\n * Documented model ladders come from the committed HTML snapshot refreshed by\n * `bun run --filter '@dbx-tools/model' metadata` (same cache path as\n * capabilities / rate limits). Error-body parsing is never cached; callers\n * persist learned ladders via the metadata module.\n *\n * Error bodies arrive as complete HTTP JSON whether the request asked for\n * streaming or not (Databricks rejects unsupported efforts with 400 before SSE\n * starts), so {@link parseReasoningLevels} applies to both paths.\n *\n * @module\n */\n\nimport { json } from \"@dbx-tools/shared-core\";\nimport { isRecord } from \"@dbx-tools/shared-core/object\";\nimport * as stringUtils from \"@dbx-tools/shared-core/string-utils\";\nimport Fuse from \"fuse.js\";\n\nimport { modelFamily, modelSearchQuery } from \"./policy.ts\";\n\n/** Industry-generic reasoning budget levels, lowest to highest. */\nexport type ReasoningLevel = \"low\" | \"medium\" | \"high\" | \"extra-high\" | \"max\";\n\n/** Runtime values for {@link ReasoningLevel}. */\nexport const ReasoningLevel = {\n  Low: \"low\",\n  Medium: \"medium\",\n  High: \"high\",\n  ExtraHigh: \"extra-high\",\n  Max: \"max\",\n} as const satisfies Record<string, ReasoningLevel>;\n\n/** Canonical ladder order used when sorting or ranking remaps. */\nexport const REASONING_LEVELS: readonly ReasoningLevel[] = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.ExtraHigh,\n  ReasoningLevel.Max,\n];\n\n/** Model identity → accepted {@link ReasoningLevel} ladder. */\nexport type ReasoningModelCatalogue = Readonly<Record<string, readonly ReasoningLevel[]>>;\n\nconst STANDARD: readonly ReasoningLevel[] = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n];\n\nconst WITH_EXTRA_HIGH: readonly ReasoningLevel[] = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.ExtraHigh,\n];\n\nconst WITH_MAX: readonly ReasoningLevel[] = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.ExtraHigh,\n  ReasoningLevel.Max,\n];\n\nconst GPT_5_5_PRO: readonly ReasoningLevel[] = [\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.ExtraHigh,\n];\n\n/**\n * Alias table for exact / near-exact labels. Keys are {@link normalizeReasoningToken}\n * results. Provider wires (`xhigh`) and plain English (`ultra`, `med`) both land\n * on the generic ladder.\n */\nconst ALIASES: Readonly<Record<string, ReasoningLevel>> = {\n  low: ReasoningLevel.Low,\n  l: ReasoningLevel.Low,\n  none: ReasoningLevel.Low,\n  off: ReasoningLevel.Low,\n  disable: ReasoningLevel.Low,\n  disabled: ReasoningLevel.Low,\n  zero: ReasoningLevel.Low,\n  minimal: ReasoningLevel.Low,\n  min: ReasoningLevel.Low,\n  tiny: ReasoningLevel.Low,\n  light: ReasoningLevel.Low,\n  medium: ReasoningLevel.Medium,\n  med: ReasoningLevel.Medium,\n  mid: ReasoningLevel.Medium,\n  moderate: ReasoningLevel.Medium,\n  default: ReasoningLevel.Medium,\n  normal: ReasoningLevel.Medium,\n  balanced: ReasoningLevel.Medium,\n  high: ReasoningLevel.High,\n  hi: ReasoningLevel.High,\n  heavy: ReasoningLevel.High,\n  \"extra-high\": ReasoningLevel.ExtraHigh,\n  extrahigh: ReasoningLevel.ExtraHigh,\n  xhigh: ReasoningLevel.ExtraHigh,\n  xh: ReasoningLevel.ExtraHigh,\n  ultra: ReasoningLevel.ExtraHigh,\n  \"ultra-high\": ReasoningLevel.ExtraHigh,\n  ultrahigh: ReasoningLevel.ExtraHigh,\n  max: ReasoningLevel.Max,\n  maximum: ReasoningLevel.Max,\n  highest: ReasoningLevel.Max,\n  full: ReasoningLevel.Max,\n};\n\nconst SUPPORTED_VALUES_PATTERN =\n  /supported\\s+values?\\s+are\\s*:?\\s*(.+?)(?:\\.?\\s*(?:param|type|code)\\b|$)/is;\nconst TOKEN_PATTERN = /'([^']+)'|\"([^\"]+)\"|`([^`]+)`|\\b([a-z][a-z0-9_-]*)\\b/gi;\nconst MAX_JSON_UNWRAP_DEPTH = 8;\n\ninterface AliasDocument {\n  readonly token: string;\n  readonly level: ReasoningLevel;\n}\n\nconst aliasDocuments: readonly AliasDocument[] = Object.entries(ALIASES).map(\n  ([token, level]) => ({ token, level }),\n);\n\nconst aliasFuse = new Fuse(aliasDocuments, {\n  keys: [\"token\"],\n  includeScore: true,\n  threshold: 0.35,\n  ignoreLocation: true,\n});\n\n/**\n * Fuzzy-match one reasoning label onto {@link ReasoningLevel}.\n *\n * Returns `undefined` when the input is empty or cannot be mapped confidently.\n */\nexport function parseReasoning(value: unknown): ReasoningLevel | undefined {\n  if (typeof value !== \"string\" && typeof value !== \"number\" && typeof value !== \"boolean\") {\n    return undefined;\n  }\n  const normalized = normalizeReasoningToken(String(value));\n  if (!normalized) return undefined;\n  const exact = ALIASES[normalized] ?? ALIASES[normalized.replace(/-/g, \"\")];\n  if (exact) return exact;\n  const [match] = aliasFuse.search(normalized);\n  if (!match || (match.score ?? 1) > 0.35) return undefined;\n  return match.item.level;\n}\n\n/**\n * Extract supported reasoning levels from an upstream error body.\n *\n * Accepts raw response text, already-parsed JSON, or Databricks envelopes that\n * nest JSON strings several times. Returns `[]` when no supported-values list\n * can be recovered. Results are not cached.\n */\nexport function parseReasoningLevels(body: unknown): ReasoningLevel[] {\n  const levels: ReasoningLevel[] = [];\n  const seen = new Set<ReasoningLevel>();\n  for (const text of collectTextLeaves(body)) {\n    for (const token of extractSupportedTokens(text)) {\n      const level = parseReasoning(token);\n      if (!level || seen.has(level)) continue;\n      seen.add(level);\n      levels.push(level);\n    }\n  }\n  return levels;\n}\n\n/**\n * Look up documented levels for a model identity inside a catalogue.\n *\n * Matches exact catalogue keys and suffix identities.\n */\nexport function documentedReasoningLevels(\n  model: string,\n  catalogue: ReasoningModelCatalogue,\n): ReasoningLevel[] | undefined {\n  const keys = catalogueKeysFor(model);\n  for (const key of keys) {\n    const levels = catalogue[key];\n    if (levels?.length) return [...levels];\n  }\n  for (const [key, levels] of Object.entries(catalogue)) {\n    if (keys.some((candidate) => key.endsWith(candidate) || candidate.endsWith(key))) {\n      return [...levels];\n    }\n  }\n  return undefined;\n}\n\n/**\n * Hard-coded family defaults used when documentation has no entry.\n *\n * Unknown families return the standard low/medium/high ladder.\n */\nexport function defaultReasoningLevels(model: string): ReasoningLevel[] {\n  const family = modelFamily(model)?.toLowerCase();\n  const normalized = model.toLowerCase();\n  if (family === \"grok\" || normalized.includes(\"grok\")) return [...WITH_EXTRA_HIGH];\n  if (family === \"gemini\" || normalized.includes(\"gemini\")) return [...STANDARD];\n  if (family === \"claude\" || normalized.includes(\"claude\")) return [...WITH_MAX];\n  if (family === \"glm\" || normalized.includes(\"glm\")) {\n    return [ReasoningLevel.High, ReasoningLevel.Max];\n  }\n  if (\n    family === \"deepseek\" ||\n    normalized.includes(\"deepseek\") ||\n    family === \"kimi\" ||\n    normalized.includes(\"kimi\")\n  ) {\n    return [ReasoningLevel.Low, ReasoningLevel.High, ReasoningLevel.Max];\n  }\n  if (family === \"inkling\" || normalized.includes(\"inkling\")) return [...WITH_MAX];\n  if (family === \"gpt\" || normalized.includes(\"gpt\") || normalized.includes(\"codex\")) {\n    if (normalized.includes(\"oss\")) return [...STANDARD];\n    if (/(?:^|[-_.])5[-_.]?5(?:[-_.]|$)/.test(normalized) && normalized.includes(\"pro\")) {\n      return [...GPT_5_5_PRO];\n    }\n    if (\n      /(?:^|[-_.])5[-_.]?6(?:[-_.]|$)/.test(normalized) ||\n      /(?:^|[-_.])6(?:[-_.]|$)/.test(normalized)\n    ) {\n      return [...WITH_MAX];\n    }\n    return [...STANDARD];\n  }\n  if (/(?:^|[-_./])o(?:1|3|4)(?:[-_./]|$)/.test(model) || normalized.includes(\"codex\")) {\n    return [...STANDARD];\n  }\n  return [...STANDARD];\n}\n\n/**\n * Prefer a documentation catalogue when provided, otherwise\n * {@link defaultReasoningLevels}.\n */\nexport function reasoningLevelsFor(\n  model: string,\n  catalogue?: ReasoningModelCatalogue,\n): ReasoningLevel[] {\n  if (catalogue) {\n    const documented = documentedReasoningLevels(model, catalogue);\n    if (documented?.length) return documented;\n  }\n  return defaultReasoningLevels(model);\n}\n\n/**\n * Map a generic level onto the most common provider wire token.\n *\n * `extra-high` becomes `xhigh` because that is what Databricks / OpenAI error\n * messages advertise today.\n */\nexport function formatReasoning(level: ReasoningLevel): string {\n  return level === ReasoningLevel.ExtraHigh ? \"xhigh\" : level;\n}\n\n/** Wire tokens that mean \"do not reason\" rather than \"use a low budget\". */\nconst DISABLED_REASONING_TOKENS = new Set([\"none\", \"off\", \"disable\", \"disabled\"]);\n\n/**\n * Remap a requested effort onto the nearest supported {@link ReasoningLevel}.\n *\n * `none` / `off` (and disable aliases) are not a low budget: when the model\n * requires reasoning, they snap to the supported level closest to\n * {@link ReasoningLevel.Medium}. Other requests prefer the highest allowed\n * level at or below the request, otherwise the lowest allowed level.\n *\n * Returns `undefined` when the request cannot be parsed or `levels` is empty.\n */\nexport function remapReasoning(\n  requested: unknown,\n  levels: readonly ReasoningLevel[],\n): ReasoningLevel | undefined {\n  if (levels.length === 0) return undefined;\n  if (isDisabledReasoningToken(requested)) {\n    return nearestReasoning(ReasoningLevel.Medium, levels);\n  }\n  const parsed = parseReasoning(requested);\n  if (!parsed) return undefined;\n  if (levels.includes(parsed)) return parsed;\n  const requestedIndex = REASONING_LEVELS.indexOf(parsed);\n  let best: ReasoningLevel | undefined;\n  let bestIndex = Number.NEGATIVE_INFINITY;\n  for (const level of levels) {\n    const index = REASONING_LEVELS.indexOf(level);\n    if (index <= requestedIndex && index > bestIndex) {\n      best = level;\n      bestIndex = index;\n    }\n  }\n  return best ?? levels[0];\n}\n\nfunction isDisabledReasoningToken(value: unknown): boolean {\n  if (typeof value !== \"string\" && typeof value !== \"number\" && typeof value !== \"boolean\") {\n    return false;\n  }\n  return DISABLED_REASONING_TOKENS.has(normalizeReasoningToken(String(value)));\n}\n\n/** Closest supported level to `target`; ties prefer the higher budget. */\nfunction nearestReasoning(\n  target: ReasoningLevel,\n  levels: readonly ReasoningLevel[],\n): ReasoningLevel | undefined {\n  if (levels.length === 0) return undefined;\n  if (levels.includes(target)) return target;\n  const targetIndex = REASONING_LEVELS.indexOf(target);\n  let best: ReasoningLevel | undefined;\n  let bestDistance = Number.POSITIVE_INFINITY;\n  for (const level of levels) {\n    const distance = Math.abs(REASONING_LEVELS.indexOf(level) - targetIndex);\n    if (\n      distance < bestDistance ||\n      (distance === bestDistance &&\n        REASONING_LEVELS.indexOf(level) > REASONING_LEVELS.indexOf(best ?? level))\n    ) {\n      best = level;\n      bestDistance = distance;\n    }\n  }\n  return best;\n}\n\n/** Result of adapting reasoning fields on a gateway request body. */\nexport interface AdaptedRequestReasoning {\n  /** Body with remapped wire tokens (same reference when unchanged). */\n  readonly body: Readonly<Record<string, unknown>>;\n  /** True when any reasoning field was rewritten. */\n  readonly changed: boolean;\n  /** Wire token written when a reasoning field was present and remapped. */\n  readonly wireEffort?: string;\n}\n\n/**\n * Rewrite `reasoning_effort` / `reasoning.effort` onto a supported ladder.\n *\n * Model-agnostic: callers supply the allowed levels (learned, documented, or\n * defaults). Bodies without reasoning fields are returned unchanged.\n */\nexport function adaptRequestReasoning(\n  body: Readonly<Record<string, unknown>>,\n  levels: readonly ReasoningLevel[],\n): AdaptedRequestReasoning {\n  if (levels.length === 0) return { body, changed: false };\n\n  const topLevel = body.reasoning_effort;\n  const reasoning = isRecord(body.reasoning) ? body.reasoning : undefined;\n  const nested = reasoning?.effort;\n  const requested = topLevel ?? nested;\n  if (requested === undefined) return { body, changed: false };\n\n  const remapped = remapReasoning(requested, levels);\n  if (!remapped) return { body, changed: false };\n  const wire = formatReasoning(remapped);\n\n  let changed = false;\n  let next: Record<string, unknown> = { ...body };\n\n  if (typeof topLevel === \"string\" || typeof topLevel === \"number\") {\n    if (String(topLevel) !== wire) {\n      next = { ...next, reasoning_effort: wire };\n      changed = true;\n    }\n  }\n  if (reasoning && (typeof nested === \"string\" || typeof nested === \"number\")) {\n    if (String(nested) !== wire) {\n      next = { ...next, reasoning: { ...reasoning, effort: wire } };\n      changed = true;\n    }\n  }\n\n  return changed ? { body: next, changed: true, wireEffort: wire } : { body, changed: false, wireEffort: wire };\n}\n\n/** Normalize labels for alias lookup (`Extra High` → `extra-high`). */\nexport function normalizeReasoningToken(value: string): string {\n  return (\n    stringUtils\n      .trimToNull(value)\n      ?.toLowerCase()\n      .replace(/[_\\s]+/g, \"-\")\n      .replace(/[^a-z0-9-]/g, \"\")\n      .replace(/-+/g, \"-\")\n      .replace(/^-|-$/g, \"\") ?? \"\"\n  );\n}\n\n/** Deduplicate levels while preserving first-seen order. */\nexport function uniqueReasoningLevels(levels: readonly ReasoningLevel[]): ReasoningLevel[] {\n  const seen = new Set<ReasoningLevel>();\n  const ordered: ReasoningLevel[] = [];\n  for (const level of levels) {\n    if (seen.has(level)) continue;\n    seen.add(level);\n    ordered.push(level);\n  }\n  return ordered;\n}\n\nfunction extractSupportedTokens(text: string): string[] {\n  const match = SUPPORTED_VALUES_PATTERN.exec(text);\n  if (!match?.[1]) return [];\n  return tokensFromFragment(match[1]);\n}\n\nfunction catalogueKeysFor(model: string): string[] {\n  const keys = new Set<string>();\n  const direct = modelCatalogueKey(model);\n  if (direct) keys.add(direct);\n  const stripped = model\n    .toLowerCase()\n    .replace(/^databricks\\//, \"\")\n    .replace(/^system\\.ai\\./, \"\")\n    .replace(/^databricks-/, \"\");\n  const strippedKey = modelCatalogueKey(stripped);\n  if (strippedKey) keys.add(strippedKey);\n  const withPrefix = modelCatalogueKey(`databricks-${stripped}`);\n  if (withPrefix) keys.add(withPrefix);\n  return [...keys];\n}\n\nfunction modelCatalogueKey(name: string): string | undefined {\n  const trimmed = stringUtils.trimToNull(name);\n  if (!trimmed) return undefined;\n  return (\n    modelSearchQuery(trimmed)?.replaceAll(\" \", \"-\") ??\n    trimmed\n      .toLowerCase()\n      .replace(/^databricks-/, \"\")\n      .replace(/[^a-z0-9._-]+/g, \"-\")\n  );\n}\n\nfunction tokensFromFragment(fragment: string): string[] {\n  const tokens: string[] = [];\n  for (const part of fragment.matchAll(TOKEN_PATTERN)) {\n    const token = part[1] ?? part[2] ?? part[3] ?? part[4];\n    if (!token || token === \"and\" || token === \"or\" || token === \"of\") continue;\n    tokens.push(token.replace(/^[\"'`]+|[\"'`]+$/g, \"\"));\n  }\n  return tokens;\n}\n\n/**\n * Walk a value tree, unwrapping nested JSON strings, and collect text leaves\n * that may contain a supported-values sentence.\n */\nfunction collectTextLeaves(value: unknown, depth = 0): string[] {\n  if (value == null || depth > MAX_JSON_UNWRAP_DEPTH) return [];\n  if (typeof value === \"string\") {\n    const trimmed = value.trim();\n    if (!trimmed) return [];\n    const parsed = tryUnwrapJson(trimmed);\n    if (parsed !== undefined && parsed !== trimmed) {\n      return collectTextLeaves(parsed, depth + 1);\n    }\n    return [trimmed];\n  }\n  if (typeof value === \"number\" || typeof value === \"boolean\") return [String(value)];\n  if (Array.isArray(value)) {\n    return value.flatMap((entry) => collectTextLeaves(entry, depth + 1));\n  }\n  if (!isRecord(value)) return [];\n  return Object.values(value).flatMap((entry) => collectTextLeaves(entry, depth + 1));\n}\n\nfunction tryUnwrapJson(text: string): unknown {\n  const asRecord = json.parseRecord(text);\n  if (asRecord) return asRecord;\n  const parsed = json.parse(text);\n  if (parsed !== undefined) return parsed;\n  if (text.includes('\\\\\"') || text.includes(\"\\\\n\")) {\n    const unescaped = text.replace(/\\\\\"/g, '\"').replace(/\\\\n/g, \"\\n\").replace(/\\\\\\\\/g, \"\\\\\");\n    if (unescaped !== text) {\n      const nested = json.parse(unescaped);\n      if (nested !== undefined) return nested;\n    }\n  }\n  return undefined;\n}\n"]}

package/lib/src/resolve.d.ts

@@ -3,11 +3,9 @@
  *
  * @module
  */
-import type { ModelQuery, RankedModel, ServingEndpointSummary } from "@dbx-tools/shared-model";
-import { type ResolveModelInput, type ResolvedModelSelection } from "./_selection.ts";
-import { type ResolvedModel, type ResolveModelOptions, type WorkspaceClientLike } from "./model-catalog.ts";
+import type { ModelQuery, RankedModel, ResolvedModel, ResolvedModelSelection, ResolveModelInput, ResolveModelOptions, ServingEndpointSummary } from "@dbx-tools/shared-model";
+import { type WorkspaceClientLike } from "./model-catalog.ts";
 export { lookupModels, rankModelId, resolveModel } from "./_selection.ts";
-export type { ResolveModelInput, ResolvedModelSelection } from "./_selection.ts";
 /** Intent plus catalogue cache controls passed to {@link selectModel}. */
 export interface SelectModelInput extends ResolveModelInput {
     ttlMs?: number;

package/lib/src/resolve.js

@@ -1,4 +1,4 @@
-import { lookupModels, rankModelId, resolveModel, } from "./_selection.js";
+import { lookupModels, rankModelId, resolveModel } from "./_selection.js";
 import { listServingEndpoints, } from "./model-catalog.js";
 export { lookupModels, rankModelId, resolveModel } from "./_selection.js";
 /** Resolve against a potentially stale catalogue, refreshing once on a miss. */
@@ -27,4 +27,4 @@ function catalogueOptions(input) {
         ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/serving-wire.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Framework-neutral repairs for OpenAI Chat traffic sent through Databricks
+ * Model Serving.
+ *
+ * @module
+ */
+import { type ChatMessage, type ChatRole } from "@dbx-tools/shared-model";
+/** Chat message plus provider reasoning fields emitted by Databricks models. */
+export interface ServingChatMessage extends ChatMessage {
+    role: ChatRole | "reasoning";
+    reasoning?: unknown;
+    reasoning_content?: unknown;
+}
+/** Prepared fetch arguments and the sanitized request body. */
+export interface RewrittenServingRequest {
+    input: Parameters<typeof fetch>[0];
+    init: Parameters<typeof fetch>[1];
+    body: string;
+}
+/** Sanitize a serialized Chat Completions request when provider quirks require it. */
+export declare function rewriteServingBody(body: string): string;
+/** Read and sanitize a Chat Completions request without retaining stale byte headers. */
+export declare function rewriteServingRequest(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]): Promise<RewrittenServingRequest>;
+/** Normalize Chat Completions reasoning for GPT tool calls. */
+export declare function applyToolReasoningCompatibility(body: Record<string, unknown>): boolean;
+/** Remove provider reasoning blocks that cannot be replayed safely. */
+export declare function stripReasoningFromServingMessages(messages: ServingChatMessage[]): boolean;
+/** Fold a trailing assistant prefill back into its preceding tool-call turn. */
+export declare function repairAssistantPrefill(messages: ServingChatMessage[]): boolean;
+/** Normalize array-valued content in a non-streaming Chat Completions response. */
+export declare function rewriteServingResponseBody(body: string): string;
+/** Normalize array-valued content in an SSE stream without buffering the stream. */
+export declare function rewriteServingResponseStream(body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+/** Flatten Chat Completions `choices[].message.content` arrays to strings. */
+export declare function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean;
+/** Flatten Chat Completions `choices[].delta.content` arrays to strings. */
+export declare function flattenChoiceDeltaContent(payload: Record<string, unknown>): boolean;