@oh-my-pi/pi-coding-agent 5.5.0 → 5.6.70

package/src/core/keybindings.ts

@@ -29,7 +29,8 @@ export type AppAction =
 	| "externalEditor"
 	| "historySearch"
 	| "followUp"
-	| "dequeue";
+	| "dequeue"
+	| "pasteImage";
 
 /**
  * All configurable actions.
@@ -61,6 +62,7 @@ export const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
 	externalEditor: "ctrl+g",
 	followUp: "ctrl+enter",
 	dequeue: "alt+up",
+	pasteImage: "ctrl+v",
 };
 
 /**
@@ -87,12 +89,60 @@ const APP_ACTIONS: AppAction[] = [
 	"externalEditor",
 	"followUp",
 	"dequeue",
+	"pasteImage",
 ];
 
 function isAppAction(action: string): action is AppAction {
 	return APP_ACTIONS.includes(action as AppAction);
 }
 
+/**
+ * Key hint formatting utilities for UI labels.
+ */
+const MODIFIER_LABELS: Record<string, string> = {
+	ctrl: "Ctrl",
+	shift: "Shift",
+	alt: "Alt",
+};
+
+const KEY_LABELS: Record<string, string> = {
+	esc: "Esc",
+	escape: "Esc",
+	enter: "Enter",
+	return: "Enter",
+	space: "Space",
+	tab: "Tab",
+	backspace: "Backspace",
+	delete: "Delete",
+	home: "Home",
+	end: "End",
+	pageup: "PgUp",
+	pagedown: "PgDn",
+	up: "Up",
+	down: "Down",
+	left: "Left",
+	right: "Right",
+};
+
+function formatKeyPart(part: string): string {
+	const lower = part.toLowerCase();
+	const modifier = MODIFIER_LABELS[lower];
+	if (modifier) return modifier;
+	const label = KEY_LABELS[lower];
+	if (label) return label;
+	if (part.length === 1) return part.toUpperCase();
+	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+}
+
+export function formatKeyHint(key: KeyId): string {
+	return key.split("+").map(formatKeyPart).join("+");
+}
+
+export function formatKeyHints(keys: KeyId | KeyId[]): string {
+	const list = Array.isArray(keys) ? keys : [keys];
+	return list.map(formatKeyHint).join("/");
+}
+
 /**
  * Manages all keybindings (app + editor).
  */

package/src/core/prompt-templates.ts

@@ -335,6 +335,21 @@ export function substituteArgs(content: string, args: string[]): string {
 		return args[index] ?? "";
 	});
 
+	result = result.replace(/\$@\[(\d+)(?::(\d*)?)?\]/g, (_, startRaw: string, lengthRaw?: string) => {
+		const start = Number.parseInt(startRaw, 10);
+		if (!Number.isFinite(start) || start < 1) return "";
+		const startIndex = start - 1;
+		if (startIndex >= args.length) return "";
+
+		if (lengthRaw === undefined || lengthRaw === "") {
+			return args.slice(startIndex).join(" ");
+		}
+
+		const length = Number.parseInt(lengthRaw, 10);
+		if (!Number.isFinite(length) || length <= 0) return "";
+		return args.slice(startIndex, startIndex + length).join(" ");
+	});
+
 	// Pre-compute all args joined (optimization)
 	const allArgs = args.join(" ");
 

