@herbertgao/pi-extensions 2026.9.12 → 2026.9.14

package/node_modules/pi-web-access/firecrawl.ts

@@ -1,5 +1,4 @@
 import { existsSync, readFileSync } from "node:fs";
-import net from "node:net";
 import { activityMonitor } from "./activity.ts";
 import { normalizeDomain } from "./domain-filter-normalization.ts";
 import { redactCredential, resolveCredential } from "./credential-source.ts";
@@ -8,7 +7,7 @@ import type { SearchOptions, SearchResponse } from "./perplexity.ts";
 import { formatSearchResultsAsAnswer } from "./search-answer-formatting.ts";
 import { normalizeSearchResultCount } from "./search-result-count-normalization.ts";
 import { loadSsrfConfig, validateRemoteUrl, type Lookup } from "./ssrf-protection.ts";
-import { getWebSearchConfigPath } from "./utils.ts";
+import { getWebSearchConfigPath, isLoopbackHostname } from "./utils.ts";
 
 const CONFIG_PATH = getWebSearchConfigPath();
 const DEFAULT_API_VERSION = "v2";
@@ -188,13 +187,6 @@ function ssrfOptions(options?: FirecrawlExtractOptions | FirecrawlSearchOptions)
 	};
 }
 
-function isLoopbackApiUrl(url: URL): boolean {
-	const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
-	if (hostname === "localhost" || hostname === "::1") return true;
-	if (net.isIP(hostname) !== 4) return false;
-	return hostname.split(".")[0] === "127";
-}
-
 function firecrawlApiSsrfOptions(
 	options: FirecrawlExtractOptions | FirecrawlSearchOptions | undefined,
 	allowLoopback: boolean,
@@ -218,7 +210,7 @@ async function fetchFirecrawlApi(
 	init: { method: string; headers: Record<string, string>; body: string; signal: AbortSignal },
 	options: FirecrawlExtractOptions | FirecrawlSearchOptions | undefined,
 ): Promise<Response> {
-	const allowLoopback = isLoopbackApiUrl(new URL(url));
+	const allowLoopback = isLoopbackHostname(new URL(url).hostname);
 	let current = await validateRemoteUrl(url, firecrawlApiSsrfOptions(options, allowLoopback));
 	let headers = init.headers;
 	for (let redirects = 0; redirects <= DEFAULT_MAX_REDIRECTS; redirects++) {

package/node_modules/pi-web-access/gemini-search.ts

@@ -38,12 +38,13 @@ import { isSerpBaseAvailable, searchWithSerpBase } from "./serpbase.ts";
 import { isSerpApiAvailable, searchWithSerpApi } from "./serpapi.ts";
 import { isSerperAvailable, searchWithSerper } from "./serper.ts";
 import { isSerplyAvailable, searchWithSerply } from "./serply.ts";
+import { isBaizhiAvailable, searchWithBaizhi } from "./baizhi.ts";
 import { isValyuAvailable, searchWithValyu } from "./valyu.ts";
 import { isKimiSearchAvailable, searchWithKimi } from "./kimi-search.ts";
 import { isMistralAvailable, searchWithMistral } from "./mistral-search.ts";
 import { getWebSearchConfigPath } from "./utils.ts";
 
-export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "bocha", "xcrawl"] as const;
+export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "bocha", "xcrawl", "baizhi"] as const;
 export const SEARCH_PROVIDERS = ["auto", "all", ...RESOLVED_SEARCH_PROVIDERS] as const;
 
 export type ResolvedSearchProvider = typeof RESOLVED_SEARCH_PROVIDERS[number];
@@ -270,20 +271,11 @@ function isAbortError(err: unknown): boolean {
 	return errorMessage(err).toLowerCase().includes("abort");
 }
 
-function shouldTryOpenAIInAuto(options: SearchOptions): boolean {
-	if (options.recencyFilter) return false;
-	if (typeof options.numResults === "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5) {
-		return false;
-	}
-	return true;
-}
-
 function isOpenAICodexSelected(ctx?: ExtensionContext): boolean {
 	return ctx?.model?.provider === "openai-codex";
 }
 
 async function tryOpenAIInAuto(query: string, options: FullSearchOptions, fallbackErrors: string[]): Promise<AttributedSearchResponse | null> {
-	if (!shouldTryOpenAIInAuto(options)) return null;
 	try {
 		if (await isOpenAISearchAvailable(options.extensionContext)) {
 			const result = await searchWithOpenAI(query, options, options.extensionContext);
@@ -411,6 +403,7 @@ async function searchWithResolvedProvider(
 	if (provider === "serpapi") return { ...(await searchWithSerpApi(query, options)), provider };
 	if (provider === "serper") return { ...(await searchWithSerper(query, options)), provider };
 	if (provider === "serply") return { ...(await searchWithSerply(query, options)), provider };
+	if (provider === "baizhi") return { ...(await searchWithBaizhi(query, options)), provider };
 	if (provider === "valyu") return { ...(await searchWithValyu(query, options)), provider };
 	if (provider === "xcrawl") return { ...(await searchWithXCrawl(query, options)), provider };
 	if (provider === "perplexity") return { ...(await searchWithPerplexity(query, options)), provider };
@@ -461,6 +454,7 @@ async function isResolvedProviderAvailable(provider: ResolvedSearchProvider, opt
 	if (provider === "serpapi") return isSerpApiAvailable();
 	if (provider === "serper") return isSerperAvailable();
 	if (provider === "serply") return isSerplyAvailable();
+	if (provider === "baizhi") return isBaizhiAvailable();
 	if (provider === "valyu") return isValyuAvailable();
 	if (provider === "xcrawl") return isXcrawlAvailable();
 	if (provider === "perplexity") return isPerplexityAvailable();
@@ -502,6 +496,7 @@ export function providerLabel(provider: ResolvedSearchProvider): string {
 	if (provider === "serpapi") return "SerpApi";
 	if (provider === "serper") return "Serper";
 	if (provider === "serply") return "Serply";
+	if (provider === "baizhi") return "Baizhi";
 	if (provider === "valyu") return "Valyu";
 	return provider.charAt(0).toUpperCase() + provider.slice(1);
 }

package/node_modules/pi-web-access/index.ts

@@ -72,6 +72,7 @@ import { isSerpBaseAvailable } from "./serpbase.ts";
 import { isSerpApiAvailable } from "./serpapi.ts";
 import { isSerperAvailable } from "./serper.ts";
 import { isSerplyAvailable } from "./serply.ts";
+import { isBaizhiAvailable } from "./baizhi.ts";
 import { isValyuAvailable } from "./valyu.ts";
 import { isXcrawlAvailable } from "./xcrawl.ts";
 import { buildSearchErrorPlan, type SearchErrorDetails, type SearchErrorPlan } from "./render-search-error.ts";
@@ -85,6 +86,7 @@ import {
 	type RecencyFilter,
 	type ResearchArtifact,
 } from "./source-check.ts";
+import { registerWebToolActivation, type WebActivationTool } from "./tool-activation.ts";
 
 // Match pi-ai's StringEnum without loading its compat barrel during registration.
 function StringEnum<T extends string[]>(values: T, options?: { description?: string; default?: T[number] }) {
@@ -155,6 +157,7 @@ interface WebSearchConfig {
 	serpapiApiKey?: unknown;
 	serperApiKey?: unknown;
 	serplyApiKey?: unknown;
+	baizhiApiKey?: unknown;
 	tinyfishApiKey?: unknown;
 	valyuApiKey?: unknown;
 	xaiApiKey?: unknown;
@@ -336,6 +339,7 @@ function resolveToolNames(config: WebSearchConfig): ToolNames {
 	const seen = new Map<string, keyof ToolNames>();
 	for (const key of registeredKeys) {
 		const name = names[key];
+		if (name === "web_enable") throw new Error(`toolNames.${key} in ${WEB_SEARCH_CONFIG_PATH} uses reserved loader name web_enable`);
 		const previous = seen.get(name);
 		if (previous) throw new Error(`toolNames.${key} duplicates toolNames.${previous} in ${WEB_SEARCH_CONFIG_PATH}`);
 		seen.set(name, key);
@@ -488,6 +492,7 @@ async function getProviderAvailability(ctx: ExtensionContext): Promise<ProviderA
 		serpapi: allowedProviders.has("serpapi") && isSerpApiAvailable(),
 		serper: allowedProviders.has("serper") && isSerperAvailable(),
 		serply: allowedProviders.has("serply") && isSerplyAvailable(),
+		baizhi: allowedProviders.has("baizhi") && isBaizhiAvailable(),
 		valyu: allowedProviders.has("valyu") && isValyuAvailable(),
 	};
 	return {
@@ -621,11 +626,12 @@ interface PendingCurate {
 
 
 const DEFAULT_MAX_INLINE_CONTENT_CHARS = 30_000;
+const MIN_INLINE_CONTENT_CHARS = 1_000;
 const MAX_INLINE_CONTENT_CHARS = 200_000;
 
 function getMaxInlineContentChars(config = loadConfig()): number {
 	const value = config.maxInlineContentChars;
-	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < MIN_INLINE_CONTENT_CHARS) {
 		return DEFAULT_MAX_INLINE_CONTENT_CHARS;
 	}
 	return Math.min(value, MAX_INLINE_CONTENT_CHARS);
@@ -772,15 +778,40 @@ function hasFullInlineCoverage(urls: string[], inlineContent: ExtractedContent[]
 
 function formatFullResults(queryData: QueryResultData): string {
 	let output = `## Results for: "${queryData.query}"\n\n`;
+	const providers = queryData.providers ?? (queryData.provider ? [queryData.provider] : []);
+	if (providers.length > 0) output += `**Provider${providers.length === 1 ? "" : "s"}:** ${providers.join(", ")}\n\n`;
 	if (queryData.answer) {
 		output += `${queryData.answer}\n\n---\n\n`;
 	}
 	for (const r of queryData.results) {
-		output += `### ${r.title}\n${r.url}\n\n`;
+		output += `### ${r.title}\n${r.url}${r.snippet ? `\n\n${r.snippet}` : ""}\n\n`;
 	}
 	return output;
 }
 
+function boundSearchPresentation(
+	text: string,
+	guidance: string,
+	truncationGuidance: string,
+	maxChars: number,
+): { text: string; truncated: boolean; originalChars: number; returnedChars: number; omittedChars: number } {
+	const fullText = `${text}${guidance}`;
+	if (fullText.length <= maxChars) {
+		return { text: fullText, truncated: false, originalChars: text.length, returnedChars: text.length, omittedChars: 0 };
+	}
+	const marker = `\n\n---\n[Output truncated.]${truncationGuidance}`;
+	// Reserve marker space so the complete model-visible response never exceeds the configured ceiling.
+	const prefixLength = maxChars - marker.length;
+	const bounded = `${text.slice(0, prefixLength)}${marker}`;
+	return {
+		text: bounded,
+		truncated: true,
+		originalChars: text.length,
+		returnedChars: prefixLength,
+		omittedChars: text.length - prefixLength,
+	};
+}
+
 function abortPendingFetches(): void {
 	for (const controller of pendingFetches.values()) {
 		controller.abort();
@@ -1365,6 +1396,7 @@ export default function (pi: ExtensionAPI) {
 		const tr = opts.results.reduce((sum, r) => sum + r.results.length, 0);
 
 		const hasApprovedSummary = typeof opts.approvedSummary === "string" && opts.approvedSummary.trim().length > 0;
+		const maxInlineContentChars = getMaxInlineContentChars(initConfig);
 		let output = "";
 		if (hasApprovedSummary) {
 			output = opts.approvedSummary!.trim();
@@ -1372,6 +1404,13 @@ export default function (pi: ExtensionAPI) {
 			if (opts.curated) {
 				output += "[These results were manually curated by the user in the browser. Use them as-is — do not re-search or discard.]\n\n";
 			}
+			const providerNames = opts.results.map(result => {
+				const providers = result.providers ?? (result.provider ? [result.provider] : []);
+				return providers.join(", ") || "unknown";
+			});
+			output += opts.results.length === 1
+				? `**Provider:** ${providerNames[0]}\n\n`
+				: `**Providers used:** ${providerNames.map((name, index) => `Query ${index + 1}: ${name}`).join("; ")}\n\n`;
 			const duplicateQueries = opts.curated ? duplicateQuerySet(opts.results) : new Set<string>();
 			for (const { query, answer, results, error, provider } of opts.results) {
 				if (opts.queryList.length > 1) {
@@ -1395,26 +1434,37 @@ export default function (pi: ExtensionAPI) {
 				urls: opts.inlineContent,
 			} satisfies StoredSearchData & { type: "fetch"; urls: ExtractedContent[] };
 			pi.appendEntry("web-search-results", storeFetchedContentResult(fetchId, data));
-			if (!hasApprovedSummary) {
-				output += `---\nFull content for ${opts.inlineContent.length} sources available [${fetchId}].`;
-			}
 		} else if (opts.includeContent) {
 			fetchId = startBackgroundFetch(opts.urls, opts.proxy);
-			if (fetchId && !hasApprovedSummary) {
-				output += `---\nContent fetching in background [${fetchId}]. Will notify when ready.`;
-			}
 		}
 
 		const searchId = storeAndPublishSearch(opts.results);
 		const isBackgroundFetch = fetchId !== null && !hasInlineReady;
-		// The model only sees `content`, not `details`: surface the id it needs to
-		// call get_search_content, the same way fetch_content does.
-		if (getSearchContentEnabled && !hasApprovedSummary) {
-			output += `\n---\nResults stored as responseId "${searchId}". Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0 }) to retrieve them.`;
-		}
+		const unboundedPresentation = output.trim();
+		const buildGuidance = (forTruncation: boolean): string => {
+			let value = "";
+			if (hasInlineReady && opts.inlineContent && fetchId) {
+				value += `\n---\nFull content for ${opts.inlineContent.length} sources is ready as responseId "${fetchId}". `;
+				value += getSearchContentEnabled
+					? `Use ${toolNames.getSearchContent}({ responseId: "${fetchId}", urlIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page.`
+					: forTruncation ? `Enable ${toolNames.getSearchContent} to retrieve the full stored content.` : "";
+			} else if (isBackgroundFetch && fetchId) {
+				value += `\n---\nContent fetching in background as responseId "${fetchId}". Will notify when ready.`;
+			}
+			if (getSearchContentEnabled || forTruncation) {
+				value += `\n---\nFull search results are stored as responseId "${searchId}". `;
+				value += getSearchContentEnabled
+					? `Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page${opts.results.length > 1 ? `; repeat with queryIndex 1 through ${opts.results.length - 1}` : ""}.`
+					: `Enable ${toolNames.getSearchContent} to retrieve the full stored results.`;
+			}
+			return value;
+		};
+		const presentation = hasApprovedSummary
+			? { text: unboundedPresentation, truncated: false, originalChars: unboundedPresentation.length, returnedChars: unboundedPresentation.length, omittedChars: 0 }
+			: boundSearchPresentation(unboundedPresentation, buildGuidance(false), buildGuidance(true), maxInlineContentChars);
 
 		return {
-			content: [{ type: "text", text: output.trim() }],
+			content: [{ type: "text", text: presentation.text }],
 			details: {
 				queries: opts.queryList,
 				queryCount: opts.queryList.length,
@@ -1424,6 +1474,14 @@ export default function (pi: ExtensionAPI) {
 				fetchId,
 				fetchUrls: isBackgroundFetch ? opts.urls : undefined,
 				searchId,
+				queryProviders: opts.results.map(result => ({
+					query: result.query,
+					providers: result.providers ?? (result.provider ? [result.provider] : []),
+				})),
+				truncated: presentation.truncated,
+				originalChars: presentation.originalChars,
+				returnedChars: presentation.returnedChars,
+				omittedChars: presentation.omittedChars,
 				...(opts.curated ? {
 					curated: true,
 					curatedFrom: opts.curatedFrom,
@@ -1775,7 +1833,7 @@ export default function (pi: ExtensionAPI) {
 		name: toolNames.webSearch,
 		label: "Web Search",
 		description:
-			`Search the web with ${allowedSearchProviders.map(providerLabel).join(", ")}. Provider arrays run simultaneously; ${allPolicyDescription}. By default, returns source-linked search results or provider answers. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query. When includeContent is true, full page content is fetched in the background. Searches return without the interactive browser curator by default; set workflow to "summary-review" to open the curator with an auto-generated summary draft or "auto-summary" to generate a summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it.`,
+			`Search the web with ${allowedSearchProviders.map(providerLabel).join(", ")}. Provider arrays run simultaneously; ${allPolicyDescription}. The default workflow is none: it returns bounded source-linked search results or provider answers without a curator or generated summary, identifies the providers used, and stores full results for retrieval by responseId. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query. When includeContent is true, full page content is fetched in the background. Set workflow to "summary-review" to open the curator with an auto-generated summary draft or "auto-summary" to generate a summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it.`,
 		promptSnippet:
 			"Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage. Omit provider unless explicitly overriding the configured default.",
 		parameters: Type.Object({
@@ -2030,7 +2088,7 @@ export default function (pi: ExtensionAPI) {
 				});
 
 				try {
-					const { answer, results, inlineContent, provider } = await search(query, {
+					const { answer, results, inlineContent, provider, providerResponses } = await search(query, {
 						provider: resolvedProvider,
 						numResults: params.numResults,
 						recencyFilter,
@@ -2040,7 +2098,8 @@ export default function (pi: ExtensionAPI) {
 						extensionContext: ctx,
 					});
 
-					return { result: { query, answer, results, error: null, provider } satisfies QueryResultData, inlineContent };
+					const providers = providerResponses?.map(response => response.provider) ?? [provider];
+					return { result: { query, answer, results, error: null, provider, providers } satisfies QueryResultData, inlineContent };
 				} catch (err) {
 					if (signal?.aborted || isAbortError(err)) throw err;
 					const message = err instanceof Error ? err.message : String(err);
@@ -2830,7 +2889,7 @@ export default function (pi: ExtensionAPI) {
 		pi.registerTool({
 		name: toolNames.getSearchContent,
 		label: "Get Search Content",
-		description: `Retrieve bounded content slices or find matching passages in a previous ${storedContentSources} call.`,
+		description: `Retrieve bounded pages of full stored search results or fetched content, or find matching passages, from a previous ${storedContentSources} call.`,
 		promptSnippet:
 			`Use after ${storedContentSources} to retrieve stored content via responseId. Use findText to locate passages without paging through the full content.`,
 		parameters: Type.Object({
@@ -2839,8 +2898,8 @@ export default function (pi: ExtensionAPI) {
 			queryIndex: Type.Optional(Type.Integer({ minimum: 0, description: "Get content for query at index" })),
 			url: Type.Optional(Type.String({ description: "Get content for this URL" })),
 			urlIndex: Type.Optional(Type.Integer({ minimum: 0, description: "Get content for URL at index" })),
-			offset: Type.Optional(Type.Integer({ minimum: 0, description: "Character offset for fetched URL content slices (default 0). Ignored when findText is supplied." })),
-			limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxInlineContentChars, description: "Maximum characters to return for fetched URL content slices (default and max are set by maxInlineContentChars). Ignored when findText is supplied." })),
+			offset: Type.Optional(Type.Integer({ minimum: 0, description: "Character offset in stored search or fetched URL content (default 0). Ignored when findText is supplied." })),
+			limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxInlineContentChars, description: "Requested maximum stored-content characters (default and max use maxInlineContentChars). Search-page continuation guidance shares the global output cap and may reduce returnedChars. Ignored when findText is supplied." })),
 			findText: Type.Optional(Type.Union([
 				Type.String({ minLength: 1, maxLength: 500 }),
 				Type.Array(Type.String({ minLength: 1, maxLength: 500 }), { minItems: 1, maxItems: 10 }),
@@ -2961,7 +3020,7 @@ export default function (pi: ExtensionAPI) {
 						const { text, ...findDetails } = found;
 						return {
 							content: [{ type: "text", text }],
-							details: { query: queryData.query, resultCount: queryData.results.length, findMode: params.findMode ?? "case-insensitive", ...findDetails },
+							details: { responseId: params.responseId, query: queryData.query, resultCount: queryData.results.length, contentLength: fullResults.length, findMode: params.findMode ?? "case-insensitive", ...findDetails },
 						};
 					} catch (err) {
 						const error = err instanceof Error ? err.message : String(err);
@@ -2972,9 +3031,53 @@ export default function (pi: ExtensionAPI) {
 					}
 				}
 
+				const offset = params.offset ?? 0;
+				const limit = params.limit ?? maxInlineContentChars;
+				if (!Number.isInteger(offset) || offset < 0) {
+					return {
+						content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for query ${formatInputValue(queryData.query)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
+						details: { error: "Invalid offset", offset },
+					};
+				}
+				if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
+					return {
+						content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for query ${formatInputValue(queryData.query)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
+						details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars },
+					};
+				}
+				if (offset > fullResults.length) {
+					return {
+						content: [{ type: "text", text: `Offset ${offset} is out of range for query ${formatInputValue(queryData.query)} in responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${fullResults.length}. Use an offset within that range.` }],
+						details: { error: "Offset out of range", offset, contentLength: fullResults.length },
+					};
+				}
+				const queryIndex = data.queries.indexOf(queryData);
+				let returnedChars = Math.min(limit, fullResults.length - offset);
+				let endOffset = offset + returnedChars;
+				let continuation = "";
+				while (endOffset < fullResults.length) {
+					continuation = `\n\n---\nShowing chars ${offset}-${endOffset} of ${fullResults.length}. Use ${toolNames.getSearchContent}({ responseId: "${params.responseId}", queryIndex: ${queryIndex}, offset: ${endOffset}, limit: ${limit} }) for the next slice.`;
+					const overflow = returnedChars + continuation.length - maxInlineContentChars;
+					if (overflow <= 0) break;
+					returnedChars -= overflow;
+					endOffset = offset + returnedChars;
+				}
+				const resultSlice = fullResults.slice(offset, endOffset);
+				const hasMore = endOffset < fullResults.length;
+				const text = `${resultSlice}${hasMore ? continuation : ""}`;
 				return {
-					content: [{ type: "text", text: fullResults }],
-					details: { query: queryData.query, resultCount: queryData.results.length },
+					content: [{ type: "text", text }],
+					details: {
+						responseId: params.responseId,
+						query: queryData.query,
+						resultCount: queryData.results.length,
+						contentLength: fullResults.length,
+						offset,
+						limit,
+						returnedChars,
+						nextOffset: hasMore ? endOffset : null,
+						truncated: hasMore,
+					},
 				};
 			}
 
@@ -3161,6 +3264,14 @@ export default function (pi: ExtensionAPI) {
 	});
 	}
 
+	const activationTools: WebActivationTool[] = [
+		...(webSearchEnabled ? [{ name: toolNames.webSearch, capability: "search" as const }] : []),
+		...(sourceCheckEnabled ? [{ name: toolNames.sourceCheck, capability: "source-check" as const }] : []),
+		...(fetchContentEnabled ? [{ name: toolNames.fetchContent, capability: "fetch" as const }] : []),
+		...(getSearchContentEnabled ? [{ name: toolNames.getSearchContent, capability: "stored-content" as const }] : []),
+	];
+	registerWebToolActivation(pi, activationTools);
+
 	if (isCommandEnabled(initConfig, "websearch")) pi.registerCommand("websearch", {
 		description: "Open web search curator",
 		handler: async (args, ctx) => {

package/node_modules/pi-web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-web-access",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "Web search, URL fetching, GitHub repo cloning, PDF extraction, YouTube video understanding, and local video analysis for Pi coding agent. Supports OpenAI, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Crawl4AI, Jina, SERPdive, Kagi, Ollama, AnySearch, Bright Data SERP, SerpBase, SerpApi, Serply, SearXNG, Exa, Perplexity, Gemini, Kimi, and Mistral.",
   "type": "module",
   "scripts": {
@@ -45,11 +45,15 @@
     "pi-web-fetch-demo.mp4"
   ],
   "devDependencies": {
+    "@earendil-works/pi-ai": "0.86.1",
+    "@earendil-works/pi-coding-agent": "0.86.1",
+    "@earendil-works/pi-tui": "0.86.1",
     "@types/turndown": "^5.0.6",
     "esbuild": "^0.28.1",
     "typescript": "^7.0.2"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "1.27.1",
     "@mozilla/readability": "^0.6.0",
     "defuddle": "0.19.3",
     "linkedom": "^0.16.0",

package/node_modules/pi-web-access/storage.ts

@@ -36,6 +36,7 @@ export interface QueryResultData {
 	results: SearchResult[];
 	error: string | null;
 	provider?: string;
+	providers?: string[];
 }
 
 interface FetchCacheRef {

package/node_modules/pi-web-access/tool-activation.ts

@@ -0,0 +1,134 @@
+import { buildSessionContext, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Type } from "typebox";
+
+export type WebCapability = "search" | "source-check" | "fetch" | "stored-content";
+
+export interface WebActivationTool {
+	name: string;
+	capability: WebCapability;
+}
+
+const LOADER_NAME = "web_enable";
+const CAPABILITY_LABELS: Record<WebCapability, string> = {
+	search: "web search",
+	"source-check": "source checking",
+	fetch: "content fetching",
+	"stored-content": "stored-result retrieval",
+};
+
+function supportsDynamicTools(pi: ExtensionAPI): boolean {
+	if (typeof pi.getAllTools !== "function" || typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return false;
+	try {
+		const packagePath = join(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "..", "package.json");
+		const [major, minor, patch] = JSON.parse(readFileSync(packagePath, "utf8")).version.split(".").map(Number);
+		return major > 0 || minor > 86 || minor === 86 && patch >= 1;
+	} catch {
+		return false;
+	}
+}
+
+function hasToolDeclarations(messages: unknown[]): boolean {
+	return messages.some(message => message && typeof message === "object" && (
+		"toolsAdded" in message || "toolsRemoved" in message
+	));
+}
+
+async function currentTranscriptToolNames(messages: unknown[]): Promise<string[]> {
+	const moduleName = "@earendil-works/pi-ai/utils/transcript";
+	const { getCurrentTools } = await import(moduleName);
+	return getCurrentTools(messages).map((tool: { name: string }) => tool.name);
+}
+
+export function registerWebToolActivation(pi: ExtensionAPI, tools: ReadonlyArray<WebActivationTool>): void {
+	if (tools.length === 0) return;
+	if (!supportsDynamicTools(pi)) {
+		console.warn("[pi-web-access] Dynamic tool activation requires Pi 0.86.1 or newer; web tools remain eagerly available.");
+		return;
+	}
+	const names = tools.map(tool => tool.name);
+	const capabilities = tools.map(tool => CAPABILITY_LABELS[tool.capability]).join(", ");
+
+	const parameters = Type.Object({}, { additionalProperties: false });
+	pi.registerTool<typeof parameters, Record<string, unknown>>({
+		name: LOADER_NAME,
+		label: "Enable Web Access",
+		description: "Enable configured pi-web-access tools for web research and content retrieval. Does not search or fetch. Enabled tools are available on the next model request; disabled capabilities remain unavailable.",
+		promptSnippet: `pi-web-access is configured for ${capabilities}. Call web_enable to activate these tools; use them on the next model request.`,
+		parameters,
+		async execute() {
+			const registered = new Set(pi.getAllTools().map(tool => tool.name));
+			const unavailable = names.filter(name => !registered.has(name));
+			if (unavailable.length > 0) {
+				return {
+					isError: true,
+					content: [{ type: "text" as const, text: `Cannot enable unavailable tools: ${unavailable.join(", ")}.` }],
+					details: { unavailable },
+				};
+			}
+
+			try {
+				pi.setActiveTools([...new Set([...pi.getActiveTools(), ...names])]);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					isError: true,
+					content: [{ type: "text" as const, text: `Activation failed: ${message}.` }],
+					details: { error: message },
+				};
+			}
+
+			const active = new Set(pi.getActiveTools());
+			const missing = names.filter(name => !active.has(name));
+			return missing.length > 0
+				? {
+					isError: true,
+					content: [{ type: "text" as const, text: `Tools still inactive after activation: ${missing.join(", ")}.` }],
+					details: { missing },
+				}
+				: {
+					content: [{ type: "text" as const, text: `Enabled: ${names.join(", ")}.` }],
+					details: { enabled: names },
+				};
+		},
+	});
+
+	function loaderAvailable(): boolean {
+		return pi.getAllTools().some(tool => tool.name === LOADER_NAME);
+	}
+
+	let warned = false;
+	async function selectFromSession(ctx: ExtensionContext): Promise<void> {
+		if (!loaderAvailable()) return;
+		try {
+			const messages = buildSessionContext(ctx.sessionManager.getBranch()).messages;
+			const recorded = hasToolDeclarations(messages)
+				? new Set(await currentTranscriptToolNames(messages))
+				: messages.length > 0
+					? new Set(names)
+					: new Set<string>();
+			const heavy = new Set(names);
+			const active = pi.getActiveTools().filter(name => !heavy.has(name));
+			for (const name of names) if (recorded.has(name)) active.push(name);
+			pi.setActiveTools([...new Set([...active, LOADER_NAME])]);
+		} catch (error) {
+			if (!warned) {
+				warned = true;
+				console.warn(`[pi-web-access] Keeping web tools eagerly available because activation setup failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+
+	pi.on("session_start", (_event, ctx) => selectFromSession(ctx));
+	pi.on("session_tree", (_event, ctx) => selectFromSession(ctx));
+	pi.on("before_agent_start", () => {
+		if (!loaderAvailable() || pi.getActiveTools().includes(LOADER_NAME)) return;
+		try {
+			pi.setActiveTools([...pi.getActiveTools(), LOADER_NAME]);
+		} catch {
+			// Best effort: preserve the current selection if Pi rejects the update.
+		}
+	});
+}

package/node_modules/pi-web-access/utils.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { isIP } from "node:net";
 import { homedir, hostname, tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -43,6 +44,13 @@ interface ApiBaseUrlOptions {
 	environmentValue: string | undefined;
 }
 
+export function isLoopbackHostname(hostnameValue: string): boolean {
+	const normalized = hostnameValue.replace(/^\[|\]$/g, "").replace(/\.$/, "").toLowerCase();
+	return normalized === "localhost"
+		|| normalized === "::1"
+		|| (isIP(normalized) === 4 && normalized.split(".", 1)[0] === "127");
+}
+
 export function resolveApiBaseUrl(options: ApiBaseUrlOptions): string {
 	const fromEnvironment = options.environmentValue !== undefined;
 	const value = fromEnvironment ? options.environmentValue : options.configuredValue;
@@ -61,7 +69,7 @@ export function resolveApiBaseUrl(options: ApiBaseUrlOptions): string {
 	} catch {
 		throw new Error(`${source} must be an absolute HTTP(S) URL`);
 	}
-	if (url.protocol !== "https:") {
+	if (url.protocol !== "https:" && (url.protocol !== "http:" || !isLoopbackHostname(url.hostname))) {
 		throw new Error(`${source} must be an absolute HTTPS URL`);
 	}
 	if (url.username || url.password) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-extensions",
-  "version": "2026.9.12",
+  "version": "2026.9.14",
   "description": "Aggregate installer for HerbertGao-maintained Pi extensions.",
   "keywords": [
     "extensions",
@@ -38,14 +38,14 @@
     "@ast-grep/napi": "^0.45.0",
     "@bufbuild/protobuf": "^2.14.0",
     "@dietrichgebert/ponytail": "4.10.0",
-    "@earendil-works/pi-ai": "^0.85.1",
-    "@earendil-works/pi-coding-agent": "^0.85.1",
-    "@earendil-works/pi-tui": "^0.85.1",
-    "@herbertgao/pi-bark": "0.1.2",
-    "@herbertgao/pi-cc-extensions": "0.9.4",
-    "@herbertgao/pi-subagents": "0.18.1",
-    "@herbertgao/resume-from": "0.2.2",
-    "@herbertgao/sol-pi": "0.3.1",
+    "@earendil-works/pi-ai": "^0.87.1",
+    "@earendil-works/pi-coding-agent": "^0.87.1",
+    "@earendil-works/pi-tui": "^0.87.1",
+    "@herbertgao/pi-bark": "0.1.3",
+    "@herbertgao/pi-cc-extensions": "0.9.5",
+    "@herbertgao/pi-subagents": "0.18.3",
+    "@herbertgao/resume-from": "0.2.3",
+    "@herbertgao/sol-pi": "0.3.2",
     "@juicesharp/rpiv-ask-user-question": "2.11.0",
     "@juicesharp/rpiv-config": "^2.11.0",
     "@modelcontextprotocol/client": "2.0.0",
@@ -55,7 +55,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
     "@napi-rs/keyring": "^1.3.0",
-    "@narumitw/pi-btw": "0.60.3",
+    "@narumitw/pi-btw": "0.61.0",
     "@narumitw/pi-caffeinate": "0.49.8",
     "@narumitw/pi-tui-kit": "^0.64.0",
     "@noble/ed25519": "^3.1.0",
@@ -90,10 +90,10 @@
     "pi-footer": "0.5.1",
     "pi-jev-auto-mode": "0.4.1",
     "pi-lens": "4.2.1",
-    "pi-mcp-adapter": "2.36.0",
-    "pi-multi-account": "1.22.0",
-    "pi-typesafe": "0.6.1",
-    "pi-web-access": "0.30.0",
+    "pi-mcp-adapter": "2.37.0",
+    "pi-multi-account": "1.23.1",
+    "pi-typesafe": "0.7.4",
+    "pi-web-access": "0.31.0",
     "pidusage": "^4.0.1",
     "promise.try": "^2.0.1",
     "proper-lockfile": "4.1.2",