@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/server.js

@@ -0,0 +1,336 @@
+/**
+ * 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 { getExecutionContext } from "@databricks/appkit";
+import { hash, http, log, object, string, token } from "@dbx-tools/shared-core";
+import { feedback, thread } from "@dbx-tools/shared-mastra";
+import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, RequestContext, } from "@mastra/core/request-context";
+import { MastraServer as MastraServerExpress } from "@mastra/express";
+import { trace } from "@opentelemetry/api";
+import { executionContextUserId, MASTRA_REQUEST_ID_KEY, MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, MASTRA_USER_NAME_KEY, } from "./config.js";
+import { resolveFeedbackEnabled } from "./mlflow.js";
+import { extractModelOverride, MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from "./serving.js";
+/**
+ * OpenTelemetry's sentinel for "no valid trace" - 32 zero hex chars.
+ * `trace.getActiveSpan()` returns a non-recording span with this id
+ * when no SDK is registered, which must never be surfaced as a trace to
+ * attach feedback to.
+ */
+const INVALID_TRACE_ID = "0".repeat(32);
+/**
+ * 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 async function stampRequestContextUser(requestContext) {
+    if ([MASTRA_USER_KEY, MASTRA_RESOURCE_ID_KEY].every((key) => requestContext.get(key)))
+        return;
+    const executionContext = getExecutionContext();
+    const user = {
+        id: executionContextUserId(executionContext),
+        executionContext,
+    };
+    requestContext.set(MASTRA_USER_KEY, user);
+    requestContext.set(MASTRA_RESOURCE_ID_KEY, user.id);
+    // AppKit's `UserContext` surfaces display name / email only on
+    // OBO requests. Service-context calls (background tasks, server
+    // start-up) leave these undefined and we skip the stamp so
+    // downstream trace metadata stays absent rather than empty.
+    let userName;
+    let email;
+    if ("isUserContext" in executionContext) {
+        userName = executionContext.userName;
+        email = executionContext.userEmail;
+    }
+    else if (process.env.NODE_ENV === "development") {
+        const currentUser = await executionContext.client.currentUser.me();
+        userName = currentUser?.userName;
+        email = currentUser?.emails?.filter((email) => email.primary).find((email) => email.value)
+            ?.value;
+    }
+    if (userName) {
+        requestContext.set(MASTRA_USER_NAME_KEY, userName);
+    }
+    if (email) {
+        requestContext.set(MASTRA_USER_EMAIL_KEY, email);
+    }
+}
+/**
+ * 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 async function createRequestContext(options = {}) {
+    const requestContext = new RequestContext();
+    await stampRequestContextUser(requestContext);
+    if (options.threadId)
+        requestContext.set(MASTRA_THREAD_ID_KEY, options.threadId);
+    // Stamped AFTER the user so an explicit resource id (a channel member, say)
+    // wins over the ambient identity `stampRequestContextUser` defaulted to.
+    if (options.resourceId)
+        requestContext.set(MASTRA_RESOURCE_ID_KEY, options.resourceId);
+    requestContext.set(MASTRA_REQUEST_ID_KEY, options.requestId ?? hash.id());
+    return 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 class MastraServer extends MastraServerExpress {
+    config;
+    log;
+    /**
+     * Whether to stamp the MLflow trace-id header on responses. Shares the
+     * plugin's feedback gate via {@link resolveFeedbackEnabled}.
+     */
+    feedbackEnabled;
+    constructor(config, ...args) {
+        super(...args);
+        this.config = config;
+        this.log = log.logger(config);
+        this.feedbackEnabled = resolveFeedbackEnabled(config.feedback);
+    }
+    registerAuthMiddleware() {
+        super.registerAuthMiddleware();
+        this.app.use(async (req, res, next) => {
+            const requestContext = res.locals.requestContext;
+            await this.configureRequestContextUser(requestContext);
+            this.configureRequestContextThreadId(req, res, requestContext);
+            this.configureRequestContextModelOverride(req, requestContext);
+            this.configureRequestContextRequestId(req, res, requestContext);
+            this.configureRequestContextScopes(req, requestContext);
+            this.configureMlflowTraceId(res);
+            this.log.debug("auth:middleware", {
+                method: req.method,
+                path: req.path,
+                requestId: requestContext.get(MASTRA_REQUEST_ID_KEY),
+                threadId: requestContext.get(MASTRA_THREAD_ID_KEY),
+                resourceId: requestContext.get(MASTRA_RESOURCE_ID_KEY),
+                userName: requestContext.get(MASTRA_USER_NAME_KEY),
+                userEmail: requestContext.get(MASTRA_USER_EMAIL_KEY),
+                modelOverride: requestContext.get(
+                // imported below; logged so a misrouted request shows
+                // up alongside its model selection in `LOG_LEVEL=debug`.
+                "mastra__model_override"),
+            });
+            next();
+        });
+    }
+    async configureRequestContextUser(requestContext) {
+        await stampRequestContextUser(requestContext);
+    }
+    /**
+     * 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, res, requestContext) {
+        if (requestContext.get(MASTRA_REQUEST_ID_KEY))
+            return;
+        const headerValue = req.headers["x-request-id"];
+        const upstream = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+        const requestId = upstream?.trim() || hash.id();
+        requestContext.set(MASTRA_REQUEST_ID_KEY, requestId);
+        res.setHeader("X-Request-Id", requestId);
+    }
+    /**
+     * Stamp OAuth scopes from the forwarded access token on
+     * {@link MASTRA_SCOPES_KEY} for workspace mount gating.
+     */
+    configureRequestContextScopes(req, requestContext) {
+        const scopes = [
+            ...object
+                .sequence(token.getAccessTokenScopes(req), token.getAccessTokenScopes(req, "authorization"))
+                .distinct(),
+        ];
+        requestContext.set(MASTRA_SCOPES_KEY, scopes);
+    }
+    /**
+     * 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) {
+        if (!this.feedbackEnabled || res.headersSent)
+            return;
+        const traceId = trace.getActiveSpan()?.spanContext().traceId;
+        if (!traceId || traceId === INVALID_TRACE_ID)
+            return;
+        res.setHeader(feedback.MLFLOW_TRACE_ID_HEADER, `tr-${traceId}`);
+    }
+    /**
+     * 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, res, requestContext) {
+        if (requestContext.get(MASTRA_THREAD_ID_KEY))
+            return;
+        const requested = this.readRequestedThreadId(req);
+        if (requested) {
+            requestContext.set(MASTRA_THREAD_ID_KEY, requested);
+            return;
+        }
+        const cookies = http.parseCookies(req.headers.cookie);
+        const cookieName = string.toIdentifierWithOptions({ delimiter: "_", distinct: true }, "appkit", this.config.name, "sessionId");
+        let sessionId = cookies[cookieName];
+        if (!sessionId) {
+            sessionId = hash.id();
+            res.cookie(cookieName, sessionId, {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: req.secure,
+                path: "/",
+            });
+        }
+        requestContext.set(MASTRA_THREAD_ID_KEY, sessionId);
+    }
+    /**
+     * 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.
+     */
+    readRequestedThreadId(req) {
+        const headerValue = req.headers[thread.THREAD_ID_HEADER];
+        const queryValue = req.query[thread.THREAD_ID_QUERY];
+        return (string.trimToNull(Array.isArray(headerValue) ? headerValue[0] : headerValue) ??
+            string.trimToNull(Array.isArray(queryValue) ? queryValue[0] : queryValue));
+    }
+    configureRequestContextModelOverride(req, requestContext) {
+        // Per-request model override: only honored when the plugin
+        // opts in (default). Sources, in priority order, are
+        // `X-Mastra-Model` header, `?model=` query, and `model` /
+        // `modelId` body field; see `serving.ts`.
+        const serving = resolveServingConfig(this.config);
+        if (serving.allowOverride) {
+            const override = extractModelOverride({
+                headers: req.headers,
+                query: req.query,
+                body: req.body,
+            });
+            if (override)
+                requestContext.set(MASTRA_MODEL_OVERRIDE_KEY, override);
+        }
+    }
+}
+/**
+ * Mount-relative agent inference paths (`/agents/:id/<verb>...`). Matched
+ * by prefix on the verb so future variants (`streamVNext`, `stream/vnext`,
+ * `generateVNext`) stay covered without a code change.
+ *
+ * Covers the plain inference verbs (`stream` / `generate` / `network`) plus
+ * the human-in-the-loop resume verbs a paused `requireApproval` tool needs
+ * to continue: `approve-tool-call` / `decline-tool-call` (streaming, and via
+ * prefix their `-generate` non-streaming variants), the `-network-` variants,
+ * and `resume-stream` (covers `resume-stream-until-idle`). Without these an
+ * approval-gated tool (e.g. `send_email`) can be requested but never approved
+ * from the browser - the resume `POST` 403s under scoped mode. These are the
+ * only *writes* the browser client is allowed to make against stock Mastra.
+ */
+const AGENT_INFERENCE = /^\/agents\/[^/]+\/(stream|generate|network|resume-stream|approve-tool-call|decline-tool-call|approve-network-tool-call|decline-network-tool-call)/i;
+/** Mount-relative read-only agent metadata (`/agents`, `/agents/:id`). */
+const AGENT_METADATA = /^\/agents(\/[^/]+)?$/;
+/**
+ * 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 function isMastraRequestAllowed(method, path, opts) {
+    if (opts.access === "full")
+        return true;
+    const p = path.startsWith("/") ? path : `/${path}`;
+    // This plugin's own custom routes are individually OBO- and
+    // resource-scoped (see history.ts / threads.ts), so every method is safe.
+    if (p === "/route" || p.startsWith("/route/"))
+        return true;
+    if (opts.mcpEnabled && (p === "/mcp" || p.startsWith("/mcp/")))
+        return true;
+    const m = method.toUpperCase();
+    if (m === "POST" && AGENT_INFERENCE.test(p))
+        return true;
+    if (m === "GET" && AGENT_METADATA.test(p))
+        return true;
+    return false;
+}
+/**
+ * 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 function attachRoutePatchMiddleware(app) {
+    app.use((req, _res, next) => {
+        const isCustomRoute = req.path === "/route" || req.path.startsWith("/route/");
+        if (!isCustomRoute)
+            return next();
+        req.originalUrl = req.path;
+        next();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Express-layer plumbing for the Mastra plugin: a `MastraServer` that\n * stamps the per-request `RequestContext`, and a route-patch middleware\n * that lets the plugin's custom API routes (e.g. `historyRoute`) work\n * behind an Express mount point.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { hash, http, log, object, string, token } from \"@dbx-tools/shared-core\";\nimport { feedback, thread } from \"@dbx-tools/shared-mastra\";\nimport {\n  MASTRA_RESOURCE_ID_KEY,\n  MASTRA_THREAD_ID_KEY,\n  RequestContext,\n} from \"@mastra/core/request-context\";\nimport { MastraServer as MastraServerExpress } from \"@mastra/express\";\nimport { trace } from \"@opentelemetry/api\";\nimport type express from \"express\";\n\nimport {\n  executionContextUserId,\n  MASTRA_REQUEST_ID_KEY,\n  MASTRA_SCOPES_KEY,\n  MASTRA_USER_EMAIL_KEY,\n  MASTRA_USER_KEY,\n  MASTRA_USER_NAME_KEY,\n  type MastraPluginConfig,\n  type User,\n} from \"./config\";\nimport { resolveFeedbackEnabled } from \"./mlflow\";\n\nimport { extractModelOverride, MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from \"./serving\";\n/**\n * OpenTelemetry's sentinel for \"no valid trace\" - 32 zero hex chars.\n * `trace.getActiveSpan()` returns a non-recording span with this id\n * when no SDK is registered, which must never be surfaced as a trace to\n * attach feedback to.\n */\nconst INVALID_TRACE_ID = \"0\".repeat(32);\n\n/**\n * Stamp the AppKit user (plus the resource id and trace metadata) onto\n * `requestContext`.\n *\n * Split out of {@link MastraServer} because the HTTP middleware is not the only\n * caller that needs it: an out-of-band turn (a Teams activity arriving on\n * another plugin's route, a scheduled job) drives `agent.generate` directly, and\n * without this stamp every user-scoped tool - `ask_genie` above all - fails with\n * \"invoke the tool from an agent turn served by the mastra plugin\". Those\n * callers build a context with {@link createRequestContext} instead of a\n * request.\n *\n * Idempotent: returns immediately when the user and resource id are already\n * present, so the middleware can call it over a context another layer stamped.\n */\nexport async function stampRequestContextUser(requestContext: RequestContext): Promise<void> {\n  if ([MASTRA_USER_KEY, MASTRA_RESOURCE_ID_KEY].every((key) => requestContext.get(key))) return;\n  const executionContext = getExecutionContext();\n  const user: User = {\n    id: executionContextUserId(executionContext),\n    executionContext,\n  };\n  requestContext.set(MASTRA_USER_KEY, user);\n  requestContext.set(MASTRA_RESOURCE_ID_KEY, user.id);\n  // AppKit's `UserContext` surfaces display name / email only on\n  // OBO requests. Service-context calls (background tasks, server\n  // start-up) leave these undefined and we skip the stamp so\n  // downstream trace metadata stays absent rather than empty.\n  let userName: string | undefined;\n  let email: string | undefined;\n  if (\"isUserContext\" in executionContext) {\n    userName = executionContext.userName;\n    email = executionContext.userEmail;\n  } else if (process.env.NODE_ENV === \"development\") {\n    const currentUser = await executionContext.client.currentUser.me();\n    userName = currentUser?.userName;\n    email = currentUser?.emails?.filter((email) => email.primary).find((email) => email.value)\n      ?.value as string;\n  }\n  if (userName) {\n    requestContext.set(MASTRA_USER_NAME_KEY, userName);\n  }\n  if (email) {\n    requestContext.set(MASTRA_USER_EMAIL_KEY, email);\n  }\n}\n\n/**\n * Build the `RequestContext` a NON-HTTP agent turn needs.\n *\n * Everything Mastra's tools read off the context is stamped the same way the\n * request middleware stamps it - the AppKit user (so `ask_genie` and the model\n * resolver can mint user-scoped tokens), the memory thread / resource pair, and\n * a request id so the turn's spans join up in traces. The result is passed as\n * `requestContext` to `agent.generate` / `agent.stream`.\n *\n * This is what makes a card turn answer with the SAME data a chat turn does: the\n * difference between the two endpoints is presentation, not capability.\n */\nexport async function createRequestContext(\n  options: { threadId?: string; resourceId?: string; requestId?: string } = {},\n): Promise<RequestContext> {\n  const requestContext = new RequestContext();\n  await stampRequestContextUser(requestContext);\n  if (options.threadId) requestContext.set(MASTRA_THREAD_ID_KEY, options.threadId);\n  // Stamped AFTER the user so an explicit resource id (a channel member, say)\n  // wins over the ambient identity `stampRequestContextUser` defaulted to.\n  if (options.resourceId) requestContext.set(MASTRA_RESOURCE_ID_KEY, options.resourceId);\n  requestContext.set(MASTRA_REQUEST_ID_KEY, options.requestId ?? hash.id());\n  return requestContext;\n}\n\n/**\n * `@mastra/express` subclass that stamps `RequestContext` with the\n * AppKit user, resource id, and a thread id backed by an HTTP-only\n * session cookie (`appkit_<plugin-name>_session_id`).\n */\nexport class MastraServer extends MastraServerExpress {\n  private log: log.Logger;\n  /**\n   * Whether to stamp the MLflow trace-id header on responses. Shares the\n   * plugin's feedback gate via {@link resolveFeedbackEnabled}.\n   */\n  private feedbackEnabled: boolean;\n\n  constructor(\n    private config: MastraPluginConfig,\n    ...args: ConstructorParameters<typeof MastraServerExpress>\n  ) {\n    super(...args);\n    this.log = log.logger(config);\n    this.feedbackEnabled = resolveFeedbackEnabled(config.feedback);\n  }\n\n  override registerAuthMiddleware(): void {\n    super.registerAuthMiddleware();\n    this.app.use(async (req, res, next) => {\n      const requestContext = res.locals.requestContext! as RequestContext;\n      await this.configureRequestContextUser(requestContext);\n      this.configureRequestContextThreadId(req, res, requestContext);\n      this.configureRequestContextModelOverride(req, requestContext);\n      this.configureRequestContextRequestId(req, res, requestContext);\n      this.configureRequestContextScopes(req, requestContext);\n\n      this.configureMlflowTraceId(res);\n      this.log.debug(\"auth:middleware\", {\n        method: req.method,\n        path: req.path,\n        requestId: requestContext.get(MASTRA_REQUEST_ID_KEY),\n        threadId: requestContext.get(MASTRA_THREAD_ID_KEY),\n        resourceId: requestContext.get(MASTRA_RESOURCE_ID_KEY),\n        userName: requestContext.get(MASTRA_USER_NAME_KEY),\n        userEmail: requestContext.get(MASTRA_USER_EMAIL_KEY),\n        modelOverride: requestContext.get(\n          // imported below; logged so a misrouted request shows\n          // up alongside its model selection in `LOG_LEVEL=debug`.\n          \"mastra__model_override\",\n        ),\n      });\n      next();\n    });\n  }\n\n  async configureRequestContextUser(requestContext: RequestContext) {\n    await stampRequestContextUser(requestContext);\n  }\n\n  /**\n   * Stamp a per-request id and echo it on the response so an upstream\n   * proxy / curl client / browser-side log line can pair its view of\n   * the request with the matching trace span. Reuses `X-Request-Id`\n   * when the upstream already supplies one so multi-hop traces stay\n   * joined; otherwise mints a UUIDv4.\n   *\n   * The id is surfaced as `mastra__requestId` span metadata via\n   * {@link TRACE_REQUEST_CONTEXT_KEYS} and as the `X-Request-Id`\n   * response header so dev tools can copy it from either side.\n   */\n  configureRequestContextRequestId(\n    req: express.Request,\n    res: express.Response,\n    requestContext: RequestContext,\n  ) {\n    if (requestContext.get(MASTRA_REQUEST_ID_KEY)) return;\n    const headerValue = req.headers[\"x-request-id\"];\n    const upstream = Array.isArray(headerValue) ? headerValue[0] : headerValue;\n    const requestId = upstream?.trim() || hash.id();\n    requestContext.set(MASTRA_REQUEST_ID_KEY, requestId);\n    res.setHeader(\"X-Request-Id\", requestId);\n  }\n\n  /**\n   * Stamp OAuth scopes from the forwarded access token on\n   * {@link MASTRA_SCOPES_KEY} for workspace mount gating.\n   */\n  configureRequestContextScopes(req: express.Request, requestContext: RequestContext) {\n    const scopes = [\n      ...object\n        .sequence(token.getAccessTokenScopes(req), token.getAccessTokenScopes(req, \"authorization\"))\n        .distinct(),\n    ];\n    requestContext.set(MASTRA_SCOPES_KEY, scopes);\n  }\n\n  /**\n   * Stamp the turn's MLflow trace id on the response so the chat client\n   * can attach thumbs / comment feedback to it later. MLflow derives\n   * its trace id from the OpenTelemetry trace id (`tr-<hex>`), and every\n   * Mastra span for this request inherits the ambient OTel context (see\n   * `observability.ts`), so the active span's trace id here is the id\n   * MLflow will record for the turn.\n   *\n   * No-op unless feedback is enabled, and when no live OTel span is\n   * active (e.g. the OTLP SDK isn't registered): in that case the header\n   * is simply absent and the client hides feedback for that message,\n   * degrading gracefully rather than emitting a bogus trace id.\n   */\n  configureMlflowTraceId(res: express.Response) {\n    if (!this.feedbackEnabled || res.headersSent) return;\n    const traceId = trace.getActiveSpan()?.spanContext().traceId;\n    if (!traceId || traceId === INVALID_TRACE_ID) return;\n    res.setHeader(feedback.MLFLOW_TRACE_ID_HEADER, `tr-${traceId}`);\n  }\n\n  /**\n   * Resolve the thread id this request targets and pin it on\n   * `RequestContext` (consumed by the agent stream for persistence and\n   * by the history / threads routes). Resolution order:\n   *\n   *   1. A client-supplied thread id (the thread-selection header /\n   *      `?threadId=` query). This is how the chat UI references a\n   *      specific conversation among the many a user owns - it picks a\n   *      thread id from the `/threads` listing (or mints one for a new\n   *      conversation) and stamps it here. The id is scoped to the\n   *      caller's resource by the recall / list routes, so a client\n   *      can only ever read or write its own threads.\n   *   2. The per-session cookie (`appkit_<plugin-name>_session_id`),\n   *      minted on first contact. This is the default single-thread\n   *      fallback for clients that don't manage threads explicitly, so\n   *      existing embeds keep one stable conversation per session with\n   *      no client changes.\n   */\n  configureRequestContextThreadId(\n    req: express.Request,\n    res: express.Response,\n    requestContext: RequestContext,\n  ) {\n    if (requestContext.get(MASTRA_THREAD_ID_KEY)) return;\n    const requested = this.readRequestedThreadId(req);\n    if (requested) {\n      requestContext.set(MASTRA_THREAD_ID_KEY, requested);\n      return;\n    }\n    const cookies = http.parseCookies(req.headers.cookie);\n    const cookieName = string.toIdentifierWithOptions(\n      { delimiter: \"_\", distinct: true },\n      \"appkit\",\n      this.config.name!,\n      \"sessionId\",\n    );\n    let sessionId = cookies[cookieName];\n    if (!sessionId) {\n      sessionId = hash.id();\n      res.cookie(cookieName, sessionId, {\n        httpOnly: true,\n        sameSite: \"lax\",\n        secure: req.secure,\n        path: \"/\",\n      });\n    }\n    requestContext.set(MASTRA_THREAD_ID_KEY, sessionId);\n  }\n\n  /**\n   * Read the client-selected thread id from the request, preferring\n   * the thread-selection header over the `?threadId=` query. Returns\n   * `null` when neither carries a non-empty value so the caller falls\n   * back to the session cookie.\n   */\n  private readRequestedThreadId(req: express.Request): string | null {\n    const headerValue = req.headers[thread.THREAD_ID_HEADER];\n    const queryValue = req.query[thread.THREAD_ID_QUERY];\n    return (\n      string.trimToNull(Array.isArray(headerValue) ? headerValue[0] : headerValue) ??\n      string.trimToNull(Array.isArray(queryValue) ? queryValue[0] : queryValue)\n    );\n  }\n\n  configureRequestContextModelOverride(req: express.Request, requestContext: RequestContext) {\n    // Per-request model override: only honored when the plugin\n    // opts in (default). Sources, in priority order, are\n    // `X-Mastra-Model` header, `?model=` query, and `model` /\n    // `modelId` body field; see `serving.ts`.\n    const serving = resolveServingConfig(this.config);\n    if (serving.allowOverride) {\n      const override = extractModelOverride({\n        headers: req.headers as Record<string, string | string[] | undefined>,\n        query: req.query as Record<string, unknown>,\n        body: req.body,\n      });\n      if (override) requestContext.set(MASTRA_MODEL_OVERRIDE_KEY, override);\n    }\n  }\n}\n\n/** Inputs for {@link isMastraRequestAllowed}. */\nexport interface MastraApiGateOptions {\n  /** `config.apiAccess`; `\"full\"` short-circuits to allow everything. */\n  access: \"scoped\" | \"full\";\n  /** Whether the MCP transport is mounted (so `/mcp/*` is legitimate). */\n  mcpEnabled: boolean;\n}\n\n/**\n * Mount-relative agent inference paths (`/agents/:id/<verb>...`). Matched\n * by prefix on the verb so future variants (`streamVNext`, `stream/vnext`,\n * `generateVNext`) stay covered without a code change.\n *\n * Covers the plain inference verbs (`stream` / `generate` / `network`) plus\n * the human-in-the-loop resume verbs a paused `requireApproval` tool needs\n * to continue: `approve-tool-call` / `decline-tool-call` (streaming, and via\n * prefix their `-generate` non-streaming variants), the `-network-` variants,\n * and `resume-stream` (covers `resume-stream-until-idle`). Without these an\n * approval-gated tool (e.g. `send_email`) can be requested but never approved\n * from the browser - the resume `POST` 403s under scoped mode. These are the\n * only *writes* the browser client is allowed to make against stock Mastra.\n */\nconst AGENT_INFERENCE =\n  /^\\/agents\\/[^/]+\\/(stream|generate|network|resume-stream|approve-tool-call|decline-tool-call|approve-network-tool-call|decline-network-tool-call)/i;\n\n/** Mount-relative read-only agent metadata (`/agents`, `/agents/:id`). */\nconst AGENT_METADATA = /^\\/agents(\\/[^/]+)?$/;\n\n/**\n * Whether a request to the stock `@mastra/express` sub-app should be\n * dispatched, given the configured {@link MastraApiGateOptions.access}.\n *\n * `path` is mount-relative (what the plugin's catch-all sees, e.g.\n * `/agents/x/stream`, `/route/history/x`, `/mcp/...`). In `\"scoped\"`\n * mode the allowlist is deliberately tight - the chat client only ever\n * needs agent inference, read-only agent metadata, this plugin's own\n * OBO/resource-scoped `/route/*` routes, and (when enabled) MCP - so the\n * whole admin / mutating / bulk-export surface Mastra also exposes is\n * denied by default rather than enumerated.\n */\nexport function isMastraRequestAllowed(\n  method: string,\n  path: string,\n  opts: MastraApiGateOptions,\n): boolean {\n  if (opts.access === \"full\") return true;\n  const p = path.startsWith(\"/\") ? path : `/${path}`;\n  // This plugin's own custom routes are individually OBO- and\n  // resource-scoped (see history.ts / threads.ts), so every method is safe.\n  if (p === \"/route\" || p.startsWith(\"/route/\")) return true;\n  if (opts.mcpEnabled && (p === \"/mcp\" || p.startsWith(\"/mcp/\"))) return true;\n  const m = method.toUpperCase();\n  if (m === \"POST\" && AGENT_INFERENCE.test(p)) return true;\n  if (m === \"GET\" && AGENT_METADATA.test(p)) return true;\n  return false;\n}\n\n/**\n * Patches around `@mastra/express`'s custom-route dispatcher so the\n * plugin's custom API routes (e.g. `historyRoute`) work when\n * `MastraServer` is hosted on an Express subapp mounted under a parent\n * path (e.g. `/api/mastra`).\n *\n * The adapter's `registerCustomApiRoutes` matches against `req.path`\n * (mount-relative, correct) but dispatches to its internal Hono\n * mini-app using `req.originalUrl`, which still contains the parent\n * mount prefix. The Hono app registers the literal route paths\n * (for example `/route/history`), so the absolute URL never matches\n * until we overwrite `originalUrl` for `/route` and `/route/*` to the\n * mount-relative path.\n */\nexport function attachRoutePatchMiddleware(app: express.Express): void {\n  app.use((req, _res, next) => {\n    const isCustomRoute = req.path === \"/route\" || req.path.startsWith(\"/route/\");\n    if (!isCustomRoute) return next();\n    req.originalUrl = req.path;\n    next();\n  });\n}\n"]}

