@code-yeongyu/senpi-codemode 2026.9.9 → 2026.9.10-2

package/src/tool/run-eval-cell.ts

@@ -0,0 +1,189 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
+import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
+import { CellHandler, type CellState } from "./cell-handler.ts";
+import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
+import { resultAfterDetach } from "./detached-eval-result.ts";
+import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
+import { evalTimeoutBehavior } from "./eval-request.ts";
+import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
+import { describeTimeoutState } from "./interrupt-note.ts";
+import type { EvalToolDetails } from "./types.ts";
+
+export async function runEvalCell(
+	options: CreateEvalToolOptions,
+	cellManager: EvalDetachedCellManager,
+	invocation: EvalCellInvocation,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
+	const detaches = evalTimeoutBehavior(invocation.input, invocation.ctx) === "detach";
+	// The per-call `timeout` is the cell's run budget (owned by the cell manager's deadlines); how long
+	// an interactive call blocks the turn is the idle detach budget, capped at the foreground window
+	// — including the grace a bridge-parked cell gets — so `timeout` never delays the detach.
+	const foregroundWindowMs = (options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS) * 1_000;
+	const detachAfterMs = Math.min(Math.floor(options.cellTimeoutSeconds * 1_000), foregroundWindowMs);
+	const bridgeAbortController = new AbortController();
+	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
+	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
+	const runtime = options.runtimes?.[invocation.input.language];
+	const state: CellState = {
+		input: invocation.input,
+		...(runtime === undefined ? {} : { runtime }),
+		startedAt: Date.now(),
+		signal: cellSignal,
+		onUpdate: invocation.onUpdate,
+		toolCalls: [],
+		toolCallMetrics: [],
+		pendingBridgeCalls: [],
+		statusEvents: [],
+		active: true,
+		output: "",
+		phase: undefined,
+		error: undefined,
+		durationMs: 0,
+		status: "pending",
+	};
+	let detached = false;
+	let execution: CellExecution;
+	const cell = cellManager.create(invocation.cellId, invocation.input, (error) => execution.cancel(error));
+	execution = new CellExecution({
+		callerSignal: invocation.signal,
+		cellId: invocation.cellId,
+		...(detaches
+			? {
+					idle: {
+						timeoutMs: detachAfterMs,
+						maxPauseGraceMs: foregroundWindowMs,
+						onTimeout: (error: Error) => {
+							if (cellManager.detach(cell)) {
+								detached = true;
+								execution.detach();
+								return;
+							}
+							execution.cancel(error);
+						},
+					},
+				}
+			: {}),
+		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
+		onAbort: (error) => {
+			state.active = false;
+			bridgeAbortController.abort(error);
+		},
+	});
+	const running = executeCell(
+		options,
+		invocation,
+		cellManager,
+		cell,
+		state,
+		execution,
+		bridgeContext,
+		bridgeAbortController,
+	);
+	let settleEventEmitted = false;
+	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
+		if (settleEventEmitted) return;
+		settleEventEmitted = true;
+		options.onCellSettled?.(
+			buildEvalExecutionEventPayload({
+				cellId: invocation.cellId,
+				state,
+				outcome,
+				completedAt: Date.now(),
+				detached,
+			}),
+		);
+	};
+	const finalized = running.then(
+		(result) => {
+			cellManager.complete(cell, result);
+			emitSettled({ result });
+			return result;
+		},
+		(error: unknown) => {
+			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
+			emitSettled({ error });
+			throw error;
+		},
+	);
+	const outcome = await Promise.race([
+		finalized.then((result) => ({ kind: "result" as const, result })),
+		execution.detached.then(() => ({ kind: "detached" as const })),
+	]);
+	if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
+	return outcome.result;
+}
+
+async function executeCell(
+	options: CreateEvalToolOptions,
+	invocation: EvalCellInvocation,
+	cellManager: EvalDetachedCellManager,
+	cell: Parameters<EvalDetachedCellManager["markRunning"]>[0],
+	state: CellState,
+	execution: CellExecution,
+	bridgeContext: ExtensionContext,
+	bridgeAbortController: AbortController,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	let handler: CellHandler | undefined;
+	try {
+		const kernel = await execution.wait(
+			options.kernelManager.getKernel(invocation.input.language, (message) => {
+				if (!state.active || handler === undefined) return;
+				if (message.type === "status") {
+					if (message.event.op === TIMEOUT_PAUSE_OP) {
+						execution.pause();
+						cellManager.pause(cell);
+						return;
+					}
+					if (message.event.op === TIMEOUT_RESUME_OP) {
+						execution.resume();
+						cellManager.resume(cell);
+						return;
+					}
+				}
+				const pending = handler.handle(message);
+				void pending.catch((error: unknown) => execution.cancel(error));
+			}),
+		);
+		execution.setKernel(kernel);
+		const activeHandler = new CellHandler(kernel, state, {
+			executeTool: options.executeTool,
+			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
+			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 }),
+		});
+		handler = activeHandler;
+		cellManager.markRunning(
+			cell,
+			kernel,
+			() => activeHandler.liveResult(),
+			(error) => execution.cancel(error),
+		);
+		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) {
+		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
+			return await handler.finalizeCancellation(error);
+		if (error instanceof Error && error.name === "TimeoutError") throw await describeTimeoutState(error, execution);
+		throw error;
+	} finally {
+		state.active = false;
+		bridgeAbortController.abort();
+		execution.finish();
+		if (handler) await handler.flushOutput();
+	}
+}

