@dbx-tools/model 0.9.21 → 0.9.28

package/lib/src/_ranking.js

@@ -0,0 +1,226 @@
+import { ModelClass as ModelClassValues, } from "@dbx-tools/shared-model/contracts";
+import { toModelDisplayName } from "@dbx-tools/shared-model/display";
+import Fuse from "fuse.js";
+import { classesAtOrBelow, CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./classes.js";
+import { classifyEndpoints, endpointCapabilities, supportsToolsByFamily, versionTuple, } from "./classify.js";
+import { modelStatusFor } from "./metadata.js";
+import { modelFamily, modelReasoningEfforts, modelServiceNames } from "./policy.js";
+const ModelClass = ModelClassValues;
+const DEFAULT_FUZZY_THRESHOLD = 0.4;
+/** Rank endpoint records through the TypeScript-owned model policy. */
+export function rankEndpoints(endpoints, query = {}, options = {}) {
+    const originalByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));
+    const normalized = endpoints.map((endpoint) => ({
+        ...endpoint,
+        ...(options.modelClass ? { class: options.modelClass } : {}),
+        ...(options.task ? { task: options.task } : {}),
+    }));
+    const classified = options.modelClass
+        ? {
+            [ModelClass.ChatThinking]: [],
+            [ModelClass.ChatBalanced]: [],
+            [ModelClass.ChatFast]: [],
+            [ModelClass.Embedding]: [],
+            [options.modelClass]: normalized,
+        }
+        : classifyEndpoints(normalized);
+    const requestedClass = options.modelClass ?? query.modelClass;
+    const eligible = requestedClass ? classesAtOrBelow(requestedClass) : CHAT_CLASS_ORDER;
+    const candidates = [];
+    for (const modelClass of eligible) {
+        for (const endpoint of classified[modelClass]) {
+            if (!options.includeDeprecated && endpoint.status?.deprecated)
+                continue;
+            if (query.requiresTools && !endpointCapabilities(endpoint).tools)
+                continue;
+            candidates.push({ endpoint, modelClass });
+        }
+    }
+    const search = query.search?.trim();
+    let ranked = candidates;
+    if (search) {
+        const exact = candidates.find((candidate) => candidate.endpoint.name === search);
+        if (exact) {
+            ranked = [{ ...exact, score: 0 }];
+        }
+        else {
+            const threshold = query.threshold ?? DEFAULT_FUZZY_THRESHOLD;
+            const searchTokens = tokenize(search);
+            const tokenMatches = candidates
+                .filter((candidate) => {
+                const candidateTokens = new Set(searchableValues(candidate.endpoint).flatMap(tokenize));
+                return (searchTokens.length > 0 && searchTokens.every((token) => candidateTokens.has(token)));
+            })
+                .map((candidate) => ({ ...candidate, score: 0 }));
+            if (tokenMatches.length > 0) {
+                ranked = tokenMatches.sort(compareRanked);
+            }
+            else {
+                const fuse = new Fuse(candidates, {
+                    keys: [
+                        "endpoint.name",
+                        "endpoint.displayName",
+                        "endpoint.family",
+                        "endpoint.modelServiceName",
+                        "endpoint.serviceNames",
+                    ],
+                    threshold,
+                    ignoreLocation: true,
+                    includeScore: true,
+                    useExtendedSearch: true,
+                    isCaseSensitive: false,
+                });
+                const normalizedSearch = tokenize(search).join(" ");
+                ranked = normalizedSearch
+                    ? fuse
+                        .search(normalizedSearch)
+                        .filter((result) => (result.score ?? 0) <= threshold)
+                        .map((result) => ({ ...result.item, score: result.score ?? 0 }))
+                        .sort(compareRanked)
+                    : [];
+            }
+        }
+    }
+    const restored = ranked.map((result) => ({
+        ...result,
+        endpoint: originalByName.get(result.endpoint.name) ?? result.endpoint,
+    }));
+    return query.limit === undefined ? restored : restored.slice(0, Math.max(0, query.limit));
+}
+/** Classify chat and embedding endpoints through the TypeScript-owned policy. */
+export function classifyEndpointClasses(endpoints) {
+    const classified = classifyEndpoints(endpoints);
+    const result = new Map();
+    for (const modelClass of MODEL_CLASS_ORDER) {
+        for (const endpoint of classified[modelClass])
+            result.set(endpoint.name, modelClass);
+    }
+    return result;
+}
+/** Normalize serialized SDK endpoint records without native bindings. */
+export function normalizeEndpoints(endpoints) {
+    const summaries = endpoints.flatMap((value) => {
+        const endpoint = record(value);
+        const name = stringValue(endpoint.name);
+        if (!name)
+            return [];
+        const entities = arrayValue(record(endpoint.config).served_entities).map(record);
+        const identities = [
+            name,
+            ...entities.flatMap((entity) => [
+                stringValue(entity.entity_name),
+                stringValue(record(entity.foundation_model).name),
+                stringValue(record(entity.external_model).name),
+            ].filter((identity) => Boolean(identity))),
+        ];
+        const modelServiceName = entities
+            .map((entity) => stringValue(record(entity.foundation_model).name) ?? stringValue(entity.entity_name))
+            .find(Boolean);
+        const family = identities.map(modelFamily).find(Boolean);
+        const reasoningEfforts = identities.map(modelReasoningEfforts).sort((left, right) => right.length - left.length)[0] ??
+            [];
+        const profile = entities.map(modelProfile).find(Boolean);
+        const summary = {
+            name,
+            displayName: toModelDisplayName(name, providedDisplayName(endpoint, entities)),
+            ...(family ? { family } : {}),
+            ...(stringValue(endpoint.task) ? { task: stringValue(endpoint.task) } : {}),
+            ...(stringValue(record(endpoint.state).ready)
+                ? { state: stringValue(record(endpoint.state).ready) }
+                : {}),
+            ...(stringValue(endpoint.description)
+                ? { description: stringValue(endpoint.description) }
+                : {}),
+            supportsTools: identities.some(supportsToolsByFamily),
+            ...(profile ? { profile } : {}),
+            serviceNames: Object.assign({}, ...identities.map(modelServiceNames)),
+            ...(modelServiceName ? { modelServiceName } : {}),
+            ...(reasoningEfforts.length ? { reasoningEfforts } : {}),
+            status: modelStatusFor(...identities),
+        };
+        return [summary];
+    });
+    const classes = classifyEndpointClasses(summaries);
+    return summaries.map((summary) => {
+        const modelClass = classes.get(summary.name);
+        return modelClass ? { ...summary, class: modelClass } : summary;
+    });
+}
+function compareRanked(left, right) {
+    const score = Math.round((left.score ?? 0) * 1000) - Math.round((right.score ?? 0) * 1000);
+    if (score !== 0)
+        return score;
+    const leftVersion = versionTuple(left.endpoint.name);
+    const rightVersion = versionTuple(right.endpoint.name);
+    for (let index = 0; index < 3; index += 1) {
+        const version = rightVersion[index] - leftVersion[index];
+        if (version !== 0)
+            return version;
+    }
+    const variant = modelVariantRank(left.endpoint.name) - modelVariantRank(right.endpoint.name);
+    if (variant !== 0)
+        return variant;
+    return MODEL_CLASS_ORDER.indexOf(left.modelClass) - MODEL_CLASS_ORDER.indexOf(right.modelClass);
+}
+function modelVariantRank(name) {
+    if (!/(?:^|[-_.])gpt(?:[-_.]|$)/i.test(name))
+        return 2;
+    if (/(?:^|[-_.])sol(?:[-_.]|$)/i.test(name))
+        return 0;
+    if (/(?:^|[-_.])luna(?:[-_.]|$)/i.test(name))
+        return 1;
+    return 2;
+}
+function tokenize(value) {
+    return value.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+function searchableValues(endpoint) {
+    return [
+        endpoint.name,
+        endpoint.displayName,
+        endpoint.family,
+        endpoint.modelServiceName,
+        ...Object.values(endpoint.serviceNames ?? {}),
+    ].filter((value) => Boolean(value));
+}
+function modelProfile(entity) {
+    const source = record(record(entity.foundation_model).ai_gateway_model_profile);
+    const quality = finiteNumber(source.quality);
+    const speed = finiteNumber(source.speed);
+    const cost = finiteNumber(source.cost);
+    if (quality === undefined && speed === undefined && cost === undefined)
+        return undefined;
+    return {
+        ...(quality !== undefined ? { quality } : {}),
+        ...(speed !== undefined ? { speed } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+    };
+}
+function providedDisplayName(endpoint, entities) {
+    for (const tag of arrayValue(endpoint.tags).map(record)) {
+        if (!["display_name", "displayName", "name"].includes(String(tag.key)))
+            continue;
+        const value = stringValue(tag.value);
+        if (value)
+            return value;
+    }
+    return entities.map((entity) => stringValue(record(entity.external_model).name)).find(Boolean);
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_ranking.js","sourceRoot":"","sources":["../../src/_ranking.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ModelClass as ModelClassValues,\n  type ModelClass as ModelClassType,\n  type ModelQuery,\n  type RankedModel,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\nimport { toModelDisplayName } from \"@dbx-tools/shared-model/display\";\nimport Fuse from \"fuse.js\";\n\nimport { classesAtOrBelow, CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from \"./classes.ts\";\nimport {\n  classifyEndpoints,\n  endpointCapabilities,\n  supportsToolsByFamily,\n  versionTuple,\n} from \"./classify.ts\";\nimport { modelStatusFor } from \"./metadata.ts\";\nimport { modelFamily, modelReasoningEfforts, modelServiceNames } from \"./policy.ts\";\n\ntype ModelClass = ModelClassType;\nconst ModelClass = ModelClassValues;\n\nconst DEFAULT_FUZZY_THRESHOLD = 0.4;\ninterface NativeRankingOptions {\n  readonly includeDeprecated?: boolean;\n  readonly modelClass?: ModelClass;\n  readonly task?: string;\n}\n\n/** Rank endpoint records through the TypeScript-owned model policy. */\nexport function rankEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n  query: ModelQuery = {},\n  options: NativeRankingOptions = {},\n): RankedModel[] {\n  const originalByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));\n  const normalized = endpoints.map((endpoint) => ({\n    ...endpoint,\n    ...(options.modelClass ? { class: options.modelClass } : {}),\n    ...(options.task ? { task: options.task } : {}),\n  }));\n  const classified = options.modelClass\n    ? {\n        [ModelClass.ChatThinking]: [],\n        [ModelClass.ChatBalanced]: [],\n        [ModelClass.ChatFast]: [],\n        [ModelClass.Embedding]: [],\n        [options.modelClass]: normalized,\n      }\n    : classifyEndpoints(normalized);\n  const requestedClass = options.modelClass ?? query.modelClass;\n  const eligible = requestedClass ? classesAtOrBelow(requestedClass) : CHAT_CLASS_ORDER;\n  const candidates: RankedModel[] = [];\n  for (const modelClass of eligible) {\n    for (const endpoint of classified[modelClass]) {\n      if (!options.includeDeprecated && endpoint.status?.deprecated) continue;\n      if (query.requiresTools && !endpointCapabilities(endpoint).tools) continue;\n      candidates.push({ endpoint, modelClass });\n    }\n  }\n\n  const search = query.search?.trim();\n  let ranked = candidates;\n  if (search) {\n    const exact = candidates.find((candidate) => candidate.endpoint.name === search);\n    if (exact) {\n      ranked = [{ ...exact, score: 0 }];\n    } else {\n      const threshold = query.threshold ?? DEFAULT_FUZZY_THRESHOLD;\n      const searchTokens = tokenize(search);\n      const tokenMatches = candidates\n        .filter((candidate) => {\n          const candidateTokens = new Set(searchableValues(candidate.endpoint).flatMap(tokenize));\n          return (\n            searchTokens.length > 0 && searchTokens.every((token) => candidateTokens.has(token))\n          );\n        })\n        .map((candidate) => ({ ...candidate, score: 0 }));\n      if (tokenMatches.length > 0) {\n        ranked = tokenMatches.sort(compareRanked);\n      } else {\n        const fuse = new Fuse(candidates, {\n          keys: [\n            \"endpoint.name\",\n            \"endpoint.displayName\",\n            \"endpoint.family\",\n            \"endpoint.modelServiceName\",\n            \"endpoint.serviceNames\",\n          ],\n          threshold,\n          ignoreLocation: true,\n          includeScore: true,\n          useExtendedSearch: true,\n          isCaseSensitive: false,\n        });\n        const normalizedSearch = tokenize(search).join(\" \");\n        ranked = normalizedSearch\n          ? fuse\n              .search(normalizedSearch)\n              .filter((result) => (result.score ?? 0) <= threshold)\n              .map((result) => ({ ...result.item, score: result.score ?? 0 }))\n              .sort(compareRanked)\n          : [];\n      }\n    }\n  }\n  const restored = ranked.map((result) => ({\n    ...result,\n    endpoint: originalByName.get(result.endpoint.name) ?? result.endpoint,\n  }));\n  return query.limit === undefined ? restored : restored.slice(0, Math.max(0, query.limit));\n}\n\n/** Classify chat and embedding endpoints through the TypeScript-owned policy. */\nexport function classifyEndpointClasses(\n  endpoints: readonly ServingEndpointSummary[],\n): ReadonlyMap<string, ModelClass> {\n  const classified = classifyEndpoints(endpoints);\n  const result = new Map<string, ModelClass>();\n  for (const modelClass of MODEL_CLASS_ORDER) {\n    for (const endpoint of classified[modelClass]) result.set(endpoint.name, modelClass);\n  }\n  return result;\n}\n\n/** Normalize serialized SDK endpoint records without native bindings. */\nexport function normalizeEndpoints(endpoints: readonly unknown[]): ServingEndpointSummary[] {\n  const summaries = endpoints.flatMap((value) => {\n    const endpoint = record(value);\n    const name = stringValue(endpoint.name);\n    if (!name) return [];\n    const entities = arrayValue(record(endpoint.config).served_entities).map(record);\n    const identities = [\n      name,\n      ...entities.flatMap((entity) =>\n        [\n          stringValue(entity.entity_name),\n          stringValue(record(entity.foundation_model).name),\n          stringValue(record(entity.external_model).name),\n        ].filter((identity): identity is string => Boolean(identity)),\n      ),\n    ];\n    const modelServiceName = entities\n      .map(\n        (entity) =>\n          stringValue(record(entity.foundation_model).name) ?? stringValue(entity.entity_name),\n      )\n      .find(Boolean);\n    const family = identities.map(modelFamily).find(Boolean);\n    const reasoningEfforts =\n      identities.map(modelReasoningEfforts).sort((left, right) => right.length - left.length)[0] ??\n      [];\n    const profile = entities.map(modelProfile).find(Boolean);\n    const summary: ServingEndpointSummary = {\n      name,\n      displayName: toModelDisplayName(name, providedDisplayName(endpoint, entities)),\n      ...(family ? { family } : {}),\n      ...(stringValue(endpoint.task) ? { task: stringValue(endpoint.task) } : {}),\n      ...(stringValue(record(endpoint.state).ready)\n        ? { state: stringValue(record(endpoint.state).ready) }\n        : {}),\n      ...(stringValue(endpoint.description)\n        ? { description: stringValue(endpoint.description) }\n        : {}),\n      supportsTools: identities.some(supportsToolsByFamily),\n      ...(profile ? { profile } : {}),\n      serviceNames: Object.assign({}, ...identities.map(modelServiceNames)),\n      ...(modelServiceName ? { modelServiceName } : {}),\n      ...(reasoningEfforts.length ? { reasoningEfforts } : {}),\n      status: modelStatusFor(...identities),\n    };\n    return [summary];\n  });\n  const classes = classifyEndpointClasses(summaries);\n  return summaries.map((summary) => {\n    const modelClass = classes.get(summary.name);\n    return modelClass ? { ...summary, class: modelClass } : summary;\n  });\n}\n\nfunction compareRanked(left: RankedModel, right: RankedModel): number {\n  const score = Math.round((left.score ?? 0) * 1000) - Math.round((right.score ?? 0) * 1000);\n  if (score !== 0) return score;\n  const leftVersion = versionTuple(left.endpoint.name);\n  const rightVersion = versionTuple(right.endpoint.name);\n  for (let index = 0; index < 3; index += 1) {\n    const version = rightVersion[index]! - leftVersion[index]!;\n    if (version !== 0) return version;\n  }\n  const variant = modelVariantRank(left.endpoint.name) - modelVariantRank(right.endpoint.name);\n  if (variant !== 0) return variant;\n  return MODEL_CLASS_ORDER.indexOf(left.modelClass) - MODEL_CLASS_ORDER.indexOf(right.modelClass);\n}\n\nfunction modelVariantRank(name: string): number {\n  if (!/(?:^|[-_.])gpt(?:[-_.]|$)/i.test(name)) return 2;\n  if (/(?:^|[-_.])sol(?:[-_.]|$)/i.test(name)) return 0;\n  if (/(?:^|[-_.])luna(?:[-_.]|$)/i.test(name)) return 1;\n  return 2;\n}\n\nfunction tokenize(value: string): string[] {\n  return value.toLowerCase().match(/[a-z0-9]+/g) ?? [];\n}\n\nfunction searchableValues(endpoint: ServingEndpointSummary): string[] {\n  return [\n    endpoint.name,\n    endpoint.displayName,\n    endpoint.family,\n    endpoint.modelServiceName,\n    ...Object.values(endpoint.serviceNames ?? {}),\n  ].filter((value): value is string => Boolean(value));\n}\n\nfunction modelProfile(entity: Record<string, unknown>) {\n  const source = record(record(entity.foundation_model).ai_gateway_model_profile);\n  const quality = finiteNumber(source.quality);\n  const speed = finiteNumber(source.speed);\n  const cost = finiteNumber(source.cost);\n  if (quality === undefined && speed === undefined && cost === undefined) return undefined;\n  return {\n    ...(quality !== undefined ? { quality } : {}),\n    ...(speed !== undefined ? { speed } : {}),\n    ...(cost !== undefined ? { cost } : {}),\n  };\n}\n\nfunction providedDisplayName(\n  endpoint: Record<string, unknown>,\n  entities: readonly Record<string, unknown>[],\n): string | undefined {\n  for (const tag of arrayValue(endpoint.tags).map(record)) {\n    if (![\"display_name\", \"displayName\", \"name\"].includes(String(tag.key))) continue;\n    const value = stringValue(tag.value);\n    if (value) return value;\n  }\n  return entities.map((entity) => stringValue(record(entity.external_model).name)).find(Boolean);\n}\n\nfunction record(value: unknown): Record<string, unknown> {\n  return value && typeof value === \"object\" && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : {};\n}\n\nfunction arrayValue(value: unknown): unknown[] {\n  return Array.isArray(value) ? value : [];\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  return trimmed || undefined;\n}\n\nfunction finiteNumber(value: unknown): number | undefined {\n  return typeof value === \"number\" && Number.isFinite(value) ? value : undefined;\n}\n"]}

package/lib/src/_selection.d.ts

@@ -0,0 +1,23 @@
+import type { ModelClass, ModelQuery, RankedModel, ServingEndpointSummary } from "@dbx-tools/shared-model/contracts";
+import type { ResolvedModel, ResolveModelOptions } from "./model-catalog.ts";
+/** Caller intent passed to {@link resolveModel}. */
+export interface ResolveModelInput {
+    explicit?: string;
+    fuzzy?: boolean;
+    threshold?: number;
+    requiresTools?: boolean;
+    modelClass?: ModelClass;
+    fallbacks?: readonly string[];
+    liveOnly?: boolean;
+}
+/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
+export interface ResolvedModelSelection {
+    modelId: string;
+    source: "explicit" | "fuzzy-match" | "class" | "fallback";
+}
+/** Rank a catalogue against a model query, best-first. */
+export declare function lookupModels(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery): RankedModel[];
+/** Resolve the closest model id in one catalogue snapshot. */
+export declare function rankModelId(endpoints: readonly ServingEndpointSummary[], search: string, options?: ResolveModelOptions): ResolvedModel;
+/** Resolve a single model id from a catalogue and caller intent. */
+export declare function resolveModel(endpoints: readonly ServingEndpointSummary[], input?: ResolveModelInput): ResolvedModelSelection;

package/lib/src/_selection.js

@@ -0,0 +1,95 @@
+/**
+ * Runtime-independent model ranking and selection.
+ *
+ * @module
+ */
+import * as object from "@dbx-tools/shared-core/object";
+import { rankEndpoints } from "./_ranking.js";
+import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.js";
+import { endpointSupportsTools } from "./policy.js";
+const DEFAULT_MODEL_FAMILY_SEARCH = "gpt";
+/** Rank a catalogue against a model query, best-first. */
+export function lookupModels(endpoints, query = {}) {
+    return rankEndpoints(endpoints, query);
+}
+/** Resolve the closest model id in one catalogue snapshot. */
+export function rankModelId(endpoints, search, options = {}) {
+    const [top] = lookupModels(endpoints, {
+        search,
+        limit: 1,
+        ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),
+        ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),
+    });
+    if (!top)
+        return { modelId: search, matched: false };
+    return { modelId: top.endpoint.name, matched: true, score: top.score };
+}
+/** Resolve a single model id from a catalogue and caller intent. */
+export function resolveModel(endpoints, input = {}) {
+    if (input.explicit !== undefined) {
+        if (input.fuzzy === false) {
+            if (input.requiresTools)
+                assertToolSupport(endpoints, input.explicit);
+            return { modelId: input.explicit, source: "explicit" };
+        }
+        const [top] = lookupModels(endpoints, buildQuery(input, input.explicit));
+        if (input.requiresTools && !top) {
+            throw new Error(`No tool-capable model matches "${input.explicit}"`);
+        }
+        return { modelId: top?.endpoint.name ?? input.explicit, source: "fuzzy-match" };
+    }
+    if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {
+        const present = new Set(endpoints
+            .filter((endpoint) => !input.requiresTools || endpointSupportsTools(endpoint))
+            .map((endpoint) => endpoint.name));
+        const pinned = input.fallbacks.find((id) => present.has(id));
+        if (pinned)
+            return { modelId: pinned, source: "fallback" };
+    }
+    const source = input.modelClass !== undefined ? "class" : "fallback";
+    if (input.modelClass === undefined) {
+        const [preferred] = lookupModels(endpoints, buildQuery(input, DEFAULT_MODEL_FAMILY_SEARCH));
+        if (preferred)
+            return { modelId: preferred.endpoint.name, source };
+    }
+    const [top] = lookupModels(endpoints, buildQuery(input, undefined));
+    if (top)
+        return { modelId: top.endpoint.name, source };
+    if (input.liveOnly) {
+        throw new Error("No matching live Model Serving endpoint is available");
+    }
+    const floorSource = input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);
+    const floor = object.sequence(floorSource).concat(FALLBACK_MODEL_IDS).distinct().toArray();
+    if (input.requiresTools) {
+        const available = new Set(endpoints.filter(endpointSupportsTools).map((endpoint) => endpoint.name));
+        const selected = floor.find((id) => available.has(id));
+        if (!selected)
+            throw new Error("No tool-capable model is available");
+        return { modelId: selected, source };
+    }
+    return { modelId: pickFirstAvailable(floor, endpoints), source };
+}
+function buildQuery(input, search) {
+    return {
+        ...(search !== undefined ? { search } : {}),
+        ...(input.modelClass !== undefined ? { modelClass: input.modelClass } : {}),
+        ...(input.requiresTools !== undefined ? { requiresTools: input.requiresTools } : {}),
+        ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),
+        limit: 1,
+    };
+}
+function assertToolSupport(endpoints, modelId) {
+    const endpoint = endpoints.find((candidate) => candidate.name === modelId);
+    if (!endpoint || !endpointSupportsTools(endpoint)) {
+        throw new Error(`Model "${modelId}" does not support function tools`);
+    }
+}
+function pickFirstAvailable(candidates, endpoints) {
+    const present = new Set(endpoints.map((endpoint) => endpoint.name));
+    for (const candidate of candidates) {
+        if (present.has(candidate))
+            return candidate;
+    }
+    return candidates[0] ?? FALLBACK_MODEL_IDS[0];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_selection.js","sourceRoot":"","sources":["../../src/_selection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Runtime-independent model ranking and selection.\n *\n * @module\n */\nimport * as object from \"@dbx-tools/shared-core/object\";\nimport type {\n  ModelClass,\n  ModelQuery,\n  RankedModel,\n  ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\n\nimport { rankEndpoints } from \"./_ranking.ts\";\nimport { FALLBACK_MODEL_IDS, modelsForClass } from \"./fallback.ts\";\nimport type { ResolvedModel, ResolveModelOptions } from \"./model-catalog.ts\";\nimport { endpointSupportsTools } from \"./policy.ts\";\n\nconst DEFAULT_MODEL_FAMILY_SEARCH = \"gpt\";\n\n/** Caller intent passed to {@link resolveModel}. */\nexport interface ResolveModelInput {\n  explicit?: string;\n  fuzzy?: boolean;\n  threshold?: number;\n  requiresTools?: boolean;\n  modelClass?: ModelClass;\n  fallbacks?: readonly string[];\n  liveOnly?: boolean;\n}\n\n/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */\nexport interface ResolvedModelSelection {\n  modelId: string;\n  source: \"explicit\" | \"fuzzy-match\" | \"class\" | \"fallback\";\n}\n\n/** Rank a catalogue against a model query, best-first. */\nexport function lookupModels(\n  endpoints: readonly ServingEndpointSummary[],\n  query: ModelQuery = {},\n): RankedModel[] {\n  return rankEndpoints(endpoints, query);\n}\n\n/** Resolve the closest model id in one catalogue snapshot. */\nexport function rankModelId(\n  endpoints: readonly ServingEndpointSummary[],\n  search: string,\n  options: ResolveModelOptions = {},\n): ResolvedModel {\n  const [top] = lookupModels(endpoints, {\n    search,\n    limit: 1,\n    ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),\n    ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),\n  });\n  if (!top) return { modelId: search, matched: false };\n  return { modelId: top.endpoint.name, matched: true, score: top.score };\n}\n\n/** Resolve a single model id from a catalogue and caller intent. */\nexport function resolveModel(\n  endpoints: readonly ServingEndpointSummary[],\n  input: ResolveModelInput = {},\n): ResolvedModelSelection {\n  if (input.explicit !== undefined) {\n    if (input.fuzzy === false) {\n      if (input.requiresTools) assertToolSupport(endpoints, input.explicit);\n      return { modelId: input.explicit, source: \"explicit\" };\n    }\n    const [top] = lookupModels(endpoints, buildQuery(input, input.explicit));\n    if (input.requiresTools && !top) {\n      throw new Error(`No tool-capable model matches \"${input.explicit}\"`);\n    }\n    return { modelId: top?.endpoint.name ?? input.explicit, source: \"fuzzy-match\" };\n  }\n\n  if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {\n    const present = new Set(\n      endpoints\n        .filter((endpoint) => !input.requiresTools || endpointSupportsTools(endpoint))\n        .map((endpoint) => endpoint.name),\n    );\n    const pinned = input.fallbacks.find((id) => present.has(id));\n    if (pinned) return { modelId: pinned, source: \"fallback\" };\n  }\n\n  const source = input.modelClass !== undefined ? \"class\" : \"fallback\";\n  if (input.modelClass === undefined) {\n    const [preferred] = lookupModels(endpoints, buildQuery(input, DEFAULT_MODEL_FAMILY_SEARCH));\n    if (preferred) return { modelId: preferred.endpoint.name, source };\n  }\n  const [top] = lookupModels(endpoints, buildQuery(input, undefined));\n  if (top) return { modelId: top.endpoint.name, source };\n\n  if (input.liveOnly) {\n    throw new Error(\"No matching live Model Serving endpoint is available\");\n  }\n\n  const floorSource =\n    input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);\n  const floor = object.sequence(floorSource).concat(FALLBACK_MODEL_IDS).distinct().toArray();\n  if (input.requiresTools) {\n    const available = new Set(\n      endpoints.filter(endpointSupportsTools).map((endpoint) => endpoint.name),\n    );\n    const selected = floor.find((id) => available.has(id));\n    if (!selected) throw new Error(\"No tool-capable model is available\");\n    return { modelId: selected, source };\n  }\n  return { modelId: pickFirstAvailable(floor, endpoints), source };\n}\n\nfunction buildQuery(input: ResolveModelInput, search: string | undefined): ModelQuery {\n  return {\n    ...(search !== undefined ? { search } : {}),\n    ...(input.modelClass !== undefined ? { modelClass: input.modelClass } : {}),\n    ...(input.requiresTools !== undefined ? { requiresTools: input.requiresTools } : {}),\n    ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),\n    limit: 1,\n  };\n}\n\nfunction assertToolSupport(endpoints: readonly ServingEndpointSummary[], modelId: string): void {\n  const endpoint = endpoints.find((candidate) => candidate.name === modelId);\n  if (!endpoint || !endpointSupportsTools(endpoint)) {\n    throw new Error(`Model \"${modelId}\" does not support function tools`);\n  }\n}\n\nfunction pickFirstAvailable(\n  candidates: readonly string[],\n  endpoints: readonly ServingEndpointSummary[],\n): string {\n  const present = new Set(endpoints.map((endpoint) => endpoint.name));\n  for (const candidate of candidates) {\n    if (present.has(candidate)) return candidate;\n  }\n  return candidates[0] ?? FALLBACK_MODEL_IDS[0]!;\n}\n"]}

