@dbx-tools/appkit-mastra 0.1.77 → 0.1.79

package/dist/index.js

@@ -338,7 +338,7 @@ function sanitizeServingMessages(messages) {
 * the demo client and any other UI consumer share the exact same
 * shape this module reads and writes.
 */
-const log$9 = logUtils.logger("mastra/chart");
+const log$7 = 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
@@ -594,7 +594,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$9.warn("write-error", {
+		log$7.warn("write-error", {
 			chartId: entry.chartId,
 			error: commonUtils.errorMessage(err)
 		});
@@ -609,7 +609,7 @@ async function readChart(chartId) {
 		const key = await chartCacheKey(chartId);
 		return await CacheManager.getInstanceSync().get(key) ?? void 0;
 	} catch (err) {
-		log$9.warn("read-error", {
+		log$7.warn("read-error", {
 			chartId,
 			error: commonUtils.errorMessage(err)
 		});
@@ -634,7 +634,7 @@ async function readChart(chartId) {
 async function prepareChart(opts) {
 	const chartId = commonUtils.id();
 	await writeChart({ chartId });
-	log$9.debug("queued", { chartId });
+	log$7.debug("queued", { chartId });
 	runPrepareChart(chartId, opts);
 	return { chartId };
 }
@@ -655,14 +655,14 @@ async function runPrepareChart(chartId, opts) {
 			chartId,
 			result
 		});
-		log$9.info("done", {
+		log$7.info("done", {
 			chartId,
 			chartType: result.chartType,
 			elapsedMs: Date.now() - startedAt
 		});
 	} catch (err) {
 		const error = commonUtils.errorMessage(err);
-		log$9.warn("error", {
+		log$7.warn("error", {
 			chartId,
 			error
 		});
@@ -849,338 +849,6 @@ function buildRenderDataTool(config) {
 	});
 }
 
-//#endregion
-//#region packages/appkit-mastra/src/rest.ts
-/**
-* Resolve the workspace host + an authenticated header set off the
-* client and issue a `fetch` against `path` (mounted on the host).
-* Runs as whatever identity the client carries - the per-request OBO
-* user when called from a request scope, the service principal
-* otherwise.
-*/
-async function databricksFetch(client, path, init) {
-	const host = (await client.config.getHost()).toString();
-	const headers = new Headers({
-		"Content-Type": "application/json",
-		...init.headers
-	});
-	await client.config.authenticate(headers);
-	const url = new URL(path, host).toString();
-	return fetch(url, {
-		method: init.method,
-		headers,
-		...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
-		...init.signal ? { signal: init.signal } : {}
-	});
-}
-/** Read a response body as text, swallowing read errors (returns `""`). */
-async function readResponseText(res) {
-	try {
-		return await res.text();
-	} catch {
-		return "";
-	}
-}
-/** Parse a response body as JSON, returning `{}` on empty / invalid bodies. */
-async function readResponseJson(res) {
-	const text = await readResponseText(res);
-	if (!text) return {};
-	try {
-		return JSON.parse(text);
-	} catch {
-		return {};
-	}
-}
-
-//#endregion
-//#region packages/appkit-mastra/src/connectors/managed-memory/client.ts
-/**
-* Thin REST client over the Databricks Unity Catalog Managed Agent
-* Memory API (Beta). There is no TS SDK for memory-stores yet, so this
-* issues authenticated requests through the shared {@link databricksFetch}
-* primitive (`rest.ts`) as whatever identity the caller's client carries
-* - the per-request OBO user for tools / recall, the service principal
-* for setup-time probes.
-*
-* Responses are parsed defensively: the Beta wire shape may still drift,
-* so the search parser tolerates missing / renamed entry fields and the
-* store probe maps a 404 to `null` rather than throwing.
-*/
-/** 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
-	};
-}
-/**
-* 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 databricksFetch(client, path, init);
-	if (!res.ok) throw new ManagedMemoryError(res.status, res.statusText, await readResponseText(res));
-	return readResponseJson(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 databricksFetch(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 readResponseText(res));
-	return readResponseJson(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 = stringUtils.firstNonEmpty([
-			obj["contents"],
-			obj["content"],
-			obj["text"]
-		]);
-		if (!contents) continue;
-		const path = stringUtils.firstNonEmpty(obj["path"]);
-		const description = stringUtils.firstNonEmpty([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;
-}
-
-//#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$8 = 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$8.debug("saved", { scope: ctx.scope });
-					return "Saved to memory.";
-				} catch (err) {
-					log$8.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$8.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
 /**
@@ -1303,7 +971,7 @@ async function safeWrite(log, writer, chunk, context = {}) {
 * `instructions` when you want the canonical "how to drive the
 * Genie tools" guidance.
 */
-const log$7 = 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";
 /**
@@ -1418,7 +1086,7 @@ async function readCachedConversationId(cacheKey) {
 	try {
 		return await CacheManager.getInstanceSync().get(cacheKey) ?? void 0;
 	} catch (err) {
-		log$7.warn("conversation-cache:read-error", { error: commonUtils.errorMessage(err) });
+		log$6.warn("conversation-cache:read-error", { error: commonUtils.errorMessage(err) });
 		return;
 	}
 }
@@ -1434,7 +1102,7 @@ async function saveCachedConversationId(cacheKey, conversationId) {
 	try {
 		await CacheManager.getInstanceSync().set(cacheKey, conversationId, { ttl: CONVERSATION_TTL_SEC });
 	} catch (err) {
-		log$7.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. */
@@ -1443,7 +1111,7 @@ async function evictCachedConversationId(cacheKey) {
 	try {
 		await CacheManager.getInstanceSync().delete(cacheKey);
 	} catch (err) {
-		log$7.warn("conversation-cache:delete-error", { error: commonUtils.errorMessage(err) });
+		log$6.warn("conversation-cache:delete-error", { error: commonUtils.errorMessage(err) });
 	}
 }
 /**
@@ -1557,7 +1225,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$7, writer, {
+			await safeWrite(log$6, writer, {
 				type: "started",
 				spaceId,
 				content: question
@@ -1570,7 +1238,7 @@ function buildAskGenieTool(opts) {
 					...seedConversationId ? { conversationId: seedConversationId } : {},
 					...signal ? { context: signal } : {}
 				})) {
-					if (event.type !== "message") await safeWrite(log$7, 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;
@@ -1584,7 +1252,7 @@ function buildAskGenieTool(opts) {
 			} catch (err) {
 				const seeded = readContextConversationId(requestContext, spaceId);
 				if (seeded && apiUtils.isNotFoundError(err)) {
-					log$7.warn("conversation-cache:stale, resetting", {
+					log$6.warn("conversation-cache:stale, resetting", {
 						spaceId,
 						conversationId: seeded,
 						error: commonUtils.errorMessage(err)
@@ -2069,7 +1737,7 @@ async function collectSpaceSuggestions(opts) {
 			}));
 			writeSuggestionCache(spaceId, questions);
 		} catch (err) {
-			log$7.warn("suggestions:fetch-error", {
+			log$6.warn("suggestions:fetch-error", {
 				spaceId,
 				error: commonUtils.errorMessage(err)
 			});
@@ -2086,107 +1754,41 @@ async function collectSpaceSuggestions(opts) {
 }
 
 //#endregion
-//#region packages/appkit-mastra/src/processor.ts
-var ResultProcessor = class {
-	id = "result-processor";
-	processDataParts = true;
-	async processOutputStream({ part }) {
-		if (!part || typeof part !== "object") return part;
-		if (![
-			"step-finish",
-			"finish",
-			"tool-result",
-			"data-tool-agent"
-		].includes(part.type)) return part;
-		const payload = part.payload;
-		if (!payload || typeof payload !== "object") return part;
-		for (const key of [
-			"output",
-			"messages",
-			"response",
-			"result"
-		]) if (key in payload) {
-			const value = payload[key];
-			if (typeof value === "object") payload[key] = {};
-			else if (Array.isArray(value)) payload[key] = [];
-			else delete payload[key];
-		}
-		return part;
-	}
-};
-
-//#endregion
-//#region packages/appkit-mastra/src/processors/managed-memory-recall.ts
+//#region packages/appkit-mastra/src/processors.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.
+* Mastra stream processors wired onto the plugin's agents.
+*
+* Two complementary processors live here:
 *
-* 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.
+* - An **input** processor ({@link stripStaleChartsProcessor}) that
+*   scrubs turn-scoped `chartId` fields out of prior tool results
+*   replayed from Memory, so the model can't copy a stale id into the
+*   new turn's `[chart:<id>]` markers.
+* - An **output** processor ({@link ResultProcessor}) that trims the
+*   bulky, redundant payload fields off targeted outbound stream frames
+*   before they're serialized to the SSE client.
 */
-const log$6 = logUtils.logger("mastra/processor/managed-memory-recall");
+const log$5 = logUtils.logger("mastra/processors");
 /**
-* 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}.
+* Recursively clone `value`, omitting any property whose key is
+* `chartId`. Arrays are mapped element-wise; primitives are
+* returned as-is. The result is structurally identical to the
+* input minus chartIds, so downstream message-shape consumers
+* keep working.
 */
-function 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$6.debug("recalled", {
-					scope: ctx.scope,
-					entries: entries.length
-				});
-				return {
-					messages: args.messages,
-					systemMessages: [...args.systemMessages, {
-						role: "system",
-						content: block
-					}]
-				};
-			} catch (err) {
-				log$6.warn("recall:error", { error: commonUtils.errorMessage(err) });
-				return args.messages;
-			}
+function stripChartIds(value) {
+	if (Array.isArray(value)) return value.map(stripChartIds);
+	if (value && typeof value === "object") {
+		const obj = value;
+		const out = {};
+		for (const [key, val] of Object.entries(obj)) {
+			if (key === "chartId") continue;
+			out[key] = stripChartIds(val);
 		}
-	};
-}
-/**
-* 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 out;
 	}
-	return null;
+	return value;
 }
-
-//#endregion
-//#region packages/appkit-mastra/src/processors/strip-stale-charts.ts
 /**
 * Mastra input processor that strips `chartId` fields from every
 * tool-invocation result in prior assistant messages before they
@@ -2210,32 +1812,8 @@ function latestUserText(messages) {
 * `prepare_chart` / `render_data` top-level chartIds and any
 * legacy `datasets[].chartId` payloads uniformly without coupling
 * to specific tool ids.
-*/
-const log$5 = logUtils.logger("mastra/processor/strip-stale-charts");
-/**
-* Recursively clone `value`, omitting any property whose key is
-* `chartId`. Arrays are mapped element-wise; primitives are
-* returned as-is. The result is structurally identical to the
-* input minus chartIds, so downstream message-shape consumers
-* keep working.
-*/
-function stripChartIds(value) {
-	if (Array.isArray(value)) return value.map(stripChartIds);
-	if (value && typeof value === "object") {
-		const obj = value;
-		const out = {};
-		for (const [key, val] of Object.entries(obj)) {
-			if (key === "chartId") continue;
-			out[key] = stripChartIds(val);
-		}
-		return out;
-	}
-	return value;
-}
-/**
-* Input processor that scrubs `chartId` from every tool-invocation
-* result in the message list. Wired onto every agent by default
-* via {@link buildAgents}; opt out with
+*
+* Wired onto every agent by default via `buildAgents`; opt out with
 * `MastraPluginConfig.stripStaleCharts: false`.
 */
 const stripStaleChartsProcessor = {
@@ -2263,6 +1841,44 @@ const stripStaleChartsProcessor = {
 		return args.messages;
 	}
 };
+/**
+* Mastra output processor that trims the bulky, redundant payload
+* fields off targeted outbound stream frames.
+*
+* Mastra emits step / finish / tool-result frames whose payloads
+* echo the full tool `output` / `result` / assistant `messages` /
+* `response` - data the chat client already received inline and
+* doesn't need re-sent. This processor empties those keys on the
+* targeted frame types so the outbound SSE stream stays lean;
+* every other frame passes through untouched.
+*/
+var ResultProcessor = class {
+	id = "result-processor";
+	processDataParts = true;
+	async processOutputStream({ part }) {
+		if (!part || typeof part !== "object") return part;
+		if (![
+			"step-finish",
+			"finish",
+			"tool-result",
+			"data-tool-agent"
+		].includes(part.type)) return part;
+		const payload = part.payload;
+		if (!payload || typeof payload !== "object") return part;
+		for (const key of [
+			"output",
+			"messages",
+			"response",
+			"result"
+		]) if (key in payload) {
+			const value = payload[key];
+			if (typeof value === "object") payload[key] = {};
+			else if (Array.isArray(value)) payload[key] = [];
+			else delete payload[key];
+		}
+		return part;
+	}
+};
 
 //#endregion
 //#region packages/appkit-mastra/src/summarize.ts
@@ -2536,6 +2152,15 @@ function composeInstructions(agentInstructions, style) {
 	return `${agentInstructions.trimEnd()}\n\n${style}`;
 }
 /**
+* Generated description for an agent whose definition omits one. Kept
+* generic (the agent's own name is the only reliable signal at build
+* time) so it reads sensibly as the `ask_<id>` MCP tool's description
+* and in agent metadata.
+*/
+function defaultAgentDescription(name) {
+	return `Conversational AI agent "${name}".`;
+}
+/**
 * Resolve every entry in `config.agents` into a Mastra `Agent`
 * instance. When `config.agents` is omitted the plugin registers a
 * single built-in `default` analyst so the bare `mastra()` call still
@@ -2549,24 +2174,19 @@ function composeInstructions(agentInstructions, style) {
 *   resolved registry; this is a wiring bug, not a runtime condition.
 */
 async function buildAgents(opts) {
-	const { config, context, memoryBuilder, managedMemory, log } = opts;
+	const { config, context, memoryBuilder, 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 systemTools = {
-		render_data: buildRenderDataTool(config),
-		summarize: buildSummarizeTool(config)
-	};
-	const managedMemoryTools = managedMemory?.tools ? buildManagedMemoryTools(managedMemory) : {};
 	const ambientTools = {
-		...systemTools,
-		...managedMemoryTools,
+		render_data: buildRenderDataTool(config),
+		summarize: buildSummarizeTool(config),
 		...config.tools ?? {}
 	};
 	const style = resolveStyleInstructions(config);
 	const outputProcessors = [new ResultProcessor()];
-	const inputProcessors = [...config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor], ...managedMemory?.recall ? [buildManagedMemoryRecallProcessor(managedMemory)] : []];
+	const inputProcessors = [...config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor]];
 	const agents = {};
 	for (const [id, def] of Object.entries(definitions)) {
 		const tools = await resolveTools(def.tools, plugins, ambientTools);
@@ -2574,7 +2194,7 @@ async function buildAgents(opts) {
 		agents[id] = new Agent({
 			id,
 			name: def.name ?? id,
-			...def.description !== void 0 ? { description: def.description } : {},
+			description: def.description?.trim() || defaultAgentDescription(def.name ?? id),
 			instructions: composeInstructions(def.instructions, style),
 			model: resolveModel(config, def.model),
 			defaultOptions: { maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS },
@@ -2811,90 +2431,30 @@ 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. */
 const DEFAULT_MCP_VERSION = "1.0.0";
 /**
-* Build the plugin's MCP server, or `null` when `config.mcp` is falsy
-* (the default - no MCP endpoints).
+* Build the plugin's MCP server, or `null` only when `config.mcp` is
+* explicitly `false`.
 *
-* `true` exposes every registered agent as an `ask_<agentId>` MCP tool
-* under a server id equal to the plugin name. 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.
+* 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.
 */
 function buildMcpServer(opts) {
 	const { config, pluginName, displayName, agents, ambientTools } = opts;
-	if (!config.mcp) return null;
-	const settings = config.mcp === true ? {} : config.mcp;
+	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 tools = {
@@ -2911,9 +2471,9 @@ function buildMcpServer(opts) {
 			...exposeAgents ? { agents } : {},
 			tools
 		}),
-		httpPath: `/mcp/${serverId}/mcp`,
-		ssePath: `/mcp/${serverId}/sse`,
-		messagePath: `/mcp/${serverId}/messages`
+		httpPath: "/mcp",
+		ssePath: "/sse",
+		messagePath: "/messages"
 	};
 }
 
@@ -3231,8 +2791,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, options = {}) {
-	return new MemoryBuilder(config, servicePrincipalPool, options);
+function createMemoryBuilder(config, servicePrincipalPool) {
+	return new MemoryBuilder(config, servicePrincipalPool);
 }
 /**
 * Builds one `Memory` per agent against a shared service-principal
@@ -3241,18 +2801,11 @@ function createMemoryBuilder(config, servicePrincipalPool, options = {}) {
 */
 var MemoryBuilder = class {
 	sharedVector;
-	constructor(config, servicePrincipalPool, options = {}) {
+	constructor(config, servicePrincipalPool) {
 		this.config = config;
 		this.servicePrincipalPool = servicePrincipalPool;
-		this.options = options;
 	}
 	/**
-	* 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.
-	*/
-	/**
 	* 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
@@ -3273,6 +2826,12 @@ var MemoryBuilder = class {
 			pool: this.servicePrincipalPool
 		});
 	}
+	/**
+	* 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, def) {
 		const storageSetting = def.storage ?? this.config.storage;
 		const memorySetting = def.memory ?? this.config.memory;
@@ -3326,7 +2885,6 @@ 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);
@@ -3394,6 +2952,49 @@ function withId(value, fallback) {
 	};
 }
 
+//#endregion
+//#region packages/appkit-mastra/src/rest.ts
+/**
+* Resolve the workspace host + an authenticated header set off the
+* client and issue a `fetch` against `path` (mounted on the host).
+* Runs as whatever identity the client carries - the per-request OBO
+* user when called from a request scope, the service principal
+* otherwise.
+*/
+async function databricksFetch(client, path, init) {
+	const host = (await client.config.getHost()).toString();
+	const headers = new Headers({
+		"Content-Type": "application/json",
+		...init.headers
+	});
+	await client.config.authenticate(headers);
+	const url = new URL(path, host).toString();
+	return fetch(url, {
+		method: init.method,
+		headers,
+		...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
+		...init.signal ? { signal: init.signal } : {}
+	});
+}
+/** Read a response body as text, swallowing read errors (returns `""`). */
+async function readResponseText(res) {
+	try {
+		return await res.text();
+	} catch {
+		return "";
+	}
+}
+/** Parse a response body as JSON, returning `{}` on empty / invalid bodies. */
+async function readResponseJson(res) {
+	const text = await readResponseText(res);
+	if (!text) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+}
+
 //#endregion
 //#region packages/appkit-mastra/src/mlflow.ts
 /**
@@ -4226,6 +3827,14 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 		return resolveFeedbackEnabled(this.config.feedback);
 	}
 	injectRoutes(router) {
+		router.use((req, _res, next) => {
+			const target = this.mcpRouteAlias(req.path);
+			if (target) {
+				const q = req.url.indexOf("?");
+				req.url = q >= 0 ? target + req.url.slice(q) : target;
+			}
+			next();
+		});
 		router.get(MASTRA_ROUTES.models, (req, res, next) => {
 			this.userScopedSelf(req).listModels().then((endpoints) => res.json({ endpoints })).catch(next);
 		});
@@ -4299,7 +3908,7 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 			if (!this.mastraApp) return res.status(503).end();
 			if (!isMastraRequestAllowed(req.method, req.path, {
 				access: this.config.apiAccess ?? "scoped",
-				mcpEnabled: Boolean(this.config.mcp)
+				mcpEnabled: this.mcp !== null
 			})) {
 				res.status(403).json({ error: "Endpoint not exposed to the client (apiAccess=scoped)" });
 				return;
@@ -4320,6 +3929,21 @@ var MastraPlugin = class MastraPlugin extends Plugin {
 		this.mastraApp(req, res, next);
 	}
 	/**
+	* Map a clean, mount-relative MCP alias path to the underlying
+	* `@mastra/express` route. Returns `null` when MCP is off or the path
+	* isn't an alias. Collapses the stock `/mcp/<serverId>/<transport>`
+	* layout (serverId defaults to the plugin name) down to `/mcp`,
+	* `/sse`, and `/messages`.
+	*/
+	mcpRouteAlias(path) {
+		if (!this.mcp) return null;
+		const id = this.mcp.serverId;
+		if (path === "/mcp") return `/mcp/${id}/mcp`;
+		if (path === "/sse") return `/mcp/${id}/sse`;
+		if (path === "/messages") return `/mcp/${id}/messages`;
+		return null;
+	}
+	/**
 	* Implementation backing the `/suggestions` route. Runs inside the
 	* AppKit user-context proxy so `getExecutionContext()` returns the
 	* OBO-scoped client. Resolves the plugin's Genie spaces and merges
@@ -4404,67 +4028,17 @@ 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 managedMemory = await this.resolveManagedMemory();
-		const memoryBuilder = this.servicePrincipalPool ? createMemoryBuilder(this.config, this.servicePrincipalPool, { suppressVector: managedMemory !== void 0 }) : void 0;
+		const memoryBuilder = this.servicePrincipalPool ? createMemoryBuilder(this.config, this.servicePrincipalPool) : 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();
@@ -4551,4 +4125,4 @@ function parseStatementLimit(raw) {
 const mastra = toPlugin(MastraPlugin);
 
 //#endregion
-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 };
+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, buildSummarizeTool, chartPlannerRequestSchema, collectSpaceSuggestions, createAgent, createTool, extractModelOverride, fetchChart, mastra, normalizeGenieSpaces, prepareChart, resolveGenieSpaces, summarizeText, tool };