@mastra/server 1.60.0-alpha.1 → 1.60.0-alpha.11

package/dist/server/handlers/agent-controller.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../rolldown-runtime-Bd6kNlEP.cjs");
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_route_builder = require("../../route-builder-BAAedfru.cjs");
+const require_route_builder = require("../../route-builder-CWsok5ci.cjs");
 const require_server_handlers_error = require("./error.cjs");
 let zod_v4 = require("zod/v4");
 //#region src/server/handlers/agent-controller.ts
@@ -21,11 +22,22 @@ let zod_v4 = require("zod/v4");
 * usage). They share the flat thread `metadata` bag with user-provided session
 * scoping tags, so they must never be treated as tags here.
 *
-* Mirrors core's `isReservedThreadMetadataKey`; kept local because importing the
-* value from `@mastra/core` would exceed this package's peer-dependency floor.
+* Importing core's list as a value would exceed this package's peer-dependency
+* floor, so it is mirrored under `satisfies`: tsc rejects a missing or extra key.
 */
+const RESERVED_THREAD_METADATA_KEYS = {
+	currentModelId: true,
+	currentModeId: true,
+	observerModelId: true,
+	reflectorModelId: true,
+	observationThreshold: true,
+	reflectionThreshold: true,
+	tokenUsage: true,
+	thinkingLevel: true,
+	notifications: true
+};
 function isReservedThreadMetadataKey(key) {
-	return key === "currentModelId" || key === "currentModeId" || key === "observerModelId" || key === "reflectorModelId" || key === "observationThreshold" || key === "reflectionThreshold" || key === "tokenUsage" || key.startsWith("modeModelId_");
+	return Object.hasOwn(RESERVED_THREAD_METADATA_KEYS, key) || key.startsWith("modeModelId_");
 }
 /**
 * Resolves a controller by id via the canonical `mastra.getAgentController`
@@ -94,6 +106,7 @@ const sessionPathParams = zod_v4.z.object({
 * on session routes; named to avoid colliding with the model-switch `scope`.
 */
 const sessionScopeQuerySchema = zod_v4.z.object({ sessionScope: zod_v4.z.string().optional() });
+const sessionStateQuerySchema = sessionScopeQuerySchema.extend({ threadId: zod_v4.z.string().optional() });
 const createSessionBodySchema = zod_v4.z.object({
 	resourceId: zod_v4.z.string(),
 	tags: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
@@ -219,6 +232,17 @@ const omProgressSummarySchema = zod_v4.z.object({
 	/** Tokens the next reflection is projected to save. */
 	projectedReflectionSavings: zod_v4.z.number()
 });
+const tokenUsageSchema = zod_v4.z.object({
+	promptTokens: zod_v4.z.number(),
+	completionTokens: zod_v4.z.number(),
+	totalTokens: zod_v4.z.number(),
+	reasoningTokens: zod_v4.z.number().optional(),
+	cachedInputTokens: zod_v4.z.number().optional(),
+	cacheCreationInputTokens: zod_v4.z.number().optional(),
+	cacheCreationInputTokens5m: zod_v4.z.number().optional(),
+	cacheCreationInputTokens1h: zod_v4.z.number().optional(),
+	raw: zod_v4.z.unknown().optional()
+});
 const sessionSettingsSchema = zod_v4.z.object({
 	yolo: zod_v4.z.boolean(),
 	/** Session override only — absent when the session inherits a configured default. */
@@ -238,6 +262,16 @@ const sessionSettingsSchema = zod_v4.z.object({
 	]),
 	smartEditing: zod_v4.z.boolean()
 });
+const taskSnapshotSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	content: zod_v4.z.string(),
+	status: zod_v4.z.enum([
+		"pending",
+		"in_progress",
+		"completed"
+	]),
+	activeForm: zod_v4.z.string()
+});
 const sessionStateResponseSchema = zod_v4.z.object({
 	controllerId: zod_v4.z.string(),
 	resourceId: zod_v4.z.string(),
@@ -246,8 +280,9 @@ const sessionStateResponseSchema = zod_v4.z.object({
 	modelId: zod_v4.z.string(),
 	/** Whether the agent is currently executing a run (for initial UI hydration). */
 	running: zod_v4.z.boolean().optional(),
+	tasks: zod_v4.z.array(taskSnapshotSchema).optional(),
 	omProgress: omProgressSummarySchema.optional(),
-	tokenUsage: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional(),
+	tokenUsage: tokenUsageSchema.optional(),
 	settings: sessionSettingsSchema.optional()
 });
 const listModesResponseSchema = zod_v4.z.object({ modes: zod_v4.z.array(zod_v4.z.object({
@@ -375,31 +410,24 @@ const CREATE_AGENT_CONTROLLER_SESSION_ROUTE = require_route_builder.createRoute(
 	}
 });
 /**
-* Session `error` events carry an `Error` instance whose `message`/`name` are
-* non-enumerable, so JSON serialization in the SSE adapter would send
-* `"error": {}` and clients could only render a generic "Error". Flatten the
-* Error into a plain object so the actual failure reaches the client.
+* An `Error`'s `message`/`name` are non-enumerable, so JSON serialization in the
+* SSE adapter would send `"error": {}` and clients could only render a generic
+* "Error". Flatten it so the actual failure reaches the client, on every event
+* that carries one (`error`, `workspace_error`, `workspace_status_changed`).
 *
 * `display_state_changed` Maps JSON-serialize to `{}`; convert them to plain
 * records so wire clients get the tool state the in-process TUI sees.
 */
 function toWireEvent(event) {
-	if (typeof event !== "object" || event === null) return event;
-	const { type } = event;
-	if (type === "error" && event.error instanceof Error) {
-		const error = event.error;
-		return {
-			...event,
-			error: {
-				name: error.name,
-				message: error.message
-			}
-		};
-	}
-	if (type === "display_state_changed") {
-		const { displayState } = event;
-		if (typeof displayState !== "object" || displayState === null) return event;
-		const wireDisplayState = { ...displayState };
+	if ("error" in event && event.error instanceof Error) return {
+		...event,
+		error: {
+			name: event.error.name,
+			message: event.error.message
+		}
+	};
+	if (event.type === "display_state_changed") {
+		const wireDisplayState = { ...event.displayState };
 		for (const [key, value] of Object.entries(wireDisplayState)) if (value instanceof Map) wireDisplayState[key] = Object.fromEntries(value);
 		return {
 			...event,
@@ -693,17 +721,32 @@ const GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = require_route_builder.createRou
 	path: "/agent-controller/:controllerId/sessions/:resourceId",
 	responseType: "json",
 	pathParamSchema: sessionPathParams,
-	queryParamSchema: sessionScopeQuerySchema,
+	queryParamSchema: sessionStateQuerySchema,
 	responseSchema: sessionStateResponseSchema,
 	summary: "Get session state",
-	description: "Returns the current mode, model, and thread for the session (for initial UI hydration).",
+	description: "Returns the current mode, model, thread, and durable tasks for initial UI hydration.",
 	tags: ["AgentController"],
 	requiresAuth: true,
 	requiresPermission: "agent-controller:read",
-	handler: async ({ mastra, controllerId, resourceId, sessionScope, requestContext }) => {
+	handler: async ({ mastra, controllerId, resourceId, sessionScope, threadId: requestedThreadId, requestContext }) => {
 		try {
 			const session = await getSession(getAgentControllerOrThrow(mastra, controllerId), resourceId, { scope: sessionScope }, requestContext);
 			const ds = session.displayState.get();
+			const threadId = requestedThreadId ?? session.thread.getId() ?? void 0;
+			const storage = mastra.getStorage();
+			if (requestedThreadId) {
+				if (!await (await storage?.getStore("memory"))?.getThreadById({
+					threadId: requestedThreadId,
+					resourceId
+				})) throw new require_http_exception.HTTPException(404, { message: `thread "${requestedThreadId}" not found` });
+			}
+			const threadState = threadId ? await storage?.getStore("threadState") : void 0;
+			const storedTasks = threadId ? await threadState?.getState({
+				threadId,
+				type: "task"
+			}) : void 0;
+			const parsedTasks = taskSnapshotSchema.array().safeParse(storedTasks);
+			const tasks = parsedTasks.success ? parsedTasks.data : [];
 			const om = ds.omProgress;
 			const reflectionSavings = om.buffered.reflection.inputObservationTokens - om.buffered.reflection.observationTokens;
 			const st = session.state.get();
@@ -712,10 +755,11 @@ const GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE = require_route_builder.createRou
 			return {
 				controllerId,
 				resourceId,
-				threadId: session.thread.getId() ?? void 0,
+				threadId,
 				modeId: session.mode.get(),
 				modelId: session.model.get(),
 				running: ds.isRunning === true,
+				tasks,
 				omProgress: {
 					status: om.status,
 					pendingTokens: om.pendingTokens,