@dbx-tools/appkit-mastra 0.3.44 → 0.4.1

package/lib/src/processors.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Mastra stream processors wired onto the plugin's agents.
+ *
+ * Two complementary processors live here:
+ *
+ * - An **input** processor ({@link stripStaleChartsProcessor}) that
+ *   scrubs turn-scoped `chartId` fields out of prior tool results
+ *   replayed from Memory, so the model can't copy a stale id into the
+ *   new turn's `[chart:<id>]` markers.
+ * - An **output** processor ({@link ResultProcessor}) that trims the
+ *   bulky, redundant payload fields off targeted outbound stream frames
+ *   before they're serialized to the SSE client.
+ *
+ * @module
+ */
+import type { InputProcessor, Processor } from "@mastra/core/processors";
+/**
+ * Mastra input processor that strips `chartId` fields from every
+ * tool-invocation result in prior assistant messages before they
+ * reach the model.
+ *
+ * Why: chartIds are turn-scoped from the model's point of view -
+ * each `prepare_chart` / `render_data` call mints a fresh id and
+ * the host UI binds it to that turn's reply. Mastra Memory
+ * replays prior tool results into the prompt; if old chartIds
+ * leak through, the model is tempted to copy them verbatim into
+ * the new turn's `[chart:<id>]` markers and the host UI ends up
+ * rendering an unrelated chart from the chart cache (or
+ * a 404 once the 1h TTL elapsed). This processor removes the
+ * temptation by deleting `chartId` keys from every assistant
+ * message's tool results before the prompt is built. The current
+ * turn's tool results don't exist yet at `processInput` time, so
+ * they pass through unmodified.
+ *
+ * The strip is recursive - any nested `chartId` field is removed,
+ * regardless of which tool produced the result. This covers
+ * `prepare_chart` / `render_data` top-level chartIds and any
+ * legacy `datasets[].chartId` payloads uniformly without coupling
+ * to specific tool ids.
+ *
+ * Wired onto every agent by default via `buildAgents`; opt out with
+ * `MastraPluginConfig.stripStaleCharts: false`.
+ */
+export declare const stripStaleChartsProcessor: InputProcessor;
+/**
+ * Mastra output processor that trims the bulky, redundant payload
+ * fields off targeted outbound stream frames.
+ *
+ * Mastra emits step / finish / tool-result frames whose payloads
+ * echo the full tool `output` / `result` / assistant `messages` /
+ * `response` - data the chat client already received inline and
+ * doesn't need re-sent. This processor empties those keys on the
+ * targeted frame types so the outbound SSE stream stays lean;
+ * every other frame passes through untouched.
+ */
+export declare class ResultProcessor implements Processor {
+    id: string;
+    processDataParts: boolean;
+    processOutputStream({ part }: {
+        part: any;
+    }): Promise<any | null>;
+}

package/lib/src/processors.js

