@oh-my-pi/pi-coding-agent 6.7.67 → 6.8.0

package/src/core/tools/web-fetch.ts

@@ -1,9 +1,11 @@
+import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
+import { $ } from "bun";
 import { nanoid } from "nanoid";
 import { parse as parseHtml } from "node-html-parser";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
@@ -69,25 +71,21 @@ const CONVERTIBLE_EXTENSIONS = new Set([
 // Utilities
 // =============================================================================
 
-type SpawnSyncOptions = NonNullable<Parameters<typeof Bun.spawnSync>[1]>;
-
 /**
  * Execute a command and return stdout
  */
-function exec(
+
+async function exec(
 	cmd: string,
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer },
-): { stdout: string; stderr: string; ok: boolean } {
-	const stdin = (options?.input ?? "ignore") as SpawnSyncOptions["stdin"];
-	const result = Bun.spawnSync([cmd, ...args], {
-		stdin,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+): Promise<{ stdout: string; stderr: string; ok: boolean }> {
+	void options;
+	const result = await $`${cmd} ${args}`.quiet().nothrow();
+	const decoder = new TextDecoder();
 	return {
-		stdout: result.stdout?.toString() ?? "",
-		stderr: result.stderr?.toString() ?? "",
+		stdout: result.stdout ? decoder.decode(result.stdout) : "",
+		stderr: result.stderr ? decoder.decode(result.stderr) : "",
 		ok: result.exitCode === 0,
 	};
 }
@@ -420,7 +418,7 @@ async function renderHtmlToText(
 		if (lynx) {
 			const normalizedPath = tmpFile.replace(/\\/g, "/");
 			const fileUrl = normalizedPath.startsWith("/") ? `file://${normalizedPath}` : `file:///${normalizedPath}`;
-			const result = exec("lynx", ["-dump", "-nolist", "-width", "120", fileUrl], { timeout });
+			const result = await exec("lynx", ["-dump", "-nolist", "-width", "120", fileUrl], { timeout });
 			if (result.ok) {
 				return { content: result.stdout, ok: true, method: "lynx" };
 			}
@@ -429,7 +427,7 @@ async function renderHtmlToText(
 		// Fall back to html2text (auto-install via uv/pip)
 		const html2text = await ensureTool("html2text", true);
 		if (html2text) {
-			const result = exec(html2text, [tmpFile], { timeout });
+			const result = await exec(html2text, [tmpFile], { timeout });
 			if (result.ok) {
 				return { content: result.stdout, ok: true, method: "html2text" };
 			}
@@ -438,7 +436,7 @@ async function renderHtmlToText(
 		return { content: "", ok: false, method: "none" };
 	} finally {
 		try {
-			await Bun.$`rm ${tmpFile}`.quiet();
+			await rm(tmpFile, { force: true });
 		} catch {}
 	}
 }

package/src/core/tools/web-scrapers/types.ts

@@ -158,9 +158,7 @@ export async function loadPage(url: string, options: LoadPageOptions = {}): Prom
 				}
 			}
 
-			const decoder = new TextDecoder();
-			const content = decoder.decode(Buffer.concat(chunks));
-
+			const content = Buffer.concat(chunks).toString("utf-8");
 			if (isBotBlocked(response.status, content) && attempt < USER_AGENTS.length - 1) {
 				continue;
 			}

package/src/core/tools/web-scrapers/utils.ts

@@ -1,5 +1,7 @@
+import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
+import { $ } from "bun";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import { createRequestSignal } from "./types";
@@ -13,18 +15,17 @@ interface ExecResult {
 	exitCode: number;
 }
 
-type SpawnSyncOptions = NonNullable<Parameters<typeof Bun.spawnSync>[1]>;
-
-function exec(cmd: string, args: string[], options?: { timeout?: number; input?: string | Buffer }): ExecResult {
-	const stdin = (options?.input ?? "ignore") as SpawnSyncOptions["stdin"];
-	const result = Bun.spawnSync([cmd, ...args], {
-		stdin,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+async function exec(
+	cmd: string,
+	args: string[],
+	options?: { timeout?: number; input?: string | Buffer },
+): Promise<ExecResult> {
+	void options;
+	const result = await $`${cmd} ${args}`.quiet().nothrow();
+	const decoder = new TextDecoder();
 	return {
-		stdout: result.stdout?.toString() ?? "",
-		stderr: result.stderr?.toString() ?? "",
+		stdout: result.stdout ? decoder.decode(result.stdout) : "",
+		stderr: result.stderr ? decoder.decode(result.stderr) : "",
 		ok: result.exitCode === 0,
 		exitCode: result.exitCode ?? -1,
 	};
@@ -71,7 +72,7 @@ export async function convertWithMarkitdown(
 
 	try {
 		await Bun.write(tmpFile, content);
-		const result = exec(markitdown, [tmpFile], { timeout });
+		const result = await exec(markitdown, [tmpFile], { timeout });
 		if (!result.ok) {
 			const stderr = result.stderr.trim();
 			return {
@@ -83,7 +84,7 @@ export async function convertWithMarkitdown(
 		return { content: result.stdout, ok: true };
 	} finally {
 		try {
-			await Bun.$`rm ${tmpFile}`.quiet();
+			await rm(tmpFile, { force: true });
 		} catch {}
 	}
 }

package/src/core/tools/web-scrapers/youtube.ts

@@ -1,6 +1,7 @@
 import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import { cspawn } from "@oh-my-pi/pi-utils";
 import type { FileSink } from "bun";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
@@ -15,12 +16,21 @@ async function exec(
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
 ): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
-	const proc = Bun.spawn([cmd, ...args], {
-		stdin: options?.input ? "pipe" : "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-		timeout: options?.timeout,
-		signal: options?.signal,
+	const controller = new AbortController();
+	const onAbort = () => controller.abort(options?.signal?.reason ?? new Error("Aborted"));
+	if (options?.signal) {
+		if (options.signal.aborted) {
+			onAbort();
+		} else {
+			options.signal.addEventListener("abort", onAbort, { once: true });
+		}
+	}
+	const timeoutId =
+		options?.timeout && options.timeout > 0
+			? setTimeout(() => controller.abort(new Error("Timeout")), options.timeout)
+			: undefined;
+	const proc = cspawn([cmd, ...args], {
+		signal: controller.signal,
 	});
 
 	if (options?.input && proc.stdin) {
@@ -37,17 +47,34 @@ async function exec(
 		}
 	}
 
-	const [stdout, stderr] = await Promise.all([
-		(proc.stdout as ReadableStream<Uint8Array>).text(),
-		(proc.stderr as ReadableStream<Uint8Array>).text(),
+	const [stdout, stderr, exitResult] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		(async () => {
+			try {
+				await proc.exited;
+				return proc.exitCode ?? 0;
+			} catch (err) {
+				if (err && typeof err === "object" && "exitCode" in err) {
+					const exitValue = (err as { exitCode?: number }).exitCode;
+					if (typeof exitValue === "number") {
+						return exitValue;
+					}
+				}
+				throw err instanceof Error ? err : new Error(String(err));
+			}
+		})(),
 	]);
-	const exitCode = await proc.exited;
+	if (timeoutId) clearTimeout(timeoutId);
+	if (options?.signal) {
+		options.signal.removeEventListener("abort", onAbort);
+	}
 
 	return {
 		stdout,
 		stderr,
-		ok: exitCode === 0,
-		exitCode,
+		ok: exitResult === 0,
+		exitCode: exitResult,
 	};
 }
 

package/src/core/tools/web-search/auth.ts

@@ -10,11 +10,11 @@
 
 import * as os from "node:os";
 import * as path from "node:path";
-import { buildBetaHeader, claudeCodeHeaders, claudeCodeVersion } from "@oh-my-pi/pi-ai";
+import { buildAnthropicHeaders as buildProviderAnthropicHeaders } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath, getConfigDirPaths } from "../../../config";
 import { AgentStorage } from "../../agent-storage";
 import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "../../auth-storage";
-import { logger } from "../../logger";
 import { migrateJsonStorage } from "../../storage-migration";
 import type { AnthropicAuthConfig, AnthropicOAuthCredential, ModelsJson } from "./types";
 
@@ -242,55 +242,19 @@ export async function findAnthropicAuth(): Promise<AnthropicAuthConfig | null> {
 	return null;
 }
 
-/**
- * Checks if a base URL points to the official Anthropic API.
- * @param baseUrl - The base URL to check
- * @returns True if the URL is for api.anthropic.com over HTTPS
- */
-function isAnthropicBaseUrl(baseUrl: string): boolean {
-	try {
-		const url = new URL(baseUrl);
-		return url.protocol === "https:" && url.hostname === "api.anthropic.com";
-	} catch {
-		return false;
-	}
-}
-
 /**
  * Builds HTTP headers for Anthropic API requests.
  * @param auth - The authentication configuration
  * @returns Headers object ready for use in fetch requests
  */
 export function buildAnthropicHeaders(auth: AnthropicAuthConfig): Record<string, string> {
-	const baseBetas = auth.isOAuth
-		? [
-				"claude-code-20250219",
-				"oauth-2025-04-20",
-				"interleaved-thinking-2025-05-14",
-				"fine-grained-tool-streaming-2025-05-14",
-			]
-		: ["fine-grained-tool-streaming-2025-05-14"];
-	const betaHeader = buildBetaHeader(baseBetas, ["web-search-2025-03-05"]);
-
-	const headers: Record<string, string> = {
-		accept: "application/json",
-		"content-type": "application/json",
-		"anthropic-dangerous-direct-browser-access": "true",
-		"anthropic-beta": betaHeader,
-		"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
-		"x-app": "cli",
-		"accept-encoding": "gzip, deflate, br, zstd",
-		connection: "keep-alive",
-		...claudeCodeHeaders,
-	};
-
-	if (auth.isOAuth || !isAnthropicBaseUrl(auth.baseUrl)) {
-		headers.authorization = `Bearer ${auth.apiKey}`;
-	} else {
-		headers["x-api-key"] = auth.apiKey;
-	}
-
-	return headers;
+	return buildProviderAnthropicHeaders({
+		apiKey: auth.apiKey,
+		baseUrl: auth.baseUrl,
+		isOAuth: auth.isOAuth,
+		extraBetas: ["web-search-2025-03-05"],
+		stream: false,
+	});
 }
 
 /**

package/src/core/tools/write.ts

@@ -7,13 +7,13 @@ import type {
 } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/interactive/theme/theme";
 import writeDescription from "../../prompts/tools/write.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
-import { untilAborted } from "../utils";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,

package/src/core/ttsr.ts

@@ -6,8 +6,8 @@
  * injected as a system reminder, and the request is retried.
  */
 
+import { logger } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
-import { logger } from "./logger";
 import type { TtsrSettings } from "./settings-manager";
 
 interface TtsrEntry {

package/src/core/utils.ts

@@ -1,187 +1 @@
-// Utility constant for representing aborted operations
-const kAbortError = new Error("Operation aborted");
-
-/**
- * Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
- * execution, the promise is rejected with a standard error.
- *
- * @param signal - Optional AbortSignal to cancel the operation
- * @param pr - Function returning a promise to run
- * @returns Promise resolving as `pr` would, or rejecting on abort
- */
-export function untilAborted<T>(signal: AbortSignal | undefined | null, pr: () => Promise<T>): Promise<T> {
-	if (!signal) {
-		return pr();
-	}
-
-	if (signal.aborted) {
-		return Promise.reject(kAbortError);
-	}
-
-	return new Promise((resolve, reject) => {
-		const listener = () => reject(kAbortError);
-		signal.addEventListener("abort", listener, { once: true });
-
-		signal.throwIfAborted();
-
-		pr()
-			.then(resolve, reject)
-			.finally(() => {
-				signal.removeEventListener("abort", listener);
-			});
-	});
-}
-
-/**
- * Memoizes a function with no arguments, calling it once and caching the result.
- *
- * @param fn - Function to be called once
- * @returns A function that returns the cached result of `fn`
- */
-export function once<T>(fn: () => T): () => T {
-	let store = undefined as { value: T } | undefined;
-	return () => {
-		if (store) {
-			return store.value;
-		}
-		const value = fn();
-		store = { value };
-		return value;
-	};
-}
-
-// ScopeSignal is a cancellation/helper utility similar to AbortController but
-// allows composition of an existing AbortSignal and/or a timeout. It exposes a
-// simple API for cancellation observation (finally, catch).
-interface ScopeSignalOptions {
-	signal?: AbortSignal;
-	timeout?: number;
-}
-
-const kTimeoutReason = new Error("Timeout");
-const kDisposedReason = new Error("Disposed");
-
-/**
- * Type of signal exit (None = disposed, TimedOut = timed out, Aborted = underlying signal aborted)
- */
-enum ExitReason {
-	None = 0,
-	TimedOut = 1,
-	Aborted = 2,
-}
-
-/**
- * ScopeSignal: composable cancellation for async work–observes an external AbortSignal and/or a timeout.
- *
- * Use .finally(fn) to register a one-time callback invoked on *any* exit (abort, timeout, or manual dispose).
- * Use .catch(fn) to register a one-time callback invoked only on abort/timeout.
- *
- * Disposing ScopeSignal disables further callbacks.
- */
-export class ScopeSignal implements Disposable {
-	#signal: AbortSignal | undefined;
-	#timer: NodeJS.Timeout | undefined;
-	#exit = undefined as ExitReason | undefined;
-	#onAbort: (() => void) | undefined;
-	#callbacks?: (() => void)[];
-	#reason: unknown | undefined;
-
-	/**
-	 * Provides abort/timeout reason (Error or user-defined).
-	 */
-	get reason(): unknown | undefined {
-		return this.#reason;
-	}
-
-	/**
-	 * True if exited due to external AbortSignal or timeout.
-	 */
-	get aborted(): boolean {
-		return this.#exit !== undefined && this.#exit > ExitReason.None;
-	}
-
-	/**
-	 * True if this ScopeSignal timed out (not external abort).
-	 */
-	timedOut(): boolean {
-		return this.#exit === ExitReason.TimedOut;
-	}
-
-	/**
-	 * Create a new ScopeSignal, optionally observing an AbortSignal and/or auto-aborting after a timeout (ms).
-	 */
-	constructor(options?: ScopeSignalOptions) {
-		const { signal, timeout } = options ?? {};
-
-		if (signal?.aborted) {
-			this.#abort(ExitReason.Aborted, signal.reason); // Immediately abort if already-aborted
-			return;
-		}
-		if (timeout && timeout <= 0) {
-			this.#abort(ExitReason.TimedOut, kTimeoutReason);
-			return;
-		}
-
-		// Observe external signal if provided
-		if (signal) {
-			const onAbort = () => {
-				this.#abort(ExitReason.Aborted, signal.reason);
-			};
-			this.#signal = signal;
-			this.#onAbort = onAbort;
-			this.#signal.addEventListener("abort", onAbort, { once: true });
-		}
-
-		// Set up timeout if provided
-		if (timeout) {
-			this.#timer = setTimeout(() => {
-				this.#abort(ExitReason.TimedOut, kTimeoutReason);
-			}, timeout);
-		}
-	}
-
-	/**
-	 * Register a one-time callback invoked on any exit (abort, timeout, or manual dispose).
-	 * Runs immediately if already exited.
-	 */
-	finally(onfinally: () => void): void {
-		if (this.#exit !== undefined) {
-			onfinally();
-			return;
-		}
-		this.#callbacks ??= [];
-		this.#callbacks.push(onfinally);
-	}
-
-	/**
-	 * Register a one-time callback invoked only if exited due to abort/timeout (not normal disposal).
-	 */
-	catch(oncatch: (reason: unknown) => void): void {
-		this.finally(() => {
-			if (this.aborted) {
-				oncatch(this.reason);
-			}
-		});
-	}
-
-	/** Internal: cause exit; only first call takes effect. */
-	#abort(exit: ExitReason, reason?: unknown): void {
-		if (this.#exit !== undefined) return;
-		this.#reason = reason;
-		clearTimeout(this.#timer);
-		this.#signal?.removeEventListener("abort", this.#onAbort!);
-
-		this.#exit = exit;
-
-		const callbacks = this.#callbacks;
-		this.#callbacks = undefined;
-		callbacks?.forEach((fn) => void fn());
-	}
-
-	/**
-	 * Dispose: marks as normally exited (not abort/timeout); disables further callback registration.
-	 */
-	[Symbol.dispose](): void {
-		this.#abort(ExitReason.None, kDisposedReason);
-	}
-}
+export { abortableSleep, once, untilAborted } from "@oh-my-pi/pi-utils";

package/src/core/voice-controller.ts

@@ -1,6 +1,6 @@
+import { logger } from "@oh-my-pi/pi-utils";
 import { Agent, run, setDefaultOpenAIKey } from "@openai/agents";
 import { z } from "zod";
-import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
 
 const DEFAULT_CONTROLLER_MODEL = process.env.OMP_VOICE_CONTROLLER_MODEL ?? "gpt-4o-mini";

package/src/core/voice-supervisor.ts

@@ -1,3 +1,4 @@
+import { logger, ptree } from "@oh-my-pi/pi-utils";
 import {
 	RealtimeAgent,
 	RealtimeSession,
@@ -6,10 +7,8 @@ import {
 	type TransportLayerAudio,
 	tool,
 } from "@openai/agents/realtime";
-import type { Subprocess } from "bun";
 import type { ReadableStreamDefaultReader as WebReadableStreamDefaultReader } from "stream/web";
 import { z } from "zod";
-import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
 
 const DEFAULT_REALTIME_MODEL = process.env.OMP_VOICE_REALTIME_MODEL ?? "gpt-realtime";
@@ -372,9 +371,9 @@ function rms16le(buffer: Uint8Array): number {
 
 export class VoiceSupervisor {
 	private session: RealtimeSession | undefined = undefined;
-	private captureProcess: Subprocess | undefined = undefined;
+	private captureProcess: ptree.ChildProcess | undefined = undefined;
 	private captureReader: WebReadableStreamDefaultReader<Uint8Array> | undefined = undefined;
-	private playbackProcess: Subprocess | undefined = undefined;
+	private playbackProcess: ptree.ChildProcess | undefined = undefined;
 	private playbackWriter:
 		| {
 				write: (chunk: Uint8Array) => Promise<void>;
@@ -744,15 +743,11 @@ export class VoiceSupervisor {
 
 		const { command, env: captureEnv } = captureResult;
 		logger.debug("voice-supervisor: starting mic capture", { command, env: captureEnv });
-		const proc = Bun.spawn(command, {
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
+		const proc = ptree.cspawn(command, {
 			env: captureEnv ? { ...process.env, ...captureEnv } : undefined,
 		});
 		this.captureProcess = proc;
-
-		const reader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
+		const reader = proc.stdout.getReader();
 		this.captureReader = reader;
 
 		(async () => {
@@ -812,7 +807,7 @@ export class VoiceSupervisor {
 		}
 		if (this.captureProcess) {
 			try {
-				this.captureProcess.kill();
+				this.captureProcess.kill("SIGINT");
 			} catch {
 				// ignore
 			}
@@ -829,14 +824,10 @@ export class VoiceSupervisor {
 		}
 
 		logger.debug("voice-supervisor: starting audio playback", { command });
-		const proc = Bun.spawn(command, {
+		const proc = ptree.cspawn(command, {
 			stdin: "pipe",
-			stdout: "ignore",
-			stderr: "pipe",
 		});
 		const startedAt = Date.now();
-		const stderrBuffer = { text: "" };
-		this.readStderr(proc.stderr, stderrBuffer);
 
 		this.playbackProcess = proc;
 		const stdin = proc.stdin;
@@ -876,17 +867,18 @@ export class VoiceSupervisor {
 		}
 
 		proc.exited
-			.then((code) => {
+			.then(() => {
+				const code = proc.exitCode;
 				if (this.playbackProcess === proc) {
 					this.playbackProcess = undefined;
 					this.playbackWriter = undefined;
 				}
-				const trimmed = stderrBuffer.text.trim();
+				const trimmed = proc.peekStderr().trim();
 				if (trimmed) {
 					logger.debug("voice-supervisor: playback stderr", { stderr: trimmed });
 				}
 				const elapsed = Date.now() - startedAt;
-				if (code !== 0 && elapsed < 2000 && this.active) {
+				if (code !== 0 && elapsed < 2000 && this.active && code !== null) {
 					this.maybeWarnPlaybackFailure(trimmed || `exit code ${code}`);
 				}
 			})
@@ -915,25 +907,6 @@ export class VoiceSupervisor {
 		this.playbackWriter = undefined;
 	}
 
-	private readStderr(stderr: Subprocess["stderr"], buffer: { text: string }): void {
-		if (!stderr || typeof stderr === "number") return;
-		const reader = (stderr as ReadableStream<Uint8Array>).getReader();
-		const decoder = new TextDecoder();
-		(async () => {
-			while (true) {
-				const { value, done } = await reader.read();
-				if (done || !value) break;
-				buffer.text += decoder.decode(value, { stream: true });
-				if (buffer.text.length > 4000) {
-					buffer.text = buffer.text.slice(0, 4000);
-					break;
-				}
-			}
-		})().catch(() => {
-			// ignore
-		});
-	}
-
 	private maybeWarnPlaybackFailure(message: string): void {
 		if (!this.callbacks.onWarning) return;
 		const now = Date.now();

package/src/core/voice.ts

@@ -2,9 +2,9 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
 import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
-import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
 import { findSmolModel } from "./model-resolver";
 import { renderPromptTemplate } from "./prompt-templates";
@@ -143,13 +143,6 @@ function buildRecordingCommand(filePath: string, sampleRate: number, channels: n
 	return null;
 }
 
-/**
- * @deprecated Use `new VoiceRecording(settings)` instead.
- */
-export function startVoiceRecording(settings: VoiceSettings): VoiceRecordingHandle {
-	return new VoiceRecording(settings);
-}
-
 export async function transcribeAudio(
 	filePath: string,
 	apiKey: string,

package/src/discovery/codex.ts

@@ -8,6 +8,7 @@
  */
 
 import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { parse as parseToml } from "smol-toml";
 import type { ContextFile } from "../capability/context-file";
 import { contextFileCapability } from "../capability/context-file";
@@ -30,7 +31,6 @@ import type { CustomTool } from "../capability/tool";
 import { toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { parseFrontmatter } from "../core/frontmatter";
-import { logger } from "../core/logger";
 import {
 	createSourceMeta,
 	discoverExtensionModulePaths,