@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

package/dist/builtin/web-access/index-heavy.ts

@@ -1,164 +0,0 @@
-import type { ExtensionAPI } from "@bastani/atomic";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
-import { appendFileSync } from "node:fs";
-import { getActiveGoogleEmail, isGeminiWebAvailable } from "./gemini-web.js";
-import { isBrowserCookieAccessAllowed } from "./gemini-web-config.ts";
-import { deleteResult, getAllResults } from "./storage.js";
-import { loadConfigForExtensionInit, resolveWorkflow, saveConfig, type WebSearchWorkflow } from "./web-search-config.js";
-
-if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL_FILE) {
-	appendFileSync(process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL_FILE, "web-access\n");
-}
-
-if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL === "1") {
-	process.env.ATOMIC_WEB_ACCESS_HEAVY_IMPORTED = "1";
-}
-import { registerWebSearchFeatures } from "./web-search-features.js";
-
-export default function (pi: ExtensionAPI) {
-	const initConfig = loadConfigForExtensionInit();
-	registerWebSearchFeatures(pi, initConfig);
-	pi.registerCommand("curator", {
-		description: "Toggle or configure the search curator workflow",
-		handler: async (args, ctx) => {
-			const arg = args.trim().toLowerCase();
-
-			let newWorkflow: WebSearchWorkflow;
-			if (arg.length === 0) {
-				const current = resolveWorkflow(loadConfigForExtensionInit().workflow, true);
-				newWorkflow = current === "none" ? "summary-review" : "none";
-			} else if (arg === "on") {
-				newWorkflow = "summary-review";
-			} else if (arg === "off") {
-				newWorkflow = "none";
-			} else if (arg === "none" || arg === "summary-review") {
-				newWorkflow = arg;
-			} else {
-				ctx.ui.notify(`Unknown option: ${arg}. Use on, off, or summary-review.`, "error");
-				return;
-			}
-
-			try {
-				saveConfig({ workflow: newWorkflow });
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				ctx.ui.notify(`Failed to save config: ${message}`, "error");
-				return;
-			}
-
-			const label = newWorkflow === "none"
-				? "Curator disabled — web_search will return raw results"
-				: "Curator enabled — web_search will open curator and auto-generate a summary draft";
-			pi.sendMessage({
-				customType: "curator-config",
-				content: [{ type: "text", text: label }],
-				display: "tool",
-				details: { workflow: newWorkflow },
-			}, { triggerTurn: false, deliverAs: "followUp" });
-		},
-	});
-
-	pi.registerCommand("google-account", {
-		description: "Show the active Google account for Gemini Web",
-		handler: async () => {
-			if (!isBrowserCookieAccessAllowed()) {
-				pi.sendMessage({
-					customType: "google-account",
-					content: [{ type: "text", text: `Gemini Web browser cookie access is disabled. Set allowBrowserCookies: true in ~/${CONFIG_DIR_NAME}/web-search.json to enable it.` }],
-					display: "tool",
-					details: { available: false, cookieAccessAllowed: false },
-				}, { triggerTurn: true, deliverAs: "followUp" });
-				return;
-			}
-
-			const cookies = await isGeminiWebAvailable();
-			if (!cookies) {
-				pi.sendMessage({
-					customType: "google-account",
-					content: [{ type: "text", text: "Gemini Web is unavailable. Sign into gemini.google.com in a supported Chromium-based browser." }],
-					display: "tool",
-					details: { available: false, cookieAccessAllowed: true },
-				}, { triggerTurn: true, deliverAs: "followUp" });
-				return;
-			}
-
-			const email = await getActiveGoogleEmail(cookies);
-			const text = email
-				? `Active Google account: ${email}`
-				: "Gemini Web is available, but the active Google account could not be determined.";
-
-			pi.sendMessage({
-				customType: "google-account",
-				content: [{ type: "text", text }],
-				display: "tool",
-				details: { available: true, email: email ?? null },
-			}, { triggerTurn: true, deliverAs: "followUp" });
-		},
-	});
-
-	pi.registerCommand("search", {
-		description: "Browse stored web search results",
-		handler: async (_args, ctx) => {
-			const results = getAllResults();
-
-			if (results.length === 0) {
-				ctx.ui.notify("No stored search results", "info");
-				return;
-			}
-
-			const options = results.map((r) => {
-				const age = Math.floor((Date.now() - r.timestamp) / 60000);
-				const ageStr = age < 60 ? `${age}m ago` : `${Math.floor(age / 60)}h ago`;
-				if (r.type === "search" && r.queries) {
-					const query = r.queries[0]?.query || "unknown";
-					return `[${r.id.slice(0, 6)}] "${query}" (${r.queries.length} queries) - ${ageStr}`;
-				}
-				if (r.type === "fetch" && r.urls) {
-					return `[${r.id.slice(0, 6)}] ${r.urls.length} URLs fetched - ${ageStr}`;
-				}
-				return `[${r.id.slice(0, 6)}] ${r.type} - ${ageStr}`;
-			});
-
-			const choice = await ctx.ui.select("Stored Search Results", options);
-			if (!choice) return;
-
-			const match = choice.match(/^\[([a-z0-9]+)\]/);
-			if (!match) return;
-
-			const selected = results.find((r) => r.id.startsWith(match[1]));
-			if (!selected) return;
-
-			const actions = ["View details", "Delete"];
-			const action = await ctx.ui.select(`Result ${selected.id.slice(0, 6)}`, actions);
-
-			if (action === "Delete") {
-				deleteResult(selected.id);
-				ctx.ui.notify(`Deleted ${selected.id.slice(0, 6)}`, "info");
-			} else if (action === "View details") {
-				let info = `ID: ${selected.id}\nType: ${selected.type}\nAge: ${Math.floor((Date.now() - selected.timestamp) / 60000)}m\n\n`;
-				if (selected.type === "search" && selected.queries) {
-					info += "Queries:\n";
-					const queries = selected.queries.slice(0, 10);
-					for (const q of queries) {
-						info += `- "${q.query}" (${q.results.length} results)\n`;
-					}
-					if (selected.queries.length > 10) {
-						info += `... and ${selected.queries.length - 10} more\n`;
-					}
-				}
-				if (selected.type === "fetch" && selected.urls) {
-					info += "URLs:\n";
-					const urls = selected.urls.slice(0, 10);
-					for (const u of urls) {
-						const urlDisplay = u.url.length > 50 ? u.url.slice(0, 47) + "..." : u.url;
-						info += `- ${urlDisplay} (${u.error || `${u.content.length} chars`})\n`;
-					}
-					if (selected.urls.length > 10) {
-						info += `... and ${selected.urls.length - 10} more\n`;
-					}
-				}
-				ctx.ui.notify(info, "info");
-			}
-		},
-	});
-}