package/src/core/python-executor-display.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test";
+import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
+import type { KernelDisplayOutput, KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
+
+class FakeKernel implements PythonKernelExecutor {
+	private result: KernelExecuteResult;
+	private onExecute: (options?: KernelExecuteOptions) => Promise<void> | void;
+
+	constructor(result: KernelExecuteResult, onExecute: (options?: KernelExecuteOptions) => Promise<void> | void) {
+		this.result = result;
+		this.onExecute = onExecute;
+	}
+
+	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
+		await this.onExecute(options);
+		return this.result;
+	}
+}
+
+describe("executePythonWithKernel display outputs", () => {
+	it("aggregates display outputs in order", async () => {
+		const outputs: KernelDisplayOutput[] = [
+			{ type: "json", data: { foo: "bar" } },
+			{ type: "image", data: "abc", mimeType: "image/png" },
+		];
+
+		const kernel = new FakeKernel(
+			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
+			async (options) => {
+				if (!options?.onDisplay) return;
+				for (const output of outputs) {
+					await options.onDisplay(output);
+				}
+			},
+		);
+
+		const result = await executePythonWithKernel(kernel, "print('hi')");
+
+		expect(result.exitCode).toBe(0);
+		expect(result.displayOutputs).toEqual(outputs);
+	});
+});

package/src/core/python-executor-lifecycle.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it, vi } from "bun:test";
+import { disposeAllKernelSessions, executePython } from "./python-executor";
+import type { KernelExecuteResult } from "./python-kernel";
+import * as pythonKernel from "./python-kernel";
+
+class FakeKernel {
+	execute = vi.fn(async () => this.result);
+	shutdown = vi.fn(async () => {});
+	ping = vi.fn(async () => true);
+	alive = true;
+
+	constructor(private readonly result: KernelExecuteResult) {}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+}
+
+const OK_RESULT: KernelExecuteResult = {
+	status: "ok",
+	cancelled: false,
+	timedOut: false,
+	stdinRequested: false,
+};
+
+afterEach(async () => {
+	vi.restoreAllMocks();
+	await disposeAllKernelSessions();
+});
+
+describe("executePython lifecycle", () => {
+	it("starts and shuts down per-call kernels", async () => {
+		const kernel = new FakeKernel(OK_RESULT);
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi
+			.spyOn(pythonKernel.PythonKernel, "start")
+			.mockResolvedValue(kernel as unknown as pythonKernel.PythonKernel);
+
+		await executePython("print('hi')", { kernelMode: "per-call", cwd: process.cwd() });
+
+		expect(startSpy).toHaveBeenCalledTimes(1);
+		expect(kernel.execute).toHaveBeenCalledTimes(1);
+		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
+	});
+
+	it("reuses session kernels until reset", async () => {
+		const kernel = new FakeKernel(OK_RESULT);
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi
+			.spyOn(pythonKernel.PythonKernel, "start")
+			.mockResolvedValue(kernel as unknown as pythonKernel.PythonKernel);
+
+		await executePython("1 + 1", { kernelMode: "session", sessionId: "test-session", cwd: process.cwd() });
+		await executePython("2 + 2", { kernelMode: "session", sessionId: "test-session", cwd: process.cwd() });
+
+		expect(startSpy).toHaveBeenCalledTimes(1);
+		expect(kernel.execute).toHaveBeenCalledTimes(2);
+	});
+
+	it("resets session kernels when requested", async () => {
+		const kernel = new FakeKernel(OK_RESULT);
+		const kernelNext = new FakeKernel(OK_RESULT);
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi
+			.spyOn(pythonKernel.PythonKernel, "start")
+			.mockResolvedValueOnce(kernel as unknown as pythonKernel.PythonKernel)
+			.mockResolvedValueOnce(kernelNext as unknown as pythonKernel.PythonKernel);
+
+		await executePython("1 + 1", { kernelMode: "session", sessionId: "reset-session", cwd: process.cwd() });
+		await executePython("2 + 2", {
+			kernelMode: "session",
+			sessionId: "reset-session",
+			reset: true,
+			cwd: process.cwd(),
+		});
+
+		expect(startSpy).toHaveBeenCalledTimes(2);
+		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
+		expect(kernelNext.execute).toHaveBeenCalledTimes(1);
+	});
+
+	it("restarts session kernels when they are dead", async () => {
+		const kernel = new FakeKernel(OK_RESULT);
+		const kernelNext = new FakeKernel(OK_RESULT);
+		kernel.alive = false;
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi
+			.spyOn(pythonKernel.PythonKernel, "start")
+			.mockResolvedValueOnce(kernel as unknown as pythonKernel.PythonKernel)
+			.mockResolvedValueOnce(kernelNext as unknown as pythonKernel.PythonKernel);
+
+		await executePython("1 + 1", { kernelMode: "session", sessionId: "dead-session", cwd: process.cwd() });
+
+		expect(startSpy).toHaveBeenCalledTimes(2);
+		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
+		expect(kernel.execute).toHaveBeenCalledTimes(0);
+		expect(kernelNext.execute).toHaveBeenCalledTimes(1);
+	});
+});

package/src/core/python-executor-mapping.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test";
+import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
+import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
+
+class FakeKernel implements PythonKernelExecutor {
+	constructor(
+		private result: KernelExecuteResult,
+		private onExecute: (options?: KernelExecuteOptions) => void = () => {},
+	) {}
+
+	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
+		this.onExecute(options);
+		return this.result;
+	}
+}
+
+describe("executePythonWithKernel mapping", () => {
+	it("annotates timeout cancellations", async () => {
+		const kernel = new FakeKernel({ status: "ok", cancelled: true, timedOut: true, stdinRequested: false });
+		const result = await executePythonWithKernel(kernel, "sleep(10)", { timeout: 5000 });
+
+		expect(result.cancelled).toBe(true);
+		expect(result.exitCode).toBeUndefined();
+		expect(result.output).toContain("Command timed out after 5 seconds");
+	});
+
+	it("maps error status to non-zero exit code", async () => {
+		const kernel = new FakeKernel(
+			{ status: "error", cancelled: false, timedOut: false, stdinRequested: false },
+			(options) => {
+				options?.onChunk?.("traceback\n");
+			},
+		);
+
+		const result = await executePythonWithKernel(kernel, "1 / 0");
+
+		expect(result.exitCode).toBe(1);
+		expect(result.output).toContain("traceback");
+		expect(result.stdinRequested).toBe(false);
+	});
+});

package/src/core/python-executor-per-call.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "bun:test";
+import { executePython } from "./python-executor";
+import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
+import { PythonKernel } from "./python-kernel";
+
+interface KernelStub {
+	execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
+	shutdown: () => Promise<void>;
+}
+
+describe("executePython (per-call)", () => {
+	it("shuts down kernel on timed-out cancellation", async () => {
+		process.env.OMP_PYTHON_SKIP_CHECK = "1";
+
+		let shutdownCalls = 0;
+		const kernel: KernelStub = {
+			execute: async () => ({
+				status: "ok",
+				cancelled: true,
+				timedOut: true,
+				stdinRequested: false,
+			}),
+			shutdown: async () => {
+				shutdownCalls += 1;
+			},
+		};
+
+		const kernelClass = PythonKernel as unknown as {
+			start: (options: { cwd: string }) => Promise<KernelStub>;
+		};
+		const originalStart = kernelClass.start;
+		kernelClass.start = async () => kernel;
+
+		try {
+			const result = await executePython("sleep(10)", {
+				kernelMode: "per-call",
+				timeout: 2000,
+				cwd: "/tmp",
+			});
+
+			expect(result.cancelled).toBe(true);
+			expect(result.exitCode).toBeUndefined();
+			expect(result.output).toContain("Command timed out after 2 seconds");
+			expect(shutdownCalls).toBe(1);
+		} finally {
+			kernelClass.start = originalStart;
+		}
+	});
+});

