@code-yeongyu/senpi 2026.7.10 → 2026.7.11

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-queue.ts

@@ -0,0 +1,100 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelResult, KernelRunInput, ToolCallMessage } from "./subprocess-contract.ts";
+import { createPendingRun, failureResult, type PendingRun, settlePendingRun } from "./subprocess-run.ts";
+
+export class SubprocessRunQueue {
+	readonly #queue: PendingRun[] = [];
+	readonly #pendingCalls: ToolCallMessage[] = [];
+	readonly #callWaiters: Array<(message: ToolCallMessage) => void> = [];
+	#active: PendingRun | null = null;
+
+	get active(): PendingRun | null {
+		return this.#active;
+	}
+
+	enqueue(input: KernelRunInput): Promise<KernelResult> {
+		return new Promise((resolve) => this.#queue.push(createPendingRun(input, resolve)));
+	}
+
+	startNext(startedAt: number): PendingRun | null {
+		if (this.#active) return null;
+		const next = this.#queue.shift() ?? null;
+		if (next) next.startedAt = startedAt;
+		this.#active = next;
+		return next;
+	}
+
+	takeWaiting(): PendingRun | null {
+		return this.#queue.shift() ?? null;
+	}
+
+	releaseActive(run: PendingRun): boolean {
+		if (this.#active !== run) return false;
+		this.#active = null;
+		return true;
+	}
+
+	settle(run: PendingRun, result: KernelResult): void {
+		if (settlePendingRun(run, result) && this.#active === run) this.#active = null;
+	}
+
+	settleAll(error: Error): void {
+		const runs = this.#active ? [this.#active, ...this.#queue] : [...this.#queue];
+		this.#active = null;
+		this.#queue.length = 0;
+		for (const run of runs) this.settle(run, failureResult(run, error));
+	}
+
+	clearToolCalls(): void {
+		this.#pendingCalls.length = 0;
+		this.#callWaiters.length = 0;
+	}
+
+	nextToolCall(): Promise<ToolCallMessage> {
+		const queued = this.#pendingCalls.shift();
+		if (queued !== undefined) return Promise.resolve(queued);
+		return new Promise((resolve) => this.#callWaiters.push(resolve));
+	}
+
+	pushToolCall(message: ToolCallMessage): void {
+		const waiter = this.#callWaiters.shift();
+		if (waiter) waiter(message);
+		else this.#pendingCalls.push(message);
+	}
+
+	handleMessage(
+		message: KernelToHostMessage,
+		onMessage: ((message: KernelToHostMessage) => void) | undefined,
+	): boolean {
+		switch (message.type) {
+			case "result": {
+				const run = this.#active;
+				if (!run || run.input.cellId !== message.cellId) return false;
+				onMessage?.(message);
+				this.releaseActive(run);
+				this.settle(run, message);
+				return true;
+			}
+			case "tool-call":
+				if (!this.#active) return false;
+				onMessage?.(message);
+				this.pushToolCall(message);
+				return false;
+			case "text":
+			case "display":
+			case "log":
+			case "phase":
+				if (this.#active) onMessage?.(message);
+				return false;
+			case "ready":
+			case "init-failed":
+			case "closed":
+				onMessage?.(message);
+				return false;
+			default: {
+				const exhaustive: never = message;
+				return exhaustive;
+			}
+		}
+	}
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-run.ts

@@ -0,0 +1,98 @@
+import type { KernelResult, KernelRunInput } from "./subprocess-contract.ts";
+
+export interface PendingRun {
+	readonly input: KernelRunInput;
+	readonly resolve: (message: KernelResult) => void;
+	timer: NodeJS.Timeout | null;
+	startedAt: number | null;
+	settled: boolean;
+}
+
+export class KernelClosedError extends Error {
+	constructor() {
+		super("Kernel is closed");
+		this.name = "KernelClosedError";
+	}
+}
+
+export class KernelStartupError extends Error {
+	constructor(message: string) {
+		super(`Kernel startup failed: ${message}`);
+		this.name = "KernelStartupError";
+	}
+}
+
+export class KernelRetirementError extends Error {
+	constructor() {
+		super("Kernel process did not exit after SIGKILL");
+		this.name = "KernelRetirementError";
+	}
+}
+
+export class KernelExitedError extends Error {
+	constructor(status: string | number) {
+		super(`Kernel exited before completing the cell (${status})`);
+		this.name = "KernelExitedError";
+	}
+}
+
+export class KernelProcessError extends Error {
+	constructor(message: string) {
+		super(`Kernel process error: ${message}`);
+		this.name = "KernelProcessError";
+	}
+}
+
+export class CellInterruptedError extends Error {
+	constructor(reason: string) {
+		super(reason === "Eval interrupted" ? reason : `Eval interrupted: ${reason}`);
+		this.name = "CellInterruptedError";
+	}
+}
+
+export class KernelResetError extends Error {
+	constructor() {
+		super("Kernel reset");
+		this.name = "KernelResetError";
+	}
+}
+
+export class KernelClosingError extends Error {
+	constructor() {
+		super("Kernel closed");
+		this.name = "KernelClosingError";
+	}
+}
+
+export function createPendingRun(input: KernelRunInput, resolve: (message: KernelResult) => void): PendingRun {
+	return { input, resolve, timer: null, startedAt: null, settled: false };
+}
+
+export function failureResult(run: PendingRun, error: Error): KernelResult {
+	return {
+		type: "result",
+		cellId: run.input.cellId,
+		ok: false,
+		error: { message: error.message },
+		durationMs: run.startedAt === null ? 0 : Math.max(0, Math.round(performance.now() - run.startedAt)),
+	};
+}
+
+export function timeoutResult(run: PendingRun, timeoutMs: number): KernelResult {
+	return {
+		type: "result",
+		cellId: run.input.cellId,
+		ok: false,
+		error: { message: `Cell timed out after ${timeoutMs}ms` },
+		durationMs: timeoutMs,
+	};
+}
+
+export function settlePendingRun(run: PendingRun, result: KernelResult): boolean {
+	if (run.settled) return false;
+	run.settled = true;
+	if (run.timer) clearTimeout(run.timer);
+	run.timer = null;
+	run.resolve(result);
+	return true;
+}

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

@@ -0,0 +1,205 @@
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } 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 type { EvalKernel, EvalToolDetails, EvalToolInput, ExecuteTool } 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 CellState {
+	readonly cellId: string;
+	readonly language: EvalToolInput["language"];
+	readonly title: string | undefined;
+	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>[];
+	active: boolean;
+	output: string;
+	phase: string | undefined;
+	durationMs: number;
+}
+
+export interface CellBridgeRuntime {
+	readonly executeTool: ExecuteTool;
+	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	readonly ctx: ExtensionContext;
+}
+
+export class CellHandler {
+	readonly #kernel: EvalKernel;
+	readonly #state: CellState;
+	readonly #runtime: CellBridgeRuntime;
+
+	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
+		this.#kernel = kernel;
+		this.#state = state;
+		this.#runtime = runtime;
+	}
+
+	async handle(message: KernelToHostMessage): Promise<void> {
+		if (!this.#state.active) return;
+		if (message.type === "text") {
+			this.#state.output += message.data;
+			this.#emitUpdate(false);
+			return;
+		}
+		if (message.type === "phase") {
+			this.#state.phase = message.title;
+			this.#emitUpdate(false);
+			return;
+		}
+		if (message.type === "log") {
+			this.#state.output += `${message.message}\n`;
+			this.#emitUpdate(false);
+			return;
+		}
+		if (message.type === "display") {
+			this.#state.images.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
+			this.#state.output += `[display: ${message.mimeType}]\n`;
+			this.#emitUpdate(false);
+			return;
+		}
+		if (message.type === "tool-call") {
+			const pending = this.#handleToolCall(message);
+			this.#state.pendingBridgeCalls.push(pending);
+			await pending;
+		}
+	}
+
+	finalize(result: Extract<KernelToHostMessage, { type: "result" }>): AgentToolResult<EvalToolDetails> {
+		this.#state.durationMs = result.durationMs;
+		if (result.ok && result.valueRepr) this.#state.output += `${result.valueRepr}\n`;
+		if (!result.ok) this.#state.output += `${result.error.message}\n`;
+		const truncation = truncateTail(this.#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).]`
+			: "";
+		return {
+			content: [{ type: "text", text: `${truncation.content}${suffix}` }, ...this.#state.images],
+			details: this.#details(truncation.truncated, !result.ok),
+		};
+	}
+
+	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 === "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;
+		}
+		try {
+			const result = await this.#runtime.executeTool(message.toolName, message.args, {
+				signal: this.#state.signal,
+			});
+			if (!this.#state.active) return;
+			this.#state.toolCalls.push({ name: message.toolName, ok: !toolResultIsError(result) });
+			this.#kernel.deliverToolReply({
+				type: "tool-reply",
+				callId: message.callId,
+				ok: true,
+				value: marshalToolResult(result),
+			});
+		} catch (error) {
+			if (!this.#state.active) return;
+			const messageText = error instanceof Error ? error.message : String(error);
+			this.#state.toolCalls.push({ name: message.toolName, ok: false, error: messageText });
+			this.#kernel.deliverToolReply({
+				type: "tool-reply",
+				callId: message.callId,
+				ok: false,
+				error: { message: messageText },
+			});
+		}
+		this.#emitUpdate(false);
+	}
+
+	#details(truncated: boolean, isError: boolean): EvalToolDetails {
+		return {
+			language: this.#state.language,
+			title: this.#state.title,
+			durationMs: this.#state.durationMs,
+			toolCalls: this.#state.toolCalls,
+			truncated,
+			isError,
+			phase: this.#state.phase,
+		};
+	}
+
+	#emitUpdate(isError: boolean): void {
+		if (!this.#state.active) return;
+		this.#state.onUpdate?.({
+			content: [{ type: "text", text: this.#state.output }],
+			details: this.#details(false, isError),
+		});
+	}
+}
+
+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 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"
+	);
+}