@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/tool/cell-handler.ts

@@ -0,0 +1,279 @@
+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 };
+
+const LIVE_OUTPUT_PREVIEW_LINES = 8;
+
+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 }),
+		};
+	}
+
+	#liveUpdateText(): string {
+		const title = this.#state.input.title === undefined ? "" : ` ${this.#state.input.title}`;
+		const aggregateOutput = this.#output.aggregateText();
+		const outputLines = aggregateOutput.split("\n");
+		const hasTrailingNewline = aggregateOutput.endsWith("\n");
+		if (hasTrailingNewline) outputLines.pop();
+		const output = `${outputLines.slice(-LIVE_OUTPUT_PREVIEW_LINES).join("\n")}${hasTrailingNewline ? "\n" : ""}`;
+		return `1/1 cells ${this.#state.status}\n[1] ${this.#state.input.language}${title} ${this.#state.status}${output.length === 0 ? "" : `\n${output}`}`;
+	}
+
+	#emitUpdate(isError: boolean): void {
+		if (!this.#state.active) return;
+		this.#state.onUpdate?.({
+			content: [{ type: "text", text: this.#liveUpdateText() }],
+			details: this.#details(undefined, isError),
+		});
+	}
+}

package/src/tool/eval-tool.ts

@@ -0,0 +1,285 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.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 { 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,
+	type EvalToolInput,
+	type ExecuteTool,
+	enabledLanguageList,
+} from "./types.ts";
+
+export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
+
+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;
+	/** Active model id; selects the emphasis dialect of the eval prompt. */
+	readonly modelId?: string;
+	/** Preformatted host line rendered into the prompt's host-sizing note. */
+	readonly hostLine?: string;
+}
+
+interface EvalCellInvocation {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly signal: AbortSignal;
+	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
+	readonly ctx: ExtensionContext;
+}
+
+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, {
+		spawns: options.spawns ?? false,
+		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
+		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
+		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
+	});
+	const languages = enabledLanguageList(options.enabledLanguages);
+	return {
+		name: "eval",
+		label: "Eval",
+		description: prompt.description,
+		promptSnippet: prompt.promptSnippet,
+		promptGuidelines: [...prompt.promptGuidelines],
+		parameters,
+		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 (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(", ")}`,
+				);
+			options.executionTracker?.assertEvalExecutionAllowed();
+			const lifecycleController = new AbortController();
+			const combinedSignal = signal
+				? AbortSignal.any([signal, lifecycleController.signal])
+				: lifecycleController.signal;
+			const execution = runEvalCell(options, {
+				cellId: toolCallId,
+				input: params,
+				signal: combinedSignal,
+				onUpdate,
+				ctx,
+			});
+			return options.executionTracker
+				? await options.executionTracker.trackEvalExecution(execution, lifecycleController)
+				: await execution;
+		},
+	};
+}
+
+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 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) {
+		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();
+	}
+}
+
+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;
+}