@oh-my-pi/pi-coding-agent 12.3.0 → 12.5.0

package/src/sdk.ts

@@ -441,6 +441,58 @@ function createCustomToolsExtension(tools: CustomTool[]): ExtensionFactory {
 		api.on("session_shutdown", async (_event, ctx) =>
 			runOnSession({ reason: "shutdown", previousSessionFile: undefined }, ctx),
 		);
+		api.on("auto_compaction_start", async (event, ctx) =>
+			runOnSession({ reason: "auto_compaction_start", trigger: event.reason }, ctx),
+		);
+		api.on("auto_compaction_end", async (event, ctx) =>
+			runOnSession(
+				{
+					reason: "auto_compaction_end",
+					result: event.result,
+					aborted: event.aborted,
+					willRetry: event.willRetry,
+					errorMessage: event.errorMessage,
+				},
+				ctx,
+			),
+		);
+		api.on("auto_retry_start", async (event, ctx) =>
+			runOnSession(
+				{
+					reason: "auto_retry_start",
+					attempt: event.attempt,
+					maxAttempts: event.maxAttempts,
+					delayMs: event.delayMs,
+					errorMessage: event.errorMessage,
+				},
+				ctx,
+			),
+		);
+		api.on("auto_retry_end", async (event, ctx) =>
+			runOnSession(
+				{
+					reason: "auto_retry_end",
+					success: event.success,
+					attempt: event.attempt,
+					finalError: event.finalError,
+				},
+				ctx,
+			),
+		);
+		api.on("ttsr_triggered", async (event, ctx) =>
+			runOnSession({ reason: "ttsr_triggered", rules: event.rules }, ctx),
+		);
+		api.on("todo_reminder", async (event, ctx) =>
+			runOnSession(
+				{
+					reason: "todo_reminder",
+					todos: event.todos,
+					attempt: event.attempt,
+					maxAttempts: event.maxAttempts,
+				},
+				ctx,
+			),
+		);
 	};
 }
 
@@ -496,6 +548,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("settings");
 	initializeWithSettings(settings);
 	time("initializeWithSettings");
+	const skillsSettings = settings.getGroup("skills") as SkillsSettings;
+	const discoveredSkillsPromise =
+		options.skills === undefined ? discoverSkills(cwd, agentDir, skillsSettings) : undefined;
 
 	// Initialize provider preferences from settings
 	setPreferredSearchProvider(settings.get("providers.webSearch") ?? "auto");
@@ -504,6 +559,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const sessionManager = options.sessionManager ?? SessionManager.create(cwd);
 	time("sessionManager");
 	const sessionId = sessionManager.getSessionId();
+	const modelApiKeyAvailability = new Map<string, boolean>();
+	const getModelAvailabilityKey = (candidate: Model): string =>
+		`${candidate.provider}\u0000${candidate.baseUrl ?? ""}`;
+	const hasModelApiKey = async (candidate: Model): Promise<boolean> => {
+		const availabilityKey = getModelAvailabilityKey(candidate);
+		const cached = modelApiKeyAvailability.get(availabilityKey);
+		if (cached !== undefined) {
+			return cached;
+		}
+
+		const hasKey = !!(await modelRegistry.getApiKey(candidate, sessionId));
+		modelApiKeyAvailability.set(availabilityKey, hasKey);
+		return hasKey;
+	};
 
 	// Check if session has existing data to restore
 	const existingSession = sessionManager.buildSessionContext();
