@dbx-tools/model 0.9.19 → 0.9.28

package/README.md

@@ -14,7 +14,7 @@ Browser-safe request/result schemas and endpoint classification types live in
 Key features:
 
 - Lists Databricks Model Serving endpoints through the SDK and normalizes them
-  into a stable summary shape with Rust-derived family and reasoning-effort
+  into a stable summary shape with TypeScript-owned family and reasoning-effort
   metadata.
 - Classifies endpoints into chat-thinking, chat-balanced, chat-fast, and
   embedding classes using Foundation Model API scores and family heuristics.
@@ -28,6 +28,8 @@ Key features:
   and re-lists once on a resolve miss so a newly deployed model still resolves.
 - Builds the invocations URL and mints per-request auth headers for callers that
   issue their own OpenAI-shaped HTTP requests.
+- Provides build-generated retirement, Responses, image-input, apply-patch,
+  web-search, ITPM, OTPM, and QPH metadata through cached in-process lookups.
 - Provides a small static fallback floor for local tools and degraded workspace
   access.
 
@@ -51,6 +53,37 @@ endpoint:
 - keep local agents and CLIs working with a static fallback when catalogue
   access is unavailable.
 
+## Use The Portable Model Client
+
+```ts
+import { createModelClient } from "@dbx-tools/model";
+
+const models = await createModelClient({
+  auth: { profile: "DEFAULT" },
+  cacheTtlMs: 60_000,
+});
+
+const selected = await models.resolveModel({ explicit: "gpt" });
+const route = await models.route({
+  explicit: selected.modelId,
+  protocol: "responses",
+});
+
+const response = await fetch(route.url, {
+  method: "POST",
+  headers: { ...route.headers, "content-type": "application/json" },
+  body: JSON.stringify({ model: route.modelId, input: "Hello" }),
+});
+```
+
+`createModelClient()` is the portable auth-backed facade embedded by the Python
+model proxy. It lists and normalizes endpoints, caches one
+catalogue per host, workspace ID, and principal, refreshes once after an
+unmatched fuzzy request, resolves routes, returns complete authentication
+headers, exposes profiles, and returns the package's generated metadata. Its
+portable `@dbx-tools/model/python` entrypoint excludes the AppKit catalogue
+wrapper while reusing the same pure ranking and policy implementation.
+
 ## Select One Model
 
 ```ts
@@ -95,10 +128,9 @@ const ranked = await resolve.searchModels(client, host, {
 
 Use `searchModels()` for UI pickers and debug routes. It returns ranked models
 with match scores and endpoint summaries, using the same fuzzy threshold and
-class ceiling logic as `selectModel()`. Both delegate catalogue ranking to the
-generated [`@dbx-tools/model-rs`](../model-rs) binding, so Node and the Rust
-model proxy use one fuzzy scorer, family-version order, variant preference, and
-class policy.
+class ceiling logic as `selectModel()`. Classification, fuzzy scoring,
+family-version order, and variant preference are implemented directly in this
+package and require no native binding.
 
 ## Work With A Held Catalogue
 
@@ -194,9 +226,24 @@ a property of the model (see `isResponsesOnly()` and `responsesUpstreamUrl()`),
 so a hard-coded string in one package silently diverges when that routing
 changes. `isResponsesOnly()` covers Codex and GPT 5.4+ endpoints, which reject
 tool-bearing Chat Completions, while keeping GPT-OSS on its supported Chat path.
-The TypeScript helper delegates this policy to the generated
-[`@dbx-tools/model-rs`](../model-rs) binding, so the Rust proxy, Node packages,
-and Python callers share one version threshold.
+The TypeScript helper owns this policy, so Node consumers and generated Python
+bindings share one version threshold without loading a native library.
+
+## Read Published Model Metadata
+
+```ts
+import { metadata } from "@dbx-tools/model";
+
+const capabilities = metadata.modelCapabilitiesFor("databricks-gpt-5-4");
+const limits = metadata.modelRateLimitsFor("gpt-5.4");
+const status = metadata.modelStatusFor("system.ai.gemini-2-5-pro");
+```
+
+The package ships committed snapshots generated from Databricks documentation
+by `bun run model:metadata`. Runtime calls normalize endpoint, display,
+foundation-model, and provider identities into memoized sets and maps; they do
+not fetch documentation. `modelMetadataFor()` returns status, capabilities, and
+published limits together for a string or `ServingEndpointSummary`.
 
 ## Use Static Fallbacks
 
@@ -214,14 +261,18 @@ policy decisions; fallbacks are a last resort.
 
 ## Modules
 
-- `resolve` - high-level `selectModel`, Rust-backed ranked search, and
+- `resolve` - high-level `selectModel`, TypeScript-ranked search, and
   catalogue-held resolver functions.
 - `serving` - Databricks serving-endpoint listing, cache management, fuzzy
   search, and endpoint-id resolution.
 - `invoke` - serving-path constants, URL construction, and per-request auth
   headers for calling an endpoint over raw HTTP.
+- `metadata` - build-generated retirement, capability, and rate-limit snapshots
+  with cached normalized lookups.
+- `modelClient` - portable authentication-aware discovery, selection, routing,
+  profile, and metadata facade.
 - `classes` - model-class parsing, ordering, and class-ceiling helpers.
-- `policy` - Rust-backed family and reasoning-effort metadata projection.
+- `policy` - family, serving-protocol, tool, and reasoning-effort policy.
 - `fallback` - static fallback model ids per class.
 
 The AppKit-Mastra integration uses this package through

package/index.ts

@@ -3,17 +3,27 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.19";
+export const PACKAGE_VERSION = "0.9.28";
 export * as classes from "./src/classes.ts";
+export * as classify from "./src/classify.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as metadata from "./src/metadata.ts";
 export * as modelCatalog from "./src/model-catalog.ts";
+export * as modelClient from "./src/model-client.ts";
 export * as policy from "./src/policy.ts";
+export * as python from "./src/python.ts";
 export * as resolve from "./src/resolve.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";
+export type { EndpointCapabilities, FamilyClass } from "./src/classify.ts";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.ts";
+export { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL } from "./src/metadata.ts";
+export type { ModelCapabilities, ModelMetadata } from "./src/metadata.ts";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
 export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/model-catalog.ts";
-export type { ResolveModelInput, ResolvedModelSelection, SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
+export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.ts";
+export type { ModelClientOptions, ModelClientStatus, ModelProtocol, ModelRouteInput, ModelRoute, ModelClient } from "./src/model-client.ts";
+export type { SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
+export * from "./exports.ts";

package/lib/exports.d.ts

@@ -0,0 +1 @@
+export { createModelClient } from "./src/model-client.ts";

package/lib/exports.js

@@ -0,0 +1,2 @@
+export { createModelClient } from "./src/model-client.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2V4cG9ydHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBjcmVhdGVNb2RlbENsaWVudCB9IGZyb20gXCIuL3NyYy9tb2RlbC1jbGllbnQudHNcIjtcbiJdfQ==

package/lib/index.d.ts

@@ -1,15 +1,25 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export declare const PACKAGE_VERSION = "0.9.19";
+export declare const PACKAGE_VERSION = "0.9.28";
 export * as classes from "./src/classes.ts";
+export * as classify from "./src/classify.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as metadata from "./src/metadata.ts";
 export * as modelCatalog from "./src/model-catalog.ts";
+export * as modelClient from "./src/model-client.ts";
 export * as policy from "./src/policy.ts";
+export * as python from "./src/python.ts";
 export * as resolve from "./src/resolve.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";
+export type { EndpointCapabilities, FamilyClass } from "./src/classify.ts";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.ts";
+export { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL } from "./src/metadata.ts";
+export type { ModelCapabilities, ModelMetadata } from "./src/metadata.ts";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
 export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/model-catalog.ts";
-export type { ResolveModelInput, ResolvedModelSelection, SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
+export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.ts";
+export type { ModelClientOptions, ModelClientStatus, ModelProtocol, ModelRouteInput, ModelRoute, ModelClient } from "./src/model-client.ts";
+export type { SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
+export * from "./exports.ts";

package/lib/index.js

@@ -2,15 +2,22 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.19";
+export const PACKAGE_VERSION = "0.9.28";
 export * as classes from "./src/classes.js";
+export * as classify from "./src/classify.js";
 export * as fallback from "./src/fallback.js";
 export * as invoke from "./src/invoke.js";
+export * as metadata from "./src/metadata.js";
 export * as modelCatalog from "./src/model-catalog.js";
+export * as modelClient from "./src/model-client.js";
 export * as policy from "./src/policy.js";
+export * as python from "./src/python.js";
 export * as resolve from "./src/resolve.js";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.js";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.js";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.js";
+export { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL } from "./src/metadata.js";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.js";
-//# sourceMappingURL=data:application/json;base64,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
+export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.js";
+export * from "./exports.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztBQUNyRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxLQUFLLFFBQVEsTUFBTSxtQkFBbUIsQ0FBQztBQUM5QyxPQUFPLEtBQUssUUFBUSxNQUFNLG1CQUFtQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxLQUFLLFFBQVEsTUFBTSxtQkFBbUIsQ0FBQztBQUM5QyxPQUFPLEtBQUssWUFBWSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0sdUJBQXVCLENBQUM7QUFDckQsT0FBTyxLQUFLLE1BQU0sTUFBTSxpQkFBaUIsQ0FBQztBQUMxQyxPQUFPLEtBQUssTUFBTSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFdkUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDdkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxtQkFBbUIsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWpILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxxQkFBcUIsRUFBRSwyQkFBMkIsRUFBRSxrQkFBa0IsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXpKLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTdGLE9BQU8sRUFBRSxpQ0FBaUMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRzFFLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9tb2RlbFwiO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9IFwiMC45LjI4XCI7XG5leHBvcnQgKiBhcyBjbGFzc2VzIGZyb20gXCIuL3NyYy9jbGFzc2VzLnRzXCI7XG5leHBvcnQgKiBhcyBjbGFzc2lmeSBmcm9tIFwiLi9zcmMvY2xhc3NpZnkudHNcIjtcbmV4cG9ydCAqIGFzIGZhbGxiYWNrIGZyb20gXCIuL3NyYy9mYWxsYmFjay50c1wiO1xuZXhwb3J0ICogYXMgaW52b2tlIGZyb20gXCIuL3NyYy9pbnZva2UudHNcIjtcbmV4cG9ydCAqIGFzIG1ldGFkYXRhIGZyb20gXCIuL3NyYy9tZXRhZGF0YS50c1wiO1xuZXhwb3J0ICogYXMgbW9kZWxDYXRhbG9nIGZyb20gXCIuL3NyYy9tb2RlbC1jYXRhbG9nLnRzXCI7XG5leHBvcnQgKiBhcyBtb2RlbENsaWVudCBmcm9tIFwiLi9zcmMvbW9kZWwtY2xpZW50LnRzXCI7XG5leHBvcnQgKiBhcyBwb2xpY3kgZnJvbSBcIi4vc3JjL3BvbGljeS50c1wiO1xuZXhwb3J0ICogYXMgcHl0aG9uIGZyb20gXCIuL3NyYy9weXRob24udHNcIjtcbmV4cG9ydCAqIGFzIHJlc29sdmUgZnJvbSBcIi4vc3JjL3Jlc29sdmUudHNcIjtcbmV4cG9ydCB7IENIQVRfQ0xBU1NfT1JERVIsIE1PREVMX0NMQVNTX09SREVSIH0gZnJvbSBcIi4vc3JjL2NsYXNzZXMudHNcIjtcbmV4cG9ydCB0eXBlIHsgRW5kcG9pbnRDYXBhYmlsaXRpZXMsIEZhbWlseUNsYXNzIH0gZnJvbSBcIi4vc3JjL2NsYXNzaWZ5LnRzXCI7XG5leHBvcnQgeyBGQUxMQkFDS19NT0RFTF9JRFMgfSBmcm9tIFwiLi9zcmMvZmFsbGJhY2sudHNcIjtcbmV4cG9ydCB7IElOVk9DQVRJT05TX1NVRkZJWCwgUkVTUE9OU0VTX1BBVEgsIE9QRU5fUkVTUE9OU0VTX1BBVEgsIENIQVRfQ09NUExFVElPTlNfUEFUSCB9IGZyb20gXCIuL3NyYy9pbnZva2UudHNcIjtcbmV4cG9ydCB0eXBlIHsgQXV0aGVudGljYXRpbmdDbGllbnRMaWtlIH0gZnJvbSBcIi4vc3JjL2ludm9rZS50c1wiO1xuZXhwb3J0IHsgTU9ERUxfTUVUQURBVEFfVFRMX01TLCBNT0RFTF9SQVRFX0xJTUlUU19VUkwsIE9QRU5BSV9SRVNQT05TRVNfTU9ERUxTX1VSTCwgUkVUSVJFRF9NT0RFTFNfVVJMLCBXRUJfU0VBUkNIX01PREVMU19VUkwgfSBmcm9tIFwiLi9zcmMvbWV0YWRhdGEudHNcIjtcbmV4cG9ydCB0eXBlIHsgTW9kZWxDYXBhYmlsaXRpZXMsIE1vZGVsTWV0YWRhdGEgfSBmcm9tIFwiLi9zcmMvbWV0YWRhdGEudHNcIjtcbmV4cG9ydCB7IERFRkFVTFRfTU9ERUxfQ0FDSEVfVFRMX01TLCBERUZBVUxUX0ZVWlpZX1RIUkVTSE9MRCB9IGZyb20gXCIuL3NyYy9tb2RlbC1jYXRhbG9nLnRzXCI7XG5leHBvcnQgdHlwZSB7IFdvcmtzcGFjZUNsaWVudExpa2UsIExpc3RTZXJ2aW5nRW5kcG9pbnRzT3B0aW9ucywgUmVzb2x2ZWRNb2RlbCwgUmVzb2x2ZU1vZGVsT3B0aW9ucywgU2NvcmVkRW5kcG9pbnQgfSBmcm9tIFwiLi9zcmMvbW9kZWwtY2F0YWxvZy50c1wiO1xuZXhwb3J0IHsgREVGQVVMVF9NT0RFTF9DTElFTlRfQ0FDSEVfVFRMX01TIH0gZnJvbSBcIi4vc3JjL21vZGVsLWNsaWVudC50c1wiO1xuZXhwb3J0IHR5cGUgeyBNb2RlbENsaWVudE9wdGlvbnMsIE1vZGVsQ2xpZW50U3RhdHVzLCBNb2RlbFByb3RvY29sLCBNb2RlbFJvdXRlSW5wdXQsIE1vZGVsUm91dGUsIE1vZGVsQ2xpZW50IH0gZnJvbSBcIi4vc3JjL21vZGVsLWNsaWVudC50c1wiO1xuZXhwb3J0IHR5cGUgeyBTZWxlY3RNb2RlbElucHV0LCBTZWFyY2hNb2RlbHNJbnB1dCB9IGZyb20gXCIuL3NyYy9yZXNvbHZlLnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9leHBvcnRzLnRzXCI7XG4iXX0=

package/lib/src/_metadata-contract.d.ts

@@ -0,0 +1,42 @@
+/** One day, matching the refresh cadence of Databricks model documentation. */
+export declare const MODEL_METADATA_TTL_MS: number;
+/** Databricks documentation URL for retired foundation models. */
+export declare const RETIRED_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/retired-models-policy";
+/** Databricks documentation URL for OpenAI Responses model support. */
+export declare const OPENAI_RESPONSES_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-openai-responses";
+/** Databricks documentation URL for native web-search model support. */
+export declare const WEB_SEARCH_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/web-search";
+/** Databricks documentation URL for Foundation Model API limits. */
+export declare const MODEL_RATE_LIMITS_URL = "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
+/** Build-generated retired-model snapshot. */
+export interface RetiredModelsSnapshot {
+    readonly generatedAt: number;
+    readonly models: readonly string[];
+}
+/** Normalized model identities grouped by documented capability. */
+export interface ModelCapabilityCatalogue {
+    readonly responses: readonly string[];
+    readonly imageInput: readonly string[];
+    readonly applyPatch: readonly string[];
+    readonly webSearch: readonly string[];
+}
+/** Build-generated model-capability snapshot. */
+export interface ModelCapabilitiesSnapshot {
+    readonly generatedAt: number;
+    readonly capabilities: ModelCapabilityCatalogue;
+}
+/** Published pay-per-token limits for one model. */
+export interface ModelRateLimits {
+    readonly inputTokensPerMinute: number | null;
+    readonly outputTokensPerMinute: number | null;
+    readonly queriesPerHour: number | null;
+}
+/** Model limits keyed by normalized Databricks model identity. */
+export interface ModelRateLimitCatalogue {
+    readonly models: Readonly<Record<string, ModelRateLimits>>;
+}
+/** Build-generated model-rate-limit snapshot. */
+export interface ModelRateLimitsSnapshot {
+    readonly generatedAt: number;
+    readonly catalogue: ModelRateLimitCatalogue;
+}

package/lib/src/_metadata-contract.js

@@ -0,0 +1,11 @@
+/** One day, matching the refresh cadence of Databricks model documentation. */
+export const MODEL_METADATA_TTL_MS = 24 * 60 * 60 * 1000;
+/** Databricks documentation URL for retired foundation models. */
+export const RETIRED_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/retired-models-policy";
+/** Databricks documentation URL for OpenAI Responses model support. */
+export const OPENAI_RESPONSES_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-openai-responses";
+/** Databricks documentation URL for native web-search model support. */
+export const WEB_SEARCH_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/web-search";
+/** Databricks documentation URL for Foundation Model API limits. */
+export const MODEL_RATE_LIMITS_URL = "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_metadata-generator.d.ts

@@ -0,0 +1,7 @@
+import type { ModelCapabilitiesSnapshot, ModelRateLimitsSnapshot, RetiredModelsSnapshot } from "./_metadata-contract.ts";
+/** Parse retired model names from Databricks retirement-policy HTML. */
+export declare function parseRetiredModels(html: string, generatedAt: number): RetiredModelsSnapshot;
+/** Parse Responses and web-search documentation into model capability sets. */
+export declare function parseModelCapabilities(responsesHtml: string, webSearchHtml: string, generatedAt: number): ModelCapabilitiesSnapshot;
+/** Parse pay-per-token limits from Databricks Foundation Model API HTML. */
+export declare function parseModelRateLimits(html: string, generatedAt: number): ModelRateLimitsSnapshot;

package/lib/src/_metadata-generator.js

@@ -0,0 +1,182 @@
+import { load } from "cheerio";
+import { modelSearchQuery } from "./policy.js";
+/** Parse retired model names from Databricks retirement-policy HTML. */
+export function parseRetiredModels(html, generatedAt) {
+    const $ = load(html);
+    const models = new Set();
+    $("table").each((_, table) => {
+        const rows = $(table).find("tr");
+        const header = collapseText($(rows.get(0)).find("th, td").first()).toLowerCase();
+        if (header !== "open model" && header !== "partner model")
+            return;
+        rows.slice(1).each((__, row) => {
+            for (const name of collapseText($(row).find("th, td").first()).split("/")) {
+                const trimmed = name.trim();
+                if (trimmed)
+                    models.add(trimmed);
+            }
+        });
+    });
+    if (models.size === 0)
+        throw new Error("Databricks retirement tables contained no model names");
+    return {
+        generatedAt,
+        models: [...models].sort((left, right) => left.localeCompare(right, "en", { sensitivity: "base" })),
+    };
+}
+/** Parse Responses and web-search documentation into model capability sets. */
+export function parseModelCapabilities(responsesHtml, webSearchHtml, generatedAt) {
+    const responsesDocument = load(responsesHtml);
+    const responses = modelsAfterHeading(responsesDocument, "databricks-hosted-foundation-models");
+    if (responses.length === 0) {
+        throw new Error("Databricks documentation contained no OpenAI Responses models");
+    }
+    const inputTypes = sectionElements(responsesDocument, "supported-input-types")
+        .map((element) => collapseText(element))
+        .join(" ")
+        .toLowerCase();
+    const inputTypeWords = new Set(inputTypes.split(/[^a-z0-9]+/).filter(Boolean));
+    const imageInput = inputTypeWords.has("text") && inputTypeWords.has("image") ? responses : [];
+    const applyPatch = codeValuesAfterHeading(responsesDocument, "limitations").includes("apply_patch")
+        ? responses
+        : [];
+    const webSearch = nativeWebSearchModels(load(webSearchHtml), responses);
+    if (webSearch.length === 0) {
+        throw new Error("Databricks documentation contained no native web-search models");
+    }
+    return {
+        generatedAt,
+        capabilities: { responses, imageInput, applyPatch, webSearch },
+    };
+}
+/** Parse pay-per-token limits from Databricks Foundation Model API HTML. */
+export function parseModelRateLimits(html, generatedAt) {
+    const $ = load(html);
+    const models = {};
+    $("table").each((_, table) => {
+        const rows = $(table).find("tr");
+        const headers = $(rows.get(0))
+            .find("th, td")
+            .toArray()
+            .map((cell) => collapseText($(cell)).toLowerCase());
+        const modelIndex = headers.findIndex((value) => value.includes("model"));
+        const inputIndex = headers.findIndex((value) => value.includes("itpm"));
+        const outputIndex = headers.findIndex((value) => value.includes("otpm"));
+        const queryIndex = headers.findIndex((value) => value.includes("qph"));
+        if (modelIndex < 0 || inputIndex < 0 || outputIndex < 0)
+            return;
+        rows.slice(1).each((__, row) => {
+            const cells = $(row)
+                .find("th, td")
+                .toArray()
+                .map((cell) => collapseText($(cell)));
+            const key = modelKey(cells[modelIndex]);
+            if (!key)
+                return;
+            models[key] = {
+                inputTokensPerMinute: number(cells[inputIndex]),
+                outputTokensPerMinute: number(cells[outputIndex]),
+                queriesPerHour: queryIndex < 0 ? null : number(cells[queryIndex]),
+            };
+        });
+    });
+    if (Object.keys(models).length === 0) {
+        throw new Error("Databricks model-limit documentation contained no models");
+    }
+    return { generatedAt, catalogue: { models: sortRecord(models) } };
+}
+function modelsAfterHeading($, headingId) {
+    return [
+        ...new Set(codeValuesAfterHeading($, headingId).flatMap((value) => modelKey(value) ?? [])),
+    ].sort();
+}
+function nativeWebSearchModels($, responses) {
+    const families = new Set();
+    const models = new Set();
+    let nativeSection = false;
+    for (const element of sectionElements($, "supported-models")) {
+        if (headingLevel(nodeTagName(element.get(0))) !== undefined) {
+            nativeSection = !collapseText(element).toLowerCase().includes("via mcp");
+            continue;
+        }
+        if (!nativeSection)
+            continue;
+        const values = nodeTagName(element.get(0)) === "code" ? [collapseText(element)] : [];
+        element.find("code").each((_, code) => {
+            values.push(collapseText($(code)));
+        });
+        for (const value of values) {
+            const model = modelKey(value);
+            if (!model)
+                continue;
+            models.add(model);
+            families.add(model.split("-", 1)[0]);
+        }
+    }
+    for (const model of responses) {
+        if (families.has(model.split("-", 1)[0]))
+            models.add(model);
+    }
+    return [...models].sort();
+}
+function codeValuesAfterHeading($, headingId) {
+    const values = [];
+    for (const element of sectionElements($, headingId)) {
+        if (nodeTagName(element.get(0)) === "code")
+            values.push(collapseText(element));
+        element.find("code").each((_, code) => {
+            values.push(collapseText($(code)));
+        });
+    }
+    return values;
+}
+function sectionElements($, headingId) {
+    const heading = $(`#${headingId}`).first();
+    if (heading.length === 0)
+        throw new Error(`Databricks capability page is missing section ${headingId}`);
+    const level = headingLevel(nodeTagName(heading.get(0)));
+    if (level === undefined)
+        throw new Error(`Databricks capability section ${headingId} is not a heading`);
+    const elements = [];
+    let sibling = heading.next();
+    while (sibling.length > 0) {
+        const siblingLevel = headingLevel(nodeTagName(sibling.get(0)));
+        if (siblingLevel !== undefined && siblingLevel <= level)
+            break;
+        elements.push(sibling);
+        sibling = sibling.next();
+    }
+    return elements;
+}
+function headingLevel(name) {
+    const match = /^h([1-6])$/.exec(name ?? "");
+    return match ? Number(match[1]) : undefined;
+}
+function collapseText(element) {
+    return element.text().split(/\s+/).filter(Boolean).join(" ");
+}
+function nodeTagName(node) {
+    if (!node || typeof node !== "object" || !("tagName" in node))
+        return undefined;
+    return typeof node.tagName === "string" ? node.tagName : undefined;
+}
+function modelKey(value) {
+    if (!value)
+        return undefined;
+    let name = value.trim().replace(/\*+$/, "").trim();
+    for (const suffix of ["(Public Preview)", "(Beta)", "(Preview)"]) {
+        if (name.endsWith(suffix))
+            name = name.slice(0, -suffix.length).trim();
+    }
+    return modelSearchQuery(name)?.replaceAll(" ", "-");
+}
+function number(value) {
+    if (!value)
+        return null;
+    const parsed = Number(value.replaceAll(",", "").trim());
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_metadata-generator.js","sourceRoot":"","sources":["../../src/_metadata-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { load, type CheerioAPI } from \"cheerio\";\n\nimport type {\n  ModelCapabilitiesSnapshot,\n  ModelRateLimitCatalogue,\n  ModelRateLimitsSnapshot,\n  RetiredModelsSnapshot,\n} from \"./_metadata-contract.ts\";\nimport { modelSearchQuery } from \"./policy.ts\";\n\ntype Selection = ReturnType<CheerioAPI>;\n\n/** Parse retired model names from Databricks retirement-policy HTML. */\nexport function parseRetiredModels(html: string, generatedAt: number): RetiredModelsSnapshot {\n  const $ = load(html);\n  const models = new Set<string>();\n  $(\"table\").each((_, table) => {\n    const rows = $(table).find(\"tr\");\n    const header = collapseText($(rows.get(0)).find(\"th, td\").first()).toLowerCase();\n    if (header !== \"open model\" && header !== \"partner model\") return;\n    rows.slice(1).each((__, row) => {\n      for (const name of collapseText($(row).find(\"th, td\").first()).split(\"/\")) {\n        const trimmed = name.trim();\n        if (trimmed) models.add(trimmed);\n      }\n    });\n  });\n  if (models.size === 0) throw new Error(\"Databricks retirement tables contained no model names\");\n  return {\n    generatedAt,\n    models: [...models].sort((left, right) =>\n      left.localeCompare(right, \"en\", { sensitivity: \"base\" }),\n    ),\n  };\n}\n\n/** Parse Responses and web-search documentation into model capability sets. */\nexport function parseModelCapabilities(\n  responsesHtml: string,\n  webSearchHtml: string,\n  generatedAt: number,\n): ModelCapabilitiesSnapshot {\n  const responsesDocument = load(responsesHtml);\n  const responses = modelsAfterHeading(responsesDocument, \"databricks-hosted-foundation-models\");\n  if (responses.length === 0) {\n    throw new Error(\"Databricks documentation contained no OpenAI Responses models\");\n  }\n  const inputTypes = sectionElements(responsesDocument, \"supported-input-types\")\n    .map((element) => collapseText(element))\n    .join(\" \")\n    .toLowerCase();\n  const inputTypeWords = new Set(inputTypes.split(/[^a-z0-9]+/).filter(Boolean));\n  const imageInput = inputTypeWords.has(\"text\") && inputTypeWords.has(\"image\") ? responses : [];\n  const applyPatch = codeValuesAfterHeading(responsesDocument, \"limitations\").includes(\n    \"apply_patch\",\n  )\n    ? responses\n    : [];\n  const webSearch = nativeWebSearchModels(load(webSearchHtml), responses);\n  if (webSearch.length === 0) {\n    throw new Error(\"Databricks documentation contained no native web-search models\");\n  }\n  return {\n    generatedAt,\n    capabilities: { responses, imageInput, applyPatch, webSearch },\n  };\n}\n\n/** Parse pay-per-token limits from Databricks Foundation Model API HTML. */\nexport function parseModelRateLimits(html: string, generatedAt: number): ModelRateLimitsSnapshot {\n  const $ = load(html);\n  const models: Record<string, ModelRateLimitCatalogue[\"models\"][string]> = {};\n  $(\"table\").each((_, table) => {\n    const rows = $(table).find(\"tr\");\n    const headers = $(rows.get(0))\n      .find(\"th, td\")\n      .toArray()\n      .map((cell) => collapseText($(cell)).toLowerCase());\n    const modelIndex = headers.findIndex((value) => value.includes(\"model\"));\n    const inputIndex = headers.findIndex((value) => value.includes(\"itpm\"));\n    const outputIndex = headers.findIndex((value) => value.includes(\"otpm\"));\n    const queryIndex = headers.findIndex((value) => value.includes(\"qph\"));\n    if (modelIndex < 0 || inputIndex < 0 || outputIndex < 0) return;\n    rows.slice(1).each((__, row) => {\n      const cells = $(row)\n        .find(\"th, td\")\n        .toArray()\n        .map((cell) => collapseText($(cell)));\n      const key = modelKey(cells[modelIndex]);\n      if (!key) return;\n      models[key] = {\n        inputTokensPerMinute: number(cells[inputIndex]),\n        outputTokensPerMinute: number(cells[outputIndex]),\n        queriesPerHour: queryIndex < 0 ? null : number(cells[queryIndex]),\n      };\n    });\n  });\n  if (Object.keys(models).length === 0) {\n    throw new Error(\"Databricks model-limit documentation contained no models\");\n  }\n  return { generatedAt, catalogue: { models: sortRecord(models) } };\n}\n\nfunction modelsAfterHeading($: CheerioAPI, headingId: string): string[] {\n  return [\n    ...new Set(codeValuesAfterHeading($, headingId).flatMap((value) => modelKey(value) ?? [])),\n  ].sort();\n}\n\nfunction nativeWebSearchModels($: CheerioAPI, responses: readonly string[]): string[] {\n  const families = new Set<string>();\n  const models = new Set<string>();\n  let nativeSection = false;\n  for (const element of sectionElements($, \"supported-models\")) {\n    if (headingLevel(nodeTagName(element.get(0))) !== undefined) {\n      nativeSection = !collapseText(element).toLowerCase().includes(\"via mcp\");\n      continue;\n    }\n    if (!nativeSection) continue;\n    const values = nodeTagName(element.get(0)) === \"code\" ? [collapseText(element)] : [];\n    element.find(\"code\").each((_, code) => {\n      values.push(collapseText($(code)));\n    });\n    for (const value of values) {\n      const model = modelKey(value);\n      if (!model) continue;\n      models.add(model);\n      families.add(model.split(\"-\", 1)[0]);\n    }\n  }\n  for (const model of responses) {\n    if (families.has(model.split(\"-\", 1)[0])) models.add(model);\n  }\n  return [...models].sort();\n}\n\nfunction codeValuesAfterHeading($: CheerioAPI, headingId: string): string[] {\n  const values: string[] = [];\n  for (const element of sectionElements($, headingId)) {\n    if (nodeTagName(element.get(0)) === \"code\") values.push(collapseText(element));\n    element.find(\"code\").each((_, code) => {\n      values.push(collapseText($(code)));\n    });\n  }\n  return values;\n}\n\nfunction sectionElements($: CheerioAPI, headingId: string): Selection[] {\n  const heading = $(`#${headingId}`).first();\n  if (heading.length === 0)\n    throw new Error(`Databricks capability page is missing section ${headingId}`);\n  const level = headingLevel(nodeTagName(heading.get(0)));\n  if (level === undefined)\n    throw new Error(`Databricks capability section ${headingId} is not a heading`);\n  const elements: Selection[] = [];\n  let sibling = heading.next();\n  while (sibling.length > 0) {\n    const siblingLevel = headingLevel(nodeTagName(sibling.get(0)));\n    if (siblingLevel !== undefined && siblingLevel <= level) break;\n    elements.push(sibling);\n    sibling = sibling.next();\n  }\n  return elements;\n}\n\nfunction headingLevel(name: string | undefined): number | undefined {\n  const match = /^h([1-6])$/.exec(name ?? \"\");\n  return match ? Number(match[1]) : undefined;\n}\n\nfunction collapseText(element: Selection): string {\n  return element.text().split(/\\s+/).filter(Boolean).join(\" \");\n}\n\nfunction nodeTagName(node: unknown): string | undefined {\n  if (!node || typeof node !== \"object\" || !(\"tagName\" in node)) return undefined;\n  return typeof node.tagName === \"string\" ? node.tagName : undefined;\n}\n\nfunction modelKey(value: string | undefined): string | undefined {\n  if (!value) return undefined;\n  let name = value.trim().replace(/\\*+$/, \"\").trim();\n  for (const suffix of [\"(Public Preview)\", \"(Beta)\", \"(Preview)\"]) {\n    if (name.endsWith(suffix)) name = name.slice(0, -suffix.length).trim();\n  }\n  return modelSearchQuery(name)?.replaceAll(\" \", \"-\");\n}\n\nfunction number(value: string | undefined): number | null {\n  if (!value) return null;\n  const parsed = Number(value.replaceAll(\",\", \"\").trim());\n  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;\n}\n\nfunction sortRecord<T>(record: Readonly<Record<string, T>>): Record<string, T> {\n  return Object.fromEntries(\n    Object.entries(record).sort(([left], [right]) => left.localeCompare(right)),\n  );\n}\n"]}

package/lib/src/_ranking.d.ts

@@ -0,0 +1,20 @@
+import { type ModelClass as ModelClassType, type ModelQuery, type RankedModel, 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";
+};
+interface NativeRankingOptions {
+    readonly includeDeprecated?: boolean;
+    readonly modelClass?: ModelClass;
+    readonly task?: string;
+}
+/** Rank endpoint records through the TypeScript-owned model policy. */
+export declare function rankEndpoints(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery, options?: NativeRankingOptions): RankedModel[];
+/** Classify chat and embedding endpoints through the TypeScript-owned policy. */
+export declare function classifyEndpointClasses(endpoints: readonly ServingEndpointSummary[]): ReadonlyMap<string, ModelClass>;
+/** Normalize serialized SDK endpoint records without native bindings. */
+export declare function normalizeEndpoints(endpoints: readonly unknown[]): ServingEndpointSummary[];
+export {};