zidane 6.4.4 → 6.5.1

package/dist/restate.js

@@ -1,6 +1,7 @@
-import { n as buildAliasMaps } from "./aliasing-lVFbm81n.js";
-import { r as coerceToolResultContent } from "./types-BIarq1qE.js";
-import { i as stagedToolState, l as hydrateReadStateFromSessionAsync, r as isToolStateOps } from "./tool-state-DTs-3ZHH.js";
+import { L as buildAliasMaps } from "./openai-compat-CnHeo4Lz.js";
+import { c as toolOutputByteLength, l as toolResultToText, r as coerceToolResultContent } from "./types-BIarq1qE.js";
+import { Dt as reserveChildLabel, Ln as hydrateReadStateFromSessionAsync, a as stagedToolState, i as isToolStateOps } from "./agent-BVNkC1h4.js";
+import { r as formatTokenUsage } from "./stats-DAKBEKjc.js";
 import { createHash } from "node:crypto";
 //#region src/restate/awakeable.ts
 /**
@@ -182,7 +183,8 @@ function restateClock(ctx, options = {}) {
 	const randomUUID = () => deterministicUuid(`${idSeed}:uuid:${idSeq++}`);
 	if (!coalesce) return {
 		now: () => ctx.date.now(),
-		randomUUID
+		randomUUID,
+		journaled: true
 	};
 	const requested = typeof coalesce === "object" ? coalesce.reanchorEvery : void 0;
 	const reanchorEvery = typeof requested === "number" && Number.isFinite(requested) && requested >= 1 ? Math.floor(requested) : DEFAULT_REANCHOR_EVERY;
@@ -201,7 +203,8 @@ function restateClock(ctx, options = {}) {
 			lastReturned = value;
 			return value;
 		},
-		randomUUID
+		randomUUID,
+		journaled: true
 	};
 }
 //#endregion
@@ -567,7 +570,7 @@ function wrapAgentTools(tools, ctx, opts = {}) {
 	const excludeSet = new Set(opts.exclude ?? []);
 	const skipWaitTask = opts.detachedTasks === "durable";
 	const wrapped = {};
-	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
+	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || def.runsNestedAgent === true || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
 	return wrapped;
 }
 //#endregion
@@ -965,6 +968,459 @@ function maxDefined(values) {
 	return max;
 }
 //#endregion
+//#region src/restate/spawn.ts
+const ZERO_STATS = {
+	totalIn: 0,
+	totalOut: 0,
+	totalCacheRead: 0,
+	totalCacheCreation: 0,
+	turns: 0,
+	elapsed: 0
+};
+const DEFAULT_DESCRIPTION = "Delegate a self-contained task to a sub-agent that runs independently and returns only its final report. Several spawn calls in one turn run in parallel.";
+function restateSpawnTool(options) {
+	const persist = options.persist ?? true;
+	const emitEvents = options.emitChildEvents ?? true;
+	let dispatchSeq = 0;
+	let sessionlessLabels = 0;
+	let cancelSignalled = false;
+	let nestedLabels = 0;
+	const pending = [];
+	const drainRegistered = /* @__PURE__ */ new WeakSet();
+	/**
+	* Build the request and the bookkeeping entry. Deliberately side-effect free
+	* apart from reserving the label: the fleet path has to be able to reject a
+	* misconfigured `dispatch` (below) without leaving a phantom child queued for
+	* the merge. `commit` is what actually enrols the child.
+	*/
+	function prepare(input, ctx) {
+		const task = String(input.task ?? "");
+		const depth = (ctx.depth ?? 0) + 1;
+		const label = ctx.session ? reserveChildLabel(ctx.session) : `child-${++sessionlessLabels}`;
+		return {
+			entry: {
+				order: ++dispatchSeq,
+				label,
+				task,
+				depth,
+				callId: ctx.callId,
+				runId: `${ctx.runId ?? "run"}-${label}`,
+				...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
+				...ctx.session !== void 0 ? { session: ctx.session } : {}
+			},
+			req: {
+				task,
+				label,
+				depth,
+				...ctx.runId !== void 0 ? { parentRunId: ctx.runId } : {},
+				parentCallId: ctx.callId,
+				...ctx.session !== void 0 ? { sessionId: ctx.session.id } : {},
+				...typeof input.model === "string" ? { model: input.model } : {},
+				...typeof input.subagent_type === "string" ? { subagentType: input.subagent_type } : {}
+			}
+		};
+	}
+	/** Enrol a dispatched child for merging, and announce it. */
+	function commit(entry, input, ctx) {
+		pending.push(entry);
+		registerDrain(ctx);
+		watchAbort(entry, ctx);
+		Promise.resolve(ctx.hooks.callHook("spawn:before", {
+			id: entry.label,
+			task: entry.task,
+			callId: entry.callId,
+			depth: entry.depth,
+			...typeof input.model === "string" ? { model: input.model } : {}
+		})).catch(() => {});
+	}
+	function registerDrain(ctx) {
+		if (drainRegistered.has(ctx.hooks)) return;
+		drainRegistered.add(ctx.hooks);
+		ctx.hooks.hook("tool-results:after", async () => {
+			await drain(ctx);
+		});
+		ctx.hooks.hook("turn:after", async () => {
+			await drain(ctx);
+		});
+	}
+	/**
+	* Persist finished children and announce them. Runs where awaiting is legal,
+	* in submission order rather than settlement order, so two children that
+	* complete out of order still land deterministically.
+	*/
+	async function drain(ctx) {
+		if (pending.length === 0) return;
+		const batch = pending.splice(0, pending.length).sort((a, b) => a.order - b.order);
+		let touchedSession;
+		for (const entry of batch) {
+			const result = entry.result;
+			const stats = result?.stats ?? ZERO_STATS;
+			const status = result?.status ?? (entry.cancelRequested ? "aborted" : "error");
+			const session = entry.session;
+			if (persist && session) {
+				touchedSession = session;
+				session.startRun(entry.runId, entry.task, {
+					...entry.parentRunId !== void 0 ? { parentRunId: entry.parentRunId } : {},
+					depth: entry.depth,
+					label: entry.label
+				});
+				if (result && result.turns.length > 0) await session.appendTurns(result.turns.map((turn) => ({
+					...turn,
+					runId: entry.runId
+				})));
+				const rollup = {
+					turns: stats.turns,
+					tokensIn: stats.totalIn,
+					tokensOut: stats.totalOut,
+					...stats.cost !== void 0 ? { cost: stats.cost } : {}
+				};
+				if (status === "completed") session.completeRun(entry.runId, rollup);
+				else if (status === "error") session.errorRun(entry.runId, errorText(entry), rollup);
+				else session.abortRun(entry.runId, rollup);
+				stampJournaledRunTimes(session, entry, result);
+			}
+			if (emitEvents && result) await replayChildEvents(entry, result.turns, ctx);
+			if (result?.children && result.children.length > 0) {
+				const merged = await mergeDescendants(entry, result.children, ctx);
+				if (merged) touchedSession = merged;
+			}
+			options.onChildMerged?.({
+				label: entry.label,
+				task: entry.task,
+				depth: entry.depth,
+				status,
+				stats,
+				turns: result?.turns ?? [],
+				...result?.startedAt !== void 0 ? { startedAt: result.startedAt } : {},
+				...result?.endedAt !== void 0 ? { endedAt: result.endedAt } : {},
+				...result?.children !== void 0 ? { children: result.children } : {}
+			}, ctx);
+			if (status === "error") await ctx.hooks.callHook("spawn:error", {
+				id: entry.label,
+				task: entry.task,
+				error: new Error(errorText(entry)),
+				depth: entry.depth
+			});
+			await ctx.hooks.callHook("spawn:complete", {
+				id: entry.label,
+				task: entry.task,
+				callId: entry.callId,
+				depth: entry.depth,
+				status,
+				stats,
+				...result?.text ? { text: result.text } : {}
+			});
+		}
+		await touchedSession?.save();
+	}
+	/**
+	* Merge a child's own descendants under it, depth-first and in the order the
+	* child reported them.
+	*
+	* Each nested child is RE-LABELED from the merging session's counter: the
+	* label it arrived with was minted by its own parent's counter and would
+	* collide (every level starts at `child-1`). Re-labeling keeps the session's
+	* labels unique and makes the synthesized events agree with the persisted
+	* tree.
+	*/
+	async function mergeDescendants(parent, nested, ctx) {
+		let touched;
+		const session = parent.session;
+		for (const child of nested) {
+			const depth = parent.depth + 1;
+			const label = session ? reserveChildLabel(session) : `${parent.runId}-nested-${++nestedLabels}`;
+			const runId = `${parent.runId}-${label}`;
+			if (persist && session) {
+				touched = session;
+				session.startRun(runId, child.task, {
+					parentRunId: parent.runId,
+					depth,
+					label
+				});
+				if (child.turns.length > 0) await session.appendTurns(child.turns.map((turn) => ({
+					...turn,
+					runId
+				})));
+				const rollup = {
+					turns: child.stats.turns,
+					tokensIn: child.stats.totalIn,
+					tokensOut: child.stats.totalOut,
+					...child.stats.cost !== void 0 ? { cost: child.stats.cost } : {}
+				};
+				if (child.status === "completed") session.completeRun(runId, rollup);
+				else if (child.status === "error") session.errorRun(runId, "sub-agent failed", rollup);
+				else session.abortRun(runId, rollup);
+				const record = session.runs.find((run) => run.id === runId);
+				if (record) {
+					const startedAt = child.startedAt ?? child.turns[0]?.createdAt;
+					const endedAt = child.endedAt ?? child.turns[child.turns.length - 1]?.createdAt ?? startedAt;
+					if (startedAt !== void 0) record.startedAt = startedAt;
+					if (endedAt !== void 0) record.endedAt = endedAt;
+				}
+			}
+			if (emitEvents) await replayChildEvents({
+				label,
+				depth,
+				runId,
+				callId: parent.callId,
+				...parent.runId ? { parentRunId: parent.runId } : {}
+			}, child.turns, ctx);
+			if (child.children && child.children.length > 0) {
+				const deeper = await mergeDescendants({
+					runId,
+					depth,
+					callId: parent.callId,
+					...session ? { session } : {}
+				}, child.children, ctx);
+				touched = touched ?? deeper;
+			}
+		}
+		return touched;
+	}
+	/**
+	* Repair the run record's timestamps with journaled values.
+	*
+	* `startRun` / `completeRun` / `errorRun` / `abortRun` stamp `Date.now()`
+	* internally, and these records reach `ctx.set` through `save()` below — so a
+	* live value here changes the state payload on a replay and kills the
+	* invocation with `RestateError 570`. The loop repairs its own runs exactly
+	* this way (`agent.ts`: `sessionRun.startedAt = runStartedAt`, `run.endedAt =
+	* await clock.now()`); the merge path has to do the same.
+	*
+	* Sampling the parent's clock here is not an option: the drain runs inside a
+	* hook the loop may abandon (`settledHook`), and an awaited journal op left in
+	* flight is its own failure mode. Everything below is already journaled by the
+	* time it reaches us — either measured by the child on ITS clock and carried
+	* inside the journaled call result, or read from state the parent's own run
+	* already wrote.
+	*/
+	function stampJournaledRunTimes(session, entry, result) {
+		const merged = session.runs.find((run) => run.id === entry.runId);
+		if (!merged) return;
+		const turns = result?.turns ?? [];
+		const parentStartedAt = entry.parentRunId !== void 0 ? session.runs.find((run) => run.id === entry.parentRunId)?.startedAt : void 0;
+		const startedAt = result?.startedAt ?? turns[0]?.createdAt ?? parentStartedAt;
+		const endedAt = result?.endedAt ?? turns[turns.length - 1]?.createdAt ?? startedAt;
+		if (startedAt !== void 0) merged.startedAt = startedAt;
+		if (endedAt !== void 0) merged.endedAt = endedAt;
+	}
+	/**
+	* Replay a finished child's transcript onto the PARENT's hook bus as `child:*`
+	* events, so hosts that already render subagent activity (`src/output/
+	* terminal.ts`, the GUI engine, any `child:tool:*` listener) light up for
+	* parallel children without a single change.
+	*
+	* Not live \u2014 hook bubbling cannot cross an invocation boundary, so these fire
+	* when the child finishes, in submission order. Everything here is derived
+	* from the journaled call result, so a parent replay produces the identical
+	* sequence; like the in-process tool's `child:tool:*`, they DO re-fire on that
+	* replay, so hosts dedupe by `callId` / `turnId` or gate on
+	* `createReplayTracker`.
+	*
+	* Only events that describe things the child actually did are synthesized.
+	* `tool:gate` / `tool:transform` / `tool:dispatched` / `tool:cancelled` /
+	* `background:*` describe decisions taken inside another process; inventing
+	* them would be fiction, so they stay absent.
+	*/
+	async function replayChildEvents(child, turns, ctx) {
+		if (turns.length === 0) return;
+		const outputs = /* @__PURE__ */ new Map();
+		for (const turn of turns) for (const block of turn.content) if (block.type === "tool_result") outputs.set(block.callId, {
+			output: block.output,
+			...block.isError !== void 0 ? { isError: block.isError } : {}
+		});
+		const childIdentity = {
+			childId: child.label,
+			depth: child.depth
+		};
+		const identity = {
+			...childIdentity,
+			runId: child.runId,
+			...child.parentRunId !== void 0 ? { parentRunId: child.parentRunId } : {},
+			parentCallId: child.callId
+		};
+		const runToolCounts = {};
+		let assistantTurns = 0;
+		for (const turn of turns) {
+			if (turn.role !== "assistant") continue;
+			assistantTurns += 1;
+			const text = turn.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+			if (text.length > 0) await ctx.hooks.callHook("child:stream:text", {
+				...childIdentity,
+				turnId: turn.id,
+				delta: text,
+				text
+			});
+			const turnToolCounts = {};
+			for (const block of turn.content) {
+				if (block.type !== "tool_call") continue;
+				runToolCounts[block.name] = (runToolCounts[block.name] ?? 0) + 1;
+				turnToolCounts[block.name] = (turnToolCounts[block.name] ?? 0) + 1;
+				const base = {
+					...identity,
+					turnId: turn.id,
+					callId: block.id,
+					name: block.name,
+					displayName: block.name,
+					input: block.input,
+					runToolCounts: { ...runToolCounts }
+				};
+				await ctx.hooks.callHook("child:tool:before", base);
+				const settled = outputs.get(block.id);
+				if (settled === void 0) continue;
+				if (settled.isError === true) {
+					await ctx.hooks.callHook("child:tool:error", {
+						...base,
+						error: new Error(toolResultToText(settled.output))
+					});
+					continue;
+				}
+				await ctx.hooks.callHook("child:tool:after", {
+					...base,
+					result: settled.output,
+					outputBytes: toolOutputByteLength(settled.output)
+				});
+			}
+			const usage = turn.usage ?? {
+				input: 0,
+				output: 0
+			};
+			await ctx.hooks.callHook("child:turn:after", {
+				...childIdentity,
+				turn: assistantTurns,
+				turnId: turn.id,
+				usage,
+				message: turn,
+				toolCounts: {
+					turn: { ...turnToolCounts },
+					run: { ...runToolCounts }
+				}
+			});
+			await ctx.hooks.callHook("child:stream:end", {
+				...childIdentity,
+				turnId: turn.id,
+				text
+			});
+		}
+	}
+	function errorText(entry) {
+		if (entry.failure !== void 0) return entry.failure instanceof Error ? entry.failure.message : String(entry.failure);
+		return entry.result?.error ?? "sub-agent failed";
+	}
+	/**
+	* Shape the model-facing result. Mirrors the in-process tool's wording so a
+	* host or model tuned on one reads the other.
+	*
+	* `stats.elapsed` is safe to print here even though it is a live measurement:
+	* the child measured it inside ITS invocation and it arrives in the journaled
+	* call result, so the parent replays the same bytes. (Sampling it on the
+	* parent side is what corrupts a transcript — see `docs/RESTATE.md`.)
+	*/
+	/**
+	* Arm the abort path for one child. Nothing is read off the dispatch promise:
+	* touching its `invocationId` mid-flight would register a second consumer on
+	* the runtime's progress channel (see `onAbort`'s note), so the hook gets
+	* labels and the host cancels the tree.
+	*/
+	function watchAbort(entry, ctx) {
+		if (!options.onAbort) return;
+		if (ctx.signal.aborted) {
+			requestCancel(ctx);
+			return;
+		}
+		const onAbort = () => requestCancel(ctx);
+		ctx.signal.addEventListener("abort", onAbort, { once: true });
+		entry.release = () => ctx.signal.removeEventListener("abort", onAbort);
+	}
+	/**
+	* Fire the host's abort hook once for the whole in-flight set. Called once per
+	* abort, not once per child: cancelling the tree is a single operation, and a
+	* second call would append a redundant journal command.
+	*/
+	function requestCancel(ctx) {
+		const onAbort = options.onAbort;
+		if (!onAbort || cancelSignalled) return;
+		const inFlight = pending.filter((entry) => !entry.settled);
+		if (inFlight.length === 0) return;
+		cancelSignalled = true;
+		for (const entry of inFlight) entry.cancelRequested = true;
+		onAbort(inFlight.map((entry) => ({
+			label: entry.label,
+			task: entry.task,
+			depth: entry.depth
+		})), ctx);
+	}
+	function settle(entry, value, failure) {
+		entry.settled = true;
+		entry.release?.();
+		if (failure !== void 0) {
+			entry.failure = failure;
+			if (entry.cancelRequested) return `[sub-agent ${entry.label}] Aborted (cancelled)`;
+			return `[sub-agent ${entry.label}] Error: ${errorText(entry)}`;
+		}
+		const result = value ?? {
+			status: "error",
+			text: "",
+			turns: [],
+			stats: ZERO_STATS
+		};
+		entry.result = result;
+		const head = `[sub-agent ${entry.label}]`;
+		const usage = `Tokens: ${formatTokenUsage(result.stats)}`;
+		if (result.status === "completed") return [
+			`${head} Completed in ${result.stats.turns} turns (${result.stats.elapsed}ms)`,
+			usage,
+			"",
+			result.text || "(no text response)"
+		].join("\n");
+		if (result.status === "error") return `${head} Error: ${errorText(entry)}`;
+		return [`${head} ${result.status === "timeout" ? "Timed out" : "Aborted"} after ${result.stats.turns} turns (${result.stats.elapsed}ms)`, usage].join("\n");
+	}
+	return {
+		spec: {
+			name: "spawn",
+			description: options.description ?? DEFAULT_DESCRIPTION,
+			inputSchema: {
+				type: "object",
+				properties: {
+					task: {
+						type: "string",
+						description: "The self-contained task for the sub-agent."
+					},
+					model: {
+						type: "string",
+						description: "Optional model id for the sub-agent."
+					},
+					subagent_type: {
+						type: "string",
+						description: "Optional named sub-agent type."
+					}
+				},
+				required: ["task"]
+			}
+		},
+		isConcurrencySafe: true,
+		runsNestedAgent: true,
+		durableExecute: (input, ctx) => {
+			const { req, entry } = prepare(input, ctx);
+			const promise = options.dispatch(req, ctx);
+			if (typeof promise.map !== "function") throw new TypeError("restateSpawnTool: `dispatch` must return the runtime's durable promise (e.g. `ctx.serviceClient(svc).runChild(req)`), which exposes `map`.");
+			commit(entry, input, ctx);
+			return promise.map((value, failure) => settle(entry, value, failure));
+		},
+		execute: async (input, ctx) => {
+			const { req, entry } = prepare(input, ctx);
+			const promise = options.dispatch(req, ctx);
+			commit(entry, input, ctx);
+			try {
+				return settle(entry, await promise);
+			} catch (err) {
+				return settle(entry, void 0, err);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/restate/tool-state.ts
 /** Default virtual-object state key holding the tool-state map. */
 const DEFAULT_TOOL_STATE_KEY = "zidane_tool_state";
@@ -1099,6 +1555,6 @@ function restateWaitBackground(options) {
 	};
 }
 //#endregion
-export { DEFAULT_TOOL_STATE_KEY, awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateTool, restateToolBatchExecutor, restateToolStateStore, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
+export { DEFAULT_TOOL_STATE_KEY, awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateSpawnTool, restateTool, restateToolBatchExecutor, restateToolStateStore, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
 
 //# sourceMappingURL=restate.js.map