@@ -0,0 +1,162 @@
+/**
+ * Mastra stream processors wired onto the plugin's agents.
+ *
+ * Two complementary processors live here:
+ *
+ * - An **input** processor ({@link stripStaleChartsProcessor}) that
+ *   scrubs turn-scoped `chartId` fields out of prior tool results
+ *   replayed from Memory, so the model can't copy a stale id into the
+ *   new turn's `[chart:<id>]` markers.
+ * - An **output** processor ({@link ResultProcessor}) that trims the
+ *   bulky, redundant payload fields off targeted outbound stream frames
+ *   before they're serialized to the SSE client.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("mastra/processors");
+/**
+ * Recursively clone `value`, omitting any property whose key is
+ * `chartId`. Arrays are mapped element-wise; primitives are
+ * returned as-is. The result is structurally identical to the
+ * input minus chartIds, so downstream message-shape consumers
+ * keep working.
+ */
+function stripChartIds(value) {
+    if (Array.isArray(value)) {
+        return value.map(stripChartIds);
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        const out = {};
+        for (const [key, val] of Object.entries(obj)) {
+            if (key === "chartId")
+                continue;
+            out[key] = stripChartIds(val);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Mastra input processor that strips `chartId` fields from every
+ * tool-invocation result in prior assistant messages before they
+ * reach the model.
+ *
+ * Why: chartIds are turn-scoped from the model's point of view -
+ * each `prepare_chart` / `render_data` call mints a fresh id and
+ * the host UI binds it to that turn's reply. Mastra Memory
+ * replays prior tool results into the prompt; if old chartIds
+ * leak through, the model is tempted to copy them verbatim into
+ * the new turn's `[chart:<id>]` markers and the host UI ends up
+ * rendering an unrelated chart from the chart cache (or
+ * a 404 once the 1h TTL elapsed). This processor removes the
+ * temptation by deleting `chartId` keys from every assistant
+ * message's tool results before the prompt is built. The current
+ * turn's tool results don't exist yet at `processInput` time, so
+ * they pass through unmodified.
+ *
+ * The strip is recursive - any nested `chartId` field is removed,
+ * regardless of which tool produced the result. This covers
+ * `prepare_chart` / `render_data` top-level chartIds and any
+ * legacy `datasets[].chartId` payloads uniformly without coupling
+ * to specific tool ids.
+ *
+ * Wired onto every agent by default via `buildAgents`; opt out with
+ * `MastraPluginConfig.stripStaleCharts: false`.
+ */
+export const stripStaleChartsProcessor = {
+    id: "strip-stale-charts",
+    description: "Removes chartId fields from prior tool-invocation results so the model can't reuse turn-scoped ids from memory.",
+    processInput(args) {
+        let stripped = 0;
+        for (const message of args.messages) {
+            if (message.role !== "assistant")
+                continue;
+            const parts = message.content?.parts;
+            if (!Array.isArray(parts))
+                continue;
+            for (const part of parts) {
+                // Tool-invocation parts hold the persisted tool result.
+                // We don't scrub the input args (`rawInput` / `args`) because
+                // the chartId there is the model's outgoing claim, not
+                // anything it could re-reference; only `result` carries
+                // ids that subsequent turns might copy.
+                if (part.type !== "tool-invocation") {
+                    continue;
+                }
+                const inv = part.toolInvocation;
+                if (!inv || inv.result === undefined)
+                    continue;
+                const before = inv.result;
+                const after = stripChartIds(before);
+                // Cheap structural check via JSON length - the actual
+                // strip writes a fresh object only when chartId keys
+                // existed, so different stringification length is a
+                // reliable signal that something was removed.
+                if (typeof before === "object" &&
+                    before !== null &&
+                    JSON.stringify(before).length !== JSON.stringify(after).length) {
+                    inv.result = after;
+                    stripped += 1;
+                }
+            }
+        }
+        if (stripped > 0) {
+            logger.debug("stripped", { results: stripped });
+        }
+        return args.messages;
+    },
+};
+/**
+ * Mastra output processor that trims the bulky, redundant payload
+ * fields off targeted outbound stream frames.
+ *
+ * Mastra emits step / finish / tool-result frames whose payloads
+ * echo the full tool `output` / `result` / assistant `messages` /
+ * `response` - data the chat client already received inline and
+ * doesn't need re-sent. This processor empties those keys on the
+ * targeted frame types so the outbound SSE stream stays lean;
+ * every other frame passes through untouched.
+ */
+export class ResultProcessor {
+    id = "result-processor";
+    // Tell Mastra to also route tool/data parts to this processor method
+    processDataParts = true;
+    async processOutputStream({ part }) {
+        // 1. Guard clause: Ensure the chunk is a valid object
+        if (!part || typeof part !== "object") {
+            return part;
+        }
+        // 2. Filter for the targeted frame types
+        const targetedTypes = ["step-finish", "finish", "tool-result", "data-tool-agent"];
+        if (!targetedTypes.includes(part.type)) {
+            return part; // Return unchanged to pass-through
+        }
+        // 3. Check for the presence of a payload object
+        const payload = part.payload;
+        if (!payload || typeof payload !== "object") {
+            return part;
+        }
+        // 4. Safely delete the unwanted keys from the payload reference
+        const keysToDelete = ["output", "messages", "response", "result"];
+        for (const key of keysToDelete) {
+            if (key in payload) {
+                const value = payload[key];
+                if (typeof value === "object") {
+                    payload[key] = {};
+                }
+                else if (Array.isArray(value)) {
+                    payload[key] = [];
+                }
+                else {
+                    delete payload[key];
+                }
+            }
+        }
+        // 5. Return the modified part object. Mastra handles re-serialization
+        // for the outbound SSE client stream automatically.
+        return part;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processors.js","sourceRoot":"","sources":["../../src/processors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra stream processors wired onto the plugin's agents.\n *\n * Two complementary processors live here:\n *\n * - An **input** processor ({@link stripStaleChartsProcessor}) that\n *   scrubs turn-scoped `chartId` fields out of prior tool results\n *   replayed from Memory, so the model can't copy a stale id into the\n *   new turn's `[chart:<id>]` markers.\n * - An **output** processor ({@link ResultProcessor}) that trims the\n *   bulky, redundant payload fields off targeted outbound stream frames\n *   before they're serialized to the SSE client.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { InputProcessor, ProcessInputArgs, Processor } from \"@mastra/core/processors\";\n\nconst logger = log.logger(\"mastra/processors\");\n\n/**\n * Recursively clone `value`, omitting any property whose key is\n * `chartId`. Arrays are mapped element-wise; primitives are\n * returned as-is. The result is structurally identical to the\n * input minus chartIds, so downstream message-shape consumers\n * keep working.\n */\nfunction stripChartIds(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(stripChartIds);\n  }\n  if (value && typeof value === \"object\") {\n    const obj = value as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(obj)) {\n      if (key === \"chartId\") continue;\n      out[key] = stripChartIds(val);\n    }\n    return out;\n  }\n  return value;\n}\n\n/**\n * Mastra input processor that strips `chartId` fields from every\n * tool-invocation result in prior assistant messages before they\n * reach the model.\n *\n * Why: chartIds are turn-scoped from the model's point of view -\n * each `prepare_chart` / `render_data` call mints a fresh id and\n * the host UI binds it to that turn's reply. Mastra Memory\n * replays prior tool results into the prompt; if old chartIds\n * leak through, the model is tempted to copy them verbatim into\n * the new turn's `[chart:<id>]` markers and the host UI ends up\n * rendering an unrelated chart from the chart cache (or\n * a 404 once the 1h TTL elapsed). This processor removes the\n * temptation by deleting `chartId` keys from every assistant\n * message's tool results before the prompt is built. The current\n * turn's tool results don't exist yet at `processInput` time, so\n * they pass through unmodified.\n *\n * The strip is recursive - any nested `chartId` field is removed,\n * regardless of which tool produced the result. This covers\n * `prepare_chart` / `render_data` top-level chartIds and any\n * legacy `datasets[].chartId` payloads uniformly without coupling\n * to specific tool ids.\n *\n * Wired onto every agent by default via `buildAgents`; opt out with\n * `MastraPluginConfig.stripStaleCharts: false`.\n */\nexport const stripStaleChartsProcessor: InputProcessor = {\n  id: \"strip-stale-charts\",\n  description:\n    \"Removes chartId fields from prior tool-invocation results so the model can't reuse turn-scoped ids from memory.\",\n  processInput(args: ProcessInputArgs) {\n    let stripped = 0;\n    for (const message of args.messages) {\n      if (message.role !== \"assistant\") continue;\n      const parts = message.content?.parts;\n      if (!Array.isArray(parts)) continue;\n      for (const part of parts) {\n        // Tool-invocation parts hold the persisted tool result.\n        // We don't scrub the input args (`rawInput` / `args`) because\n        // the chartId there is the model's outgoing claim, not\n        // anything it could re-reference; only `result` carries\n        // ids that subsequent turns might copy.\n        if ((part as { type?: unknown }).type !== \"tool-invocation\") {\n          continue;\n        }\n        const inv = (part as { toolInvocation?: { result?: unknown } }).toolInvocation;\n        if (!inv || inv.result === undefined) continue;\n        const before = inv.result;\n        const after = stripChartIds(before);\n        // Cheap structural check via JSON length - the actual\n        // strip writes a fresh object only when chartId keys\n        // existed, so different stringification length is a\n        // reliable signal that something was removed.\n        if (\n          typeof before === \"object\" &&\n          before !== null &&\n          JSON.stringify(before).length !== JSON.stringify(after).length\n        ) {\n          inv.result = after;\n          stripped += 1;\n        }\n      }\n    }\n    if (stripped > 0) {\n      logger.debug(\"stripped\", { results: stripped });\n    }\n    return args.messages;\n  },\n};\n\n/**\n * Mastra output processor that trims the bulky, redundant payload\n * fields off targeted outbound stream frames.\n *\n * Mastra emits step / finish / tool-result frames whose payloads\n * echo the full tool `output` / `result` / assistant `messages` /\n * `response` - data the chat client already received inline and\n * doesn't need re-sent. This processor empties those keys on the\n * targeted frame types so the outbound SSE stream stays lean;\n * every other frame passes through untouched.\n */\nexport class ResultProcessor implements Processor {\n  id = \"result-processor\";\n\n  // Tell Mastra to also route tool/data parts to this processor method\n  processDataParts = true;\n\n  async processOutputStream({ part }: { part: any }): Promise<any | null> {\n    // 1. Guard clause: Ensure the chunk is a valid object\n    if (!part || typeof part !== \"object\") {\n      return part;\n    }\n\n    // 2. Filter for the targeted frame types\n    const targetedTypes = [\"step-finish\", \"finish\", \"tool-result\", \"data-tool-agent\"];\n    if (!targetedTypes.includes(part.type)) {\n      return part; // Return unchanged to pass-through\n    }\n\n    // 3. Check for the presence of a payload object\n    const payload = part.payload;\n    if (!payload || typeof payload !== \"object\") {\n      return part;\n    }\n\n    // 4. Safely delete the unwanted keys from the payload reference\n    const keysToDelete = [\"output\", \"messages\", \"response\", \"result\"];\n    for (const key of keysToDelete) {\n      if (key in payload) {\n        const value = payload[key];\n        if (typeof value === \"object\") {\n          payload[key] = {};\n        } else if (Array.isArray(value)) {\n          payload[key] = [];\n        } else {\n          delete payload[key];\n        }\n      }\n    }\n\n    // 5. Return the modified part object. Mastra handles re-serialization\n    // for the outbound SSE client stream automatically.\n    return part;\n  }\n}\n"]}

package/lib/src/rest.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Minimal authenticated Databricks REST helper. Pulls the workspace
+ * host and a fresh bearer header off an OBO-scoped `WorkspaceClient`
+ * (`client.config.getHost()` + `authenticate()`), then issues a plain
+ * `fetch`. Used by modules that hit REST surfaces without a typed SDK
+ * method (e.g. the MLflow assessments API); returns the raw `Response`
+ * so callers decide how to treat status codes. Also carries the
+ * defensive `Response` body readers those callers share.
+ *
+ * @module
+ */
+import { appkit } from "@dbx-tools/appkit";
+/** Workspace client carried on an AppKit execution context. */
+type WorkspaceClient = appkit.WorkspaceClientLike;
+/** Request options for {@link databricksFetch}. */
+export interface DatabricksFetchInit {
+    method: string;
+    /** JSON-serialized as the request body when present. */
+    body?: unknown;
+    /** Extra headers merged over the default `Content-Type: application/json`. */
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * Resolve the workspace host + an authenticated header set off the
+ * client and issue a `fetch` against `path` (mounted on the host).
+ * Runs as whatever identity the client carries - the per-request OBO
+ * user when called from a request scope, the service principal
+ * otherwise.
+ */
+export declare function databricksFetch(client: WorkspaceClient, path: string, init: DatabricksFetchInit): Promise<Response>;
+/** Read a response body as text, swallowing read errors (returns `""`). */
+export declare function readResponseText(res: Response): Promise<string>;
+/** Parse a response body as JSON, returning `{}` on empty / invalid bodies. */
+export declare function readResponseJson(res: Response): Promise<unknown>;
+export {};

package/lib/src/rest.js

@@ -0,0 +1,46 @@
+/**
+ * Minimal authenticated Databricks REST helper. Pulls the workspace
+ * host and a fresh bearer header off an OBO-scoped `WorkspaceClient`
+ * (`client.config.getHost()` + `authenticate()`), then issues a plain
+ * `fetch`. Used by modules that hit REST surfaces without a typed SDK
+ * method (e.g. the MLflow assessments API); returns the raw `Response`
+ * so callers decide how to treat status codes. Also carries the
+ * defensive `Response` body readers those callers share.
+ *
+ * @module
+ */
+import { json } from "@dbx-tools/shared-core";
+/**
+ * Resolve the workspace host + an authenticated header set off the
+ * client and issue a `fetch` against `path` (mounted on the host).
+ * Runs as whatever identity the client carries - the per-request OBO
+ * user when called from a request scope, the service principal
+ * otherwise.
+ */
+export async function databricksFetch(client, path, init) {
+    const host = (await client.config.getHost()).toString();
+    const headers = new Headers({ "Content-Type": "application/json", ...init.headers });
+    await client.config.authenticate(headers);
+    const url = new URL(path, host).toString();
+    return fetch(url, {
+        method: init.method,
+        headers,
+        ...(init.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+        ...(init.signal ? { signal: init.signal } : {}),
+    });
+}
+/** Read a response body as text, swallowing read errors (returns `""`). */
+export async function readResponseText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return "";
+    }
+}
+/** Parse a response body as JSON, returning `{}` on empty / invalid bodies. */
+export async function readResponseJson(res) {
+    const text = await readResponseText(res);
+    return json.parse(text, {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/server.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Express-layer plumbing for the Mastra plugin: a `MastraServer` that
+ * stamps the per-request `RequestContext`, and a route-patch middleware
+ * that lets the plugin's custom API routes (e.g. `historyRoute`) work
+ * behind an Express mount point.
+ *
+ * @module
+ */
+import { RequestContext } from "@mastra/core/request-context";
+import { MastraServer as MastraServerExpress } from "@mastra/express";
+import type express from "express";
+import { type MastraPluginConfig } from "./config.js";
+/**
+ * Stamp the AppKit user (plus the resource id and trace metadata) onto
+ * `requestContext`.
+ *
+ * Split out of {@link MastraServer} because the HTTP middleware is not the only
+ * caller that needs it: an out-of-band turn (a Teams activity arriving on
+ * another plugin's route, a scheduled job) drives `agent.generate` directly, and
+ * without this stamp every user-scoped tool - `ask_genie` above all - fails with
+ * "invoke the tool from an agent turn served by the mastra plugin". Those
+ * callers build a context with {@link createRequestContext} instead of a
+ * request.
+ *
+ * Idempotent: returns immediately when the user and resource id are already
+ * present, so the middleware can call it over a context another layer stamped.
+ */
+export declare function stampRequestContextUser(requestContext: RequestContext): Promise<void>;
+/**
+ * Build the `RequestContext` a NON-HTTP agent turn needs.
+ *
+ * Everything Mastra's tools read off the context is stamped the same way the
+ * request middleware stamps it - the AppKit user (so `ask_genie` and the model
+ * resolver can mint user-scoped tokens), the memory thread / resource pair, and
+ * a request id so the turn's spans join up in traces. The result is passed as
+ * `requestContext` to `agent.generate` / `agent.stream`.
+ *
+ * This is what makes a card turn answer with the SAME data a chat turn does: the
+ * difference between the two endpoints is presentation, not capability.
+ */
+export declare function createRequestContext(options?: {
+    threadId?: string;
+    resourceId?: string;
+    requestId?: string;
+}): Promise<RequestContext>;
+/**
+ * `@mastra/express` subclass that stamps `RequestContext` with the
+ * AppKit user, resource id, and a thread id backed by an HTTP-only
+ * session cookie (`appkit_<plugin-name>_session_id`).
+ */
+export declare class MastraServer extends MastraServerExpress {
+    private config;
+    private log;
+    /**
+     * Whether to stamp the MLflow trace-id header on responses. Shares the
+     * plugin's feedback gate via {@link resolveFeedbackEnabled}.
+     */
+    private feedbackEnabled;
+    constructor(config: MastraPluginConfig, ...args: ConstructorParameters<typeof MastraServerExpress>);
+    registerAuthMiddleware(): void;
+    configureRequestContextUser(requestContext: RequestContext): Promise<void>;
+    /**
+     * Stamp a per-request id and echo it on the response so an upstream
+     * proxy / curl client / browser-side log line can pair its view of
+     * the request with the matching trace span. Reuses `X-Request-Id`
+     * when the upstream already supplies one so multi-hop traces stay
+     * joined; otherwise mints a UUIDv4.
+     *
+     * The id is surfaced as `mastra__requestId` span metadata via
+     * {@link TRACE_REQUEST_CONTEXT_KEYS} and as the `X-Request-Id`
+     * response header so dev tools can copy it from either side.
+     */
+    configureRequestContextRequestId(req: express.Request, res: express.Response, requestContext: RequestContext): void;
+    /**
+     * Stamp OAuth scopes from the forwarded access token on
+     * {@link MASTRA_SCOPES_KEY} for workspace mount gating.
+     */
+    configureRequestContextScopes(req: express.Request, requestContext: RequestContext): void;
+    /**
+     * Stamp the turn's MLflow trace id on the response so the chat client
+     * can attach thumbs / comment feedback to it later. MLflow derives
+     * its trace id from the OpenTelemetry trace id (`tr-<hex>`), and every
+     * Mastra span for this request inherits the ambient OTel context (see
+     * `observability.ts`), so the active span's trace id here is the id
+     * MLflow will record for the turn.
+     *
+     * No-op unless feedback is enabled, and when no live OTel span is
+     * active (e.g. the OTLP SDK isn't registered): in that case the header
+     * is simply absent and the client hides feedback for that message,
+     * degrading gracefully rather than emitting a bogus trace id.
+     */
+    configureMlflowTraceId(res: express.Response): void;
+    /**
+     * Resolve the thread id this request targets and pin it on
+     * `RequestContext` (consumed by the agent stream for persistence and
+     * by the history / threads routes). Resolution order:
+     *
+     *   1. A client-supplied thread id (the thread-selection header /
+     *      `?threadId=` query). This is how the chat UI references a
+     *      specific conversation among the many a user owns - it picks a
+     *      thread id from the `/threads` listing (or mints one for a new
+     *      conversation) and stamps it here. The id is scoped to the
+     *      caller's resource by the recall / list routes, so a client
+     *      can only ever read or write its own threads.
+     *   2. The per-session cookie (`appkit_<plugin-name>_session_id`),
+     *      minted on first contact. This is the default single-thread
+     *      fallback for clients that don't manage threads explicitly, so
+     *      existing embeds keep one stable conversation per session with
+     *      no client changes.
+     */
+    configureRequestContextThreadId(req: express.Request, res: express.Response, requestContext: RequestContext): void;
+    /**
+     * Read the client-selected thread id from the request, preferring
+     * the thread-selection header over the `?threadId=` query. Returns
+     * `null` when neither carries a non-empty value so the caller falls
+     * back to the session cookie.
+     */
+    private readRequestedThreadId;
+    configureRequestContextModelOverride(req: express.Request, requestContext: RequestContext): void;
+}
+/** Inputs for {@link isMastraRequestAllowed}. */
+export interface MastraApiGateOptions {
+    /** `config.apiAccess`; `"full"` short-circuits to allow everything. */
+    access: "scoped" | "full";
+    /** Whether the MCP transport is mounted (so `/mcp/*` is legitimate). */
+    mcpEnabled: boolean;
+}
+/**
+ * Whether a request to the stock `@mastra/express` sub-app should be
+ * dispatched, given the configured {@link MastraApiGateOptions.access}.
+ *
+ * `path` is mount-relative (what the plugin's catch-all sees, e.g.
+ * `/agents/x/stream`, `/route/history/x`, `/mcp/...`). In `"scoped"`
+ * mode the allowlist is deliberately tight - the chat client only ever
+ * needs agent inference, read-only agent metadata, this plugin's own
+ * OBO/resource-scoped `/route/*` routes, and (when enabled) MCP - so the
+ * whole admin / mutating / bulk-export surface Mastra also exposes is
+ * denied by default rather than enumerated.
+ */
+export declare function isMastraRequestAllowed(method: string, path: string, opts: MastraApiGateOptions): boolean;
+/**
+ * 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`).
+ *
+ * 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;