@oh-my-pi/pi-coding-agent 15.10.4 → 15.10.6

package/src/edit/renderer.ts

@@ -260,6 +260,7 @@ function renderEditHeader(
 	uiTheme: Theme,
 	options: {
 		icon: "pending" | "success" | "error";
+		iconOverride?: string;
 		spinnerFrame?: number;
 		op?: Operation;
 		rawPath: string;
@@ -279,8 +280,16 @@ function renderEditHeader(
 	const formatted = formatEditDescription(options.rawPath, uiTheme, descriptionOptions);
 	const suffix = `${options.statsSuffix ?? ""}${options.extraSuffix ?? ""}`;
 	const buildHeader = (description: string): string =>
-		renderStatusLine({ icon: options.icon, spinnerFrame: options.spinnerFrame, title, description }, uiTheme) +
-		suffix;
+		renderStatusLine(
+			{
+				icon: options.icon,
+				iconOverride: options.iconOverride,
+				spinnerFrame: options.spinnerFrame,
+				title,
+				description,
+			},
+			uiTheme,
+		) + suffix;
 
 	const header = buildHeader(formatted.description);
 	const overflow = visibleWidth(header) - editHeaderLabelBudget(width, uiTheme);
@@ -633,6 +642,7 @@ function renderSingleFileResult(
 		const statsSuffix = headerDiff ? formatDiffStatsSuffix(headerDiff, uiTheme) : "";
 		const header = renderEditHeader(width, uiTheme, {
 			icon: isError ? "error" : "success",
+			iconOverride: !isError && !options.isPartial ? uiTheme.styledSymbol("tool.edit", "accent") : undefined,
 			op,
 			rawPath,
 			rename,

package/src/eval/__tests__/helpers-local-roots.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "bun:test";
+import * as path from "node:path";
+import { TempDir } from "@oh-my-pi/pi-utils";
+import { createHelpers, type HelperContext } from "../js/shared/helpers";
+
+/**
+ * The eval helpers (`read`/`write`/`append`) must substitute injected on-disk
+ * roots for internal-URL schemes. Without it, `write("local://x.md")` hits a
+ * stdlib `path.resolve` that collapses `local://` to `local:/`, creating a junk
+ * `local:` directory under the cwd instead of landing where `read local://x.md`
+ * resolves. These lock the substitution contract and its guards.
+ */
+function makeCtx(cwd: string, roots: Record<string, string>): HelperContext {
+	return {
+		cwd: () => cwd,
+		env: new Map(),
+		localRoots: () => roots,
+		emitStatus: () => {},
+	};
+}
+
+describe("eval js helpers internal-url resolution", () => {
+	it("writes, reads, and appends local:// under the injected root", async () => {
+		using tmp = TempDir.createSync("@eval-helpers-local-");
+		const root = path.join(tmp.path(), "local");
+		const helpers = createHelpers(makeCtx(tmp.path(), { local: root }));
+
+		const written = await helpers.writeFile("local://notes/merge-map.md", "hello");
+		expect(written).toBe(path.join(root, "notes", "merge-map.md"));
+		expect(await Bun.file(written).text()).toBe("hello");
+		expect(await helpers.read("local://notes/merge-map.md")).toBe("hello");
+
+		await helpers.append("local://notes/merge-map.md", " world");
+		expect(await helpers.read("local://notes/merge-map.md")).toBe("hello world");
+
+		// Regression: no literal `local:` directory created under the cwd.
+		expect(await Bun.file(path.join(tmp.path(), "local:")).exists()).toBe(false);
+		expect(await Bun.file(path.join(tmp.path(), "local:", "notes", "merge-map.md")).exists()).toBe(false);
+	});
+
+	it("rejects traversal and schemes without an injected root", async () => {
+		using tmp = TempDir.createSync("@eval-helpers-guard-");
+		const helpers = createHelpers(makeCtx(tmp.path(), { local: path.join(tmp.path(), "local") }));
+
+		await expect(helpers.writeFile("local://../escape.md", "x")).rejects.toThrow(/traversal|escapes/i);
+		await expect(helpers.writeFile("memory://x.md", "x")).rejects.toThrow(/not supported/i);
+		await expect(helpers.read("https://example.com/page")).rejects.toThrow(/not supported/i);
+	});
+
+	it("leaves plain relative and absolute paths resolving against the cwd", async () => {
+		using tmp = TempDir.createSync("@eval-helpers-plain-");
+		const helpers = createHelpers(makeCtx(tmp.path(), {}));
+
+		const rel = await helpers.writeFile("foo/bar.txt", "bar");
+		expect(rel).toBe(path.join(tmp.path(), "foo", "bar.txt"));
+		expect(await helpers.read("foo/bar.txt")).toBe("bar");
+	});
+});

package/src/eval/backend.ts

@@ -1,3 +1,4 @@
+import { buildEvalUrlRoots, type LocalProtocolOptions } from "../internal-urls";
 import type { ToolSession } from "../tools";
 import type { EvalDisplayOutput, EvalLanguage, EvalStatusEvent } from "./types";
 
@@ -56,3 +57,17 @@ export interface ExecutorBackend {
 	/** Execute one cell. Caller invokes once per cell and aggregates results. */
 	execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
 }
+
+/**
+ * Resolve the on-disk roots that the eval helpers substitute for internal-URL
+ * schemes (currently `local://`). Prefers the session's own
+ * {@link LocalProtocolOptions} — the exact mapping `read local://…` uses — so an
+ * eval `write("local://x")` and a later `read local://x` agree on the location.
+ */
+export function resolveEvalUrlRoots(session: ToolSession): Record<string, string> {
+	const options: LocalProtocolOptions = session.localProtocolOptions ?? {
+		getArtifactsDir: () => session.getArtifactsDir?.() ?? null,
+		getSessionId: () => session.getSessionId?.() ?? null,
+	};
+	return buildEvalUrlRoots(options);
+}

package/src/eval/js/context-manager.ts

@@ -68,6 +68,7 @@ export async function executeInVmContext(options: {
 	sessionId: string;
 	cwd: string;
 	session: ToolSession;
+	localRoots?: Record<string, string>;
 	reset?: boolean;
 	code: string;
 	filename: string;
@@ -100,7 +101,7 @@ export async function executeInVmContext(options: {
 	}
 	const session = await acquireSession(
 		options.sessionKey,
-		{ cwd: options.cwd, sessionId: options.sessionId },
+		{ cwd: options.cwd, sessionId: options.sessionId, localRoots: options.localRoots },
 		options.timeoutMs,
 	);
 	return await runOnce(session, options);
@@ -132,6 +133,7 @@ async function runOnce(
 		sessionId: string;
 		cwd: string;
 		session: ToolSession;
+		localRoots?: Record<string, string>;
 		code: string;
 		filename: string;
 		runState: VmRunState;
@@ -171,7 +173,7 @@ async function runOnce(
 			runId,
 			code: options.code,
 			filename: options.filename,
-			snapshot: { cwd: options.cwd, sessionId: options.sessionId },
+			snapshot: { cwd: options.cwd, sessionId: options.sessionId, localRoots: options.localRoots },
 		});
 		return await promise;
 	} finally {

package/src/eval/js/executor.ts

@@ -24,6 +24,8 @@ export interface JsExecutorOptions {
 	artifactPath?: string;
 	artifactId?: string;
 	session: ToolSession;
+	/** On-disk roots the helpers substitute for internal-URL schemes (e.g. `local://`). */
+	localRoots?: Record<string, string>;
 }
 
 export interface JsResult {
@@ -96,6 +98,7 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 			sessionId: options.sessionId,
 			cwd: options.cwd ?? options.session.cwd,
 			session: options.session,
+			localRoots: options.localRoots,
 			reset: options.reset,
 			code,
 			filename: `js-cell-${crypto.randomUUID()}.js`,

package/src/eval/js/index.ts

@@ -1,5 +1,10 @@
 import type { ToolSession } from "../../tools";
-import type { ExecutorBackend, ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import {
+	type ExecutorBackend,
+	type ExecutorBackendExecOptions,
+	type ExecutorBackendResult,
+	resolveEvalUrlRoots,
+} from "../backend";
 import { executeJs } from "./executor";
 
 const JS_SESSION_PREFIX = "js:";
@@ -30,6 +35,7 @@ export default {
 			onChunk: opts.onChunk,
 			onStatus: opts.onStatus,
 			session: opts.session,
+			localRoots: resolveEvalUrlRoots(opts.session),
 		});
 		return {
 			output: result.output,

package/src/eval/js/shared/helpers.ts

@@ -24,6 +24,12 @@ export interface HelperOptions {
 export interface HelperContext {
 	cwd(): string;
 	env: Map<string, string>;
+	/**
+	 * On-disk roots for internal-URL schemes the helpers accept (e.g.
+	 * `{ local: "/…/artifacts/local" }`). A path like `local://x.md` is rewritten
+	 * to `<root>/x.md` before any filesystem op; unknown schemes are rejected.
+	 */
+	localRoots(): Record<string, string>;
 	emitStatus(event: JsStatusEvent): void;
 }
 
@@ -66,7 +72,7 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 			if (!isWriteData(data)) {
 				throw new ToolError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
 			}
-			const filePath = resolvePath(ctx, rawPath);
+			const filePath = resolveHelperPath(ctx, rawPath, "write");
 			if (typeof data === "string" || data instanceof Blob || data instanceof ArrayBuffer) {
 				await Bun.write(filePath, data);
 			} else {
@@ -76,7 +82,7 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 			return filePath;
 		},
 		append: async (rawPath, content) => {
-			const target = resolvePath(ctx, rawPath);
+			const target = resolveHelperPath(ctx, rawPath, "write");
 			await Bun.write(
 				target,
 				`${await Bun.file(target)
@@ -202,19 +208,60 @@ function getMergedEnv(ctx: HelperContext): Record<string, string> {
 	return merged;
 }
 
+const INTERNAL_URL_RE = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/i;
+
 function resolvePath(ctx: HelperContext, value: string): string {
 	if (path.isAbsolute(value)) return path.normalize(value);
 	return path.resolve(ctx.cwd(), value);
 }
 
+/**
+ * Map a raw helper path to an absolute filesystem path. Plain paths resolve
+ * against the cwd; an internal-URL whose scheme has an injected root (e.g.
+ * `local://`) is rewritten under that root; any other `scheme://` is rejected
+ * so we never silently create a literal `scheme:/` directory.
+ */
+function resolveHelperPath(ctx: HelperContext, rawPath: string, op: "read" | "write"): string {
+	const match = INTERNAL_URL_RE.exec(rawPath);
+	if (!match) return resolvePath(ctx, rawPath);
+	const scheme = match[1].toLowerCase();
+	const root = ctx.localRoots()[scheme];
+	if (!root) {
+		throw new ToolError(`Protocol paths are not supported by ${op}(): ${rawPath}`);
+	}
+	return resolveUnderRoot(scheme, root, match[2], rawPath);
+}
+
+/** Resolve an internal-URL relative path under its root, mirroring the host
+ *  local-protocol handler: decode, reject absolute/traversal, confine to root. */
+function resolveUnderRoot(scheme: string, root: string, rawRelative: string, rawPath: string): string {
+	let relative: string;
+	try {
+		relative = decodeURIComponent(rawRelative.replaceAll("\\", "/"));
+	} catch {
+		throw new ToolError(`Invalid URL encoding in ${scheme}:// path: ${rawPath}`);
+	}
+	const rootPath = path.resolve(root);
+	if (relative === "") return rootPath;
+	if (path.isAbsolute(relative)) {
+		throw new ToolError(`Absolute paths are not allowed in ${scheme}:// URLs: ${rawPath}`);
+	}
+	const normalized = path.normalize(relative);
+	if (normalized.startsWith("..") || normalized.includes("/../") || normalized.includes("/..")) {
+		throw new ToolError(`Path traversal (..) is not allowed in ${scheme}:// URLs: ${rawPath}`);
+	}
+	const resolved = path.resolve(rootPath, normalized);
+	if (resolved !== rootPath && !resolved.startsWith(`${rootPath}${path.sep}`)) {
+		throw new ToolError(`${scheme}:// path escapes its root: ${rawPath}`);
+	}
+	return resolved;
+}
+
 async function resolveRegularFile(
 	ctx: HelperContext,
 	rawPath: string,
 ): Promise<{ filePath: string; file: Bun.BunFile; size: number }> {
-	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(rawPath)) {
-		throw new ToolError(`Protocol paths are not supported by read(): ${rawPath}`);
-	}
-	const filePath = resolvePath(ctx, rawPath);
+	const filePath = resolveHelperPath(ctx, rawPath, "read");
 	const file = Bun.file(filePath);
 	const stat = await file.stat();
 	if (stat.isDirectory()) {

package/src/eval/js/shared/runtime.ts

@@ -42,6 +42,11 @@ export interface RuntimeOptions {
 	 * via `setRunScope()` instead.
 	 */
 	extraGlobals?: Record<string, unknown>;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes (e.g.
+	 * `{ local: "/…/artifacts/local" }`). Stable for the worker's lifetime.
+	 */
+	localRoots?: Record<string, string>;
 }
 
 // Strict base64: characters from the standard alphabet plus optional `=` padding, and a
@@ -126,15 +131,18 @@ export class JsRuntime {
 	#env: Map<string, string>;
 	#als = new AsyncLocalStorage<RunContext>();
 	#moduleLoader: LocalModuleLoader;
+	#localRoots: Record<string, string>;
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
 		this.sessionId = opts.sessionId;
 		this.#env = new Map();
 		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
+		this.#localRoots = opts.localRoots ?? {};
 		this.helpers = createHelpers({
 			cwd: () => this.#activeCwd(),
 			env: this.#env,
+			localRoots: () => this.#localRoots,
 			emitStatus: event => this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event }),
 		});
 		this.#install(opts.extraGlobals);

package/src/eval/js/worker-core.ts

@@ -71,6 +71,7 @@ export class WorkerCore {
 		this.#runtime = new JsRuntime({
 			initialCwd: snapshot.cwd,
 			sessionId: snapshot.sessionId,
+			localRoots: snapshot.localRoots,
 		});
 		return this.#runtime;
 	}

package/src/eval/js/worker-protocol.ts

@@ -5,6 +5,12 @@ export type { JsDisplayOutput } from "./shared/types";
 export interface SessionSnapshot {
 	cwd: string;
 	sessionId: string;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes
+	 * (e.g. `{ local: "/…/artifacts/local" }`). Lets `read`/`write`/`append`
+	 * accept `local://…` paths instead of writing a literal `local:/` directory.
+	 */
+	localRoots?: Record<string, string>;
 }
 
 export interface RunErrorPayload {

package/src/eval/py/executor.ts

@@ -56,6 +56,13 @@ export interface PythonExecutorOptions {
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
+	/**
+	 * On-disk roots the prelude helpers (`read`/`write`/`append`) substitute for
+	 * internal-URL schemes (e.g. `{ local: "/…/artifacts/local" }`). Exported to
+	 * the kernel as `PI_EVAL_LOCAL_ROOTS` (JSON) so `write("local://x")` lands
+	 * where `read local://x` resolves instead of a literal `local:/` directory.
+	 */
+	localRoots?: Record<string, string>;
 	/**
 	 * ToolSession used to resolve host-side `tool.<name>(args)` calls made from
 	 * the Python prelude's bridge proxy. When omitted, the bridge env vars are
@@ -275,6 +282,7 @@ const MANAGED_KERNEL_ENV_KEYS = [
 	"PI_TOOL_BRIDGE_URL",
 	"PI_TOOL_BRIDGE_TOKEN",
 	"PI_TOOL_BRIDGE_SESSION",
+	"PI_EVAL_LOCAL_ROOTS",
 ] as const;
 
 function buildKernelEnvPatch(options: {
@@ -282,13 +290,16 @@ function buildKernelEnvPatch(options: {
 	artifactsDir?: string;
 	bridgeSessionId?: string;
 	bridge?: { url: string; token: string };
+	localRoots?: Record<string, string>;
 }): KernelRuntimeEnv {
+	const localRoots = options.localRoots;
 	return {
 		PI_SESSION_FILE: options.sessionFile ?? null,
 		PI_ARTIFACTS_DIR: options.artifactsDir ?? null,
 		PI_TOOL_BRIDGE_URL: options.bridge?.url ?? null,
 		PI_TOOL_BRIDGE_TOKEN: options.bridge?.token ?? null,
 		PI_TOOL_BRIDGE_SESSION: options.bridge && options.bridgeSessionId ? options.bridgeSessionId : null,
+		PI_EVAL_LOCAL_ROOTS: localRoots && Object.keys(localRoots).length > 0 ? JSON.stringify(localRoots) : null,
 	};
 }
 
@@ -297,6 +308,7 @@ function buildKernelEnv(options: {
 	artifactsDir?: string;
 	bridgeSessionId?: string;
 	bridge?: { url: string; token: string };
+	localRoots?: Record<string, string>;
 }): Record<string, string> | undefined {
 	const patch = buildKernelEnvPatch(options);
 	const env: Record<string, string> = {};

package/src/eval/py/index.ts

@@ -1,5 +1,10 @@
 import type { ToolSession } from "../../tools";
-import type { ExecutorBackend, ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import {
+	type ExecutorBackend,
+	type ExecutorBackendExecOptions,
+	type ExecutorBackendResult,
+	resolveEvalUrlRoots,
+} from "../backend";
 import { executePython, type PythonExecutorOptions } from "./executor";
 import { checkPythonKernelAvailability } from "./kernel";
 
@@ -34,6 +39,7 @@ export default {
 			kernelMode,
 			sessionFile: opts.sessionFile,
 			artifactsDir: opts.session.getArtifactsDir?.() ?? undefined,
+			localRoots: resolveEvalUrlRoots(opts.session),
 			kernelOwnerId: opts.kernelOwnerId,
 			reset: opts.reset,
 			artifactPath: opts.artifactPath,

package/src/eval/py/prelude.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
-    import os, json, math
+    import os, json, math, re
+    from urllib.parse import unquote
 
     # __omp_display is injected by runner.py before the prelude executes; it
     # mirrors IPython's display() semantics with the same MIME bundle output.
@@ -53,9 +54,47 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("env", key=key, value=val, action="get")
         return val
 
+    _OMP_INTERNAL_URL_RE = re.compile(r"^([a-z][a-z0-9+.-]*)://(.*)$", re.IGNORECASE)
+
+    def _resolve_omp_path(path: str | Path) -> Path:
+        """Map a helper path to a real filesystem Path.
+
+        A `scheme://…` whose scheme has an injected on-disk root (e.g.
+        `local://`, via PI_EVAL_LOCAL_ROOTS) is rewritten under that root so it
+        lands where `read local://…` resolves — not a literal `local:/`
+        directory under the cwd (which `Path("local://x")` collapses to). Plain
+        paths pass through unchanged; any other `scheme://` is rejected."""
+        if not isinstance(path, str):
+            return Path(path)
+        match = _OMP_INTERNAL_URL_RE.match(path)
+        if not match:
+            return Path(path)
+        scheme = match.group(1).lower()
+        try:
+            roots = json.loads(os.environ.get("PI_EVAL_LOCAL_ROOTS") or "{}")
+        except (ValueError, TypeError):
+            roots = {}
+        root = roots.get(scheme) if isinstance(roots, dict) else None
+        if not root:
+            raise ValueError(f"Protocol paths are not supported by this helper: {path}")
+        relative = unquote(match.group(2).replace("\\", "/"))
+        # Mirror the host `path.resolve`/`resolveLocalUrlToPath`: normalize and
+        # make absolute WITHOUT realpath'ing symlinks (Path.resolve would turn
+        # /tmp into /private/tmp and diverge from the read-side resolution).
+        root_path = os.path.abspath(root)
+        if relative == "":
+            return Path(root_path)
+        rel_path = Path(relative)
+        if rel_path.is_absolute() or ".." in rel_path.parts:
+            raise ValueError(f"Unsafe {scheme}:// path (absolute or traversal): {path}")
+        resolved = os.path.abspath(os.path.join(root_path, relative))
+        if resolved != root_path and not resolved.startswith(root_path + os.sep):
+            raise ValueError(f"{scheme}:// path escapes its root: {path}")
+        return Path(resolved)
+
     def read(path: str | Path, offset: int = 1, limit: int | None = None) -> str:
         """Read file contents. offset/limit are 1-indexed line numbers."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         data = p.read_text(encoding="utf-8")
         lines = data.splitlines(keepends=True)
         if offset > 1 or limit is not None:
@@ -69,7 +108,7 @@ if "__omp_prelude_loaded__" not in globals():
 
     def write(path: str | Path, content: str) -> Path:
         """Write file contents (create parents)."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         p.parent.mkdir(parents=True, exist_ok=True)
         p.write_text(content, encoding="utf-8")
         _emit_status("write", path=str(p), chars=len(content))
@@ -77,7 +116,7 @@ if "__omp_prelude_loaded__" not in globals():
 
     def append(path: str | Path, content: str) -> Path:
         """Append to file."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         p.parent.mkdir(parents=True, exist_ok=True)
         with p.open("a", encoding="utf-8") as f:
             f.write(content)

package/src/eval/py/runner.py

@@ -819,6 +819,7 @@ _MANAGED_ENV_KEYS = (
     "PI_TOOL_BRIDGE_URL",
     "PI_TOOL_BRIDGE_TOKEN",
     "PI_TOOL_BRIDGE_SESSION",
+    "PI_EVAL_LOCAL_ROOTS",
 )
 
 

package/src/exa/index.ts

@@ -1,27 +1,2 @@
-/**
- * Exa MCP Tools
- *
- * 22 tools for Exa's MCP servers:
- * - 4 search tools (search, deep, code, crawl)
- * - 1 LinkedIn search tool
- * - 1 company research tool
- * - 2 researcher tools (start, poll)
- * - 14 websets tools (CRUD, items, search, enrichment, monitor)
- */
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import { researcherTools } from "./researcher";
-import { searchTools } from "./search";
-import type { ExaRenderDetails } from "./types";
-import { websetsTools } from "./websets";
-
-/** All Exa tools (22 total) - static export for backward compatibility */
-export const exaTools: CustomTool<any, ExaRenderDetails>[] = [...searchTools, ...researcherTools, ...websetsTools];
-
 export * from "./mcp-client";
-export { renderExaCall, renderExaResult } from "./render";
-export { researcherTools } from "./researcher";
-// Re-export individual modules for selective importing
-export { searchTools } from "./search";
-// Re-export types and utilities
-export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult, MCPToolWrapperConfig } from "./types";
-export { websetsTools } from "./websets";
+export type { ExaSearchResponse, MCPCallResponse, MCPTool, MCPToolsResponse, MCPToolWrapperConfig } from "./types";

package/src/exa/mcp-client.ts

@@ -2,14 +2,14 @@ import type { TSchema } from "@oh-my-pi/pi-ai";
 import { $env, logger } from "@oh-my-pi/pi-utils";
 import type { CustomTool, CustomToolResult } from "../extensibility/custom-tools/types";
 import { type CallMcpOptions, callMCP } from "../mcp/json-rpc";
-import type {
-	ExaRenderDetails,
-	ExaSearchResponse,
-	MCPCallResponse,
-	MCPTool,
-	MCPToolsResponse,
-	MCPToolWrapperConfig,
-} from "./types";
+import type { ExaSearchResponse, MCPCallResponse, MCPTool, MCPToolsResponse, MCPToolWrapperConfig } from "./types";
+
+type MCPWrappedToolDetails = {
+	response?: ExaSearchResponse;
+	error?: string;
+	toolName?: string;
+	raw?: unknown;
+};
 
 /** Find EXA_API_KEY from Bun.env or .env files */
 export function findApiKey(): string | null {
@@ -296,7 +296,7 @@ export async function fetchMCPToolSchema(
  * This allows tools to be generated from MCP server schemas without hardcoding,
  * reducing drift when MCP servers add new parameters.
  */
-export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
+export class MCPWrappedTool implements CustomTool<TSchema, MCPWrappedToolDetails> {
 	readonly name: string;
 	readonly label: string;
 
@@ -315,7 +315,7 @@ export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
 		_onUpdate?: unknown,
 		_ctx?: unknown,
 		_signal?: AbortSignal,
-	): Promise<CustomToolResult<ExaRenderDetails>> {
+	): Promise<CustomToolResult<MCPWrappedToolDetails>> {
 		try {
 			const apiKey = findApiKey();
 			// Websets tools require an API key; basic Exa MCP tools work without one

package/src/exa/types.ts

@@ -5,10 +5,6 @@
  */
 import type { TSchema } from "@oh-my-pi/pi-ai";
 
-/** MCP endpoint URLs */
-export const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
-export const WEBSETS_MCP_URL = "https://websetsmcp.exa.ai/mcp";
-
 /** MCP tool definition from server */
 export interface MCPTool {
 	name: string;
@@ -71,96 +67,3 @@ export interface ExaSearchResponse {
 	searchTime?: number;
 	requestId?: string;
 }
-
-/** Researcher task status */
-export interface ResearcherStatus {
-	id: string;
-	status: "pending" | "running" | "completed" | "failed";
-	result?: string;
-	error?: string;
-}
-
-/** Webset definition */
-export interface Webset {
-	id: string;
-	name: string;
-	description?: string;
-	createdAt?: string;
-	updatedAt?: string;
-}
-
-/** Webset item */
-export interface WebsetItem {
-	id: string;
-	websetId: string;
-	url: string;
-	title?: string;
-	content?: string;
-	metadata?: Record<string, unknown>;
-}
-
-/** Webset search */
-export interface WebsetSearch {
-	id: string;
-	websetId: string;
-	query: string;
-	status: "pending" | "running" | "completed" | "cancelled";
-	resultCount?: number;
-}
-
-/** Webset enrichment */
-export interface WebsetEnrichment {
-	id: string;
-	websetId: string;
-	name: string;
-	prompt: string;
-	status: "pending" | "running" | "completed" | "cancelled";
-}
-
-/** Tool name mappings: MCP name -> our tool name */
-export const EXA_TOOL_MAPPINGS = {
-	// Search tools
-	web_search_exa: "exa_search",
-	get_code_context_exa: "exa_search_code",
-	crawling_exa: "exa_crawl",
-	// LinkedIn
-	linkedin_search_exa: "exa_linkedin",
-	// Company
-	company_research_exa: "exa_company",
-	// Researcher
-	deep_researcher_start: "exa_researcher_start",
-	deep_researcher_check: "exa_researcher_poll",
-} as const;
-
-export const WEBSETS_TOOL_MAPPINGS = {
-	create_webset: "webset_create",
-	list_websets: "webset_list",
-	get_webset: "webset_get",
-	update_webset: "webset_update",
-	delete_webset: "webset_delete",
-	list_webset_items: "webset_items_list",
-	get_item: "webset_item_get",
-	create_search: "webset_search_create",
-	get_search: "webset_search_get",
-	cancel_search: "webset_search_cancel",
-	create_enrichment: "webset_enrichment_create",
-	get_enrichment: "webset_enrichment_get",
-	update_enrichment: "webset_enrichment_update",
-	delete_enrichment: "webset_enrichment_delete",
-	cancel_enrichment: "webset_enrichment_cancel",
-	create_monitor: "webset_monitor_create",
-} as const;
-
-export type ExaMcpToolName = keyof typeof EXA_TOOL_MAPPINGS;
-export type WebsetsMcpToolName = keyof typeof WEBSETS_TOOL_MAPPINGS;
-export type ExaToolName = (typeof EXA_TOOL_MAPPINGS)[ExaMcpToolName];
-export type WebsetsToolName = (typeof WEBSETS_TOOL_MAPPINGS)[WebsetsMcpToolName];
-
-/** Render details for TUI */
-export interface ExaRenderDetails {
-	response?: ExaSearchResponse;
-	error?: string;
-	toolName?: string;
-	/** Raw result for non-search responses */
-	raw?: unknown;
-}