@code-yeongyu/senpi-codemode 2026.7.31-2 → 2026.8.1

package/src/tool/detached-eval-result.ts

@@ -0,0 +1,140 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import type {
+	EvalDetachedCellManager,
+	EvalDetachedCellSnapshot,
+	EvalDetachedCellState,
+} from "./detached-cell-manager.ts";
+import { interruptionStateNote } from "./interrupt-note.ts";
+import type { EvalCellResult, EvalControlInput, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+export async function executeEvalControl(
+	cellManager: EvalDetachedCellManager,
+	request: EvalControlInput,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	const snapshot =
+		request.action === "stop" ? await cellManager.stop(request.cell_id) : cellManager.peek(request.cell_id);
+	return createDetachedControlResult(snapshot);
+}
+
+export function resultAfterDetach(
+	snapshot: EvalDetachedCellSnapshot,
+	input: EvalToolInput,
+): AgentToolResult<EvalToolDetails> {
+	if (snapshot.state !== "detached" && snapshot.state !== "running") return createDetachedControlResult(snapshot);
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Eval cell ${snapshot.cellId} detached and is still running in the ${input.language} kernel. Completion will arrive as a notification. Use eval({ action: "peek", cell_id: "${snapshot.cellId}" }) or eval({ action: "stop", cell_id: "${snapshot.cellId}" }).`,
+			},
+		],
+		details: snapshot.result.details,
+	};
+}
+
+export function createDetachedControlResult(snapshot: EvalDetachedCellSnapshot): AgentToolResult<EvalToolDetails> {
+	const terminationNote =
+		snapshot.state === "cancelled" ? interruptionStateNote(snapshot.language, snapshot.stateRetained) : undefined;
+	const output = textContent(snapshot.result);
+	const text = [
+		`Eval cell ${snapshot.cellId} (${snapshot.language}) is ${snapshot.state}.`,
+		output.length === 0 ? "(no buffered output)" : output,
+		...(terminationNote === undefined ? [] : [terminationNote]),
+	].join("\n");
+	return {
+		content: [{ type: "text", text }, ...snapshot.result.content.filter((part) => part.type === "image")],
+		details: {
+			...snapshot.result.details,
+			...(snapshot.state === "failed" ? { isError: true } : {}),
+		},
+	};
+}
+
+export function resultForDetachedState(
+	result: AgentToolResult<EvalToolDetails>,
+	state: EvalDetachedCellState,
+	durationMs: number,
+): AgentToolResult<EvalToolDetails> {
+	const details = result.details;
+	const cells = details.cells ?? [];
+	const nextCells =
+		cells.length === 0
+			? []
+			: cells.map((cell, index) =>
+					index === 0
+						? {
+								...cell,
+								durationMs: terminalDuration(cell, state, durationMs),
+								status: cellStatus(state),
+							}
+						: { ...cell },
+				);
+	return {
+		content: result.content.map((part) => ({ ...part })),
+		details: {
+			...details,
+			durationMs: terminalDuration(details, state, durationMs),
+			toolCalls: details.toolCalls.map((toolCall) => ({ ...toolCall })),
+			...(details.statusEvents === undefined
+				? {}
+				: {
+						statusEvents: details.statusEvents.map((event) => ({
+							...event,
+						})),
+					}),
+			...(nextCells.length === 0
+				? {}
+				: {
+						cells: nextCells.map((cell) => ({
+							...cell,
+							...(cell.statusEvents === undefined
+								? {}
+								: {
+										statusEvents: cell.statusEvents.map((event) => ({
+											...event,
+										})),
+									}),
+						})),
+					}),
+			...(details.jsonOutputs === undefined ? {} : { jsonOutputs: structuredClone(details.jsonOutputs) }),
+		},
+	};
+}
+
+export function detachedKernelBusyError(snapshot: EvalDetachedCellSnapshot): Error {
+	const tail = snapshot.outputTail.length === 0 ? "(no output yet)" : snapshot.outputTail;
+	return new Error(
+		`The ${snapshot.language} eval kernel is busy running detached cell ${snapshot.cellId}. Do not re-run it; use eval({ action: "peek", cell_id: "${snapshot.cellId}" }). Current output tail:\n${tail}`,
+	);
+}
+
+function textContent(result: AgentToolResult<EvalToolDetails>): string {
+	return result.content
+		.filter((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function terminalDuration(
+	value: { readonly durationMs?: number },
+	state: EvalDetachedCellState,
+	liveDurationMs: number,
+): number {
+	if (state === "completed" || state === "failed" || state === "cancelled") return value.durationMs ?? liveDurationMs;
+	return liveDurationMs;
+}
+
+function cellStatus(state: EvalDetachedCellState): EvalCellResult["status"] {
+	switch (state) {
+		case "running":
+			return "running";
+		case "detached":
+			return "detached";
+		case "completed":
+			return "complete";
+		case "failed":
+			return "error";
+		case "cancelled":
+			return "cancelled";
+	}
+}

package/src/tool/detached-notification-queue.ts

@@ -0,0 +1,53 @@
+import type { EvalDetachedCellNotifier, EvalDetachedCellSnapshot } from "./detached-cell-manager.ts";
+import { buildDetachedCellNotification } from "./detached-cell-notification.ts";
+
+export interface PendingDetachedNotification {
+	readonly snapshot: () => EvalDetachedCellSnapshot;
+	readonly spillPath: string | undefined;
+}
+
+export class DetachedNotificationQueue {
+	readonly #artifactsDir: string | undefined;
+	readonly #notifier: EvalDetachedCellNotifier | undefined;
+	#pending: PendingDetachedNotification[] = [];
+	#flush: Promise<void> | undefined;
+
+	constructor(notifier: EvalDetachedCellNotifier | undefined, artifactsDir: string | undefined) {
+		this.#notifier = notifier;
+		this.#artifactsDir = artifactsDir;
+	}
+
+	enqueue(notification: PendingDetachedNotification): void {
+		this.#pending.push(notification);
+		this.#schedule();
+	}
+
+	async flush(): Promise<void> {
+		const flush = this.#flush;
+		if (flush !== undefined) await flush;
+	}
+
+	#schedule(): void {
+		if (this.#flush !== undefined) return;
+		const flush = Promise.resolve().then(async () => {
+			const pending = this.#pending.splice(0);
+			const notifications = await Promise.all(
+				pending.map(
+					async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath, this.#artifactsDir),
+				),
+			);
+			this.#notifier?.notify(notifications);
+		});
+		this.#flush = flush;
+		void flush.then(
+			() => this.#finish(flush),
+			() => this.#finish(flush),
+		);
+	}
+
+	#finish(flush: Promise<void>): void {
+		if (this.#flush !== flush) return;
+		this.#flush = undefined;
+		if (this.#pending.length > 0) this.#schedule();
+	}
+}

package/src/tool/eval-request.ts

@@ -0,0 +1,45 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalControlInput, EvalToolInput, EvalToolRequest } from "./types.ts";
+
+const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
+
+export function parseEvalRequest(params: unknown): EvalToolRequest {
+	if (!isRecord(params)) throw new TypeError("eval parameters must be an object");
+	if (params.action === "peek" || params.action === "stop") {
+		if (typeof params.cell_id !== "string" || params.cell_id.length === 0)
+			throw new TypeError(`eval action "${params.action}" requires cell_id`);
+		return { action: params.action, cell_id: params.cell_id };
+	}
+	if (params.action !== undefined && params.action !== "run")
+		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
+	if (!isEvalLanguage(params.language)) throw new TypeError("eval run requires language");
+	if (typeof params.code !== "string") throw new TypeError("eval run requires code");
+	if (params.on_timeout !== undefined && params.on_timeout !== "detach" && params.on_timeout !== "error")
+		throw new TypeError(`Unknown eval on_timeout value "${String(params.on_timeout)}"`);
+	return {
+		language: params.language,
+		code: params.code,
+		...(params.action === "run" ? { action: "run" as const } : {}),
+		...(typeof params.title === "string" ? { title: params.title } : {}),
+		...(typeof params.timeout === "number" ? { timeout: params.timeout } : {}),
+		...(params.on_timeout === "detach" || params.on_timeout === "error" ? { on_timeout: params.on_timeout } : {}),
+		...(typeof params.reset === "boolean" ? { reset: params.reset } : {}),
+	};
+}
+
+export function isEvalControlRequest(request: EvalToolRequest): request is EvalControlInput {
+	return request.action === "peek" || request.action === "stop";
+}
+
+export function evalTimeoutBehavior(input: EvalToolInput, ctx: ExtensionContext): "detach" | "error" {
+	if (input.on_timeout !== undefined) return input.on_timeout;
+	return NON_INTERACTIVE_MODES.has(ctx.mode) ? "error" : "detach";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function isEvalLanguage(value: unknown): value is EvalToolInput["language"] {
+	return value === "py" || value === "js" || value === "rb" || value === "jl";
+}

package/src/tool/eval-tool-options.ts

@@ -0,0 +1,45 @@
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
+import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { ResolvedCodemodeSettings } from "../config/settings.ts";
+import type { EvalExecutionTracker } from "../extension/session-manager.ts";
+import type { EvalTimeoutFactory } from "./cell-execution.ts";
+import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
+import type { EvalImageResizer } from "./image.ts";
+import type {
+	EnabledEvalLanguages,
+	EvalInputSchema,
+	EvalKernelManager,
+	EvalToolDetails,
+	EvalToolInput,
+	ExecuteTool,
+} from "./types.ts";
+
+export interface CreateEvalToolOptions {
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly kernelManager: EvalKernelManager;
+	readonly cellTimeoutSeconds: number;
+	readonly executeTool: ExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
+	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	readonly settings?: ResolvedCodemodeSettings;
+	readonly artifactsDir?: string;
+	readonly imageResizer?: EvalImageResizer;
+	readonly executionTracker?: EvalExecutionTracker;
+	readonly cellManager?: EvalDetachedCellManager;
+	readonly timeoutFactory?: EvalTimeoutFactory;
+	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
+	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
+	readonly spawns?: boolean;
+	readonly spawnDefaultAgent?: string;
+	readonly modelId?: string;
+	readonly hostLine?: string;
+}
+
+export interface EvalCellInvocation {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly signal: AbortSignal;
+	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
+	readonly ctx: ExtensionContext;
+}