package/lib/src/serving-sanitize.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Repairs traffic between Mastra / the AI SDK and Databricks Model Serving's
+ * OpenAI-compatible `/chat/completions` route, in both directions.
+ *
+ * Outbound ({@link rewriteServingBody}), because the transcript Mastra
+ * persists is not always a transcript the provider will accept back:
+ * Databricks-hosted Claude rejects replayed extended-thinking blocks and reads
+ * a trailing assistant message as a prefill request.
+ *
+ * Inbound ({@link rewriteServingResponseBody}), because Databricks-hosted
+ * Gemini answers with its native content-parts array where the OpenAI contract
+ * (and therefore the AI SDK's response schema) requires a plain string.
+ *
+ * Every repair here is a provider quirk rather than a schema violation, so all
+ * of them are applied on the wire (see the `globalThis.fetch` wrapper in
+ * `model.ts`) rather than by changing what the agent stores or what the UI
+ * shows.
+ *
+ * @module
+ */
+import { type ChatMessage, type ChatRole } from "@dbx-tools/shared-model";
+/**
+ * A chat message as it arrives on the serving wire, plus the extended-thinking
+ * fields Databricks-hosted Claude adds. The OpenAI-standard part of the shape
+ * is {@link ChatMessage} from `@dbx-tools/shared-model`; only the provider
+ * extensions this module strips are declared here.
+ */
+export interface ServingChatMessage extends ChatMessage {
+    /** Narrowed to the roles this repair pass reasons about, plus Claude's `reasoning` turn. */
+    role: ChatRole | "reasoning";
+    reasoning?: unknown;
+    reasoning_content?: unknown;
+}
+/**
+ * Parse, sanitize, and re-serialize a `/serving-endpoints/...` POST
+ * body. Returns the original string verbatim when the body is not
+ * JSON or no rewrite was needed.
+ */
+export declare function rewriteServingBody(body: string): string;
+/**
+ * Drop extended-thinking / reasoning blocks from a replayed transcript.
+ *
+ * Hybrid Claude endpoints (e.g. Sonnet 4.5+) may emit `reasoning` content
+ * parts on the first turn. Mastra persists and replays them on the next
+ * agent step, but Databricks-hosted Claude rejects those blocks on
+ * multi-turn tool continuations. The UI already captured reasoning for
+ * display; stripping here keeps provider replay compatible without
+ * changing what users see in the chat bubble.
+ */
+export declare function stripReasoningFromServingMessages(messages: ServingChatMessage[]): boolean;
+/**
+ * Repair a Mastra/AI SDK message replay that Databricks-hosted Claude
+ * rejects with `"This model does not support assistant message
+ * prefill. The conversation must end with a user message."`.
+ *
+ * The bug pattern: when an assistant turn streams text *and* a
+ * `tool_call`, the AI SDK persists them as two separate assistant
+ * entries (text-only and tool-call-only). On the next agent step the
+ * tool-call entry is replayed *before* the tool result and the
+ * text entry is replayed *after* it, so the conversation ends with a
+ * trailing assistant text message. Anthropic interprets that as a
+ * prefill request and rejects it on Databricks (the upstream Bedrock
+ * route disallows prefill).
+ *
+ * Fix: when the last message is an assistant text with no `tool_calls`
+ * and the chain immediately before it is `assistant(tool_calls=...)`
+ * followed only by `tool(...)` results, fold the trailing text back
+ * into the `content` of that opening assistant and drop the duplicate.
+ */
+export declare function repairAssistantPrefill(messages: ServingChatMessage[]): boolean;
+/**
+ * Parse, sanitize, and re-serialize a `/serving-endpoints/...` non-streaming
+ * JSON RESPONSE body. Returns the original string verbatim when the body is
+ * not JSON or no rewrite was needed, mirroring
+ * {@link rewriteServingBody} on the request side.
+ */
+export declare function rewriteServingResponseBody(body: string): string;
+/**
+ * Collapse a structured `choices[].message.content` array to the plain string
+ * the OpenAI Chat Completions contract specifies.
+ *
+ * Databricks-hosted Gemini answers a non-streaming `/chat/completions` call
+ * with the Gemini-native parts shape:
+ *
+ * ```json
+ * "content": [{ "type": "text", "text": "...", "thoughtSignature": "..." }]
+ * ```
+ *
+ * `@ai-sdk/openai-compatible` validates the response against the OpenAI
+ * schema, where `content` is a nullable string, so it throws
+ * `Type validation failed: ... expected string, received array` and the whole
+ * call fails (`AI_APICallError: Invalid JSON response` on an HTTP 200). Mastra
+ * uses `doGenerate` for its side calls, so the visible symptom is
+ * `Error generating title` - every thread keeps its placeholder name.
+ *
+ * Flattening on the wire keeps the repair in one place: the streaming path is
+ * unaffected (deltas already carry string content), and neither the agent's
+ * stored transcript nor the UI has to know the provider emitted parts. Any
+ * non-text part (a `thoughtSignature`-only entry, an inline image) contributes
+ * nothing, matching {@link openaiChat.chatContentToText}, and an all-parts-empty
+ * message flattens to `""` rather than being dropped, so `finish_reason` and
+ * `usage` still round-trip.
+ */
+export declare function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean;