@dbx-tools/appkit-mastra 0.1.71 → 0.1.72

package/dist/index.js

@@ -1,5 +1,5 @@
-import { ChartSchema, ChartTypeSchema, MASTRA_ROUTES, MODEL_OVERRIDE_BODY_FIELDS, MODEL_OVERRIDE_HEADER, MODEL_OVERRIDE_QUERY } from "@dbx-tools/appkit-mastra-shared";
-import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_MODEL_CACHE_TTL_MS, FALLBACK_MODEL_IDS, ModelClass, clearServingEndpointsCache, listServingEndpoints, parseModelClass, selectModel } from "@dbx-tools/model";
+import { ChartSchema, ChartTypeSchema, MASTRA_ROUTES, MODEL_OVERRIDE_BODY_FIELDS, MODEL_OVERRIDE_HEADER, MODEL_OVERRIDE_QUERY, THREAD_ID_HEADER, THREAD_ID_QUERY } from "@dbx-tools/appkit-mastra-shared";
+import { DEFAULT_FUZZY_THRESHOLD, DEFAULT_MODEL_CACHE_TTL_MS, FALLBACK_MODEL_IDS, ModelClass, ModelClass as ModelClass$1, clearServingEndpointsCache, listServingEndpoints, parseModelClass, selectModel } from "@dbx-tools/model";
 import { apiUtils, appkitUtils, commonUtils, httpUtils, logUtils, netUtils, projectUtils, stringUtils } from "@dbx-tools/shared";
 import { Agent } from "@mastra/core/agent";
 import { createTool, createTool as createTool$1 } from "@mastra/core/tools";
