@dbx-tools/appkit-mastra 0.9.69 → 0.9.71

package/lib/src/openapi-tool.js

@@ -0,0 +1,181 @@
+/**
+ * OpenAPI operation loading and JSON Schema extraction.
+ *
+ * @module
+ */
+import { readFile } from "node:fs/promises";
+import { object } from "@dbx-tools/shared-core";
+import { urlBuilder } from "@dbx-tools/shared-core/net";
+import { z } from "zod";
+const HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+    "HEAD",
+    "TRACE",
+];
+const JsonObjectSchema = z
+    .record(z.string(), z.unknown())
+    .describe("A JSON object embedded in an OpenAPI document.");
+const OpenApiMediaTypeSchema = z
+    .object({
+    schema: JsonObjectSchema.describe("The JSON Schema for this media type."),
+})
+    .describe("One OpenAPI media type.");
+const OpenApiRequestBodySchema = z
+    .object({
+    content: z
+        .record(z.string(), OpenApiMediaTypeSchema)
+        .describe("Request media types keyed by content type."),
+})
+    .describe("An OpenAPI request body.");
+const OpenApiResponseSchema = z
+    .object({
+    content: z
+        .record(z.string(), OpenApiMediaTypeSchema)
+        .optional()
+        .describe("Response media types keyed by content type."),
+})
+    .describe("One OpenAPI response.");
+const OpenApiOperationSchema = z
+    .object({
+    operationId: z.string().describe("The stable operation identifier."),
+    summary: z.string().optional().describe("The short operation summary."),
+    description: z.string().optional().describe("The full operation description."),
+    requestBody: OpenApiRequestBodySchema.optional().describe("The optional operation request body."),
+    responses: z
+        .record(z.string(), OpenApiResponseSchema)
+        .describe("Operation responses keyed by HTTP status."),
+})
+    .describe("The OpenAPI fields required to define a tool.");
+const OpenApiPathSchema = z
+    .object({
+    get: OpenApiOperationSchema.optional(),
+    post: OpenApiOperationSchema.optional(),
+    put: OpenApiOperationSchema.optional(),
+    patch: OpenApiOperationSchema.optional(),
+    delete: OpenApiOperationSchema.optional(),
+    options: OpenApiOperationSchema.optional(),
+    head: OpenApiOperationSchema.optional(),
+    trace: OpenApiOperationSchema.optional(),
+})
+    .describe("Operations available at one OpenAPI path.");
+const OpenApiDocumentSchema = z
+    .object({
+    paths: z
+        .record(z.string(), OpenApiPathSchema)
+        .refine((paths) => Object.keys(paths).length > 0, "OpenAPI paths must not be empty")
+        .describe("OpenAPI path items keyed by URL path."),
+    components: JsonObjectSchema.optional().describe("Reusable OpenAPI components."),
+    servers: z
+        .array(z.object({
+        url: z.string().describe("Server base URL."),
+    }))
+        .optional()
+        .describe("OpenAPI server definitions."),
+})
+    .describe("An OpenAPI document used to define HTTP tools.");
+/** Load an HTTP(S) URL or local file and return its OpenAPI operations as tool schemas. */
+export async function openApiTools(source, options = {}) {
+    const sourceUrl = httpUrl(source);
+    const document = OpenApiDocumentSchema.parse(sourceUrl
+        ? await fetchDocument(sourceUrl, options)
+        : await readDocument(source, options.signal));
+    return Object.entries(document.paths).flatMap(([path, item]) => HTTP_METHODS.flatMap((method) => {
+        const operation = item[method.toLowerCase()];
+        return operation ? [operationTool(document, sourceUrl, path, method, operation)] : [];
+    }));
+}
+function httpUrl(source) {
+    const url = urlBuilder(source);
+    return url?.scheme === "http" || url?.scheme === "https" ? url : undefined;
+}
+async function fetchDocument(url, options) {
+    const response = await fetch(url, {
+        signal: options.signal,
+        headers: options.headers,
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAPI request failed with HTTP ${response.status}: ${url}`);
+    }
+    return response.json();
+}
+async function readDocument(path, signal) {
+    return JSON.parse(await readFile(path, { encoding: "utf8", signal }));
+}
+function operationTool(document, sourceUrl, path, method, operation) {
+    const requestSchema = jsonSchema(operation.requestBody?.content) ?? { type: "object" };
+    const responseSchema = successfulResponseSchema(operation);
+    return {
+        id: operation.operationId,
+        description: operation.description?.trim() || operation.summary?.trim() || operation.operationId,
+        url: operationUrl(document, sourceUrl, path),
+        method,
+        inputSchema: resolveReferences(document, requestSchema),
+        outputSchema: resolveReferences(document, responseSchema),
+    };
+}
+function successfulResponseSchema(operation) {
+    for (const [status, response] of Object.entries(operation.responses)) {
+        const schema = jsonSchema(response.content);
+        if (/^2(?:\d{2}|XX)$/i.test(status) && schema)
+            return schema;
+    }
+    return {};
+}
+function jsonSchema(content) {
+    const mediaType = Object.entries(content ?? {}).find(([type]) => /^application\/(?:[^+;]+\+)?json(?:;|$)/i.test(type));
+    return mediaType?.[1].schema;
+}
+function operationUrl(document, sourceUrl, path) {
+    const server = document.servers?.[0]?.url;
+    if (server) {
+        const base = sourceUrl ? urlBuilder(new URL(server, sourceUrl)) : httpUrl(server);
+        return base
+            ? base.withPathAppend(path).toString()
+            : `${server.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+    }
+    return sourceUrl ? urlBuilder(sourceUrl)?.withPathReplace(path).toString() ?? path : path;
+}
+function resolveReferences(document, value, active = new Set()) {
+    if (Array.isArray(value))
+        return value.map((item) => resolveReferences(document, item, active));
+    if (!object.isRecord(value))
+        return value;
+    const reference = typeof value.$ref === "string" ? value.$ref : undefined;
+    if (reference) {
+        if (active.has(reference))
+            throw new Error(`Cyclic OpenAPI reference: ${reference}`);
+        const target = referenceTarget(document, reference);
+        const next = new Set(active).add(reference);
+        const { $ref: _ignored, ...siblings } = value;
+        return {
+            ...resolveReferences(document, target, next),
+            ...resolveReferences(document, siblings, next),
+        };
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, resolveReferences(document, child, active)]));
+}
+function referenceTarget(document, reference) {
+    if (!reference.startsWith("#/"))
+        throw new Error(`Unsupported OpenAPI reference: ${reference}`);
+    let current = document;
+    for (const rawSegment of reference.slice(2).split("/")) {
+        const segment = rawSegment.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!object.isRecord(current) || !(segment in current)) {
+            throw new Error(`Unresolved OpenAPI reference: ${reference}`);
+        }
+        current = current[segment];
+    }
+    return current;
+}
+if (import.meta.main) {
+    const source = process.argv[2];
+    if (!source)
+        throw new Error("Usage: bun openapi-tool.ts <openapi-url-or-file>");
+    console.log(JSON.stringify(await openApiTools(source), null, 2));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openapi-tool.js","sourceRoot":"","sources":["../../src/openapi-tool.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAPI operation loading and JSON Schema extraction.\n *\n * @module\n */\nimport { readFile } from \"node:fs/promises\";\nimport { object } from \"@dbx-tools/shared-core\";\nimport { urlBuilder, type UrlBuilder } from \"@dbx-tools/shared-core/net\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { z } from \"zod\";\n\nconst HTTP_METHODS = [\n  \"GET\",\n  \"POST\",\n  \"PUT\",\n  \"PATCH\",\n  \"DELETE\",\n  \"OPTIONS\",\n  \"HEAD\",\n  \"TRACE\",\n] as const;\n\nconst JsonObjectSchema = z\n  .record(z.string(), z.unknown())\n  .describe(\"A JSON object embedded in an OpenAPI document.\");\n\nconst OpenApiMediaTypeSchema = z\n  .object({\n    schema: JsonObjectSchema.describe(\"The JSON Schema for this media type.\"),\n  })\n  .describe(\"One OpenAPI media type.\");\n\nconst OpenApiRequestBodySchema = z\n  .object({\n    content: z\n      .record(z.string(), OpenApiMediaTypeSchema)\n      .describe(\"Request media types keyed by content type.\"),\n  })\n  .describe(\"An OpenAPI request body.\");\n\nconst OpenApiResponseSchema = z\n  .object({\n    content: z\n      .record(z.string(), OpenApiMediaTypeSchema)\n      .optional()\n      .describe(\"Response media types keyed by content type.\"),\n  })\n  .describe(\"One OpenAPI response.\");\n\nconst OpenApiOperationSchema = z\n  .object({\n    operationId: z.string().describe(\"The stable operation identifier.\"),\n    summary: z.string().optional().describe(\"The short operation summary.\"),\n    description: z.string().optional().describe(\"The full operation description.\"),\n    requestBody: OpenApiRequestBodySchema.optional().describe(\n      \"The optional operation request body.\",\n    ),\n    responses: z\n      .record(z.string(), OpenApiResponseSchema)\n      .describe(\"Operation responses keyed by HTTP status.\"),\n  })\n  .describe(\"The OpenAPI fields required to define a tool.\");\n\nconst OpenApiPathSchema = z\n  .object({\n    get: OpenApiOperationSchema.optional(),\n    post: OpenApiOperationSchema.optional(),\n    put: OpenApiOperationSchema.optional(),\n    patch: OpenApiOperationSchema.optional(),\n    delete: OpenApiOperationSchema.optional(),\n    options: OpenApiOperationSchema.optional(),\n    head: OpenApiOperationSchema.optional(),\n    trace: OpenApiOperationSchema.optional(),\n  })\n  .describe(\"Operations available at one OpenAPI path.\");\n\nconst OpenApiDocumentSchema = z\n  .object({\n    paths: z\n      .record(z.string(), OpenApiPathSchema)\n      .refine((paths) => Object.keys(paths).length > 0, \"OpenAPI paths must not be empty\")\n      .describe(\"OpenAPI path items keyed by URL path.\"),\n    components: JsonObjectSchema.optional().describe(\"Reusable OpenAPI components.\"),\n    servers: z\n      .array(\n        z.object({\n          url: z.string().describe(\"Server base URL.\"),\n        }),\n      )\n      .optional()\n      .describe(\"OpenAPI server definitions.\"),\n  })\n  .describe(\"An OpenAPI document used to define HTTP tools.\");\n\ntype OpenApiDocument = z.infer<typeof OpenApiDocumentSchema>;\ntype OpenApiOperation = z.infer<typeof OpenApiOperationSchema>;\n\n/** HTTP method supported by an {@link OpenApiTool}. */\nexport type OpenApiHttpMethod = (typeof HTTP_METHODS)[number];\n\n/** One executable HTTP operation derived from an OpenAPI document. */\nexport interface OpenApiTool {\n  /** Stable operation identifier. */\n  id: string;\n  /** Model-facing operation description. */\n  description: string;\n  /** Resolved operation URL, or the OpenAPI path for a local document without a server URL. */\n  url: string;\n  /** HTTP method used by the operation. */\n  method: OpenApiHttpMethod;\n  /** JSON Schema describing operation input. */\n  inputSchema: JSONSchema7;\n  /** JSON Schema describing a successful operation result. */\n  outputSchema: JSONSchema7;\n}\n\n/** Request options used while loading an OpenAPI document. */\nexport interface OpenApiToolsOptions {\n  /** Cancels an HTTP request or file read. */\n  signal?: AbortSignal;\n  /** Headers sent when `source` is an HTTP(S) URL. */\n  headers?: RequestInit[\"headers\"];\n}\n\n/** Load an HTTP(S) URL or local file and return its OpenAPI operations as tool schemas. */\nexport async function openApiTools(\n  source: string,\n  options: OpenApiToolsOptions = {},\n): Promise<OpenApiTool[]> {\n  const sourceUrl = httpUrl(source);\n  const document = OpenApiDocumentSchema.parse(\n    sourceUrl\n      ? await fetchDocument(sourceUrl, options)\n      : await readDocument(source, options.signal),\n  );\n  return Object.entries(document.paths).flatMap(([path, item]) =>\n    HTTP_METHODS.flatMap((method) => {\n      const operation = item[method.toLowerCase() as Lowercase<OpenApiHttpMethod>];\n      return operation ? [operationTool(document, sourceUrl, path, method, operation)] : [];\n    }),\n  );\n}\n\nfunction httpUrl(source: string): UrlBuilder | undefined {\n  const url = urlBuilder(source);\n  return url?.scheme === \"http\" || url?.scheme === \"https\" ? url : undefined;\n}\n\nasync function fetchDocument(url: URL, options: OpenApiToolsOptions): Promise<unknown> {\n  const response = await fetch(url, {\n    signal: options.signal,\n    headers: options.headers,\n  });\n  if (!response.ok) {\n    throw new Error(`OpenAPI request failed with HTTP ${response.status}: ${url}`);\n  }\n  return response.json();\n}\n\nasync function readDocument(path: string, signal?: AbortSignal): Promise<unknown> {\n  return JSON.parse(await readFile(path, { encoding: \"utf8\", signal }));\n}\n\nfunction operationTool(\n  document: OpenApiDocument,\n  sourceUrl: URL | undefined,\n  path: string,\n  method: OpenApiHttpMethod,\n  operation: OpenApiOperation,\n): OpenApiTool {\n  const requestSchema = jsonSchema(operation.requestBody?.content) ?? { type: \"object\" };\n  const responseSchema = successfulResponseSchema(operation);\n  return {\n    id: operation.operationId,\n    description:\n      operation.description?.trim() || operation.summary?.trim() || operation.operationId,\n    url: operationUrl(document, sourceUrl, path),\n    method,\n    inputSchema: resolveReferences(document, requestSchema) as JSONSchema7,\n    outputSchema: resolveReferences(document, responseSchema) as JSONSchema7,\n  };\n}\n\nfunction successfulResponseSchema(operation: OpenApiOperation): Record<string, unknown> {\n  for (const [status, response] of Object.entries(operation.responses)) {\n    const schema = jsonSchema(response.content);\n    if (/^2(?:\\d{2}|XX)$/i.test(status) && schema) return schema;\n  }\n  return {};\n}\n\nfunction jsonSchema(\n  content: Record<string, z.infer<typeof OpenApiMediaTypeSchema>> | undefined,\n): Record<string, unknown> | undefined {\n  const mediaType = Object.entries(content ?? {}).find(([type]) =>\n    /^application\\/(?:[^+;]+\\+)?json(?:;|$)/i.test(type),\n  );\n  return mediaType?.[1].schema;\n}\n\nfunction operationUrl(document: OpenApiDocument, sourceUrl: URL | undefined, path: string): string {\n  const server = document.servers?.[0]?.url;\n  if (server) {\n    const base = sourceUrl ? urlBuilder(new URL(server, sourceUrl)) : httpUrl(server);\n    return base\n      ? base.withPathAppend(path).toString()\n      : `${server.replace(/\\/$/, \"\")}/${path.replace(/^\\//, \"\")}`;\n  }\n  return sourceUrl ? urlBuilder(sourceUrl)?.withPathReplace(path).toString() ?? path : path;\n}\n\nfunction resolveReferences(\n  document: OpenApiDocument,\n  value: unknown,\n  active: ReadonlySet<string> = new Set(),\n): unknown {\n  if (Array.isArray(value)) return value.map((item) => resolveReferences(document, item, active));\n  if (!object.isRecord(value)) return value;\n  const reference = typeof value.$ref === \"string\" ? value.$ref : undefined;\n  if (reference) {\n    if (active.has(reference)) throw new Error(`Cyclic OpenAPI reference: ${reference}`);\n    const target = referenceTarget(document, reference);\n    const next = new Set(active).add(reference);\n    const { $ref: _ignored, ...siblings } = value;\n    return {\n      ...(resolveReferences(document, target, next) as Record<string, unknown>),\n      ...(resolveReferences(document, siblings, next) as Record<string, unknown>),\n    };\n  }\n  return Object.fromEntries(\n    Object.entries(value).map(([key, child]) => [key, resolveReferences(document, child, active)]),\n  );\n}\n\nfunction referenceTarget(document: OpenApiDocument, reference: string): unknown {\n  if (!reference.startsWith(\"#/\")) throw new Error(`Unsupported OpenAPI reference: ${reference}`);\n  let current: unknown = document;\n  for (const rawSegment of reference.slice(2).split(\"/\")) {\n    const segment = rawSegment.replaceAll(\"~1\", \"/\").replaceAll(\"~0\", \"~\");\n    if (!object.isRecord(current) || !(segment in current)) {\n      throw new Error(`Unresolved OpenAPI reference: ${reference}`);\n    }\n    current = current[segment];\n  }\n  return current;\n}\n\nif (import.meta.main) {\n  const source = process.argv[2];\n  if (!source) throw new Error(\"Usage: bun openapi-tool.ts <openapi-url-or-file>\");\n  console.log(JSON.stringify(await openApiTools(source), null, 2));\n}\n"]}

