@dbx-tools/appkit-mastra 0.1.40 → 0.1.42

package/dist/src/plugin.d.ts

@@ -1,9 +1,9 @@
 /**
  * AppKit plugin that builds one or more Mastra `Agent` instances and
- * mounts the `@mastra/express` server plus `@mastra/ai-sdk` `chatRoute`
- * handlers. The UI message stream matches what `chatRoute()` emits, so
- * the client can use `useChat()` from `@ai-sdk/react` without custom
- * parsing.
+ * mounts the `@mastra/express` server. Clients drive the conversation
+ * over the standard Mastra agent stream (`@mastra/client-js`'s
+ * `getAgent(id).stream()`), so there's no bespoke chat transport to
+ * keep in sync.
  *
  * - Agents: registered through `config.agents` at plugin creation
  *   ({@link MastraAgentDefinition}). Each entry's `tools` field accepts
@@ -21,17 +21,18 @@
  *   `schemaName: "mastra_<agentId>"`; the vector store is a single
  *   shared singleton across every agent.
  * - Server: the Express subapp wiring lives in `./server.js`.
- * - HTTP: AppKit mounts this plugin under `/api/mastra`. `chatRoute`
- *   is registered at `/route/chat` (bound to `config.defaultAgent` or
- *   the first registered id) and `/route/chat/:agentId`, so the
- *   AI SDK transport URL is `/api/mastra/route/chat/<agentId>`.
+ * - HTTP: AppKit mounts this plugin under `/api/mastra`. Alongside the
+ *   Mastra agent routes, the plugin registers `/route/history`
+ *   (load + clear thread history), `/models`, `/suggestions`, and the
+ *   generic `/embed/:type/:id` resolver for inline chart / data
+ *   markers.
  */
 import { Plugin, type IAppRouter, type ResourceRequirement } from "@databricks/appkit";
 import type { Agent } from "@mastra/core/agent";
 import { Mastra } from "@mastra/core/mastra";
+import { type ServingEndpointSummary } from "@dbx-tools/model";
 import type { MastraPluginConfig } from "./config.js";
 import { MastraServer } from "./server.js";
-import { type ServingEndpointSummary } from "./serving.js";
 /**
  * AppKit plugin (registered name: `mastra`) that hosts Mastra agents
  * with optional Lakebase-backed memory and AI SDK chat routes under
@@ -59,6 +60,14 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
     private mastra;
     private mastraApp;
     private mastraServer;
+    /**
+     * Dedicated service-principal Lakebase pool backing Mastra memory /
+     * storage. Built once in {@link buildAgentAndServer} (outside any
+     * `asUser` scope, so it never inherits a request's OBO identity) and
+     * drained in {@link abortActiveOperations}. `null` until setup runs
+     * or when Lakebase isn't needed.
+     */
+    private servicePrincipalPool;
     setup(): Promise<void>;
     /**
      * When the `lakebase` plugin is registered, auto-enable `storage`
@@ -68,6 +77,13 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
      * already in the registry by the time this fires.
      */
     private applyLakebaseAutoDefaults;