@@ -337,7 +337,7 @@ function sanitizeServingMessages(messages) {
 * the demo client and any other UI consumer share the exact same
 * shape this module reads and writes.
 */
-const log$5 = logUtils.logger("mastra/chart");
+const log$8 = logUtils.logger("mastra/chart");
 /**
 * TTL for cached chart entries. One hour balances "long enough for
 * the host UI to fetch the chart well after the model finished
@@ -547,7 +547,7 @@ function getPlannerAgent(config) {
 			name: "Chart Planner",
 			description: "Picks chart type and axis encodings for a dataset.",
 			instructions: CHART_PLANNER_INSTRUCTIONS,
-			model: ({ requestContext }) => buildModel(config, requestContext, { modelClass: ModelClass.ChatFast })
+			model: ({ requestContext }) => buildModel(config, requestContext, { modelClass: ModelClass$1.ChatFast })
 		});
 		plannerAgents.set(config, agent);
 	}
@@ -593,7 +593,7 @@ async function writeChart(entry) {
 		const key = await chartCacheKey(entry.chartId);
 		await CacheManager.getInstanceSync().set(key, entry, { ttl: CHART_CACHE_TTL_SEC });
 	} catch (err) {
-		log$5.warn("write-error", {
+		log$8.warn("write-error", {
 			chartId: entry.chartId,
 			error: commonUtils.errorMessage(err)
 		});
@@ -608,7 +608,7 @@ async function readChart(chartId) {
 		const key = await chartCacheKey(chartId);
 		return await CacheManager.getInstanceSync().get(key) ?? void 0;
 	} catch (err) {
-		log$5.warn("read-error", {
+		log$8.warn("read-error", {
 			chartId,
 			error: commonUtils.errorMessage(err)
 		});
@@ -633,7 +633,7 @@ async function readChart(chartId) {
 async function prepareChart(opts) {
 	const chartId = commonUtils.id();
 	await writeChart({ chartId });
-	log$5.debug("queued", { chartId });
+	log$8.debug("queued", { chartId });
 	runPrepareChart(chartId, opts);
 	return { chartId };
 }
@@ -654,14 +654,14 @@ async function runPrepareChart(chartId, opts) {
 			chartId,
 			result
 		});
-		log$5.info("done", {
+		log$8.info("done", {
 			chartId,
 			chartType: result.chartType,
 			elapsedMs: Date.now() - startedAt
 		});
 	} catch (err) {
 		const error = commonUtils.errorMessage(err);
-		log$5.warn("error", {
+		log$8.warn("error", {
 			chartId,
 			error
 		});
@@ -848,6 +848,319 @@ function buildRenderDataTool(config) {
 	});
 }
 
+//#endregion
+//#region packages/appkit-mastra/src/connectors/managed-memory/client.ts
+/** Base path for the Unity Catalog memory-stores REST surface. */
+const MEMORY_STORES_PATH = "/api/2.1/unity-catalog/memory-stores";
+/**
+* Error thrown for a non-2xx memory-store response. Carries the HTTP
+* status so callers can distinguish "feature unavailable / store
+* missing" (probe falls back) from genuine failures.
+*/
+var ManagedMemoryError = class extends Error {
+	constructor(status, statusText, body) {
+		super(`managed-memory: ${status} ${statusText}${body ? ` - ${body}` : ""}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.name = "ManagedMemoryError";
+	}
+};
+/**
+* Split a three-level `catalog.schema.name` into its parts. Throws when
+* the input isn't exactly three dot-separated, non-empty segments so a
+* misconfigured `MEMORY_STORE` fails loudly at setup rather than
+* silently hitting a malformed URL.
+*/
+function parseStoreName(fullName) {
+	const parts = fullName.split(".");
+	if (parts.length !== 3 || parts.some((p) => p.trim() === "")) throw new Error(`managed-memory: store name must be three-level "catalog.schema.name", got "${fullName}"`);
+	const [catalog, schema, name] = parts;
+	return {
+		catalog,
+		schema,
+		name
+	};
+}
+/**
+* Resolve the workspace host and an authenticated header set off the
+* client, then issue a `fetch`. Returns the raw `Response` so callers
+* decide how to handle status codes (the store probe wants the 404, the
+* mutating calls want a throw).
+*/
+async function rawFetch(client, path, init) {
+	const host = (await client.config.getHost()).toString();
+	const headers = new Headers({ "Content-Type": "application/json" });
+	await client.config.authenticate(headers);
+	const url = new URL(path, host).toString();
+	return fetch(url, {
+		method: init.method,
+		headers,
+		...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+		...init.signal ? { signal: init.signal } : {}
+	});
+}
+/**
+* Issue a request and parse the JSON body, throwing
+* {@link ManagedMemoryError} on any non-2xx status. Used by the calls
+* where anything but success is a real error (create / write / search).
+*/
+async function requestJson(client, path, init) {
+	const res = await rawFetch(client, path, init);
+	if (!res.ok) throw new ManagedMemoryError(res.status, res.statusText, await safeText(res));
+	return safeJson(res);
+}
+/**
+* Fetch a store by full name. Returns the raw store payload when it
+* exists, or `null` on 404 so callers can treat "missing" as a normal
+* condition (the capability probe and `ensureStore` both rely on this).
+* Any other non-2xx status throws.
+*/
+async function getStore(client, fullName, signal) {
+	const res = await rawFetch(client, `${MEMORY_STORES_PATH}/${fullName}`, {
+		method: "GET",
+		...signal ? { signal } : {}
+	});
+	if (res.status === 404) return null;
+	if (!res.ok) throw new ManagedMemoryError(res.status, res.statusText, await safeText(res));
+	return safeJson(res);
+}
+/**
+* Probe for the store and create it when missing. Returns `true` when
+* the store exists (found or created). The create body splits the
+* three-level name into the catalog / schema / name fields the API
+* expects. A `getStore` 404 followed by a successful create is the
+* common first-run path.
+*/
+async function ensureStore(client, fullName, description, signal) {
+	if (await getStore(client, fullName, signal) !== null) return true;
+	const { catalog, schema, name } = parseStoreName(fullName);
+	await requestJson(client, MEMORY_STORES_PATH, {
+		method: "POST",
+		body: {
+			name,
+			catalog_name: catalog,
+			schema_name: schema,
+			description
+		},
+		...signal ? { signal } : {}
+	});
+	return true;
+}
+/**
+* Write (upsert) an entry into the store under `scope`. Scope is the
+* OBO user id resolved in trusted code; it travels as a query parameter
+* so the API isolates one user's memories from another's.
+*/
+async function writeEntry(client, fullName, scope, entry, signal) {
+	await requestJson(client, `${MEMORY_STORES_PATH}/${fullName}/entries?scope=${encodeURIComponent(scope)}`, {
+		method: "POST",
+		body: {
+			path: entry.path,
+			contents: entry.contents,
+			...entry.description ? { description: entry.description } : {}
+		},
+		...signal ? { signal } : {}
+	});
+}
+/**
+* Semantic search over a user's entries within `scope`. Returns up to
+* `topK` entries, parsed defensively so a renamed / missing Beta field
+* degrades to an empty list rather than crashing the turn.
+*/
+async function search(client, fullName, scope, query, topK, signal) {
+	return parseEntries(await requestJson(client, `${MEMORY_STORES_PATH}/${fullName}/entries:search?scope=${encodeURIComponent(scope)}`, {
+		method: "POST",
+		body: {
+			query,
+			top_k: topK
+		},
+		...signal ? { signal } : {}
+	})).slice(0, topK);
+}
+/**
+* Defensively pull a `MemoryEntry[]` out of a search response. Accepts
+* the documented `{ entries: [...] }` envelope plus a bare array, and
+* tolerates snake_case / camelCase field drift. Entries without any
+* textual content are dropped.
+*/
+function parseEntries(body) {
+	const list = Array.isArray(body) ? body : Array.isArray(body?.entries) ? body.entries : Array.isArray(body?.results) ? body.results : [];
+	const out = [];
+	for (const raw of list) {
+		if (!raw || typeof raw !== "object") continue;
+		const obj = raw;
+		const contents = firstString(obj["contents"], obj["content"], obj["text"]);
+		if (!contents) continue;
+		const path = firstString(obj["path"]);
+		const description = firstString(obj["description"], obj["summary"]);
+		const score = typeof obj["score"] === "number" ? obj["score"] : void 0;
+		out.push({
+			contents,
+			...path ? { path } : {},
+			...description ? { description } : {},
+			...score !== void 0 ? { score } : {}
+		});
+	}
+	return out;
+}
+/** Return the first argument that is a non-empty string, else undefined. */
+function firstString(...values) {
+	for (const v of values) if (typeof v === "string" && v.trim() !== "") return v;
+}
+/** Parse a response body as JSON, returning `{}` on empty / invalid bodies. */
+async function safeJson(res) {
+	const text = await safeText(res);
+	if (!text) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+}
+/** Read a response body as text, swallowing read errors. */
+async function safeText(res) {
+	try {
+		return await res.text();
+	} catch {
+		return "";
+	}
+}
+
+//#endregion
+//#region packages/appkit-mastra/src/connectors/managed-memory/context.ts
+/**
+* Per-request resolution of the OBO workspace client and the memory
+* scope (the user id memories are partitioned by). Shared by the
+* managed-memory tools and the recall processor so the "who is this
+* turn for, and as whom do we call Databricks" logic lives in one
+* place.
+*
+* Scope is always derived from trusted server state - the AppKit user
+* stamped on the request context, or the active execution context - and
+* never from anything the model controls. Returns `null` when there is
+* no resolvable user (a stateless turn, or an MCP call with no request
+* context), so callers cleanly no-op instead of leaking memories across
+* users.
+*/
+/**
+* Resolve the OBO-scoped workspace client and the memory scope for the
+* current turn. Mirrors `model.ts`: prefer the AppKit user stamped on
+* the request context, fall back to the ambient execution context (the
+* active OBO scope or the service principal). Scope is the Mastra
+* resource id (the per-user thread owner) when present, else the user
+* id. Returns `null` when neither yields a usable scope.
+*/
+function resolveMemoryContext(requestContext) {
+	const user = requestContext?.get(MASTRA_USER_KEY);
+	let executionContext;
+	try {
+		executionContext = user?.executionContext ?? getExecutionContext();
+	} catch {
+		return null;
+	}
+	const resourceId = requestContext?.get(MASTRA_RESOURCE_ID_KEY);
+	const scope = stringUtils.trimToNull(resourceId) ?? stringUtils.trimToNull(user?.id);
+	if (!scope) return null;
+	return {
+		client: executionContext.client,
+		scope
+	};
+}
+
+//#endregion
+//#region packages/appkit-mastra/src/connectors/managed-memory/tools.ts
+/**
+* Ambient Mastra tools for Databricks Managed Agent Memory:
+* `save_memory` (persist a durable fact) and `search_memory` (look up
+* prior memories). Built only when managed memory is the active
+* long-term backend and merged into every agent's tool set by
+* `buildAgents`.
+*
+* Both tools resolve the OBO user scope from trusted request state via
+* {@link resolveMemoryContext} - the model passes only the content /
+* query, never the scope (honoring the Managed Memory security
+* guidance). On a stateless turn (no resolvable user) the tools no-op
+* with a clear message instead of writing cross-user data, and any REST
+* failure degrades to a short error string rather than aborting the
+* turn.
+*/
+const log$7 = logUtils.logger("mastra/managed-memory/tools");
+const saveMemoryInput = z.object({
+	content: z.string().describe("The durable fact or preference to remember."),
+	summary: z.string().optional().describe("Optional one-line summary used to label the memory.")
+});
+const searchMemoryInput = z.object({ query: z.string().describe("What to look up in the user's saved memories.") });
+/**
+* Build the `save_memory` / `search_memory` tool pair bound to a
+* resolved managed-memory runtime. The runtime supplies the store name,
+* recall size, and default entry path; the per-request client and scope
+* are resolved inside each `execute`.
+*/
+function buildManagedMemoryTools(runtime) {
+	return {
+		save_memory: createTool$1({
+			id: "save_memory",
+			description: stringUtils.toDescription([`
+          Save a durable fact or preference about the user to long-term
+          memory so it can be recalled in future conversations. Use when
+          the user states something worth remembering across sessions
+          ("I'm in the EU, use EUR", "always show the SQL"). Pass the
+          fact as \`content\` and an optional one-line \`summary\`.
+        `, `
+          The memory is automatically scoped to the current user - never
+          include another person's data.
+        `]),
+			inputSchema: saveMemoryInput,
+			execute: async (input, ctxRaw) => {
+				const { content, summary } = input;
+				const ctx = resolveMemoryContext(requestContextOf(ctxRaw));
+				if (!ctx) return "Memory is not available for this conversation.";
+				try {
+					await writeEntry(ctx.client, runtime.storeName, ctx.scope, {
+						path: runtime.entryPath,
+						contents: content,
+						...summary ? { description: summary } : {}
+					});
+					log$7.debug("saved", { scope: ctx.scope });
+					return "Saved to memory.";
+				} catch (err) {
+					log$7.warn("save:error", { error: commonUtils.errorMessage(err) });
+					return "Could not save to memory right now.";
+				}
+			}
+		}),
+		search_memory: createTool$1({
+			id: "search_memory",
+			description: stringUtils.toDescription([`
+          Search the user's long-term memory for relevant saved facts or
+          preferences. Use before answering when prior context might
+          help. Pass what you're looking for as \`query\`; returns the
+          most relevant saved memories (scoped to the current user).
+        `]),
+			inputSchema: searchMemoryInput,
+			execute: async (input, ctxRaw) => {
+				const { query } = input;
+				const ctx = resolveMemoryContext(requestContextOf(ctxRaw));
+				if (!ctx) return { memories: [] };
+				try {
+					return { memories: (await search(ctx.client, runtime.storeName, ctx.scope, query, runtime.topK)).map(renderEntry) };
+				} catch (err) {
+					log$7.warn("search:error", { error: commonUtils.errorMessage(err) });
+					return { memories: [] };
+				}
+			}
+		})
+	};
+}
+/** Render an entry to a single recall line (summary prefix when present). */
+function renderEntry(entry) {
+	return entry.description ? `${entry.description}: ${entry.contents}` : entry.contents;
+}
+/** Pull the Mastra `RequestContext` out of a tool's execution context arg. */
+function requestContextOf(ctxRaw) {
+	return ctxRaw?.requestContext;
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/statement.ts
 /**
@@ -970,7 +1283,7 @@ async function safeWrite(log, writer, chunk, context = {}) {
 * `instructions` when you want the canonical "how to drive the
 * Genie tools" guidance.
 */
-const log$4 = logUtils.logger("mastra/genie");
+const log$6 = logUtils.logger("mastra/genie");
 /** Default alias used when a single unnamed Genie space is wired up. */
 const DEFAULT_GENIE_ALIAS = "default";
 /**
@@ -1085,7 +1398,7 @@ async function readCachedConversationId(cacheKey) {
 	try {
 		return await CacheManager.getInstanceSync().get(cacheKey) ?? void 0;
 	} catch (err) {
-		log$4.warn("conversation-cache:read-error", { error: commonUtils.errorMessage(err) });
+		log$6.warn("conversation-cache:read-error", { error: commonUtils.errorMessage(err) });
 		return;
 	}
 }
@@ -1101,7 +1414,7 @@ async function saveCachedConversationId(cacheKey, conversationId) {
 	try {
 		await CacheManager.getInstanceSync().set(cacheKey, conversationId, { ttl: CONVERSATION_TTL_SEC });
 	} catch (err) {
-		log$4.warn("conversation-cache:write-error", { error: commonUtils.errorMessage(err) });
+		log$6.warn("conversation-cache:write-error", { error: commonUtils.errorMessage(err) });
 	}
 }
 /** Force-evict a cached conversation id. Used on the stale-id recovery path. */
@@ -1110,7 +1423,7 @@ async function evictCachedConversationId(cacheKey) {
 	try {
 		await CacheManager.getInstanceSync().delete(cacheKey);
 	} catch (err) {
-		log$4.warn("conversation-cache:delete-error", { error: commonUtils.errorMessage(err) });
+		log$6.warn("conversation-cache:delete-error", { error: commonUtils.errorMessage(err) });
 	}
 }
 /**
@@ -1224,7 +1537,7 @@ function buildAskGenieTool(opts) {
 			if (trimmed.length === 0 || PLACEHOLDER_QUESTIONS.has(trimmed.toLowerCase())) throw new Error(`${toolId}: refusing placeholder question "${question}" - call ${toolId} only with a real natural-language question, or skip the call entirely`);
 			const cacheKey = await conversationCacheKey(spaceId, threadId);
 			await ensureConversationSeeded(requestContext, spaceId, cacheKey);
-			await safeWrite(log$4, writer, {
+			await safeWrite(log$6, writer, {
 				type: "started",
 				spaceId,
 				content: question
@@ -1237,7 +1550,7 @@ function buildAskGenieTool(opts) {
 					...seedConversationId ? { conversationId: seedConversationId } : {},
 					...signal ? { context: signal } : {}
 				})) {
-					if (event.type !== "message") await safeWrite(log$4, writer, event);
+					if (event.type !== "message") await safeWrite(log$6, writer, event);
 					const eventConversationId = event.conversation_id;
 					if (eventConversationId) writeContextConversationId(requestContext, spaceId, eventConversationId);
 					if (event.type === "result") finalMessage = event.message;
@@ -1251,7 +1564,7 @@ function buildAskGenieTool(opts) {
 			} catch (err) {
 				const seeded = readContextConversationId(requestContext, spaceId);
 				if (seeded && apiUtils.isNotFoundError(err)) {
-					log$4.warn("conversation-cache:stale, resetting", {
+					log$6.warn("conversation-cache:stale, resetting", {
 						spaceId,
 						conversationId: seeded,
 						error: commonUtils.errorMessage(err)
@@ -1736,7 +2049,7 @@ async function collectSpaceSuggestions(opts) {
 			}));
 			writeSuggestionCache(spaceId, questions);
 		} catch (err) {
-			log$4.warn("suggestions:fetch-error", {
+			log$6.warn("suggestions:fetch-error", {
 				spaceId,
 				error: commonUtils.errorMessage(err)
 			});
@@ -1782,6 +2095,76 @@ var ResultProcessor = class {
 	}
 };
 
+//#endregion
+//#region packages/appkit-mastra/src/processors/managed-memory-recall.ts
+/**
+* Mastra input processor that auto-recalls Databricks Managed Agent
+* Memory before each turn. This is the managed-memory replacement for
+* Postgres `PgVector` semantic recall: instead of Mastra reading a
+* vector index, this processor searches the user's memory-store scope
+* with the latest user message and injects the top entries as an
+* appended system message so the model has the user's durable context.
+*
+* Scope comes from trusted request state via {@link resolveMemoryContext}
+* (the OBO user), never from the model. On a stateless turn, an empty
+* query, or any REST failure the processor passes the messages through
+* unchanged so a recall hiccup never blocks the conversation.
+*/
+const log$5 = logUtils.logger("mastra/processor/managed-memory-recall");
+/**
+* Build the recall processor bound to a managed-memory runtime. Created
+* once at setup (when managed memory is active) and wired onto every
+* agent's `inputProcessors` by {@link buildAgents}.
+*/
+function buildManagedMemoryRecallProcessor(runtime) {
+	return {
+		id: "managed-memory-recall",
+		description: "Recalls the user's Databricks Managed Memory entries and injects them as context before the model runs.",
+		async processInput(args) {
+			const ctx = resolveMemoryContext(args.requestContext);
+			if (!ctx) return args.messages;
+			const query = latestUserText(args.messages);
+			if (!query) return args.messages;
+			try {
+				const entries = await search(ctx.client, runtime.storeName, ctx.scope, query, runtime.topK, args.abortSignal);
+				if (entries.length === 0) return args.messages;
+				const block = ["Relevant memories about the user (from long-term memory):", ...entries.map((e) => `- ${renderEntry(e)}`)].join("\n");
+				log$5.debug("recalled", {
+					scope: ctx.scope,
+					entries: entries.length
+				});
+				return {
+					messages: args.messages,
+					systemMessages: [...args.systemMessages, {
+						role: "system",
+						content: block
+					}]
+				};
+			} catch (err) {
+				log$5.warn("recall:error", { error: commonUtils.errorMessage(err) });
+				return args.messages;
+			}
+		}
+	};
+}
+/**
+* Extract the most recent user message's text. Walks the message list
+* from the end, collecting `text` parts off the first `user` message.
+* Returns `null` when there is no user text to search with.
+*/
+function latestUserText(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (!message || message.role !== "user") continue;
+		const content = message.content;
+		const parts = content?.parts;
+		if (!Array.isArray(parts)) return stringUtils.trimToNull(content?.content);
+		const text = parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(" ");
+		return stringUtils.trimToNull(text);
+	}
+	return null;
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/processors/strip-stale-charts.ts
 /**
@@ -1808,7 +2191,7 @@ var ResultProcessor = class {
 * legacy `datasets[].chartId` payloads uniformly without coupling
 * to specific tool ids.
 */
-const log$3 = logUtils.logger("mastra/processor/strip-stale-charts");
+const log$4 = logUtils.logger("mastra/processor/strip-stale-charts");
 /**
 * Recursively clone `value`, omitting any property whose key is
 * `chartId`. Arrays are mapped element-wise; primitives are
@@ -1856,11 +2239,135 @@ const stripStaleChartsProcessor = {
 				}
 			}
 		}
-		if (stripped > 0) log$3.debug("stripped", { results: stripped });
+		if (stripped > 0) log$4.debug("stripped", { results: stripped });
 		return args.messages;
 	}
 };
 
+//#endregion
+//#region packages/appkit-mastra/src/summarize.ts
+/**
+* Small-tier summarization for the Mastra plugin.
+*
+* Two surfaces, both backed by the fast / small chat tier
+* ({@link ModelClass.ChatFast}) resolved through the same
+* `/serving-endpoints` pipeline as the main agents:
+*
+*   - A dedicated `summarize` tool (see {@link buildSummarizeTool})
+*     agents can call to condense arbitrary text without burning the
+*     heavyweight chat model.
+*   - The model + instructions Mastra's memory uses to auto-name
+*     conversation threads (`generateTitle`), so titling reuses the
+*     same small tier rather than the agent's primary model.
+*
+* Mirrors the chart-planner wiring in `chart.ts`: a per-config cached
+* `Agent` on the fast tier, invoked via `agent.generate(...)` inside
+* the active `asUser` scope so tokens stay user-scoped.
+*/
+/** Fast / small chat tier used for both titling and summaries. */
+const SUMMARY_MODEL_CLASS = ModelClass.ChatFast;
+/** System prompt for the summarizer agent (and the `summarize` tool). */
+const SUMMARIZER_INSTRUCTIONS = [
+	"You are a summarization engine.",
+	"Given a block of text, produce a faithful, concise summary of it.",
+	"Default to a few sentences; follow any length guidance the caller gives.",
+	"Plain prose. No preamble, no headers, no bullet points unless asked.",
+	"Never use emojis. Use hyphens (-) only, never em dashes or en dashes.",
+	"Never add information, opinions, or details not present in the input.",
+	"Output only the summary."
+].join("\n");
+/**
+* Instructions Mastra's `generateTitle` hands the small-tier model to
+* name a conversation thread from its opening turn. Kept terse so the
+* model returns a bare title with no decoration.
+*/
+const TITLE_INSTRUCTIONS = [
+	"Generate a short, specific title for this conversation, 3 to 6 words.",
+	"Capture the user's topic, not the assistant's response.",
+	"Plain text only: no surrounding quotes, no trailing punctuation,",
+	"no emojis, and no em dashes. Output only the title."
+].join(" ");
+/**
+* Resolve the small-tier model for summarization / titling. Reused by
+* both the summarizer agent and Mastra memory's `generateTitle`.
+*
+* Returned as a `requestContext`-taking function (a Mastra
+* `DynamicArgument<MastraModelConfig>`) so each call mints user-scoped
+* tokens via {@link buildModel}, exactly like the primary agents.
+*/
+function summaryModel(config) {
+	return ({ requestContext }) => buildModel(config, requestContext, { modelClass: SUMMARY_MODEL_CLASS });
+}
+/**
+* One summarizer `Agent` per plugin config, cached on config-object
+* identity so a hot tool path doesn't pay the constructor cost each
+* call. `WeakMap` lets retired configs (e.g. test reconfigurations)
+* release their agent without manual eviction.
+*/
+const summarizerAgents = /* @__PURE__ */ new WeakMap();
+function getSummarizerAgent(config) {
+	let agent = summarizerAgents.get(config);
+	if (!agent) {
+		agent = new Agent({
+			id: "summarizer",
+			name: "Summarizer",
+			description: "Condenses text into a short summary using a fast, small model.",
+			instructions: SUMMARIZER_INSTRUCTIONS,
+			model: summaryModel(config)
+		});
+		summarizerAgents.set(config, agent);
+	}
+	return agent;
+}
+/** Inputs accepted by the `summarize` tool. */
+const summarizeInput = z.object({
+	text: z.string().min(1).describe("The text to summarize."),
+	instructions: z.string().optional().describe("Optional extra guidance for the summary, e.g. 'one sentence' or 'list the action items'."),
+	maxWords: z.number().int().positive().optional().describe("Optional soft cap on the summary length, in words.")
+});
+/**
+* Summarize `text` with the small-tier summarizer agent, returning the
+* trimmed summary string. Throws on model failure (the caller decides
+* how to degrade).
+*/
+async function summarizeText(config, text, options = {}) {
+	const { instructions, maxWords, requestContext, abortSignal } = options;
+	const prompt = stringUtils.toDescription({
+		...instructions ? { Guidance: instructions } : {},
+		...maxWords !== void 0 ? { "Max length (words)": String(maxWords) } : {},
+		Text: text
+	});
+	return (await getSummarizerAgent(config).generate(prompt, {
+		...requestContext ? { requestContext } : {},
+		...abortSignal ? { abortSignal } : {}
+	})).text.trim();
+}
+/**
+* Build the `summarize` tool. Exposed as an ambient system tool (like
+* `render_data`) so every agent can offload condensing long content,
+* notes, transcripts, or bulky tool results to the fast tier instead of
+* spending its primary chat model. The tool reads the live
+* `requestContext` / `abortSignal` off the Mastra execution context so
+* its model call stays user-scoped and cancels with the turn.
+*/
+function buildSummarizeTool(config) {
+	return createTool$1({
+		id: "summarize",
+		description: "Summarize a block of text using a fast, small model. Use it to condense long content, notes, transcripts, or tool results into a short summary without spending the main chat model.",
+		inputSchema: summarizeInput,
+		execute: async (input, context) => {
+			const { text, instructions, maxWords } = input;
+			const ctx = context;
+			return { summary: await summarizeText(config, text, {
+				...instructions ? { instructions } : {},
+				...maxWords !== void 0 ? { maxWords } : {},
+				...ctx?.requestContext ? { requestContext: ctx.requestContext } : {},
+				...ctx?.abortSignal ? { abortSignal: ctx.abortSignal } : {}
+			}) };
+		}
+	});
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/agents.ts
 /**
@@ -2022,18 +2529,24 @@ function composeInstructions(agentInstructions, style) {
 *   resolved registry; this is a wiring bug, not a runtime condition.
 */
 async function buildAgents(opts) {
-	const { config, context, memoryBuilder, log } = opts;
+	const { config, context, memoryBuilder, managedMemory, log } = opts;
 	const definitions = resolveDefinitions(config);
 	const ids = Object.keys(definitions);
 	const defaultAgentId = config.defaultAgent ?? ids[0] ?? FALLBACK_AGENT_ID;
 	const plugins = buildPluginsMap(config, context);
-	const ambientTools = {
+	const systemTools = {
 		render_data: buildRenderDataTool(config),
+		summarize: buildSummarizeTool(config)
+	};
+	const managedMemoryTools = managedMemory?.tools ? buildManagedMemoryTools(managedMemory) : {};
+	const ambientTools = {
+		...systemTools,
+		...managedMemoryTools,
 		...config.tools ?? {}
 	};
 	const style = resolveStyleInstructions(config);
 	const outputProcessors = [new ResultProcessor()];
-	const inputProcessors = config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor];
+	const inputProcessors = [...config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor], ...managedMemory?.recall ? [buildManagedMemoryRecallProcessor(managedMemory)] : []];
 	const agents = {};
 	for (const [id, def] of Object.entries(definitions)) {
 		const tools = await resolveTools(def.tools, plugins, ambientTools);
@@ -2278,6 +2791,72 @@ function toolkitEntryToMastraTool(entry, plugin) {
 	});
 }
 
+//#endregion
+//#region packages/appkit-mastra/src/connectors/managed-memory/defaults.ts
+/**
+* Default values and environment variable names for the managed-memory
+* connector. Kept in a leaf module so the client, tools, recall
+* processor, and plugin setup can share them without a cycle.
+*/
+/**
+* Environment variable holding the three-level Unity Catalog store name
+* (`catalog.schema.name`). Read when {@link ManagedMemoryConfig.store}
+* is omitted; also the sole enable signal in prefer-if-available mode
+* (managed memory stays off when it is unset).
+*/
+const MEMORY_STORE_ENV = "MEMORY_STORE";
+/**
+* Default number of entries the recall processor injects and
+* `search_memory` returns. Matches the prior `PgVector`
+* `semanticRecall.topK` so behavior is unchanged after the swap.
+*/
+const DEFAULT_TOPK = 3;
+/**
+* Default path `save_memory` writes land under. Managed Memory keys
+* entries by path within a scope, so a single stable path accumulates a
+* user's notes rather than scattering them.
+*/
+const DEFAULT_ENTRY_PATH = "/memories/notes.md";
+/** Description stamped on the store when the connector auto-creates it. */
+const DEFAULT_STORE_DESCRIPTION = "Long-term agent memory managed by @dbx-tools/appkit-mastra.";
+
+//#endregion
+//#region packages/appkit-mastra/src/connectors/managed-memory/resolve.ts
+/**
+* Resolve the managed-memory target from config + env, or `null` when
+* managed memory is disabled. Throws when explicitly enabled but no
+* store name can be resolved (config or `MEMORY_STORE`), so a
+* misconfiguration surfaces at setup rather than silently falling back.
+*/
+function resolveManagedMemoryTarget(config) {
+	const setting = config.managedMemory;
+	if (setting === false) return null;
+	const envStore = trimmedEnv(MEMORY_STORE_ENV);
+	const obj = typeof setting === "object" ? setting : {};
+	if (!(setting === true || typeof setting === "object") && !envStore) return null;
+	const storeName = trimmed(obj.store) ?? envStore;
+	if (!storeName) throw new Error(`mastra: managedMemory is enabled but no store name is set. Set managedMemory.store or the ${MEMORY_STORE_ENV} env var to a three-level Unity Catalog name (catalog.schema.name).`);
+	return {
+		storeName,
+		description: trimmed(obj.description) ?? DEFAULT_STORE_DESCRIPTION,
+		topK: obj.topK ?? DEFAULT_TOPK,
+		entryPath: trimmed(obj.entryPath) ?? DEFAULT_ENTRY_PATH,
+		autoCreate: obj.autoCreate ?? true,
+		recall: obj.recall ?? true,
+		tools: obj.tools ?? true
+	};
+}
+/** Trimmed env var value, or undefined when unset / blank. */
+function trimmedEnv(name) {
+	return trimmed(process.env[name]);
+}
+/** Trimmed string, or undefined when undefined / blank. */
+function trimmed(value) {
+	if (typeof value !== "string") return void 0;
+	const t = value.trim();
+	return t === "" ? void 0 : t;
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/mcp.ts
 /** MCP server version advertised when the caller doesn't pin one. */
@@ -2320,11 +2899,11 @@ function buildMcpServer(opts) {
 
 //#endregion
 //#region packages/appkit-mastra/src/history.ts
-const log$2 = logUtils.logger("mastra/history");
+const log$3 = logUtils.logger("mastra/history");
 /** Default history page size; matches the Mastra storage default. */
-const DEFAULT_PER_PAGE = 20;
+const DEFAULT_PER_PAGE$1 = 20;
 /** Hard cap so a misbehaving client can't fetch the whole thread at once. */
-const MAX_PER_PAGE = 200;
+const MAX_PER_PAGE$1 = 200;
 /**
 * Fetch a page of UI-formatted messages for a thread.
 *
@@ -2341,11 +2920,11 @@ const MAX_PER_PAGE = 200;
 * without sorting locally.
 */
 async function loadHistory(opts) {
-	const perPage = clampPerPage(opts.perPage);
+	const perPage = clampPerPage$1(opts.perPage);
 	const page = Math.max(0, Math.trunc(opts.page ?? 0));
 	const memory = await opts.agent.getMemory();
 	if (!memory) {
-		log$2.debug("recall:no-memory", {
+		log$3.debug("recall:no-memory", {
 			agentId: opts.agent.id,
 			threadId: opts.threadId
 		});
@@ -2369,7 +2948,7 @@ async function loadHistory(opts) {
 		}
 	});
 	const uiMessages = toAISdkV5Messages(sortChronological(result.messages));
-	log$2.debug("recall:done", {
+	log$3.debug("recall:done", {
 		agentId: opts.agent.id,
 		threadId: opts.threadId,
 		page,
@@ -2403,7 +2982,7 @@ async function loadHistory(opts) {
 async function clearHistory(opts) {
 	const memory = await opts.agent.getMemory();
 	if (!memory) {
-		log$2.debug("clear:no-memory", {
+		log$3.debug("clear:no-memory", {
 			agentId: opts.agent.id,
 			threadId: opts.threadId
 		});
@@ -2417,7 +2996,7 @@ async function clearHistory(opts) {
 			perPage: 1
 		})).total;
 	} catch (err) {
-		log$2.debug("clear:probe-failed", {
+		log$3.debug("clear:probe-failed", {
 			agentId: opts.agent.id,
 			threadId: opts.threadId,
 			error: commonUtils.errorMessage(err)
@@ -2427,13 +3006,13 @@ async function clearHistory(opts) {
 	try {
 		await memory.deleteThread(opts.threadId);
 	} catch (err) {
-		log$2.warn("clear:delete-soft-failed", {
+		log$3.warn("clear:delete-soft-failed", {
 			agentId: opts.agent.id,
 			threadId: opts.threadId,
 			error: commonUtils.errorMessage(err)
 		});
 	}
-	log$2.info("clear:done", {
+	log$3.info("clear:done", {
 		agentId: opts.agent.id,
 		threadId: opts.threadId,
 		cleared,
@@ -2490,8 +3069,8 @@ function historyRoute(options) {
 				agent: ctx.agent,
 				threadId: ctx.threadId,
 				...ctx.resourceId ? { resourceId: ctx.resourceId } : {},
-				page: parseIntParam(c.req.query("page")),
-				perPage: parseIntParam(c.req.query("perPage"))
+				page: parseIntParam$1(c.req.query("page")),
+				perPage: parseIntParam$1(c.req.query("perPage"))
 			});
 			return c.json(payload);
 		}
@@ -2515,11 +3094,11 @@ function historyRoute(options) {
 	})];
 }
 /** Coerce / clamp `perPage`; falls back to the page-size default. */
-function clampPerPage(value) {
-	if (value === void 0 || Number.isNaN(value)) return DEFAULT_PER_PAGE;
+function clampPerPage$1(value) {
+	if (value === void 0 || Number.isNaN(value)) return DEFAULT_PER_PAGE$1;
 	const n = Math.trunc(value);
-	if (n <= 0) return DEFAULT_PER_PAGE;
-	return Math.min(n, MAX_PER_PAGE);
+	if (n <= 0) return DEFAULT_PER_PAGE$1;
+	return Math.min(n, MAX_PER_PAGE$1);
 }
 /**
 * Sort messages oldest-first by `createdAt`, falling back to whatever
@@ -2545,7 +3124,7 @@ function toEpoch(value) {
 * `undefined` for empty / non-numeric / negative inputs so
 * {@link loadHistory} can apply its built-in defaults.
 */
-function parseIntParam(value) {
+function parseIntParam$1(value) {
 	if (!value) return void 0;
 	const n = Number(value);
 	if (!Number.isFinite(n) || n < 0) return void 0;
@@ -2582,7 +3161,7 @@ function parseIntParam(value) {
 * (auto-defaulted to `true` in `plugin.ts` when the `lakebase` plugin
 * is registered); per-agent settings cascade on top of that.
 */
-const log$1 = logUtils.logger("mastra/memory");
+const log$2 = logUtils.logger("mastra/memory");
 /**
 * Build a dedicated **service-principal** Lakebase pool for Mastra
 * memory from the lakebase plugin's resolved SP pg config.
@@ -2626,8 +3205,8 @@ function needsLakebase(config) {
 * Caches the shared `PgVector` singleton (built on first need) so each
 * agent build is O(1) after the first.
 */
-function createMemoryBuilder(config, servicePrincipalPool) {
-	return new MemoryBuilder(config, servicePrincipalPool);
+function createMemoryBuilder(config, servicePrincipalPool, options = {}) {
+	return new MemoryBuilder(config, servicePrincipalPool, options);
 }
 /**
 * Builds one `Memory` per agent against a shared service-principal
@@ -2636,9 +3215,10 @@ function createMemoryBuilder(config, servicePrincipalPool) {
 */
 var MemoryBuilder = class {
 	sharedVector;
-	constructor(config, servicePrincipalPool) {
+	constructor(config, servicePrincipalPool, options = {}) {
 		this.config = config;
 		this.servicePrincipalPool = servicePrincipalPool;
+		this.options = options;
 	}
 	/**
 	* Build a `Memory` for `agentId` after the plugin/agent cascade.
@@ -2673,10 +3253,10 @@ var MemoryBuilder = class {
 		const storage = this.buildStorage(agentId, storageSetting);
 		const vector = this.buildVector(memorySetting);
 		if (!storage && !vector) {
-			log$1.debug("agent:stateless", { agentId });
+			log$2.debug("agent:stateless", { agentId });
 			return;
 		}
-		log$1.debug("agent:configured", {
+		log$2.debug("agent:configured", {
 			agentId,
 			storage: storage !== void 0,
 			vector: vector !== void 0,
@@ -2693,6 +3273,10 @@ var MemoryBuilder = class {
 				...vector ? { semanticRecall: {
 					topK: 3,
 					messageRange: 2
+				} } : {},
+				...storage ? { generateTitle: {
+					model: summaryModel(this.config),
+					instructions: TITLE_INSTRUCTIONS
 				} } : {}
 			}
 		});
@@ -2716,6 +3300,7 @@ var MemoryBuilder = class {
 	* - object: build a dedicated `PgVector` for this agent.
 	*/
 	buildVector(setting) {
+		if (this.options.suppressVector) return void 0;
 		if (!setting) return void 0;
 		if (typeof setting === "boolean") return this.getSharedVector();
 		return buildPgVector(setting);
@@ -2817,7 +3402,7 @@ function withId(value, fallback) {
 * to the global noop tracer, mirroring how the `agents` plugin
 * silently no-ops in the same situation.
 */
-const log = logUtils.logger("mastra/observability");
+const log$1 = logUtils.logger("mastra/observability");
 const DEFAULT_SERVICE_NAME = "mastra";
 /**
 * Build a Mastra `Observability` whose spans ride AppKit's global
@@ -2835,7 +3420,7 @@ async function buildObservability(options) {
 	const otelBase = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
 	const otelTracesOverride = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT;
 	const resolvedTracesUrl = otelTracesOverride ? otelTracesOverride : otelBase ? `${otelBase.replace(/\/+$/, "")}/v1/traces` : void 0;
-	log.info("Mastra observability wired through OTel bridge", {
+	log$1.info("Mastra observability wired through OTel bridge", {
 		serviceName,
 		requestContextKeys,
 		otelBase: otelBase ?? "<unset>",
@@ -2921,8 +3506,31 @@ var MastraServer$1 = class extends MastraServer {
 		requestContext.set(MASTRA_REQUEST_ID_KEY, requestId);
 		res.setHeader("X-Request-Id", requestId);
 	}
+	/**
+	* Resolve the thread id this request targets and pin it on
+	* `RequestContext` (consumed by the agent stream for persistence and
+	* by the history / threads routes). Resolution order:
+	*
+	*   1. A client-supplied thread id (the thread-selection header /
+	*      `?threadId=` query). This is how the chat UI references a
+	*      specific conversation among the many a user owns - it picks a
+	*      thread id from the `/threads` listing (or mints one for a new
+	*      conversation) and stamps it here. The id is scoped to the
+	*      caller's resource by the recall / list routes, so a client
+	*      can only ever read or write its own threads.
+	*   2. The per-session cookie (`appkit_<plugin-name>_session_id`),
+	*      minted on first contact. This is the default single-thread
+	*      fallback for clients that don't manage threads explicitly, so
+	*      existing embeds keep one stable conversation per session with
+	*      no client changes.
+	*/
 	configureRequestContextThreadId(req, res, requestContext) {
 		if (requestContext.get(MASTRA_THREAD_ID_KEY)) return;
+		const requested = this.readRequestedThreadId(req);
+		if (requested) {
+			requestContext.set(MASTRA_THREAD_ID_KEY, requested);
+			return;
+		}
 		const cookies = httpUtils.parseCookies(req.headers.cookie);
 		const cookieName = stringUtils.toIdentifierWithOptions({
 			delimiter: "_",
@@ -2940,6 +3548,17 @@ var MastraServer$1 = class extends MastraServer {
 		}
 		requestContext.set(MASTRA_THREAD_ID_KEY, sessionId);
 	}
+	/**
+	* Read the client-selected thread id from the request, preferring
+	* the thread-selection header over the `?threadId=` query. Returns
+	* `null` when neither carries a non-empty value so the caller falls
+	* back to the session cookie.
+	*/
+	readRequestedThreadId(req) {
+		const headerValue = req.headers[THREAD_ID_HEADER];
+		const queryValue = req.query[THREAD_ID_QUERY];
+		return stringUtils.trimToNull(Array.isArray(headerValue) ? headerValue[0] : headerValue) ?? stringUtils.trimToNull(Array.isArray(queryValue) ? queryValue[0] : queryValue);
+	}
 	configureRequestContextModelOverride(req, requestContext) {
 		if (resolveServingConfig(this.config).allowOverride) {
 			const override = extractModelOverride({
@@ -2973,6 +3592,206 @@ function attachRoutePatchMiddleware(app) {
 	});
 }
 
+//#endregion
+//#region packages/appkit-mastra/src/threads.ts
+const log = logUtils.logger("mastra/threads");
+/** Default threads page size. */
+const DEFAULT_PER_PAGE = 30;
+/** Hard cap so a misbehaving client can't fetch every thread at once. */
+const MAX_PER_PAGE = 200;
+/**
+* Fetch a page of the resource's conversation threads, newest
+* (`updatedAt` DESC) first.
+*
+* Uses the agent's resolved `Memory` (`getMemory()`) so the per-agent
+* storage namespace (`mastra_<agentId>` schema) applies 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.
+*/
+async function listThreads(opts) {
+	const perPage = clampPerPage(opts.perPage);
+	const page = Math.max(0, Math.trunc(opts.page ?? 0));
+	const memory = await opts.agent.getMemory();
+	if (!memory) {
+		log.debug("list:no-memory", { agentId: opts.agent.id });
+		return {
+			threads: [],
+			page,
+			perPage,
+			total: 0,
+			hasMore: false
+		};
+	}
+	const startedAt = Date.now();
+	const result = await memory.listThreads({
+		filter: { resourceId: opts.resourceId },
+		page,
+		perPage,
+		orderBy: {
+			field: "updatedAt",
+			direction: "DESC"
+		}
+	});
+	const threads = result.threads.map(toWireThread);
+	log.debug("list:done", {
+		agentId: opts.agent.id,
+		resourceId: opts.resourceId,
+		page,
+		perPage,
+		returned: threads.length,
+		total: result.total,
+		hasMore: result.hasMore,
+		elapsedMs: Date.now() - startedAt
+	});
+	return {
+		threads,
+		page,
+		perPage,
+		total: result.total,
+		hasMore: result.hasMore
+	};
+}
+/**
+* Delete a single named thread (and every message on it).
+*
+* Ownership is enforced: the thread is only removed when it belongs to
+* the calling resource, so a client can't delete another user's
+* conversation by guessing its id. A thread that doesn't exist (or
+* isn't owned by the caller) is a successful no-op (`deleted: false`)
+* so the UI can fire-and-forget.
+*/
+async function deleteThread(opts) {
+	const memory = await opts.agent.getMemory();
+	if (!memory) {
+		log.debug("delete:no-memory", { agentId: opts.agent.id });
+		return { deleted: false };
+	}
+	const existing = await memory.getThreadById({ threadId: opts.threadId });
+	if (!existing || existing.resourceId !== opts.resourceId) {
+		log.debug("delete:not-owned", {
+			agentId: opts.agent.id,
+			threadId: opts.threadId,
+			found: existing !== null
+		});
+		return { deleted: false };
+	}
+	const startedAt = Date.now();
+	await memory.deleteThread(opts.threadId);
+	log.info("delete:done", {
+		agentId: opts.agent.id,
+		threadId: opts.threadId,
+		elapsedMs: Date.now() - startedAt
+	});
+	return { deleted: true };
+}
+/**
+* Register the `<path>` Mastra custom API route. Handles two methods
+* on the same mount:
+*
+*   - `GET`: a page of the resource's conversation threads
+*     ({@link listThreads}).
+*   - `DELETE`: remove the thread named by the thread-selection header
+*     / `?threadId=` query ({@link deleteThread}). The id is read from
+*     `RequestContext` (the auth middleware resolves it the same way it
+*     does for streaming and history), so the client deletes any of its
+*     threads by stamping the target id - no separate path param.
+*
+* Follows the `@mastra/ai-sdk` agent-binding convention: pass `agent`
+* for a fixed-agent mount, or include `:agentId` in the path for
+* dynamic routing. The plugin registers both `/route/threads` (default
+* agent) and `/route/threads/:agentId`.
+*/
+function threadsRoute(options) {
+	const { path } = options;
+	const fixedAgent = "agent" in options ? options.agent : void 0;
+	if (!fixedAgent && !path.includes(":agentId")) throw new Error("threadsRoute path must include `:agentId` or `agent` must be passed explicitly");
+	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 resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY);
+		if (!resourceId) return { error: c.json({ error: "resource id missing from request context" }, 400) };
+		return {
+			agentId,
+			agent,
+			requestContext,
+			resourceId
+		};
+	};
+	return [registerApiRoute(path, {
+		method: "GET",
+		handler: async (c) => {
+			const ctx = resolveContext(c);
+			if ("error" in ctx) return ctx.error;
+			const payload = await listThreads({
+				agent: ctx.agent,
+				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 threadId = ctx.requestContext.get(MASTRA_THREAD_ID_KEY);
+			if (!threadId) return c.json({ error: "thread id missing from request context" }, 400);
+			const { deleted } = await deleteThread({
+				agent: ctx.agent,
+				threadId,
+				resourceId: ctx.resourceId
+			});
+			const payload = {
+				ok: true,
+				agentId: ctx.agentId,
+				threadId,
+				deleted
+			};
+			return c.json(payload);
+		}
+	})];
+}
+/** Coerce a Mastra `StorageThreadType` into the JSON-safe wire shape. */
+function toWireThread(thread) {
+	return {
+		id: thread.id,
+		...thread.title ? { title: thread.title } : {},
+		resourceId: thread.resourceId,
+		createdAt: toIso(thread.createdAt),
+		updatedAt: toIso(thread.updatedAt),
+		...thread.metadata ? { metadata: thread.metadata } : {}
+	};
+}
+/** Render a storage timestamp as an ISO-8601 string for the wire. */
+function toIso(value) {
+	if (value instanceof Date) return value.toISOString();
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date(0)).toISOString() : parsed.toISOString();
+}
+/** Coerce / clamp `perPage`; falls back to the page-size default. */
+function clampPerPage(value) {
+	if (value === void 0 || Number.isNaN(value)) return DEFAULT_PER_PAGE;
+	const n = Math.trunc(value);
+	if (n <= 0) return DEFAULT_PER_PAGE;
+	return Math.min(n, MAX_PER_PAGE);
+}
+/**
+* Coerce a Hono query value into a non-negative integer. Returns
+* `undefined` for empty / non-numeric / negative inputs so
+* {@link listThreads} can apply its built-in defaults.
+*/
+function parseIntParam(value) {
+	if (!value) return void 0;
+	const n = Number(value);
+	if (!Number.isFinite(n) || n < 0) return void 0;
+	return Math.trunc(n);
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/plugin.ts
 /**
@@ -3000,9 +3819,10 @@ function attachRoutePatchMiddleware(app) {
 * - Server: the Express subapp wiring lives in `./server.js`.
 * - HTTP: AppKit mounts this plugin under `/api/mastra`. Alongside the
 *   Mastra agent routes, the plugin registers `/route/history`
-*   (load + clear thread history), `/models`, `/suggestions`, and the
-*   generic `/embed/:type/:id` resolver for inline chart / data
-*   markers.
+*   (load + clear a thread's messages), `/route/threads` (list the
+*   caller's conversations + delete one), `/models`, `/suggestions`,
+*   and the generic `/embed/:type/:id` resolver for inline chart /
+*   data markers.
 * - MCP: opt in with `config.mcp` to expose the agents (and optionally
 *   tools) as a Mastra `MCPServer`. It is registered on the `Mastra`
 *   instance via `mcpServers`, so `@mastra/express` serves the stock
@@ -3259,17 +4079,67 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 		const client = getExecutionContext().client;
 		return listServingEndpoints(client, (await client.config.getHost()).toString(), { ttlMs: resolveServingConfig(this.config).ttlMs });
 	}
+	/**
+	* Resolve and probe the Databricks Managed Memory backend at setup.
+	*
+	* Returns the runtime (store + recall sizing + tool / recall toggles)
+	* when managed memory is enabled and the workspace memory-stores API
+	* is reachable, else `undefined` so the caller uses the PgVector path.
+	*
+	* The probe runs as the service principal (setup is outside any
+	* `asUser` scope, so `getExecutionContext()` yields the SP client):
+	* the SP owns the store and is the identity that can `CREATE MEMORY
+	* STORE`. When `autoCreate` is on the store is created if missing.
+	*
+	* A misconfiguration where managed memory is explicitly enabled but no
+	* store name is resolvable throws ({@link resolveManagedMemoryTarget})
+	* - that is a wiring bug, not a runtime condition. Every other failure
+	* (feature unavailable, permission denied, network) is caught, logged,
+	* and degraded to a PgVector fallback so chat stays available.
+	*/
+	async resolveManagedMemory() {
+		const target = resolveManagedMemoryTarget(this.config);
+		if (!target) return void 0;
+		try {
+			const client = getExecutionContext().client;
+			if (!(target.autoCreate ? await ensureStore(client, target.storeName, target.description) : await getStore(client, target.storeName) !== null)) {
+				this.log.warn("managed-memory:unavailable; using PgVector fallback", { store: target.storeName });
+				return;
+			}
+			this.log.info("managed-memory:active", {
+				store: target.storeName,
+				topK: target.topK,
+				autoCreate: target.autoCreate
+			});
+			return {
+				storeName: target.storeName,
+				topK: target.topK,
+				entryPath: target.entryPath,
+				tools: target.tools,
+				recall: target.recall
+			};
+		} catch (err) {
+			this.log.warn("managed-memory:probe failed; using PgVector fallback", {
+				store: target.storeName,
+				error: commonUtils.errorMessage(err)
+			});
+			return;
+		}
+	}
 	async buildAgentAndServer() {
 		if (needsLakebase(this.config)) this.servicePrincipalPool = await createServicePrincipalPool(appkitUtils.require(this.context, lakebase, this.config).exports().getPgConfig());
-		const memoryBuilder = this.servicePrincipalPool ? createMemoryBuilder(this.config, this.servicePrincipalPool) : void 0;
+		const managedMemory = await this.resolveManagedMemory();
+		const memoryBuilder = this.servicePrincipalPool ? createMemoryBuilder(this.config, this.servicePrincipalPool, { suppressVector: managedMemory !== void 0 }) : void 0;
 		this.log.debug("build:start", {
 			lakebase: memoryBuilder !== void 0,
+			managedMemory: managedMemory !== void 0,
 			stripStaleCharts: this.config.stripStaleCharts !== false
 		});
 		this.built = await buildAgents({
 			config: this.config,
 			context: this.context,
 			memoryBuilder,
+			...managedMemory ? { managedMemory } : {},
 			log: this.log
 		});
 		const instanceStorage = memoryBuilder?.instanceStorage();
@@ -3293,10 +4163,18 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 			app: this.mastraApp,
 			mastra: this.mastra,
 			prefix: "",
-			customApiRoutes: [...historyRoute({
-				path: MASTRA_ROUTES.history,
-				agent: this.built.defaultAgentId
-			}), ...historyRoute({ path: `${MASTRA_ROUTES.history}/:agentId` })]
+			customApiRoutes: [
+				...historyRoute({
+					path: MASTRA_ROUTES.history,
+					agent: this.built.defaultAgentId
+				}),
+				...historyRoute({ path: `${MASTRA_ROUTES.history}/:agentId` }),
+				...threadsRoute({
+					path: MASTRA_ROUTES.threads,
+					agent: this.built.defaultAgentId
+				}),
+				...threadsRoute({ path: `${MASTRA_ROUTES.threads}/:agentId` })
+			]
 		});
 		await this.mastraServer.init();
 		this.log.debug("build:done", {
@@ -3304,6 +4182,7 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 			defaultAgent: this.built.defaultAgentId,
 			routes: [
 				"/route/history",
+				"/route/threads",
 				"/models",
 				"/suggestions",
 				"/embed/:type/:id"
@@ -3346,4 +4225,4 @@ function parseStatementLimit(raw) {
 const mastra = toPlugin(MastraPlugin);
 
 //#endregion
-export { DEFAULT_AGENT_MAX_STEPS, DEFAULT_GENIE_ALIAS, DEFAULT_STYLE_INSTRUCTIONS, FALLBACK_AGENT_ID, GENIE_INSTRUCTIONS, MASTRA_MODEL_OVERRIDE_KEY, MASTRA_REQUEST_ID_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, MASTRA_USER_NAME_KEY, MastraPlugin, TRACE_REQUEST_CONTEXT_KEYS, buildAgents, buildGenieToolkitProvider, buildGenieTools, buildMcpServer, buildRenderDataTool, chartPlannerRequestSchema, collectSpaceSuggestions, createAgent, createTool, extractModelOverride, fetchChart, mastra, normalizeGenieSpaces, prepareChart, resolveGenieSpaces, tool };
+export { DEFAULT_AGENT_MAX_STEPS, DEFAULT_ENTRY_PATH, DEFAULT_GENIE_ALIAS, DEFAULT_STORE_DESCRIPTION, DEFAULT_STYLE_INSTRUCTIONS, DEFAULT_TOPK, FALLBACK_AGENT_ID, GENIE_INSTRUCTIONS, MASTRA_MODEL_OVERRIDE_KEY, MASTRA_REQUEST_ID_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, MASTRA_USER_NAME_KEY, MEMORY_STORE_ENV, ManagedMemoryError, MastraPlugin, TRACE_REQUEST_CONTEXT_KEYS, buildAgents, buildGenieToolkitProvider, buildGenieTools, buildManagedMemoryTools, buildMcpServer, buildRenderDataTool, buildSummarizeTool, chartPlannerRequestSchema, collectSpaceSuggestions, createAgent, createTool, ensureStore, extractModelOverride, fetchChart, getStore, mastra, normalizeGenieSpaces, parseStoreName, prepareChart, renderEntry, resolveGenieSpaces, resolveManagedMemoryTarget, resolveMemoryContext, search, summarizeText, tool, writeEntry };