@oh-my-pi/pi-coding-agent 14.5.11 → 14.5.13

package/src/tools/exit-plan-mode.ts

@@ -46,7 +46,7 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 	readonly parameters = exitPlanModeSchema;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
-	readonly intent = (): string => "Exiting plan mode";
+	readonly intent = (): string => "present plan";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(exitPlanModeDescription);

package/src/tools/index.ts

@@ -1,14 +1,13 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
-import { $env, $flag, isBunTestRuntime, logger } from "@oh-my-pi/pi-utils";
+import { $env, $flag, logger } from "@oh-my-pi/pi-utils";
 import type { AsyncJobManager } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
+import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { InternalUrlRouter } from "../internal-urls";
-import { getPreludeDocs, resetPreludeDocsCache, warmPythonEnvironment } from "../ipy/executor";
-import { checkPythonKernelAvailability } from "../ipy/kernel";
 import { LspTool } from "../lsp";
 import type { DiscoverableMCPSearchIndex, DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
 import type { PlanModeState } from "../plan-mode/state";
@@ -27,6 +26,7 @@ import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
+import { EvalTool } from "./eval";
 import { ExitPlanModeTool } from "./exit-plan-mode";
 import { FindTool } from "./find";
 import { GithubTool } from "./gh";
@@ -35,7 +35,6 @@ import { IrcTool } from "./irc";
 import { JobTool } from "./job";
 import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
-import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { RecipeTool } from "./recipe";
 import { RenderMermaidTool } from "./render-mermaid";
@@ -66,6 +65,7 @@ export * from "./browser";
 export * from "./calculator";
 export * from "./checkpoint";
 export * from "./debug";
+export * from "./eval";
 export * from "./exit-plan-mode";
 export * from "./find";
 export * from "./gh";
@@ -74,7 +74,6 @@ export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
 export * from "./notebook";
-export * from "./python";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -108,8 +107,6 @@ export interface ToolSession {
 	hasUI: boolean;
 	/** Skip Python kernel availability check and warmup */
 	skipPythonPreflight?: boolean;
-	/** Force Python prelude warmup even when test env would normally skip it */
-	forcePythonWarmup?: boolean;
 	/** Pre-loaded context files (AGENTS.md, etc) */
 	contextFiles?: ContextFileEntry[];
 	/** Pre-loaded skills */
@@ -130,16 +127,18 @@ export interface ToolSession {
 	taskDepth?: number;
 	/** Get session file */
 	getSessionFile: () => string | null;
-	/** Get Python kernel owner ID for session-scoped retained-kernel cleanup */
-	getPythonKernelOwnerId?: () => string | null;
-	/** Reject new Python work once session disposal has started. */
-	assertPythonExecutionAllowed?: () => void;
-	/** Track tool-owned Python work so session disposal can await/abort it like direct session Python runs. */
-	trackPythonExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
+	/** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
+	getEvalKernelOwnerId?: () => string | null;
+	/** Reject new eval (python or js) work once session disposal has started. */
+	assertEvalExecutionAllowed?: () => void;
+	/** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
+	trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
 	/** Get session ID */
 	getSessionId?: () => string | null;
 	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
 	getAgentId?: () => string | null;
+	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+	getToolByName?: (name: string) => AgentTool | undefined;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;
 	/** Get artifacts directory for artifact:// URLs */
@@ -210,7 +209,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: AskTool.createIf,
 	bash: s => new BashTool(s),
 	debug: DebugTool.createIf,
-	python: s => new PythonTool(s),
+	eval: s => new EvalTool(s),
 	calc: s => new CalculatorTool(s),
 	ssh: loadSshTool,
 	edit: s => new EditTool(s),
@@ -244,34 +243,40 @@ export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 
 export type ToolName = keyof typeof BUILTIN_TOOLS;
 
-export type PythonToolMode = "ipy-only" | "bash-only" | "both";
+export interface EvalBackendsAllowance {
+	python: boolean;
+	js: boolean;
+}
 
 /**
- * Parse PI_PY environment variable to determine Python tool mode.
- * Returns null if not set or invalid.
- *
- * Values:
- * - "0" or "bash" → bash-only
- * - "1" or "py" → ipy-only
- * - "mix" or "both" → both
+ * Parse PI_PY / PI_JS environment variables. Each is a boolean flag; unset
+ * means "not specified, defer to settings". Returns null when neither is set
+ * so the caller can fall through to `readEvalBackendsAllowance` per key.
  */
-function getPythonModeFromEnv(): PythonToolMode | null {
-	const value = $env.PI_PY?.toLowerCase();
-	if (!value) return null;
+function getEvalBackendsFromEnv(): EvalBackendsAllowance | null {
+	const pyEnv = $env.PI_PY;
+	const jsEnv = $env.PI_JS;
+	if (pyEnv === undefined && jsEnv === undefined) return null;
+	return {
+		python: pyEnv === undefined ? true : $flag("PI_PY"),
+		js: jsEnv === undefined ? true : $flag("PI_JS"),
+	};
+}
 
-	switch (value) {
-		case "0":
-		case "bash":
-			return "bash-only";
-		case "1":
-		case "py":
-			return "ipy-only";
-		case "mix":
-		case "both":
-			return "both";
-		default:
-			return null;
-	}
+/** Read per-backend allowance from settings (defaults true). */
+export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance {
+	return {
+		python: session.settings.get("eval.py") ?? true,
+		js: session.settings.get("eval.js") ?? true,
+	};
+}
+
+/**
+ * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
+ * override the per-key settings; otherwise settings (defaults true) win.
+ */
+export function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance {
+	return getEvalBackendsFromEnv() ?? readEvalBackendsAllowance(session);
 }
 
 /**
@@ -285,77 +290,34 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	if (requestedTools && !requestedTools.includes("exit_plan_mode")) {
 		requestedTools.push("exit_plan_mode");
 	}
-	const pythonMode = getPythonModeFromEnv() ?? session.settings.get("python.toolMode");
+	const backends = resolveEvalBackends(session);
+	const allowPython = backends.python;
+	const allowJs = backends.js;
 	const skipPythonPreflight = session.skipPythonPreflight === true;
+	// Eval tool is enabled if EITHER backend is reachable. We only need to know
+	// whether python is reachable when JS is disabled — otherwise allowEval is
+	// already true and the python-availability check can be deferred to first
+	// invocation of the python backend (already handled inside the executor).
 	let pythonAvailable = true;
-	const shouldCheckPython =
+	if (
 		!skipPythonPreflight &&
-		pythonMode !== "bash-only" &&
-		(requestedTools === undefined || requestedTools.includes("python"));
-	const isTestEnv = isBunTestRuntime();
-	const forcePythonWarmup = session.forcePythonWarmup === true;
-	const skipPythonWarm = (isTestEnv && !forcePythonWarmup) || $flag("PI_PYTHON_SKIP_CHECK");
-	const cachedPreludeDocs = getPreludeDocs();
-	const shouldWarmPython = !skipPythonWarm && (forcePythonWarmup || cachedPreludeDocs.length === 0);
-	if (shouldCheckPython) {
+		allowPython &&
+		!allowJs &&
+		(requestedTools === undefined || requestedTools.includes("eval"))
+	) {
 		const availability = await logger.time("createTools:pythonCheck", checkPythonKernelAvailability, session.cwd);
 		pythonAvailable = availability.ok;
 		if (!availability.ok) {
-			logger.warn("Python kernel unavailable, falling back to bash", {
+			logger.warn("Python kernel unavailable and JS backend disabled; eval will be unavailable", {
 				reason: availability.reason,
 			});
-		} else if (shouldWarmPython) {
-			const sessionFile = session.getSessionFile?.() ?? undefined;
-			const kernelOwnerId = session.getPythonKernelOwnerId?.() ?? undefined;
-			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
-			const warmupAbortController = new AbortController();
-			try {
-				session.assertPythonExecutionAllowed?.();
-				if (forcePythonWarmup && cachedPreludeDocs.length > 0) {
-					resetPreludeDocsCache();
-				}
-				const warmupExecution = session.trackPythonExecution
-					? logger.time(
-							"createTools:warmPython",
-							warmPythonEnvironment,
-							session.cwd,
-							warmSessionId,
-							session.settings.get("python.sharedGateway"),
-							sessionFile,
-							kernelOwnerId,
-							warmupAbortController.signal,
-						)
-					: logger.time(
-							"createTools:warmPython",
-							warmPythonEnvironment,
-							session.cwd,
-							warmSessionId,
-							session.settings.get("python.sharedGateway"),
-							sessionFile,
-							kernelOwnerId,
-						);
-				await (session.trackPythonExecution?.(warmupExecution, warmupAbortController) ?? warmupExecution);
-				session.assertPythonExecutionAllowed?.();
-			} catch (err) {
-				logger.warn("Failed to warm Python environment", {
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
 		}
 	}
 
-	const effectiveMode = pythonAvailable ? pythonMode : "bash-only";
-	const allowBash = effectiveMode !== "ipy-only";
-	const allowPython = effectiveMode !== "bash-only";
-	if (
-		requestedTools &&
-		allowBash &&
-		!allowPython &&
-		requestedTools.includes("python") &&
-		!requestedTools.includes("bash")
-	) {
-		requestedTools.push("bash");
-	}
+	const effectivePythonAllowed = allowPython && pythonAvailable;
+	// Eval is exposed whenever any backend is reachable. The python backend may
+	// be unreachable, in which case eval dispatches exclusively to js.
+	const allowEval = effectivePythonAllowed || allowJs;
 
 	// Auto-include AST counterparts when their text-based sibling is present
 	if (requestedTools) {
@@ -384,8 +346,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
 		if (name === "lsp") return enableLsp && session.settings.get("lsp.enabled");
-		if (name === "bash") return allowBash;
-		if (name === "python") return allowPython;
+		if (name === "bash") return true;
+		if (name === "eval") return allowEval;
 		if (name === "debug") return session.settings.get("debug.enabled");
 		if (name === "todo_write") return !includeYield && session.settings.get("todo.enabled");
 		if (name === "find") return session.settings.get("find.enabled");

package/src/tools/plan-mode-guard.ts

@@ -1,3 +1,4 @@
+import * as path from "node:path";
 import { resolveLocalUrlToPath } from "../internal-urls";
 import type { ToolSession } from ".";
 import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
@@ -5,7 +6,7 @@ import { ToolError } from "./tool-errors";
 
 const LOCAL_SCHEME_PREFIX = "local:";
 
-export function resolvePlanPath(session: ToolSession, targetPath: string): string {
+function resolveRawPath(session: ToolSession, targetPath: string): string {
 	const normalized = normalizeLocalScheme(targetPath);
 	if (normalized.startsWith(LOCAL_SCHEME_PREFIX)) {
 		return resolveLocalUrlToPath(normalized, {
@@ -17,6 +18,31 @@ export function resolvePlanPath(session: ToolSession, targetPath: string): strin
 	return resolveToCwd(normalized, session.cwd);
 }
 
+/**
+ * Resolve a write/edit target to its absolute filesystem path.
+ *
+ * In plan mode, transparently redirects targets whose basename matches the
+ * plan file's basename (e.g. a bare `PLAN.md` or `./PLAN.md`) to the canonical
+ * plan file location at `state.planFilePath`. This lets `write` and `edit`
+ * accept the unqualified plan filename and have the change land at the
+ * session-scoped `local://PLAN.md` artifact instead of a stray cwd-relative
+ * file the plan-mode guard would otherwise reject.
+ *
+ * Outside plan mode (or when the basename does not match) this is a no-op.
+ */
+export function resolvePlanPath(session: ToolSession, targetPath: string): string {
+	const resolved = resolveRawPath(session, targetPath);
+
+	const state = session.getPlanModeState?.();
+	if (!state?.enabled) return resolved;
+
+	const planResolved = resolveRawPath(session, state.planFilePath);
+	if (resolved === planResolved) return resolved;
+	if (path.basename(resolved) !== path.basename(planResolved)) return resolved;
+
+	return planResolved;
+}
+
 export function enforcePlanModeWrite(
 	session: ToolSession,
 	targetPath: string,

package/src/tools/read.ts

@@ -456,12 +456,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;
 	readonly strict = true;
-	readonly intent = (args: Partial<ReadParams>): string => {
-		const p = typeof args.path === "string" ? args.path.trim() : "";
-		if (!p) return "Reading";
-		const isUrl = /^(https?|ftp):\/\//i.test(p);
-		return isUrl ? `Fetching ${p}` : `Reading ${p}`;
-	};
 
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;

package/src/tools/recipe/runners/pkg.ts

@@ -10,21 +10,19 @@ interface PackageJsonInfo {
 }
 
 async function resolvePackageRunner(cwd: string): Promise<string> {
-	if ((await isFile(path.join(cwd, "bun.lock"))) || (await isFile(path.join(cwd, "bun.lockb")))) {
-		return "bun run";
-	}
-	if (await isFile(path.join(cwd, "pnpm-lock.yaml"))) {
-		return "pnpm run";
-	}
-	if (await isFile(path.join(cwd, "yarn.lock"))) {
-		return "yarn";
-	}
-	if ((await isFile(path.join(cwd, "package-lock.json"))) || (await isFile(path.join(cwd, "npm-shrinkwrap.json")))) {
-		return "npm run";
-	}
-	if ($which("bun")) {
-		return "bun run";
-	}
+	const [bunLock, bunLockb, pnpmLock, yarnLock, npmLock, npmShrink] = await Promise.all([
+		isFile(path.join(cwd, "bun.lock")),
+		isFile(path.join(cwd, "bun.lockb")),
+		isFile(path.join(cwd, "pnpm-lock.yaml")),
+		isFile(path.join(cwd, "yarn.lock")),
+		isFile(path.join(cwd, "package-lock.json")),
+		isFile(path.join(cwd, "npm-shrinkwrap.json")),
+	]);
+	if (bunLock || bunLockb) return "bun run";
+	if (pnpmLock) return "pnpm run";
+	if (yarnLock) return "yarn";
+	if (npmLock || npmShrink) return "npm run";
+	if ($which("bun")) return "bun run";
 	return "npm run";
 }
 
@@ -86,18 +84,23 @@ async function readPackageJson(filePath: string): Promise<PackageJsonInfo | null
 async function findWorkspacePackageJsons(cwd: string, patterns: string[]): Promise<string[]> {
 	const includePatterns = patterns.filter(pattern => !pattern.startsWith("!")).map(normalizeWorkspacePattern);
 	const excludePatterns = patterns.filter(pattern => pattern.startsWith("!")).map(normalizeWorkspacePattern);
-	const excluded = new Set<string>();
-	for (const pattern of excludePatterns) {
-		for await (const entry of new Bun.Glob(pattern.slice(1)).scan({ cwd, onlyFiles: true })) {
-			excluded.add(path.normalize(String(entry)));
-		}
-	}
-	const files = new Set<string>();
-	for (const pattern of includePatterns) {
+
+	const collect = async (pattern: string): Promise<string[]> => {
+		const out: string[] = [];
 		for await (const entry of new Bun.Glob(pattern).scan({ cwd, onlyFiles: true })) {
-			const normalized = path.normalize(String(entry));
-			if (normalized !== "package.json" && !excluded.has(normalized)) files.add(normalized);
+			out.push(path.normalize(String(entry)));
 		}
+		return out;
+	};
+
+	const [excludedLists, includedLists] = await Promise.all([
+		Promise.all(excludePatterns.map(pattern => collect(pattern.slice(1)))),
+		Promise.all(includePatterns.map(pattern => collect(pattern))),
+	]);
+	const excluded = new Set<string>(excludedLists.flat());
+	const files = new Set<string>();
+	for (const entry of includedLists.flat()) {
+		if (entry !== "package.json" && !excluded.has(entry)) files.add(entry);
 	}
 	return [...files].sort((left, right) => left.localeCompare(right));
 }
@@ -132,10 +135,10 @@ async function readPackageTasks(cwd: string): Promise<RunnerTask[] | null> {
 		);
 	}
 
-	for (const packageJsonPath of workspacePackageJsons) {
-		const pkg = await readPackageJson(path.join(cwd, packageJsonPath));
-		if (!pkg || pkg.scripts.length === 0) continue;
-		const packageDir = path.dirname(packageJsonPath);
+	const pkgs = await Promise.all(workspacePackageJsons.map(p => readPackageJson(path.join(cwd, p))));
+	pkgs.forEach((pkg, index) => {
+		if (!pkg || pkg.scripts.length === 0) return;
+		const packageDir = path.dirname(workspacePackageJsons[index]);
 		tasks.push(
 			...tasksForPackage({
 				pkg,
@@ -143,7 +146,7 @@ async function readPackageTasks(cwd: string): Promise<RunnerTask[] | null> {
 				namespaced: true,
 			}),
 		);
-	}
+	});
 
 	return tasks.length > 0 ? tasks : null;
 }
@@ -153,8 +156,7 @@ export const pkgRunner: TaskRunner = {
 	label: "Pkg",
 	async detect(cwd: string): Promise<DetectedRunner | null> {
 		try {
-			const commandPrefix = await resolvePackageRunner(cwd);
-			const tasks = await readPackageTasks(cwd);
+			const [commandPrefix, tasks] = await Promise.all([resolvePackageRunner(cwd), readPackageTasks(cwd)]);
 			if (!tasks || tasks.length === 0) return null;
 			return { id: "pkg", label: "Pkg", commandPrefix, tasks };
 		} catch (err) {

package/src/tools/renderers.ts

@@ -14,14 +14,15 @@ import { askToolRenderer } from "./ask";
 import { astEditToolRenderer } from "./ast-edit";
 import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
+import { browserToolRenderer } from "./browser/render";
 import { calculatorToolRenderer } from "./calculator";
 import { debugToolRenderer } from "./debug";
+import { evalToolRenderer } from "./eval";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
 import { notebookToolRenderer } from "./notebook";
-import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { recipeToolRenderer } from "./recipe/render";
 import { resolveToolRenderer } from "./resolve";
@@ -49,9 +50,10 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	ast_grep: astGrepToolRenderer as ToolRenderer,
 	ast_edit: astEditToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
+	browser: browserToolRenderer as ToolRenderer,
 	recipe: recipeToolRenderer as ToolRenderer,
 	debug: debugToolRenderer as ToolRenderer,
-	python: pythonToolRenderer as ToolRenderer,
+	eval: evalToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
 	apply_patch: editToolRenderer as ToolRenderer,

package/src/tools/resolve.ts

@@ -110,8 +110,13 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	readonly description: string;
 	readonly parameters = resolveSchema;
 	readonly strict = true;
-	readonly intent = (args: Partial<ResolveParams>) =>
-		args.action === "discard" ? "Discarding pending action" : "Applying pending action";
+	readonly intent = (args: Partial<ResolveParams>) => {
+		if (args.action === "discard") {
+			return args.reason ? `discarding: ${args.reason}` : "aiscarding changes";
+		} else {
+			return args.reason ? `accepting: ${args.reason}` : "accepting changes";
+		}
+	};
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(resolveDescription);

package/src/tools/todo-write.ts

@@ -507,7 +507,6 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 	readonly parameters = todoWriteSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
-	readonly intent = "omit" as const;
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(todoWriteDescription);

package/src/tools/tool-timeouts.ts

@@ -9,8 +9,8 @@ export interface ToolTimeoutConfig {
 
 export const TOOL_TIMEOUTS = {
 	bash: { default: 300, min: 1, max: 3600 },
-	python: { default: 30, min: 1, max: 600 },
-	browser: { default: 30, min: 1, max: 120 },
+	eval: { default: 30, min: 1, max: 600 },
+	browser: { default: 30, min: 1, max: 30 },
 	ssh: { default: 60, min: 1, max: 3600 },
 	fetch: { default: 20, min: 1, max: 45 },
 	lsp: { default: 20, min: 5, max: 60 },

package/src/utils/markit.ts

@@ -1,6 +1,5 @@
 import { untilAborted } from "@oh-my-pi/pi-utils";
-import type { StreamInfo } from "markit-ai";
-import { Markit } from "markit-ai";
+import type { Markit, StreamInfo } from "markit-ai";
 import { ToolAbortError } from "../tools/tool-errors";
 
 export interface MarkitConversionResult {
@@ -9,7 +8,15 @@ export interface MarkitConversionResult {
 	error?: string;
 }
 
-const markit = new Markit();
+let markit: () => Markit | Promise<Markit> = async () => {
+	const promise = import("markit-ai").then(({ Markit }) => {
+		const instance = new Markit();
+		markit = () => instance;
+		return instance;
+	});
+	markit = () => promise;
+	return promise;
+};
 
 function normalizeExtension(extension: string): string {
 	const trimmed = extension.trim().toLowerCase();
@@ -24,9 +31,10 @@ function normalizeError(error: unknown): string {
 	return "Conversion failed";
 }
 
-async function runMarkitConversion<T>(task: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+async function runMarkitConversion<T>(task: (markit: Markit) => Promise<T>, signal?: AbortSignal): Promise<T> {
 	try {
-		return signal ? await untilAborted(signal, task) : await task();
+		const instance = await markit();
+		return signal ? await untilAborted(signal, () => task(instance)) : await task(instance);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
 			throw error;
@@ -48,7 +56,7 @@ function finalizeConversion(markdown?: string): MarkitConversionResult {
 
 export async function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult> {
 	try {
-		const result = await runMarkitConversion(() => markit.convertFile(filePath), signal);
+		const result = await runMarkitConversion(markit => markit.convertFile(filePath), signal);
 		return finalizeConversion(result.markdown);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
@@ -70,7 +78,7 @@ export async function convertBufferWithMarkit(
 	};
 
 	try {
-		const result = await runMarkitConversion(() => markit.convert(Buffer.from(buffer), streamInfo), signal);
+		const result = await runMarkitConversion(markit => markit.convert(Buffer.from(buffer), streamInfo), signal);
 		return finalizeConversion(result.markdown);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {

package/src/utils/tools-manager.ts

@@ -74,14 +74,14 @@ const TOOLS: Record<string, ToolConfig> = {
 	},
 };
 
-// Python packages installed via uv/pip
-interface PythonToolConfig {
+// CLI packages installed via uv/pip
+interface PythonPackageToolConfig {
 	name: string;
 	package: string; // PyPI package name
 	binaryName: string; // CLI command name after install
 }
 
-const PYTHON_TOOLS: Record<string, PythonToolConfig> = {
+const PYTHON_TOOLS: Record<string, PythonPackageToolConfig> = {
 	trafilatura: {
 		name: "trafilatura",
 		package: "trafilatura",
@@ -93,7 +93,7 @@ export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export function getToolPath(tool: ToolName): string | null {
-	// Check Python tools first
+	// Check uv/pip-installed CLI packages first
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
 		return $which(pythonConfig.binaryName);
@@ -306,7 +306,7 @@ export async function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOpt
 		return undefined;
 	}
 
-	// Handle Python tools
+	// Handle uv/pip-installed CLI packages
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
 		if (!silent) {

package/src/web/search/index.ts

@@ -15,7 +15,7 @@ import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { ty
 import webSearchDescription from "../../prompts/tools/web-search.md" with { type: "text" };
 import type { ToolSession } from "../../tools";
 import { formatAge } from "../../tools/render-utils";
-import { getSearchProvider, resolveProviderChain, type SearchProvider } from "./provider";
+import { getSearchProvider, getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
 import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
 import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
@@ -63,7 +63,7 @@ function formatProviderError(error: unknown, provider: SearchProvider): string {
 			if (error.provider === "zai") {
 				return error.message;
 			}
-			return `${getSearchProvider(error.provider).label} authorization failed (${error.status}). Check API key or base URL.`;
+			return `${getSearchProviderLabel(error.provider)} authorization failed (${error.status}). Check API key or base URL.`;
 		}
 		return error.message;
 	}
@@ -139,9 +139,9 @@ async function executeSearch(
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
 	const providers =
 		params.provider && params.provider !== "auto"
-			? (await getSearchProvider(params.provider).isAvailable())
-				? [getSearchProvider(params.provider)]
-				: await resolveProviderChain("auto")
+			? await getSearchProvider(params.provider).then(provider =>
+					provider.isAvailable() ? [provider] : resolveProviderChain("auto"),
+				)
 			: await resolveProviderChain();
 	if (providers.length === 0) {
 		const message = "No web search provider configured.";