@herbertgao/pi-extensions 2026.9.13 → 2026.9.14

package/node_modules/pi-web-access/dist/index.js

@@ -18,6 +18,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";
 function getWebSearchConfigDir() {
@@ -41,6 +42,10 @@ function getWebSearchConfigDir() {
 function getWebSearchConfigPath() {
   return join(getWebSearchConfigDir(), "web-search.json");
 }
+function isLoopbackHostname(hostnameValue) {
+  const normalized = hostnameValue.replace(/^\[|\]$/g, "").replace(/\.$/, "").toLowerCase();
+  return normalized === "localhost" || normalized === "::1" || isIP(normalized) === 4 && normalized.split(".", 1)[0] === "127";
+}
 function resolveApiBaseUrl(options) {
   const fromEnvironment = options.environmentValue !== void 0;
   const value = fromEnvironment ? options.environmentValue : options.configuredValue;
@@ -55,7 +60,7 @@ function resolveApiBaseUrl(options) {
   } 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) {
@@ -5265,7 +5270,6 @@ var init_ssrf_protection = __esm({
 
 // firecrawl.ts
 import { existsSync as existsSync21, readFileSync as readFileSync22 } from "node:fs";
-import net2 from "node:net";
 function loadConfig14() {
   if (cachedConfig15) return cachedConfig15;
   if (!existsSync21(CONFIG_PATH16)) {
@@ -5370,12 +5374,6 @@ function ssrfOptions(options) {
     ...options?.lookup ? { lookup: options.lookup } : {}
   };
 }
-function isLoopbackApiUrl(url) {
-  const hostname2 = url.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
-  if (hostname2 === "localhost" || hostname2 === "::1") return true;
-  if (net2.isIP(hostname2) !== 4) return false;
-  return hostname2.split(".")[0] === "127";
-}
 function firecrawlApiSsrfOptions(options, allowLoopback) {
   return { ...ssrfOptions(options), allowLoopback };
 }
@@ -5390,7 +5388,7 @@ function withoutSensitiveHeaders(headers) {
   return next;
 }
 async function fetchFirecrawlApi(url, init, options) {
-  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_REDIRECTS2; redirects++) {
@@ -6330,20 +6328,20 @@ var init_rsc_extract = __esm({
 });
 
 // datalab-pdf-extract.ts
-import { existsSync as existsSync39, readFileSync as readFileSync41 } from "node:fs";
+import { existsSync as existsSync40, readFileSync as readFileSync43 } from "node:fs";
 function loadConfig31() {
   if (cachedConfig32) return cachedConfig32;
-  if (!existsSync39(CONFIG_PATH34)) {
+  if (!existsSync40(CONFIG_PATH35)) {
     cachedConfig32 = {};
     return cachedConfig32;
   }
-  const rawText = readFileSync41(CONFIG_PATH34, "utf-8");
+  const rawText = readFileSync43(CONFIG_PATH35, "utf-8");
   try {
     cachedConfig32 = JSON.parse(rawText);
     return cachedConfig32;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH34}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH35}: ${message}`);
   }
 }
 function normalizeString(value) {
@@ -6690,7 +6688,7 @@ async function readResponseText(response) {
 function datalabFilename(title) {
   return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "document";
 }
-var DEFAULT_API_HOST2, API_PREFIX, DEFAULT_TIMEOUT_MS, DEFAULT_POLL_INTERVAL_MS, MAX_RESPONSE_BYTES, MAX_ERROR_BODY_BYTES, CLEANUP_TIMEOUT_MS, CONFIG_PATH34, DATALAB_MODE_VALUES, DATALAB_LOCATION_VALUES, DEFAULT_DATALAB_MODE, DEFAULT_PROCESSING_LOCATION, DEFAULT_DATALAB_TIMEOUT_MS, cachedConfig32;
+var DEFAULT_API_HOST2, API_PREFIX, DEFAULT_TIMEOUT_MS, DEFAULT_POLL_INTERVAL_MS, MAX_RESPONSE_BYTES, MAX_ERROR_BODY_BYTES, CLEANUP_TIMEOUT_MS, CONFIG_PATH35, DATALAB_MODE_VALUES, DATALAB_LOCATION_VALUES, DEFAULT_DATALAB_MODE, DEFAULT_PROCESSING_LOCATION, DEFAULT_DATALAB_TIMEOUT_MS, cachedConfig32;
 var init_datalab_pdf_extract = __esm({
   "datalab-pdf-extract.ts"() {
     init_credential_source();
@@ -6702,7 +6700,7 @@ var init_datalab_pdf_extract = __esm({
     MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
     MAX_ERROR_BODY_BYTES = 300;
     CLEANUP_TIMEOUT_MS = 5e3;
-    CONFIG_PATH34 = getWebSearchConfigPath();
+    CONFIG_PATH35 = getWebSearchConfigPath();
     DATALAB_MODE_VALUES = /* @__PURE__ */ new Set([
       "fast",
       "balanced",
@@ -6805,12 +6803,12 @@ var init_gemini_pdf_extract = __esm({
 });
 
 // pdf-extract.ts
-import { existsSync as existsSync40, readFileSync as readFileSync42 } from "node:fs";
+import { existsSync as existsSync41, readFileSync as readFileSync44 } from "node:fs";
 import { writeFile as writeFile2, mkdir } from "node:fs/promises";
-import { join as join7, basename as basename3 } from "node:path";
+import { join as join8, basename as basename3 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 function loadPDFConfig() {
-  if (!existsSync40(CONFIG_PATH35)) {
+  if (!existsSync41(CONFIG_PATH36)) {
     return {
       enabled: true,
       maxSizeMB: DEFAULT_PDF_MAX_SIZE_MB,
@@ -6820,13 +6818,13 @@ function loadPDFConfig() {
       datalabTimeoutMs: DEFAULT_DATALAB_TIMEOUT_MS
     };
   }
-  const rawText = readFileSync42(CONFIG_PATH35, "utf-8");
+  const rawText = readFileSync44(CONFIG_PATH36, "utf-8");
   let raw;
   try {
     raw = JSON.parse(rawText);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH35}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH36}: ${message}`);
   }
   const root = raw && typeof raw === "object" ? raw : {};
   const pdf = root.pdf && typeof root.pdf === "object" ? root.pdf : {};
@@ -6984,7 +6982,7 @@ async function writeMarkdownResult(options) {
   }
   const content = lines.join("\n");
   const outputFilename = options.filename || sanitizeFilename(options.title) + ".md";
-  const outputPath = join7(options.outputDir, outputFilename);
+  const outputPath = join8(options.outputDir, outputFilename);
   await mkdir(options.outputDir, { recursive: true });
   await writeFile2(outputPath, content, "utf-8");
   return {
@@ -7035,7 +7033,7 @@ function isPDF(url, contentType) {
     return false;
   }
 }
-var PDF_PROVIDER_VALUES, DEFAULT_PDF_MAX_SIZE_MB, MAX_PDF_MAX_SIZE_MB, MAX_DATALAB_TIMEOUT_MS, DEFAULT_MAX_PAGES, DEFAULT_OUTPUT_DIR, CONFIG_PATH35, PAGE_MARKER_PATTERN2;
+var PDF_PROVIDER_VALUES, DEFAULT_PDF_MAX_SIZE_MB, MAX_PDF_MAX_SIZE_MB, MAX_DATALAB_TIMEOUT_MS, DEFAULT_MAX_PAGES, DEFAULT_OUTPUT_DIR, CONFIG_PATH36, PAGE_MARKER_PATTERN2;
 var init_pdf_extract = __esm({
   "pdf-extract.ts"() {
     init_credential_source();
@@ -7053,33 +7051,33 @@ var init_pdf_extract = __esm({
     MAX_PDF_MAX_SIZE_MB = 50;
     MAX_DATALAB_TIMEOUT_MS = 3e5;
     DEFAULT_MAX_PAGES = 100;
-    DEFAULT_OUTPUT_DIR = join7(tmpdir3(), "pi-web-pdf");
-    CONFIG_PATH35 = getWebSearchConfigPath();
+    DEFAULT_OUTPUT_DIR = join8(tmpdir3(), "pi-web-pdf");
+    CONFIG_PATH36 = getWebSearchConfigPath();
     PAGE_MARKER_PATTERN2 = /^<!-- Page (\d+) -->$/gm;
   }
 });
 
 // github-issue-pr.ts
 import { execFile as execFile4 } from "node:child_process";
-import { existsSync as existsSync41, readFileSync as readFileSync43 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync45 } from "node:fs";
 function loadConfig32() {
   if (cachedConfig33) return cachedConfig33;
   const defaults2 = { enabled: true };
-  if (!existsSync41(CONFIG_PATH36)) {
+  if (!existsSync42(CONFIG_PATH37)) {
     cachedConfig33 = defaults2;
     return cachedConfig33;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync43(CONFIG_PATH36, "utf-8"));
+    parsed = JSON.parse(readFileSync45(CONFIG_PATH37, "utf-8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH36}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH37}: ${message}`);
   }
   const root = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   const value = root.githubPrIssue;
   if (value !== void 0 && (typeof value !== "object" || value === null || Array.isArray(value))) {
-    throw new Error(`githubPrIssue in ${CONFIG_PATH36} must be an object`);
+    throw new Error(`githubPrIssue in ${CONFIG_PATH37} must be an object`);
   }
   const enabled = typeof value?.enabled === "boolean" ? value.enabled : true;
   cachedConfig33 = { enabled };
@@ -7647,13 +7645,13 @@ async function extractGitHubIssuePr(url, signal, options) {
   if ("data" in fallback) return renderGitHubPrIssue(fallback.data);
   return fallback;
 }
-var CONFIG_PATH36, GH_TIMEOUT_MS, GH_TOTAL_TIMEOUT_MS, MAX_DOC_CHARS, BODY_INLINE_CHARS, COMMENT_INLINE_CHARS, MAX_INLINE_COMMENTS, MAX_INLINE_REVIEWS, MAX_INLINE_CHECKS, MAX_INLINE_FILES, MAX_INLINE_COMMITS, MAX_INLINE_REVIEW_THREADS, REST_HEADERS, PR_SUBPATHS, PR_FIELDS, PR_CORE_FIELDS, ISSUE_FIELDS, ISSUE_CORE_FIELDS, cachedConfig33;
+var CONFIG_PATH37, GH_TIMEOUT_MS, GH_TOTAL_TIMEOUT_MS, MAX_DOC_CHARS, BODY_INLINE_CHARS, COMMENT_INLINE_CHARS, MAX_INLINE_COMMENTS, MAX_INLINE_REVIEWS, MAX_INLINE_CHECKS, MAX_INLINE_FILES, MAX_INLINE_COMMITS, MAX_INLINE_REVIEW_THREADS, REST_HEADERS, PR_SUBPATHS, PR_FIELDS, PR_CORE_FIELDS, ISSUE_FIELDS, ISSUE_CORE_FIELDS, cachedConfig33;
 var init_github_issue_pr = __esm({
   "github-issue-pr.ts"() {
     init_github_api();
     init_ssrf_protection();
     init_utils();
-    CONFIG_PATH36 = getWebSearchConfigPath();
+    CONFIG_PATH37 = getWebSearchConfigPath();
     GH_TIMEOUT_MS = 1e4;
     GH_TOTAL_TIMEOUT_MS = 2e4;
     MAX_DOC_CHARS = 15e4;
@@ -7739,15 +7737,15 @@ var init_github_issue_pr = __esm({
 });
 
 // feature-config.ts
-import { existsSync as existsSync42, readFileSync as readFileSync44 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync46 } from "node:fs";
 function loadFeatureConfig() {
-  if (!existsSync42(CONFIG_PATH37)) return {};
+  if (!existsSync43(CONFIG_PATH38)) return {};
   try {
-    const raw = JSON.parse(readFileSync44(CONFIG_PATH37, "utf-8"));
+    const raw = JSON.parse(readFileSync46(CONFIG_PATH38, "utf-8"));
     return raw && typeof raw === "object" ? raw : {};
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH37}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH38}: ${message}`);
   }
 }
 function isImageEnabled() {
@@ -7760,17 +7758,17 @@ function canAttachImages() {
     return false;
   }
 }
-var CONFIG_PATH37;
+var CONFIG_PATH38;
 var init_feature_config = __esm({
   "feature-config.ts"() {
     init_utils();
-    CONFIG_PATH37 = getWebSearchConfigPath();
+    CONFIG_PATH38 = getWebSearchConfigPath();
   }
 });
 
 // youtube-extract.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync43, readFileSync as readFileSync45 } from "node:fs";
+import { existsSync as existsSync44, readFileSync as readFileSync47 } from "node:fs";
 function errorMessage25(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -7791,17 +7789,17 @@ function normalizeEnabled2(value, fallback) {
 }
 function loadYouTubeConfig() {
   if (cachedConfig34) return cachedConfig34;
-  if (!existsSync43(CONFIG_PATH38)) {
+  if (!existsSync44(CONFIG_PATH39)) {
     cachedConfig34 = { ...defaults };
     return cachedConfig34;
   }
-  const rawText = readFileSync45(CONFIG_PATH38, "utf-8");
+  const rawText = readFileSync47(CONFIG_PATH39, "utf-8");
   let raw;
   try {
     raw = JSON.parse(rawText);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH38}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH39}: ${message}`);
   }
   const yt = raw.youtube ?? {};
   cachedConfig34 = {
@@ -8003,7 +8001,7 @@ ${answer}
     return null;
   }
 }
-var CONFIG_PATH38, YOUTUBE_PROMPT, YOUTUBE_REGEX, defaults, cachedConfig34;
+var CONFIG_PATH39, YOUTUBE_PROMPT, YOUTUBE_REGEX, defaults, cachedConfig34;
 var init_youtube_extract = __esm({
   "youtube-extract.ts"() {
     init_activity();
@@ -8013,7 +8011,7 @@ var init_youtube_extract = __esm({
     init_perplexity();
     init_extract();
     init_utils();
-    CONFIG_PATH38 = getWebSearchConfigPath();
+    CONFIG_PATH39 = getWebSearchConfigPath();
     YOUTUBE_PROMPT = `Extract the complete content of this YouTube video. Include:
 1. Video title, channel name, and duration
 2. A brief summary (2-3 sentences)
@@ -8125,24 +8123,23 @@ URL: `;
 });
 
 // crawl4ai.ts
-import { existsSync as existsSync44, readFileSync as readFileSync46 } from "node:fs";
-import net3 from "node:net";
+import { existsSync as existsSync45, readFileSync as readFileSync48 } from "node:fs";
 function loadConfig33() {
   if (cachedConfig35) return cachedConfig35;
-  if (!existsSync44(CONFIG_PATH39)) {
+  if (!existsSync45(CONFIG_PATH40)) {
     cachedConfig35 = {};
     return cachedConfig35;
   }
-  const raw = readFileSync46(CONFIG_PATH39, "utf8");
+  const raw = readFileSync48(CONFIG_PATH40, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH39}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH40}: ${message}`);
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Invalid config in ${CONFIG_PATH39}: expected a JSON object`);
+    throw new Error(`Invalid config in ${CONFIG_PATH40}: expected a JSON object`);
   }
   cachedConfig35 = parsed;
   return cachedConfig35;
@@ -8155,13 +8152,13 @@ function normalizeBaseUrl4(value) {
   try {
     parsed = new URL(trimmed);
   } catch {
-    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH39}: expected an HTTP or HTTPS URL`);
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH40}: expected an HTTP or HTTPS URL`);
   }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH39}: expected an HTTP or HTTPS URL`);
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH40}: expected an HTTP or HTTPS URL`);
   }
   if (parsed.username || parsed.password) {
-    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH39}: URL credentials are not allowed`);
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH40}: URL credentials are not allowed`);
   }
   parsed.pathname = parsed.pathname.replace(/\/+$/, "");
   parsed.search = "";
@@ -8176,7 +8173,7 @@ function requireBaseUrl3() {
   if (!baseUrl) {
     throw new Error(
       `Crawl4AI base URL not configured. Either:
-  1. Set crawl4aiBaseUrl in ${CONFIG_PATH39}
+  1. Set crawl4aiBaseUrl in ${CONFIG_PATH40}
   2. Set CRAWL4AI_BASE_URL environment variable`
     );
   }
@@ -8206,12 +8203,6 @@ function ssrfOptions2(options) {
     ...options?.lookup ? { lookup: options.lookup } : {}
   };
 }
-function isLoopbackApiUrl2(url) {
-  const hostname2 = url.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
-  if (hostname2 === "localhost" || hostname2 === "::1") return true;
-  if (net3.isIP(hostname2) !== 4) return false;
-  return hostname2.split(".")[0] === "127";
-}
 function firstHeadingTitle(markdown) {
   return /^[ \t]*#[ \t]+(\S.*?)[ \t\r]*$/m.exec(markdown)?.[1] ?? "";
 }
@@ -8237,7 +8228,7 @@ async function extractWithCrawl4ai(url, signal, options) {
   try {
     const response = await fetchRemoteUrl(requestUrl, init, {
       ...ssrf,
-      allowLoopback: isLoopbackApiUrl2(requestUrl),
+      allowLoopback: isLoopbackHostname(requestUrl.hostname),
       onRedirect: ({ to, init: redirectInit, response: response2 }) => {
         if (to.origin !== requestUrl.origin) {
           throw new Error(`Crawl4AI refused cross-origin redirect to ${to.origin}`);
@@ -8281,14 +8272,14 @@ async function extractWithCrawl4ai(url, signal, options) {
     throw err;
   }
 }
-var CONFIG_PATH39, EXTRACT_TIMEOUT_MS2, MARKDOWN_FILTER, cachedConfig35;
+var CONFIG_PATH40, EXTRACT_TIMEOUT_MS2, MARKDOWN_FILTER, cachedConfig35;
 var init_crawl4ai = __esm({
   "crawl4ai.ts"() {
     init_activity();
     init_credential_source();
     init_ssrf_protection();
     init_utils();
-    CONFIG_PATH39 = getWebSearchConfigPath();
+    CONFIG_PATH40 = getWebSearchConfigPath();
     EXTRACT_TIMEOUT_MS2 = 6e4;
     MARKDOWN_FILTER = "fit";
     cachedConfig35 = null;
@@ -8296,7 +8287,7 @@ var init_crawl4ai = __esm({
 });
 
 // brightdata-unlocker.ts
-import { existsSync as existsSync45, readFileSync as readFileSync47 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync49 } from "node:fs";
 function parseFailureDetail(err) {
   const message = err instanceof Error ? err.message : String(err);
   const position = message.match(/at position \d+(?: \(line \d+ column \d+\))?/);
@@ -8304,19 +8295,19 @@ function parseFailureDetail(err) {
 }
 function loadConfig34() {
   if (cachedConfig36) return cachedConfig36;
-  if (!existsSync45(CONFIG_PATH40)) {
+  if (!existsSync46(CONFIG_PATH41)) {
     cachedConfig36 = {};
     return cachedConfig36;
   }
-  const raw = readFileSync47(CONFIG_PATH40, "utf8");
+  const raw = readFileSync49(CONFIG_PATH41, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new Error(`Failed to parse ${CONFIG_PATH40}: ${parseFailureDetail(err)}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH41}: ${parseFailureDetail(err)}`);
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Invalid config in ${CONFIG_PATH40}: expected a JSON object`);
+    throw new Error(`Invalid config in ${CONFIG_PATH41}: expected a JSON object`);
   }
   cachedConfig36 = parsed;
   return cachedConfig36;
@@ -8331,7 +8322,7 @@ function zoneSetting() {
   const fromEnv = process.env.BRIGHTDATA_UNLOCKER_ZONE;
   if (typeof fromEnv === "string" && fromEnv.trim()) return { raw: fromEnv.trim(), label: "BRIGHTDATA_UNLOCKER_ZONE" };
   const configured = loadConfig34().brightdataUnlockerZone;
-  if (typeof configured === "string" && configured.trim()) return { raw: configured.trim(), label: `brightdataUnlockerZone in ${CONFIG_PATH40}` };
+  if (typeof configured === "string" && configured.trim()) return { raw: configured.trim(), label: `brightdataUnlockerZone in ${CONFIG_PATH41}` };
   return null;
 }
 function getZone() {
@@ -8349,7 +8340,7 @@ function requireZone() {
   }
   throw new Error(
     `Bright Data Web Unlocker zone not configured. Either:
-  1. Set brightdataUnlockerZone in ${CONFIG_PATH40}
+  1. Set brightdataUnlockerZone in ${CONFIG_PATH41}
   2. Set BRIGHTDATA_UNLOCKER_ZONE environment variable
 The zone must be of type "unblocker"; a SERP zone will not serve Web Unlocker requests.`
   );
@@ -8364,7 +8355,7 @@ async function getApiKey26(signal) {
   if (!apiKey) {
     throw new Error(
       `Bright Data API key not found. Either:
-  1. Create ${CONFIG_PATH40} with { "brightdataApiKey": "your-key" }
+  1. Create ${CONFIG_PATH41} with { "brightdataApiKey": "your-key" }
   2. Set BRIGHTDATA_API_KEY environment variable
 Get a key at https://brightdata.com/cp/setting/users`
     );
@@ -8473,14 +8464,14 @@ async function extractWithBrightDataUnlocker(url, signal, options) {
   if (!content) return null;
   return { url, title: headingTitle(content), content, error: null };
 }
-var CONFIG_PATH40, BRIGHTDATA_REQUEST_URL, EXTRACT_TIMEOUT_MS3, DEFAULT_MAX_REDIRECTS3, REDIRECT_STATUSES3, ZONE_PATTERN2, cachedConfig36;
+var CONFIG_PATH41, BRIGHTDATA_REQUEST_URL, EXTRACT_TIMEOUT_MS3, DEFAULT_MAX_REDIRECTS3, REDIRECT_STATUSES3, ZONE_PATTERN2, cachedConfig36;
 var init_brightdata_unlocker = __esm({
   "brightdata-unlocker.ts"() {
     init_activity();
     init_credential_source();
     init_ssrf_protection();
     init_utils();
-    CONFIG_PATH40 = getWebSearchConfigPath();
+    CONFIG_PATH41 = getWebSearchConfigPath();
     BRIGHTDATA_REQUEST_URL = "https://api.brightdata.com/request";
     EXTRACT_TIMEOUT_MS3 = 6e4;
     DEFAULT_MAX_REDIRECTS3 = 5;
@@ -8492,9 +8483,9 @@ var init_brightdata_unlocker = __esm({
 
 // video-extract.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync46, readFileSync as readFileSync48, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync47, readFileSync as readFileSync50, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { resolve, extname as extname2, basename as basename4, join as join8, dirname as dirname2 } from "node:path";
+import { resolve, extname as extname2, basename as basename4, join as join9, dirname as dirname3 } from "node:path";
 function shouldRethrow3(err) {
   const message = err instanceof Error ? err.message : String(err);
   return message.startsWith("Failed to parse ");
@@ -8513,17 +8504,17 @@ function normalizeMaxSizeMB(value, fallback) {
 }
 function loadVideoConfig() {
   if (cachedVideoConfig) return cachedVideoConfig;
-  if (!existsSync46(CONFIG_PATH41)) {
+  if (!existsSync47(CONFIG_PATH42)) {
     cachedVideoConfig = { ...VIDEO_CONFIG_DEFAULTS };
     return cachedVideoConfig;
   }
-  const rawText = readFileSync48(CONFIG_PATH41, "utf-8");
+  const rawText = readFileSync50(CONFIG_PATH42, "utf-8");
   let raw;
   try {
     raw = JSON.parse(rawText);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH41}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH42}: ${message}`);
   }
   const v = raw.video ?? {};
   cachedVideoConfig = {
@@ -8569,14 +8560,14 @@ function isVideoFile(input) {
 }
 function resolveFilePath(filePath) {
   const absolutePath = resolve(filePath);
-  if (existsSync46(absolutePath)) return absolutePath;
-  const dir = dirname2(absolutePath);
+  if (existsSync47(absolutePath)) return absolutePath;
+  const dir = dirname3(absolutePath);
   const base = basename4(absolutePath);
-  if (!existsSync46(dir)) return null;
+  if (!existsSync47(dir)) return null;
   try {
     const normalizedBase = normalizeSpaces(base);
     const match = readdirSync4(dir).find((f) => normalizeSpaces(f) === normalizedBase);
-    return match ? join8(dir, match) : null;
+    return match ? join9(dir, match) : null;
   } catch {
     return null;
   }
@@ -8770,7 +8761,7 @@ function deleteGeminiFile(fileName, apiKey) {
 function extractVideoTitle(text2, filePath) {
   return extractHeadingTitle(text2) ?? basename4(filePath, extname2(filePath));
 }
-var CONFIG_PATH41, DEFAULT_VIDEO_PROMPT, VIDEO_EXTENSIONS, VIDEO_CONFIG_DEFAULTS, cachedVideoConfig;
+var CONFIG_PATH42, DEFAULT_VIDEO_PROMPT, VIDEO_EXTENSIONS, VIDEO_CONFIG_DEFAULTS, cachedVideoConfig;
 var init_video_extract = __esm({
   "video-extract.ts"() {
     init_activity();
@@ -8779,7 +8770,7 @@ var init_video_extract = __esm({
     init_gemini_api();
     init_extract();
     init_utils();
-    CONFIG_PATH41 = getWebSearchConfigPath();
+    CONFIG_PATH42 = getWebSearchConfigPath();
     DEFAULT_VIDEO_PROMPT = `Extract the complete content of this video. Include:
 1. Video title (infer from content if not explicit), duration
 2. A brief summary (2-3 sentences)
@@ -9264,13 +9255,13 @@ __export(extract_exports, {
   readPDFResponseBuffer: () => readPDFResponseBuffer,
   resolveFetchTimeoutMs: () => resolveFetchTimeoutMs
 });
-import { existsSync as existsSync47, readFileSync as readFileSync49 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync51 } from "node:fs";
 import pLimit from "p-limit";
 function loadFetchTimeoutMs() {
-  if (!existsSync47(WEB_SEARCH_CONFIG_PATH3)) return DEFAULT_TIMEOUT_MS3;
+  if (!existsSync48(WEB_SEARCH_CONFIG_PATH3)) return DEFAULT_TIMEOUT_MS3;
   let raw;
   try {
-    raw = JSON.parse(readFileSync49(WEB_SEARCH_CONFIG_PATH3, "utf-8"));
+    raw = JSON.parse(readFileSync51(WEB_SEARCH_CONFIG_PATH3, "utf-8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_PATH3}: ${message}`);
@@ -9396,12 +9387,12 @@ async function fetchAuthenticatedRemoteUrl(url, init, validationOptions, profile
   throw new Error(`Too many redirects fetching ${current.toString()}`);
 }
 function loadFetchRouting() {
-  if (!existsSync47(WEB_SEARCH_CONFIG_PATH3)) {
+  if (!existsSync48(WEB_SEARCH_CONFIG_PATH3)) {
     return { providers: DEFAULT_FETCH_PROVIDER_ORDER, allowRemoteHostedProviders: false };
   }
   let raw;
   try {
-    const parsed = JSON.parse(readFileSync49(WEB_SEARCH_CONFIG_PATH3, "utf-8"));
+    const parsed = JSON.parse(readFileSync51(WEB_SEARCH_CONFIG_PATH3, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new Error("expected a JSON object");
     }
@@ -10461,7 +10452,7 @@ var init_extract = __esm({
 
 // index.ts
 import { Box, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 import pLimit2 from "p-limit";
 
 // fetch-params.ts
@@ -11048,7 +11039,7 @@ init_gemini_api();
 init_gemini_adc();
 init_gemini_web();
 init_perplexity();
-import { existsSync as existsSync38, readFileSync as readFileSync39 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync40 } from "node:fs";
 
 // exa.ts
 init_activity();
@@ -15048,6 +15039,118 @@ async function searchWithSerply(query, options = {}) {
   return { answer: formatSearchResultsAsAnswer(results), results };
 }
 
+// baizhi.ts
+init_activity();
+init_credential_source();
+init_domain_filter_normalization();
+init_search_result_count_normalization();
+init_utils();
+import { existsSync as existsSync36, readFileSync as readFileSync37 } from "node:fs";
+import { isIP as isIP2 } from "node:net";
+var MCP_URL = "https://agent-toolkit.app.baizhi.cloud/mcp";
+var SEARCH_TIMEOUT_MS25 = 6e4;
+var CONFIG_PATH31 = getWebSearchConfigPath();
+function credentialOptions() {
+  let config = {};
+  if (existsSync36(CONFIG_PATH31)) {
+    try {
+      const parsed = JSON.parse(readFileSync37(CONFIG_PATH31, "utf8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+      config = parsed;
+    } catch {
+      throw new Error(`Invalid configuration in ${CONFIG_PATH31}: expected a JSON object`);
+    }
+  }
+  return { provider: "Baizhi", configuredValue: config.baizhiApiKey, environmentValue: process.env.BAIZHI_API_KEY };
+}
+function isBaizhiAvailable() {
+  return hasCredentialSource(credentialOptions());
+}
+function searchArguments(query, options) {
+  if (!query.trim()) throw new Error("Baizhi search query must not be empty");
+  const domains = [];
+  const excludeDomains = [];
+  for (const raw of options.domainFilter ?? []) {
+    const bare = raw.trim().replace(/^-/, "").trim();
+    const domain = isIP2(bare) ? bare : normalizeDomain(raw);
+    if (!domain) throw new Error("Baizhi domain filter must contain a valid domain");
+    const target = raw.trim().startsWith("-") ? excludeDomains : domains;
+    if (!target.includes(domain)) target.push(domain);
+  }
+  return {
+    query: query.trim(),
+    count: normalizeSearchResultCount(options.numResults),
+    need_summary: false,
+    // The published discovery contract defaults to month, not unrestricted time.
+    time_range: options.recencyFilter ?? "month",
+    ...domains.length || excludeDomains.length ? { filter: {
+      ...domains.length ? { domains } : {},
+      ...excludeDomains.length ? { exclude_domains: excludeDomains } : {}
+    } } : {}
+  };
+}
+async function searchWithBaizhi(query, options = {}) {
+  const args = searchArguments(query, options);
+  const timeoutSignal = AbortSignal.timeout(SEARCH_TIMEOUT_MS25);
+  const signal = options.signal ? AbortSignal.any([timeoutSignal, options.signal]) : timeoutSignal;
+  if (signal.aborted) throw new Error("Aborted");
+  const apiKey = await resolveCredential({ ...credentialOptions(), signal });
+  if (!apiKey) throw new Error("Baizhi API key not found. Set BAIZHI_API_KEY or baizhiApiKey in web-search.json. Get your own key at https://agent-toolkit.app.baizhi.cloud/");
+  let headers;
+  try {
+    headers = new Headers({ Authorization: `Bearer ${apiKey}` });
+  } catch {
+    throw new Error("Baizhi credential resolution failed: invalid-header-value");
+  }
+  const [{ Client }, { StreamableHTTPClientTransport }] = await Promise.all([
+    import("@modelcontextprotocol/sdk/client/index.js"),
+    import("@modelcontextprotocol/sdk/client/streamableHttp.js")
+  ]);
+  let cleaningUp = false;
+  const transport = new StreamableHTTPClientTransport(new URL(MCP_URL), {
+    requestInit: { headers },
+    fetch: async (url, init) => {
+      if (String(url) !== MCP_URL) throw new Error("Baizhi endpoint changed unexpectedly");
+      const requestSignal15 = cleaningUp ? AbortSignal.timeout(1500) : signal;
+      return fetch(url, { ...init, redirect: "error", signal: !cleaningUp && init?.signal ? AbortSignal.any([init.signal, requestSignal15]) : requestSignal15 });
+    },
+    reconnectionOptions: { maxRetries: 0, initialReconnectionDelay: 1e3, maxReconnectionDelay: 1e3, reconnectionDelayGrowFactor: 1 }
+  });
+  const client = new Client({ name: "pi-web-access-baizhi", version: "1.0.0" });
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    await client.connect(transport, { signal, timeout: SEARCH_TIMEOUT_MS25 });
+    const result = await client.callTool({ name: "websearch_search", arguments: args }, void 0, { signal, timeout: SEARCH_TIMEOUT_MS25 });
+    if (result.isError) throw new Error("Baizhi search tool returned an error");
+    const parts = [];
+    if (result.structuredContent !== void 0) parts.push(JSON.stringify(result.structuredContent, null, 2));
+    for (const item of Array.isArray(result.content) ? result.content : []) {
+      if (item.type === "text" && typeof item.text === "string" && item.text.trim()) parts.push(item.text);
+    }
+    if (!parts.length) throw new Error("Baizhi returned invalid response: no search text or structured content");
+    const answer = redactCredential(redactCredential(parts.join("\n\n"), apiKey), JSON.stringify(apiKey).slice(1, -1));
+    activityMonitor.logComplete(activityId, 200);
+    return { answer, results: [] };
+  } catch (err) {
+    let message;
+    if (options.signal?.aborted) message = "Aborted";
+    else if (timeoutSignal.aborted) message = "Baizhi request timed out after 60s";
+    else {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      message = typeof code === "number" && Number.isInteger(code) && code >= 400 && code <= 599 ? `Baizhi HTTP ${code} request failed; check your API key, account and service status` : err instanceof TypeError ? "Baizhi network request failed" : err instanceof SyntaxError || code === -32700 || code === -32602 ? "Baizhi returned invalid response" : err instanceof Error && /^Baizhi (search tool returned an error|returned invalid response:)/.test(err.message) ? err.message : "Baizhi MCP request failed; check your connection, API key and account status";
+    }
+    activityMonitor.logError(activityId, message);
+    throw new Error(message);
+  } finally {
+    cleaningUp = true;
+    try {
+      await transport.terminateSession();
+    } catch {
+    }
+    await client.close();
+  }
+}
+
 // valyu.ts
 init_activity();
 init_domain_filter_normalization();
@@ -15055,29 +15158,29 @@ init_search_answer_formatting();
 init_search_result_count_normalization();
 init_credential_source();
 init_utils();
-import { existsSync as existsSync36, readFileSync as readFileSync37 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync38 } from "node:fs";
 var VALYU_SEARCH_URL = "https://api.valyu.ai/v1/search";
-var CONFIG_PATH31 = getWebSearchConfigPath();
-var SEARCH_TIMEOUT_MS25 = 6e4;
+var CONFIG_PATH32 = getWebSearchConfigPath();
+var SEARCH_TIMEOUT_MS26 = 6e4;
 var MAX_SNIPPET_CHARS = 2500;
 var MAX_CONTENT_CHARS = 4e3;
 var cachedConfig30 = null;
 function loadConfig29() {
   if (cachedConfig30) return cachedConfig30;
-  if (!existsSync36(CONFIG_PATH31)) {
+  if (!existsSync37(CONFIG_PATH32)) {
     cachedConfig30 = {};
     return cachedConfig30;
   }
-  const raw = readFileSync37(CONFIG_PATH31, "utf-8");
+  const raw = readFileSync38(CONFIG_PATH32, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH31}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH32}: ${message}`);
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Invalid config in ${CONFIG_PATH31}: expected a JSON object`);
+    throw new Error(`Invalid config in ${CONFIG_PATH32}: expected a JSON object`);
   }
   cachedConfig30 = parsed;
   return cachedConfig30;
@@ -15095,7 +15198,7 @@ async function requireApiKey12(signal) {
   if (!apiKey) {
     throw new Error(
       `Valyu API key not found. Either:
-  1. Create ${CONFIG_PATH31} with { "valyuApiKey": "your-key" }
+  1. Create ${CONFIG_PATH32} with { "valyuApiKey": "your-key" }
   2. Set VALYU_API_KEY environment variable
 Get a key at https://platform.valyu.ai`
     );
@@ -15152,7 +15255,7 @@ async function searchWithValyu(query, options = {}) {
       method: "POST",
       headers: { "x-api-key": apiKey, "Content-Type": "application/json", Accept: "application/json" },
       body: JSON.stringify({ query, max_num_results: numResults, ...mapDomainFilter8(options.domainFilter), ...startDate ? { start_date: startDate } : {} }),
-      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS25), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS25)
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS26), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS26)
     });
   } catch (err) {
     const message = errorMessage21(err);
@@ -15209,7 +15312,7 @@ init_search_result_count_normalization();
 import { randomUUID as randomUUID2 } from "node:crypto";
 var KIMI_SEARCH_URL = "https://api.kimi.com/coding/v1/search";
 var KIMI_PROVIDERS = ["kimi-coding", "kimi-code"];
-var SEARCH_TIMEOUT_MS26 = 3e4;
+var SEARCH_TIMEOUT_MS27 = 3e4;
 function buildRequestHeaders(auth) {
   const headers = new Headers();
   for (const [name, value] of Object.entries(auth.headers)) {
@@ -15324,7 +15427,7 @@ async function searchWithKimi(query, options = {}, ctx) {
     throw new Error("Kimi Code web search unavailable. Run /login kimi-coding to authenticate a Kimi Code Plan account.");
   }
   const activityId = activityMonitor.logStart({ type: "api", query });
-  const timeoutSignal = AbortSignal.timeout(SEARCH_TIMEOUT_MS26);
+  const timeoutSignal = AbortSignal.timeout(SEARCH_TIMEOUT_MS27);
   const requestSignal15 = options.signal ? AbortSignal.any([timeoutSignal, options.signal]) : timeoutSignal;
   try {
     const response = await fetch(KIMI_SEARCH_URL, {
@@ -15376,30 +15479,30 @@ init_activity();
 init_domain_filter_normalization();
 init_credential_source();
 init_utils();
-import { existsSync as existsSync37, readFileSync as readFileSync38 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync39 } from "node:fs";
 var MISTRAL_CONVERSATIONS_URL = "https://api.mistral.ai/v1/conversations";
-var CONFIG_PATH32 = getWebSearchConfigPath();
-var SEARCH_TIMEOUT_MS27 = 6e4;
+var CONFIG_PATH33 = getWebSearchConfigPath();
+var SEARCH_TIMEOUT_MS28 = 6e4;
 var DEFAULT_SEARCH_MODEL = "mistral-small-latest";
 var DEFAULT_SEARCH_TOOL = "web_search";
 var MAX_RESULTS = 20;
 var cachedConfig31 = null;
 function loadConfig30() {
   if (cachedConfig31) return cachedConfig31;
-  if (!existsSync37(CONFIG_PATH32)) {
+  if (!existsSync38(CONFIG_PATH33)) {
     cachedConfig31 = {};
     return cachedConfig31;
   }
-  const raw = readFileSync38(CONFIG_PATH32, "utf-8");
+  const raw = readFileSync39(CONFIG_PATH33, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH32}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH33}: ${message}`);
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Invalid config in ${CONFIG_PATH32}: expected a JSON object`);
+    throw new Error(`Invalid config in ${CONFIG_PATH33}: expected a JSON object`);
   }
   cachedConfig31 = parsed;
   return cachedConfig31;
@@ -15407,14 +15510,14 @@ function loadConfig30() {
 function resolveSearchModel(value) {
   if (value === void 0) return DEFAULT_SEARCH_MODEL;
   if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`mistralSearchModel in ${CONFIG_PATH32} must be a non-empty string`);
+    throw new Error(`mistralSearchModel in ${CONFIG_PATH33} must be a non-empty string`);
   }
   return value.trim();
 }
 function resolveSearchTool(value) {
   if (value === void 0) return DEFAULT_SEARCH_TOOL;
   if (value !== "web_search" && value !== "web_search_premium") {
-    throw new Error(`mistralSearchTool in ${CONFIG_PATH32} must be either web_search or web_search_premium`);
+    throw new Error(`mistralSearchTool in ${CONFIG_PATH33} must be either web_search or web_search_premium`);
   }
   return value;
 }
@@ -15528,7 +15631,7 @@ async function getApiKey25(signal) {
   if (!apiKey) {
     throw new Error(
       `Mistral API key not found. Either:
-  1. Create ${CONFIG_PATH32} with { "mistralApiKey": "your-key" }
+  1. Create ${CONFIG_PATH33} with { "mistralApiKey": "your-key" }
   2. Set MISTRAL_API_KEY environment variable
 Get a key at https://console.mistral.ai/api-keys`
     );
@@ -15555,7 +15658,7 @@ async function searchWithMistral(query, options = {}) {
   const tool = resolveSearchTool(config.mistralSearchTool);
   const numResults = normalizeCount4(options.numResults);
   const apiKey = await getApiKey25(options.signal);
-  const requestSignal15 = options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS27), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS27);
+  const requestSignal15 = options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS28), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS28);
   const activityId = activityMonitor.logStart({ type: "api", query });
   try {
     const response = await fetch(MISTRAL_CONVERSATIONS_URL, {
@@ -15602,7 +15705,7 @@ async function searchWithMistral(query, options = {}) {
 
 // gemini-search.ts
 init_utils();
-var 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"];
+var 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"];
 var SEARCH_PROVIDERS = ["auto", "all", ...RESOLVED_SEARCH_PROVIDERS];
 var SearchProviderError = class extends Error {
   provider;
@@ -15618,18 +15721,18 @@ var SearchProviderError = class extends Error {
     this.causeError = cause;
   }
 };
-var CONFIG_PATH33 = getWebSearchConfigPath();
+var CONFIG_PATH34 = getWebSearchConfigPath();
 var DEFAULT_SEARCH_MODEL2 = "gemini-3.6-flash";
 var ALL_SEARCH_PROVIDERS = ["searxng", "openai", "exa", "brave", "parallel", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "ollama", "perplexity", "gemini", "bocha"];
 var VALID_ROUTING_KINDS = ["transient", "quota", "network", "invalid-response", "unsupported"];
 var cachedSearchConfig = null;
 function getSearchConfig() {
   if (cachedSearchConfig) return cachedSearchConfig;
-  if (!existsSync38(CONFIG_PATH33)) {
+  if (!existsSync39(CONFIG_PATH34)) {
     cachedSearchConfig = { searchProvider: "auto", searchProviderConfigured: false };
     return cachedSearchConfig;
   }
-  const rawText = readFileSync39(CONFIG_PATH33, "utf-8");
+  const rawText = readFileSync40(CONFIG_PATH34, "utf-8");
   let raw;
   try {
     const parsed = JSON.parse(rawText);
@@ -15639,25 +15742,25 @@ function getSearchConfig() {
     raw = parsed;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${CONFIG_PATH33}: ${message}`);
+    throw new Error(`Failed to parse ${CONFIG_PATH34}: ${message}`);
   }
   const searchModel = normalizeSearchModel(raw.searchModel);
   const webSearch = raw.webSearch;
   if (webSearch !== void 0 && (!webSearch || typeof webSearch !== "object" || Array.isArray(webSearch))) {
-    throw new Error(`webSearch in ${CONFIG_PATH33} must be an object`);
+    throw new Error(`webSearch in ${CONFIG_PATH34} must be an object`);
   }
-  const allowedProviders = webSearch && Object.hasOwn(webSearch, "allowedProviders") ? normalizeResolvedProviderList(webSearch.allowedProviders, `webSearch.allowedProviders in ${CONFIG_PATH33}`) : void 0;
+  const allowedProviders = webSearch && Object.hasOwn(webSearch, "allowedProviders") ? normalizeResolvedProviderList(webSearch.allowedProviders, `webSearch.allowedProviders in ${CONFIG_PATH34}`) : void 0;
   const searchProviderConfigured = Object.hasOwn(raw, "searchProvider") || Object.hasOwn(raw, "provider");
-  const searchProvider = normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH33}`);
+  const searchProvider = normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH34}`);
   const searchRouting = Object.hasOwn(raw, "searchRouting") ? normalizeSearchRouting(raw.searchRouting) : void 0;
   if (allowedProviders) {
     if (Object.hasOwn(raw, "searchProvider")) {
-      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.searchProvider), `searchProvider in ${CONFIG_PATH33}`, allowedProviders);
+      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.searchProvider), `searchProvider in ${CONFIG_PATH34}`, allowedProviders);
     }
     if (Object.hasOwn(raw, "provider")) {
-      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.provider), `provider in ${CONFIG_PATH33}`, allowedProviders);
+      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.provider), `provider in ${CONFIG_PATH34}`, allowedProviders);
     }
-    if (searchRouting) assertSearchProviderSelectionAllowed(searchRouting.providers, `searchRouting.providers in ${CONFIG_PATH33}`, allowedProviders);
+    if (searchRouting) assertSearchProviderSelectionAllowed(searchRouting.providers, `searchRouting.providers in ${CONFIG_PATH34}`, allowedProviders);
   }
   cachedSearchConfig = {
     searchProvider,
@@ -15670,21 +15773,21 @@ function getSearchConfig() {
 }
 function normalizeSearchRouting(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`searchRouting in ${CONFIG_PATH33} must be an object`);
+    throw new Error(`searchRouting in ${CONFIG_PATH34} must be an object`);
   }
   const raw = value;
-  const providers = normalizeResolvedProviderList(raw.providers, `searchRouting.providers in ${CONFIG_PATH33}`);
+  const providers = normalizeResolvedProviderList(raw.providers, `searchRouting.providers in ${CONFIG_PATH34}`);
   const useCurrentModel = raw.useCurrentModel;
   if (useCurrentModel !== void 0 && typeof useCurrentModel !== "boolean") {
-    throw new Error(`searchRouting.useCurrentModel in ${CONFIG_PATH33} must be a boolean`);
+    throw new Error(`searchRouting.useCurrentModel in ${CONFIG_PATH34} must be a boolean`);
   }
   if (!Array.isArray(raw.fallbackOn) || raw.fallbackOn.length === 0) {
-    throw new Error(`searchRouting.fallbackOn in ${CONFIG_PATH33} must be a non-empty array`);
+    throw new Error(`searchRouting.fallbackOn in ${CONFIG_PATH34} must be a non-empty array`);
   }
   const fallbackOn = [];
   for (const kind of raw.fallbackOn) {
     if (typeof kind !== "string" || !VALID_ROUTING_KINDS.includes(kind)) {
-      throw new Error(`searchRouting.fallbackOn in ${CONFIG_PATH33} may only contain transient, quota, network, invalid-response, or unsupported`);
+      throw new Error(`searchRouting.fallbackOn in ${CONFIG_PATH34} may only contain transient, quota, network, invalid-response, or unsupported`);
     }
     if (!fallbackOn.includes(kind)) {
       fallbackOn.push(kind);
@@ -15744,18 +15847,10 @@ function errorMessage23(err) {
 function isAbortError2(err) {
   return errorMessage23(err).toLowerCase().includes("abort");
 }
-function shouldTryOpenAIInAuto(options) {
-  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) {
   return ctx?.model?.provider === "openai-codex";
 }
 async function tryOpenAIInAuto(query, options, fallbackErrors) {
-  if (!shouldTryOpenAIInAuto(options)) return null;
   try {
     if (await isOpenAISearchAvailable(options.extensionContext)) {
       const result = await searchWithOpenAI(query, options, options.extensionContext);
@@ -15865,6 +15960,7 @@ async function searchWithResolvedProvider(provider, query, options, useCurrentMo
   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 };
@@ -15876,7 +15972,7 @@ async function searchWithResolvedProvider(provider, query, options, useCurrentMo
     if (result2) return { ...result2, provider };
     throw new Error(
       `Gemini search unavailable. Either:
-  1. Configure geminiApiKey in ${CONFIG_PATH33} or set GEMINI_API_KEY
+  1. Configure geminiApiKey in ${CONFIG_PATH34} or set GEMINI_API_KEY
   2. Set GOOGLE_GEMINI_BASE_URL + CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing
   3. Set geminiAuth to "adc" in web-search.json with a Google Cloud ADC + project/location
   4. Sign into gemini.google.com in a supported Chromium-based browser`
@@ -15912,6 +16008,7 @@ async function isResolvedProviderAvailable(provider, options, useCurrentModel =
   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();
@@ -15951,6 +16048,7 @@ function providerLabel(provider) {
   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);
 }
@@ -16228,7 +16326,7 @@ async function search(query, options = {}) {
   throw new Error(
     `No search provider available. Either:
   1. Use /login to sign in with a Codex subscription for OpenAI web search
-  2. Set openaiApiKey, braveApiKey, parallelApiKey, tinyfishApiKey, search1apiApiKey, searchinfinityApiKey, queritApiKey, tavilyApiKey, firecrawlBaseUrl, jinaApiKey, serpdiveApiKey, kagiApiKey, ollamaApiKey, searxngBaseUrl, perplexityApiKey, exaApiKey, geminiApiKey, bochaApiKey, or cloudflareApiKey in ${CONFIG_PATH33}
+  2. Set openaiApiKey, braveApiKey, parallelApiKey, tinyfishApiKey, search1apiApiKey, searchinfinityApiKey, queritApiKey, tavilyApiKey, firecrawlBaseUrl, jinaApiKey, serpdiveApiKey, kagiApiKey, ollamaApiKey, searxngBaseUrl, perplexityApiKey, exaApiKey, geminiApiKey, bochaApiKey, or cloudflareApiKey in ${CONFIG_PATH34}
   3. Set OPENAI_API_KEY, BRAVE_API_KEY, PARALLEL_API_KEY, TINYFISH_API_KEY, SEARCH1API_KEY, SEARCHINFINITY_API_KEY, QUERIT_API_KEY, TAVILY_API_KEY, FIRECRAWL_BASE_URL, JINA_API_KEY, SERPDIVE_API_KEY, KAGI_API_KEY, BOCHA_API_KEY, OLLAMA_API_KEY, SEARXNG_BASE_URL, EXA_API_KEY, PERPLEXITY_API_KEY, GEMINI_API_KEY, or CLOUDFLARE_API_KEY env vars
   4. Set GOOGLE_GEMINI_BASE_URL with CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing
   5. Sign into gemini.google.com in a supported Chromium-based browser
@@ -16377,7 +16475,7 @@ init_utils();
 
 // storage.ts
 init_utils();
-import { closeSync as closeSync2, constants, fchmodSync, fstatSync as fstatSync2, fsyncSync, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync40, readdirSync as readdirSync3, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { closeSync as closeSync2, constants, fchmodSync, fstatSync as fstatSync2, fsyncSync, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync41, readdirSync as readdirSync3, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join6 } from "node:path";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
@@ -16697,7 +16795,7 @@ function readCachedFetchData(data, now = Date.now()) {
     const opened = openRegularFile(path);
     fd = opened.fd;
     enforceFileMode(fd);
-    const parsed = JSON.parse(readFileSync40(fd, "utf8"));
+    const parsed = JSON.parse(readFileSync41(fd, "utf8"));
     if (!isValidStoredData(parsed) || parsed.type !== "fetch" || parsed.id !== data.id || !isInlineFetchData(parsed)) {
       return unavailableFetchData(data, "Cached fetched content is invalid");
     }
@@ -16847,6 +16945,7 @@ function buildProviderButtons(available, selected, hasInitialQueries) {
     { value: "serpapi", label: "SerpApi", available: available.serpapi },
     { value: "serper", label: "Serper", available: available.serper },
     { value: "serply", label: "Serply", available: available.serply },
+    { value: "baizhi", label: "Baizhi", available: available.baizhi },
     { value: "valyu", label: "Valyu", available: available.valyu }
   ];
   return providers.filter((p) => p.available).map((p) => {
@@ -18257,7 +18356,7 @@ var SCRIPT = `(function() {
   var token = DATA.sessionToken;
   var timeoutSec = DATA.timeout;
   var queries = Array.isArray(DATA.queries) ? DATA.queries : [];
-  var providers = ["auto", "all", "openai", "exa", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "bocha", "ollama", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "anysearch", "xcrawl", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu"];
+  var providers = ["auto", "all", "openai", "exa", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "bocha", "ollama", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "anysearch", "xcrawl", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "baizhi"];
   var availProviders = DATA.availableProviders && typeof DATA.availableProviders === "object" ? DATA.availableProviders : {};
   var workflow = "summary-review";
   var initialDefaultProvider = typeof DATA.defaultProvider === "string" ? DATA.defaultProvider : "exa";
@@ -18492,6 +18591,7 @@ var SCRIPT = `(function() {
     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 "Unknown";
   }
@@ -20599,6 +20699,7 @@ function startCuratorServer(options, callbacks) {
     if (provider === "serpbase") return availableProviders.serpbase;
     if (provider === "serper") return availableProviders.serper;
     if (provider === "serply") return availableProviders.serply;
+    if (provider === "baizhi") return availableProviders.baizhi;
     if (provider === "valyu") return availableProviders.valyu;
     return false;
   }
@@ -21378,8 +21479,8 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import { execFileSync as execFileSync3, spawn as spawn3 } from "node:child_process";
 import { createRequire } from "node:module";
 import { platform } from "node:os";
-import { existsSync as existsSync48, readFileSync as readFileSync50, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync49, readFileSync as readFileSync52, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 init_gemini_api();
 init_gemini_web();
 init_gemini_web_config();
@@ -21659,9 +21760,118 @@ function getResearchArtifact(id) {
   return data.artifact;
 }
 
+// tool-activation.ts
+import { buildSessionContext } from "@earendil-works/pi-coding-agent";
+import { dirname as dirname2, join as join7 } from "node:path";
+import { readFileSync as readFileSync42 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Type } from "typebox";
+var LOADER_NAME = "web_enable";
+var CAPABILITY_LABELS = {
+  search: "web search",
+  "source-check": "source checking",
+  fetch: "content fetching",
+  "stored-content": "stored-result retrieval"
+};
+function supportsDynamicTools(pi) {
+  if (typeof pi.getAllTools !== "function" || typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return false;
+  try {
+    const packagePath = join7(dirname2(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "..", "package.json");
+    const [major, minor, patch] = JSON.parse(readFileSync42(packagePath, "utf8")).version.split(".").map(Number);
+    return major > 0 || minor > 86 || minor === 86 && patch >= 1;
+  } catch {
+    return false;
+  }
+}
+function hasToolDeclarations(messages) {
+  return messages.some((message) => message && typeof message === "object" && ("toolsAdded" in message || "toolsRemoved" in message));
+}
+async function currentTranscriptToolNames(messages) {
+  const moduleName = "@earendil-works/pi-ai/utils/transcript";
+  const { getCurrentTools } = await import(moduleName);
+  return getCurrentTools(messages).map((tool) => tool.name);
+}
+function registerWebToolActivation(pi, tools) {
+  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({
+    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", text: `Cannot enable unavailable tools: ${unavailable.join(", ")}.` }],
+          details: { unavailable }
+        };
+      }
+      try {
+        pi.setActiveTools([.../* @__PURE__ */ new Set([...pi.getActiveTools(), ...names])]);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          isError: true,
+          content: [{ type: "text", 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", text: `Tools still inactive after activation: ${missing.join(", ")}.` }],
+        details: { missing }
+      } : {
+        content: [{ type: "text", text: `Enabled: ${names.join(", ")}.` }],
+        details: { enabled: names }
+      };
+    }
+  });
+  function loaderAvailable() {
+    return pi.getAllTools().some((tool) => tool.name === LOADER_NAME);
+  }
+  let warned = false;
+  async function selectFromSession(ctx) {
+    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) : /* @__PURE__ */ new Set();
+      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([.../* @__PURE__ */ 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 {
+    }
+  });
+}
+
 // index.ts
 function StringEnum(values, options) {
-  return Type.Unsafe({
+  return Type2.Unsafe({
     type: "string",
     enum: values,
     ...options?.description && { description: options.description },
@@ -21712,17 +21922,17 @@ function parseConfigRoot(raw) {
   return parsed;
 }
 function loadConfig35() {
-  if (!existsSync48(WEB_SEARCH_CONFIG_PATH4)) return {};
-  return parseConfigRoot(readFileSync50(WEB_SEARCH_CONFIG_PATH4, "utf-8"));
+  if (!existsSync49(WEB_SEARCH_CONFIG_PATH4)) return {};
+  return parseConfigRoot(readFileSync52(WEB_SEARCH_CONFIG_PATH4, "utf-8"));
 }
 function saveConfig(updates) {
   let config = {};
-  if (existsSync48(WEB_SEARCH_CONFIG_PATH4)) {
-    config = parseConfigRoot(readFileSync50(WEB_SEARCH_CONFIG_PATH4, "utf-8"));
+  if (existsSync49(WEB_SEARCH_CONFIG_PATH4)) {
+    config = parseConfigRoot(readFileSync52(WEB_SEARCH_CONFIG_PATH4, "utf-8"));
   }
   Object.assign(config, updates);
   const dir = getWebSearchConfigDir();
-  if (!existsSync48(dir)) mkdirSync3(dir, { recursive: true });
+  if (!existsSync49(dir)) mkdirSync3(dir, { recursive: true });
   writeFileSync3(WEB_SEARCH_CONFIG_PATH4, JSON.stringify(config, null, 2) + "\n");
 }
 var DEFAULT_TOOL_NAMES = {
@@ -21771,9 +21981,9 @@ function curatorResultIndexCapacity(queryCount) {
   return queryCount * RESOLVED_SEARCH_PROVIDERS.length;
 }
 function searchProviderSchema(description, allowedProviders) {
-  return Type.Union([
+  return Type2.Union([
     StringEnum(["auto", "all", ...allowedProviders]),
-    Type.Array(StringEnum([...allowedProviders]), { minItems: 1 })
+    Type2.Array(StringEnum([...allowedProviders]), { minItems: 1 })
   ], { description });
 }
 function isToolEnabled(config, key) {
@@ -21809,6 +22019,7 @@ function resolveToolNames(config) {
   const seen = /* @__PURE__ */ new Map();
   for (const key of registeredKeys) {
     const name = names[key];
+    if (name === "web_enable") throw new Error(`toolNames.${key} in ${WEB_SEARCH_CONFIG_PATH4} 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_PATH4}`);
     seen.set(name, key);
@@ -21933,6 +22144,7 @@ async function getProviderAvailability(ctx) {
     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 {
@@ -22011,10 +22223,11 @@ var pendingCurates = /* @__PURE__ */ new Map();
 var activeCurators = /* @__PURE__ */ new Map();
 var glimpseWins = /* @__PURE__ */ new Map();
 var DEFAULT_MAX_INLINE_CONTENT_CHARS = 3e4;
+var MIN_INLINE_CONTENT_CHARS = 1e3;
 var MAX_INLINE_CONTENT_CHARS = 2e5;
 function getMaxInlineContentChars(config = loadConfig35()) {
   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);
@@ -22137,6 +22350,10 @@ function hasFullInlineCoverage(urls, inlineContent) {
 function formatFullResults(queryData) {
   let output = `## Results for: "${queryData.query}"
 
+`;
+  const providers = queryData.providers ?? (queryData.provider ? [queryData.provider] : []);
+  if (providers.length > 0) output += `**Provider${providers.length === 1 ? "" : "s"}:** ${providers.join(", ")}
+
 `;
   if (queryData.answer) {
     output += `${queryData.answer}
@@ -22147,12 +22364,33 @@ function formatFullResults(queryData) {
   }
   for (const r of queryData.results) {
     output += `### ${r.title}
-${r.url}
+${r.url}${r.snippet ? `
+
+${r.snippet}` : ""}
 
 `;
   }
   return output;
 }
+function boundSearchPresentation(text2, guidance, truncationGuidance, maxChars) {
+  const fullText = `${text2}${guidance}`;
+  if (fullText.length <= maxChars) {
+    return { text: fullText, truncated: false, originalChars: text2.length, returnedChars: text2.length, omittedChars: 0 };
+  }
+  const marker = `
+
+---
+[Output truncated.]${truncationGuidance}`;
+  const prefixLength = maxChars - marker.length;
+  const bounded = `${text2.slice(0, prefixLength)}${marker}`;
+  return {
+    text: bounded,
+    truncated: true,
+    originalChars: text2.length,
+    returnedChars: prefixLength,
+    omittedChars: text2.length - prefixLength
+  };
+}
 function abortPendingFetches() {
   for (const controller of pendingFetches.values()) {
     controller.abort();
@@ -22232,8 +22470,8 @@ function findGlimpseMjs() {
   }
   try {
     const globalRoot = execFileSync3("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
-    const entry = join9(globalRoot, "glimpseui", "src", "glimpse.mjs");
-    if (existsSync48(entry)) return entry;
+    const entry = join10(globalRoot, "glimpseui", "src", "glimpse.mjs");
+    if (existsSync49(entry)) return entry;
   } catch {
   }
   return null;
@@ -22627,6 +22865,7 @@ function index_default(pi) {
     const sc = opts.results.filter((r) => !r.error).length;
     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();
@@ -22634,6 +22873,15 @@ function index_default(pi) {
       if (opts.curated) {
         output += "[These results were manually curated by the user in the browser. Use them as-is \u2014 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]}
+
+` : `**Providers used:** ${providerNames.map((name, index) => `Query ${index + 1}: ${name}`).join("; ")}
+
+`;
       const duplicateQueries = opts.curated ? duplicateQuerySet(opts.results) : /* @__PURE__ */ new Set();
       for (const { query, answer, results, error, provider } of opts.results) {
         if (opts.queryList.length > 1) {
@@ -22658,26 +22906,35 @@ function index_default(pi) {
         urls: opts.inlineContent
       };
       pi.appendEntry("web-search-results", storeFetchedContentResult(fetchId, data));
-      if (!hasApprovedSummary) {
-        output += `---
-Full content for ${opts.inlineContent.length} sources available [${fetchId}].`;
-      }
     } else if (opts.includeContent) {
       fetchId = startBackgroundFetch(opts.urls, opts.proxy);
-      if (fetchId && !hasApprovedSummary) {
-        output += `---
-Content fetching in background [${fetchId}]. Will notify when ready.`;
-      }
     }
     const searchId = storeAndPublishSearch(opts.results);
     const isBackgroundFetch = fetchId !== null && !hasInlineReady;
-    if (getSearchContentEnabled && !hasApprovedSummary) {
-      output += `
+    const unboundedPresentation = output.trim();
+    const buildGuidance = (forTruncation) => {
+      let value = "";
+      if (hasInlineReady && opts.inlineContent && fetchId) {
+        value += `
 ---
-Results stored as responseId "${searchId}". Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0 }) to retrieve them.`;
-    }
+Full 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 += `
+---
+Content fetching in background as responseId "${fetchId}". Will notify when ready.`;
+      }
+      if (getSearchContentEnabled || forTruncation) {
+        value += `
+---
+Full 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,
@@ -22687,6 +22944,14 @@ Results stored as responseId "${searchId}". Use ${toolNames.getSearchContent}({
         fetchId,
         fetchUrls: isBackgroundFetch ? opts.urls : void 0,
         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,
@@ -23011,24 +23276,24 @@ Open manually: ${handle.url}` }],
   if (webSearchEnabled) pi.registerTool({
     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.`,
+    description: `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({
-      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 concurrently (up to three at a time), each returning source-linked search results or a provider answer. Prefer this for research \u2014 vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
-      numResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Results per query (default: 5, max: 20)" })),
-      includeContent: Type.Optional(Type.Boolean({ description: "Fetch full page content (async)" })),
-      recencyFilter: Type.Optional(
+    parameters: Type2.Object({
+      query: Type2.Optional(Type2.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
+      queries: Type2.Optional(Type2.Array(Type2.String(), { description: "Multiple queries searched concurrently (up to three at a time), each returning source-linked search results or a provider answer. Prefer this for research \u2014 vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
+      numResults: Type2.Optional(Type2.Integer({ minimum: 1, maximum: 20, description: "Results per query (default: 5, max: 20)" })),
+      includeContent: Type2.Optional(Type2.Boolean({ description: "Fetch full page content (async)" })),
+      recencyFilter: Type2.Optional(
         StringEnum(["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(searchProviderSchema(`Search provider or non-empty list of allowed providers to search simultaneously; ${allPolicyDescription}; omit this field to use the configured provider, or use auto when none is configured`, allowedSearchProviders)),
-      workflow: Type.Optional(
+      domainFilter: Type2.Optional(Type2.Array(Type2.String(), { description: "Limit to domains (prefix with - to exclude)" })),
+      provider: Type2.Optional(searchProviderSchema(`Search provider or non-empty list of allowed providers to search simultaneously; ${allPolicyDescription}; omit this field to use the configured provider, or use auto when none is configured`, allowedSearchProviders)),
+      workflow: Type2.Optional(
         StringEnum(["none", "summary-review", "auto-summary"], {
           description: "Search workflow mode: none = no curator (default), summary-review = open curator with auto summary draft, auto-summary = generate summary without opening curator"
         })
       ),
-      proxy: Type.Optional(Type.String({
+      proxy: Type2.Optional(Type2.String({
         description: "http(s) or socks proxy URL (e.g. http://host:port or socks5h://host:port) used for every outbound request in this call (search APIs and content fetches). Node fetch ignores HTTP(S)_PROXY env vars, so set this (or `proxy` in web-search.json) when direct access is blocked; empty string forces direct access."
       }))
     }),
@@ -23245,7 +23510,7 @@ Open manually: ${handle.url}` }],
             details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query }
           });
           try {
-            const { answer, results, inlineContent, provider } = await search(query, {
+            const { answer, results, inlineContent, provider, providerResponses } = await search(query, {
               provider: resolvedProvider,
               numResults: params.numResults,
               recencyFilter,
@@ -23254,7 +23519,8 @@ Open manually: ${handle.url}` }],
               signal,
               extensionContext: ctx
             });
-            return { result: { query, answer, results, error: null, provider }, inlineContent };
+            const providers = providerResponses?.map((response) => response.provider) ?? [provider];
+            return { result: { query, answer, results, error: null, provider, providers }, inlineContent };
           } catch (err) {
             if (signal?.aborted || isAbortError7(err)) throw err;
             const message = err instanceof Error ? err.message : String(err);
@@ -23524,15 +23790,15 @@ Open manually: ${handle.url}` }],
     label: "Source Check",
     description: "Gather web sources for a claim and return a bounded machine-readable research artifact with exact passage citations for manual review.",
     promptSnippet: "Gather structured source evidence and passage-level citations for manual semantic review of a claim.",
-    parameters: Type.Object({
-      claim: Type.String({ description: "The assertion to gather web sources for." }),
-      queries: Type.Optional(Type.Array(Type.String(), { description: "Search queries (default: the claim)." })),
-      numResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Results per query (default: 5, max: 20)." })),
-      fetchContent: Type.Optional(Type.Boolean({ description: "Fetch up to 5 result pages for exact passage extraction." })),
-      recencyFilter: Type.Optional(StringEnum(["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(searchProviderSchema(`Search provider or non-empty list of allowed providers to search simultaneously; ${allPolicyDescription}`, allowedSearchProviders)),
-      proxy: Type.Optional(Type.String({
+    parameters: Type2.Object({
+      claim: Type2.String({ description: "The assertion to gather web sources for." }),
+      queries: Type2.Optional(Type2.Array(Type2.String(), { description: "Search queries (default: the claim)." })),
+      numResults: Type2.Optional(Type2.Integer({ minimum: 1, maximum: 20, description: "Results per query (default: 5, max: 20)." })),
+      fetchContent: Type2.Optional(Type2.Boolean({ description: "Fetch up to 5 result pages for exact passage extraction." })),
+      recencyFilter: Type2.Optional(StringEnum(["day", "week", "month", "year"], { description: "Filter by recency." })),
+      domainFilter: Type2.Optional(Type2.Array(Type2.String(), { description: "Limit to domains; prefix with - to exclude." })),
+      provider: Type2.Optional(searchProviderSchema(`Search provider or non-empty list of allowed providers to search simultaneously; ${allPolicyDescription}`, allowedSearchProviders)),
+      proxy: Type2.Optional(Type2.String({
         description: "http(s) or socks proxy URL (e.g. http://host:port or socks5h://host:port) used for every outbound request in this call (search APIs and result-page fetches). Empty string forces direct access."
       }))
     }),
@@ -23613,38 +23879,38 @@ Open manually: ${handle.url}` }],
     label: "Fetch Content",
     description: `Fetch URL(s). Available modes: ${fetchModeDescription}. Direct image URLs return resized image content when supported by the selected mode. Supports YouTube transcripts, GitHub repositories, PDFs, and local videos when supported by the selected mode. ${fetchContentStorageNote}`,
     promptSnippet: "Use to fetch URL content, direct images, GitHub repos, and videos.",
-    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({
+    parameters: Type2.Object({
+      url: Type2.Optional(Type2.String({ description: "Single URL to fetch" })),
+      urls: Type2.Optional(Type2.Array(Type2.String(), { description: "Multiple URLs (parallel)" })),
+      forceClone: Type2.Optional(Type2.Boolean({
         description: "Force cloning large GitHub repositories that exceed the size threshold"
       })),
-      prompt: Type.Optional(Type.String({
+      prompt: Type2.Optional(Type2.String({
         description: fetchModeConfig.allowedModes.includes("answer") ? "Question or instruction for video analysis, or the page-local question required by answer mode." : "Question or instruction for video analysis."
       })),
-      mode: Type.Optional(StringEnum(fetchModeConfig.allowedModes, {
+      mode: Type2.Optional(StringEnum(fetchModeConfig.allowedModes, {
         description: `Fetch mode. ${fetchModeDescription}.`
       })),
       ...fetchModeConfig.allowedModes.includes("answer") ? {
-        answerModel: Type.Optional(Type.String({
+        answerModel: Type2.Optional(Type2.String({
           description: "Optional provider/model-id override for answer mode. Defaults to fetch.answerProvider + fetch.answerModel when configured, otherwise the current Pi model."
         }))
       } : {},
-      timestamp: Type.Optional(Type.String({
+      timestamp: Type2.Optional(Type2.String({
         description: "Extract video frame(s) at a timestamp or time range. Single: '1:23:45', '23:45', or '85' (seconds). Range: '23:41-25:00' extracts evenly-spaced frames across that span (default 6). Use frames with ranges to control density; single+frames uses a fixed 5s interval. YouTube requires yt-dlp + ffmpeg; local videos require ffmpeg. Use a range when you know the approximate area but not the exact moment \u2014 you'll get a contact sheet to visually identify the right frame."
       })),
-      frames: Type.Optional(Type.Integer({
+      frames: Type2.Optional(Type2.Integer({
         minimum: 1,
         maximum: 12,
         description: "Number of frames to extract. Use with timestamp range for custom density, with single timestamp to get N frames at 5s intervals, or alone to sample across the entire video. Requires yt-dlp + ffmpeg for YouTube, ffmpeg for local video."
       })),
-      model: Type.Optional(Type.String({
+      model: Type2.Optional(Type2.String({
         description: "Override the Gemini model for video/YouTube analysis (e.g. 'gemini-3.6-flash'). Defaults to config or gemini-3.6-flash."
       })),
-      auth: Type.Optional(Type.Union([Type.String(), Type.Boolean()], {
+      auth: Type2.Optional(Type2.Union([Type2.String(), Type2.Boolean()], {
         description: "Opt into an authFetch profile for local browser-cookie fetching. Use a profile name, or true only when exactly one profile exists."
       })),
-      proxy: Type.Optional(Type.String({
+      proxy: Type2.Optional(Type2.String({
         description: "http(s) or socks proxy URL (e.g. http://host:port or socks5h://host:port) used for this fetch. Needed when the target is unreachable directly; localhost and NO_PROXY hosts always bypass the proxy. Empty string forces direct access."
       }))
     }),
@@ -23924,21 +24190,21 @@ Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 })
     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({
-        responseId: Type.String({ description: `The responseId from ${storedContentSources}` }),
-        query: Type.Optional(Type.String({ description: searchQueryDescription })),
-        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." })),
-        findText: Type.Optional(Type.Union([
-          Type.String({ minLength: 1, maxLength: 500 }),
-          Type.Array(Type.String({ minLength: 1, maxLength: 500 }), { minItems: 1, maxItems: 10 })
+      parameters: Type2.Object({
+        responseId: Type2.String({ description: `The responseId from ${storedContentSources}` }),
+        query: Type2.Optional(Type2.String({ description: searchQueryDescription })),
+        queryIndex: Type2.Optional(Type2.Integer({ minimum: 0, description: "Get content for query at index" })),
+        url: Type2.Optional(Type2.String({ description: "Get content for this URL" })),
+        urlIndex: Type2.Optional(Type2.Integer({ minimum: 0, description: "Get content for URL at index" })),
+        offset: Type2.Optional(Type2.Integer({ minimum: 0, description: "Character offset in stored search or fetched URL content (default 0). Ignored when findText is supplied." })),
+        limit: Type2.Optional(Type2.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: Type2.Optional(Type2.Union([
+          Type2.String({ minLength: 1, maxLength: 500 }),
+          Type2.Array(Type2.String({ minLength: 1, maxLength: 500 }), { minItems: 1, maxItems: 10 })
         ], { description: "Text or texts to find in the selected stored content. When supplied, offset and limit are ignored." })),
-        findMode: Type.Optional(StringEnum(["exact", "case-insensitive", "fuzzy"], { description: "Matching mode for findText (default: case-insensitive). Requires findText." }))
+        findMode: Type2.Optional(StringEnum(["exact", "case-insensitive", "fuzzy"], { description: "Matching mode for findText (default: case-insensitive). Requires findText." }))
       }),
       async execute(_toolCallId, rawParams) {
         const params = normalizeGetSearchContentParams(rawParams);
@@ -24045,10 +24311,10 @@ Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 })
           if (params.findText !== void 0) {
             try {
               const found = findContent(fullResults, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
-              const { text: text2, ...findDetails } = found;
+              const { text: text3, ...findDetails } = found;
               return {
-                content: [{ type: "text", text: text2 }],
-                details: { query: queryData.query, resultCount: queryData.results.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
+                content: [{ type: "text", text: text3 }],
+                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);
@@ -24058,9 +24324,56 @@ Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 })
               };
             }
           }
+          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 = `
+
+---
+Showing 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 text2 = `${resultSlice}${hasMore ? continuation : ""}`;
           return {
-            content: [{ type: "text", text: fullResults }],
-            details: { query: queryData.query, resultCount: queryData.results.length }
+            content: [{ type: "text", text: text2 }],
+            details: {
+              responseId: params.responseId,
+              query: queryData.query,
+              resultCount: queryData.results.length,
+              contentLength: fullResults.length,
+              offset,
+              limit,
+              returnedChars,
+              nextOffset: hasMore ? endOffset : null,
+              truncated: hasMore
+            }
           };
         }
         if (data.type === "fetch" && data.urls) {
@@ -24222,6 +24535,13 @@ Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
       }
     });
   }
+  const activationTools = [
+    ...webSearchEnabled ? [{ name: toolNames.webSearch, capability: "search" }] : [],
+    ...sourceCheckEnabled ? [{ name: toolNames.sourceCheck, capability: "source-check" }] : [],
+    ...fetchContentEnabled ? [{ name: toolNames.fetchContent, capability: "fetch" }] : [],
+    ...getSearchContentEnabled ? [{ name: toolNames.getSearchContent, capability: "stored-content" }] : []
+  ];
+  registerWebToolActivation(pi, activationTools);
   if (isCommandEnabled(initConfig, "websearch")) pi.registerCommand("websearch", {
     description: "Open web search curator",
     handler: async (args, ctx) => {