@code-yeongyu/senpi 2026.7.10 → 2026.7.13

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

@@ -1,13 +1,18 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
-import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
-import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../host-sdk.ts";
+import { defaultCodemodeSettings, type ResolvedCodemodeSettings } from "../config/settings.ts";
+import type { EvalExecutionTracker } from "../extension/session-manager.ts";
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
-import { renderEvalCall, renderEvalResult } from "./render.ts";
+import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
+import { IdleTimeout } from "../timeouts/idle-timeout.ts";
+import { CellHandler, type CellState } from "./cell-handler.ts";
+import type { EvalImageResizer } from "./image.ts";
 import {
 	createEvalInputSchema,
 	type EnabledEvalLanguages,
+	type EvalInputSchema,
 	type EvalKernel,
 	type EvalKernelManager,
 	type EvalToolDetails,
@@ -18,38 +23,136 @@ import {
 
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
-type ImageContent = { type: "image"; mimeType: string; data: string };
-type ToolContent = AgentToolResult<unknown>["content"][number];
-type TextPart = Extract<ToolContent, { type: "text" }>;
-type RuntimeImagePart = { type: "image"; mimeType: string; data: string };
-
 export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
 	readonly cellTimeoutSeconds: number;
 	readonly executeTool: ExecuteTool;
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	readonly settings?: ResolvedCodemodeSettings;
+	readonly artifactsDir?: string;
+	readonly imageResizer?: EvalImageResizer;
+	readonly executionTracker?: EvalExecutionTracker;
+	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
+	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
+	/** Whether the task-tool spawn helpers (agent()/output()/<dag>) are advertised in the prompt. */
+	readonly spawns?: boolean;
+	/** Default agent name surfaced in the agent() helper docs when spawns are enabled. */
+	readonly spawnDefaultAgent?: string;
 }
 
-interface CellState {
+interface EvalCellInvocation {
 	readonly cellId: string;
-	readonly language: EvalToolInput["language"];
-	readonly title: string | undefined;
-	readonly signal: AbortSignal | undefined;
+	readonly input: EvalToolInput;
+	readonly signal: AbortSignal;
 	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
-	readonly toolCalls: EvalToolDetails["toolCalls"] extends readonly (infer T)[] ? T[] : never;
-	readonly images: ImageContent[];
-	readonly pendingBridgeCalls: Promise<void>[];
-	output: string;
-	phase: string | undefined;
-	durationMs: number;
+	readonly ctx: ExtensionContext;
 }
 
-export function createEvalTool(
-	options: CreateEvalToolOptions,
-): ToolDefinition<ReturnType<typeof createEvalInputSchema>, EvalToolDetails> {
+interface CellExecutionOptions {
+	readonly callerSignal: AbortSignal;
+	readonly cellId: string;
+	readonly onAbort: (error: Error) => void;
+	readonly timeoutMs: number;
+}
+
+const INTERRUPT_DELIVERY_GRACE_MS = 100;
+
+class CellExecution {
+	readonly #callerSignal: AbortSignal;
+	readonly #onAbort: (error: Error) => void;
+	readonly #abortPromise: Promise<never>;
+	readonly #watchdog: IdleTimeout;
+	#rejectAbort: ((reason?: unknown) => void) | undefined;
+	#kernel: EvalKernel | undefined;
+	#interruptDeadline: ReturnType<typeof setTimeout> | undefined;
+	#active = true;
+
+	constructor(options: CellExecutionOptions) {
+		this.#callerSignal = options.callerSignal;
+		this.#onAbort = options.onAbort;
+		this.#abortPromise = new Promise<never>((_resolve, reject) => {
+			this.#rejectAbort = reject;
+		});
+		this.#watchdog = new IdleTimeout({
+			cellId: options.cellId,
+			timeoutMs: options.timeoutMs,
+			onTimeout: ({ error }) => this.#abort(error),
+		});
+		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, { once: true });
+	}
+
+	pause(): void {
+		this.#watchdog.pause();
+	}
+	resume(): void {
+		this.#watchdog.resume();
+	}
+	setKernel(kernel: EvalKernel): void {
+		this.#kernel = kernel;
+	}
+	cancel(reason: unknown): void {
+		this.#abort(reason);
+	}
+	finish(): void {
+		this.#active = false;
+		this.#cleanup();
+	}
+
+	async wait<Result>(operation: Promise<Result>): Promise<Result> {
+		const guarded = operation.then(
+			(value): Result | Promise<never> => (this.#active ? value : this.#abortPromise),
+			(reason: unknown): Promise<never> => (this.#active ? Promise.reject(reason) : this.#abortPromise),
+		);
+		return await Promise.race([guarded, this.#abortPromise]);
+	}
+
+	readonly #handleCallerAbort = (): void => {
+		this.#abort(this.#callerSignal.reason);
+	};
+
+	#abort(reason: unknown): void {
+		if (!this.#active) return;
+		this.#active = false;
+		this.#cleanup();
+		const error = abortError(reason);
+		this.#onAbort(error);
+		const kernel = this.#kernel;
+		if (kernel === undefined) {
+			this.#settleAbort(error);
+			return;
+		}
+		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
+		void Promise.resolve()
+			.then(() => kernel.interrupt(error.message))
+			.then(
+				() => this.#settleAbort(error),
+				(interruptError: unknown) => this.#settleAbort(interruptError),
+			);
+	}
+
+	#settleAbort(reason: unknown): void {
+		const reject = this.#rejectAbort;
+		if (reject === undefined) return;
+		this.#rejectAbort = undefined;
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		reject(reason);
+	}
+
+	#cleanup(): void {
+		this.#callerSignal.removeEventListener("abort", this.#handleCallerAbort);
+		this.#watchdog.dispose();
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		this.#interruptDeadline = undefined;
+	}
+}
+
+export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<EvalInputSchema, EvalToolDetails> {
 	const parameters = createEvalInputSchema(options.enabledLanguages);
-	const prompt = buildEvalPrompt(options.enabledLanguages);
+	const prompt = buildEvalPrompt(options.enabledLanguages, {
+		spawns: options.spawns ?? false,
+		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
+	});
 	const languages = enabledLanguageList(options.enabledLanguages);
 	return {
 		name: "eval",
@@ -58,207 +161,119 @@ export function createEvalTool(
 		promptSnippet: prompt.promptSnippet,
 		promptGuidelines: [...prompt.promptGuidelines],
 		parameters,
-		renderCall: renderEvalCall,
-		renderResult: renderEvalResult,
+		executionMode: "sequential",
+		...(options.renderers?.renderCall === undefined ? {} : { renderCall: options.renderers.renderCall }),
+		...(options.renderers?.renderResult === undefined ? {} : { renderResult: options.renderers.renderResult }),
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			if (!languages.includes(params.language)) {
-				throw new Error(
+			if (options.proxyExecutor) return await options.proxyExecutor(params, signal);
+			if (!languages.includes(params.language))
+				throw new RangeError(
 					`Unsupported eval language "${params.language}". Enabled languages: ${languages.join(", ")}`,
 				);
-			}
-			const state: CellState = {
+			options.executionTracker?.assertEvalExecutionAllowed();
+			const lifecycleController = new AbortController();
+			const combinedSignal = signal
+				? AbortSignal.any([signal, lifecycleController.signal])
+				: lifecycleController.signal;
+			const execution = runEvalCell(options, {
 				cellId: toolCallId,
-				language: params.language,
-				title: params.title,
-				signal,
+				input: params,
+				signal: combinedSignal,
 				onUpdate,
-				toolCalls: [],
-				images: [],
-				pendingBridgeCalls: [],
-				output: "",
-				phase: undefined,
-				durationMs: 0,
-			};
-			// `kernel` is referenced by the onMessage closure below. Subprocess kernels
-			// (py/rb/jl) emit their `ready` frame synchronously from within getKernel's
-			// await, before the binding is assigned — a `const` here would be in the
-			// temporal dead zone and throw. A pre-declared `let` yields `undefined` for
-			// that pre-ready frame instead (which is a control message, never a tool-call,
-			// so the kernel argument is unused for it).
-			let kernel!: EvalKernel;
-			kernel = await options.kernelManager.getKernel(
-				params.language,
-				(message) => void handleMessage(message, kernel, state, options.executeTool, options.complete, ctx),
-			);
-			if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
-				options.kernelManager.setContext(ctx);
-			}
-			if (params.reset) await kernel.reset();
-			const timeoutMs = Math.floor((params.timeout ?? options.cellTimeoutSeconds) * 1000);
-			const result = await kernel.run({ cellId: toolCallId, code: params.code, timeoutMs });
-			await Promise.all(state.pendingBridgeCalls);
-			return finalizeResult(result, state);
+				ctx,
+			});
+			return options.executionTracker
+				? await options.executionTracker.trackEvalExecution(execution, lifecycleController)
+				: await execution;
 		},
 	};
 }
 
