@dbx-tools/model 0.1.112 → 0.3.1

package/dist/index.js

@@ -1,576 +0,0 @@
-import { ModelClass, ModelClassSchema, classifyByFamily, classifyEndpoints } from "@dbx-tools/model-shared";
-import { CacheManager } from "@databricks/appkit";
-import { commonUtils, logUtils, stringUtils } from "@dbx-tools/shared";
-import Fuse from "fuse.js";
-
-export * from "@dbx-tools/model-shared"
-
-//#region packages/model/src/classes.ts
-/**
-* Model-class ordering for the model service.
-*
-* `@dbx-tools/model-shared` declares the {@link ModelClass} values and
-* their schema; the *behavior* over those values - the chat capability
-* order, the "this class and below" ceiling, and coercing loose request
-* input to a class - lives here in the service so the shared
-* wire-format surface stays purely declarative.
-*/
-/**
-* Chat capability ladder in descending order - most capable
-* ({@link ModelClass.ChatThinking}) first, least
-* ({@link ModelClass.ChatFast}) last. {@link ModelClass.Embedding} is a
-* separate modality and is deliberately absent: the ceiling never spans
-* it. This is the order used to filter "this class and below" and to
-* break ranking ties toward the more capable model.
-*/
-const CHAT_CLASS_ORDER = [
-	ModelClass.ChatThinking,
-	ModelClass.ChatBalanced,
-	ModelClass.ChatFast
-];
-/**
-* Every class in display order: the chat ladder followed by
-* {@link ModelClass.Embedding}. Used when flattening a full
-* classification (e.g. stamping the class onto each cached endpoint).
-*/
-const MODEL_CLASS_ORDER = [...CHAT_CLASS_ORDER, ModelClass.Embedding];
-/** Whether `cls` is one of the chat capability bands (vs. embedding). */
-function isChatClass(cls) {
-	return CHAT_CLASS_ORDER.includes(cls);
-}
-/**
-* Coerce an arbitrary value (query string, header, body field) to a
-* {@link ModelClass}, returning `null` when it isn't a known class.
-* Lets a route accept a class request without throwing on junk input.
-*
-* Matches the full slug first (`"chat-fast"`, `"embedding"`), then -
-* for a bare chat band - retries with a `chat-` prefix, so the shorthand
-* `"thinking"` / `"balanced"` / `"fast"` resolves to the corresponding
-* `chat-*` class.
-*/
-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;
-}
-/**
-* Classes at or below `cls` in chat capability: the class itself plus
-* every less-capable chat band, in {@link CHAT_CLASS_ORDER}. Treats a
-* chat `cls` as a ceiling - requesting {@link ModelClass.ChatBalanced}
-* yields `[ChatBalanced, ChatFast]`, never
-* {@link ModelClass.ChatThinking} - so a class ask can degrade downward
-* to a smaller chat model but never escalate to a larger one.
-*
-* {@link ModelClass.Embedding} is its own modality, not a rung on the
-* chat ladder, so it yields just `[Embedding]`. An unrecognized class
-* yields the full chat ladder.
-*/
-function classesAtOrBelow(cls) {
-	if (cls === ModelClass.Embedding) return [ModelClass.Embedding];
-	const index = CHAT_CLASS_ORDER.indexOf(cls);
-	return index < 0 ? [...CHAT_CLASS_ORDER] : [...CHAT_CLASS_ORDER.slice(index)];
-}
-
-//#endregion
-//#region packages/model/src/fallback.ts
-/**
-* Server-side offline fallback opinion for model selection.
-*
-* When the live `/serving-endpoints` catalogue can't be read at all -
-* no user 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 shared {@link classifyByFamily} heuristic
-* (no classes are hard-coded here) and ordered best-first.
-*
-* This is deliberately *server-only*. A browser client never talks to
-* Databricks directly - it always goes through this server - so it has
-* nothing to fall back to and must not assume a stale, baked-in model
-* list; it consumes the live `/models` response instead. The pure
-* classifier ({@link classifyEndpoints}) is what the client shares.
-*/
-/**
-* Small, last-resort set of well-known Foundation Model API endpoint
-* names, ordered best-first within each class by {@link classifyByFamily}.
-* 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 - each name is classified by family heuristic.
-*/
-const FALLBACK_MODEL_NAMES = [
-	"databricks-claude-opus-4-8",
-	"databricks-gpt-5-5-pro",
-	"databricks-gemini-3-1-pro",
-	"databricks-claude-sonnet-4-6",
-	"databricks-gpt-5-5",
-	"databricks-meta-llama-3-3-70b-instruct",
-	"databricks-claude-haiku-4-5",
-	"databricks-gpt-5-nano",
-	"databricks-meta-llama-3-1-8b-instruct"
-];
-/**
-* Static fallback model ids for a chat class, drawn from the small
-* built-in {@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 `classifyEndpoints`. Returns
-* `[]` for {@link ModelClass.Embedding} (the floor is chat-only).
-*/
-function modelsForClass(cls) {
-	return FALLBACK_MODEL_NAMES.map((name) => ({
-		name,
-		c: classifyByFamily(name)
-	})).filter((x) => x.c !== null && x.c.class === cls).sort((a, b) => b.c.rank - a.c.rank).map((x) => x.name);
-}
-/** Top static fallback model id for a chat class. */
-function modelForClass(cls) {
-	return modelsForClass(cls)[0];
-}
-/**
-* Priority-ordered fallback chain (ChatThinking -> ChatBalanced ->
-* ChatFast) over the small built-in list. The floor walked at resolve
-* time when no agent / plugin / env / request model is set *and* the
-* live catalogue yields nothing.
-*/
-const FALLBACK_MODEL_IDS = [
-	...modelsForClass(ModelClass.ChatThinking),
-	...modelsForClass(ModelClass.ChatBalanced),
-	...modelsForClass(ModelClass.ChatFast)
-];
-
-//#endregion
-//#region packages/model/src/serving.ts
-/**
-* Live Databricks Model Serving catalogue access.
-*
-* Lists the workspace's `/serving-endpoints` once per host and caches
-* the result with a TTL via AppKit's `CacheManager`, with concurrent
-* callers sharing one in-flight promise (the coalescing pattern of
-* Python's `cachetools-async`). Surfaces each endpoint as a stable
-* {@link ServingEndpointSummary} - including the Foundation Model API
-* `quality` / `speed` / `cost` profile when present, the classified
-* {@link ModelClass}, and (for embedding endpoints) the measured vector
-* `dimension` - and snaps loose, human-typed names to real endpoint ids
-* through `fuse.js` extended search so tokens like `"claude sonnet"`
-* resolve to `databricks-claude-sonnet-4-6`.
-*
-* The class stamp and embedding dimension are computed once per cache
-* load: every embedding endpoint is "pinged" in parallel and the
-* resulting vector length recorded, so the cost is paid on a cache miss,
-* not per read. The ping is best-effort - a failure logs at debug and
-* leaves `dimension` unset rather than failing the whole listing.
-*/
-const log = logUtils.logger("model/serving");
-/** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */
-const DEFAULT_MODEL_CACHE_TTL_MS = 300 * 1e3;
-/** Default Fuse.js score threshold below which a fuzzy match is accepted. */
-const DEFAULT_FUZZY_THRESHOLD = .4;
-/** Cache key parts under which endpoint listings are stored. */
-const CACHE_KEY_NAMESPACE = "serving-endpoints";
-/**
-* Stable `userKey` arg for AppKit's `CacheManager.getOrExecute`.
-* Endpoint visibility is effectively workspace-scoped (we cache by
-* host in the key parts), so a single shared key lets every user of
-* the same workspace share one cached fetch and coalesce on the
-* in-flight promise. Permissions can differ in theory, but the
-* Foundation Model API catalogue is the same view for every caller.
-*/
-const SHARED_USER_KEY = "model-shared";
-/**
-* List Model Serving endpoints for the workspace owning `client`,
-* routed through AppKit's `CacheManager`. The manager gives us
-* everything `cachetools.TTLCache` provides plus what
-* `cachetools-async` adds on top: per-entry TTL, in-flight request
-* coalescing (concurrent callers share one fetch via the manager's
-* internal `inFlightRequests` map), bounded size, telemetry spans
-* (`cache.getOrExecute`), and optional Lakebase persistence so the
-* catalogue survives restarts when the lakebase plugin is wired up.
-*
-* Returns plain {@link ServingEndpointSummary} objects (a stable
-* subset of the SDK type) so cache hits never expose stale SDK
-* internals. Errors from `CacheManager` or the SDK fetch propagate
-* to the caller - we don't swallow them so users see the real
-* auth / network issue.
-*
-* @param host - Workspace host used as the cache key. Pass the value
-*   resolved from `client.config.getHost()` so multi-host apps share
-*   one entry per workspace.
-* @param options.ttlMs - Override the default TTL just for this call.
-*   Forwarded to `CacheManager` as seconds.
-*/
-async function listServingEndpoints(client, host, options = {}) {
-	const ttlSec = Math.max(1, Math.round((options.ttlMs ?? DEFAULT_MODEL_CACHE_TTL_MS) / 1e3));
-	return CacheManager.getInstanceSync().getOrExecute([CACHE_KEY_NAMESPACE, host], () => fetchEndpoints(client), SHARED_USER_KEY, { ttl: ttlSec });
-}
-/**
-* List the workspace's serving endpoints as minimal
-* {@link ServingEndpointSummary} objects straight from the SDK: no
-* caching, and none of the cache-load enrichment ({@link listServingEndpoints}
-* adds the {@link ModelClass} stamp and the embedding-dimension probe).
-* Use this for a one-shot, dependency-light listing - e.g. a CLI that
-* only needs names/tasks for fuzzy resolution and doesn't want AppKit's
-* `CacheManager` or the per-embedding ping cost. Prefer
-* {@link listServingEndpoints} for the cached, enriched view.
-*/
-async function listServingEndpointsUncached(client) {
-	const out = [];
-	for await (const ep of client.servingEndpoints.list()) {
-		if (!ep.name) continue;
-		const profile = extractProfile(ep);
-		out.push({
-			name: ep.name,
-			...ep.task !== void 0 ? { task: ep.task } : {},
-			...ep.state?.ready !== void 0 ? { state: String(ep.state.ready) } : {},
-			...ep.description !== void 0 ? { description: ep.description } : {},
-			...profile ? { profile } : {}
-		});
-	}
-	return out;
-}
-async function fetchEndpoints(client) {
-	const startedAt = Date.now();
-	const out = await listServingEndpointsUncached(client);
-	stampModelClasses(out);
-	await measureEmbeddingDimensions(client, out);
-	log.debug("listed", {
-		count: out.length,
-		elapsedMs: Date.now() - startedAt
-	});
-	return out;
-}
-/**
-* Stamp each summary's {@link ServingEndpointSummary.class} from the
-* relative classification of the whole set. Mutates `summaries` in
-* place. Endpoints the classifier doesn't recognize (custom, unscored,
-* non-LLM) are left without a class.
-*/
-function stampModelClasses(summaries) {
-	const buckets = classifyEndpoints(summaries);
-	const classOf = /* @__PURE__ */ new Map();
-	for (const cls of MODEL_CLASS_ORDER) for (const ep of buckets[cls]) classOf.set(ep.name, cls);
-	for (const summary of summaries) {
-		const cls = classOf.get(summary.name);
-		if (cls !== void 0) summary.class = cls;
-	}
-}
-/**
-* Measure the embedding vector dimension of every
-* {@link ModelClass.Embedding} endpoint by pinging it once, all in
-* parallel. Mutates the matching summaries in place with the resulting
-* `dimension`. Runs only on a cache miss (it's called from
-* {@link fetchEndpoints}), so the probe cost is amortized across the
-* cached TTL window. Per-endpoint failures are swallowed (logged at
-* warn) so one unreachable embedding model never fails the listing.
-*/
-async function measureEmbeddingDimensions(client, summaries) {
-	await Promise.all(summaries.filter((s) => s.class === ModelClass.Embedding).map(async (summary) => {
-		const dimension = await pingEmbeddingDimension(client, summary.name);
-		if (dimension !== void 0) summary.dimension = dimension;
-	}));
-}
-/**
-* Best-effort embedding dimension probe: query `name` with a tiny
-* `"ping"` input and return the length of the returned vector. Returns
-* `undefined` (and logs at warn) when the endpoint can't be queried or
-* returns no vector - the dimension is informational, never required.
-*/
-async function pingEmbeddingDimension(client, name) {
-	try {
-		const dimension = (await client.servingEndpoints.query({
-			name,
-			input: "ping"
-		})).data?.[0]?.embedding?.length;
-		if (typeof dimension === "number" && dimension > 0) return dimension;
-		log.warn("embedding ping returned no vector", { name });
-		return;
-	} catch (err) {
-		log.warn("embedding ping failed", {
-			name,
-			error: commonUtils.errorMessage(err)
-		});
-		return;
-	}
-}
-/**
-* Pull the Foundation Model API `quality` / `speed` / `cost` scores
-* off a serving-endpoint listing entry. Databricks returns these
-* under `config.served_entities[].foundation_model.ai_gateway_model_profile`
-* (snake_case at the wire level, preserved verbatim by the SDK), but
-* the field is newer than the typed `FoundationModel` interface, so we
-* read it through a structural cast. Returns `undefined` when no
-* served entity carries a profile (custom models, embeddings, and
-* brand-new endpoints that Databricks has not scored yet).
-*/
-function extractProfile(ep) {
-	const entities = ep.config?.served_entities;
-	if (!entities) return void 0;
-	for (const entity of entities) {
-		const raw = entity.foundation_model?.ai_gateway_model_profile;
-		if (!raw) continue;
-		const profile = {};
-		if (Number.isFinite(raw.quality)) profile.quality = raw.quality;
-		if (Number.isFinite(raw.speed)) profile.speed = raw.speed;
-		if (Number.isFinite(raw.cost)) profile.cost = raw.cost;
-		if (Object.keys(profile).length > 0) return profile;
-	}
-}
-/**
-* Force-evict cached endpoint listings via AppKit's `CacheManager`.
-* With a `host` deletes that one workspace's entry; without one
-* clears every cache entry on the manager (since `CacheManager`
-* doesn't expose a namespace-scoped clear, this is the brute-force
-* path - fine for tests, avoid in steady-state code).
-*/
-async function clearServingEndpointsCache(host) {
-	const cache = CacheManager.getInstanceSync();
-	if (host) {
-		const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], SHARED_USER_KEY);
-		await cache.delete(key);
-	} else await cache.clear();
-}
-/**
-* Fuzzy-rank endpoints by how closely their `name` matches `input`,
-* best (lowest score) first, keeping only those within `threshold`:
-*
-* 1. An exact name match short-circuits to a single `score: 0` result.
-* 2. Otherwise the input is tokenized (dashes / underscores / spaces
-*    become separators) and fed through Fuse.js extended search, which
-*    AND-s each token with fuzzy matching enabled - the "tokenized
-*    fuzzy match" a caller reaches for when they type `"claude sonnet"`
-*    instead of the full endpoint name.
-*
-* Returns `[]` for an empty endpoint list or when `input` tokenizes to
-* nothing, so callers fall back to the raw input and let Databricks
-* surface a clean 404. This multi-result core is shared by
-* {@link resolveModelId} (single best) and the ranked `rankModels`
-* selector.
-*/
-function searchServingEndpoints(input, endpoints, options = {}) {
-	if (endpoints.length === 0) return [];
-	for (const ep of endpoints) if (ep.name === input) return [{
-		endpoint: ep,
-		score: 0
-	}];
-	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	const query = Array.from(stringUtils.tokenizeWithOptions({
-		lowerCase: true,
-		camelCase: false
-	}, input)).join(" ");
-	if (!query) return [];
-	return new Fuse(endpoints, {
-		keys: ["name"],
-		threshold,
-		ignoreLocation: true,
-		includeScore: true,
-		useExtendedSearch: true,
-		isCaseSensitive: false
-	}).search(query).filter((r) => (r.score ?? 0) <= threshold).map((r) => ({
-		endpoint: r.item,
-		score: r.score ?? 0
-	}));
-}
-/**
-* Snap a user-supplied model name to the single closest configured
-* serving endpoint via {@link searchServingEndpoints}. Returns the
-* input unchanged with `matched: false` when nothing scores within the
-* threshold (or the catalogue is empty), so a deliberate model id is
-* never silently rewritten to a similar-looking neighbour and the
-* upstream call surfaces the canonical 404.
-*/
-function resolveModelId(input, endpoints, options = {}) {
-	const [best] = searchServingEndpoints(input, endpoints, options);
-	if (best) return {
-		modelId: best.endpoint.name,
-		matched: true,
-		score: best.score
-	};
-	return {
-		modelId: input,
-		matched: false
-	};
-}
-
-//#endregion
-//#region packages/model/src/resolve.ts
-/**
-* Workspace-aware model selection.
-*
-* Given a caller's intent - a search string, a capability
-* {@link ModelClass} ceiling, both, or nothing - the toolkit returns
-* matching endpoints ranked by match quality then class, or collapses
-* to the single best id the workspace actually has, degrading from
-* "best in range" down to the static fallback floor. Selection is
-* chat-only: embedding endpoints surface only when `modelClass` is
-* explicitly {@link ModelClass.Embedding}.
-*
-* Two shapes of selection, each in a pure form (over an endpoint list
-* the caller already holds) and an I/O wrapper (that lists
-* `/serving-endpoints` first): ranking, which returns a match- then
-* class-ordered list, and single-selection, which collapses to one id
-* plus how it was reached and layers the operator-pinned fallback /
-* static-floor safety net on top. A chat `modelClass` acts as a
-* ceiling: that band and the less-capable chat bands below it are
-* eligible (see {@link classesAtOrBelow}), so a `chat-balanced` ask can
-* fall to `chat-fast` but never escalate to `chat-thinking`.
-*/
-/**
-* Round a Fuse score to the display precision so version siblings that
-* match a token identically (e.g. `opus-4-7` vs `opus-4-8` for the
-* query `"opus"`) tie on match and let the class / within-class rank
-* decide - which is what surfaces the newer, higher-quality sibling.
-*/
-function matchBucket(score) {
-	return Math.round((score ?? 0) * 1e3);
-}
-/**
-* Rank the live catalogue against a {@link ModelQuery}, best-first.
-*
-* Candidates are the classified endpoints in the eligible classes:
-* {@link classesAtOrBelow} the requested `modelClass`, or - when none is
-* given - the chat bands only ({@link CHAT_CLASS_ORDER}), so a general
-* ask never surfaces an embedding endpoint. Each class bucket is
-* already best-first from {@link classifyEndpoints}. Ranking is **match
-* then class**:
-*
-* 1. With a `search`, only endpoints matching it survive, ordered by
-*    match distance (bucketed via {@link matchBucket} so near-identical
-*    scores tie), then by class (more capable first), then by the stable
-*    within-class rank.
-* 2. Without a `search`, the class-then-rank candidate order stands.
-*
-* A `limit` truncates the result. Returns `[]` when nothing is
-* eligible or matches - callers layer their own fallback.
-*/
-function rankModels(endpoints, query = {}) {
-	const classified = classifyEndpoints(endpoints);
-	const eligible = query.modelClass !== void 0 ? classesAtOrBelow(query.modelClass) : CHAT_CLASS_ORDER;
-	const candidates = [];
-	for (const modelClass of eligible) for (const endpoint of classified[modelClass]) candidates.push({
-		endpoint,
-		modelClass
-	});
-	const search = query.search?.trim();
-	let ranked;
-	if (search) {
-		const scores = /* @__PURE__ */ new Map();
-		for (const match of searchServingEndpoints(search, candidates.map((c) => c.endpoint), query.threshold !== void 0 ? { threshold: query.threshold } : {})) scores.set(match.endpoint.name, match.score);
-		ranked = candidates.filter((c) => scores.has(c.endpoint.name)).map((c) => ({
-			...c,
-			score: scores.get(c.endpoint.name)
-		})).sort((a, b) => {
-			const byMatch = matchBucket(a.score) - matchBucket(b.score);
-			if (byMatch !== 0) return byMatch;
-			return MODEL_CLASS_ORDER.indexOf(a.modelClass) - MODEL_CLASS_ORDER.indexOf(b.modelClass);
-		});
-	} else ranked = candidates;
-	return query.limit !== void 0 ? ranked.slice(0, Math.max(0, query.limit)) : ranked;
-}
-/**
-* Rank a workspace's catalogue in one call: list its
-* `/serving-endpoints` (cached) and run {@link rankModels} over the
-* result. The list counterpart to {@link selectModel}, for a consumer
-* that wants the full ranked set (a model picker, a CLI) rather than a
-* single id. Catalogue fetches fail loud: network / auth errors
-* propagate so the caller sees the real SDK message.
-*
-* @param host - Workspace host used as the cache key. Pass the value
-*   resolved from `client.config.getHost()`.
-*/
-async function searchModels(client, host, input = {}) {
-	return rankModels(await listServingEndpoints(client, host, input.ttlMs !== void 0 ? { ttlMs: input.ttlMs } : {}), input);
-}
-/**
-* Resolve a model id for a workspace in one call: list its
-* `/serving-endpoints` (cached) and run {@link resolveModel} over the
-* result. This is the entry point for any consumer that holds a
-* `WorkspaceClient` and just wants a usable model name - a Lakeflow
-* job, a one-off script, or the Mastra plugin alike.
-*
-* Cheap exit: when an `explicit` name is given and `fuzzy` is off, the
-* catalogue is never fetched - the name is returned verbatim and
-* Databricks surfaces the canonical 404 if it doesn't exist. Catalogue
-* fetches otherwise fail loud: network / auth errors propagate so the
-* caller sees the real SDK message instead of a silent fallback.
-*
-* @param host - Workspace host used as the cache key. Pass the value
-*   resolved from `client.config.getHost()`.
-*/
-async function selectModel(client, host, input = {}) {
-	if (input.explicit !== void 0 && input.fuzzy === false) return {
-		modelId: input.explicit,
-		source: "explicit"
-	};
-	return resolveModel(await listServingEndpoints(client, host, { ...input.ttlMs !== void 0 ? { ttlMs: input.ttlMs } : {} }), input);
-}
-/**
-* Resolve a single model id from the live catalogue and caller intent,
-* delegating the live selection to {@link rankModels} with `limit: 1`.
-*
-* 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise
-*    fuzzy-ranked within the (optional) class ceiling and the best taken,
-*    falling back to the input verbatim when nothing matches.
-* 2. **No explicit ask**: an operator-pinned `fallback` that exists in
-*    the live catalogue wins first; then the ranked live catalogue
-*    (class ceiling applied); then the static {@link FALLBACK_MODEL_IDS}
-*    floor when the catalogue yields nothing in range.
-*/
-function resolveModel(endpoints, input = {}) {
-	if (input.explicit !== void 0) {
-		if (input.fuzzy === false) return {
-			modelId: input.explicit,
-			source: "explicit"
-		};
-		const [top] = rankModels(endpoints, buildQuery(input, input.explicit));
-		return {
-			modelId: top?.endpoint.name ?? input.explicit,
-			source: "fuzzy-match"
-		};
-	}
-	if (input.modelClass === void 0 && input.fallbacks && input.fallbacks.length > 0) {
-		const present = new Set(endpoints.map((e) => e.name));
-		const pinned = input.fallbacks.find((id) => present.has(id));
-		if (pinned) return {
-			modelId: pinned,
-			source: "fallback"
-		};
-	}
-	const source = input.modelClass !== void 0 ? "class" : "fallback";
-	const [top] = rankModels(endpoints, buildQuery(input, void 0));
-	if (top) return {
-		modelId: top.endpoint.name,
-		source
-	};
-	return {
-		modelId: pickFirstAvailable(input.modelClass !== void 0 ? dedupe([...modelsForClass(input.modelClass), ...FALLBACK_MODEL_IDS]) : dedupe([...input.fallbacks ?? [], ...FALLBACK_MODEL_IDS]), endpoints),
-		source
-	};
-}
-/** Build a {@link ModelQuery} from {@link ResolveModelInput} for the `limit: 1` delegation. */
-function buildQuery(input, search) {
-	return {
-		...search !== void 0 ? { search } : {},
-		...input.modelClass !== void 0 ? { modelClass: input.modelClass } : {},
-		...input.threshold !== void 0 ? { threshold: input.threshold } : {},
-		limit: 1
-	};
-}
-/** Drop duplicate ids while preserving first-seen order. */
-function dedupe(ids) {
-	return [...new Set(ids)];
-}
-/**
-* Find the first id in `candidates` whose endpoint is present in
-* `endpoints`. Returns the top candidate when the workspace has none
-* of them so callers always get a string; an offline workspace then
-* receives a clean 404 from Databricks instead of a malformed config.
-*/
-function pickFirstAvailable(candidates, endpoints) {
-	const present = new Set(endpoints.map((e) => e.name));
-	for (const candidate of candidates) if (present.has(candidate)) return candidate;
-	return candidates[0] ?? FALLBACK_MODEL_IDS[0];
-}
-
-//#endregion
-export { CHAT_CLASS_ORDER, DEFAULT_FUZZY_THRESHOLD, DEFAULT_MODEL_CACHE_TTL_MS, FALLBACK_MODEL_IDS, MODEL_CLASS_ORDER, classesAtOrBelow, clearServingEndpointsCache, isChatClass, listServingEndpoints, listServingEndpointsUncached, modelForClass, modelsForClass, parseModelClass, rankModels, resolveModel, resolveModelId, searchModels, searchServingEndpoints, selectModel };