+    /**
+     * Drain the memory service-principal pool on shutdown. AppKit calls
+     * this during teardown; the lakebase plugin closes its own SP / OBO
+     * pools the same way. Fire-and-forget so shutdown isn't blocked on a
+     * slow drain, and clear the handle so a re-`setup()` rebuilds it.
+     */
+    abortActiveOperations(): void;
     exports(): {
         /**
          * Ids of every registered agent in registration order. Matches
@@ -82,9 +98,9 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
          */
         get: (id: string) => Agent | null;
         /**
-         * The agent `chatRoute` binds to when the client doesn't name
-         * one. Resolves to `config.defaultAgent`, the first registered
-         * id, or the built-in `default` fallback.
+         * The agent the client converses with when it doesn't name one.
+         * Resolves to `config.defaultAgent`, the first registered id, or
+         * the built-in `default` fallback.
          */
         getDefault: () => Agent | null;
         /** Underlying Mastra instance for advanced use (custom routes etc.). */

package/dist/src/plugin.js

@@ -1,9 +1,9 @@
 /**
  * AppKit plugin that builds one or more Mastra `Agent` instances and
- * mounts the `@mastra/express` server plus `@mastra/ai-sdk` `chatRoute`
- * handlers. The UI message stream matches what `chatRoute()` emits, so
- * the client can use `useChat()` from `@ai-sdk/react` without custom
- * parsing.
+ * mounts the `@mastra/express` server. Clients drive the conversation
+ * over the standard Mastra agent stream (`@mastra/client-js`'s
+ * `getAgent(id).stream()`), so there's no bespoke chat transport to
+ * keep in sync.
  *
  * - Agents: registered through `config.agents` at plugin creation
  *   ({@link MastraAgentDefinition}). Each entry's `tools` field accepts
@@ -21,24 +21,26 @@
  *   `schemaName: "mastra_<agentId>"`; the vector store is a single
  *   shared singleton across every agent.
  * - Server: the Express subapp wiring lives in `./server.js`.
- * - HTTP: AppKit mounts this plugin under `/api/mastra`. `chatRoute`
- *   is registered at `/route/chat` (bound to `config.defaultAgent` or
- *   the first registered id) and `/route/chat/:agentId`, so the
- *   AI SDK transport URL is `/api/mastra/route/chat/<agentId>`.
+ * - HTTP: AppKit mounts this plugin under `/api/mastra`. Alongside the
+ *   Mastra agent routes, the plugin registers `/route/history`
+ *   (load + clear thread history), `/models`, `/suggestions`, and the
+ *   generic `/embed/:type/:id` resolver for inline chart / data
+ *   markers.
  */
 import { genie, getExecutionContext, lakebase, Plugin, toPlugin, } from "@databricks/appkit";
-import { appkitUtils, logUtils } from "@dbx-tools/shared";
-import { chatRoute } from "@mastra/ai-sdk";
+import { appkitUtils, commonUtils, logUtils } from "@dbx-tools/shared";
 import { Mastra } from "@mastra/core/mastra";
 import express from "express";
+import { MASTRA_ROUTES, } from "@dbx-tools/appkit-mastra-shared";
+import { clearServingEndpointsCache, listServingEndpoints, } from "@dbx-tools/model";
 import { buildAgents, FALLBACK_AGENT_ID } from "./agents.js";
 import { fetchChart } from "./chart.js";
 import { collectSpaceSuggestions, resolveGenieSpaces } from "./genie.js";
 import { historyRoute } from "./history.js";
-import { createMemoryBuilder, needsLakebase } from "./memory.js";
+import { createMemoryBuilder, createServicePrincipalPool, needsLakebase, } from "./memory.js";
 import { buildObservability } from "./observability.js";
 import { attachRoutePatchMiddleware, MastraServer } from "./server.js";
-import { clearServingEndpointsCache, listServingEndpoints, resolveServingConfig, } from "./serving.js";
+import { resolveServingConfig } from "./serving.js";
 import { fetchStatementData, isStatementNotFoundError, STATEMENT_ROW_CAP, } from "./statement.js";
 const GENIE_MANIFEST = appkitUtils.data(genie).plugin.manifest;
 const LAKEBASE_MANIFEST = appkitUtils.data(lakebase).plugin.manifest;
@@ -93,6 +95,14 @@ export class MastraPlugin extends Plugin {
     mastra = null;
     mastraApp = null;
     mastraServer = null;
+    /**
+     * Dedicated service-principal Lakebase pool backing Mastra memory /
+     * storage. Built once in {@link buildAgentAndServer} (outside any
+     * `asUser` scope, so it never inherits a request's OBO identity) and
+     * drained in {@link abortActiveOperations}. `null` until setup runs
+     * or when Lakebase isn't needed.
+     */
+    servicePrincipalPool = null;
     async setup() {
         // Wait until sibling plugins (e.g. `lakebase`) finish `setup()` so
         // the lakebase pool is valid when storage/memory are enabled.
@@ -118,6 +128,25 @@ export class MastraPlugin extends Plugin {
         if (this.config.memory === undefined)
             this.config.memory = true;
     }
+    /**
+     * Drain the memory service-principal pool on shutdown. AppKit calls
+     * this during teardown; the lakebase plugin closes its own SP / OBO
+     * pools the same way. Fire-and-forget so shutdown isn't blocked on a
+     * slow drain, and clear the handle so a re-`setup()` rebuilds it.
+     */
+    abortActiveOperations() {
+        super.abortActiveOperations();
+        if (this.servicePrincipalPool) {
+            this.log.info("closing memory SP pool");
+            const pool = this.servicePrincipalPool;
+            this.servicePrincipalPool = null;
+            pool.end().catch((err) => {
+                this.log.error("error closing memory SP pool", {
+                    error: commonUtils.errorMessage(err),
+                });
+            });
+        }
+    }
     exports() {
         return {
             /**
@@ -133,9 +162,9 @@ export class MastraPlugin extends Plugin {
              */
             get: (id) => this.built?.agents[id] ?? null,
             /**
-             * The agent `chatRoute` binds to when the client doesn't name
-             * one. Resolves to `config.defaultAgent`, the first registered
-             * id, or the built-in `default` fallback.
+             * The agent the client converses with when it doesn't name one.
+             * Resolves to `config.defaultAgent`, the first registered id, or
+             * the built-in `default` fallback.
              */
             getDefault: () => (this.built && this.built.agents[this.built.defaultAgentId]) ?? null,
             /** Underlying Mastra instance for advanced use (custom routes etc.). */
@@ -161,22 +190,16 @@ export class MastraPlugin extends Plugin {
     }
     clientConfig() {
         // AppKit mounts every plugin at `/api/<plugin.name>`. `this.name`
-        // honors `config.name` overrides, so the published paths stay
-        // accurate if someone remounts the plugin under a custom id.
+        // honors `config.name` overrides, so publishing `basePath` is
+        // enough for the client to stay correct under a custom mount id -
+        // the per-route segments are fixed (`MASTRA_ROUTES`) and the
+        // client (`MastraPluginClient`) derives every endpoint from
+        // `basePath`.
         // Return widens to `Record<string, unknown>` to satisfy the
         // base-class signature; consumers read it through the typed
         // `MastraClientConfig` shape via `usePluginClientConfig<...>(...)`.
-        const basePath = `/api/${this.name}`;
         const config = {
-            basePath,
-            chatPath: `${basePath}/route/chat`,
-            chatPathTemplate: `${basePath}/route/chat/:agentId`,
-            modelsPath: `${basePath}/models`,
-            historyPath: `${basePath}/route/history`,
-            historyPathTemplate: `${basePath}/route/history/:agentId`,
-            embedPathTemplate: `${basePath}/embed/:type/:id`,
-            suggestionsPath: `${basePath}/suggestions`,
-            suggestionsPathTemplate: `${basePath}/suggestions/:agentId`,
+            basePath: `/api/${this.name}`,
             defaultAgent: this.built?.defaultAgentId ?? FALLBACK_AGENT_ID,
             agents: Object.keys(this.built?.agents ?? {}),
         };
@@ -188,7 +211,7 @@ export class MastraPlugin extends Plugin {
         // be registered before the catch-all that forwards everything to
         // the Mastra subapp. Errors propagate to Express's default error
         // handler via `next(err)` so callers see the real SDK message.
-        router.get("/models", (req, res, next) => {
+        router.get(MASTRA_ROUTES.models, (req, res, next) => {
             this.userScopedSelf(req)
                 .listModels()
                 .then((endpoints) => res.json({ endpoints }))
@@ -240,7 +263,7 @@ export class MastraPlugin extends Plugin {
                 });
             },
         };
-        router.get("/embed/:type/:id", (req, res, next) => {
+        router.get(`${MASTRA_ROUTES.embed}/:type/:id`, (req, res, next) => {
             const type = req.params["type"] ?? "";
             const id = req.params["id"];
             const resolve = embedResolvers[type];
@@ -295,8 +318,8 @@ export class MastraPlugin extends Plugin {
                 res.json({ questions: [] });
             });
         };
-        router.get("/suggestions", handleSuggestions);
-        router.get("/suggestions/:agentId", handleSuggestions);
+        router.get(MASTRA_ROUTES.suggestions, handleSuggestions);
+        router.get(`${MASTRA_ROUTES.suggestions}/:agentId`, handleSuggestions);
         router.use((req, res, next) => {
             if (!this.mastraApp)
                 return res.status(503).end();
@@ -402,12 +425,25 @@ export class MastraPlugin extends Plugin {
         return listServingEndpoints(client, host, { ttlMs: serving.ttlMs });
     }
     async buildAgentAndServer() {
-        // Per-agent memory factory. The builder resolves the Lakebase pool
-        // lazily (on first agent that actually needs storage / vector) and
-        // caches both the pool and the shared `PgVector` singleton so
-        // registering N agents stays cheap. See `./memory.js`.
-        const memoryBuilder = needsLakebase(this.config)
-            ? createMemoryBuilder(this.config, this.context)
+        // Per-agent memory factory. When any storage / memory setting needs
+        // Postgres, stand up a dedicated service-principal pool first so
+        // memory acts as the app SP (owner of the `mastra_*` schemas),
+        // never the per-request OBO identity the chat turn runs under.
+        // `getPgConfig()` is read here, outside any `asUser` scope, so it
+        // returns the SP connection target + token refresh plus any
+        // `lakebase({ pool })` overrides; `require` turns a missing
+        // sibling into a clear wiring error. The builder caches the shared
+        // `PgVector` singleton so registering N agents stays cheap. See
+        // `./memory.js`.
+        if (needsLakebase(this.config)) {
+            const spPgConfig = appkitUtils
+                .require(this.context, lakebase, this.config)
+                .exports()
+                .getPgConfig();
+            this.servicePrincipalPool = await createServicePrincipalPool(spPgConfig);
+        }
+        const memoryBuilder = this.servicePrincipalPool
+            ? createMemoryBuilder(this.config, this.servicePrincipalPool)
             : undefined;
         this.log.debug("build:start", {
             lakebase: memoryBuilder !== undefined,
@@ -455,20 +491,28 @@ export class MastraPlugin extends Plugin {
             mastra: this.mastra,
             prefix: "",
             customApiRoutes: [
-                chatRoute({ path: "/route/chat", agent: this.built.defaultAgentId }),
-                chatRoute({ path: "/route/chat/:agentId" }),
                 // `historyRoute` registers both GET (load) and DELETE
                 // (clear) on the same path, so it returns an array we
                 // splice in.
-                ...historyRoute({ path: "/route/history", agent: this.built.defaultAgentId }),
-                ...historyRoute({ path: "/route/history/:agentId" }),
+                ...historyRoute({
+                    path: MASTRA_ROUTES.history,
+                    agent: this.built.defaultAgentId,
+                }),
+                // Assert the `:agentId` template type: the per-package build's
+                // NodeNext resolution widens the imported `MASTRA_ROUTES.history`
+                // to `string` (the source/bundler typecheck keeps it a literal),
+                // which would otherwise drop this out of the dynamic-agent
+                // overload and demand a fixed `agent`.
+                ...historyRoute({
+                    path: `${MASTRA_ROUTES.history}/:agentId`,
+                }),
             ],
         });
         await this.mastraServer.init();
         this.log.debug("build:done", {
             agents: Object.keys(this.built.agents),
             defaultAgent: this.built.defaultAgentId,
-            routes: ["/route/chat", "/route/history", "/models"],
+            routes: ["/route/history", "/models", "/suggestions", "/embed/:type/:id"],
             instanceStorage: instanceStorage !== undefined,
             observability: observability !== undefined ? "mlflow" : "off",
         });

package/dist/src/server.d.ts

@@ -1,8 +1,8 @@
 /**
  * Express-layer plumbing for the Mastra plugin: a `MastraServer` that
  * stamps the per-request `RequestContext`, and a route-patch middleware
- * that lets `@mastra/ai-sdk` `chatRoute` work behind an Express mount
- * point.
+ * that lets the plugin's custom API routes (e.g. `historyRoute`) work
+ * behind an Express mount point.
  */
 import { type RequestContext } from "@mastra/core/request-context";
 import { MastraServer as MastraServerExpress } from "@mastra/express";
@@ -35,24 +35,17 @@ export declare class MastraServer extends MastraServerExpress {
     configureRequestContextModelOverride(req: express.Request, requestContext: RequestContext): void;
 }
 /**
- * Patches around `@mastra/express`'s custom-route dispatcher so
- * `chatRoute` works when `MastraServer` is hosted on an Express subapp
- * mounted under a parent path (e.g. `/api/mastra`).
+ * Patches around `@mastra/express`'s custom-route dispatcher so the
+ * plugin's custom API routes (e.g. `historyRoute`) work when
+ * `MastraServer` is hosted on an Express subapp mounted under a parent
+ * path (e.g. `/api/mastra`).
  *
- * Two concerns:
- *
- * 1. The adapter's `registerCustomApiRoutes` matches against `req.path`
- *    (mount-relative, correct) but dispatches to its internal Hono
- *    mini-app using `req.originalUrl`, which still contains the parent
- *    mount prefix. The Hono app registers the literal `chatRoute` paths
- *    (for example `/route/chat`), so the absolute URL never matches
- *    until we overwrite `originalUrl` for `/route` and `/route/*` to
- *    the mount-relative path.
- *
- * 2. `memory.resource` must be the authenticated user, not whatever the
- *    client posts. The custom-route forwarder re-serializes `req.body`
- *    into the Request body it hands Hono, so mutating the parsed body
- *    here would propagate into `handleChatStream`'s params (kept for
- *    future use; `express.json()` runs first so `req.body` is parsed).
+ * The adapter's `registerCustomApiRoutes` matches against `req.path`
+ * (mount-relative, correct) but dispatches to its internal Hono
+ * mini-app using `req.originalUrl`, which still contains the parent
+ * mount prefix. The Hono app registers the literal route paths
+ * (for example `/route/history`), so the absolute URL never matches
+ * until we overwrite `originalUrl` for `/route` and `/route/*` to the
+ * mount-relative path.
  */
 export declare function attachRoutePatchMiddleware(app: express.Express): void;

package/dist/src/server.js

@@ -1,8 +1,8 @@
 /**
  * Express-layer plumbing for the Mastra plugin: a `MastraServer` that
  * stamps the per-request `RequestContext`, and a route-patch middleware
- * that lets `@mastra/ai-sdk` `chatRoute` work behind an Express mount
- * point.
+ * that lets the plugin's custom API routes (e.g. `historyRoute`) work
+ * behind an Express mount point.
  */
 import { getExecutionContext } from "@databricks/appkit";
 import { httpUtils, logUtils, stringUtils } from "@dbx-tools/shared";
@@ -128,30 +128,23 @@ export class MastraServer extends MastraServerExpress {
     }
 }
 /**
- * Patches around `@mastra/express`'s custom-route dispatcher so
- * `chatRoute` works when `MastraServer` is hosted on an Express subapp
- * mounted under a parent path (e.g. `/api/mastra`).
+ * Patches around `@mastra/express`'s custom-route dispatcher so the
+ * plugin's custom API routes (e.g. `historyRoute`) work when
+ * `MastraServer` is hosted on an Express subapp mounted under a parent
+ * path (e.g. `/api/mastra`).
  *
- * Two concerns:
- *
- * 1. The adapter's `registerCustomApiRoutes` matches against `req.path`
- *    (mount-relative, correct) but dispatches to its internal Hono
- *    mini-app using `req.originalUrl`, which still contains the parent
- *    mount prefix. The Hono app registers the literal `chatRoute` paths
- *    (for example `/route/chat`), so the absolute URL never matches
- *    until we overwrite `originalUrl` for `/route` and `/route/*` to
- *    the mount-relative path.
- *
- * 2. `memory.resource` must be the authenticated user, not whatever the
- *    client posts. The custom-route forwarder re-serializes `req.body`
- *    into the Request body it hands Hono, so mutating the parsed body
- *    here would propagate into `handleChatStream`'s params (kept for
- *    future use; `express.json()` runs first so `req.body` is parsed).
+ * The adapter's `registerCustomApiRoutes` matches against `req.path`
+ * (mount-relative, correct) but dispatches to its internal Hono
+ * mini-app using `req.originalUrl`, which still contains the parent
+ * mount prefix. The Hono app registers the literal route paths
+ * (for example `/route/history`), so the absolute URL never matches
+ * until we overwrite `originalUrl` for `/route` and `/route/*` to the
+ * mount-relative path.
  */
 export function attachRoutePatchMiddleware(app) {
     app.use((req, _res, next) => {
-        const isChat = req.path === "/route" || req.path.startsWith("/route/");
-        if (!isChat)
+        const isCustomRoute = req.path === "/route" || req.path.startsWith("/route/");
+        if (!isCustomRoute)
             return next();
         req.originalUrl = req.path;
         next();

package/dist/src/serving.d.ts

@@ -1,28 +1,14 @@
 /**
- * Dynamic model resolution against Databricks Model Serving.
+ * Mastra-specific glue over the generic `@dbx-tools/model` toolkit.
  *
- * Turns loose, human-typed model names into real serving-endpoint ids
- * so the same agent can target different endpoints without code
- * changes. The workspace's `/serving-endpoints` list is fetched once
- * per host and cached with a TTL, with concurrent callers sharing one
- * in-flight promise (the coalescing pattern of Python's
- * `cachetools-async`). Names are matched through `fuse.js` extended
- * search so tokens like `"claude sonnet"` snap to
- * `databricks-claude-sonnet-4-6`, and a per-request override can be
- * pulled from the request header, query string, or body so a model
- * can be swapped per call without redeploying.
+ * The live `/serving-endpoints` catalogue access, fuzzy name
+ * resolution, and tier/fallback selection all live in
+ * `@dbx-tools/model`; this module only adds what is specific to the
+ * Mastra plugin: pulling a per-request model override off an HTTP
+ * request (header / query / body) and projecting the plugin config
+ * onto the knobs `buildModel` and the `/models` route share.
  */
-import { type getExecutionContext } from "@databricks/appkit";
-import type { ServingEndpointSummary } from "@dbx-tools/appkit-mastra-shared";
 import type { MastraPluginConfig } from "./config.js";
-export type { ServingEndpointSummary };
-/**
- * Structural type for the Databricks workspace client. Derived from
- * AppKit's `ExecutionContext` so this module doesn't take a direct
- * dependency on `@databricks/sdk-experimental`; the dep flows in
- * transitively through `@databricks/appkit`.
- */
-type WorkspaceClientLike = ReturnType<typeof getExecutionContext>["client"];
 /**
  * `RequestContext` key under which {@link MastraServer} stores the
  * per-request model override (header / query / body). `model.ts`
@@ -35,76 +21,6 @@ export declare const MODEL_OVERRIDE_HEADER = "x-mastra-model";
 export declare const MODEL_OVERRIDE_QUERY = "model";
 /** Body fields (in priority order) inspected for a per-request model override. */
 export declare const MODEL_OVERRIDE_BODY_FIELDS: readonly ["model", "modelId"];
-/**
- * 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 opts.ttlMs - Override the default TTL just for this call.
- *   Forwarded to `CacheManager` as seconds.
- */
-export declare function listServingEndpoints(client: WorkspaceClientLike, host: string, opts?: {
-    ttlMs?: number;
-}): Promise<ServingEndpointSummary[]>;
-/**
- * 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).
- */
-export declare function clearServingEndpointsCache(host?: string): Promise<void>;
-/**
- * Result of fuzzy-resolving a user-supplied model name against the
- * live endpoint list. `score` is Fuse.js's distance (`0` is exact,
- * `1` is no match); `matched` is `false` when the score exceeds the
- * configured threshold so callers can fall back to the original
- * input (Databricks will then return a clean 404).
- */
-export interface ResolvedModel {
-    modelId: string;
-    matched: boolean;
-    score?: number;
-}
-/** Options accepted by {@link resolveModelId}. */
-export interface ResolveModelOptions {
-    /** Fuse.js threshold (0 = exact, 1 = anything). Default `0.4`. */
-    threshold?: number;
-}
-/**
- * Snap a user-supplied model name to the closest configured serving
- * endpoint:
- *
- * 1. Exact name match wins immediately (no fuzzy needed).
- * 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. This is the
- *    "tokenized fuzzy match" the user reaches for when they type
- *    `"claude sonnet"` instead of the full endpoint name.
- * 3. If the best Fuse score is above `threshold`, return the input
- *    unchanged and let the upstream call surface the 404. This keeps
- *    deliberate model ids (e.g. brand new endpoints) from being
- *    silently rewritten to a similar-looking neighbour.
- *
- * Pass an empty endpoint list to short-circuit fuzzy matching - the
- * input is returned verbatim. This is what {@link buildModel} does
- * when the workspace client can't be reached at resolve time.
- */
-export declare function resolveModelId(input: string, endpoints: readonly ServingEndpointSummary[], opts?: ResolveModelOptions): ResolvedModel;
 /**
  * Minimal Express-ish request shape used by {@link extractModelOverride}.
  * Keeps this module independent of `express` so the helper can be
@@ -132,15 +48,15 @@ export interface ModelOverrideRequest {
 export declare function extractModelOverride(req: ModelOverrideRequest): string | null;
 /**
  * Read the fuzzy-resolution config knobs off the plugin config with
- * defaults applied. Kept here so `buildModel` and the `/models` route
- * agree on what "enabled" means.
+ * `@dbx-tools/model` defaults applied. Kept here so `buildModel` and
+ * the `/models` route agree on what "enabled" means.
  *
- * `fallbacks` is the priority-ordered list `pickModelId` walks when
- * nothing explicit is set; defaults live in `model.ts`
- * (`FALLBACK_MODEL_IDS`) and are passed in by callers to avoid a
- * circular import between `serving.ts` and `model.ts`.
+ * `fallbacks` is the priority-ordered list `resolveModel` walks first
+ * when nothing explicit is set; defaults to an empty list so the
+ * generic resolver falls through to the live catalogue and its own
+ * `FALLBACK_MODEL_IDS` floor.
  */
-export declare function resolveServingConfig(config: MastraPluginConfig, defaultFallbacks?: readonly string[]): {
+export declare function resolveServingConfig(config: MastraPluginConfig): {
     ttlMs: number;
     threshold: number;
     fuzzy: boolean;