package/src/core/python-executor-session.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it, vi } from "bun:test";
+import { disposeAllKernelSessions, executePython } from "./python-executor";
+import * as pythonKernel from "./python-kernel";
+
+class FakeKernel {
+	executeCalls = 0;
+	shutdownCalls = 0;
+	alive = true;
+	constructor(private readonly shouldThrow: boolean = false) {}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	async execute(): Promise<{ status: "ok"; cancelled: false; timedOut: false; stdinRequested: false }> {
+		this.executeCalls += 1;
+		if (this.shouldThrow) {
+			this.alive = false;
+			throw new Error("kernel crashed");
+		}
+		return { status: "ok", cancelled: false, timedOut: false, stdinRequested: false };
+	}
+
+	async ping(): Promise<boolean> {
+		return this.alive;
+	}
+
+	async shutdown(): Promise<void> {
+		this.shutdownCalls += 1;
+		this.alive = false;
+	}
+}
+
+describe("executePython session lifecycle", () => {
+	afterEach(async () => {
+		vi.restoreAllMocks();
+		await disposeAllKernelSessions();
+	});
+
+	it("restarts session when kernel is not alive", async () => {
+		const kernel1 = new FakeKernel();
+		kernel1.alive = false;
+		const kernel2 = new FakeKernel();
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi
+			.spyOn(pythonKernel.PythonKernel, "start")
+			.mockResolvedValueOnce(kernel1 as unknown as pythonKernel.PythonKernel)
+			.mockResolvedValueOnce(kernel2 as unknown as pythonKernel.PythonKernel);
+
+		await executePython("print('hi')", { cwd: "/tmp", sessionId: "session-1", kernelMode: "session" });
+
+		expect(startSpy).toHaveBeenCalledTimes(2);
+		expect(kernel1.executeCalls).toBe(0);
+		expect(kernel1.shutdownCalls).toBe(1);
+		expect(kernel2.executeCalls).toBe(1);
+	});
+
+	it("restarts after an execution failure when kernel is dead", async () => {
+		const kernel1 = new FakeKernel(true);
+		const kernel2 = new FakeKernel();
+		const starts = [kernel1, kernel2];
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi.spyOn(pythonKernel.PythonKernel, "start").mockImplementation(async () => {
+			const next = starts.shift();
+			if (!next) {
+				throw new Error("No kernel available");
+			}
+			return next as unknown as pythonKernel.PythonKernel;
+		});
+
+		await executePython("raise", { cwd: "/tmp", sessionId: "session-2", kernelMode: "session" });
+
+		expect(startSpy).toHaveBeenCalledTimes(2);
+		expect(kernel1.executeCalls).toBe(1);
+		expect(kernel2.executeCalls).toBe(1);
+	});
+
+	it("resets existing session when requested", async () => {
+		const kernel1 = new FakeKernel();
+		const kernel2 = new FakeKernel();
+		const starts = [kernel1, kernel2];
+		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
+		const startSpy = vi.spyOn(pythonKernel.PythonKernel, "start").mockImplementation(async () => {
+			const next = starts.shift();
+			if (!next) {
+				throw new Error("No kernel available");
+			}
+			return next as unknown as pythonKernel.PythonKernel;
+		});
+
+		await executePython("print('one')", { cwd: "/tmp", sessionId: "session-3", kernelMode: "session" });
+		await executePython("print('two')", {
+			cwd: "/tmp",
+			sessionId: "session-3",
+			kernelMode: "session",
+			reset: true,
+		});
+
+		expect(startSpy).toHaveBeenCalledTimes(2);
+		expect(kernel1.shutdownCalls).toBe(1);
+		expect(kernel2.executeCalls).toBe(1);
+	});
+});