-async function handleMessage(
-	message: KernelToHostMessage,
-	kernel: EvalKernel,
-	state: CellState,
-	executeTool: ExecuteTool,
-	complete: CreateEvalToolOptions["complete"],
-	ctx: ExtensionContext,
-): Promise<void> {
-	if (message.type === "text") {
-		state.output += message.data;
-		emitUpdate(state, false);
-		return;
-	}
-	if (message.type === "phase") {
-		state.phase = message.title;
-		emitUpdate(state, false);
-		return;
-	}
-	if (message.type === "log") {
-		state.output += `${message.message}\n`;
-		emitUpdate(state, false);
-		return;
-	}
-	if (message.type === "display") {
-		state.images.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
-		state.output += `[display: ${message.mimeType}]\n`;
-		emitUpdate(state, false);
-		return;
-	}
-	if (message.type === "tool-call") {
-		const pending = handleToolCall(message, kernel, state, executeTool, complete, ctx);
-		state.pendingBridgeCalls.push(pending);
-		await pending;
-	}
-}
-
-async function handleToolCall(
-	message: Extract<KernelToHostMessage, { type: "tool-call" }>,
-	kernel: EvalKernel,
-	state: CellState,
-	executeTool: ExecuteTool,
-	complete: CreateEvalToolOptions["complete"],
-	ctx: ExtensionContext,
-): Promise<void> {
-	if (message.toolName === "eval") {
-		const error = "recursive eval is not allowed";
-		state.toolCalls.push({ name: message.toolName, ok: false, error });
-		kernel.deliverToolReply({ type: "tool-reply", callId: message.callId, ok: false, error: { message: error } });
-		return;
-	}
-	if (message.toolName === "completion" && complete) {
-		const result = await handleCompletionToolCall({ message, kernel, complete, ctx });
-		state.toolCalls.push(
-			result.ok ? { name: message.toolName, ok: true } : { name: message.toolName, ok: false, error: result.error },
-		);
-		emitUpdate(state, false);
-		return;
-	}
+async function runEvalCell(
+	options: CreateEvalToolOptions,
+	invocation: EvalCellInvocation,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
+	const timeoutMs = Math.floor((invocation.input.timeout ?? options.cellTimeoutSeconds) * 1_000);
+	const bridgeAbortController = new AbortController();
+	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
+	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
+	const state: CellState = {
+		input: invocation.input,
+		signal: cellSignal,
+		onUpdate: invocation.onUpdate,
+		toolCalls: [],
+		pendingBridgeCalls: [],
+		statusEvents: [],
+		active: true,
+		output: "",
+		phase: undefined,
+		durationMs: 0,
+		status: "pending",
+	};
+	const execution = new CellExecution({
+		callerSignal: invocation.signal,
+		cellId: invocation.cellId,
+		onAbort: (error) => {
+			state.active = false;
+			bridgeAbortController.abort(error);
+		},
+		timeoutMs,
+	});
+	let handler: CellHandler | undefined;
 	try {
-		const result = await executeTool(message.toolName, message.args, { signal: state.signal });
-		state.toolCalls.push({ name: message.toolName, ok: !toolResultIsError(result) });
-		kernel.deliverToolReply({
-			type: "tool-reply",
-			callId: message.callId,
-			ok: true,
-			value: marshalToolResult(result),
+		const acquired = await execution.wait(
+			options.kernelManager.getKernel(invocation.input.language, (message) => {
+				if (!state.active || !handler) return;
+				if (message.type === "status") {
+					if (message.event.op === TIMEOUT_PAUSE_OP) {
+						execution.pause();
+						return;
+					}
+					if (message.event.op === TIMEOUT_RESUME_OP) {
+						execution.resume();
+						return;
+					}
+				}
+				const pending = handler.handle(message);
+				void pending.catch((error: unknown) => execution.cancel(error));
+			}),
+		);
+		const kernel = acquired;
+		execution.setKernel(kernel);
+		handler = new CellHandler(kernel, state, {
+			executeTool: options.executeTool,
+			settings: options.settings ?? defaultCodemodeSettings,
+			...(options.complete === undefined ? {} : { complete: options.complete }),
+			ctx: bridgeContext,
+			...(options.artifactsDir === undefined
+				? {}
+				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
+			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
 		});
+		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
+			options.kernelManager.setContext(bridgeContext);
+		}
+		if (invocation.input.reset) await execution.wait(kernel.reset());
+		const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
+		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
+		return await handler.finalize(result);
 	} catch (error) {
-		const messageText = errorMessage(error);
-		state.toolCalls.push({ name: message.toolName, ok: false, error: messageText });
-		kernel.deliverToolReply({
-			type: "tool-reply",
-			callId: message.callId,
-			ok: false,
-			error: { message: messageText },
-		});
+		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError") {
+			return await handler.finalizeCancellation(error);
+		}
+		throw error;
+	} finally {
+		state.active = false;
+		bridgeAbortController.abort();
+		execution.finish();
+		if (handler) await handler.flushOutput();
 	}
-	emitUpdate(state, false);
-}
-
-function marshalToolResult(result: AgentToolResult<unknown>): unknown {
-	const texts: string[] = [];
-	const images: Array<{ mimeType: string; dataBase64: string }> = [];
-	for (const part of result.content) {
-		if (isTextPart(part)) texts.push(part.text);
-		if (isRuntimeImagePart(part)) images.push({ mimeType: part.mimeType, dataBase64: part.data });
-	}
-	const text = texts.join("\n");
-	const details = isEmptyObject(result.details) ? undefined : result.details;
-	const hasError = toolResultIsError(result);
-	if (images.length === 0 && details === undefined && !hasError) return { text };
-	return { text, details, images, hasError };
-}
-
-function finalizeResult(
-	result: Extract<KernelToHostMessage, { type: "result" }>,
-	state: CellState,
-): AgentToolResult<EvalToolDetails> {
-	state.durationMs = result.durationMs;
-	if (result.ok && result.valueRepr) state.output += `${result.valueRepr}\n`;
-	if (!result.ok) state.output += `${result.error.message}\n`;
-	const truncation = truncateTail(state.output, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
-	const suffix = truncation.truncated
-		? `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines (${truncation.outputBytes} of ${truncation.totalBytes} bytes).]`
-		: "";
-	const details = detailsFor(state, truncation.truncated, !result.ok);
-	return {
-		content: [{ type: "text", text: `${truncation.content}${suffix}` }, ...state.images],
-		details,
-	};
-}
-
-function detailsFor(state: CellState, truncated: boolean, isError: boolean): EvalToolDetails {
-	return {
-		language: state.language,
-		title: state.title,
-		durationMs: state.durationMs,
-		toolCalls: state.toolCalls,
-		truncated,
-		isError,
-		phase: state.phase,
-	};
-}
-
-function emitUpdate(state: CellState, isError: boolean): void {
-	state.onUpdate?.({
-		content: [{ type: "text", text: state.output }],
-		details: detailsFor(state, false, isError),
-	});
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function isEmptyObject(value: unknown): boolean {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
-}
-
-function toolResultIsError(result: AgentToolResult<unknown>): boolean {
-	const details = result.details;
-	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
-}
-
-function isTextPart(part: ToolContent): part is TextPart {
-	return part.type === "text";
 }
 
-function isRuntimeImagePart(part: unknown): part is RuntimeImagePart {
-	return (
-		typeof part === "object" &&
-		part !== null &&
-		"type" in part &&
-		part.type === "image" &&
-		"mimeType" in part &&
-		typeof part.mimeType === "string" &&
-		"data" in part &&
-		typeof part.data === "string"
-	);
+function abortError(reason: unknown): Error {
+	if (reason instanceof Error && reason.name !== "AbortError") return reason;
+	const error = new Error(typeof reason === "string" ? reason : "Eval interrupted", { cause: reason });
+	error.name = "AbortError";
+	return error;
 }