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

package/src/web/search/provider.ts

@@ -1,39 +1,121 @@
-import { AnthropicProvider } from "./providers/anthropic";
+// Lazy registry of web search providers.
+//
+// Each provider is loaded on first use; importing this module loads zero
+// provider implementations. Provider modules are heavy (each pulls in
+// fetch/parse/format helpers) and only one — at most — is needed per session,
+// so eager construction was wasted work at startup.
+//
+// The `label`/`id` metadata is kept inline so callers needing a display name
+// (error formatting, UI listings) do not force a load.
+
 import type { SearchProvider } from "./providers/base";
-import { BraveProvider } from "./providers/brave";
-import { CodexProvider } from "./providers/codex";
-import { ExaProvider } from "./providers/exa";
-import { GeminiProvider } from "./providers/gemini";
-import { JinaProvider } from "./providers/jina";
-import { KagiProvider } from "./providers/kagi";
-import { KimiProvider } from "./providers/kimi";
-import { ParallelProvider } from "./providers/parallel";
-import { PerplexityProvider } from "./providers/perplexity";
-import { SearXNGProvider } from "./providers/searxng";
-import { SyntheticProvider } from "./providers/synthetic";
-import { TavilyProvider } from "./providers/tavily";
-import { ZaiProvider } from "./providers/zai";
 import type { SearchProviderId } from "./types";
 
 export type { SearchParams } from "./providers/base";
 export { SearchProvider } from "./providers/base";
 
-const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
-	exa: new ExaProvider(),
-	brave: new BraveProvider(),
-	jina: new JinaProvider(),
-	perplexity: new PerplexityProvider(),
-	kimi: new KimiProvider(),
-	zai: new ZaiProvider(),
-	anthropic: new AnthropicProvider(),
-	gemini: new GeminiProvider(),
-	codex: new CodexProvider(),
-	tavily: new TavilyProvider(),
-	parallel: new ParallelProvider(),
-	kagi: new KagiProvider(),
-	synthetic: new SyntheticProvider(),
-	searxng: new SearXNGProvider(),
-} as const;
+interface ProviderMeta {
+	id: SearchProviderId;
+	label: string;
+	load: () => Promise<SearchProvider>;
+}
+
+/** Lazy factories. Each `load()` dynamic-imports its provider module on first call. */
+const PROVIDER_META: Record<SearchProviderId, ProviderMeta> = {
+	exa: {
+		id: "exa",
+		label: "Exa",
+		load: async () => new (await import("./providers/exa")).ExaProvider(),
+	},
+	brave: {
+		id: "brave",
+		label: "Brave",
+		load: async () => new (await import("./providers/brave")).BraveProvider(),
+	},
+	jina: {
+		id: "jina",
+		label: "Jina",
+		load: async () => new (await import("./providers/jina")).JinaProvider(),
+	},
+	perplexity: {
+		id: "perplexity",
+		label: "Perplexity",
+		load: async () => new (await import("./providers/perplexity")).PerplexityProvider(),
+	},
+	kimi: {
+		id: "kimi",
+		label: "Kimi",
+		load: async () => new (await import("./providers/kimi")).KimiProvider(),
+	},
+	zai: {
+		id: "zai",
+		label: "Z.AI",
+		load: async () => new (await import("./providers/zai")).ZaiProvider(),
+	},
+	anthropic: {
+		id: "anthropic",
+		label: "Anthropic",
+		load: async () => new (await import("./providers/anthropic")).AnthropicProvider(),
+	},
+	gemini: {
+		id: "gemini",
+		label: "Gemini",
+		load: async () => new (await import("./providers/gemini")).GeminiProvider(),
+	},
+	codex: {
+		id: "codex",
+		label: "Codex",
+		load: async () => new (await import("./providers/codex")).CodexProvider(),
+	},
+	tavily: {
+		id: "tavily",
+		label: "Tavily",
+		load: async () => new (await import("./providers/tavily")).TavilyProvider(),
+	},
+	parallel: {
+		id: "parallel",
+		label: "Parallel",
+		load: async () => new (await import("./providers/parallel")).ParallelProvider(),
+	},
+	kagi: {
+		id: "kagi",
+		label: "Kagi",
+		load: async () => new (await import("./providers/kagi")).KagiProvider(),
+	},
+	synthetic: {
+		id: "synthetic",
+		label: "Synthetic",
+		load: async () => new (await import("./providers/synthetic")).SyntheticProvider(),
+	},
+	searxng: {
+		id: "searxng",
+		label: "SearXNG",
+		load: async () => new (await import("./providers/searxng")).SearXNGProvider(),
+	},
+};
+
+const instanceCache = new Map<SearchProviderId, SearchProvider>();
+
+/** Cheap, sync metadata accessor — never triggers a provider load. */
+export function getSearchProviderLabel(id: SearchProviderId): string {
+	return PROVIDER_META[id]?.label ?? id;
+}
+
+/**
+ * Resolve and cache a provider instance. First call for a given id loads the
+ * underlying module; subsequent calls return the cached singleton.
+ */
+export async function getSearchProvider(id: SearchProviderId): Promise<SearchProvider> {
+	const cached = instanceCache.get(id);
+	if (cached) return cached;
+	const meta = PROVIDER_META[id];
+	if (!meta) {
+		throw new Error(`Unknown search provider: ${id}`);
+	}
+	const provider = await meta.load();
+	instanceCache.set(id, provider);
+	return provider;
+}
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"tavily",
@@ -52,10 +134,6 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"searxng",
 ];
 