package/dist/builtin/web-access/index.ts

@@ -1,401 +0,0 @@
-import type { ExtensionAPI, ExtensionContext, HandlerFn, MessageRenderer, RegisteredCommand, ToolDefinition } from "@bastani/atomic";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
-import { renderWebAccessToolResult } from "./result-renderers.js";
-import { assertCurrentLifecycleLease, createLifecycleLease, retainSettledLifecycleCleanup, retireLifecycleLease, type LifecycleLease } from "./lifecycle-lease.js";
-
-type CapturedCommand = Omit<RegisteredCommand, "name" | "sourceInfo">;
-type CapturedShortcut = Parameters<ExtensionAPI["registerShortcut"]>[1];
-type ToolRenderResultArgs = Parameters<NonNullable<ToolDefinition["renderResult"]>>;
-type CapturedHeavy = {
-	tools: Map<string, ToolDefinition>;
-	commands: Map<string, CapturedCommand>;
-	handlers: Map<string, HandlerFn[]>;
-	shortcuts: Map<string, CapturedShortcut>;
-};
-type ShutdownSnapshot = { event: unknown; ctx: ExtensionContext; generation: number };
-type WebLease = LifecycleLease<ShutdownSnapshot>;
-type SessionSnapshot = {
-	eventName: "session_start" | "session_tree";
-	event: unknown;
-	ctx: ExtensionContext;
-	generation: number;
-	lease: WebLease;
-};
-type HeavyHandle = { heavy: CapturedHeavy; assertCurrent: () => void };
-type HeavyAttempt = { lease: WebLease; promise: Promise<HeavyHandle> };
-type ReplayAttempt = { lease: WebLease; heavy: CapturedHeavy; promise: Promise<void> };
-
-function addHandler(captured: CapturedHeavy, event: string, handler: HandlerFn): void {
-	const handlers = captured.handlers.get(event) ?? [];
-	handlers.push(handler);
-	captured.handlers.set(event, handlers);
-}
-
-async function dispatchHandlers(captured: CapturedHeavy, eventName: string, event: unknown, ctx: ExtensionContext): Promise<void> {
-	for (const handler of captured.handlers.get(eventName) ?? []) {
-		await handler(event, ctx);
-	}
-}
-
-function createHeavyProxy(pi: ExtensionAPI, captured: CapturedHeavy): ExtensionAPI {
-	return new Proxy(pi, {
-		get(target, prop, receiver) {
-			if (prop === "registerTool") {
-				return (tool: ToolDefinition) => {
-					captured.tools.set(tool.name, tool);
-				};
-			}
-			if (prop === "registerCommand") {
-				return (name: string, options: CapturedCommand) => {
-					captured.commands.set(name, options);
-				};
-			}
-			if (prop === "on") {
-				return (event: string, handler: HandlerFn) => {
-					addHandler(captured, event, handler);
-				};
-			}
-			if (prop === "registerShortcut") {
-				return (shortcut: string, options: CapturedShortcut) => {
-					captured.shortcuts.set(shortcut, options);
-				};
-			}
-			if (prop === "registerMessageRenderer") {
-				return (customType: string, renderer: MessageRenderer) => pi.registerMessageRenderer(customType, renderer);
-			}
-			return Reflect.get(target, prop, receiver);
-		},
-	}) as ExtensionAPI;
-}
-
-function waitForCaller<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
-	if (!signal) return promise;
-	signal.throwIfAborted();
-	return new Promise<T>((resolve, reject) => {
-		let settled = false;
-		const finish = (callback: () => void): void => {
-			if (settled) return;
-			settled = true;
-			signal.removeEventListener("abort", onAbort);
-			callback();
-		};
-		const onAbort = (): void => finish(() => reject(signal.reason));
-		signal.addEventListener("abort", onAbort, { once: true });
-		void promise.then((value) => finish(() => resolve(value)), (error: unknown) => finish(() => reject(error)));
-		if (signal.aborted) onAbort();
-	});
-}
-
-async function executeHeavyTool(
-	loadHeavy: () => Promise<HeavyHandle>,
-	name: string,
-	args: Parameters<NonNullable<ToolDefinition["execute"]>>,
-): Promise<Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>> {
-	args[2]?.throwIfAborted();
-	const handle = await waitForCaller(loadHeavy(), args[2]);
-	args[2]?.throwIfAborted();
-	handle.assertCurrent();
-	const tool = handle.heavy.tools.get(name);
-	if (!tool?.execute) throw new Error(`Web access tool implementation not found: ${name}`);
-	let result: Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>;
-	try {
-		result = await tool.execute(...args);
-	} catch (error) {
-		args[2]?.throwIfAborted();
-		throw error;
-	}
-	args[2]?.throwIfAborted();
-	handle.assertCurrent();
-	return result as Awaited<ReturnType<NonNullable<ToolDefinition["execute"]>>>;
-}
-
-async function runHeavyCommand(loadHeavy: () => Promise<HeavyHandle>, name: string, args: string | undefined, ctx: ExtensionContext): Promise<void> {
-	const handle = await loadHeavy();
-	handle.assertCurrent();
-	const command = handle.heavy.commands.get(name);
-	if (!command) throw new Error(`Web access command implementation not found: ${name}`);
-	await command.handler(args, ctx);
-	handle.assertCurrent();
-}
-
-function renderHeavyToolResult(loadedHeavy: CapturedHeavy | null, name: string, args: ToolRenderResultArgs): ReturnType<NonNullable<ToolDefinition["renderResult"]>> {
-	const renderer = loadedHeavy?.tools.get(name)?.renderResult;
-	if (renderer) return renderer(...args);
-	return renderWebAccessToolResult(name, args);
-}
-
-function getInitialShortcutConfig(): { curate: string; activity: string } {
-	const defaults = { curate: "ctrl+shift+s", activity: "ctrl+shift+w" };
-	for (const configPath of [join(homedir(), ".atomic", "web-search.json"), join(homedir(), ".pi", "web-search.json")]) {
-		try {
-			if (!existsSync(configPath)) continue;
-			const parsed = JSON.parse(readFileSync(configPath, "utf8")) as { shortcuts?: { curate?: string; activity?: string } };
-			return {
-				curate: parsed.shortcuts?.curate?.trim() || defaults.curate,
-				activity: parsed.shortcuts?.activity?.trim() || defaults.activity,
-			};
-		} catch (error) {
-			console.error(`[pi-web-access] Failed to inspect shortcuts in ${configPath}:`, error);
-		}
-	}
-	return defaults;
-}
-
-function isAllFailedWebResult(toolName: string, details: unknown): boolean {
-	if (toolName !== "web_search" && toolName !== "fetch_content") return false;
-	if (!details || typeof details !== "object") return false;
-	return Reflect.get(details, "outcome") === "all_failed";
-}
-
-export default function webAccess(pi: ExtensionAPI) {
-	let heavyAttempt: HeavyAttempt | null = null;
-	let loadedHeavy: HeavyHandle | null = null;
-	let sessionSnapshot: SessionSnapshot | null = null;
-	let lifecycleGeneration = 0;
-	let nextLeaseId = 1;
-	let activeLease = createLifecycleLease<ShutdownSnapshot>(nextLeaseId++);
-	let replayedGeneration = 0;
-	let replayAttempt: ReplayAttempt | null = null;
-	const invalidatedMessage = "Web access initialization was invalidated by session shutdown";
-
-	function assertLease(lease: WebLease): void {
-		assertCurrentLifecycleLease(activeLease, lease, invalidatedMessage);
-	}
-
-	function createHandle(heavy: CapturedHeavy, lease: WebLease): HeavyHandle {
-		return { heavy, assertCurrent: () => assertLease(lease) };
-	}
-
-	async function waitForPriorCleanup(lease: WebLease): Promise<void> {
-		await lease.priorCleanup;
-		assertLease(lease);
-	}
-
-	async function replayCurrentSession(heavy: CapturedHeavy, lease: WebLease, onReplay?: (ctx: ExtensionContext) => void): Promise<void> {
-		for (;;) {
-			assertLease(lease);
-			const snapshot = sessionSnapshot;
-			if (!snapshot || snapshot.lease !== lease || replayedGeneration === snapshot.generation) return;
-			onReplay?.(snapshot.ctx);
-			await dispatchHandlers(heavy, snapshot.eventName, snapshot.event, snapshot.ctx);
-			assertLease(lease);
-			if (sessionSnapshot === snapshot) {
-				replayedGeneration = snapshot.generation;
-				return;
-			}
-		}
-	}
-
-	async function ensureCurrentSessionReplayed(heavy: CapturedHeavy, lease: WebLease, onReplay?: (ctx: ExtensionContext) => void): Promise<void> {
-		await waitForPriorCleanup(lease);
-		const snapshot = sessionSnapshot;
-		if (!snapshot || snapshot.lease !== lease || replayedGeneration === snapshot.generation) return;
-		const existing = replayAttempt;
-		if (existing?.lease === lease && existing.heavy === heavy) return existing.promise;
-		let promise: Promise<void>;
-		promise = replayCurrentSession(heavy, lease, onReplay).finally(() => {
-			if (replayAttempt?.promise === promise) replayAttempt = null;
-		});
-		replayAttempt = { lease, heavy, promise };
-		await promise;
-	}
-
-	async function loadHeavy(): Promise<HeavyHandle> {
-		const lease = activeLease;
-		if (lease.retired) throw new Error("Web access initialization unavailable: no active session");
-		await waitForPriorCleanup(lease);
-		const existing = heavyAttempt;
-		if (existing?.lease === lease) {
-			const handle = await existing.promise;
-			assertLease(lease);
-			await ensureCurrentSessionReplayed(handle.heavy, lease);
-			assertLease(lease);
-			return handle;
-		}
-		let promise: Promise<HeavyHandle>;
-		promise = (async (): Promise<HeavyHandle> => {
-			const captured: CapturedHeavy = { tools: new Map(), commands: new Map(), handlers: new Map(), shortcuts: new Map() };
-			let replayCtx: ExtensionContext | null = null;
-			let cleaned = false;
-			const cleanupCandidate = async (): Promise<void> => {
-				const shutdown = lease.shutdown;
-				const cleanupCtx = shutdown?.ctx ?? replayCtx;
-				if (!cleanupCtx || cleaned) return;
-				cleaned = true;
-				try {
-					await dispatchHandlers(captured, "session_shutdown", shutdown?.event ?? { type: "session_shutdown", reason: "quit" }, cleanupCtx);
-				} catch (cleanupError) {
-					console.error("[pi-web-access] Failed to clean rejected lazy candidate:", cleanupError);
-				}
-			};
-			try {
-				const mod = await import("./index-heavy.js");
-				assertLease(lease);
-				await mod.default(createHeavyProxy(pi, captured));
-				assertLease(lease);
-				await ensureCurrentSessionReplayed(captured, lease, (ctx) => { replayCtx = ctx; });
-				assertLease(lease);
-				const handle = createHandle(captured, lease);
-				loadedHeavy = handle;
-				return handle;
-			} catch (error) {
-				await cleanupCandidate();
-				throw error;
-			}
-		})();
-		heavyAttempt = { lease, promise };
-		void promise.then(
-			() => undefined,
-			() => { if (heavyAttempt?.promise === promise) heavyAttempt = null; },
-		);
-		return promise;
-	}
-
-	pi.on("session_start", async (event, ctx) => {
-		if (activeLease.retired) activeLease = createLifecycleLease<ShutdownSnapshot>(nextLeaseId++, activeLease.cleanupBarrier);
-		const lease = activeLease;
-		await waitForPriorCleanup(lease);
-		const generation = ++lifecycleGeneration;
-		sessionSnapshot = { eventName: "session_start", event, ctx, generation, lease };
-		if (loadedHeavy) await ensureCurrentSessionReplayed(loadedHeavy.heavy, lease);
-	});
-
-	pi.on("session_tree", async (event, ctx) => {
-		const lease = activeLease;
-		if (lease.retired) return;
-		await lease.priorCleanup;
-		if (activeLease !== lease || lease.retired) return;
-		const generation = ++lifecycleGeneration;
-		sessionSnapshot = { eventName: "session_tree", event, ctx, generation, lease };
-		if (loadedHeavy) await ensureCurrentSessionReplayed(loadedHeavy.heavy, lease);
-	});
-
-	pi.on("session_shutdown", async (event, ctx) => {
-		const lease = activeLease;
-		const generation = ++lifecycleGeneration;
-		const shutdown = { event, ctx, generation };
-		retireLifecycleLease(lease, shutdown);
-		const retiredHeavy = loadedHeavy?.heavy ?? null;
-		const retiredAttempt = heavyAttempt?.lease === lease ? heavyAttempt.promise : null;
-		const retiredReplay = replayAttempt?.lease === lease ? replayAttempt.promise : null;
-		sessionSnapshot = null;
-		heavyAttempt = null;
-		loadedHeavy = null;
-		replayAttempt = null;
-		replayedGeneration = generation;
-		const publishedCleanup = retiredHeavy
-			? dispatchHandlers(retiredHeavy, "session_shutdown", event, ctx)
-			: Promise.resolve();
-		const retainedCleanup = retainSettledLifecycleCleanup(lease, [publishedCleanup, retiredAttempt, retiredReplay]);
-		try {
-			await publishedCleanup;
-		} finally {
-			await retainedCleanup;
-		}
-	});
-
-	pi.on("tool_result", (event) => {
-		if (isAllFailedWebResult(event.toolName, event.details)) return { isError: true };
-	});
-
-	const shortcuts = getInitialShortcutConfig();
-	for (const [shortcut, name] of [[shortcuts.curate, "curate"], [shortcuts.activity, "activity"]] as const) {
-		pi.registerShortcut(shortcut, {
-			description: name === "curate" ? "Open web search curator" : "Show web search activity",
-			handler: async (ctx) => {
-				const handle = await loadHeavy();
-				handle.assertCurrent();
-				const handler = handle.heavy.shortcuts.get(shortcut)?.handler;
-				if (!handler) throw new Error(`Web access shortcut implementation not found: ${shortcut}`);
-				await handler(ctx);
-				handle.assertCurrent();
-			},
-		});
-	}
-
-	pi.registerTool({
-		name: "web_search",
-		label: "Web Search",
-		description: "Search the web using Perplexity AI, Exa, or Gemini. Returns an AI-synthesized answer with source citations. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches return raw results by default. Enable the interactive browser curator with /curator on or by setting workflow to \"summary-review\" in web-search config. Provider auto-selects: Exa (direct API with key, MCP fallback without), else Perplexity (needs key), else Gemini API (needs key), else Gemini Web (needs a supported Chromium-based browser login).",
-		promptSnippet: "Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage.",
-		parameters: Type.Object({
-			query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
-			queries: Type.Optional(Type.Array(Type.String(), { description: "Multiple queries searched in sequence, each returning its own synthesized answer. Prefer this for research — vary phrasing, scope, and angle across 2-4 queries to maximize coverage." })),
-			numResults: Type.Optional(Type.Number({ description: "Results per query (default: 5, max: 20)" })),
-			includeContent: Type.Optional(Type.Boolean({ description: "Fetch full page content (async)" })),
-			recencyFilter: Type.Optional(Type.String({ enum: ["day", "week", "month", "year"], description: "Filter by recency" })),
-			domainFilter: Type.Optional(Type.Array(Type.String(), { description: "Limit to domains (prefix with - to exclude)" })),
-			provider: Type.Optional(Type.String({ enum: ["auto", "perplexity", "gemini", "exa"], description: "Search provider (default: auto)" })),
-		}),
-		execute: (...args) => executeHeavyTool(loadHeavy, "web_search", args),
-		renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "web_search", args),
-		renderCall(args, theme) {
-			const input = args as { query?: string; queries?: string[] };
-			const label = input.queries?.length ? `${input.queries.length} queries` : input.query ?? "(no query)";
-			return new Text(theme.fg("toolTitle", theme.bold("web_search ")) + theme.fg("accent", label), 0, 0);
-		},
-	});
-
-	pi.registerTool({
-		name: "code_search",
-		label: "Code Search",
-		description: "Search for code examples, documentation, and API references. Returns relevant code snippets and docs from GitHub, Stack Overflow, and official documentation. Use for any programming question — API usage, library examples, debugging help.",
-		promptSnippet: "Use for programming/API/library questions to retrieve concrete examples and docs before implementing or debugging code.",
-		parameters: Type.Object({
-			query: Type.String({ description: "Programming question, API, library, or debugging topic to search for" }),
-			maxTokens: Type.Optional(Type.Integer({ minimum: 1000, maximum: 50000, description: "Maximum tokens of code/documentation context to return (default: 5000)" })),
-		}),
-		execute: (...args) => executeHeavyTool(loadHeavy, "code_search", args),
-		renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "code_search", args),
-	});
-
-	pi.registerTool({
-		name: "fetch_content",
-		label: "Fetch Content",
-		description: "Fetch URL(s) and extract readable content as markdown. Supports YouTube video transcripts (with thumbnail), GitHub repository contents, and local video files (with frame thumbnail). Video frames can be extracted via timestamp/range or sampled across the entire video with frames alone. Falls back to Gemini for pages that block bots or fail Readability extraction. For YouTube and video files: ALWAYS pass the user's specific question via the prompt parameter — this directs the AI to focus on that aspect of the video, producing much better results than a generic extraction. Content is always stored and can be retrieved with get_search_content.",
-		promptSnippet: "Use to extract readable content from URL(s), YouTube, GitHub repos, or local videos. For video questions, pass the user's exact question in prompt.",
-		parameters: Type.Object({
-			url: Type.Optional(Type.String({ description: "Single URL to fetch" })),
-			urls: Type.Optional(Type.Array(Type.String(), { description: "Multiple URLs (parallel)" })),
-			forceClone: Type.Optional(Type.Boolean({ description: "Force cloning large GitHub repositories that exceed the size threshold" })),
-			prompt: Type.Optional(Type.String({ description: "Question or instruction for video analysis (YouTube and video files)." })),
-			timestamp: Type.Optional(Type.String({ description: "Extract video frame(s) at a timestamp or time range." })),
-			frames: Type.Optional(Type.Integer({ minimum: 1, maximum: 12, description: "Number of frames to extract." })),
-			model: Type.Optional(Type.String({ description: "Override the Gemini model for video/YouTube analysis." })),
-		}),
-		execute: (...args) => executeHeavyTool(loadHeavy, "fetch_content", args),
-		renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "fetch_content", args),
-	});
-
-	pi.registerTool({
-		name: "get_search_content",
-		label: "Get Search Content",
-		description: "Retrieve full content from a previous web_search or fetch_content call.",
-		promptSnippet: "Use after web_search/fetch_content when full stored content is needed via responseId plus query/url selectors.",
-		parameters: Type.Object({
-			responseId: Type.String({ description: "The responseId from web_search or fetch_content" }),
-			query: Type.Optional(Type.String({ description: "Get content for this query (web_search)" })),
-			queryIndex: Type.Optional(Type.Number({ description: "Get content for query at index" })),
-			url: Type.Optional(Type.String({ description: "Get content for this URL" })),
-			urlIndex: Type.Optional(Type.Number({ description: "Get content for URL at index" })),
-		}),
-		execute: (...args) => executeHeavyTool(loadHeavy, "get_search_content", args),
-		renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "get_search_content", args),
-	});
-
-	for (const [name, description] of [
-		["websearch", "Configure web search"],
-		["curator", "Configure web search curator"],
-		["google-account", "Show the active Google account for Gemini Web"],
-		["search", "Browse stored web search results"],
-	] as const) {
-		pi.registerCommand(name, {
-			description,
-			handler: (args, ctx) => runHeavyCommand(loadHeavy, name, args, ctx),
-		});
-	}
-}

