@dbx-tools/model 0.9.19 → 0.9.28

package/lib/src/classify.js

@@ -0,0 +1,283 @@
+/**
+ * Model-class classification for Databricks Model Serving endpoints.
+ *
+ * Chat capability bands are derived from the live workspace catalogue
+ * rather than a hand-maintained table. Databricks publishes
+ * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground
+ * bars) on the serving list; {@link classifyEndpoints} buckets scored
+ * chat models into the chat {@link ModelClass} bands by the *relative*
+ * distribution of those scores (quantiles, not fixed cut-offs) so a
+ * brand-new model that lands outside today's score range still slots in
+ * next to its peers. Embedding endpoints (`task === "llm/v1/embeddings"`)
+ * are bucketed into {@link ModelClass.Embedding} by task, independent of
+ * any score.
+ *
+ * Unscored-but-recognizable chat endpoints are still placed by a small
+ * family heuristic ({@link classifyByFamily}) so a workspace whose
+ * models predate Foundation Model API scoring keeps working. The
+ * offline fallback floor - the hard-coded model list reached for when
+ * the live catalogue can't be read at all - is a server concern and
+ * lives in `@dbx-tools/model`, not here: a browser client never talks
+ * to Databricks directly, so it has nothing to fall back to.
+ *
+ * Pure (no Node-only imports), so a client can classify a `/models`
+ * response without server dependencies.
+ *
+ * @module
+ */
+import { ModelClass as ModelClassValues, } from "@dbx-tools/shared-model/contracts";
+const ModelClass = ModelClassValues;
+/** Task hint Databricks stamps on chat completion endpoints. */
+const CHAT_TASK = "llm/v1/chat";
+/** Task hint Databricks stamps on embedding endpoints. */
+const EMBEDDING_TASK = "llm/v1/embeddings";
+/**
+ * Provider families verified against Databricks Responses/Open Responses with
+ * both a forced function call and a stateless `function_call_output` replay.
+ *
+ * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.
+ * Keep this conservative: an unknown chat family is not agent-safe until it is
+ * verified. Gemini is excluded because it emits a call but Open Responses
+ * cannot replay the required thought signature; GPT-OSS rejects Responses
+ * passthrough entirely.
+ */
+export function supportsToolsByFamily(name) {
+    const n = name.toLowerCase();
+    if (n.includes("gemini") || n.includes("gpt-oss"))
+        return false;
+    return (n.includes("claude") ||
+        n.includes("gpt") ||
+        n.includes("qwen") ||
+        n.includes("glm") ||
+        n.includes("llama"));
+}
+/**
+ * Derive an endpoint's capabilities from its Databricks task hint and its
+ * classified {@link ModelClass}, so consumers filter on capability instead of
+ * re-deriving it from raw `task` / `class` strings.
+ *
+ * Either signal alone is enough: the task hint is authoritative when present,
+ * and the class covers endpoints Databricks left untasked but the classifier
+ * recognized. Embedding wins over chat when both point at it, since the two are
+ * not interchangeable.
+ */
+export function endpointCapabilities(endpoint) {
+    const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;
+    // Every non-embedding class is a chat band, so "classified but not embedding"
+    // is the class-side test for chat capability.
+    const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);
+    const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));
+    return { chat, embedding, tools };
+}
+/**
+ * Numeric `[major, minor, patch]` version parsed from an endpoint
+ * name, used to order siblings within a family/tier. Starts at the
+ * first digit in the name, then reads successive separator-delimited,
+ * digit-prefixed chunks as the three components (missing ones default
+ * to `0`):
+ *
+ *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`
+ *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)
+ *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`
+ *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)
+ *
+ * Component-wise comparison (not a decimal collapse) so `4.10` beats
+ * `4.8` - the bug a `major + minor/10` score would hit.
+ */
+export function versionTuple(name) {
+    const start = name.search(/\d/);
+    if (start < 0)
+        return [0, 0, 0];
+    const nums = name
+        .slice(start)
+        .split(/[^a-z0-9]+/i)
+        .map((chunk) => chunk.match(/^\d+/)?.[0])
+        .filter((digits) => digits !== undefined)
+        .map(Number);
+    return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];
+}
+/** Compare two version tuples so the higher version sorts first (descending). */
+function compareVersionDesc(a, b) {
+    for (let i = 0; i < 3; i++) {
+        const diff = (b[i] ?? 0) - (a[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/**
+ * Monotonic version key for ordering siblings within a family/tier
+ * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}
+ * as a single number so callers that need a scalar rank (the family
+ * heuristic, the static fallback ordering) keep working; the encoding
+ * preserves component order without the decimal-collapse bug.
+ */
+function versionScore(name) {
+    const [major, minor, patch] = versionTuple(name);
+    return major * 1_000_000 + minor * 1_000 + patch;
+}
+/**
+ * Best-effort chat capability band for an endpoint we have no live
+ * score for, keyed off provider family and the well-known variant words
+ * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,
+ * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for
+ * names we don't recognize so unknown custom endpoints are never
+ * auto-selected as a default. The accompanying `rank` orders siblings
+ * within a class. Only ever returns a chat band - embedding endpoints
+ * are classified by task, not name.
+ */
+export function classifyByFamily(name) {
+    const n = name.toLowerCase();
+    const at = (cls) => ({ class: cls, rank: versionScore(n) });
+    // Anthropic Claude
+    if (n.includes("opus"))
+        return at(ModelClass.ChatThinking);
+    if (n.includes("sonnet"))
+        return at(ModelClass.ChatBalanced);
+    if (n.includes("haiku"))
+        return at(ModelClass.ChatFast);
+    // OpenAI open-weights (check before the generic gpt branch)
+    if (n.includes("gpt-oss")) {
+        return at(n.includes("120b") ? ModelClass.ChatBalanced : ModelClass.ChatFast);
+    }
+    // OpenAI GPT family
+    if (n.includes("gpt")) {
+        if (n.includes("pro"))
+            return at(ModelClass.ChatThinking);
+        if (n.includes("mini") || n.includes("nano"))
+            return at(ModelClass.ChatFast);
+        return at(ModelClass.ChatBalanced);
+    }
+    // Google Gemini / Gemma
+    if (n.includes("gemini")) {
+        if (n.includes("flash-lite"))
+            return at(ModelClass.ChatFast);
+        if (n.includes("pro"))
+            return at(ModelClass.ChatThinking);
+        return at(ModelClass.ChatBalanced);
+    }
+    if (n.includes("gemma"))
+        return at(ModelClass.ChatFast);
+    // Meta Llama
+    if (n.includes("llama")) {
+        if (n.includes("maverick") || n.includes("405b"))
+            return at(ModelClass.ChatThinking);
+        if (n.includes("70b"))
+            return at(ModelClass.ChatBalanced);
+        if (n.includes("8b") || n.includes("1b"))
+            return at(ModelClass.ChatFast);
+        return at(ModelClass.ChatBalanced);
+    }
+    // Alibaba Qwen
+    if (n.includes("qwen"))
+        return at(ModelClass.ChatBalanced);
+    return null;
+}
+/** Linear-interpolated quantile of an ascending-sorted numeric array. */
+function quantile(sortedAsc, p) {
+    if (sortedAsc.length === 0)
+        return Number.NaN;
+    const idx = (sortedAsc.length - 1) * p;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sortedAsc[lo];
+    return sortedAsc[lo] + (sortedAsc[hi] - sortedAsc[lo]) * (idx - lo);
+}
+function rankOrder(a, b) {
+    if (a.scored !== b.scored)
+        return a.scored ? -1 : 1;
+    if (b.sort !== a.sort)
+        return b.sort - a.sort;
+    if (a.tieCost !== b.tieCost)
+        return a.tieCost - b.tieCost;
+    if (b.tieSpeed !== a.tieSpeed)
+        return b.tieSpeed - a.tieSpeed;
+    // Same scored-ness, quality, cost, and speed (e.g. several Claude
+    // Opus point releases): prefer the newer parsed version so
+    // `opus-4-8` beats `opus-4-7`.
+    return compareVersionDesc(a.version, b.version);
+}
+/**
+ * Bucket live endpoints into {@link ModelClass}es, ranked best-first
+ * within each chat band.
+ *
+ * Embedding endpoints (`task === "llm/v1/embeddings"`) go into
+ * {@link ModelClass.Embedding} by task, in listing order (they carry no
+ * capability score to rank on).
+ *
+ * Chat endpoints (`task === "llm/v1/chat"`) split into the three chat
+ * bands. Scored endpoints (those carrying a `profile.quality`) drive
+ * the banding: the observed quality distribution is split at its 1/3
+ * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},
+ * the bottom third {@link ModelClass.ChatFast}, and the middle
+ * {@link ModelClass.ChatBalanced}. Because the thresholds come from the
+ * data, the split adapts as Databricks adds or rescores models -
+ * nothing is pinned to a fixed score band.
+ *
+ * Unscored chat endpoints are placed by {@link classifyByFamily} and
+ * ranked after the scored ones in their band; unrecognized, unscored
+ * endpoints (e.g. custom external models) are omitted entirely so they
+ * are never picked as an automatic default.
+ *
+ * Within a chat band, scored models sort by `quality` desc, then `cost`
+ * asc, then `speed` desc, then parsed name version desc; family-only
+ * models sort by version rank then parsed version. The version
+ * tie-break ({@link versionTuple}) is what separates point releases
+ * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).
+ */
+export function classifyEndpoints(endpoints) {
+    const chat = endpoints.filter((e) => e.task === CHAT_TASK);
+    const qualities = chat
+        .map((e) => e.profile?.quality)
+        .filter((q) => Number.isFinite(q))
+        .sort((a, b) => a - b);
+    const low = quantile(qualities, 1 / 3);
+    const high = quantile(qualities, 2 / 3);
+    const buckets = {
+        [ModelClass.ChatThinking]: [],
+        [ModelClass.ChatBalanced]: [],
+        [ModelClass.ChatFast]: [],
+        [ModelClass.Embedding]: [],
+    };
+    for (const ep of chat) {
+        const q = ep.profile?.quality;
+        if (Number.isFinite(q)) {
+            const quality = q;
+            const cls = quality >= high
+                ? ModelClass.ChatThinking
+                : quality <= low
+                    ? ModelClass.ChatFast
+                    : ModelClass.ChatBalanced;
+            buckets[cls].push({
+                ep,
+                sort: quality,
+                scored: true,
+                tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,
+                tieSpeed: ep.profile?.speed ?? 0,
+                version: versionTuple(ep.name),
+            });
+            continue;
+        }
+        const family = classifyByFamily(ep.name);
+        if (!family)
+            continue;
+        buckets[family.class].push({
+            ep,
+            sort: family.rank,
+            scored: false,
+            tieCost: Number.POSITIVE_INFINITY,
+            tieSpeed: 0,
+            version: versionTuple(ep.name),
+        });
+    }
+    // Embeddings are bucketed by task in listing order - no score to rank.
+    const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);
+    return {
+        [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.Embedding]: embeddings,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,UAAU,IAAI,gBAAgB,GAG/B,MAAM,mCAAmC,CAAC;AAG3C,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAEpC,gEAAgE;AAChE,MAAM,SAAS,GAAG,aAAa,CAAC;AAEhC,0DAA0D;AAC1D,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAY3C;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC7B,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IAChE,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACpB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QAClB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CACpB,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgC;IACnE,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,KAAK,cAAc,IAAI,QAAQ,CAAC,KAAK,KAAK,UAAU,CAAC,SAAS,CAAC;IAC9F,8EAA8E;IAC9E,8CAA8C;IAC9C,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;IACzF,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,IAAI,qBAAqB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACvF,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AACpC,CAAC;AAUD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,IAAI;SACd,KAAK,CAAC,KAAK,CAAC;SACZ,KAAK,CAAC,aAAa,CAAC;SACpB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACxC,MAAM,CAAC,CAAC,MAAM,EAAoB,EAAE,CAAC,MAAM,KAAK,SAAS,CAAC;SAC1D,GAAG,CAAC,MAAM,CAAC,CAAC;IACf,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,iFAAiF;AACjF,SAAS,kBAAkB,CAAC,CAAoB,EAAE,CAAoB;IACpE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACvC,IAAI,IAAI,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;IAC9B,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,IAAY;IAChC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACjD,OAAO,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AACnD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC7B,MAAM,EAAE,GAAG,CAAC,GAAe,EAAe,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAErF,mBAAmB;IACnB,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC3D,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC7D,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAExD,4DAA4D;IAC5D,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAChF,CAAC;IACD,oBAAoB;IACpB,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACtB,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAC1D,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC7E,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IAED,wBAAwB;IACxB,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,IAAI,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAC1D,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IACD,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAExD,aAAa;IACb,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QACrF,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAC1D,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QACzE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IAED,eAAe;IACf,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAE3D,OAAO,IAAI,CAAC;AACd,CAAC;AAED,yEAAyE;AACzE,SAAS,QAAQ,CAAC,SAA4B,EAAE,CAAS;IACvD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC,GAAG,CAAC;IAC9C,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACvC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC,EAAE,CAAE,CAAC;IACrC,OAAO,SAAS,CAAC,EAAE,CAAE,GAAG,CAAC,SAAS,CAAC,EAAE,CAAE,GAAG,SAAS,CAAC,EAAE,CAAE,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC;AACzE,CAAC;AAeD,SAAS,SAAS,CAAC,CAAS,EAAE,CAAS;IACrC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;IAC9C,IAAI,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO;QAAE,OAAO,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC;IAC1D,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;IAC9D,kEAAkE;IAClE,2DAA2D;IAC3D,+BAA+B;IAC/B,OAAO,kBAAkB,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAA4C;IAE5C,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAC3D,MAAM,SAAS,GAAG,IAAI;SACnB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC;SAC9B,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;SAC9C,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,MAAM,GAAG,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAExC,MAAM,OAAO,GAAiC;QAC5C,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE;QAC7B,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE;QAC7B,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,EAAE;QACzB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,EAAE;KAC3B,CAAC;IAEF,KAAK,MAAM,EAAE,IAAI,IAAI,EAAE,CAAC;QACtB,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;QAC9B,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACvB,MAAM,OAAO,GAAG,CAAW,CAAC;YAC5B,MAAM,GAAG,GACP,OAAO,IAAI,IAAI;gBACb,CAAC,CAAC,UAAU,CAAC,YAAY;gBACzB,CAAC,CAAC,OAAO,IAAI,GAAG;oBACd,CAAC,CAAC,UAAU,CAAC,QAAQ;oBACrB,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC;YAChC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;gBAChB,EAAE;gBACF,IAAI,EAAE,OAAO;gBACb,MAAM,EAAE,IAAI;gBACZ,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,IAAI,IAAI,MAAM,CAAC,iBAAiB;gBACrD,QAAQ,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC;gBAChC,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC;aAC/B,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,MAAM,MAAM,GAAG,gBAAgB,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC,MAAM;YAAE,SAAS;QACtB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YACzB,EAAE;YACF,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,MAAM,EAAE,KAAK;YACb,OAAO,EAAE,MAAM,CAAC,iBAAiB;YACjC,QAAQ,EAAE,CAAC;YACX,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,uEAAuE;IACvE,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,cAAc,CAAC,CAAC;IAEtE,OAAO;QACL,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5F,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5F,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpF,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU;KACnC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport {\n  ModelClass as ModelClassValues,\n  type ModelClass as ModelClassType,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\n\ntype ModelClass = ModelClassType;\nconst ModelClass = ModelClassValues;\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */\nexport interface EndpointCapabilities {\n  /** OpenAI chat/completions + Responses: the surface a chat agent needs. */\n  chat: boolean;\n  /** Embedding (vector) endpoint. */\n  embedding: boolean;\n  /** Complete function-tool round-trip (call plus function_call_output replay). */\n  tools: boolean;\n}\n\n/**\n * Provider families verified against Databricks Responses/Open Responses with\n * both a forced function call and a stateless `function_call_output` replay.\n *\n * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.\n * Keep this conservative: an unknown chat family is not agent-safe until it is\n * verified. Gemini is excluded because it emits a call but Open Responses\n * cannot replay the required thought signature; GPT-OSS rejects Responses\n * passthrough entirely.\n */\nexport function supportsToolsByFamily(name: string): boolean {\n  const n = name.toLowerCase();\n  if (n.includes(\"gemini\") || n.includes(\"gpt-oss\")) return false;\n  return (\n    n.includes(\"claude\") ||\n    n.includes(\"gpt\") ||\n    n.includes(\"qwen\") ||\n    n.includes(\"glm\") ||\n    n.includes(\"llama\")\n  );\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));\n  return { chat, embedding, tools };\n}\n\n/** Family-heuristic classification of a single endpoint name. */\nexport interface FamilyClass {\n  /** Chat capability band the family maps to (never embedding). */\n  class: ModelClass;\n  /** Intra-family ordering hint (higher is newer / more capable). */\n  rank: number;\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  for (let i = 0; i < 3; i++) {\n    const diff = (b[i] ?? 0) - (a[i] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}

package/lib/src/fallback.d.ts

@@ -5,7 +5,7 @@
  * token, the service principal can't list, or the workspace is unreachable -
  * the resolver still has to name *some* endpoint. This module holds that floor:
  * a small, hard-coded set of well-known Foundation Model API endpoint names,
- * each bucketed into a chat {@link ModelClass} by the Rust family policy
+ * each bucketed into a chat {@link ModelClass} by the TypeScript family policy
  * and ordered best-first.
  *
  * This is deliberately *server-only*. A browser client never talks to
@@ -15,8 +15,8 @@
  *
  * @module
  */
-import { model } from "@dbx-tools/shared-model";
-type ModelClass = model.ModelClass;
+import { type ModelClass as ModelClassType } from "@dbx-tools/shared-model/contracts";
+type ModelClass = ModelClassType;
 declare const ModelClass: {
     readonly ChatThinking: "chat-thinking";
     readonly ChatBalanced: "chat-balanced";
@@ -28,7 +28,7 @@ declare const ModelClass: {
  * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
  * and workspace-independent: this is the *fallback opinion* used to seed default
  * lists or when the live catalogue is unreachable - live resolution prefers
- * the Rust-classified workspace catalogue. Returns `[]` for
+ * the classified workspace catalogue. Returns `[]` for
  * {@link ModelClass.Embedding} (the floor is chat-only).
  */
 export declare function modelsForClass(cls: ModelClass): readonly string[];

package/lib/src/fallback.js

@@ -5,7 +5,7 @@
  * token, the service principal can't list, or the workspace is unreachable -
  * the resolver still has to name *some* endpoint. This module holds that floor:
  * a small, hard-coded set of well-known Foundation Model API endpoint names,
- * each bucketed into a chat {@link ModelClass} by the Rust family policy
+ * each bucketed into a chat {@link ModelClass} by the TypeScript family policy
  * and ordered best-first.
  *
  * This is deliberately *server-only*. A browser client never talks to
@@ -15,12 +15,12 @@
  *
  * @module
  */
-import { model } from "@dbx-tools/shared-model";
-import { rankEndpoints } from "./_native.js";
-const { ModelClass } = model;
+import { ModelClass as ModelClassValues, } from "@dbx-tools/shared-model/contracts";
+import { rankEndpoints } from "./_ranking.js";
+const ModelClass = ModelClassValues;
 /**
  * Small, last-resort set of well-known Foundation Model API endpoint names,
- * ordered best-first within each class by the Rust model ranker.
+ * ordered best-first within each class by the model ranker.
  * Used only as the floor when the live `/serving-endpoints` catalogue can't be
  * read at resolve time; the live, score-driven classification supersedes it
  * whenever the workspace listing is available. Classes are not hard-coded here
@@ -46,7 +46,7 @@ const FALLBACK_ENDPOINTS = FALLBACK_MODEL_NAMES.map((name) => ({
  * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
  * and workspace-independent: this is the *fallback opinion* used to seed default
  * lists or when the live catalogue is unreachable - live resolution prefers
- * the Rust-classified workspace catalogue. Returns `[]` for
+ * the classified workspace catalogue. Returns `[]` for
  * {@link ModelClass.Embedding} (the floor is chat-only).
  */
 export function modelsForClass(cls) {
@@ -68,4 +68,4 @@ export const FALLBACK_MODEL_IDS = [
     ...modelsForClass(ModelClass.ChatBalanced),
     ...modelsForClass(ModelClass.ChatFast),
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/generated/model-capabilities.json

@@ -0,0 +1,90 @@
+{
+    "generatedAt": 1791150180,
+    "capabilities": {
+        "responses": [
+            "gpt-5",
+            "gpt-5-1",
+            "gpt-5-2",
+            "gpt-5-3-codex",
+            "gpt-5-4",
+            "gpt-5-4-mini",
+            "gpt-5-4-nano",
+            "gpt-5-5",
+            "gpt-5-5-pro",
+            "gpt-5-6-luna",
+            "gpt-5-6-sol",
+            "gpt-5-6-terra",
+            "gpt-5-mini",
+            "gpt-5-nano",
+            "gpt-6-1-sol",
+            "gpt-6-astra",
+            "gpt-6-luna",
+            "gpt-6-sol"
+        ],
+        "imageInput": [
+            "gpt-5",
+            "gpt-5-1",
+            "gpt-5-2",
+            "gpt-5-3-codex",
+            "gpt-5-4",
+            "gpt-5-4-mini",
+            "gpt-5-4-nano",
+            "gpt-5-5",
+            "gpt-5-5-pro",
+            "gpt-5-6-luna",
+            "gpt-5-6-sol",
+            "gpt-5-6-terra",
+            "gpt-5-mini",
+            "gpt-5-nano",
+            "gpt-6-1-sol",
+            "gpt-6-astra",
+            "gpt-6-luna",
+            "gpt-6-sol"
+        ],
+        "applyPatch": [
+            "gpt-5",
+            "gpt-5-1",
+            "gpt-5-2",
+            "gpt-5-3-codex",
+            "gpt-5-4",
+            "gpt-5-4-mini",
+            "gpt-5-4-nano",
+            "gpt-5-5",
+            "gpt-5-5-pro",
+            "gpt-5-6-luna",
+            "gpt-5-6-sol",
+            "gpt-5-6-terra",
+            "gpt-5-mini",
+            "gpt-5-nano",
+            "gpt-6-1-sol",
+            "gpt-6-astra",
+            "gpt-6-luna",
+            "gpt-6-sol"
+        ],
+        "webSearch": [
+            "gemini-2-5-flash",
+            "gemini-2-5-pro",
+            "gemini-3-1-flash-lite",
+            "gemini-3-1-pro",
+            "gemini-3-flash",
+            "gpt-5",
+            "gpt-5-1",
+            "gpt-5-2",
+            "gpt-5-3-codex",
+            "gpt-5-4",
+            "gpt-5-4-mini",
+            "gpt-5-4-nano",
+            "gpt-5-5",
+            "gpt-5-5-pro",
+            "gpt-5-6-luna",
+            "gpt-5-6-sol",
+            "gpt-5-6-terra",
+            "gpt-5-mini",
+            "gpt-5-nano",
+            "gpt-6-1-sol",
+            "gpt-6-astra",
+            "gpt-6-luna",
+            "gpt-6-sol"
+        ]
+    }
+}