package/src/tool/types.ts

@@ -1,6 +1,12 @@
 import type { AgentToolResult, AgentToolUpdateCallback } from "@code-yeongyu/senpi";
-import { type TUnsafe, Type } from "typebox";
+import { type TSchema, type TUnsafe, Type } from "typebox";
 import type { HostToKernelMessage, KernelToHostMessage } from "../bridge/protocol.ts";
+import {
+	DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	DEFAULT_HARD_LIMIT_SECONDS,
+	DEFAULT_RUN_BUDGET_SECONDS,
+	defaultCodemodeSettings,
+} from "../config/settings.ts";
 import type { TruncationMeta } from "../output/output-meta.ts";
 
 export const evalLanguageOrder = ["js", "py", "rb", "jl"] as const;
@@ -13,11 +19,30 @@ export function enabledLanguageList(enabled: EnabledEvalLanguages): EvalLanguage
 
 export const EVAL_SUMMARY_MAX_LENGTH = 80;
 
-const TIMEOUT_FIELD_DESCRIPTION =
-	"Seconds the cell may block the turn before it detaches, and the amount by which it raises the wall-clock hard limit. In interactive sessions the detach point is capped at the foreground window (default 60s), so a large value frees the turn at the window while the cell keeps running; on_timeout:'error' (and print/json) keep the full value as the uncapped deadline.";
+/** The deadlines the schema teaches the model; every number comes from the resolved settings. */
+export interface EvalDeadlineSeconds {
+	readonly runBudgetSeconds: number;
+	/** Effective interactive detach point: `cellTimeoutSeconds` capped by the foreground window. */
+	readonly detachAfterSeconds: number;
+	/** Longest a host tool call can hold an interactive call before it detaches anyway. */
+	readonly foregroundWindowSeconds: number;
+	readonly hardLimitSeconds: number;
+}
+
+export const defaultEvalDeadlineSeconds: EvalDeadlineSeconds = {
+	runBudgetSeconds: DEFAULT_RUN_BUDGET_SECONDS,
+	detachAfterSeconds: Math.min(defaultCodemodeSettings.cellTimeoutSeconds, DEFAULT_FOREGROUND_WINDOW_SECONDS),
+	foregroundWindowSeconds: DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
+};
 
