@dbx-tools/shared-model 0.6.62 → 0.6.64

package/README.md

@@ -49,6 +49,7 @@ import { model } from "@dbx-tools/shared-model";
 const query = model.ModelQuerySchema.parse({
   search: "claude sonnet",
   modelClass: "chat-balanced",
+  requiresTools: true,
   limit: 5,
 });
 ```
@@ -67,7 +68,9 @@ const ranked: RankedModel = model.RankedModelSchema.parse(response);
 
 `model.ServingEndpointSummarySchema` describes the stable endpoint fields exposed
 to clients: endpoint name, task, state, optional profile scores, classified
-class, and embedding dimension.
+class, `supportsTools`, and embedding dimension. `requiresTools: true` filters
+search/ranking to endpoints that can complete both a function call and the
+subsequent `function_call_output` replay.
 
 ## Classify Endpoint Catalogues
 
@@ -76,8 +79,16 @@ import { classify, model } from "@dbx-tools/shared-model";
 
 const byClass = classify.classifyEndpoints(endpoints);
 const fast = byClass[model.ModelClass.ChatFast];
+const agentModels = endpoints.filter((endpoint) => classify.endpointCapabilities(endpoint).tools);
 ```
 
+Databricks currently exposes no tool-capability attribute in the endpoint list
+or OpenAPI schema. `supportsTools` therefore uses a conservative, live-verified
+provider-family policy: GPT (except GPT-OSS), Claude, Qwen, GLM, and Llama.
+Gemini is excluded because its Open Responses tool-result replay requires a
+thought signature the wire does not currently accept; GPT-OSS rejects Responses
+passthrough. An explicit `supportsTools` stamp overrides the family fallback.
+
 The classifier uses Foundation Model API quality/speed/cost scores when present
 and family-name heuristics when scores are missing. This is useful for client
 grouping, tests, and offline catalogue analysis.

package/lib/src/classify.d.ts

