@dbx-tools/appkit-mastra 0.1.58 → 0.1.67

package/package.json

@@ -1,26 +1,18 @@
 {
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "source": "./index.ts",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
   "name": "@dbx-tools/appkit-mastra",
-  "version": "0.1.58",
+  "version": "0.1.67",
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17",
-    "@dbx-tools/appkit-mastra-shared": "0.1.58",
-    "@dbx-tools/genie": "0.1.58",
-    "@dbx-tools/genie-shared": "0.1.58",
-    "@dbx-tools/model": "0.1.58",
-    "@dbx-tools/shared": "0.1.58",
+    "@dbx-tools/appkit-mastra-shared": "0.1.67",
+    "@dbx-tools/genie": "0.1.67",
+    "@dbx-tools/genie-shared": "0.1.67",
+    "@dbx-tools/model": "0.1.67",
+    "@dbx-tools/shared": "0.1.67",
     "@mastra/ai-sdk": "^1",
     "@mastra/core": "^1",
     "@mastra/express": "^1",
     "@mastra/fastembed": "^1",
+    "@mastra/mcp": "^1",
     "@mastra/memory": "^1",
     "@mastra/observability": "^1",
     "@mastra/otel-bridge": "^1",
@@ -28,26 +20,23 @@
     "pg": "^8.20.0",
     "zod": "^4.3.6"
   },
-  "module": "index.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "peerDependencies": {
     "@databricks/appkit": "^0.41",
     "express": "^5"
   },
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
-    "bin",
     "dist",
-    "index*.ts",
     "src"
   ],
-  "license": "Apache-2.0",
-  "homepage": "https://github.com/reggie-db/dbx-tools-js#readme",
-  "bugs": {
-    "url": "https://github.com/reggie-db/dbx-tools-js/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/reggie-db/dbx-tools-js.git",
-    "directory": "packages/appkit-mastra"
-  }
+  "license": "Apache-2.0"
 }

package/src/agents.ts

@@ -319,6 +319,12 @@ export type MastraMemoryConfigOverride = DistributiveOmit<PgVectorConfig, "id">
 export interface BuiltAgents {
   agents: Record<string, Agent>;
   defaultAgentId: string;
+  /**
+   * Ambient tools shared across every agent (the built-in system tools
+   * spread with `config.tools`). Surfaced so the optional MCP server
+   * can re-expose them when {@link MastraMcpConfig.tools} is enabled.
+   */
+  ambientTools: MastraTools;
 }
 
 /** Fallback agent id used when `config.agents` is omitted entirely. */
@@ -477,7 +483,7 @@ export async function buildAgents(opts: {
   }
 
   log.info("agents ready", { ids, defaultAgentId });
-  return { agents, defaultAgentId };
+  return { agents, defaultAgentId, ambientTools };
 }
 
 /**

package/src/config.ts

@@ -80,6 +80,45 @@ export type MastraMemoryConfig = PgVectorConfig & {
   id?: string;
 };
 
+/**
+ * Fine-grained control for the optional MCP server exposure
+ * ({@link MastraPluginConfig.mcp}). Every field is optional; the object
+ * form only needs to set what differs from the defaults.
+ */
+export interface MastraMcpConfig {
+  /**
+   * Server id used in the route path (`/mcp/<serverId>/...`) and as the
+   * MCP registry id. Defaults to the plugin's registered name.
+   */
+  serverId?: string;
+  /** Display name advertised over MCP. Defaults to `"<displayName> MCP"`. */
+  name?: string;
+  /** Semantic version advertised over MCP. Defaults to `"1.0.0"`. */
+  version?: string;
+  /** Optional human-readable description advertised over MCP. */
+  description?: string;
+  /**
+   * Expose every registered agent as an `ask_<agentId>` MCP tool.
+   * Defaults to `true` - this is the "leverage the Mastra agents over
+   * MCP" behavior most callers want.
+   */
+  agents?: boolean;
+  /**
+   * Also expose the plugin's ambient tools (the built-in `render_data`
+   * plus anything in `config.tools`) as MCP tools. Defaults to `false`:
+   * the ambient tools assume an in-process chat turn (they publish
+   * writer events the chat UI consumes), so they aren't useful to a
+   * standalone MCP client. Turn this on only when those tools are safe
+   * to call out-of-band.
+   */
+  tools?: boolean;
+  /**
+   * Extra tools to expose over MCP beyond the agent / ambient sets.
+   * Use this for tools written specifically for MCP consumers.
+   */
+  extraTools?: MastraTools;
+}
+
 /** Configuration accepted by the Mastra AppKit plugin. */
 export interface MastraPluginConfig extends BasePluginConfig {
   /** Mastra OpenAI-compatible provider id. Defaults to `"databricks"`. */
@@ -317,4 +356,29 @@ export interface MastraPluginConfig extends BasePluginConfig {
    * to drill deep into a dataset within a single turn.
    */
   agentMaxSteps?: number;
+  /**
+   * Expose the plugin's agents (and optionally tools) as a Mastra MCP
+   * server so external MCP clients - Claude Desktop, Cursor, the Mastra
+   * playground, or another agent - can call them over the standard MCP
+   * transports. Disabled by default.
+   *
+   * - `undefined` / `false`: no MCP endpoints.
+   * - `true`: expose every registered agent as an `ask_<agentId>` MCP
+   *   tool under a server whose id is the plugin name.
+   * - {@link MastraMcpConfig}: fine-grained control over the server id,
+   *   advertised metadata, and which agents / tools are exposed.
+   *
+   * When enabled, the stock Mastra MCP routes mount under the plugin's
+   * base path (no bespoke route is added - the server is handed to the
+   * `Mastra` instance via `mcpServers`, which `@mastra/express` serves):
+   *
+   * - Streamable HTTP: `POST /api/<plugin>/mcp/<serverId>/mcp`
+   * - SSE (legacy):    `GET  /api/<plugin>/mcp/<serverId>/sse`
+   *                    `POST /api/<plugin>/mcp/<serverId>/messages`
+   *
+   * Requests run under the same AppKit OBO scope as the chat routes, so
+   * an agent invoked over MCP resolves its model and tools as the
+   * calling user.
+   */
+  mcp?: boolean | MastraMcpConfig;
 }

package/src/genie.ts

@@ -35,7 +35,7 @@
  */
 
 import { CacheManager, genie } from "@databricks/appkit";
-import { ApiError, HttpError, WorkspaceClient } from "@databricks/sdk-experimental";
+import { WorkspaceClient } from "@databricks/sdk-experimental";
 import {
   ChartSchema,
   type MastraWriter,
@@ -43,7 +43,13 @@ import {
 } from "@dbx-tools/appkit-mastra-shared";
 import { genieEventChat, genieSampleQuestions, getGenieSpace } from "@dbx-tools/genie";
 import { GenieMessageSchema, type GenieMessage } from "@dbx-tools/genie-shared";
-import { appkitUtils, commonUtils, logUtils, stringUtils } from "@dbx-tools/shared";
+import {
+  apiUtils,
+  appkitUtils,
+  commonUtils,
+  logUtils,
+  stringUtils,
+} from "@dbx-tools/shared";
 import type { RequestContext } from "@mastra/core/request-context";
 import { MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
 import { createTool } from "@mastra/core/tools";
@@ -302,24 +308,6 @@ async function ensureConversationSeeded(
   if (cached) writeContextConversationId(requestContext, spaceId, cached);
 }
 
-/**
- * True when `err` is the SDK error Genie returns for a
- * conversation id that no longer exists (deleted, expired upstream,
- * or referenced from the wrong space). Matches the typed
- * {@link ApiError} 404 / `RESOURCE_DOES_NOT_EXIST` shape first, then
- * falls back to the lower-level {@link HttpError} 404, then to a
- * loose message sniff for SDK shapes we haven't catalogued.
- */
-function isConversationGoneError(err: unknown): boolean {
-  if (err instanceof ApiError) {
-    if (err.statusCode === 404) return true;
-    if (err.errorCode === "RESOURCE_DOES_NOT_EXIST") return true;
-  }
-  if (err instanceof HttpError && err.code === 404) return true;
-  if (err instanceof Error && /does not exist/i.test(err.message)) return true;
-  return false;
-}
-
 /* ------------------------ prepare_chart input ------------------------ */
 
 /**
@@ -506,7 +494,7 @@ function buildAskGenieTool(opts: { spaceId: string; alias: string; hint?: string
         // and try once more. Only retry when we *had* a seeded id -
         // a fresh call that 404s shouldn't loop.
         const seeded = readContextConversationId(requestContext, spaceId);
-        if (seeded && isConversationGoneError(err)) {
+        if (seeded && apiUtils.isNotFoundError(err)) {
           log.warn("conversation-cache:stale, resetting", {
             spaceId,
             conversationId: seeded,

package/{index.ts → src/index.ts}

@@ -12,16 +12,14 @@
  */
 export * from "@dbx-tools/appkit-mastra-shared";
 export * from "@dbx-tools/model";
-export * from "./src/agents.js";
-export * from "./src/chart.js";
-export * from "./src/config.js";
-export * from "./src/genie.js";
-export * from "./src/plugin.js";
+export * from "./agents.js";
+export * from "./chart.js";
+export * from "./config.js";
+export * from "./genie.js";
+export * from "./mcp.js";
+export * from "./plugin.js";
 export {
   MASTRA_MODEL_OVERRIDE_KEY,
-  MODEL_OVERRIDE_BODY_FIELDS,
-  MODEL_OVERRIDE_HEADER,
-  MODEL_OVERRIDE_QUERY,
   extractModelOverride,
   type ModelOverrideRequest,
-} from "./src/serving.js";
+} from "./serving.js";

package/src/mcp.ts

@@ -0,0 +1,89 @@
+/**
+ * Optional Mastra MCP server exposure for the AppKit Mastra plugin.
+ *
+ * Turns the plugin's registered agents (and, opt-in, its ambient tools)
+ * into a Mastra `MCPServer` so external MCP clients - Claude Desktop,
+ * Cursor, the Mastra playground, or another agent - can call them over
+ * the standard MCP transports. The resulting server is handed to the
+ * `Mastra` instance via `mcpServers`, which makes `@mastra/express`
+ * serve the stock MCP routes under the plugin's base path; the plugin
+ * never registers a bespoke MCP route of its own.
+ */
+
+import type { Agent } from "@mastra/core/agent";
+import { MCPServer } from "@mastra/mcp";
+
+import type { MastraTools } from "./agents.js";
+import type { MastraMcpConfig, MastraPluginConfig } from "./config.js";
+
+/** MCP server version advertised when the caller doesn't pin one. */
+const DEFAULT_MCP_VERSION = "1.0.0";
+
+/**
+ * A built MCP server plus the request paths it answers on, relative to
+ * the plugin's base path (`/api/<plugin>`). The paths are informational
+ * (logging / `exports().getMcp()`); the routes themselves are mounted
+ * by `@mastra/express` off the `Mastra` instance's `mcpServers`.
+ */
+export interface ResolvedMcp {
+  /** Registry id, used in the route path (`/mcp/<serverId>/...`). */
+  serverId: string;
+  /** The Mastra MCP server to hand to `new Mastra({ mcpServers })`. */
+  server: MCPServer;
+  /** Streamable-HTTP transport path, relative to the plugin base path. */
+  httpPath: string;
+  /** SSE transport path, relative to the plugin base path. */
+  ssePath: string;
+  /** SSE message path, relative to the plugin base path. */
+  messagePath: string;
+}
+
+/**
+ * Build the plugin's MCP server, or `null` when `config.mcp` is falsy
+ * (the default - no MCP endpoints).
+ *
+ * `true` exposes every registered agent as an `ask_<agentId>` MCP tool
+ * under a server id equal to the plugin name. The object form
+ * ({@link MastraMcpConfig}) tunes the id / advertised metadata and can
+ * additionally expose the plugin's ambient tools or a set of extra
+ * MCP-only tools.
+ */
+export function buildMcpServer(opts: {
+  config: MastraPluginConfig;
+  pluginName: string;
+  displayName: string;
+  agents: Record<string, Agent>;
+  ambientTools: MastraTools;
+}): ResolvedMcp | null {
+  const { config, pluginName, displayName, agents, ambientTools } = opts;
+  if (!config.mcp) return null;
+  const settings: MastraMcpConfig = config.mcp === true ? {} : config.mcp;
+
+  const serverId = settings.serverId ?? pluginName;
+  const exposeAgents = settings.agents !== false;
+  const exposeTools = settings.tools === true;
+
+  // MCPServerConfig.tools is required, so always pass a record (empty
+  // when the caller exposes only agents).
+  const tools: MastraTools = {
+    ...(exposeTools ? ambientTools : {}),
+    ...(settings.extraTools ?? {}),
+  };
+
+  const server = new MCPServer({
+    id: serverId,
+    name: settings.name ?? `${displayName} MCP`,
+    version: settings.version ?? DEFAULT_MCP_VERSION,
+    ...(settings.description ? { description: settings.description } : {}),
+    ...(exposeAgents ? { agents } : {}),
+    tools,
+  });
+
+  return {
+    serverId,
+    server,
+    httpPath: `/mcp/${serverId}/mcp`,
+    ssePath: `/mcp/${serverId}/sse`,
+    messagePath: `/mcp/${serverId}/messages`,
+  };
+}

package/src/model.ts

@@ -21,6 +21,7 @@
  * propagate so callers see the real SDK message.
  */
 
+import { getExecutionContext } from "@databricks/appkit";
 import { type ModelClass, parseModelClass, selectModel } from "@dbx-tools/model";
 import { commonUtils, logUtils, netUtils, stringUtils } from "@dbx-tools/shared";
 import type { MastraModelConfig } from "@mastra/core/llm";
@@ -68,8 +69,13 @@ export async function buildModel(
   overrides: BuildModelOverrides = {},
 ): Promise<MastraModelConfig> {
   void setupFetchInterceptor();
-  const user = requestContext.get(MASTRA_USER_KEY) as User;
-  const clientConfig = user.executionContext.client.config;
+  // The chat path stamps the AppKit user on the request context via
+  // `MastraServer`. The MCP transport routes don't thread that context
+  // into tool execution, so fall back to the ambient execution context
+  // (the active OBO scope, or the service principal) when it's absent.
+  const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;
+  const executionContext = user?.executionContext ?? getExecutionContext();
+  const clientConfig = executionContext.client.config;
   const host = (await clientConfig.getHost()).toString();
   const headers = new Headers();
   await clientConfig.authenticate(headers);
@@ -97,7 +103,7 @@ export async function buildModel(
   const explicit = requestedClass === null ? requested : undefined;
   const modelClass = requestedClass ?? overrides.modelClass;
 
-  const { modelId, source } = await selectModel(user.executionContext.client, host, {
+  const { modelId, source } = await selectModel(executionContext.client, host, {
     ...(explicit !== undefined ? { explicit } : {}),
     fuzzy: serving.fuzzy,
     threshold: serving.threshold,

package/src/plugin.ts

@@ -26,6 +26,11 @@
  *   (load + clear thread history), `/models`, `/suggestions`, and the
  *   generic `/embed/:type/:id` resolver for inline chart / data
  *   markers.
+ * - MCP: opt in with `config.mcp` to expose the agents (and optionally
+ *   tools) as a Mastra `MCPServer`. It is registered on the `Mastra`
+ *   instance via `mcpServers`, so `@mastra/express` serves the stock
+ *   MCP transport routes (`/mcp/<serverId>/...`) under the mount. See
+ *   `./mcp.js`.
  */
 
 import {
@@ -38,7 +43,7 @@ import {
   type PluginManifest,
   type ResourceRequirement,
 } from "@databricks/appkit";
-import { appkitUtils, commonUtils, logUtils } from "@dbx-tools/shared";
+import { apiUtils, appkitUtils, commonUtils, logUtils } from "@dbx-tools/shared";
 import type { Agent } from "@mastra/core/agent";
 import { Mastra } from "@mastra/core/mastra";
 import express from "express";
@@ -59,6 +64,7 @@ import { fetchChart } from "./chart.js";
 import type { MastraPluginConfig } from "./config.js";
 import { collectSpaceSuggestions, resolveGenieSpaces } from "./genie.js";
 import { historyRoute } from "./history.js";
+import { buildMcpServer, type ResolvedMcp } from "./mcp.js";
 import {
   createMemoryBuilder,
   createServicePrincipalPool,
@@ -67,11 +73,7 @@ import {
 import { buildObservability } from "./observability.js";
 import { attachRoutePatchMiddleware, MastraServer } from "./server.js";
 import { resolveServingConfig } from "./serving.js";
-import {
-  fetchStatementData,
-  isStatementNotFoundError,
-  STATEMENT_ROW_CAP,
-} from "./statement.js";
+import { fetchStatementData, STATEMENT_ROW_CAP } from "./statement.js";
 
 const GENIE_MANIFEST = appkitUtils.data(genie).plugin.manifest;
 const LAKEBASE_MANIFEST = appkitUtils.data(lakebase).plugin.manifest;
@@ -131,6 +133,12 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
   private mastra: Mastra | null = null;
   private mastraApp: express.Express | null = null;
   private mastraServer: MastraServer | null = null;
+  /**
+   * The optional MCP server exposing this plugin's agents / tools, or
+   * `null` when `config.mcp` is disabled (the default). Built in
+   * {@link buildAgentAndServer} and registered on the Mastra instance.
+   */
+  private mcp: ResolvedMcp | null = null;
   /**
    * Dedicated service-principal Lakebase pool backing Mastra memory /
    * storage. Built once in {@link buildAgentAndServer} (outside any
@@ -207,6 +215,26 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
         (this.built && this.built.agents[this.built.defaultAgentId]) ?? null,
       /** Underlying Mastra instance for advanced use (custom routes etc.). */
       getMastra: () => this.mastra,
+      /**
+       * MCP endpoint info when `config.mcp` is enabled, else `null`.
+       * Paths are absolute (under the plugin mount), ready to hand to an
+       * MCP client. Streamable HTTP is `http`; the SSE pair is the
+       * legacy transport.
+       */
+      getMcp: (): {
+        serverId: string;
+        http: string;
+        sse: string;
+        messages: string;
+      } | null =>
+        this.mcp
+          ? {
+              serverId: this.mcp.serverId,
+              http: `/api/${this.name}${this.mcp.httpPath}`,
+              sse: `/api/${this.name}${this.mcp.ssePath}`,
+              messages: `/api/${this.name}${this.mcp.messagePath}`,
+            }
+          : null,
       /** Express subapp Mastra is mounted on; mostly for tests. */
       getMastraServer: () => this.mastraServer,
       /**
@@ -357,7 +385,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
           // failure should leave the chat usable with a bare empty
           // state rather than surfacing a 500. Log and degrade.
           this.log.warn("suggestions:error", {
-            error: err instanceof Error ? err.message : String(err),
+            error: commonUtils.errorMessage(err),
           });
           res.json({ questions: [] });
         });
@@ -448,7 +476,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
     } catch (err) {
       // The Databricks SDK throws on 404; surface as `undefined`
       // so the route maps to a clean HTTP 404 instead of a 500.
-      if (isStatementNotFoundError(err)) return undefined;
+      if (apiUtils.isNotFoundError(err)) return undefined;
       throw err;
     }
   }
@@ -536,10 +564,24 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
     // `createApp`, so the OTLP endpoint / headers / sampling are
     // env-driven and shared with every other AppKit plugin.
     const observability = await buildObservability({ serviceName: this.name });
+    // Optional MCP exposure: build a Mastra MCP server from the
+    // registered agents (and, opt-in, the ambient tools) and register
+    // it on the Mastra instance. `@mastra/express` serves the stock MCP
+    // transport routes (`/mcp/<serverId>/...`) off `mcpServers`, so the
+    // catch-all dispatch below already routes MCP requests under OBO -
+    // no bespoke route needed. See `./mcp.js`.
+    this.mcp = buildMcpServer({
+      config: this.config,
+      pluginName: this.name,
+      displayName: MastraPlugin.manifest.displayName,
+      agents: this.built.agents,
+      ambientTools: this.built.ambientTools,
+    });
     this.mastra = new Mastra({
       agents: this.built.agents,
       ...(instanceStorage ? { storage: instanceStorage } : {}),
       ...(observability ? { observability } : {}),
+      ...(this.mcp ? { mcpServers: { [this.mcp.serverId]: this.mcp.server } } : {}),
     });
     this.mastraApp = express();
     attachRoutePatchMiddleware(this.mastraApp);
@@ -572,6 +614,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
       routes: ["/route/history", "/models", "/suggestions", "/embed/:type/:id"],
       instanceStorage: instanceStorage !== undefined,
       observability: observability !== undefined ? "mlflow" : "off",
+      mcp: this.mcp ? `/api/${this.name}${this.mcp.httpPath}` : "off",
     });
   }
 }

package/src/serving.ts

@@ -9,6 +9,11 @@
  * onto the knobs `buildModel` and the `/models` route share.
  */
 
+import {
+  MODEL_OVERRIDE_BODY_FIELDS,
+  MODEL_OVERRIDE_HEADER,
+  MODEL_OVERRIDE_QUERY,
+} from "@dbx-tools/appkit-mastra-shared";
 import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_MODEL_CACHE_TTL_MS } from "@dbx-tools/model";
 import { stringUtils } from "@dbx-tools/shared";
 
@@ -21,15 +26,6 @@ import type { MastraPluginConfig } from "./config.js";
  */
 export const MASTRA_MODEL_OVERRIDE_KEY = "mastra__model_override";
 
-/** HTTP header inspected for a per-request model override. */
-export const MODEL_OVERRIDE_HEADER = "x-mastra-model";
-
-/** Query string parameter inspected for a per-request model override. */
-export const MODEL_OVERRIDE_QUERY = "model";
-
-/** Body fields (in priority order) inspected for a per-request model override. */
-export const MODEL_OVERRIDE_BODY_FIELDS = ["model", "modelId"] as const;
-
 /**
  * Minimal Express-ish request shape used by {@link extractModelOverride}.
  * Keeps this module independent of `express` so the helper can be

package/src/statement.ts

@@ -1,17 +1,14 @@
 /**
  * Databricks Statement Execution helpers for the Mastra plugin.
  *
- * Wraps `client.statementExecution.getStatement` with the shape,
- * size, and error handling the plugin's tools and the
- * `/embed/data/:id` route both need: a low-level fetch that returns a
- * raw `{columns, rows, rowCount}` shape and coerces numeric strings
- * to numbers so downstream charts and aggregations don't have to, a
+ * Wraps `client.statementExecution.getStatement` with the shape and
+ * size handling the plugin's tools and the `/embed/data/:id` route
+ * both need: a low-level fetch that returns a raw
+ * `{columns, rows, rowCount}` shape and coerces numeric strings to
+ * numbers so downstream charts and aggregations don't have to, plus a
  * hard row cap callers clamp `limit` to so a runaway result set can't
- * hose a response, and a structural not-found detector that
- * normalizes the SDK's error classes and loose `does not exist` /
- * `not found` message shapes into one boolean so the route can map
- * upstream 404s to a clean HTTP 404 without coupling to SDK
- * error-class identity.
+ * hose a response. Upstream 404s are detected via
+ * `apiUtils.isNotFoundError` at the call sites.
  *
  * Not Genie-specific: a Databricks `statement_id` is workspace
  * scoped and lives in the Statement Execution API regardless of
@@ -20,7 +17,7 @@
  * 404s without reaching into the Genie tool module.
  */
 
-import { ApiError, HttpError, WorkspaceClient } from "@databricks/sdk-experimental";
+import { WorkspaceClient } from "@databricks/sdk-experimental";
 import type { GenieDatasetData } from "@dbx-tools/appkit-mastra-shared";
 import { apiUtils } from "@dbx-tools/shared";
 
@@ -93,28 +90,3 @@ export async function fetchStatementData(
     rowCount: r.manifest?.total_row_count ?? dataArray.length,
   };
 }
-
-/**
- * True when `err` looks like the Databricks SDK's "statement not
- * found" error. Matches the typed {@link ApiError} 404 /
- * `RESOURCE_DOES_NOT_EXIST` shape first, then falls back to the
- * lower-level {@link HttpError} 404, then to a loose `does not
- * exist` / `not found` message sniff for SDK shapes we haven't
- * catalogued.
- *
- * Pulled into its own helper so callers (notably the
- * `/embed/data/:id` route) stay decoupled from SDK
- * error-class identity, and the conversion logic stays testable
- * in isolation.
- */
-export function isStatementNotFoundError(err: unknown): boolean {
-  if (err instanceof ApiError) {
-    if (err.statusCode === 404) return true;
-    if (err.errorCode === "RESOURCE_DOES_NOT_EXIST") return true;
-  }
-  if (err instanceof HttpError && err.code === 404) return true;
-  if (err instanceof Error && /does not exist|not found/i.test(err.message)) {
-    return true;
-  }
-  return false;
-}