@dbx-tools/appkit-mastra 0.1.41 → 0.1.42

package/src/plugin.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,10 +21,11 @@
  *   `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 {
@@ -38,16 +39,21 @@ import {
   type ResourceRequirement,
 } from "@databricks/appkit";
 import { appkitUtils, commonUtils, logUtils } from "@dbx-tools/shared";
-import { chatRoute } from "@mastra/ai-sdk";
 import type { Agent } from "@mastra/core/agent";
 import { Mastra } from "@mastra/core/mastra";
 import express from "express";
 import type { Pool } from "pg";
 
-import type {
-  MastraClientConfig,
-  StatementData,
+import {
+  MASTRA_ROUTES,
+  type MastraClientConfig,
+  type StatementData,
 } from "@dbx-tools/appkit-mastra-shared";
+import {
+  clearServingEndpointsCache,
+  listServingEndpoints,
+  type ServingEndpointSummary,
+} from "@dbx-tools/model";
 import { buildAgents, FALLBACK_AGENT_ID, type BuiltAgents } from "./agents.js";
 import { fetchChart } from "./chart.js";
 import type { MastraPluginConfig } from "./config.js";
@@ -60,12 +66,7 @@ import {
 } from "./memory.js";
 import { buildObservability } from "./observability.js";
 import { attachRoutePatchMiddleware, MastraServer } from "./server.js";
-import {
-  clearServingEndpointsCache,
-  listServingEndpoints,
-  resolveServingConfig,
-  type ServingEndpointSummary,
-} from "./serving.js";
+import { resolveServingConfig } from "./serving.js";
 import {
   fetchStatementData,
   isStatementNotFoundError,
@@ -198,9 +199,9 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
        */
       get: (id: string): Agent | null => 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: (): Agent | null =>
         (this.built && this.built.agents[this.built.defaultAgentId]) ?? null,
@@ -229,22 +230,16 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
 
   override clientConfig(): Record<string, unknown> {
     // 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: MastraClientConfig = {
-      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 ?? {}),
     };
@@ -257,7 +252,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
     // 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 }))
@@ -311,7 +306,7 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
       },
     };
 
-    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];
@@ -367,8 +362,8 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
           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();
@@ -553,20 +548,28 @@ export class MastraPlugin extends Plugin<MastraPluginConfig> {
       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` as `${string}: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/src/server.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 { getExecutionContext } from "@databricks/appkit";
@@ -172,30 +172,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: express.Express): void {
   app.use((req, _res, next) => {
-    const isChat = req.path === "/route" || req.path.startsWith("/route/");
-    if (!isChat) return next();
+    const isCustomRoute = req.path === "/route" || req.path.startsWith("/route/");
+    if (!isCustomRoute) return next();
     req.originalUrl = req.path;
     next();
   });

package/src/serving.ts

@@ -1,37 +1,19 @@
 /**
- * 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 { CacheManager, type getExecutionContext } from "@databricks/appkit";
-import { logUtils, stringUtils } from "@dbx-tools/shared";
-import Fuse from "fuse.js";
+import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_MODEL_CACHE_TTL_MS } from "@dbx-tools/model";
+import { stringUtils } from "@dbx-tools/shared";
 
-import type { ServingEndpointSummary } from "@dbx-tools/appkit-mastra-shared";
 import type { MastraPluginConfig } from "./config.js";
 
-export type { ServingEndpointSummary };
-
-const log = logUtils.logger("mastra/serving");
-
-/**
- * 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`
@@ -48,187 +30,6 @@ 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;
 
