@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/session/eval-runner.ts

@@ -0,0 +1,217 @@
+import type { Agent } from "@oh-my-pi/pi-agent-core";
+import { logger } from "@oh-my-pi/pi-utils";
+import type { Settings } from "../config/settings";
+import { disposeJuliaKernelSessionsByOwner } from "../eval/jl/executor";
+import { namespaceSessionId as namespacePythonSessionId } from "../eval/py";
+import {
+	disposeKernelSessionsByOwner,
+	executePython as executePythonCommand,
+	type PythonResult,
+} from "../eval/py/executor";
+import { disposeRubyKernelSessionsByOwner } from "../eval/rb/executor";
+import { defaultEvalSessionId } from "../eval/session-id";
+import type { ExtensionRunner } from "../extensibility/extensions";
+import { outputMeta } from "../tools/output-meta";
+import type { PythonExecutionMessage } from "./messages";
+import type { SessionManager } from "./session-manager";
+
+/** Capabilities the eval runner borrows from its owning session. */
+export interface EvalRunnerHost {
+	agent: Agent;
+	sessionManager: SessionManager;
+	settings: Settings;
+	extensionRunner(): ExtensionRunner | undefined;
+	isStreaming(): boolean;
+	appendSessionMessage(message: PythonExecutionMessage): void;
+}
+
+/** Owns user-initiated Python execution and retained eval-kernel lifecycle. */
+export class EvalRunner {
+	readonly #host: EvalRunnerHost;
+	readonly #kernelOwnerId: string;
+	readonly #parentSessionId: string | undefined;
+	#abortControllers = new Set<AbortController>();
+	#pendingMessages: PythonExecutionMessage[] = [];
+	#activeExecutions = new Set<Promise<unknown>>();
+	#disposing = false;
+
+	constructor(host: EvalRunnerHost, options: { kernelOwnerId: string; parentSessionId: string | undefined }) {
+		this.#host = host;
+		this.#kernelOwnerId = options.kernelOwnerId;
+		this.#parentSessionId = options.parentSessionId;
+	}
+
+	/** Executes Python in the session's shared kernel. */
+	async executePython(
+		code: string,
+		onChunk?: (chunk: string) => void,
+		options?: { excludeFromContext?: boolean },
+	): Promise<PythonResult> {
+		const excludeFromContext = options?.excludeFromContext === true;
+		const cwd = this.#host.sessionManager.getCwd();
+		this.assertExecutionAllowed();
+		const abortController = new AbortController();
+		const execution = (async (): Promise<PythonResult> => {
+			const extensionRunner = this.#host.extensionRunner();
+			if (extensionRunner?.hasHandlers("user_python")) {
+				const hookResult = await extensionRunner.emitUserPython({
+					type: "user_python",
+					code,
+					excludeFromContext,
+					cwd,
+				});
+				this.assertExecutionAllowed();
+				if (hookResult?.result) {
+					this.recordPythonResult(code, hookResult.result, options);
+					return hookResult.result;
+				}
+			}
+			const sessionId =
+				this.getSessionId() ??
+				defaultEvalSessionId({
+					cwd,
+					getSessionFile: () => this.#host.sessionManager.getSessionFile() ?? null,
+				});
+			const result = await executePythonCommand(code, {
+				cwd,
+				sessionId: namespacePythonSessionId(sessionId),
+				kernelOwnerId: this.#kernelOwnerId,
+				kernelMode: this.#host.settings.get("python.kernelMode"),
+				interpreter: this.#host.settings.get("python.interpreter")?.trim() || undefined,
+				onChunk,
+				signal: abortController.signal,
+			});
+			this.recordPythonResult(code, result, options);
+			return result;
+		})();
+		return await this.trackExecution(execution, abortController);
+	}
+
+	/** Rejects new eval work once session disposal begins. */
+	assertExecutionAllowed(): void {
+		if (this.#disposing) throw new Error("Python execution is unavailable while session disposal is in progress");
+	}
+
+	/** Tracks externally started Python work so disposal can await and abort it. */
+	trackExecution<T>(execution: Promise<T>, abortController: AbortController): Promise<T> {
+		this.#abortControllers.add(abortController);
+		this.#activeExecutions.add(execution);
+		void execution.then(
+			() => {
+				this.#abortControllers.delete(abortController);
+				this.#activeExecutions.delete(execution);
+			},
+			() => {
+				this.#abortControllers.delete(abortController);
+				this.#activeExecutions.delete(execution);
+			},
+		);
+		return execution;
+	}
+
+	/** Records a Python execution result in session history. */
+	recordPythonResult(code: string, result: PythonResult, options?: { excludeFromContext?: boolean }): void {
+		const meta = outputMeta().truncationFromSummary(result, { direction: "tail" }).get();
+		const message: PythonExecutionMessage = {
+			role: "pythonExecution",
+			code,
+			output: result.output,
+			exitCode: result.exitCode,
+			cancelled: result.cancelled,
+			truncated: result.truncated,
+			meta,
+			timestamp: Date.now(),
+			excludeFromContext: options?.excludeFromContext,
+		};
+		if (this.#host.isStreaming()) {
+			this.#pendingMessages.push(message);
+		} else {
+			this.#host.appendSessionMessage(message);
+		}
+	}
+
+	/** Cancels every running Python execution. */
+	abort(): void {
+		for (const abortController of this.#abortControllers) abortController.abort();
+	}
+
+	/** Whether a Python execution is currently running. */
+	get isRunning(): boolean {
+		return this.#abortControllers.size > 0;
+	}
+
+	/** Whether Python results are waiting for a safe persistence boundary. */
+	get hasPendingMessages(): boolean {
+		return this.#pendingMessages.length > 0;
+	}
+
+	/** Returns the stable owner shared by eval and session-owned tools. */
+	getKernelOwnerId(): string {
+		return this.#kernelOwnerId;
+	}
+
+	/** Returns the eval session shared with the Python backend. */
+	getSessionId(): string | null {
+		if (this.#parentSessionId !== undefined) return this.#parentSessionId;
+		return defaultEvalSessionId({
+			cwd: this.#host.sessionManager.getCwd(),
+			getSessionFile: () => this.#host.sessionManager.getSessionFile() ?? null,
+		});
+	}
+
+	/** Flushes deferred Python results into agent state and persistence. */
+	flushPending(): void {
+		if (this.#pendingMessages.length === 0) return;
+		for (const message of this.#pendingMessages) this.#host.appendSessionMessage(message);
+		this.#pendingMessages = [];
+	}
+
+	/** Prevents new Python executions before asynchronous disposal starts. */
+	beginDispose(): void {
+		this.#disposing = true;
+	}
+
+	/** Waits for active work and disposes every retained eval kernel owned by the session. */
+	async disposeKernels(): Promise<void> {
+		const settled = await this.#prepareExecutionsForDispose();
+		if (!settled) {
+			logger.warn("Detaching retained eval-kernel ownership during dispose while eval execution is still active");
+		}
+		const results = await Promise.allSettled([
+			disposeKernelSessionsByOwner(this.#kernelOwnerId),
+			disposeRubyKernelSessionsByOwner(this.#kernelOwnerId),
+			disposeJuliaKernelSessionsByOwner(this.#kernelOwnerId),
+		]);
+		const errors: unknown[] = [];
+		for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Failed to dispose one or more eval kernels");
+	}
+
+	async #waitForExecutionsToSettle(timeoutMs: number): Promise<boolean> {
+		const deadline = Date.now() + timeoutMs;
+		while (this.#activeExecutions.size > 0) {
+			const remainingMs = deadline - Date.now();
+			if (remainingMs <= 0) return false;
+			const settled = await Promise.race([
+				Promise.allSettled(Array.from(this.#activeExecutions)).then(() => true),
+				Bun.sleep(remainingMs).then(() => false),
+			]);
+			if (!settled && this.#activeExecutions.size > 0) return false;
+		}
+		return true;
+	}
+
+	async #prepareExecutionsForDispose(): Promise<boolean> {
+		if (!(await this.#waitForExecutionsToSettle(3_000))) {
+			logger.warn("Aborting active Python execution during dispose before retained kernel cleanup");
+			this.abort();
+			if (!(await this.#waitForExecutionsToSettle(1_000))) {
+				logger.warn(
+					"Python execution is still active after dispose aborted all active runs; retained kernel ownership will still be detached",
+				);
+				return false;
+			}
+		}
+		return true;
+	}
+}

package/src/session/indexed-session-storage.ts

@@ -270,8 +270,15 @@ export class IndexedSessionStorage implements SessionStorage {
 				{ trackDrain: false },
 			);
 		} catch (err) {
-			this.#restoreIndex(path, previous);
-			throw toError(err);
+			const error = toError(err);
+			try {
+				if ((await this.#backend.readFull(path)) === content) return;
+			} catch {
+				// Preserve the original write failure; verification was unavailable.
+			}
+			const current = this.#index.get(path);
+			if (current?.mtimeMs === mtimeMs) this.#restoreIndex(path, previous);
+			throw error;
 		}
 	}
 

package/src/session/irc-bridge.ts

@@ -0,0 +1,203 @@
+import type { Agent } from "@oh-my-pi/pi-agent-core";
+import { logger, prompt } from "@oh-my-pi/pi-utils";
+import type { Settings } from "../config/settings";
+import { IrcBus, type IrcMessage } from "../irc/bus";
+import parentIrcSteerTemplate from "../prompts/steering/parent-irc.md" with { type: "text" };
+import ircAutoReplyTemplate from "../prompts/system/irc-autoreply.md" with { type: "text" };
+import ircIncomingTemplate from "../prompts/system/irc-incoming.md" with { type: "text" };
+import { AgentRegistry } from "../registry/agent-registry";
+import type { AgentSessionEvent } from "./agent-session-events";
+import type { CustomMessage } from "./messages";
+import type { SessionManager } from "./session-manager";
+
+/** Capabilities the IRC bridge borrows from its owning session. */
+export interface IrcBridgeHost {
+	agent: Agent;
+	sessionManager: SessionManager;
+	settings: Settings;
+	isDisposed(): boolean;
+	isStreaming(): boolean;
+	planModeEnabled(): boolean;
+	emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+	wakeForIrc(records: CustomMessage[]): void;
+	runEphemeralTurn(args: { promptText: string }): Promise<{ replyText: string }>;
+}
+
+/** Owns incoming IRC queues, injection, and side-channel auto-replies. */
+export class IrcBridge {
+	readonly #host: IrcBridgeHost;
+	#interrupts: CustomMessage[] = [];
+	#asides: CustomMessage[] = [];
+
+	constructor(host: IrcBridgeHost) {
+		this.#host = host;
+	}
+
+	/** Whether an incoming peer message can interrupt a wait. */
+	hasInterrupts(): boolean {
+		return this.#interrupts.length > 0;
+	}
+
+	/** Whether any undelivered IRC record remains queued. */
+	hasPending(): boolean {
+		return this.#interrupts.length > 0 || this.#asides.length > 0;
+	}
+
+	/** Takes every queued IRC record in interrupt-before-aside order. */
+	drainPending(): CustomMessage[] {
+		const records = [...this.#interrupts, ...this.#asides];
+		this.#interrupts = [];
+		this.#asides = [];
+		return records;
+	}
+
+	/** Surfaces and consumes queued incoming records before automatic injection. */
+	drainInboxMessages(agentId: string, opts?: { from?: string; limit?: number }): IrcMessage[] {
+		const messages: IrcMessage[] = [];
+		const remainingInterrupts: CustomMessage[] = [];
+		const remainingAsides: CustomMessage[] = [];
+		const queues = [
+			{ records: this.#interrupts, remaining: remainingInterrupts },
+			{ records: this.#asides, remaining: remainingAsides },
+		];
+		for (const queue of queues) {
+			for (const record of queue.records) {
+				if (record.customType !== "irc:incoming") {
+					queue.remaining.push(record);
+					continue;
+				}
+				const details = record.details;
+				if (!details || typeof details !== "object") {
+					queue.remaining.push(record);
+					continue;
+				}
+				const id = Reflect.get(details, "id");
+				const from = Reflect.get(details, "from");
+				const body = Reflect.get(details, "message");
+				const replyTo = Reflect.get(details, "replyTo");
+				if (typeof id !== "string" || typeof from !== "string" || typeof body !== "string") {
+					queue.remaining.push(record);
+					continue;
+				}
+				if (opts?.from !== undefined && from !== opts.from) {
+					queue.remaining.push(record);
+					continue;
+				}
+				if (opts?.limit !== undefined && messages.length >= opts.limit) {
+					queue.remaining.push(record);
+					continue;
+				}
+				messages.push({
+					id,
+					from,
+					to: agentId,
+					body,
+					ts: record.timestamp,
+					...(typeof replyTo === "string" ? { replyTo } : {}),
+				});
+			}
+		}
+		this.#interrupts = remainingInterrupts;
+		this.#asides = remainingAsides;
+		return messages;
+	}
+
+	/** Delivers an IRC message into the recipient session without awaiting any wake turn. */
+	async deliver(msg: IrcMessage, opts?: { expectsReply?: boolean }): Promise<"injected" | "woken"> {
+		if (this.#host.isDisposed()) throw new Error("Recipient session is disposed.");
+		const streaming = this.#host.isStreaming();
+		const planModeIdle = !streaming && this.#host.planModeEnabled();
+		const autoReply =
+			(opts?.expectsReply ?? false) && ((streaming && !this.#host.settings.get("async.enabled")) || planModeIdle);
+		const record: CustomMessage = {
+			role: "custom",
+			customType: "irc:incoming",
+			content: prompt.render(ircIncomingTemplate, {
+				from: msg.from,
+				message: msg.body,
+				replyTo: msg.replyTo ?? "",
+				autoReplied: autoReply,
+				interrupting: streaming,
+			}),
+			display: true,
+			details: { id: msg.id, from: msg.from, message: msg.body, ...(msg.replyTo ? { replyTo: msg.replyTo } : {}) },
+			attribution: "agent",
+			timestamp: msg.ts,
+		};
+		void this.#host.emitSessionEvent({ type: "irc_message", message: record });
+		if (streaming) {
+			const recipientParentId = AgentRegistry.global().get(msg.to)?.parentId;
+			if (recipientParentId === msg.from) {
+				this.#host.agent.steer({
+					role: "user",
+					content: prompt.render(parentIrcSteerTemplate, { from: msg.from, message: msg.body }),
+					attribution: "agent",
+					timestamp: msg.ts,
+					steering: true,
+				});
+			} else {
+				this.#interrupts.push(record);
+			}
+			if (autoReply) void this.#runAutoReply(msg);
+			return "injected";
+		}
+		if (this.#host.planModeEnabled()) {
+			this.#host.agent.appendMessage(record);
+			this.#host.sessionManager.appendCustomMessageEntry(
+				record.customType,
+				record.content,
+				record.display,
+				record.details,
+				record.attribution ?? "agent",
+			);
+			if (autoReply) void this.#runAutoReply(msg);
+			return "injected";
+		}
+		this.#host.wakeForIrc([record]);
+		return "woken";
+	}
+
+	/** Emits an IRC relay observation for rendering without persisting it. */
+	emitRelayObservation(record: CustomMessage): void {
+		void this.#host.emitSessionEvent({ type: "irc_message", message: record });
+	}
+
+	/** Persists queued IRC records that missed their step-boundary injection. */
+	flushPending(): void {
+		for (const record of this.drainPending()) {
+			this.#host.agent.emitExternalEvent({ type: "message_start", message: record });
+			this.#host.agent.emitExternalEvent({ type: "message_end", message: record });
+		}
+	}
+
+	async #runAutoReply(msg: IrcMessage): Promise<void> {
+		try {
+			const { replyText } = await this.#host.runEphemeralTurn({
+				promptText: prompt.render(ircAutoReplyTemplate, {
+					from: msg.from,
+					message: msg.body,
+					replyTo: msg.replyTo ?? "",
+				}),
+			});
+			const body = replyText.trim();
+			if (!body || this.#host.isDisposed()) return;
+			const record: CustomMessage = {
+				role: "custom",
+				customType: "irc:autoreply",
+				content: `[IRC you → \`${msg.from}\` (auto)]\n\n${body}`,
+				display: true,
+				details: { to: msg.from, body, replyTo: msg.id },
+				attribution: "agent",
+				timestamp: Date.now(),
+			};
+			void this.#host.emitSessionEvent({ type: "irc_message", message: record });
+			this.#asides.push(record);
+			const receipt = await IrcBus.global().send({ from: msg.to, to: msg.from, body, replyTo: msg.id });
+			if (receipt.outcome === "failed") {
+				logger.warn("IRC auto-reply delivery failed", { to: msg.from, error: receipt.error });
+			}
+		} catch (error) {
+			logger.warn("IRC auto-reply turn failed", { from: msg.from, error: String(error) });
+		}
+	}
+}