package/lib/src/server.js

@@ -13,8 +13,8 @@ import { trace } from "@opentelemetry/api";
 import { attributedUserId, MASTRA_REQUEST_ID_KEY, MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, MASTRA_USER_NAME_KEY, } from "./config.js";
 import { requestUserEmail, requestUserId } from "./identity.js";
 import { resolveFeedbackEnabled } from "./mlflow.js";
+import { extractModelOverride, MASTRA_MODEL_OVERRIDE_KEY, MASTRA_RESOLVED_MODEL_KEY, resolveServingConfig, } from "./serving.js";
 import { recordActiveTraceAuth, recordActiveTraceUser } from "./telemetry.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
@@ -31,6 +31,7 @@ const TRUSTED_REQUEST_CONTEXT_KEYS = [
     MASTRA_REQUEST_ID_KEY,
     MASTRA_SCOPES_KEY,
     MASTRA_MODEL_OVERRIDE_KEY,
+    MASTRA_RESOLVED_MODEL_KEY,
 ];
 /** Remove browser-supplied values for fields owned by trusted server middleware. */
 export function clearTrustedRequestContext(requestContext) {
@@ -389,4 +390,4 @@ export function attachRoutePatchMiddleware(app) {
         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 scoped native API gate.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { hash, http, log, object, stringUtils, 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 ExpressMastraServer } from \"@mastra/express\";\nimport { trace } from \"@opentelemetry/api\";\nimport type express from \"express\";\n\nimport {\n  attributedUserId,\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.ts\";\nimport { requestUserEmail, requestUserId } from \"./identity.ts\";\nimport { resolveFeedbackEnabled } from \"./mlflow.ts\";\nimport { recordActiveTraceAuth, recordActiveTraceUser } from \"./telemetry.ts\";\n\nimport {\n  extractModelOverride,\n  MASTRA_MODEL_OVERRIDE_KEY,\n  resolveServingConfig,\n} from \"./serving.ts\";\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);\nconst TRUSTED_REQUEST_CONTEXT_KEYS = [\n  MASTRA_RESOURCE_ID_KEY,\n  MASTRA_THREAD_ID_KEY,\n  MASTRA_USER_KEY,\n  MASTRA_USER_NAME_KEY,\n  MASTRA_USER_EMAIL_KEY,\n  MASTRA_REQUEST_ID_KEY,\n  MASTRA_SCOPES_KEY,\n  MASTRA_MODEL_OVERRIDE_KEY,\n] as const;\n\n/** Remove browser-supplied values for fields owned by trusted server middleware. */\nexport function clearTrustedRequestContext(requestContext: RequestContext): void {\n  for (const key of TRUSTED_REQUEST_CONTEXT_KEYS) {\n    requestContext.deleteRaw(key);\n  }\n}\n\n/**\n * Who a turn is ATTRIBUTED to, independent of which Databricks credential runs\n * its calls. Supplied by the HTTP middleware from the forwarded user headers so\n * that in `service-principal` mode - where every request shares the app SP's\n * client - the memory thread, per-user cache namespace, and trace metadata\n * still key off the real caller. Ignored in an OBO (user) context, whose own\n * user id / email are authoritative.\n */\nexport interface AttributedIdentity {\n  /** Forwarded `x-forwarded-user` id, used when the client is the service principal. */\n  userId?: string | undefined;\n  /** Forwarded `x-forwarded-email`, used for trace metadata under the service principal. */\n  email?: string | undefined;\n}\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 * The Databricks credential always comes from the ambient execution context;\n * `attributed` only changes WHO the turn is attributed to when that context is\n * the service principal (see {@link AttributedIdentity}).\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(\n  requestContext: RequestContext,\n  attributed: AttributedIdentity = {},\n): Promise<void> {\n  if ([MASTRA_USER_KEY, MASTRA_RESOURCE_ID_KEY].every((key) => requestContext.get(key))) return;\n  const executionContext = getExecutionContext();\n  const isUserContext = \"isUserContext\" in executionContext;\n  // The Databricks CREDENTIAL is always the ambient execution context's client\n  // (OBO in a user context, the service principal otherwise). WHO the turn is\n  // attributed to can differ: in `service-principal` mode every request shares\n  // the SP client, but the forwarded user id must still key the memory thread\n  // and the per-user cache namespace so two callers don't share a conversation.\n  const user: User = {\n    id: attributedUserId(executionContext, attributed.userId),\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. In\n  // `service-principal` mode the forwarded email still identifies the caller,\n  // so it is used for trace metadata even though the client is the SP.\n  let userName: string | undefined;\n  let email: string | undefined = attributed.email;\n  if (isUserContext) {\n    userName = executionContext.userName;\n    email = executionContext.userEmail ?? email;\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 ExpressMastraServer {\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 ExpressMastraServer>\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      clearTrustedRequestContext(requestContext);\n      await this.configureRequestContextUser(req, 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(req: express.Request, requestContext: RequestContext) {\n    // Pass the forwarded caller identity so `service-principal` mode still keys\n    // memory / cache / traces per user even though the client is the app SP.\n    // In an OBO context these are ignored in favor of the context's own user.\n    await stampRequestContextUser(requestContext, {\n      userId: requestUserId(req),\n      email: requestUserEmail(req),\n    });\n    const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;\n    if (user) {\n      recordActiveTraceAuth(\n        \"isUserContext\" in user.executionContext ? \"obo\" : \"service-principal\",\n      );\n    }\n    const traceUser = [\n      requestContext.get(MASTRA_USER_EMAIL_KEY),\n      requestContext.get(MASTRA_USER_NAME_KEY),\n      requestContext.get(MASTRA_RESOURCE_ID_KEY),\n    ].find((value): value is string => typeof value === \"string\" && value.trim().length > 0);\n    recordActiveTraceUser(traceUser);\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    if (res.getHeader(feedback.MLFLOW_TRACE_ID_HEADER)) 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 native memory 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 = stringUtils.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      stringUtils.trimToNull(Array.isArray(headerValue) ? headerValue[0] : headerValue) ??\n      stringUtils.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. Together with\n * the resource-scoped memory mutations below, these are the only stock Mastra\n * writes the browser client can make.\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/** Persisted approval discovery for one agent. */\nconst AGENT_SUSPENDED_RUNS = /^\\/agents\\/[^/]+\\/suspended-runs$/i;\n/** Official AI SDK UI stream route, including `resumeData` continuations. */\nconst AGENT_CHAT = /^\\/chat\\/[^/]+$/i;\n/** Native resource-scoped memory reads used by history and the thread list. */\nconst MEMORY_READ = /^\\/memory\\/threads(?:\\/[^/]+(?:\\/messages)?)?$/i;\n/** Native thread rename/delete routes. */\nconst MEMORY_THREAD_MUTATION = /^\\/memory\\/threads\\/[^/]+$/i;\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 * `/chat/x`, `/memory/threads`, `/mcp/...`). In `\"scoped\"`\n * mode the allowlist is deliberately tight - the chat client only ever\n * needs agent inference, read-only agent metadata, resource-scoped memory,\n * this plugin's own `/route/*` routes, and (when enabled) MCP. The remaining\n * admin, mutating, and bulk-export surface stays denied by default.\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  // The plugin's `/route/*` additions validate their own inputs and trusted\n  // AppKit request context before reaching product behavior.\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_CHAT.test(p)) return true;\n  if (m === \"POST\" && AGENT_INFERENCE.test(p)) return true;\n  if (m === \"GET\" && (AGENT_METADATA.test(p) || AGENT_SUSPENDED_RUNS.test(p))) return true;\n  if (m === \"GET\" && MEMORY_READ.test(p)) return true;\n  if ((m === \"PATCH\" || m === \"DELETE\") && MEMORY_THREAD_MUTATION.test(p)) return true;\n  if (m === \"POST\" && p === \"/memory/messages/delete\") return true;\n  return false;\n}\n\n/**\n * Keep Mastra custom API routes mount-relative when the Express subapp is\n * hosted under AppKit's `/api/<plugin>` path.\n */\nexport function attachRoutePatchMiddleware(app: express.Express): void {\n  app.use((req, _res, next) => {\n    const isCustomRoute =\n      req.path === \"/chat\" ||\n      req.path.startsWith(\"/chat/\") ||\n      req.path === \"/route\" ||\n      req.path.startsWith(\"/route/\");\n    if (!isCustomRoute) return next();\n    req.originalUrl = req.path;\n    next();\n  });\n}\n"]}