-/** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */
-const DEFAULT_TTL_MS = 5 * 60 * 1000;
-
-/** Default Fuse.js score threshold below which a fuzzy match is accepted. */
-const DEFAULT_FUZZY_THRESHOLD = 0.4;
-
-/** Cache key parts under which endpoint listings are stored. */
-const CACHE_KEY_NAMESPACE = "mastra:serving-endpoints";
-
-/**
- * Stable `userKey` arg for AppKit's `CacheManager.getOrExecute`.
- * Endpoint visibility is effectively workspace-scoped (we cache by
- * host in the key parts), so a single shared key lets every user of
- * the same workspace share one cached fetch and coalesce on the
- * in-flight promise. Permissions can differ in theory, but the
- * Foundation Model API catalogue is the same view for every caller.
- */
-const SHARED_USER_KEY = "mastra-shared";
-
-/**
- * List Model Serving endpoints for the workspace owning `client`,
- * routed through AppKit's `CacheManager`. The manager gives us
- * everything `cachetools.TTLCache` provides plus what
- * `cachetools-async` adds on top: per-entry TTL, in-flight request
- * coalescing (concurrent callers share one fetch via the manager's
- * internal `inFlightRequests` map), bounded size, telemetry spans
- * (`cache.getOrExecute`), and optional Lakebase persistence so the
- * catalogue survives restarts when the lakebase plugin is wired up.
- *
- * Returns plain {@link ServingEndpointSummary} objects (a stable
- * subset of the SDK type) so cache hits never expose stale SDK
- * internals. Errors from `CacheManager` or the SDK fetch propagate
- * to the caller - we don't swallow them so users see the real
- * auth / network issue.
- *
- * @param host - Workspace host used as the cache key. Pass the value
- *   resolved from `client.config.getHost()` so multi-host apps share
- *   one entry per workspace.
- * @param opts.ttlMs - Override the default TTL just for this call.
- *   Forwarded to `CacheManager` as seconds.
- */
-export async function listServingEndpoints(
-  client: WorkspaceClientLike,
-  host: string,
-  opts: { ttlMs?: number } = {},
-): Promise<ServingEndpointSummary[]> {
-  const ttlSec = Math.max(1, Math.round((opts.ttlMs ?? DEFAULT_TTL_MS) / 1000));
-  return CacheManager.getInstanceSync().getOrExecute(
-    [CACHE_KEY_NAMESPACE, host],
-    () => fetchEndpoints(client),
-    SHARED_USER_KEY,
-    { ttl: ttlSec },
-  );
-}
-
-async function fetchEndpoints(
-  client: WorkspaceClientLike,
-): Promise<ServingEndpointSummary[]> {
-  const startedAt = Date.now();
-  const out: ServingEndpointSummary[] = [];
-  for await (const ep of client.servingEndpoints.list()) {
-    if (!ep.name) continue;
-    out.push({
-      name: ep.name,
-      ...(ep.task !== undefined ? { task: ep.task } : {}),
-      ...(ep.state?.ready !== undefined ? { state: String(ep.state.ready) } : {}),
-      ...(ep.description !== undefined ? { description: ep.description } : {}),
-    });
-  }
-  log.debug("listed", { count: out.length, elapsedMs: Date.now() - startedAt });
-  return out;
-}
-
-/**
- * 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 async function clearServingEndpointsCache(host?: string): Promise<void> {
-  const cache = CacheManager.getInstanceSync();
-  if (host) {
-    const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], SHARED_USER_KEY);
-    await cache.delete(key);
-  } else {
-    await cache.clear();
-  }
-}
-
-/**
- * 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 function resolveModelId(
-  input: string,
-  endpoints: readonly ServingEndpointSummary[],
-  opts: ResolveModelOptions = {},
-): ResolvedModel {
-  if (endpoints.length === 0) {
-    log.debug("resolve:no-endpoints", { input });
-    return { modelId: input, matched: false };
-  }
-  for (const ep of endpoints) {
-    if (ep.name === input) {
-      log.debug("resolve:exact", { input });
-      return { modelId: ep.name, matched: true, score: 0 };
-    }
-  }
-  const threshold = opts.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-  const fuse = new Fuse(endpoints, {
-    keys: ["name"],
-    threshold,
-    ignoreLocation: true,
-    includeScore: true,
-    useExtendedSearch: true,
-    isCaseSensitive: false,
-  });
-  // Fuse 7.3 has no built-in tokenize hook; in extended search,
-  // space-separated tokens are AND-ed with fuzzy matching enabled. We
-  // lean on the shared tokenizer so the splitting rules stay
-  // consistent with the rest of the toolkit.
-  const query = Array.from(
-    stringUtils.tokenizeWithOptions({ lowerCase: true, camelCase: false }, input),
-  ).join(" ");
-  if (!query) {
-    log.debug("resolve:empty-tokens", { input });
-    return { modelId: input, matched: false };
-  }
-  const results = fuse.search(query);
-  const best = results[0];
-  if (best?.item.name && (best.score ?? 0) <= threshold) {
-    log.debug("resolve:fuzzy-match", {
-      input,
-      modelId: best.item.name,
-      score: best.score,
-    });
-    return { modelId: best.item.name, matched: true, score: best.score };
-  }
-  log.debug("resolve:no-match", {
-    input,
-    bestScore: best?.score,
-    threshold,
-  });
-  return { modelId: input, matched: false };
-}
-
 /**
  * Minimal Express-ish request shape used by {@link extractModelOverride}.
  * Keeps this module independent of `express` so the helper can be
@@ -278,18 +79,15 @@ export 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 function resolveServingConfig(
-  config: MastraPluginConfig,
-  defaultFallbacks: readonly string[] = [],
-): {
+export function resolveServingConfig(config: MastraPluginConfig): {
   ttlMs: number;
   threshold: number;
   fuzzy: boolean;
@@ -297,10 +95,10 @@ export function resolveServingConfig(
   fallbacks: readonly string[];
 } {
   return {
-    ttlMs: config.modelCacheTtlMs ?? DEFAULT_TTL_MS,
+    ttlMs: config.modelCacheTtlMs ?? DEFAULT_MODEL_CACHE_TTL_MS,
     threshold: config.modelFuzzyThreshold ?? DEFAULT_FUZZY_THRESHOLD,
     fuzzy: config.modelFuzzyMatch !== false,
     allowOverride: config.modelOverride !== false,
-    fallbacks: config.defaultModelFallbacks ?? defaultFallbacks,
+    fallbacks: config.defaultModelFallbacks ?? [],
   };
 }

package/src/writer.ts

@@ -10,7 +10,7 @@
  * away can't crash a tool mid-flight.
  */
 
-import type { MinimalWriter } from "@dbx-tools/appkit-mastra-shared";
+import type { MastraWriter } from "@dbx-tools/appkit-mastra-shared";
 import { commonUtils, type logUtils } from "@dbx-tools/shared";
 
 /**
@@ -24,7 +24,7 @@ import { commonUtils, type logUtils } from "@dbx-tools/shared";
  */
 export async function safeWrite(
   log: logUtils.Logger,
-  writer: MinimalWriter | undefined,
+  writer: MastraWriter | undefined,
   chunk: unknown,
   context: Record<string, unknown> = {},
 ): Promise<void> {

package/dist/src/intercept.d.ts

@@ -1,48 +0,0 @@
-/**
- * Server-side Server-Sent-Events frame interceptor for the native
- * Mastra agent `/stream` endpoint.
- *
- * The Mastra stream (`@mastra/express`) emits one `data: <json>\n\n`
- * SSE frame per chunk, where the decoded JSON carries a
- * discriminating `type` (`text-delta`, `reasoning-delta`,
- * `tool-call`, `step-finish`, ...) and is terminated by a
- * `data: [DONE]` sentinel. {@link installStreamEventInterceptor} wraps
- * an Express response and runs a caller-supplied
- * {@link StreamFrameInterceptor} over each decoded frame so the caller
- * can keep, rewrite, or drop it; every non-`data:` byte (SSE
- * keep-alive comments, the `[DONE]` sentinel, blank padding) passes
- * through verbatim.
- *
- * The wrap is inert unless the response turns out to be a streamed
- * `200 text/event-stream` body, so non-streaming JSON routes and
- * error responses are never touched.
- */
-import type express from "express";
-/**
- * Per-frame interceptor invoked with the `JSON.parse`d object of every
- * `data: {json}` frame on the Mastra `/stream` response. The return
- * value decides the frame's fate:
- *
- * - `true`: forward the frame's original bytes unchanged (no
- *   re-serialization).
- * - `false`: drop the frame entirely.
- * - `{ replace }`: re-emit the frame with the original `data:` prefix
- *   and trailing whitespace preserved and only the JSON body replaced
- *   by `JSON.stringify(replace)`.
- */
-export type StreamFrameInterceptor = (chunk: unknown) => {
-    replace: unknown;
-} | true | false;
-/**
- * Wrap `res.write` / `res.end` so each SSE frame on a streamed Mastra
- * response is run through `interceptor` (keep / rewrite / drop).
- *
- * Interception only engages once the response is confirmed to be a
- * `200 text/event-stream` body (decided lazily on the first write,
- * after the handler has set status + content-type); any other
- * response streams through unchanged. A {@link StringDecoder}
- * reassembles multi-byte UTF-8 sequences that straddle chunk
- * boundaries, and a running buffer holds the trailing partial frame
- * until its `\n\n` arrives.
- */
-export declare function installStreamEventInterceptor(res: express.Response, interceptor: StreamFrameInterceptor): void;