package/dist/builtin/web-access/lifecycle-lease.ts

@@ -1,38 +0,0 @@
-export interface LifecycleLease<TShutdown> {
-	readonly id: number;
-	readonly priorCleanup: Promise<void>;
-	retired: boolean;
-	shutdown: TShutdown | null;
-	cleanupBarrier: Promise<void>;
-}
-
-export function createLifecycleLease<TShutdown>(
-	id: number,
-	priorCleanup: Promise<void> = Promise.resolve(),
-): LifecycleLease<TShutdown> {
-	return { id, priorCleanup, retired: false, shutdown: null, cleanupBarrier: priorCleanup };
-}
-
-export function retireLifecycleLease<TShutdown>(lease: LifecycleLease<TShutdown>, shutdown: TShutdown): void {
-	if (lease.retired) return;
-	lease.retired = true;
-	lease.shutdown = shutdown;
-}
-
-export function retainSettledLifecycleCleanup<TShutdown>(
-	lease: LifecycleLease<TShutdown>,
-	cleanup: readonly (Promise<unknown> | null)[],
-): Promise<void> {
-	const previousCleanup = lease.cleanupBarrier;
-	const pendingCleanup = cleanup.filter((task): task is Promise<unknown> => task !== null);
-	lease.cleanupBarrier = Promise.allSettled([previousCleanup, ...pendingCleanup]).then(() => undefined);
-	return lease.cleanupBarrier;
-}
-
-export function assertCurrentLifecycleLease<TShutdown>(
-	current: LifecycleLease<TShutdown>,
-	expected: LifecycleLease<TShutdown>,
-	message: string,
-): void {
-	if (current !== expected || expected.retired) throw new Error(message);
-}