package/lib/src/classes.d.ts

@@ -9,8 +9,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";

package/lib/src/classes.js

@@ -9,8 +9,9 @@
  *
  * @module
  */
-import { model } from "@dbx-tools/shared-model";
-const { ModelClass, ModelClassSchema } = model;
+import { ModelClass as ModelClassValues, } from "@dbx-tools/shared-model/contracts";
+const ModelClass = ModelClassValues;
+const MODEL_CLASSES = new Set(Object.values(ModelClassValues));
 /**
  * Chat capability ladder in descending order - most capable
  * ({@link ModelClass.ChatThinking}) first, least ({@link ModelClass.ChatFast})
@@ -43,11 +44,12 @@ export function isChatClass(cls) {
  * `"balanced"` / `"fast"` resolves to the corresponding `chat-*` class.
  */
 export function parseModelClass(value) {
-    const exact = ModelClassSchema.safeParse(value);
-    if (exact.success)
-        return exact.data;
-    const prefixed = ModelClassSchema.safeParse(`chat-${value}`);
-    return prefixed.success ? prefixed.data : null;
+    if (typeof value !== "string")
+        return null;
+    if (MODEL_CLASSES.has(value))
+        return value;
+    const prefixed = `chat-${value}`;
+    return MODEL_CLASSES.has(prefixed) ? prefixed : null;
 }
 /**
  * Classes at or below `cls` in chat capability: the class itself plus every
@@ -67,4 +69,4 @@ export function classesAtOrBelow(cls) {
     const index = CHAT_CLASS_ORDER.indexOf(cls);
     return index < 0 ? [...CHAT_CLASS_ORDER] : [...CHAT_CLASS_ORDER.slice(index)];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/classify.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 { type ModelClass as ModelClassType, type ServingEndpointSummary } from "@dbx-tools/shared-model/contracts";
+type ModelClass = ModelClassType;
+declare const ModelClass: {
+    readonly ChatThinking: "chat-thinking";
+    readonly ChatBalanced: "chat-balanced";
+    readonly ChatFast: "chat-fast";
+    readonly Embedding: "embedding";
+};
+/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */
+export interface EndpointCapabilities {
+    /** OpenAI chat/completions + Responses: the surface a chat agent needs. */
+    chat: boolean;
+    /** Embedding (vector) endpoint. */
+    embedding: boolean;
+    /** Complete function-tool round-trip (call plus function_call_output replay). */
+    tools: boolean;
+}
+/**
+ * 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 declare function supportsToolsByFamily(name: string): boolean;
+/**
+ * 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 declare function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities;
+/** Family-heuristic classification of a single endpoint name. */
+export interface FamilyClass {
+    /** Chat capability band the family maps to (never embedding). */
+    class: ModelClass;
+    /** Intra-family ordering hint (higher is newer / more capable). */
+    rank: number;
+}
+/**
+ * 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 declare function versionTuple(name: string): [number, number, number];
+/**
+ * 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 declare function classifyByFamily(name: string): FamilyClass | null;
+/**
+ * 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 declare function classifyEndpoints(endpoints: readonly ServingEndpointSummary[]): Record<ModelClass, ServingEndpointSummary[]>;
+export {};