+//# 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 scoped native API gate.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { hash, http, log, object, stringUtils, 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 ExpressMastraServer } from \"@mastra/express\";\nimport { trace } from \"@opentelemetry/api\";\nimport type express from \"express\";\n\nimport {\n  attributedUserId,\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.ts\";\nimport { requestUserEmail, requestUserId } from \"./identity.ts\";\nimport { resolveFeedbackEnabled } from \"./mlflow.ts\";\nimport {\n  extractModelOverride,\n  MASTRA_MODEL_OVERRIDE_KEY,\n  MASTRA_RESOLVED_MODEL_KEY,\n  resolveServingConfig,\n} from \"./serving.ts\";\nimport { recordActiveTraceAuth, recordActiveTraceUser } from \"./telemetry.ts\";\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);\nconst TRUSTED_REQUEST_CONTEXT_KEYS = [\n  MASTRA_RESOURCE_ID_KEY,\n  MASTRA_THREAD_ID_KEY,\n  MASTRA_USER_KEY,\n  MASTRA_USER_NAME_KEY,\n  MASTRA_USER_EMAIL_KEY,\n  MASTRA_REQUEST_ID_KEY,\n  MASTRA_SCOPES_KEY,\n  MASTRA_MODEL_OVERRIDE_KEY,\n  MASTRA_RESOLVED_MODEL_KEY,\n] as const;\n\n/** Remove browser-supplied values for fields owned by trusted server middleware. */\nexport function clearTrustedRequestContext(requestContext: RequestContext): void {\n  for (const key of TRUSTED_REQUEST_CONTEXT_KEYS) {\n    requestContext.deleteRaw(key);\n  }\n}\n\n/**\n * Who a turn is ATTRIBUTED to, independent of which Databricks credential runs\n * its calls. Supplied by the HTTP middleware from the forwarded user headers so\n * that in `service-principal` mode - where every request shares the app SP's\n * client - the memory thread, per-user cache namespace, and trace metadata\n * still key off the real caller. Ignored in an OBO (user) context, whose own\n * user id / email are authoritative.\n */\nexport interface AttributedIdentity {\n  /** Forwarded `x-forwarded-user` id, used when the client is the service principal. */\n  userId?: string | undefined;\n  /** Forwarded `x-forwarded-email`, used for trace metadata under the service principal. */\n  email?: string | undefined;\n}\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 * The Databricks credential always comes from the ambient execution context;\n * `attributed` only changes WHO the turn is attributed to when that context is\n * the service principal (see {@link AttributedIdentity}).\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(\n  requestContext: RequestContext,\n  attributed: AttributedIdentity = {},\n): Promise<void> {\n  if ([MASTRA_USER_KEY, MASTRA_RESOURCE_ID_KEY].every((key) => requestContext.get(key))) return;\n  const executionContext = getExecutionContext();\n  const isUserContext = \"isUserContext\" in executionContext;\n  // The Databricks CREDENTIAL is always the ambient execution context's client\n  // (OBO in a user context, the service principal otherwise). WHO the turn is\n  // attributed to can differ: in `service-principal` mode every request shares\n  // the SP client, but the forwarded user id must still key the memory thread\n  // and the per-user cache namespace so two callers don't share a conversation.\n  const user: User = {\n    id: attributedUserId(executionContext, attributed.userId),\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. In\n  // `service-principal` mode the forwarded email still identifies the caller,\n  // so it is used for trace metadata even though the client is the SP.\n  let userName: string | undefined;\n  let email: string | undefined = attributed.email;\n  if (isUserContext) {\n    userName = executionContext.userName;\n    email = executionContext.userEmail ?? email;\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 ExpressMastraServer {\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 ExpressMastraServer>\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      clearTrustedRequestContext(requestContext);\n      await this.configureRequestContextUser(req, 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(req: express.Request, requestContext: RequestContext) {\n    // Pass the forwarded caller identity so `service-principal` mode still keys\n    // memory / cache / traces per user even though the client is the app SP.\n    // In an OBO context these are ignored in favor of the context's own user.\n    await stampRequestContextUser(requestContext, {\n      userId: requestUserId(req),\n      email: requestUserEmail(req),\n    });\n    const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;\n    if (user) {\n      recordActiveTraceAuth(\"isUserContext\" in user.executionContext ? \"obo\" : \"service-principal\");\n    }\n    const traceUser = [\n      requestContext.get(MASTRA_USER_EMAIL_KEY),\n      requestContext.get(MASTRA_USER_NAME_KEY),\n      requestContext.get(MASTRA_RESOURCE_ID_KEY),\n    ].find((value): value is string => typeof value === \"string\" && value.trim().length > 0);\n    recordActiveTraceUser(traceUser);\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    if (res.getHeader(feedback.MLFLOW_TRACE_ID_HEADER)) 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 native memory 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 = stringUtils.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      stringUtils.trimToNull(Array.isArray(headerValue) ? headerValue[0] : headerValue) ??\n      stringUtils.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. Together with\n * the resource-scoped memory mutations below, these are the only stock Mastra\n * writes the browser client can make.\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/** Persisted approval discovery for one agent. */\nconst AGENT_SUSPENDED_RUNS = /^\\/agents\\/[^/]+\\/suspended-runs$/i;\n/** Official AI SDK UI stream route, including `resumeData` continuations. */\nconst AGENT_CHAT = /^\\/chat\\/[^/]+$/i;\n/** Native resource-scoped memory reads used by history and the thread list. */\nconst MEMORY_READ = /^\\/memory\\/threads(?:\\/[^/]+(?:\\/messages)?)?$/i;\n/** Native thread rename/delete routes. */\nconst MEMORY_THREAD_MUTATION = /^\\/memory\\/threads\\/[^/]+$/i;\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 * `/chat/x`, `/memory/threads`, `/mcp/...`). In `\"scoped\"`\n * mode the allowlist is deliberately tight - the chat client only ever\n * needs agent inference, read-only agent metadata, resource-scoped memory,\n * this plugin's own `/route/*` routes, and (when enabled) MCP. The remaining\n * admin, mutating, and bulk-export surface stays denied by default.\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  // The plugin's `/route/*` additions validate their own inputs and trusted\n  // AppKit request context before reaching product behavior.\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_CHAT.test(p)) return true;\n  if (m === \"POST\" && AGENT_INFERENCE.test(p)) return true;\n  if (m === \"GET\" && (AGENT_METADATA.test(p) || AGENT_SUSPENDED_RUNS.test(p))) return true;\n  if (m === \"GET\" && MEMORY_READ.test(p)) return true;\n  if ((m === \"PATCH\" || m === \"DELETE\") && MEMORY_THREAD_MUTATION.test(p)) return true;\n  if (m === \"POST\" && p === \"/memory/messages/delete\") return true;\n  return false;\n}\n\n/**\n * Keep Mastra custom API routes mount-relative when the Express subapp is\n * hosted under AppKit's `/api/<plugin>` path.\n */\nexport function attachRoutePatchMiddleware(app: express.Express): void {\n  app.use((req, _res, next) => {\n    const isCustomRoute =\n      req.path === \"/chat\" ||\n      req.path.startsWith(\"/chat/\") ||\n      req.path === \"/route\" ||\n      req.path.startsWith(\"/route/\");\n    if (!isCustomRoute) return next();\n    req.originalUrl = req.path;\n    next();\n  });\n}\n"]}