-export function getSearchProvider(provider: SearchProviderId): SearchProvider {
-	return SEARCH_PROVIDERS[provider];
-}
-
 /** Preferred provider set via settings (default: auto) */
 let preferredProvId: SearchProviderId | "auto" = "auto";
 
@@ -64,22 +142,26 @@ export function setPreferredSearchProvider(provider: SearchProviderId | "auto"):
 	preferredProvId = provider;
 }
 
-/** Determine which providers are configured  */
+/**
+ * Determine which providers are configured and currently available.
+ * Each candidate is loaded (and its `isAvailable()` called) only as the chain
+ * is walked, so unconfigured providers never pay the load cost.
+ */
 export async function resolveProviderChain(
 	preferredProvider: SearchProviderId | "auto" = preferredProvId,
 ): Promise<SearchProvider[]> {
 	const providers: SearchProvider[] = [];
 
 	if (preferredProvider !== "auto") {
-		if (await getSearchProvider(preferredProvider).isAvailable()) {
-			providers.push(getSearchProvider(preferredProvider));
+		const provider = await getSearchProvider(preferredProvider);
+		if (await provider.isAvailable()) {
+			providers.push(provider);
 		}
 	}
 
 	for (const id of SEARCH_PROVIDER_ORDER) {
 		if (id === preferredProvider) continue;
-
-		const provider = getSearchProvider(id);
+		const provider = await getSearchProvider(id);
 		if (await provider.isAvailable()) {
 			providers.push(provider);
 		}

package/src/web/search/providers/gemini.ts

@@ -10,9 +10,9 @@ import {
 	extractRetryDelay,
 	getAntigravityHeaders,
 	getGeminiCliHeaders,
-	refreshAntigravityToken,
-	refreshGoogleCloudToken,
 } from "@oh-my-pi/pi-ai";
+import { refreshAntigravityToken } from "@oh-my-pi/pi-ai/utils/oauth/google-antigravity";
+import { refreshGoogleCloudToken } from "@oh-my-pi/pi-ai/utils/oauth/google-gemini-cli";
 import { getAgentDbPath } from "@oh-my-pi/pi-utils";
 import { AgentStorage } from "../../../session/agent-storage";
 import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";

package/src/web/search/render.ts

@@ -22,7 +22,7 @@ import {
 } from "../../tools/render-utils";
 import { renderStatusLine, renderTreeList } from "../../tui";
 import { CachedOutputBlock } from "../../tui/output-block";
-import { getSearchProvider } from "./provider";
+import { getSearchProviderLabel } from "./provider";
 import type { SearchResponse } from "./types";
 
 const MAX_COLLAPSED_ANSWER_LINES = PREVIEW_LIMITS.COLLAPSED_LINES;
@@ -112,7 +112,7 @@ export function renderSearchResult(
 		: [];
 	const totalAnswerLines = answerLines.length;
 
-	const providerLabel = provider !== "none" ? getSearchProvider(provider).label : "None";
+	const providerLabel = provider !== "none" ? getSearchProviderLabel(provider) : "None";
 	const queryPreview = args?.query
 		? truncateToWidth(args.query, 80)
 		: searchQueries[0]

package/src/ipy/modules.ts

@@ -1,144 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { getAgentModulesDir, getProjectDir, getProjectModulesDir } from "@oh-my-pi/pi-utils";
-import { getExecutionCancellationError } from "./cancellation";
-
-export type PythonModuleSource = "user" | "project";
-
-export interface PythonModuleEntry {
-	path: string;
-	content: string;
-	source: PythonModuleSource;
-}
-
-export interface PythonModuleExecuteResult {
-	status: "ok" | "error";
-	cancelled: boolean;
-	timedOut?: boolean;
-	error?: { name: string; value: string; traceback: string[] };
-}
-
-export interface PythonModuleExecutor {
-	execute: (
-		code: string,
-		options?: { signal?: AbortSignal; timeoutMs?: number; silent?: boolean; storeHistory?: boolean },
-	) => Promise<PythonModuleExecuteResult>;
-}
-
-export interface DiscoverPythonModulesOptions {
-	/** Working directory for project-level modules. Default: getProjectDir() */
-	cwd?: string;
-	/** Agent directory for user-level modules. Default: from getAgentDir() */
-	agentDir?: string;
-}
-
-export interface LoadPythonModulesOptions extends DiscoverPythonModulesOptions {
-	signal?: AbortSignal;
-	timeoutMs?: number;
-	deadlineMs?: number;
-}
-
-interface ModuleCandidate {
-	name: string;
-	path: string;
-	source: PythonModuleSource;
-}
-
-async function listModuleCandidates(dir: string, source: PythonModuleSource): Promise<ModuleCandidate[]> {
-	try {
-		const entries = await fs.readdir(dir, { withFileTypes: true });
-		return entries
-			.filter(entry => entry.isFile() && entry.name.endsWith(".py"))
-			.map(entry => ({
-				name: entry.name,
-				path: path.resolve(dir, entry.name),
-				source,
-			}));
-	} catch {
-		return [];
-	}
-}
-
-async function readModuleContent(candidate: ModuleCandidate): Promise<PythonModuleEntry> {
-	try {
-		const content = await Bun.file(candidate.path).text();
-		return { path: candidate.path, content, source: candidate.source };
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`Failed to read Python module ${candidate.path}: ${message}`);
-	}
-}
-
-function createTimeoutError(message: string): Error {
-	const error = new Error(message);
-	error.name = "TimeoutError";
-	return error;
-}
-
-function requireModuleExecutionTimeoutMs(options: LoadPythonModulesOptions): number | undefined {
-	if (options.deadlineMs === undefined) {
-		return options.timeoutMs;
-	}
-
-	const remainingMs = options.deadlineMs - Date.now();
-	if (remainingMs <= 0) {
-		throw createTimeoutError("Python module loading timed out");
-	}
-
-	return remainingMs;
-}
-
-/**
- * Discover Python prelude extension modules from user and project directories.
- */
-export async function discoverPythonModules(options: DiscoverPythonModulesOptions = {}): Promise<PythonModuleEntry[]> {
-	const cwd = options.cwd ?? getProjectDir();
-
-	const userDir = getAgentModulesDir(options.agentDir);
-	const projectDir = getProjectModulesDir(cwd);
-
-	const userCandidates = await listModuleCandidates(userDir, "user");
-	const projectCandidates = await listModuleCandidates(projectDir, "project");
-
-	const byName = new Map<string, ModuleCandidate>();
-	for (const candidate of userCandidates) {
-		if (!byName.has(candidate.name)) {
-			byName.set(candidate.name, candidate);
-		}
-	}
-	for (const candidate of projectCandidates) {
-		const existing = byName.get(candidate.name);
-		if (!existing || existing.source === "user") {
-			byName.set(candidate.name, candidate);
-		}
-	}
-
-	const sorted = Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
-	return Promise.all(sorted.map(candidate => readModuleContent(candidate)));
-}
-
-/**
- * Load Python prelude extension modules into an active kernel.
- */
-export async function loadPythonModules(
-	executor: PythonModuleExecutor,
-	options: LoadPythonModulesOptions = {},
-): Promise<PythonModuleEntry[]> {
-	const modules = await discoverPythonModules(options);
-	for (const module of modules) {
-		const result = await executor.execute(module.content, {
-			signal: options.signal,
-			timeoutMs: requireModuleExecutionTimeoutMs(options),
-			silent: true,
-			storeHistory: false,
-		});
-		if (result.cancelled) {
-			throw getExecutionCancellationError(result, options.signal, `Failed to load Python module ${module.path}`);
-		}
-		if (result.status === "error") {
-			const details = result.error ? `${result.error.name}: ${result.error.value}` : "unknown error";
-			throw new Error(`Failed to load Python module ${module.path}: ${details}`);
-		}
-	}
-	return modules;
-}

package/src/prompts/tools/python.md

@@ -1,57 +0,0 @@
-Runs Python cells sequentially in persistent IPython kernel.
-
-<instruction>
-Kernel persists across calls and cells; **imports, variables, and functions survive — use this.**
-
-**Work incrementally:** one logical step per cell (imports, define, test, use). Pass multiple small cells in one call. Define small reusable functions you can debug individually. You **MUST** put workflow explanations in the assistant message or cell title — never inside cell code.
-
-**On failure:** errors identify the failing cell (e.g., "Cell 3 failed"). Resubmit only the fixed cell (or fixed cell + remaining cells).
-</instruction>
-
-{{#if categories.length}}
-<prelude>
-All helpers auto-print results and return values for chaining.
-
-{{#each categories}}
-### {{name}}
-
-```
-{{#each functions}}
-{{name}}{{signature}}
-    {{docstring}}
-{{/each}}
-```
-{{/each}}
-</prelude>
-{{/if}}
-
-<output>
-User sees output like Jupyter notebook; rich displays render fully:
-- `display(JSON(data))` → interactive JSON tree
-- `display(HTML(…))` → rendered HTML
-- `display(Markdown(…))` → formatted markdown
-- `plt.show()` → inline figures
-
-**You will see object repr** (e.g., `<IPython.core.display.JSON object>`). Trust `display()`; you **MUST NOT** assume the user sees only the repr.
-</output>
-
-<caution>
-- Per-call mode uses a fresh kernel each call
-- You **MUST** use `reset: true` to clear state when session mode is active
-</caution>
-
-<critical>
-- You **MUST** use `run()` for shell commands; you **MUST NOT** use raw `subprocess`
-</critical>
-
-<examples>
-# Multiple small cells
-```python
-cells: [
-    {"title": "imports", "code": "import json\nfrom pathlib import Path"},
-    {"title": "parse helper", "code": "def parse_config(path):\n    return json.loads(Path(path).read_text())"},
-    {"title": "test helper", "code": "parse_config('config.json')"},
-    {"title": "use helper", "code": "configs = [parse_config(p) for p in Path('.').glob('*.json')]"}
-]
-```
-</examples>