@@ -32,9 +32,20 @@ export interface EndpointCapabilities {
     chat: boolean;
     /** Embedding (vector) endpoint. */
     embedding: boolean;
-    /** Function / tool calling. Every chat endpoint on Databricks supports it. */
+    /** 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

package/lib/src/classify.js

@@ -30,6 +30,26 @@ import { ModelClass } from "./model.js";
 const CHAT_TASK = "llm/v1/chat";
 /** Task hint Databricks stamps on embedding endpoints. */
 const EMBEDDING_TASK = "llm/v1/embeddings";
+/**
+ * Provider families verified against Databricks Responses/Open Responses with
+ * both a forced function call and a stateless `function_call_output` replay.
+ *
+ * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.
+ * Keep this conservative: an unknown chat family is not agent-safe until it is
+ * verified. Gemini is excluded because it emits a call but Open Responses
+ * cannot replay the required thought signature; GPT-OSS rejects Responses
+ * passthrough entirely.
+ */
+export function supportsToolsByFamily(name) {
+    const n = name.toLowerCase();
+    if (n.includes("gemini") || n.includes("gpt-oss"))
+        return false;
+    return (n.includes("claude") ||
+        n.includes("gpt") ||
+        n.includes("qwen") ||
+        n.includes("glm") ||
+        n.includes("llama"));
+}
 /**
  * Derive an endpoint's capabilities from its Databricks task hint and its
  * classified {@link ModelClass}, so consumers filter on capability instead of
@@ -45,7 +65,8 @@ export function endpointCapabilities(endpoint) {
     // Every non-embedding class is a chat band, so "classified but not embedding"
     // is the class-side test for chat capability.
     const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);
-    return { chat, embedding, tools: chat };
+    const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));
+    return { chat, embedding, tools };
 }
 /**
  * Numeric `[major, minor, patch]` version parsed from an endpoint
@@ -258,4 +279,4 @@ export function classifyEndpoints(endpoints) {
         [ModelClass.Embedding]: embeddings,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport { ModelClass, type ServingEndpointSummary } from \"./model.ts\";\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */\nexport interface EndpointCapabilities {\n  /** OpenAI chat/completions + Responses: the surface a chat agent needs. */\n  chat: boolean;\n  /** Embedding (vector) endpoint. */\n  embedding: boolean;\n  /** Function / tool calling. Every chat endpoint on Databricks supports it. */\n  tools: boolean;\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  return { chat, embedding, tools: chat };\n}\n\n/** Family-heuristic classification of a single endpoint name. */\nexport interface FamilyClass {\n  /** Chat capability band the family maps to (never embedding). */\n  class: ModelClass;\n  /** Intra-family ordering hint (higher is newer / more capable). */\n  rank: number;\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  for (let i = 0; i < 3; i++) {\n    const diff = (b[i] ?? 0) - (a[i] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport { ModelClass, type ServingEndpointSummary } from \"./model.ts\";\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */\nexport interface EndpointCapabilities {\n  /** OpenAI chat/completions + Responses: the surface a chat agent needs. */\n  chat: boolean;\n  /** Embedding (vector) endpoint. */\n  embedding: boolean;\n  /** Complete function-tool round-trip (call plus function_call_output replay). */\n  tools: boolean;\n}\n\n/**\n * Provider families verified against Databricks Responses/Open Responses with\n * both a forced function call and a stateless `function_call_output` replay.\n *\n * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.\n * Keep this conservative: an unknown chat family is not agent-safe until it is\n * verified. Gemini is excluded because it emits a call but Open Responses\n * cannot replay the required thought signature; GPT-OSS rejects Responses\n * passthrough entirely.\n */\nexport function supportsToolsByFamily(name: string): boolean {\n  const n = name.toLowerCase();\n  if (n.includes(\"gemini\") || n.includes(\"gpt-oss\")) return false;\n  return (\n    n.includes(\"claude\") ||\n    n.includes(\"gpt\") ||\n    n.includes(\"qwen\") ||\n    n.includes(\"glm\") ||\n    n.includes(\"llama\")\n  );\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));\n  return { chat, embedding, tools };\n}\n\n/** Family-heuristic classification of a single endpoint name. */\nexport interface FamilyClass {\n  /** Chat capability band the family maps to (never embedding). */\n  class: ModelClass;\n  /** Intra-family ordering hint (higher is newer / more capable). */\n  rank: number;\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  for (let i = 0; i < 3; i++) {\n    const diff = (b[i] ?? 0) - (a[i] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}

package/lib/src/model.d.ts

@@ -54,6 +54,7 @@ export declare const ServingEndpointSummarySchema: z.ZodObject<{
     task: z.ZodOptional<z.ZodString>;
     state: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
+    supportsTools: z.ZodOptional<z.ZodBoolean>;
     profile: z.ZodOptional<z.ZodObject<{
         quality: z.ZodOptional<z.ZodNumber>;
         speed: z.ZodOptional<z.ZodNumber>;
@@ -78,6 +79,7 @@ export type ServingEndpointSummary = z.infer<typeof ServingEndpointSummarySchema
 export declare const ModelQuerySchema: z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     modelClass: z.ZodOptional<z.ZodEnum<typeof ModelClass>>;
+    requiresTools: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
     threshold: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -93,6 +95,7 @@ export declare const RankedModelSchema: z.ZodObject<{
         task: z.ZodOptional<z.ZodString>;
         state: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
+        supportsTools: z.ZodOptional<z.ZodBoolean>;
         profile: z.ZodOptional<z.ZodObject<{
             quality: z.ZodOptional<z.ZodNumber>;
             speed: z.ZodOptional<z.ZodNumber>;

package/lib/src/model.js

@@ -69,6 +69,10 @@ export const ServingEndpointSummarySchema = z.object({
     task: z.string().optional().describe("Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'."),
     state: z.string().optional().describe("Deployment state, e.g. ready, updating, or failed."),
     description: z.string().optional().describe("Free-form endpoint description; informational."),
+    supportsTools: z
+        .boolean()
+        .optional()
+        .describe("Whether this endpoint supports a complete function-tool round-trip (call plus function_call_output replay). Derived from verified provider-family policy when Databricks exposes no capability attribute."),
     profile: ModelProfileSchema.optional().describe("Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise."),
     class: ModelClassSchema.optional().describe("Class the endpoint was classified into; absent when the classifier doesn't recognize it."),
     dimension: z
@@ -94,6 +98,10 @@ export const ModelQuerySchema = z.object({
         .optional()
         .describe("Loose name fuzzy-matched against endpoint names, e.g. 'claude sonnet'. Omit to rank by class alone."),
     modelClass: ModelClassSchema.optional().describe("Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band."),
+    requiresTools: z
+        .boolean()
+        .optional()
+        .describe("When true, consider only endpoints that support a complete function-tool round-trip."),
     limit: z
         .number()
         .int()
@@ -120,4 +128,4 @@ export const RankedModelSchema = z.object({
         .optional()
         .describe("Fuzzy-match distance (0 = exact .. 1 = worst) when the query carried a search; absent for class-only ranking."),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Wire-format types for the model toolkit: the model class taxonomy,\n * the Foundation Model API score profile, the minimal serving-endpoint\n * descriptor, and the model-lookup request / ranked-result contract.\n * Pure types and zod schemas - no Node-only imports - so a browser\n * client (or an agent tool's `inputSchema`) can validate a lookup\n * request and type a ranked response without dragging in server\n * dependencies.\n *\n * @module\n */\n\nimport { z } from \"zod\";\n\n/**\n * Class of a Databricks Model Serving endpoint - its modality plus,\n * for chat models, a capability band. Chat endpoints split by measured\n * `quality` into a three-rung ladder; embeddings are a separate\n * modality, not a rung on that ladder.\n *\n * String enum so the value is the slug used in cache keys, logs, query\n * strings, and serialized configs - and is what a client sends to\n * request a class.\n */\nexport enum ModelClass {\n  ChatThinking = \"chat-thinking\",\n  ChatBalanced = \"chat-balanced\",\n  ChatFast = \"chat-fast\",\n  Embedding = \"embedding\",\n}\n\nconst ModelClassDescriptions: Record<ModelClass, string> = {\n  [ModelClass.ChatThinking]:\n    \"Most capable reasoning for hard, multi-step tasks; slowest and most expensive.\",\n  [ModelClass.ChatBalanced]:\n    \"Good default for most chat and agent work; balances quality, speed, and cost.\",\n  [ModelClass.ChatFast]:\n    \"Fastest and cheapest; best for simple tasks like classification, routing, and short summaries.\",\n  [ModelClass.Embedding]:\n    \"Produces text embeddings (vectors), not chat replies; not interchangeable with chat models.\",\n};\n\nexport const ModelClassSchema = z.enum(ModelClass).describe(\n  `Endpoint class slug: ${(Object.values(ModelClass) as ModelClass[])\n    .map((modelClass) => {\n      return `'${modelClass}' (${ModelClassDescriptions[modelClass]})`;\n    })\n    .join(\", \")}.`,\n);\n\n/**\n * Foundation Model API quality / speed / cost scores Databricks\n * publishes per pay-per-token endpoint (the bars shown in the AI\n * Playground). Surfaced from the serving list under\n * `config.served_entities[].foundation_model.ai_gateway_model_profile`\n * so the class classifier can rank models from live, workspace-local\n * numbers instead of a hand-maintained table. Scales are relative and\n * unitless; all axes are absent for custom or brand-new endpoints that\n * have no profile yet.\n */\nexport const ModelProfileSchema = z.object({\n  quality: z.number().optional().describe(\"Relative quality score; higher is better.\"),\n  speed: z.number().optional().describe(\"Relative throughput score; higher is faster.\"),\n  cost: z.number().optional().describe(\"Relative price score; lower is cheaper.\"),\n});\nexport type ModelProfile = z.infer<typeof ModelProfileSchema>;\n\n/**\n * Minimal descriptor for a Databricks Model Serving endpoint - a\n * stable subset of the SDK type so cache hits and `/models` responses\n * never expose SDK internals.\n */\nexport const ServingEndpointSummarySchema = z.object({\n  name: z\n    .string()\n    .describe(\n      \"Endpoint name as listed by the Model Serving REST API; the id used to invoke the model.\",\n    ),\n  displayName: z\n    .string()\n    .optional()\n    .describe(\n      \"Human-readable label for the endpoint: a Databricks-provided name when present (a display-name tag or external-model name), else a title-cased rendering of `name` with vendor prefixes stripped. `name` remains the invoke id.\",\n    ),\n  task: z.string().optional().describe(\"Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'.\"),\n  state: z.string().optional().describe(\"Deployment state, e.g. ready, updating, or failed.\"),\n  description: z.string().optional().describe(\"Free-form endpoint description; informational.\"),\n  profile: ModelProfileSchema.optional().describe(\n    \"Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise.\",\n  ),\n  class: ModelClassSchema.optional().describe(\n    \"Class the endpoint was classified into; absent when the classifier doesn't recognize it.\",\n  ),\n  dimension: z\n    .number()\n    .optional()\n    .describe(\n      \"Embedding vector length, measured by a best-effort server-side ping. Only set for embedding endpoints, and only when the probe succeeded.\",\n    ),\n});\nexport type ServingEndpointSummary = z.infer<typeof ServingEndpointSummarySchema>;\n\n/**\n * A model-lookup request: search string, capability ceiling, both, or\n * nothing. This is the caller-facing query the `@dbx-tools/model`\n * ranker reads - shaped as a zod schema (with per-field descriptions)\n * so an agent tool can adopt it directly as its `inputSchema` and a\n * browser client can validate args before calling the model service.\n *\n * Every field is optional: an empty query ranks the live catalogue by\n * class alone. The \"this class and below\" ceiling semantics and the\n * match-then-class ordering live in the service, not here - this\n * surface is declarative.\n */\nexport const ModelQuerySchema = z.object({\n  search: z\n    .string()\n    .optional()\n    .describe(\n      \"Loose name fuzzy-matched against endpoint names, e.g. 'claude sonnet'. Omit to rank by class alone.\",\n    ),\n  modelClass: ModelClassSchema.optional().describe(\n    \"Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band.\",\n  ),\n  limit: z\n    .number()\n    .int()\n    .positive()\n    .max(50)\n    .optional()\n    .describe(\"Maximum number of ranked results to return.\"),\n  threshold: z\n    .number()\n    .min(0)\n    .max(1)\n    .optional()\n    .describe(\"Fuzzy-match distance cutoff (0 = exact, 1 = match anything). Default 0.4.\"),\n});\nexport type ModelQuery = z.infer<typeof ModelQuerySchema>;\n\n/**\n * One ranked lookup result. Backs an agent tool's `outputSchema` and a\n * `/models` ranked response.\n */\nexport const RankedModelSchema = z.object({\n  endpoint: ServingEndpointSummarySchema.describe(\"The matched serving endpoint.\"),\n  modelClass: ModelClassSchema.describe(\"Class the endpoint was classified into.\"),\n  score: z\n    .number()\n    .optional()\n    .describe(\n      \"Fuzzy-match distance (0 = exact .. 1 = worst) when the query carried a search; absent for class-only ranking.\",\n    ),\n});\nexport type RankedModel = z.infer<typeof RankedModelSchema>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,4CAA8B,CAAA;IAC9B,4CAA8B,CAAA;IAC9B,oCAAsB,CAAA;IACtB,qCAAuB,CAAA;AACzB,CAAC,EALW,UAAU,KAAV,UAAU,QAKrB;AAED,MAAM,sBAAsB,GAA+B;IACzD,CAAC,UAAU,CAAC,YAAY,CAAC,EACvB,gFAAgF;IAClF,CAAC,UAAU,CAAC,YAAY,CAAC,EACvB,+EAA+E;IACjF,CAAC,UAAU,CAAC,QAAQ,CAAC,EACnB,gGAAgG;IAClG,CAAC,UAAU,CAAC,SAAS,CAAC,EACpB,6FAA6F;CAChG,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,QAAQ,CACzD,wBAAyB,MAAM,CAAC,MAAM,CAAC,UAAU,CAAkB;KAChE,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE;IAClB,OAAO,IAAI,UAAU,MAAM,sBAAsB,CAAC,UAAU,CAAC,GAAG,CAAC;AACnE,CAAC,CAAC;KACD,IAAI,CAAC,IAAI,CAAC,GAAG,CACjB,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACpF,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8CAA8C,CAAC;IACrF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;CAChF,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,IAAI,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,QAAQ,CACP,yFAAyF,CAC1F;IACH,WAAW,EAAE,CAAC;SACX,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,iOAAiO,CAClO;IACH,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,uDAAuD,CAAC;IAC7F,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oDAAoD,CAAC;IAC3F,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gDAAgD,CAAC;IAC7F,aAAa,EAAE,CAAC;SACb,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACP,2MAA2M,CAC5M;IACH,OAAO,EAAE,kBAAkB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC7C,qHAAqH,CACtH;IACD,KAAK,EAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACzC,0FAA0F,CAC3F;IACD,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,2IAA2I,CAC5I;CACJ,CAAC,CAAC;AAGH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,CAAC;SACN,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,qGAAqG,CACtG;IACH,UAAU,EAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC9C,mLAAmL,CACpL;IACD,aAAa,EAAE,CAAC;SACb,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACP,sFAAsF,CACvF;IACH,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,GAAG,CAAC,EAAE,CAAC;SACP,QAAQ,EAAE;SACV,QAAQ,CAAC,6CAA6C,CAAC;IAC1D,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC,2EAA2E,CAAC;CACzF,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,QAAQ,EAAE,4BAA4B,CAAC,QAAQ,CAAC,+BAA+B,CAAC;IAChF,UAAU,EAAE,gBAAgB,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IAChF,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,+GAA+G,CAChH;CACJ,CAAC,CAAC","sourcesContent":["/**\n * Wire-format types for the model toolkit: the model class taxonomy,\n * the Foundation Model API score profile, the minimal serving-endpoint\n * descriptor, and the model-lookup request / ranked-result contract.\n * Pure types and zod schemas - no Node-only imports - so a browser\n * client (or an agent tool's `inputSchema`) can validate a lookup\n * request and type a ranked response without dragging in server\n * dependencies.\n *\n * @module\n */\n\nimport { z } from \"zod\";\n\n/**\n * Class of a Databricks Model Serving endpoint - its modality plus,\n * for chat models, a capability band. Chat endpoints split by measured\n * `quality` into a three-rung ladder; embeddings are a separate\n * modality, not a rung on that ladder.\n *\n * String enum so the value is the slug used in cache keys, logs, query\n * strings, and serialized configs - and is what a client sends to\n * request a class.\n */\nexport enum ModelClass {\n  ChatThinking = \"chat-thinking\",\n  ChatBalanced = \"chat-balanced\",\n  ChatFast = \"chat-fast\",\n  Embedding = \"embedding\",\n}\n\nconst ModelClassDescriptions: Record<ModelClass, string> = {\n  [ModelClass.ChatThinking]:\n    \"Most capable reasoning for hard, multi-step tasks; slowest and most expensive.\",\n  [ModelClass.ChatBalanced]:\n    \"Good default for most chat and agent work; balances quality, speed, and cost.\",\n  [ModelClass.ChatFast]:\n    \"Fastest and cheapest; best for simple tasks like classification, routing, and short summaries.\",\n  [ModelClass.Embedding]:\n    \"Produces text embeddings (vectors), not chat replies; not interchangeable with chat models.\",\n};\n\nexport const ModelClassSchema = z.enum(ModelClass).describe(\n  `Endpoint class slug: ${(Object.values(ModelClass) as ModelClass[])\n    .map((modelClass) => {\n      return `'${modelClass}' (${ModelClassDescriptions[modelClass]})`;\n    })\n    .join(\", \")}.`,\n);\n\n/**\n * Foundation Model API quality / speed / cost scores Databricks\n * publishes per pay-per-token endpoint (the bars shown in the AI\n * Playground). Surfaced from the serving list under\n * `config.served_entities[].foundation_model.ai_gateway_model_profile`\n * so the class classifier can rank models from live, workspace-local\n * numbers instead of a hand-maintained table. Scales are relative and\n * unitless; all axes are absent for custom or brand-new endpoints that\n * have no profile yet.\n */\nexport const ModelProfileSchema = z.object({\n  quality: z.number().optional().describe(\"Relative quality score; higher is better.\"),\n  speed: z.number().optional().describe(\"Relative throughput score; higher is faster.\"),\n  cost: z.number().optional().describe(\"Relative price score; lower is cheaper.\"),\n});\nexport type ModelProfile = z.infer<typeof ModelProfileSchema>;\n\n/**\n * Minimal descriptor for a Databricks Model Serving endpoint - a\n * stable subset of the SDK type so cache hits and `/models` responses\n * never expose SDK internals.\n */\nexport const ServingEndpointSummarySchema = z.object({\n  name: z\n    .string()\n    .describe(\n      \"Endpoint name as listed by the Model Serving REST API; the id used to invoke the model.\",\n    ),\n  displayName: z\n    .string()\n    .optional()\n    .describe(\n      \"Human-readable label for the endpoint: a Databricks-provided name when present (a display-name tag or external-model name), else a title-cased rendering of `name` with vendor prefixes stripped. `name` remains the invoke id.\",\n    ),\n  task: z.string().optional().describe(\"Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'.\"),\n  state: z.string().optional().describe(\"Deployment state, e.g. ready, updating, or failed.\"),\n  description: z.string().optional().describe(\"Free-form endpoint description; informational.\"),\n  supportsTools: z\n    .boolean()\n    .optional()\n    .describe(\n      \"Whether this endpoint supports a complete function-tool round-trip (call plus function_call_output replay). Derived from verified provider-family policy when Databricks exposes no capability attribute.\",\n    ),\n  profile: ModelProfileSchema.optional().describe(\n    \"Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise.\",\n  ),\n  class: ModelClassSchema.optional().describe(\n    \"Class the endpoint was classified into; absent when the classifier doesn't recognize it.\",\n  ),\n  dimension: z\n    .number()\n    .optional()\n    .describe(\n      \"Embedding vector length, measured by a best-effort server-side ping. Only set for embedding endpoints, and only when the probe succeeded.\",\n    ),\n});\nexport type ServingEndpointSummary = z.infer<typeof ServingEndpointSummarySchema>;\n\n/**\n * A model-lookup request: search string, capability ceiling, both, or\n * nothing. This is the caller-facing query the `@dbx-tools/model`\n * ranker reads - shaped as a zod schema (with per-field descriptions)\n * so an agent tool can adopt it directly as its `inputSchema` and a\n * browser client can validate args before calling the model service.\n *\n * Every field is optional: an empty query ranks the live catalogue by\n * class alone. The \"this class and below\" ceiling semantics and the\n * match-then-class ordering live in the service, not here - this\n * surface is declarative.\n */\nexport const ModelQuerySchema = z.object({\n  search: z\n    .string()\n    .optional()\n    .describe(\n      \"Loose name fuzzy-matched against endpoint names, e.g. 'claude sonnet'. Omit to rank by class alone.\",\n    ),\n  modelClass: ModelClassSchema.optional().describe(\n    \"Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band.\",\n  ),\n  requiresTools: z\n    .boolean()\n    .optional()\n    .describe(\n      \"When true, consider only endpoints that support a complete function-tool round-trip.\",\n    ),\n  limit: z\n    .number()\n    .int()\n    .positive()\n    .max(50)\n    .optional()\n    .describe(\"Maximum number of ranked results to return.\"),\n  threshold: z\n    .number()\n    .min(0)\n    .max(1)\n    .optional()\n    .describe(\"Fuzzy-match distance cutoff (0 = exact, 1 = match anything). Default 0.4.\"),\n});\nexport type ModelQuery = z.infer<typeof ModelQuerySchema>;\n\n/**\n * One ranked lookup result. Backs an agent tool's `outputSchema` and a\n * `/models` ranked response.\n */\nexport const RankedModelSchema = z.object({\n  endpoint: ServingEndpointSummarySchema.describe(\"The matched serving endpoint.\"),\n  modelClass: ModelClassSchema.describe(\"Class the endpoint was classified into.\"),\n  score: z\n    .number()\n    .optional()\n    .describe(\n      \"Fuzzy-match distance (0 = exact .. 1 = worst) when the query carried a search; absent for class-only ranking.\",\n    ),\n});\nexport type RankedModel = z.infer<typeof RankedModelSchema>;\n"]}

package/package.json

@@ -23,7 +23,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.62",
+    "@dbx-tools/shared-core": "0.6.64",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -40,7 +40,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.62",
+  "version": "0.6.64",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/classify.ts

@@ -40,10 +40,32 @@ export interface EndpointCapabilities {
   chat: boolean;
   /** Embedding (vector) endpoint. */
   embedding: boolean;
-  /** Function / tool calling. Every chat endpoint on Databricks supports it. */
+  /** 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 function supportsToolsByFamily(name: string): boolean {
+  const n = name.toLowerCase();
+  if (n.includes("gemini") || n.includes("gpt-oss")) return false;
+  return (
+    n.includes("claude") ||
+    n.includes("gpt") ||
+    n.includes("qwen") ||
+    n.includes("glm") ||
+    n.includes("llama")
+  );
+}
+
 /**
  * Derive an endpoint's capabilities from its Databricks task hint and its
  * classified {@link ModelClass}, so consumers filter on capability instead of
@@ -59,7 +81,8 @@ export function endpointCapabilities(endpoint: ServingEndpointSummary): Endpoint
   // Every non-embedding class is a chat band, so "classified but not embedding"
   // is the class-side test for chat capability.
   const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);
-  return { chat, embedding, tools: chat };
+  const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));
+  return { chat, embedding, tools };
 }
 
 /** Family-heuristic classification of a single endpoint name. */

package/src/model.ts

@@ -85,6 +85,12 @@ export const ServingEndpointSummarySchema = z.object({
   task: z.string().optional().describe("Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'."),
   state: z.string().optional().describe("Deployment state, e.g. ready, updating, or failed."),
   description: z.string().optional().describe("Free-form endpoint description; informational."),
+  supportsTools: z
+    .boolean()
+    .optional()
+    .describe(
+      "Whether this endpoint supports a complete function-tool round-trip (call plus function_call_output replay). Derived from verified provider-family policy when Databricks exposes no capability attribute.",
+    ),
   profile: ModelProfileSchema.optional().describe(
     "Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise.",
   ),
@@ -122,6 +128,12 @@ export const ModelQuerySchema = z.object({
   modelClass: ModelClassSchema.optional().describe(
     "Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band.",
   ),
+  requiresTools: z
+    .boolean()
+    .optional()
+    .describe(
+      "When true, consider only endpoints that support a complete function-tool round-trip.",
+    ),
   limit: z
     .number()
     .int()