@code-yeongyu/senpi 2026.7.10 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/prompt/eval-prompt.ts

@@ -11,13 +11,58 @@ export interface EvalPromptParts {
 	readonly promptGuidelines: readonly string[];
 }
 
+export interface EvalPromptOptions {
+	readonly spawns: boolean;
+	readonly spawnDefaultAgent?: string;
+}
+
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
+type EvalPromptExample = {
+	readonly caption: string;
+	readonly language: keyof EnabledLanguages;
+	readonly title: string;
+	readonly code: string;
+};
+
+// senpi ToolDefinition has no examples field, so description embeds parity examples.
+const REUSE_CHAIN_EXAMPLES = [
+	{
+		caption: "First call — set up once",
+		language: "py",
+		title: "imports",
+		code: "import json\nfrom pathlib import Path",
+	},
+	{
+		caption: "Second call — reuse, do NOT re-import",
+		language: "py",
+		title: "load config",
+		code: "data = json.loads(read('package.json'))\ndisplay(data)",
+	},
+	{
+		caption: "Third call — reuse the loaded config",
+		language: "py",
+		title: "scan deps",
+		code: "display(sorted(data['dependencies']))",
+	},
+	{
+		caption: "Ruby first call — set up once",
+		language: "rb",
+		title: "setup",
+		code: "require 'json'\npkg_path = 'package.json'",
+	},
+	{
+		caption: "Ruby second call — reuse, do NOT re-require",
+		language: "rb",
+		title: "load config",
+		code: "pkg = JSON.parse(read(pkg_path))\ndisplay(pkg.keys.sort)",
+	},
+] as const satisfies readonly EvalPromptExample[];
 
 const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 
 <instruction>