package/src/core/python-executor-streaming.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { rmSync } from "node:fs";
+import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
+import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
+import { DEFAULT_MAX_BYTES } from "./tools/truncate";
+
+class FakeKernel implements PythonKernelExecutor {
+	private result: KernelExecuteResult;
+	private onExecute: (options?: KernelExecuteOptions) => void;
+
+	constructor(result: KernelExecuteResult, onExecute: (options?: KernelExecuteOptions) => void) {
+		this.result = result;
+		this.onExecute = onExecute;
+	}
+
+	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
+		this.onExecute(options);
+		return this.result;
+	}
+}
+
+const cleanupPaths: string[] = [];
+
+afterEach(() => {
+	while (cleanupPaths.length > 0) {
+		const path = cleanupPaths.pop();
+		if (path) {
+			try {
+				rmSync(path, { force: true });
+			} catch {}
+		}
+	}
+});
+
+describe("executePythonWithKernel streaming", () => {
+	it("truncates large output and writes full output file", async () => {
+		const largeOutput = "a".repeat(DEFAULT_MAX_BYTES + 128);
+		const kernel = new FakeKernel(
+			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
+			(options) => {
+				options?.onChunk?.(largeOutput);
+			},
+		);
+
+		const result = await executePythonWithKernel(kernel, "print('hi')");
+
+		expect(result.truncated).toBe(true);
+		expect(result.fullOutputPath).toBeDefined();
+		expect(result.output.length).toBeLessThan(largeOutput.length);
+		if (result.fullOutputPath) {
+			cleanupPaths.push(result.fullOutputPath);
+		}
+	});
+
+	it("annotates timed out runs", async () => {
+		const kernel = new FakeKernel({ status: "ok", cancelled: true, timedOut: true, stdinRequested: false }, () => {});
+
+		const result = await executePythonWithKernel(kernel, "sleep", { timeout: 2000 });
+
+		expect(result.cancelled).toBe(true);
+		expect(result.exitCode).toBeUndefined();
+		expect(result.output).toContain("Command timed out after 2 seconds");
+	});
+
+	it("sanitizes ANSI and carriage returns", async () => {
+		const kernel = new FakeKernel(
+			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
+			(options) => {
+				options?.onChunk?.("\u001b[31mhello\r\n");
+			},
+		);
+
+		const result = await executePythonWithKernel(kernel, "print('hello')");
+
+		expect(result.output).toBe("hello\n");
+	});
+});

package/src/core/python-executor-timeout.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "bun:test";
+import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
+import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
+
+class FakeKernel implements PythonKernelExecutor {
+	private result: KernelExecuteResult;
+	private onExecute: (options?: KernelExecuteOptions) => void;
+
+	constructor(result: KernelExecuteResult, onExecute: (options?: KernelExecuteOptions) => void) {
+		this.result = result;
+		this.onExecute = onExecute;
+	}
+
+	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
+		this.onExecute(options);
+		return this.result;
+	}
+}
+
+describe("executePythonWithKernel cancellation", () => {
+	it("annotates timeouts when cancelled", async () => {
+		const kernel = new FakeKernel(
+			{ status: "ok", cancelled: true, timedOut: true, stdinRequested: false },
+			(options) => {
+				options?.onChunk?.("tick\n");
+			},
+		);
+
+		const result = await executePythonWithKernel(kernel, "sleep(10)", { timeout: 5000 });
+
+		expect(result.cancelled).toBe(true);
+		expect(result.exitCode).toBeUndefined();
+		expect(result.output).toContain("Command timed out after 5 seconds");
+	});
+});

