@dbx-tools/appkit-mastra 0.3.44 → 0.4.1

package/lib/src/history.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Thread history loader exposed as a Mastra custom API route.
+ *
+ * Backed entirely by native Mastra: looks up the active agent by id,
+ * asks its `Memory` instance to `recall` a page of `MastraDBMessage`s,
+ * and converts the result to AI SDK V5 `UIMessage`s with the official
+ * {@link toAISdkV5Messages} helper from `@mastra/ai-sdk/ui`. No direct
+ * database reads.
+ *
+ * The route is registered through {@link historyRoute} as a Mastra
+ * `registerApiRoute` so it sits in the same dispatcher pipeline as
+ * the standard agent routes. That means the `MastraServer` auth
+ * middleware (in `./server.ts`) has already populated `RequestContext` with
+ * `MASTRA_THREAD_ID_KEY` and `MASTRA_RESOURCE_ID_KEY` by the time
+ * the handler runs - no cookie or user lookups happen here, and the
+ * session-cookie logic stays the single source of truth in `server.ts`.
+ *
+ * @module
+ */
+import type { MastraHistoryResponse } from "@dbx-tools/shared-mastra";
+import type { Agent } from "@mastra/core/agent";
+/** Inputs accepted by {@link loadHistory}. */
+export interface LoadHistoryOptions {
+    agent: Agent;
+    threadId: string;
+    resourceId?: string;
+    page?: number;
+    perPage?: number;
+    /** When true, returns the *oldest* page first (chronological). */
+    ascending?: boolean;
+}
+/**
+ * Fetch a page of UI-formatted messages for a thread.
+ *
+ * Uses the agent's resolved `Memory` (`getMemory()`) so per-agent
+ * storage namespaces (`mastra_<agentId>` schemas) and any future
+ * memory-side filters apply automatically. When the agent has no
+ * memory configured the response is a successful empty page so
+ * callers don't have to special-case stateless agents.
+ *
+ * Pagination is descending-by-default: page 0 is the most recent
+ * page, page 1 the page before that, etc. The returned `uiMessages`
+ * are always re-sorted into chronological order (oldest -> newest)
+ * so the client can prepend them above the existing transcript
+ * without sorting locally.
+ */
+export declare function loadHistory(opts: LoadHistoryOptions): Promise<MastraHistoryResponse>;
+/** Inputs accepted by {@link clearHistory}. */
+export interface ClearHistoryOptions {
+    agent: Agent;
+    threadId: string;
+}
+/**
+ * Wipe every persisted message tied to a thread. Returns the count
+ * of messages that were on the thread at delete time so the caller
+ * can render a "cleared N messages" affordance without an
+ * additional round-trip.
+ *
+ * Agents without a configured `Memory` resolve to a no-op (count
+ * 0), matching {@link loadHistory}'s "stateless agents return an
+ * empty page" stance so callers don't have to special-case them.
+ * Threads that don't exist yet are also a successful no-op - the
+ * operation is idempotent so the UI can fire-and-forget without
+ * tracking thread existence.
+ */
+export declare function clearHistory(opts: ClearHistoryOptions): Promise<{
+    cleared: number;
+}>;
+/** Options accepted by {@link historyRoute}. */
+export type HistoryRouteOptions = {
+    path: `${string}:agentId${string}`;
+    agent?: never;
+} | {
+    path: string;
+    agent: string;
+};
+/**
+ * Register the `<path>` Mastra custom API route. Handles two
+ * methods on the same mount:
+ *
+ *   - `GET`: return a page of AI SDK V5 `UIMessage`s for the
+ *     caller's current thread ({@link loadHistory}).
+ *   - `DELETE`: wipe every persisted message on the caller's
+ *     thread ({@link clearHistory}). The session cookie that
+ *     anchors the thread id is left alone so the user keeps the
+ *     same thread - only the contents go away.
+ *
+ * Follows the `@mastra/ai-sdk` `chatRoute` convention for agent
+ * binding: pass `agent` for a fixed-agent mount, or include
+ * `:agentId` in the path for dynamic routing. The plugin registers
+ * both `/route/history` (default agent) and `/route/history/:agentId`.
+ *
+ * The handler reads `threadId` and `resourceId` from `RequestContext`
+ * (populated upstream by `MastraServer.registerAuthMiddleware`), so
+ * no cookie or user lookups happen here.
+ */
+export declare function historyRoute(options: HistoryRouteOptions): import("@mastra/core/server").ApiRoute[];

package/lib/src/history.js