-const ON_TIMEOUT_FIELD_DESCRIPTION =
-	"Timeout behavior. Interactive sessions detach by default (at the foreground window); print/json sessions error by default. 'error' uses the full timeout as an uncapped deadline.";
+function timeoutFieldDescription(deadlines: EvalDeadlineSeconds): string {
+	return `Run budget in seconds for this cell's own execution (default ${deadlines.runBudgetSeconds}s); time parked in host tool calls such as agent() or tool.* is not charged. When it runs out the cell is killed, and a js cell that cannot settle (a pending timer or Bun.$ command, a synchronous call) restarts its kernel and loses every global. Raise it only for a declared long run; a value above ${deadlines.hardLimitSeconds}s also raises the wall-clock hard limit. It does not move the detach point.`;
+}
+
+function onTimeoutFieldDescription(deadlines: EvalDeadlineSeconds): string {
+	return `'detach' (interactive default): the call returns after ${deadlines.detachAfterSeconds}s of the cell's own work (a host tool call in flight can hold it up to the ${deadlines.foregroundWindowSeconds}s foreground window) while the cell keeps running; completion arrives as a notification. 'error' (print/json default): the call blocks until the cell settles or a deadline kills it.`;
+}
 
 export interface EvalToolInput {
 	readonly language: EvalLanguage;
@@ -36,69 +61,54 @@ export interface EvalControlInput {
 
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
-const fullEvalInputSchema = Type.Object({
-	action: Type.Optional(
-		Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
-			description: "Defaults to run. peek and stop require cell_id.",
-		}),
-	),
-	language: Type.Optional(
+function evalInputProperties<Language extends TSchema>(languageSchema: Language, deadlines: EvalDeadlineSeconds) {
+	return {
+		action: Type.Optional(
+			Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
+				description: "Defaults to run. peek and stop require cell_id.",
+			}),
+		),
+		language: Type.Optional(languageSchema),
+		code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
+		summary: Type.Optional(
+			Type.String({
+				maxLength: EVAL_SUMMARY_MAX_LENGTH,
+				description:
+					"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
+			}),
+		),
+		timeout: Type.Optional(Type.Number({ minimum: 1, description: timeoutFieldDescription(deadlines) })),
+		on_timeout: Type.Optional(
+			Type.Union([Type.Literal("detach"), Type.Literal("error")], {
+				description: onTimeoutFieldDescription(deadlines),
+			}),
+		),
+		reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
+		cell_id: Type.Optional(Type.String({ description: "Detached eval cell id for peek or stop." })),
+	};
+}
+
+const fullEvalInputSchema = Type.Object(
+	evalInputProperties(
 		Type.Union([Type.Literal("js"), Type.Literal("py"), Type.Literal("rb"), Type.Literal("jl")]),
+		defaultEvalDeadlineSeconds,
 	),
-	code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
-	summary: Type.Optional(
-		Type.String({
-			maxLength: EVAL_SUMMARY_MAX_LENGTH,
-			description:
-				"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
-		}),
-	),
-	timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
-	on_timeout: Type.Optional(
-		Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-			description: ON_TIMEOUT_FIELD_DESCRIPTION,
-		}),
-	),
-	reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
-	cell_id: Type.Optional(Type.String({ description: "Detached eval cell id for peek or stop." })),
-});
+);
 
 /** Runtime accepts a discriminated run/control union. */
 export type EvalInputSchema = TUnsafe<EvalToolRequest> & Pick<typeof fullEvalInputSchema, "properties">;
 
-export function createEvalInputSchema(enabled: EnabledEvalLanguages): EvalInputSchema {
+export function createEvalInputSchema(
+	enabled: EnabledEvalLanguages,
+	deadlines: EvalDeadlineSeconds = defaultEvalDeadlineSeconds,
+): EvalInputSchema {
 	const languages = enabledLanguageList(enabled);
 	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
 	const languageSchema =
 		languages.length === 1
 			? Type.Union([Type.Literal(languages[0])])
 			: Type.Union(languages.map((item) => Type.Literal(item)));
-	return Type.Unsafe<EvalToolRequest>(
-		Type.Object({
-			action: Type.Optional(
-				Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
-					description: "Defaults to run. peek and stop require cell_id.",
-				}),
-			),
-			language: Type.Optional(languageSchema),
-			code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
-			summary: Type.Optional(
-				Type.String({
-					maxLength: EVAL_SUMMARY_MAX_LENGTH,
-					description:
-						"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
-				}),
-			),
-			timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
-			on_timeout: Type.Optional(
-				Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-					description: ON_TIMEOUT_FIELD_DESCRIPTION,
-				}),
-			),
-			reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
-			cell_id: Type.Optional(Type.String({ description: "Detached eval cell id for peek or stop." })),
-		}),
-	) as EvalInputSchema;
+	return Type.Unsafe<EvalToolRequest>(Type.Object(evalInputProperties(languageSchema, deadlines))) as EvalInputSchema;
 }
 export type EvalKernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 export type EvalToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;