package/lib/src/serving.d.ts

@@ -17,6 +17,8 @@ import type { MastraPluginConfig } from "./config.ts";
  * reads it before falling back to the agent / plugin default.
  */
 export declare const MASTRA_MODEL_OVERRIDE_KEY = "mastra__model_override";
+/** RequestContext key carrying the endpoint selected for the active agent step. */
+export declare const MASTRA_RESOLVED_MODEL_KEY = "mastra__resolved_model";
 /**
  * Minimal Express-ish request shape used by {@link extractModelOverride}.
  * Keeps this module independent of `express` so the helper can be

package/lib/src/serving.js

@@ -19,6 +19,8 @@ import { override } from "@dbx-tools/shared-mastra";
  * reads it before falling back to the agent / plugin default.
  */
 export const MASTRA_MODEL_OVERRIDE_KEY = "mastra__model_override";
+/** RequestContext key carrying the endpoint selected for the active agent step. */
+export const MASTRA_RESOLVED_MODEL_KEY = "mastra__resolved_model";
 /**
  * Pull a model override out of a single HTTP request, checking
  * sources in priority order:
@@ -75,4 +77,4 @@ export function resolveServingConfig(config) {
         fallbacks: config.defaultModelFallbacks ?? [],
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/telemetry.d.ts

@@ -19,7 +19,7 @@
  */
 import { type Span } from "@opentelemetry/api";
 import type express from "express";