@@ -0,0 +1,264 @@
+/**
+ * Thread history loader exposed as a Mastra custom API route.
+ *
+ * Backed entirely by native Mastra: looks up the active agent by id,
+ * asks its `Memory` instance to `recall` a page of `MastraDBMessage`s,
+ * and converts the result to AI SDK V5 `UIMessage`s with the official
+ * {@link toAISdkV5Messages} helper from `@mastra/ai-sdk/ui`. No direct
+ * database reads.
+ *
+ * The route is registered through {@link historyRoute} as a Mastra
+ * `registerApiRoute` so it sits in the same dispatcher pipeline as
+ * the standard agent routes. That means the `MastraServer` auth
+ * middleware (in `./server.ts`) has already populated `RequestContext` with
+ * `MASTRA_THREAD_ID_KEY` and `MASTRA_RESOURCE_ID_KEY` by the time
+ * the handler runs - no cookie or user lookups happen here, and the
+ * session-cookie logic stays the single source of truth in `server.ts`.
+ *
+ * @module
+ */
+import { ValidationError } from "@databricks/appkit";
+import { error, log } from "@dbx-tools/shared-core";
+import { toAISdkV5Messages } from "@mastra/ai-sdk/ui";
+import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
+import { registerApiRoute } from "@mastra/core/server";
+import { clampPerPage, parseIntParam } from "./pagination.js";
+const logger = log.logger("mastra/history");
+/** Default history page size; matches the Mastra storage default. */
+const DEFAULT_PER_PAGE = 20;
+/** Hard cap so a misbehaving client can't fetch the whole thread at once. */
+const MAX_PER_PAGE = 200;
+/**
+ * Fetch a page of UI-formatted messages for a thread.
+ *
+ * Uses the agent's resolved `Memory` (`getMemory()`) so per-agent
+ * storage namespaces (`mastra_<agentId>` schemas) and any future
+ * memory-side filters apply automatically. When the agent has no
+ * memory configured the response is a successful empty page so
+ * callers don't have to special-case stateless agents.
+ *
+ * Pagination is descending-by-default: page 0 is the most recent
+ * page, page 1 the page before that, etc. The returned `uiMessages`
+ * are always re-sorted into chronological order (oldest -> newest)
+ * so the client can prepend them above the existing transcript
+ * without sorting locally.
+ */
+export async function loadHistory(opts) {
+    const perPage = clampPerPage(opts.perPage, {
+        fallback: DEFAULT_PER_PAGE,
+        max: MAX_PER_PAGE,
+    });
+    const page = Math.max(0, Math.trunc(opts.page ?? 0));
+    const memory = await opts.agent.getMemory();
+    if (!memory) {
+        logger.debug("recall:no-memory", { agentId: opts.agent.id, threadId: opts.threadId });
+        return { uiMessages: [], page, perPage, total: 0, hasMore: false };
+    }
+    const startedAt = Date.now();
+    const result = await memory.recall({
+        threadId: opts.threadId,
+        ...(opts.resourceId ? { resourceId: opts.resourceId } : {}),
+        page,
+        perPage,
+        orderBy: {
+            field: "createdAt",
+            direction: opts.ascending ? "ASC" : "DESC",
+        },
+    });
+    const chronological = sortChronological(result.messages);
+    const uiMessages = toAISdkV5Messages(chronological);
+    logger.debug("recall:done", {
+        agentId: opts.agent.id,
+        threadId: opts.threadId,
+        page,
+        perPage,
+        returned: uiMessages.length,
+        total: result.total,
+        hasMore: result.hasMore,
+        elapsedMs: Date.now() - startedAt,
+    });
+    return {
+        uiMessages,
+        page,
+        perPage,
+        total: result.total,
+        hasMore: result.hasMore,
+    };
+}
+/**
+ * Wipe every persisted message tied to a thread. Returns the count
+ * of messages that were on the thread at delete time so the caller
+ * can render a "cleared N messages" affordance without an
+ * additional round-trip.
+ *
+ * Agents without a configured `Memory` resolve to a no-op (count
+ * 0), matching {@link loadHistory}'s "stateless agents return an
+ * empty page" stance so callers don't have to special-case them.
+ * Threads that don't exist yet are also a successful no-op - the
+ * operation is idempotent so the UI can fire-and-forget without
+ * tracking thread existence.
+ */
+export async function clearHistory(opts) {
+    const memory = await opts.agent.getMemory();
+    if (!memory) {
+        logger.debug("clear:no-memory", { agentId: opts.agent.id, threadId: opts.threadId });
+        return { cleared: 0 };
+    }
+    // Mastra's `deleteThread` cascades to the message table, so we
+    // can't ask for a count after the fact. Read it pre-delete with a
+    // one-page recall sized to fit common threads in a single round
+    // trip; the value is for telemetry / UI, not correctness.
+    let cleared = 0;
+    try {
+        const probe = await memory.recall({
+            threadId: opts.threadId,
+            page: 0,
+            perPage: 1,
+        });
+        cleared = probe.total;
+    }
+    catch (err) {
+        // A missing-thread error is the happy-path "nothing to count";
+        // every other error is logged but doesn't block the delete.
+        logger.debug("clear:probe-failed", {
+            agentId: opts.agent.id,
+            threadId: opts.threadId,
+            error: error.errorMessage(err),
+        });
+    }
+    const startedAt = Date.now();
+    try {
+        await memory.deleteThread(opts.threadId);
+    }
+    catch (err) {
+        // Mastra's `deleteThread` raises when the thread row was never
+        // created (e.g. clearing an empty session). Surface as a soft
+        // warn and treat as success - the user-facing semantic is
+        // "history is now empty" which is already true.
+        logger.warn("clear:delete-soft-failed", {
+            agentId: opts.agent.id,
+            threadId: opts.threadId,
+            error: error.errorMessage(err),
+        });
+    }
+    logger.info("clear:done", {
+        agentId: opts.agent.id,
+        threadId: opts.threadId,
+        cleared,
+        elapsedMs: Date.now() - startedAt,
+    });
+    return { cleared };
+}
+/**
+ * Register the `<path>` Mastra custom API route. Handles two
+ * methods on the same mount:
+ *
+ *   - `GET`: return a page of AI SDK V5 `UIMessage`s for the
+ *     caller's current thread ({@link loadHistory}).
+ *   - `DELETE`: wipe every persisted message on the caller's
+ *     thread ({@link clearHistory}). The session cookie that
+ *     anchors the thread id is left alone so the user keeps the
+ *     same thread - only the contents go away.
+ *
+ * Follows the `@mastra/ai-sdk` `chatRoute` convention for agent
+ * binding: pass `agent` for a fixed-agent mount, or include
+ * `:agentId` in the path for dynamic routing. The plugin registers
+ * both `/route/history` (default agent) and `/route/history/:agentId`.
+ *
+ * The handler reads `threadId` and `resourceId` from `RequestContext`
+ * (populated upstream by `MastraServer.registerAuthMiddleware`), so
+ * no cookie or user lookups happen here.
+ */
+export function historyRoute(options) {
+    const { path } = options;
+    const fixedAgent = "agent" in options ? options.agent : undefined;
+    if (!fixedAgent && !path.includes(":agentId")) {
+        throw ValidationError.invalidValue("historyRoute.path", path, "a path containing `:agentId`, or an explicit `agent`");
+    }
+    // Tiny resolver shared by GET / DELETE: derive the active agent
+    // and thread id, returning a JSON error response when either is
+    // missing. Keeps both handlers thin and gives them identical
+    // validation behaviour.
+    const resolveContext = (c) => {
+        const mastra = c.get("mastra");
+        const requestContext = c.get("requestContext");
+        const agentId = fixedAgent ?? c.req.param("agentId");
+        if (!agentId) {
+            return { error: c.json({ error: "agentId is required" }, 400) };
+        }
+        const agent = mastra.getAgentById(agentId);
+        if (!agent) {
+            return {
+                error: c.json({ error: `Unknown agent "${agentId}"` }, 404),
+            };
+        }
+        const threadId = requestContext.get(MASTRA_THREAD_ID_KEY);
+        if (!threadId) {
+            return {
+                error: c.json({ error: "thread id missing from request context" }, 400),
+            };
+        }
+        const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY);
+        return { agentId, agent, threadId, resourceId };
+    };
+    return [
+        registerApiRoute(path, {
+            method: "GET",
+            handler: async (c) => {
+                const ctx = resolveContext(c);
+                if ("error" in ctx)
+                    return ctx.error;
+                const payload = await loadHistory({
+                    agent: ctx.agent,
+                    threadId: ctx.threadId,
+                    ...(ctx.resourceId ? { resourceId: ctx.resourceId } : {}),
+                    page: parseIntParam(c.req.query("page")),
+                    perPage: parseIntParam(c.req.query("perPage")),
+                });
+                return c.json(payload);
+            },
+        }),
+        registerApiRoute(path, {
+            method: "DELETE",
+            handler: async (c) => {
+                const ctx = resolveContext(c);
+                if ("error" in ctx)
+                    return ctx.error;
+                const { cleared } = await clearHistory({
+                    agent: ctx.agent,
+                    threadId: ctx.threadId,
+                });
+                const payload = {
+                    ok: true,
+                    agentId: ctx.agentId,
+                    threadId: ctx.threadId,
+                    cleared,
+                };
+                return c.json(payload);
+            },
+        }),
+    ];
+}
+/**
+ * Sort messages oldest-first by `createdAt`, falling back to whatever
+ * order the storage returned them in. The native `recall` call honors
+ * `orderBy` but doesn't guarantee a stable secondary sort, so we
+ * normalize here before handing the page to the AI SDK converter.
+ */
+function sortChronological(messages) {
+    return [...messages].sort((a, b) => {
+        const ta = toEpoch(a.createdAt);
+        const tb = toEpoch(b.createdAt);
+        return ta - tb;
+    });
+}
+function toEpoch(value) {
+    if (value instanceof Date)
+        return value.getTime();
+    if (typeof value === "string" || typeof value === "number") {
+        const parsed = new Date(value).getTime();
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"history.js","sourceRoot":"","sources":["../../src/history.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Thread history loader exposed as a Mastra custom API route.\n *\n * Backed entirely by native Mastra: looks up the active agent by id,\n * asks its `Memory` instance to `recall` a page of `MastraDBMessage`s,\n * and converts the result to AI SDK V5 `UIMessage`s with the official\n * {@link toAISdkV5Messages} helper from `@mastra/ai-sdk/ui`. No direct\n * database reads.\n *\n * The route is registered through {@link historyRoute} as a Mastra\n * `registerApiRoute` so it sits in the same dispatcher pipeline as\n * the standard agent routes. That means the `MastraServer` auth\n * middleware (in `./server.ts`) has already populated `RequestContext` with\n * `MASTRA_THREAD_ID_KEY` and `MASTRA_RESOURCE_ID_KEY` by the time\n * the handler runs - no cookie or user lookups happen here, and the\n * session-cookie logic stays the single source of truth in `server.ts`.\n *\n * @module\n */\n\nimport { ValidationError } from \"@databricks/appkit\";\nimport { error, log } from \"@dbx-tools/shared-core\";\nimport type {\n  MastraClearHistoryResponse,\n  MastraHistoryResponse,\n  MastraHistoryUIMessage,\n} from \"@dbx-tools/shared-mastra\";\nimport { toAISdkV5Messages } from \"@mastra/ai-sdk/ui\";\nimport type { Agent } from \"@mastra/core/agent\";\nimport type { MastraDBMessage } from \"@mastra/core/agent/message-list\";\nimport { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from \"@mastra/core/request-context\";\nimport type { ContextWithMastra } from \"@mastra/core/server\";\nimport { registerApiRoute } from \"@mastra/core/server\";\n\nimport { clampPerPage, parseIntParam } from \"./pagination\";\n\nconst logger = log.logger(\"mastra/history\");\n\n/** Default history page size; matches the Mastra storage default. */\nconst DEFAULT_PER_PAGE = 20;\n/** Hard cap so a misbehaving client can't fetch the whole thread at once. */\nconst MAX_PER_PAGE = 200;\n\n/** Inputs accepted by {@link loadHistory}. */\nexport interface LoadHistoryOptions {\n  agent: Agent;\n  threadId: string;\n  resourceId?: string;\n  page?: number;\n  perPage?: number;\n  /** When true, returns the *oldest* page first (chronological). */\n  ascending?: boolean;\n}\n\n/**\n * Fetch a page of UI-formatted messages for a thread.\n *\n * Uses the agent's resolved `Memory` (`getMemory()`) so per-agent\n * storage namespaces (`mastra_<agentId>` schemas) and any future\n * memory-side filters apply automatically. When the agent has no\n * memory configured the response is a successful empty page so\n * callers don't have to special-case stateless agents.\n *\n * Pagination is descending-by-default: page 0 is the most recent\n * page, page 1 the page before that, etc. The returned `uiMessages`\n * are always re-sorted into chronological order (oldest -> newest)\n * so the client can prepend them above the existing transcript\n * without sorting locally.\n */\nexport async function loadHistory(opts: LoadHistoryOptions): Promise<MastraHistoryResponse> {\n  const perPage = clampPerPage(opts.perPage, {\n    fallback: DEFAULT_PER_PAGE,\n    max: MAX_PER_PAGE,\n  });\n  const page = Math.max(0, Math.trunc(opts.page ?? 0));\n  const memory = await opts.agent.getMemory();\n  if (!memory) {\n    logger.debug(\"recall:no-memory\", { agentId: opts.agent.id, threadId: opts.threadId });\n    return { uiMessages: [], page, perPage, total: 0, hasMore: false };\n  }\n  const startedAt = Date.now();\n  const result = await memory.recall({\n    threadId: opts.threadId,\n    ...(opts.resourceId ? { resourceId: opts.resourceId } : {}),\n    page,\n    perPage,\n    orderBy: {\n      field: \"createdAt\",\n      direction: opts.ascending ? \"ASC\" : \"DESC\",\n    },\n  });\n  const chronological = sortChronological(result.messages);\n  const uiMessages = toAISdkV5Messages(chronological) as unknown as MastraHistoryUIMessage[];\n  logger.debug(\"recall:done\", {\n    agentId: opts.agent.id,\n    threadId: opts.threadId,\n    page,\n    perPage,\n    returned: uiMessages.length,\n    total: result.total,\n    hasMore: result.hasMore,\n    elapsedMs: Date.now() - startedAt,\n  });\n  return {\n    uiMessages,\n    page,\n    perPage,\n    total: result.total,\n    hasMore: result.hasMore,\n  };\n}\n\n/** Inputs accepted by {@link clearHistory}. */\nexport interface ClearHistoryOptions {\n  agent: Agent;\n  threadId: string;\n}\n\n/**\n * Wipe every persisted message tied to a thread. Returns the count\n * of messages that were on the thread at delete time so the caller\n * can render a \"cleared N messages\" affordance without an\n * additional round-trip.\n *\n * Agents without a configured `Memory` resolve to a no-op (count\n * 0), matching {@link loadHistory}'s \"stateless agents return an\n * empty page\" stance so callers don't have to special-case them.\n * Threads that don't exist yet are also a successful no-op - the\n * operation is idempotent so the UI can fire-and-forget without\n * tracking thread existence.\n */\nexport async function clearHistory(opts: ClearHistoryOptions): Promise<{ cleared: number }> {\n  const memory = await opts.agent.getMemory();\n  if (!memory) {\n    logger.debug(\"clear:no-memory\", { agentId: opts.agent.id, threadId: opts.threadId });\n    return { cleared: 0 };\n  }\n  // Mastra's `deleteThread` cascades to the message table, so we\n  // can't ask for a count after the fact. Read it pre-delete with a\n  // one-page recall sized to fit common threads in a single round\n  // trip; the value is for telemetry / UI, not correctness.\n  let cleared = 0;\n  try {\n    const probe = await memory.recall({\n      threadId: opts.threadId,\n      page: 0,\n      perPage: 1,\n    });\n    cleared = probe.total;\n  } catch (err) {\n    // A missing-thread error is the happy-path \"nothing to count\";\n    // every other error is logged but doesn't block the delete.\n    logger.debug(\"clear:probe-failed\", {\n      agentId: opts.agent.id,\n      threadId: opts.threadId,\n      error: error.errorMessage(err),\n    });\n  }\n\n  const startedAt = Date.now();\n  try {\n    await memory.deleteThread(opts.threadId);\n  } catch (err) {\n    // Mastra's `deleteThread` raises when the thread row was never\n    // created (e.g. clearing an empty session). Surface as a soft\n    // warn and treat as success - the user-facing semantic is\n    // \"history is now empty\" which is already true.\n    logger.warn(\"clear:delete-soft-failed\", {\n      agentId: opts.agent.id,\n      threadId: opts.threadId,\n      error: error.errorMessage(err),\n    });\n  }\n  logger.info(\"clear:done\", {\n    agentId: opts.agent.id,\n    threadId: opts.threadId,\n    cleared,\n    elapsedMs: Date.now() - startedAt,\n  });\n  return { cleared };\n}\n\n/** Options accepted by {@link historyRoute}. */\nexport type HistoryRouteOptions =\n  { path: `${string}:agentId${string}`; agent?: never } | { path: string; agent: string };\n\n/**\n * Register the `<path>` Mastra custom API route. Handles two\n * methods on the same mount:\n *\n *   - `GET`: return a page of AI SDK V5 `UIMessage`s for the\n *     caller's current thread ({@link loadHistory}).\n *   - `DELETE`: wipe every persisted message on the caller's\n *     thread ({@link clearHistory}). The session cookie that\n *     anchors the thread id is left alone so the user keeps the\n *     same thread - only the contents go away.\n *\n * Follows the `@mastra/ai-sdk` `chatRoute` convention for agent\n * binding: pass `agent` for a fixed-agent mount, or include\n * `:agentId` in the path for dynamic routing. The plugin registers\n * both `/route/history` (default agent) and `/route/history/:agentId`.\n *\n * The handler reads `threadId` and `resourceId` from `RequestContext`\n * (populated upstream by `MastraServer.registerAuthMiddleware`), so\n * no cookie or user lookups happen here.\n */\nexport function historyRoute(options: HistoryRouteOptions) {\n  const { path } = options;\n  const fixedAgent = \"agent\" in options ? options.agent : undefined;\n  if (!fixedAgent && !path.includes(\":agentId\")) {\n    throw ValidationError.invalidValue(\n      \"historyRoute.path\",\n      path,\n      \"a path containing `:agentId`, or an explicit `agent`\",\n    );\n  }\n  // Tiny resolver shared by GET / DELETE: derive the active agent\n  // and thread id, returning a JSON error response when either is\n  // missing. Keeps both handlers thin and gives them identical\n  // validation behaviour.\n  const resolveContext = (c: ContextWithMastra) => {\n    const mastra = c.get(\"mastra\");\n    const requestContext = c.get(\"requestContext\");\n    const agentId = fixedAgent ?? c.req.param(\"agentId\");\n    if (!agentId) {\n      return { error: c.json({ error: \"agentId is required\" }, 400) } as const;\n    }\n    const agent = mastra.getAgentById(agentId);\n    if (!agent) {\n      return {\n        error: c.json({ error: `Unknown agent \"${agentId}\"` }, 404),\n      } as const;\n    }\n    const threadId = requestContext.get(MASTRA_THREAD_ID_KEY) as string | undefined;\n    if (!threadId) {\n      return {\n        error: c.json({ error: \"thread id missing from request context\" }, 400),\n      } as const;\n    }\n    const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY) as string | undefined;\n    return { agentId, agent, threadId, resourceId } as const;\n  };\n\n  return [\n    registerApiRoute(path, {\n      method: \"GET\",\n      handler: async (c: ContextWithMastra) => {\n        const ctx = resolveContext(c);\n        if (\"error\" in ctx) return ctx.error;\n        const payload = await loadHistory({\n          agent: ctx.agent,\n          threadId: ctx.threadId,\n          ...(ctx.resourceId ? { resourceId: ctx.resourceId } : {}),\n          page: parseIntParam(c.req.query(\"page\")),\n          perPage: parseIntParam(c.req.query(\"perPage\")),\n        });\n        return c.json(payload);\n      },\n    }),\n    registerApiRoute(path, {\n      method: \"DELETE\",\n      handler: async (c: ContextWithMastra) => {\n        const ctx = resolveContext(c);\n        if (\"error\" in ctx) return ctx.error;\n        const { cleared } = await clearHistory({\n          agent: ctx.agent,\n          threadId: ctx.threadId,\n        });\n        const payload: MastraClearHistoryResponse = {\n          ok: true,\n          agentId: ctx.agentId,\n          threadId: ctx.threadId,\n          cleared,\n        };\n        return c.json(payload);\n      },\n    }),\n  ];\n}\n\n/**\n * Sort messages oldest-first by `createdAt`, falling back to whatever\n * order the storage returned them in. The native `recall` call honors\n * `orderBy` but doesn't guarantee a stable secondary sort, so we\n * normalize here before handing the page to the AI SDK converter.\n */\nfunction sortChronological(messages: MastraDBMessage[]): MastraDBMessage[] {\n  return [...messages].sort((a, b) => {\n    const ta = toEpoch(a.createdAt);\n    const tb = toEpoch(b.createdAt);\n    return ta - tb;\n  });\n}\n\nfunction toEpoch(value: unknown): number {\n  if (value instanceof Date) return value.getTime();\n  if (typeof value === \"string\" || typeof value === \"number\") {\n    const parsed = new Date(value).getTime();\n    return Number.isNaN(parsed) ? 0 : parsed;\n  }\n  return 0;\n}\n"]}

package/lib/src/mcp.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Optional Mastra MCP server exposure for the AppKit Mastra plugin.
+ *
+ * Turns the plugin's registered agents (and, opt-in, its ambient tools)
+ * into a Mastra `MCPServer` so external MCP clients - Claude Desktop,
+ * Cursor, the Mastra playground, or another agent - can call them over
+ * the standard MCP transports. The resulting server is handed to the
+ * `Mastra` instance via `mcpServers`, which makes `@mastra/express`
+ * serve the stock MCP routes under the plugin's base path; the plugin
+ * never registers a bespoke MCP route of its own.
+ *
+ * @module
+ */
+import type { Agent } from "@mastra/core/agent";
+import { MCPServer } from "@mastra/mcp";
+import type { MastraTools } from "./agents.js";
+import type { MastraPluginConfig } from "./config.js";
+/**
+ * A built MCP server plus the request paths it answers on, relative to
+ * the plugin's base path (`/api/<plugin>`).
+ *
+ * The paths are the **clean public aliases** (`/mcp`, `/sse`,
+ * `/messages`) the plugin exposes. `@mastra/express` actually mounts the
+ * transports under `/mcp/<serverId>/<transport>` off the `Mastra`
+ * instance's `mcpServers`; the plugin rewrites the alias to that route
+ * before dispatch (see {@link ResolvedMcp.serverId}), so a client never
+ * sees the doubled `/mcp/<serverId>/mcp` segment.
+ */
+export interface ResolvedMcp {
+    /**
+     * Registry id, used in the underlying `@mastra/express` route
+     * (`/mcp/<serverId>/...`) the plugin rewrites the clean alias to.
+     */
+    serverId: string;
+    /** The Mastra MCP server to hand to `new Mastra({ mcpServers })`. */
+    server: MCPServer;
+    /** Streamable-HTTP transport path, relative to the plugin base path. */
+    httpPath: string;
+    /** SSE transport path, relative to the plugin base path. */
+    ssePath: string;
+    /** SSE message path, relative to the plugin base path. */
+    messagePath: string;
+}
+/**
+ * Build the plugin's MCP server, or `null` only when `config.mcp` is
+ * explicitly `false`.
+ *
+ * Agent exposure is on by default because it's cheap: the already-
+ * registered agents are wrapped as `ask_<agentId>` tools and handed to
+ * `@mastra/express` (already mounted for the chat routes) - no extra
+ * process, dependency, or network cost, and requests run under the same
+ * OBO scope. So `undefined` (the default) and `true` both expose every
+ * registered agent under a server id equal to the plugin name; only
+ * `false` turns MCP off. The object form ({@link MastraMcpConfig}) tunes
+ * the id / advertised metadata and can additionally expose the plugin's
+ * ambient tools or a set of extra MCP-only tools. Ambient tools stay off
+ * unless explicitly enabled - they assume an in-process chat turn, so
+ * they aren't cheap / safe to expose to a standalone MCP client.
+ */
+export declare function buildMcpServer(opts: {
+    config: MastraPluginConfig;
+    pluginName: string;
+    displayName: string;
+    agents: Record<string, Agent>;
+    ambientTools: MastraTools;
+}): ResolvedMcp | null;

package/lib/src/mcp.js

@@ -0,0 +1,65 @@
+/**
+ * Optional Mastra MCP server exposure for the AppKit Mastra plugin.
+ *
+ * Turns the plugin's registered agents (and, opt-in, its ambient tools)
+ * into a Mastra `MCPServer` so external MCP clients - Claude Desktop,
+ * Cursor, the Mastra playground, or another agent - can call them over
+ * the standard MCP transports. The resulting server is handed to the
+ * `Mastra` instance via `mcpServers`, which makes `@mastra/express`
+ * serve the stock MCP routes under the plugin's base path; the plugin
+ * never registers a bespoke MCP route of its own.
+ *
+ * @module
+ */
+import { MCPServer } from "@mastra/mcp";
+/** MCP server version advertised when the caller doesn't pin one. */
+const DEFAULT_MCP_VERSION = "1.0.0";
+/**
+ * Build the plugin's MCP server, or `null` only when `config.mcp` is
+ * explicitly `false`.
+ *
+ * Agent exposure is on by default because it's cheap: the already-
+ * registered agents are wrapped as `ask_<agentId>` tools and handed to
+ * `@mastra/express` (already mounted for the chat routes) - no extra
+ * process, dependency, or network cost, and requests run under the same
+ * OBO scope. So `undefined` (the default) and `true` both expose every
+ * registered agent under a server id equal to the plugin name; only
+ * `false` turns MCP off. The object form ({@link MastraMcpConfig}) tunes
+ * the id / advertised metadata and can additionally expose the plugin's
+ * ambient tools or a set of extra MCP-only tools. Ambient tools stay off
+ * unless explicitly enabled - they assume an in-process chat turn, so
+ * they aren't cheap / safe to expose to a standalone MCP client.
+ */
+export function buildMcpServer(opts) {
+    const { config, pluginName, displayName, agents, ambientTools } = opts;
+    if (config.mcp === false)
+        return null;
+    const settings = typeof config.mcp === "object" ? config.mcp : {};
+    const serverId = settings.serverId ?? pluginName;
+    const exposeAgents = settings.agents !== false;
+    const exposeTools = settings.tools === true;
+    // MCPServerConfig.tools is required, so always pass a record (empty
+    // when the caller exposes only agents).
+    const tools = {
+        ...(exposeTools ? ambientTools : {}),
+        ...(settings.extraTools ?? {}),
+    };
+    const server = new MCPServer({
+        id: serverId,
+        name: settings.name ?? `${displayName} MCP`,
+        version: settings.version ?? DEFAULT_MCP_VERSION,
+        ...(settings.description ? { description: settings.description } : {}),
+        ...(exposeAgents ? { agents } : {}),
+        tools,
+    });
+    // Advertise the clean aliases; the plugin rewrites these to the stock
+    // `/mcp/<serverId>/<transport>` routes `@mastra/express` mounts.
+    return {
+        serverId,
+        server,
+        httpPath: "/mcp",
+        ssePath: "/sse",
+        messagePath: "/messages",
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/memory.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Lakebase-backed Mastra memory wiring.
+ *
+ * Provides a {@link MemoryBuilder} that mints one `Memory` per agent
+ * with two independent knobs:
+ *
+ * - **Storage** (threads / messages via `PostgresStore`): defaults to
+ *   **per-agent** namespacing via {@link agentStorageSchemaName} so
+ *   conversation history stays isolated between agents in the same
+ *   database. `PostgresStore` auto-creates the schema with
+ *   `CREATE SCHEMA IF NOT EXISTS` on init.
+ * - **Memory** (semantic recall via `PgVector`): defaults to a single
+ *   **shared** instance across every agent. Cross-agent recall on one
+ *   index is almost always what users want; opt into per-agent recall
+ *   by passing a {@link MastraMemoryConfigOverride} on the agent.
+ *
+ * Additionally, {@link MemoryBuilder.instanceStorage} returns a
+ * **Mastra-instance-level** `PostgresStore` (schema `mastra_instance`)
+ * used for workflow snapshots - the persistence layer
+ * `agent.resumeStream()` reads from when waking a suspended
+ * `requireApproval` tool call. Per-agent stores are not enough for
+ * this: workflow runs are scoped to the Mastra instance, not an
+ * individual agent's `Memory`.
+ *
+ * Plugin-level `config.storage` / `config.memory` act as the baseline
+ * (auto-defaulted to `true` in `plugin.ts` when the `lakebase` plugin
+ * is registered); per-agent settings cascade on top of that.
+ *
+ * @module
+ */
+import { Memory } from "@mastra/memory";
+import { PostgresStore } from "@mastra/pg";
+import { Pool, type PoolConfig } from "pg";
+import type { MastraAgentDefinition } from "./agents.js";
+import type { MastraPluginConfig } from "./config.js";
+/**
+ * Build a dedicated **service-principal** Lakebase pool for Mastra
+ * memory from the lakebase plugin's resolved SP pg config.
+ *
+ * The plugin's `exports().pool` is a `RoutingPool` that switches to
+ * the per-user (OBO) pool whenever a query runs inside an `asUser`
+ * scope - exactly the context the mastra plugin establishes around
+ * every chat turn. Memory (threads / messages + semantic recall) must
+ * instead always act as the app service principal: it owns the
+ * auto-created `mastra_*` schemas (a per-user role usually can't
+ * `CREATE SCHEMA`) and is shared across users, so it cannot inherit a
+ * request's OBO identity.
+ *
+ * `pgConfig` must be the plugin's `exports().getPgConfig()` evaluated
+ * **outside** any `asUser` scope (i.e. during setup), so it carries
+ * the SP connection target, OAuth token-refresh `password` callback,
+ * and any `lakebase({ pool })` tuning overrides - all of which this
+ * pool inherits. See the call site in `plugin.ts`.
+ */
+export declare function createServicePrincipalPool(pgConfig: PoolConfig): Promise<Pool>;
+/**
+ * True when any plugin-level or per-agent setting could need the
+ * Lakebase pool. Used by `plugin.ts` to gate creation of the
+ * service-principal pool and the {@link MemoryBuilder} that consumes
+ * it; when false neither is built.
+ */
+export declare function needsLakebase(config: MastraPluginConfig): boolean;
+/**
+ * Construct a per-agent {@link Memory} factory bound to the supplied
+ * service-principal pool (see {@link createServicePrincipalPool}).
+ * Caches the shared `PgVector` singleton (built on first need) so each
+ * agent build is O(1) after the first.
+ */
+export declare function createMemoryBuilder(config: MastraPluginConfig, servicePrincipalPool: Pool): MemoryBuilder;
+/**
+ * Builds one `Memory` per agent against a shared service-principal
+ * Lakebase pool. Per-instance state keeps the shared `PgVector` alive
+ * across calls so registering N agents stays cheap.
+ */
+export declare class MemoryBuilder {
+    private readonly config;
+    private readonly servicePrincipalPool;
+    private sharedVector;
+    constructor(config: MastraPluginConfig, servicePrincipalPool: Pool);
+    /**
+     * Build the Mastra-instance-level storage used for workflow
+     * snapshots. Returns `undefined` when plugin-level `storage` is
+     * disabled, in which case `agent.resumeStream()` (and therefore
+     * the `requireApproval` flow) will not be available.
+     *
+     * The store lives in a dedicated `mastra_instance` schema so it
+     * never collides with per-agent {@link agentStorageSchemaName} namespaces.
+     * Workflow snapshots are not per-agent state; they belong to the
+     * `Mastra` instance that owns the workflow execution.
+     */
+    instanceStorage(): PostgresStore | undefined;
+    /**
+     * Build a `Memory` for `agentId` after the plugin/agent cascade.
+     * Returns `undefined` when the agent has neither storage nor a
+     * vector store enabled - Mastra accepts a missing `memory` field
+     * and treats the agent as stateless.
+     */
+    forAgent(agentId: string, def: MastraAgentDefinition): Memory | undefined;
+    private buildStorage;
+    /**
+     * Resolve the agent's vector store. Cascade:
+     *
+     * - falsy: no vector.
+     * - `boolean` / `undefined-inheriting-true`: return the shared
+     *   singleton (built lazily on first call). All agents that
+     *   default-enable memory write into and recall from one index.
+     * - object: build a dedicated `PgVector` for this agent.
+     */
+    private buildVector;
+    private getSharedVector;
+}