package/src/core/python-executor.lifecycle.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { disposeAllKernelSessions, executePython } from "./python-executor";
+import { type KernelExecuteOptions, type KernelExecuteResult, PythonKernel } from "./python-kernel";
+
+process.env.OMP_PYTHON_SKIP_CHECK = "1";
+
+class FakeKernel {
+	private result: KernelExecuteResult;
+	private onExecute?: (options?: KernelExecuteOptions) => void;
+	private alive: boolean;
+	readonly executeCalls: string[] = [];
+	shutdownCalls = 0;
+
+	constructor(
+		result: KernelExecuteResult,
+		options: { alive?: boolean; onExecute?: (options?: KernelExecuteOptions) => void } = {},
+	) {
+		this.result = result;
+		this.onExecute = options.onExecute;
+		this.alive = options.alive ?? true;
+	}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	async execute(code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
+		this.executeCalls.push(code);
+		this.onExecute?.(options);
+		return this.result;
+	}
+
+	async shutdown(): Promise<void> {
+		this.shutdownCalls += 1;
+		this.alive = false;
+	}
+
+	async ping(): Promise<boolean> {
+		return this.alive;
+	}
+}
+
+const okResult: KernelExecuteResult = {
+	status: "ok",
+	cancelled: false,
+	timedOut: false,
+	stdinRequested: false,
+};
+
+describe("executePython session lifecycle", () => {
+	const originalStart = PythonKernel.start;
+
+	afterEach(async () => {
+		PythonKernel.start = originalStart;
+		await disposeAllKernelSessions();
+	});
+
+	it("reuses a session kernel across calls", async () => {
+		let startCount = 0;
+		const kernel = new FakeKernel(okResult, { onExecute: (options) => options?.onChunk?.("ok\n") });
+		PythonKernel.start = async () => {
+			startCount += 1;
+			return kernel as unknown as PythonKernel;
+		};
+
+		const first = await executePython("print('one')", { sessionId: "session-1" });
+		const second = await executePython("print('two')", { sessionId: "session-1" });
+
+		expect(startCount).toBe(1);
+		expect(kernel.executeCalls).toEqual(["print('one')", "print('two')"]);
+		expect(first.output).toContain("ok");
+		expect(second.output).toContain("ok");
+	});
+
+	it("restarts the session kernel when not alive", async () => {
+		const deadKernel = new FakeKernel(okResult, { alive: false });
+		const liveKernel = new FakeKernel(okResult, { onExecute: (options) => options?.onChunk?.("live\n") });
+		const kernels = [deadKernel, liveKernel];
+		let startCount = 0;
+
+		PythonKernel.start = async () => {
+			startCount += 1;
+			return kernels.shift() as unknown as PythonKernel;
+		};
+
+		const result = await executePython("print('restart')", { sessionId: "session-restart" });
+
+		expect(startCount).toBe(2);
+		expect(deadKernel.shutdownCalls).toBe(1);
+		expect(deadKernel.executeCalls).toEqual([]);
+		expect(liveKernel.executeCalls).toEqual(["print('restart')"]);
+		expect(result.output).toContain("live");
+	});
+
+	it("resets the session kernel when requested", async () => {
+		const firstKernel = new FakeKernel(okResult);
+		const secondKernel = new FakeKernel(okResult);
+		const kernels = [firstKernel, secondKernel];
+		let startCount = 0;
+
+		PythonKernel.start = async () => {
+			startCount += 1;
+			return kernels.shift() as unknown as PythonKernel;
+		};
+
+		await executePython("print('one')", { sessionId: "session-reset" });
+		await executePython("print('two')", { sessionId: "session-reset", reset: true });
+
+		expect(startCount).toBe(2);
+		expect(firstKernel.shutdownCalls).toBe(1);
+		expect(secondKernel.executeCalls).toEqual(["print('two')"]);
+	});
+
+	it("uses per-call kernels when configured", async () => {
+		const kernelA = new FakeKernel(okResult);
+		const kernelB = new FakeKernel(okResult);
+		const kernels = [kernelA, kernelB];
+		let startCount = 0;
+		let shutdownCount = 0;
+
+		PythonKernel.start = async () => {
+			startCount += 1;
+			return kernels.shift() as unknown as PythonKernel;
+		};
+
+		kernelA.shutdown = async () => {
+			shutdownCount += 1;
+		};
+		kernelB.shutdown = async () => {
+			shutdownCount += 1;
+		};
+
+		await executePython("print('one')", { kernelMode: "per-call" });
+		await executePython("print('two')", { kernelMode: "per-call" });
+
+		expect(startCount).toBe(2);
+		expect(shutdownCount).toBe(2);
+	});
+});