-export { MLFLOW_AGENT_TAG, MLFLOW_AGENT_TAG_ATTR, MLFLOW_GENIE_TAG, MLFLOW_GENIE_TAG_ATTR, MLFLOW_MODEL_TAG, MLFLOW_MODEL_TAG_ATTR, MLFLOW_LOCAL_TAG, MLFLOW_LOCAL_TAG_ATTR, MLFLOW_OBO_AUTH_TAG, MLFLOW_OBO_AUTH_TAG_ATTR, MLFLOW_SP_AUTH_TAG, MLFLOW_SP_AUTH_TAG_ATTR, MLFLOW_TRACE_TAG_PREFIX, } from "./trace-attributes.ts";
+export { MLFLOW_AGENT_TAG, MLFLOW_AGENT_TAG_ATTR, APPKIT_AGENT_TRACE_ROOT_ATTR, MLFLOW_GENIE_TAG, MLFLOW_GENIE_TAG_ATTR, MLFLOW_LOCAL_TAG, MLFLOW_LOCAL_TAG_ATTR, MLFLOW_OBO_AUTH_TAG, MLFLOW_OBO_AUTH_TAG_ATTR, MLFLOW_SP_AUTH_TAG, MLFLOW_SP_AUTH_TAG_ATTR, MLFLOW_TRACE_TAG_PREFIX, } from "./trace-attributes.ts";
 /** Cap on each payload copied onto a span, so one turn cannot bloat the export. */
 export declare const TRACE_IO_LIMIT = 8000;
 /** Attribute keys the MLflow UC `*_trace_unified` view reads from the root span. */
@@ -70,14 +70,12 @@ export declare function stampGenieToolSpan(span?: Span | undefined): void;
 export declare function recordActiveTraceTag(name: string, value?: ChatTraceTagValue): void;
 /** Inject multiple MLflow trace tags into the active chat request. */
 export declare function recordActiveTraceTags(tags: Readonly<Record<string, ChatTraceTagValue | undefined>>): void;
-/** Record a selected model on the active chat trace, preserving first-use order. */
+/** Record the first selected model as the active chat trace's `agent` tag. */
 export declare function recordActiveTraceModel(modelId: string): void;
 /** Record the best resolved user identifier on the active chat trace. */
 export declare function recordActiveTraceUser(user: string | undefined): void;
 /** Record one Databricks authentication mode used during the active chat trace. */
 export declare function recordActiveTraceAuth(auth: "obo" | "service-principal"): void;
-/** Serialize model tags as a scalar or an ordered JSON array for multiple values. */
-export declare function modelTraceTag(models: Iterable<string>): string | undefined;
 /** Return one raw prompt when the request is exactly one text-only user message. */
 export declare function textOnlyChatInput(messages: unknown): string | undefined;
 /**