-**One eval call = one cell = one logical step.** State persists per language across separate eval calls and tool calls — define helpers, datasets, and clients in one call, then later calls reuse them directly.
+**One eval call = one cell = one logical step.** State persists per language across separate eval calls and tool calls{{#if spawns}}, and \`task\` subagents{{/if}} — define helpers, datasets, and clients in one call, then later calls reuse them directly.
 
 Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after \`reset\`, a kernel crash, or a \`NameError\`/\`ReferenceError\` proving the state is gone. Parallelize work *within* a cell with the \`parallel(thunks)\` helper, not by batching steps.
 
@@ -26,61 +71,93 @@ Fields:
 - \`language\` — {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
 - \`code\` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
 - \`title\` (optional) — short transcript label (e.g. \`"imports"\`).
-- \`timeout\` (optional) — seconds. Raise only for heavy compute or long delegated tool calls.
+- \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
 - \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
 
-{{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(...)\` raises "cannot be called from a running event loop".{{/if}}
+{{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
 {{#if js}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}
-{{#if rb}}Ruby: synchronous; helper options are keyword args; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition.{{/if}}
-{{#if jl}}Julia: synchronous; helper options are standard keyword args; the last expression auto-displays unless it is an assignment or a definition.{{/if}}
+{{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
+{{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
 On error, fix and re-run only the failing step — prior calls' state survives.
 </instruction>
 
 <prelude>
-{{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/\`await\`able, options = ONE trailing object literal, never positional.{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional.{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
+{{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/\`await\`able, options = ONE trailing object literal, never positional (extras throw).{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional (extras throw).{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
 \`\`\`
-display(value) -> None
-    Cell result; figures/images/dataframes shown natively.
-print(value, ...) -> None
-    Text stream.
-read(path, offset?=1, limit?=None) -> str
-    File as text; offset/limit are 1-indexed lines.
-write(path, content) -> str
-    Write file, creating parents, and return the resolved path.
-env(key?=None, value?=None) -> str | None | dict
-    No args -> full env dict; one -> value of key; two -> set key=value and return value.
-tool.<name>(args) -> unknown
-    Invoke any active session tool; args = its parameter object.
-completion(prompt, model?="default", system?=None, schema?=None) -> str | dict
-    Oneshot, stateless completion. model "default" uses the session model; schema is JSON Schema for structured results.
-parallel(thunks) -> list
-    Thunks through a bounded pool, input order kept; returns when all finish, a throwing thunk propagates.
-pipeline(items, ...stages) -> list
+display(value) → None
+    Cell output; figures/images/dataframes shown natively.
+print(value, ...) → None
+    Text output.
+read(path, offset?=1, limit?=None) → str
+    File as text; offset/limit are 1-indexed lines. Accepts \`local://…\`.
+write(path, content) → str
+    Write file (creates parents) → resolved path. \`local://…\` persists across turns/subagents.
+env(key?=None, value?=None) → str | None | dict
+    No args → full env dict; one → value of \`key\`; two → set \`key=value\`, return value.
+{{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
+    Task/agent output by id. \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
+{{/if}}tool.<name>(args) → unknown
+    Invoke any session tool; \`args\` = its parameter object.
+completion(prompt, model?="default", system?=None, schema?=None) → str | dict
+    Oneshot, stateless (no history/tools). \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → structured output, parsed object.
+{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
+    Run a subagent → final output. \`agent\` picks another discovered agent; omit it to use \`{{spawnDefaultAgent}}\`. \`schema\` as in completion(). Background via \`local://\` files named in the prompt. \`handle\` → DAG node dict { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` when \`schema\` set).
+{{#if js}}    JS: options are ONE trailing object — agent(prompt, { agent, schema, handle }).
+{{/if}}{{/if}}parallel(thunks) → list
+    Thunks through a bounded pool (wide as a \`task\` batch — don't pre-shrink), input order kept; returns when all finish, a throwing thunk propagates.
+pipeline(items, ...stages) → list
     Map items through one-arg stages left-to-right, barrier between stages; stage 1 gets the item, later stages the previous result.
-log(message) -> None
+log(message) → None
     Progress line above the status tree.
-phase(title) -> None
+phase(title) → None
     Phase grouping subsequent status lines.
 \`\`\`
 </prelude>
+{{#if spawns}}
+<dag>
+Pipe handles through stage helpers to build a dependency graph — acyclic waves:
+- **Name nodes.** Capture each \`agent(…, {{#if py}}handle=True{{/if}}{{#if js}}{ handle: true }{{/if}}{{#if jl}}handle=true{{/if}})\` result; carries \`handle\` (\`agent://<id>\`) + \`output\`.
+- **Wire edges by reference.** Put an upstream node's \`handle\`/\`output\` in the dependent stage's prompt — large transcript never re-inlined. Bulk: \`write("local://<name>.md", …)\`, pass the URI.
+- **\`pipeline(items, *stages)\` = staged waves**, barrier between stages (every item clears stage N before any enters N+1). **\`parallel(thunks)\` = one wave** of independent nodes.
+- **Isolate failure.** A raising node re-raises the lowest-index error, aborts its wave; wrap risky nodes in try/except so a failure degrades only its dependent subtree, independent branches finish.
+- **Acyclic only.** A node never waits on its own descendant.
+</dag>
+{{/if}}
 
 <critical>
-Prior top-level names survive into the next eval call — reuse them; NEVER re-import, re-require, or re-declare a helper. Re-read a file only if it may have changed since the last read. Re-run setup only after \`reset\`, a crash, or a \`NameError\`/\`ReferenceError\`.
+Prior top-level names (\`data\`, \`sessions\`, helpers, imports) survive into the next eval call — reuse them; NEVER re-import, re-require, or re-declare a helper. Re-read a file only if it may have changed since the last read. Re-run setup only after \`reset\`, a crash, or a \`NameError\`/\`ReferenceError\`.
 </critical>`;
 
-export function buildEvalPrompt(enabled: EnabledLanguages): EvalPromptParts {
+export function buildEvalPrompt(
+	enabled: EnabledLanguages,
+	options: EvalPromptOptions = { spawns: false },
+): EvalPromptParts {
 	if (!enabled.py && !enabled.js && !enabled.rb && !enabled.jl) {
 		throw new Error("no kernels enabled for eval prompt");
 	}
+	const spawnDefaultAgent = options.spawnDefaultAgent ?? "task";
 	const context: Context = {
 		py: enabled.py,
 		js: enabled.js,
 		rb: enabled.rb,
 		jl: enabled.jl,
+		spawns: options.spawns,
+		spawnDefaultAgent,
 	};
-	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
-		.replace(/\n{3,}/g, "\n\n")
-		.trim();
+	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
+		.map((example) => {
+			const call = { language: example.language, title: example.title, code: example.code };
+			return `### ${example.caption}\n\`\`\`json\n${JSON.stringify(call, null, 2)}\n\`\`\``;
+		})
+		.join("\n\n");
+	const description = [
+		renderTemplate(EVAL_PROMPT_TEMPLATE, context)
+			.replace(/\n{3,}/g, "\n\n")
+			.trim(),
+		examples === "" ? "" : `<examples>\n${examples}\n</examples>`,
+	]
+		.filter((part) => part !== "")
+		.join("\n\n");
 	return {
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",

package/node_modules/@code-yeongyu/senpi-codemode/src/timeouts/bridge-timeout.ts

@@ -1,3 +1,5 @@
+export { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../bridge/reserved.ts";
+
 import type { TimeoutPauseHandle } from "./idle-timeout.ts";
 
 export async function withBridgeTimeoutPause<T>(

package/node_modules/@code-yeongyu/senpi-codemode/src/timeouts/idle-timeout.ts

@@ -16,10 +16,10 @@ export interface TimeoutPauseHandle {
 
 export class IdleTimeout implements TimeoutPauseHandle {
 	readonly #cellId: string;
-	readonly #timeoutMs: number;
 	readonly #onTimeout: (event: IdleTimeoutEvent) => void;
 	readonly #controller = new AbortController();
-	#remainingMs: number;
+	readonly signal = this.#controller.signal;
+	readonly timeoutMs: number;
 	#deadlineMs: number;
 	#timer: ReturnType<typeof setTimeout> | undefined;
 	#pauseDepth = 0;
@@ -27,26 +27,16 @@ export class IdleTimeout implements TimeoutPauseHandle {
 
 	constructor(options: IdleTimeoutOptions) {
 		this.#cellId = options.cellId;
-		this.#timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
-		this.#remainingMs = this.#timeoutMs;
-		this.#deadlineMs = Date.now() + this.#remainingMs;
+		this.timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
+		this.#deadlineMs = Date.now() + this.timeoutMs;
 		this.#onTimeout = options.onTimeout;
-		this.#arm(this.#remainingMs);
-	}
-
-	get signal(): AbortSignal {
-		return this.#controller.signal;
-	}
-
-	get timeoutMs(): number {
-		return this.#timeoutMs;
+		this.#arm(this.timeoutMs);
 	}
 
 	pause(): void {
 		if (this.#settled) return;
 		this.#pauseDepth++;
 		if (this.#pauseDepth !== 1) return;
-		this.#remainingMs = Math.max(0, this.#deadlineMs - Date.now());
 		this.#clearTimer();
 	}
 
@@ -54,8 +44,8 @@ export class IdleTimeout implements TimeoutPauseHandle {
 		if (this.#settled || this.#pauseDepth === 0) return;
 		this.#pauseDepth--;
 		if (this.#pauseDepth > 0) return;
-		this.#deadlineMs = Date.now() + this.#remainingMs;
-		this.#arm(this.#remainingMs);
+		this.#deadlineMs = Date.now() + this.timeoutMs;
+		this.#arm(this.timeoutMs);
 	}
 
 	dispose(): void {
@@ -81,13 +71,12 @@ export class IdleTimeout implements TimeoutPauseHandle {
 		if (this.#settled || this.#pauseDepth > 0) return;
 		const remainingMs = this.#deadlineMs - Date.now();
 		if (remainingMs > 0) {
-			this.#remainingMs = remainingMs;
 			this.#arm(remainingMs);
 			return;
 		}
 		this.#settled = true;
 		this.#timer = undefined;
-		const error = new Error(`Cell timed out after ${this.#timeoutMs}ms`);
+		const error = new Error(`Cell timed out after ${this.timeoutMs}ms`);
 		error.name = "TimeoutError";
 		this.#controller.abort(error);
 		this.#onTimeout({ cellId: this.#cellId, error });

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/cell-handler.ts

@@ -0,0 +1,267 @@
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import { RESERVED_AGENT_TOOL, RESERVED_OUTPUT_TOOL } from "../bridge/reserved.ts";
+import { type AgentExecuteTool, runEvalAgent } from "../bridges/agent-bridge.ts";
+import { runEvalOutput } from "../bridges/output-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
+import type { ResolvedCodemodeSettings } from "../config/settings.ts";
+import {
+	type EvalImageResizer,
+	EvalOutputCollector,
+	type EvalOutputResult,
+	marshalToolResult,
+	toolResultIsError,
+} from "./image.ts";
+import { upsertStatusEvent } from "./status-events.ts";
+import type { EvalKernel, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+type ResolvedToolReply = { readonly value: unknown; readonly toolCallOk: boolean };
+
+export interface CellState {
+	readonly input: EvalToolInput;
+	readonly signal: AbortSignal;
+	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
+	readonly toolCalls: EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? Item[] : never;
+	readonly pendingBridgeCalls: Promise<void>[];
+	readonly statusEvents: EvalStatusEvent[];
+	active: boolean;
+	output: string;
+	phase: string | undefined;
+	durationMs: number;
+	status: "pending" | "running" | "complete" | "error";
+}
+
+export interface CellBridgeRuntime {
+	readonly executeTool: AgentExecuteTool;
+	readonly settings: ResolvedCodemodeSettings;
+	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	readonly ctx: ExtensionContext;
+	readonly artifactPath?: string;
+	readonly imageResizer?: EvalImageResizer;
+}
+
+export class CellHandler {
+	readonly #kernel: EvalKernel;
+	readonly #state: CellState;
+	readonly #runtime: CellBridgeRuntime;
+	readonly #output: EvalOutputCollector;
+
+	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
+		this.#kernel = kernel;
+		this.#state = state;
+		this.#runtime = runtime;
+		const settings = runtime.settings.outputSink;
+		this.#output = new EvalOutputCollector({
+			headBytes: settings.headBytes,
+			maxColumns: settings.maxColumns,
+			model: runtime.ctx.model,
+			...(runtime.artifactPath === undefined ? {} : { artifactPath: runtime.artifactPath }),
+			...(runtime.imageResizer === undefined ? {} : { imageResizer: runtime.imageResizer }),
+			onChunk: (_aggregate, cell) => {
+				state.output = cell;
+				this.#emitUpdate(false);
+			},
+		});
+		state.status = "running";
+		this.#emitUpdate(false);
+	}
+
+	async handle(message: KernelToHostMessage): Promise<void> {
+		if (!this.#state.active) return;
+		switch (message.type) {
+			case "text":
+				this.#output.push(message.data);
+				return;
+			case "phase":
+				this.#state.phase = message.title;
+				this.#emitUpdate(false);
+				return;
+			case "status":
+				this.#recordStatus(message.event);
+				return;
+			case "log":
+				this.#output.push(`${message.message}\n`);
+				return;
+			case "display":
+				this.#output.display(message);
+				return;
+			case "tool-call": {
+				const pending = this.#handleToolCall(message);
+				this.#state.pendingBridgeCalls.push(pending);
+				await pending;
+				return;
+			}
+			case "ready":
+			case "init-failed":
+			case "result":
+			case "closed":
+				return;
+			default:
+				throw new TypeError(`Unhandled kernel message: ${String(message)}`);
+		}
+	}
+
+	async finalize(result: Extract<KernelToHostMessage, { type: "result" }>): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#state.durationMs = result.durationMs;
+		if (result.ok) {
+			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
+			this.#state.status = "complete";
+		} else {
+			this.#output.push(`${result.error.message}\n`);
+			this.#state.status = "error";
+		}
+		return await this.#finish(!result.ok);
+	}
+
+	async finalizeCancellation(error: Error): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#output.push(`${error.message}\n`);
+		this.#state.status = "error";
+		return await this.#finish(true);
+	}
+
+	async flushOutput(): Promise<void> {
+		await this.#output.flush();
+	}
+
+	async #finish(isError: boolean): Promise<AgentToolResult<EvalToolDetails>> {
+		const output = await this.#output.finish();
+		this.#state.output = output.output;
+		const details = this.#details(output, isError);
+		this.#emitUpdate(isError);
+		const text =
+			output.output ||
+			(output.images.length > 0
+				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
+				: "(no output)");
+		return { content: [{ type: "text", text }, ...output.images], details };
+	}
+
+	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
+		if (message.toolName === "eval") {
+			const error = "recursive eval is not allowed";
+			this.#state.toolCalls.push({ name: message.toolName, ok: false, error });
+			this.#kernel.deliverToolReply({
+				type: "tool-reply",
+				callId: message.callId,
+				ok: false,
+				error: { message: error },
+			});
+			return;
+		}
+		if (message.toolName === RESERVED_AGENT_TOOL) {
+			await this.#deliverToolReply(message, async () => ({
+				value: await runEvalAgent(message.args, {
+					callId: message.callId,
+					taskToolName: this.#runtime.settings.taskTools.task,
+					executeTool: this.#runtime.executeTool,
+					signal: this.#state.signal,
+					emitStatus: (event) => this.#recordStatus(event),
+				}),
+				toolCallOk: true,
+			}));
+			return;
+		}
+		if (message.toolName === RESERVED_OUTPUT_TOOL) {
+			await this.#deliverToolReply(message, async () => ({
+				value: await runEvalOutput(message.args, {
+					taskOutputToolName: this.#runtime.settings.taskTools.output,
+					executeTool: this.#runtime.executeTool,
+					signal: this.#state.signal,
+					marshalToolResult,
+				}),
+				toolCallOk: true,
+			}));
+			return;
+		}
+		if (message.toolName === "completion" && this.#runtime.complete) {
+			const result = await handleCompletionToolCall({
+				message,
+				kernel: this.#kernel,
+				complete: this.#runtime.complete,
+				ctx: this.#runtime.ctx,
+				isActive: () => this.#state.active,
+			});
+			if (!this.#state.active) return;
+			this.#state.toolCalls.push(
+				result.ok
+					? { name: message.toolName, ok: true }
+					: { name: message.toolName, ok: false, error: result.error },
+			);
+			this.#emitUpdate(false);
+			return;
+		}
+		await this.#deliverToolReply(message, async () => {
+			const result = await this.#runtime.executeTool(message.toolName, message.args, { signal: this.#state.signal });
+			return { value: marshalToolResult(result), toolCallOk: !toolResultIsError(result) };
+		});
+	}
+
+	async #deliverToolReply(
+		message: Extract<KernelToHostMessage, { type: "tool-call" }>,
+		resolve: () => Promise<ResolvedToolReply>,
+	): Promise<void> {
+		try {
+			const reply = await resolve();
+			if (!this.#state.active) return;
+			this.#state.toolCalls.push({ name: message.toolName, ok: reply.toolCallOk });
+			this.#kernel.deliverToolReply({ type: "tool-reply", callId: message.callId, ok: true, value: reply.value });
+		} catch (error) {
+			if (!this.#state.active) return;
+			const text = error instanceof Error ? error.message : String(error);
+			this.#state.toolCalls.push({ name: message.toolName, ok: false, error: text });
+			this.#kernel.deliverToolReply({
+				type: "tool-reply",
+				callId: message.callId,
+				ok: false,
+				error: { message: text },
+			});
+		}
+		this.#emitUpdate(false);
+	}
+
+	#recordStatus(event: EvalStatusEvent): void {
+		if (!this.#runtime.settings.statusEvents) return;
+		upsertStatusEvent(this.#state.statusEvents, event);
+		this.#emitUpdate(false);
+	}
+
+	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
+		const statusEvents = this.#state.statusEvents.length > 0 ? [...this.#state.statusEvents] : undefined;
+		return {
+			language: this.#state.input.language,
+			languages: [this.#state.input.language],
+			...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
+			durationMs: this.#state.durationMs,
+			toolCalls: [...this.#state.toolCalls],
+			truncated: output?.truncated ?? false,
+			...(isError ? { isError: true } : {}),
+			...(this.#state.phase === undefined ? {} : { phase: this.#state.phase }),
+			cells: [
+				{
+					index: 0,
+					...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
+					code: this.#state.input.code,
+					language: this.#state.input.language,
+					output: this.#state.output,
+					status: this.#state.status,
+					durationMs: this.#state.durationMs,
+					...(statusEvents === undefined ? {} : { statusEvents }),
+					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
+				},
+			],
+			...(statusEvents === undefined ? {} : { statusEvents }),
+			...(output === undefined || output.jsonOutputs.length === 0 ? {} : { jsonOutputs: output.jsonOutputs }),
+			...(output?.notice === undefined ? {} : { notice: output.notice }),
+			...(output?.meta === undefined ? {} : { meta: output.meta }),
+		};
+	}
+
+	#emitUpdate(isError: boolean): void {
+		if (!this.#state.active) return;
+		this.#state.onUpdate?.({
+			content: [{ type: "text", text: this.#output.aggregateText() }],
+			details: this.#details(undefined, isError),
+		});
+	}
+}