@@ -521,7 +590,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const parsedModel = parseModelString(defaultModelStr);
 		if (parsedModel) {
 			const restoredModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
-			if (restoredModel && (await modelRegistry.getApiKey(restoredModel, sessionId))) {
+			if (restoredModel && (await hasModelApiKey(restoredModel))) {
 				model = restoredModel;
 			}
 		}
@@ -537,7 +606,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			const parsedModel = parseModelString(settingsDefaultModel);
 			if (parsedModel) {
 				const settingsModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
-				if (settingsModel && (await modelRegistry.getApiKey(settingsModel, sessionId))) {
+				if (settingsModel && (await hasModelApiKey(settingsModel))) {
 					model = settingsModel;
 				}
 			}
@@ -547,10 +616,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Fall back to first available model with a valid API key
 	if (!model) {
 		const allModels = modelRegistry.getAll();
-		const keyResults = await Promise.all(
-			allModels.map(async m => ({ model: m, hasKey: !!(await modelRegistry.getApiKey(m, sessionId)) })),
-		);
-		model = keyResults.find(r => r.hasKey)?.model;
+		for (const candidate of allModels) {
+			if (await hasModelApiKey(candidate)) {
+				model = candidate;
+				break;
+			}
+		}
 		time("findAvailableModel");
 		if (model) {
 			if (modelFallbackMessage) {
@@ -563,6 +634,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
+	time("findModel");
+
 	// For subagent sessions using GitHub Copilot, add X-Initiator header
 	// to ensure proper billing (agent-initiated vs user-initiated)
 	const taskDepth = options.taskDepth ?? 0;
@@ -604,12 +677,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		skills = options.skills;
 		skillWarnings = [];
 	} else {
-		const skillsSettings = settings.getGroup("skills") as SkillsSettings;
-		const discovered = await discoverSkills(cwd, agentDir, skillsSettings);
+		const discovered = discoveredSkillsPromise ? await discoveredSkillsPromise : { skills: [], warnings: [] };
+		time("discoverSkills");
 		skills = discovered.skills;
 		skillWarnings = discovered.warnings;
 	}
-	time("discoverSkills");
+
 	debugStartup("sdk:discoverSkills");
 
 	// Discover rules

package/src/session/agent-session.ts

@@ -66,7 +66,7 @@ import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
 import { resolvePlanUrlToPath } from "../internal-urls";
 import { executePython as executePythonCommand, type PythonResult } from "../ipy/executor";
-import { theme } from "../modes/theme/theme";
+import { getCurrentThemeName, theme } from "../modes/theme/theme";
 import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../patch";
 import type { PlanModeState } from "../plan-mode/state";
 import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
@@ -340,6 +340,7 @@ export class AgentSession {
 	#streamingEditCheckedLineCounts = new Map<string, number>();
 	#streamingEditFileCache = new Map<string, string>();
 	#promptInFlight = false;
+	#promptGeneration = 0;
 	#providerSessionState = new Map<string, ProviderSessionState>();
 
 	constructor(config: AgentSessionConfig) {
@@ -400,6 +401,11 @@ export class AgentSession {
 		}
 	}
 
+	async #emitSessionEvent(event: AgentSessionEvent): Promise<void> {
+		await this.#emitExtensionEvent(event);
+		this.#emit(event);
+	}
+
 	// Track last assistant message for auto-compaction check
 	#lastAssistantMessage: AssistantMessage | undefined = undefined;
 
@@ -424,11 +430,7 @@ export class AgentSession {
 			}
 		}
 
-		// Emit to extensions first
-		await this.#emitExtensionEvent(event);
-
-		// Notify all listeners
-		this.#emit(event);
+		await this.#emitSessionEvent(event);
 
 		if (event.type === "turn_start") {
 			this.#resetStreamingEditState();
@@ -453,11 +455,11 @@ export class AgentSession {
 					this.#ttsrManager.markInjected(matches);
 					// Store for injection on retry
 					this.#pendingTtsrInjections.push(...matches);
-					// Emit TTSR event before aborting (so UI can handle it)
+					// Abort the stream immediately — do not gate on extension callbacks
 					this.#ttsrAbortPending = true;
-					this.#emit({ type: "ttsr_triggered", rules: matches });
-					// Abort the stream
 					this.agent.abort();
+					// Notify extensions (fire-and-forget, does not block abort)
+					this.#emitSessionEvent({ type: "ttsr_triggered", rules: matches }).catch(() => {});
 					// Schedule retry after a short delay
 					setTimeout(async () => {
 						this.#ttsrAbortPending = false;
@@ -525,8 +527,12 @@ export class AgentSession {
 				// Reset retry counter immediately on successful assistant response
 				// This prevents accumulation across multiple LLM calls within a turn
 				const assistantMsg = event.message as AssistantMessage;
-				if (assistantMsg.stopReason !== "error" && this.#retryAttempt > 0) {
-					this.#emit({
+				if (
+					assistantMsg.stopReason !== "error" &&
+					assistantMsg.stopReason !== "aborted" &&
+					this.#retryAttempt > 0
+				) {
+					await this.#emitSessionEvent({
 						type: "auto_retry_end",
 						success: true,
 						attempt: this.#retryAttempt,
@@ -537,11 +543,13 @@ export class AgentSession {
 			}
 
 			if (event.message.role === "toolResult") {
-				const { toolName, $normative, toolCallId, details } = event.message as {
+				const { toolName, $normative, toolCallId, details, isError, content } = event.message as {
 					toolName?: string;
 					toolCallId?: string;
 					details?: { path?: string };
 					$normative?: Record<string, unknown>;
+					isError?: boolean;
+					content?: Array<TextContent | ImageContent>;
 				};
 				if ($normative && toolCallId && this.settings.get("normativeRewrite")) {
 					await this.#rewriteToolCallArgs(toolCallId, $normative);
@@ -550,6 +558,25 @@ export class AgentSession {
 				if (toolName === "edit" && details?.path) {
 					this.#invalidateFileCacheForPath(details.path);
 				}
+				if (toolName === "todo_write" && isError) {
+					const errorText = content?.find(part => part.type === "text")?.text;
+					const reminderText = [
+						"<system_reminder>",
+						"todo_write failed, so todo progress is not visible to the user.",
+						errorText ? `Failure: ${errorText}` : "Failure: todo_write returned an error.",
+						"Fix the todo payload and call todo_write again before continuing.",
+						"</system_reminder>",
+					].join("\n");
+					await this.sendCustomMessage(
+						{
+							customType: "todo-write-error-reminder",
+							content: reminderText,
+							display: false,
+							details: { toolName, errorText },
+						},
+						{ deliverAs: "nextTurn" },
+					);
+				}
 			}
 		}
 
@@ -823,10 +850,9 @@ export class AgentSession {
 		}
 	}
 
-	/** Emit extension events based on agent events */
-	async #emitExtensionEvent(event: AgentEvent): Promise<void> {
+	/** Emit extension events based on session events */
+	async #emitExtensionEvent(event: AgentSessionEvent): Promise<void> {
 		if (!this.#extensionRunner) return;
-
 		if (event.type === "agent_start") {
 			this.#turnIndex = 0;
 			await this.#extensionRunner.emit({ type: "agent_start" });
@@ -848,6 +874,40 @@ export class AgentSession {
 			};
 			await this.#extensionRunner.emit(hookEvent);
 			this.#turnIndex++;
+		} else if (event.type === "auto_compaction_start") {
+			await this.#extensionRunner.emit({ type: "auto_compaction_start", reason: event.reason });
+		} else if (event.type === "auto_compaction_end") {
+			await this.#extensionRunner.emit({
+				type: "auto_compaction_end",
+				result: event.result,
+				aborted: event.aborted,
+				willRetry: event.willRetry,
+				errorMessage: event.errorMessage,
+			});
+		} else if (event.type === "auto_retry_start") {
+			await this.#extensionRunner.emit({
+				type: "auto_retry_start",
+				attempt: event.attempt,
+				maxAttempts: event.maxAttempts,
+				delayMs: event.delayMs,
+				errorMessage: event.errorMessage,
+			});
+		} else if (event.type === "auto_retry_end") {
+			await this.#extensionRunner.emit({
+				type: "auto_retry_end",
+				success: event.success,
+				attempt: event.attempt,
+				finalError: event.finalError,
+			});
+		} else if (event.type === "ttsr_triggered") {
+			await this.#extensionRunner.emit({ type: "ttsr_triggered", rules: event.rules });
+		} else if (event.type === "todo_reminder") {
+			await this.#extensionRunner.emit({
+				type: "todo_reminder",
+				todos: event.todos,
+				attempt: event.attempt,
+				maxAttempts: event.maxAttempts,
+			});
 		}
 	}
 
@@ -1342,6 +1402,7 @@ export class AgentSession {
 		options?: Pick<PromptOptions, "toolChoice" | "images">,
 	): Promise<void> {
 		this.#promptInFlight = true;
+		const generation = this.#promptGeneration;
 		try {
 			// Flush any pending bash messages before the new prompt
 			this.#flushPendingBashMessages();
@@ -1387,6 +1448,12 @@ export class AgentSession {
 
 			messages.push(message);
 
+			// Early bail-out: if a newer abort/prompt cycle started during setup,
+			// return before mutating shared state (nextTurn messages, system prompt).
+			if (this.#promptGeneration !== generation) {
+				return;
+			}
+
 			// Inject any pending "nextTurn" messages as context alongside the user message
 			for (const msg of this.#pendingNextTurnMessages) {
 				messages.push(msg);
@@ -1430,6 +1497,11 @@ export class AgentSession {
 				}
 			}
 
+			// Bail out if a newer abort/prompt cycle has started since we began setup
+			if (this.#promptGeneration !== generation) {
+				return;
+			}
+
 			const agentPromptOptions = options?.toolChoice ? { toolChoice: options.toolChoice } : undefined;
 			await this.agent.prompt(messages, agentPromptOptions);
 			await this.#waitForRetry();
@@ -1797,8 +1869,14 @@ export class AgentSession {
 	 */
 	async abort(): Promise<void> {
 		this.abortRetry();
+		this.#promptGeneration++;
 		this.agent.abort();
 		await this.agent.waitForIdle();
+		// Clear promptInFlight: waitForIdle resolves when the agent loop's finally
+		// block runs (#resolveRunningPrompt), but #promptWithMessage's finally
+		// (#promptInFlight = false) fires on a later microtask. Without this,
+		// isStreaming stays true and a subsequent prompt() throws.
+		this.#promptInFlight = false;
 	}
 
 	/**
@@ -2672,7 +2750,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		});
 
 		// Emit event for UI to render notification
-		this.#emit({
+		await this.#emitSessionEvent({
 			type: "todo_reminder",
 			todos: incomplete,
 			attempt: this.#todoReminderCount,
@@ -2743,7 +2821,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	async #runAutoCompaction(reason: "overflow" | "threshold", willRetry: boolean): Promise<void> {
 		const compactionSettings = this.settings.getGroup("compaction");
 
-		this.#emit({ type: "auto_compaction_start", reason });
+		await this.#emitSessionEvent({ type: "auto_compaction_start", reason });
 		// Properly abort and null existing controller before replacing
 		if (this.#autoCompactionAbortController) {
 			this.#autoCompactionAbortController.abort();
@@ -2752,13 +2830,23 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 		try {
 			if (!this.model) {
-				this.#emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+				await this.#emitSessionEvent({
+					type: "auto_compaction_end",
+					result: undefined,
+					aborted: false,
+					willRetry: false,
+				});
 				return;
 			}
 
 			const availableModels = this.#modelRegistry.getAvailable();
 			if (availableModels.length === 0) {
-				this.#emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+				await this.#emitSessionEvent({
+					type: "auto_compaction_end",
+					result: undefined,
+					aborted: false,
+					willRetry: false,
+				});
 				return;
 			}
 
@@ -2766,7 +2854,12 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 			const preparation = prepareCompaction(pathEntries, compactionSettings);
 			if (!preparation) {
-				this.#emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+				await this.#emitSessionEvent({
+					type: "auto_compaction_end",
+					result: undefined,
+					aborted: false,
+					willRetry: false,
+				});
 				return;
 			}
 
@@ -2786,7 +2879,12 @@ Be thorough - include exact file paths, function names, error messages, and tech
 				})) as SessionBeforeCompactResult | undefined;
 
 				if (hookResult?.cancel) {
-					this.#emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+					await this.#emitSessionEvent({
+						type: "auto_compaction_end",
+						result: undefined,
+						aborted: true,
+						willRetry: false,
+					});
 					return;
 				}
 
@@ -2914,7 +3012,12 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			}
 
 			if (this.#autoCompactionAbortController.signal.aborted) {
-				this.#emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+				await this.#emitSessionEvent({
+					type: "auto_compaction_end",
+					result: undefined,
+					aborted: true,
+					willRetry: false,
+				});
 				return;
 			}
 
@@ -2952,7 +3055,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 				details,
 				preserveData,
 			};
-			this.#emit({ type: "auto_compaction_end", result, aborted: false, willRetry });
+			await this.#emitSessionEvent({ type: "auto_compaction_end", result, aborted: false, willRetry });
 
 			if (!willRetry && compactionSettings.autoContinue !== false) {
 				await this.prompt("Continue if you have next steps.", {
@@ -2980,11 +3083,16 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			}
 		} catch (error) {
 			if (this.#autoCompactionAbortController?.signal.aborted) {
-				this.#emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+				await this.#emitSessionEvent({
+					type: "auto_compaction_end",
+					result: undefined,
+					aborted: true,
+					willRetry: false,
+				});
 				return;
 			}
 			const errorMessage = error instanceof Error ? error.message : "compaction failed";
-			this.#emit({
+			await this.#emitSessionEvent({
 				type: "auto_compaction_end",
 				result: undefined,
 				aborted: false,
@@ -3106,7 +3214,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 		if (this.#retryAttempt > retrySettings.maxRetries) {
 			// Max retries exceeded, emit final failure and reset
-			this.#emit({
+			await this.#emitSessionEvent({
 				type: "auto_retry_end",
 				success: false,
 				attempt: this.#retryAttempt - 1,
@@ -3135,7 +3243,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			}
 		}
 
-		this.#emit({
+		await this.#emitSessionEvent({
 			type: "auto_retry_start",
 			attempt: this.#retryAttempt,
 			maxAttempts: retrySettings.maxRetries,
@@ -3162,7 +3270,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			const attempt = this.#retryAttempt;
 			this.#retryAttempt = 0;
 			this.#retryAbortController = undefined;
-			this.#emit({
+			await this.#emitSessionEvent({
 				type: "auto_retry_end",
 				success: false,
 				attempt,
@@ -3932,7 +4040,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	 * @returns Path to exported file
 	 */
 	async exportToHtml(outputPath?: string): Promise<string> {
-		const themeName = this.settings.get("theme");
+		const themeName = getCurrentThemeName();
 		return exportSessionToHtml(this.sessionManager, this.state, { outputPath, themeName });
 	}
 

package/src/session/streaming-output.ts

@@ -1,4 +1,4 @@
-import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { DEFAULT_MAX_BYTES } from "../tools/truncate";
 
 export interface OutputSummary {

package/src/stt/downloader.ts

@@ -0,0 +1,71 @@
+import { logger } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
+import { resolvePython } from "./transcriber";
+
+export interface DownloadProgress {
+	stage: string;
+	percent?: number;
+}
+
+export interface EnsureOptions {
+	modelName?: string;
+	onProgress?: (progress: DownloadProgress) => void;
+}
+
+// ── Recording tool ─────────────────────────────────────────────────
+
+async function ensureRecordingTool(options?: EnsureOptions): Promise<void> {
+	if (Bun.which("sox")) return;
+	if (Bun.which("ffmpeg")) return;
+	if (process.platform === "linux" && Bun.which("arecord")) return;
+
+	// Windows: PowerShell mciSendString is always available as fallback
+	if (process.platform === "win32") {
+		// Try to get ffmpeg for better quality, but don't block on failure
+		options?.onProgress?.({ stage: "Trying to install FFmpeg via winget..." });
+		const result = await $`winget install --id Gyan.FFmpeg -e --accept-source-agreements --accept-package-agreements`
+			.quiet()
+			.nothrow();
+		if (result.exitCode === 0) {
+			logger.debug("FFmpeg installed via winget");
+		}
+		return;
+	}
+
+	throw new Error(
+		"No audio recording tool found. Install SoX: sudo apt install sox, or FFmpeg: sudo apt install ffmpeg",
+	);
+}
+
+// ── Python whisper ─────────────────────────────────────────────────
+
+async function ensurePythonWhisper(options?: EnsureOptions): Promise<void> {
+	const pythonCmd = resolvePython();
+	if (!pythonCmd) {
+		throw new Error("Python not found. Install Python 3.8+ from https://python.org");
+	}
+
+	// Check if whisper module is already importable
+	const check = Bun.spawnSync([pythonCmd, "-c", "import whisper"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	if (check.exitCode === 0) return;
+
+	options?.onProgress?.({ stage: "Installing openai-whisper (this may take a few minutes)..." });
+	logger.debug("Installing openai-whisper via pip");
+
+	const install = await $`${pythonCmd} -m pip install -q openai-whisper`.quiet().nothrow();
+	if (install.exitCode !== 0) {
+		const stderr = install.stderr.toString().trim();
+		throw new Error(`Failed to install openai-whisper: ${stderr.split("\n").pop()}`);
+	}
+	logger.debug("openai-whisper installed successfully");
+}
+
+// ── Public API ─────────────────────────────────────────────────────
+
+export async function ensureSTTDependencies(options?: EnsureOptions): Promise<void> {
+	await ensureRecordingTool(options);
+	await ensurePythonWhisper(options);
+}

package/src/stt/index.ts

@@ -0,0 +1,3 @@
+export { type DownloadProgress, ensureSTTDependencies } from "./downloader";
+export { checkDependencies, formatDependencyStatus, type STTDependencyStatus } from "./setup";
+export { STTController, type SttState } from "./stt-controller";