privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-C4IV7ZFG.mjs

@@ -0,0 +1,717 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  GITHUB_TOKEN_ENV_VAR,
+  GitHubInterceptor,
+  PROVIDERS,
+  buildInterceptors,
+  createSearchProvider,
+  getActiveGitHubInterceptor,
+  getConfigPath,
+  getInterceptors,
+  parseGitHubUrl,
+  readConfig,
+  resolveGitHubOptions,
+  validateGuidanceFields,
+  writeConfig
+} from "./c-6FUXKHOK.mjs";
+import "./c-B2Y7VNHU.mjs";
+import "./c-SKMK3PEE.mjs";
+import "./c-I54OKQHW.mjs";
+import "./c-UPBH5AXY.mjs";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  truncateHead
+} from "./c-7UOG7POX.mjs";
+import "./c-E4Z3Y5B5.mjs";
+import "./c-6ZO2SADQ.mjs";
+import "./c-JKTFXTGF.mjs";
+import "./c-CRBXNKFO.mjs";
+import "./c-KP6CRIP4.mjs";
+import "./c-RSKCUPJF.mjs";
+import "./c-PTN4S6G2.mjs";
+import "./c-P6N5DQGZ.mjs";
+import "./c-6LOBR4I6.mjs";
+import "./c-3STKRSVO.mjs";
+import "./c-YRDO2WEF.mjs";
+import "./c-BHNIF2AR.mjs";
+import "./c-ABXULAFL.mjs";
+import "./c-2G3BBHRJ.mjs";
+import "./c-O5PP6CTX.mjs";
+import "./c-CDBEJSBF.mjs";
+import "./c-DEE67DJO.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import {
+  Text
+} from "./c-EQBKXWNX.mjs";
+import {
+  typebox_exports
+} from "./c-RQJJ26T4.mjs";
+import "./c-L5GHWG5G.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@juicesharp/rpiv-web-tools/web-tools.ts?ext=privateer-web
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/fetch-helpers.ts?ext=privateer-web
+var USER_AGENT = "Mozilla/5.0 (compatible; rpiv-pi/1.0)";
+var FETCH_ACCEPT_HEADER = "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.5";
+var BINARY_CONTENT_TYPE_PREFIXES = ["image/", "video/", "audio/"];
+var HTML_CONTENT_TYPE_TOKEN = "text/html";
+var SCRIPT_BLOCK_REGEX = /<script[\s\S]*?<\/script>/gi;
+var STYLE_BLOCK_REGEX = /<style[\s\S]*?<\/style>/gi;
+var NOSCRIPT_BLOCK_REGEX = /<noscript[\s\S]*?<\/noscript>/gi;
+var BLOCK_CLOSER_REGEX = /<\/(p|div|h[1-6]|li|tr|br|blockquote|pre|section|article|header|footer|nav|details|summary)>/gi;
+var SELF_CLOSING_BR_REGEX = /<br\s*\/?>/gi;
+var ANY_REMAINING_TAG_REGEX = /<[^>]+>/g;
+var TITLE_TAG_REGEX = /<title[^>]*>([\s\S]*?)<\/title>/i;
+var NUMERIC_HTML_ENTITY_REGEX = /&#(\d+);/g;
+var HORIZONTAL_WHITESPACE_RUN = /[ \t]+/g;
+var BLANK_LINE_RUN = /\n{3,}/g;
+function stripNonContentBlocks(html) {
+  return html.replace(SCRIPT_BLOCK_REGEX, "").replace(STYLE_BLOCK_REGEX, "").replace(NOSCRIPT_BLOCK_REGEX, "");
+}
+__name(stripNonContentBlocks, "stripNonContentBlocks");
+function convertBlockTagsToNewlines(text) {
+  return text.replace(BLOCK_CLOSER_REGEX, "\n").replace(SELF_CLOSING_BR_REGEX, "\n");
+}
+__name(convertBlockTagsToNewlines, "convertBlockTagsToNewlines");
+function stripRemainingTags(text) {
+  return text.replace(ANY_REMAINING_TAG_REGEX, " ");
+}
+__name(stripRemainingTags, "stripRemainingTags");
+function decodeHtmlEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(NUMERIC_HTML_ENTITY_REGEX, (_, code) => String.fromCharCode(Number(code)));
+}
+__name(decodeHtmlEntities, "decodeHtmlEntities");
+function collapseWhitespace(text) {
+  return text.replace(HORIZONTAL_WHITESPACE_RUN, " ").replace(BLANK_LINE_RUN, "\n\n");
+}
+__name(collapseWhitespace, "collapseWhitespace");
+function htmlToText(html) {
+  let text = stripNonContentBlocks(html);
+  text = convertBlockTagsToNewlines(text);
+  text = stripRemainingTags(text);
+  text = decodeHtmlEntities(text);
+  text = collapseWhitespace(text);
+  return text.trim();
+}
+__name(htmlToText, "htmlToText");
+function extractTitle(html) {
+  const match = html.match(TITLE_TAG_REGEX);
+  if (!match) return void 0;
+  return match[1].replace(ANY_REMAINING_TAG_REGEX, "").trim() || void 0;
+}
+__name(extractTitle, "extractTitle");
+function isHtmlContentType(contentType) {
+  return contentType.includes(HTML_CONTENT_TYPE_TOKEN);
+}
+__name(isHtmlContentType, "isHtmlContentType");
+function assertTextContentType(contentType) {
+  if (BINARY_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.includes(prefix))) {
+    throw new Error(`Unsupported content type: ${contentType}. web_fetch supports text pages only.`);
+  }
+}
+__name(assertTextContentType, "assertTextContentType");
+function buildFetchRequestInit(signal) {
+  return {
+    signal,
+    redirect: "follow",
+    headers: { "User-Agent": USER_AGENT, Accept: FETCH_ACCEPT_HEADER }
+  };
+}
+__name(buildFetchRequestInit, "buildFetchRequestInit");
+async function fetchUrlOrThrow(url, signal) {
+  const res = await fetch(url, buildFetchRequestInit(signal));
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} for ${url}`);
+  }
+  return res;
+}
+__name(fetchUrlOrThrow, "fetchUrlOrThrow");
+async function extractBodyAsText(res, contentType, raw) {
+  const body = await res.text();
+  if (!raw && isHtmlContentType(contentType)) {
+    return { text: htmlToText(body), title: extractTitle(body) };
+  }
+  return { text: body };
+}
+__name(extractBodyAsText, "extractBodyAsText");
+async function fetchViaGenericHtml(url, raw, signal) {
+  const res = await fetchUrlOrThrow(url, signal);
+  const contentType = res.headers.get("content-type") ?? "";
+  assertTextContentType(contentType);
+  const { text, title } = await extractBodyAsText(res, contentType, raw);
+  const contentLengthHeader = res.headers.get("content-length");
+  return {
+    text,
+    title,
+    contentType: contentType || void 0,
+    contentLength: contentLengthHeader ? Number(contentLengthHeader) : void 0
+  };
+}
+__name(fetchViaGenericHtml, "fetchViaGenericHtml");
+
+// node_modules/@juicesharp/rpiv-web-tools/web-tools.ts?ext=privateer-web
+var MIN_SEARCH_RESULTS = 1;
+var MAX_SEARCH_RESULTS = 10;
+var DEFAULT_SEARCH_RESULTS = 5;
+var SEARCH_RESULT_PREVIEW_LIMIT = 5;
+var FETCH_PREVIEW_LINE_LIMIT = 15;
+var API_KEY_MASK_VISIBLE_CHARS = 4;
+var FETCH_TEMP_DIR_PREFIX = "rpiv-fetch-";
+var FETCH_TEMP_FILE_NAME = "content.txt";
+var CONFIG_PATH = getConfigPath();
+var SUPPORTED_HTTP_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var WEB_TOOLS_COMMAND_NAME = "web-tools";
+var SHOW_FLAG = "--show";
+var UNSET_LABEL = "(not set)";
+var DEFAULT_PROVIDER_NAME = "brave";
+var LEGACY_TOP_LEVEL_KEY_PROVIDER = "brave";
+var loadConfig = readConfig;
+var saveConfig = writeConfig;
+var DEFAULT_WEB_SEARCH_SNIPPET = "Search the web for up-to-date information";
+var DEFAULT_WEB_SEARCH_GUIDELINES = [
+  "Use web_search for information beyond your training data \u2014 recent events, current library versions, live API documentation.",
+  'Use the current year from "Current date:" in your context when searching for recent information or documentation.',
+  'After answering using search results, include a "Sources:" section listing relevant URLs as markdown hyperlinks: [Title](URL). Never skip this.',
+  "Domain filtering is supported to include or block specific websites.",
+  "If no API key is configured, ask the user to run /web-tools before proceeding."
+];
+var DEFAULT_WEB_FETCH_SNIPPET = "Fetch and read content from a specific URL";
+var DEFAULT_WEB_FETCH_GUIDELINES = [
+  "Use web_fetch to read the full content of a specific URL \u2014 documentation pages, blog posts, API references found via web_search.",
+  "web_fetch is complementary to web_search: search finds URLs, fetch reads them.",
+  'After answering using fetched content, include a "Sources:" section with a markdown hyperlink to the fetched URL.',
+  "Large responses are truncated and spilled to a temp file \u2014 the temp path is reported in the result details."
+];
+function resolveProviderApiKey(providerName, config) {
+  const meta = PROVIDERS.find((p) => p.name === providerName);
+  if (!meta) return void 0;
+  const envKey = meta.envVar ? process.env[meta.envVar]?.trim() : void 0;
+  if (envKey) return envKey;
+  const configKey = config.apiKeys?.[providerName]?.trim();
+  if (configKey) return configKey;
+  if (providerName === LEGACY_TOP_LEVEL_KEY_PROVIDER) {
+    return config.apiKey?.trim() || void 0;
+  }
+  return void 0;
+}
+__name(resolveProviderApiKey, "resolveProviderApiKey");
+function resolveProviderBaseUrl(meta, config) {
+  if (!meta.baseUrlEnvVar) return "";
+  const envUrl = process.env[meta.baseUrlEnvVar]?.trim();
+  if (envUrl) return envUrl;
+  const configUrl = config.baseUrls?.[meta.name]?.trim();
+  if (configUrl) return configUrl;
+  return meta.defaultBaseUrl ?? "";
+}
+__name(resolveProviderBaseUrl, "resolveProviderBaseUrl");
+var KNOWN_PROVIDER_NAMES = PROVIDERS.map((p) => p.name);
+function isProviderConfigured(meta, config) {
+  if (meta.baseUrlEnvVar) {
+    return Boolean(process.env[meta.baseUrlEnvVar]?.trim() || config.baseUrls?.[meta.name]?.trim());
+  }
+  return resolveProviderApiKey(meta.name, config) !== void 0;
+}
+__name(isProviderConfigured, "isProviderConfigured");
+function getVisibleProviderNames(config) {
+  const active = resolveActiveProviderName(config);
+  const configured = PROVIDERS.filter((meta) => isProviderConfigured(meta, config)).map((meta) => meta.name);
+  const names = configured.filter((name) => name !== active.name);
+  if (KNOWN_PROVIDER_NAMES.includes(active.name)) names.unshift(active.name);
+  if (names.length === 0) names.push(DEFAULT_PROVIDER_NAME);
+  return { active, names };
+}
+__name(getVisibleProviderNames, "getVisibleProviderNames");
+function providerSelectionDescription(names, active) {
+  return `Search provider to use for this call only, overriding the active provider set via /web-tools. Configured providers: ${names.join(", ")}. Default provider: ${active.name} (source: ${active.source}). Omit to use the configured active provider. The named provider must have its API key/URL configured or the call throws.`;
+}
+__name(providerSelectionDescription, "providerSelectionDescription");
+function assertKnownProvider(name) {
+  if (!KNOWN_PROVIDER_NAMES.includes(name)) {
+    throw new Error(`Unknown web_search provider: "${name}". Valid providers: ${KNOWN_PROVIDER_NAMES.join(", ")}.`);
+  }
+}
+__name(assertKnownProvider, "assertKnownProvider");
+function resolveActiveProviderName(config) {
+  const envProvider = process.env.WEB_SEARCH_PROVIDER?.trim();
+  if (envProvider) return { name: envProvider, source: "env" };
+  if (config.provider) return { name: config.provider, source: "config" };
+  return { name: DEFAULT_PROVIDER_NAME, source: "default" };
+}
+__name(resolveActiveProviderName, "resolveActiveProviderName");
+function instantiateProvider(config, override) {
+  let providerName;
+  if (override !== void 0) {
+    assertKnownProvider(override);
+    providerName = override;
+  } else {
+    const active = resolveActiveProviderName(config);
+    if (active.source === "env") assertKnownProvider(active.name);
+    providerName = active.name;
+  }
+  const apiKey = resolveProviderApiKey(providerName, config);
+  const meta = PROVIDERS.find((p) => p.name === providerName);
+  const baseUrl = meta?.baseUrlEnvVar ? resolveProviderBaseUrl(meta, config) : void 0;
+  const provider = createSearchProvider(providerName, { apiKey: apiKey ?? "", baseUrl });
+  return { providerName, provider };
+}
+__name(instantiateProvider, "instantiateProvider");
+function maskApiKey(key) {
+  if (!key) return UNSET_LABEL;
+  const head = key.slice(0, API_KEY_MASK_VISIBLE_CHARS);
+  const tail = key.slice(-API_KEY_MASK_VISIBLE_CHARS);
+  return `${head}...${tail}`;
+}
+__name(maskApiKey, "maskApiKey");
+function clampSearchResultCount(requested) {
+  const value = requested ?? DEFAULT_SEARCH_RESULTS;
+  return Math.min(Math.max(value, MIN_SEARCH_RESULTS), MAX_SEARCH_RESULTS);
+}
+__name(clampSearchResultCount, "clampSearchResultCount");
+function isPrivateOrLoopbackHostname(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h.endsWith(".localhost")) return true;
+  if (h === "::1" || h === "::" || h.startsWith("fe80:") || h.startsWith("fc") || h.startsWith("fd")) return true;
+  const v4 = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!v4) return false;
+  const [a, b] = [Number(v4[1]), Number(v4[2])];
+  if (a === 0 || a === 127 || a === 10) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+__name(isPrivateOrLoopbackHostname, "isPrivateOrLoopbackHostname");
+function parseAndAssertHttpUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`Invalid URL: ${raw}`);
+  }
+  if (!SUPPORTED_HTTP_PROTOCOLS.has(parsed.protocol)) {
+    throw new Error(`Unsupported URL protocol: ${parsed.protocol}. Only http and https are supported.`);
+  }
+  if (isPrivateOrLoopbackHostname(parsed.hostname)) {
+    throw new Error(`Refusing to fetch private/loopback address: ${parsed.hostname}`);
+  }
+  return parsed;
+}
+__name(parseAndAssertHttpUrl, "parseAndAssertHttpUrl");
+async function spillFullContentToTempFile(content) {
+  const tempDir = await mkdtemp(join(tmpdir(), FETCH_TEMP_DIR_PREFIX));
+  const tempFile = join(tempDir, FETCH_TEMP_FILE_NAME);
+  await writeFile(tempFile, content, "utf8");
+  return tempFile;
+}
+__name(spillFullContentToTempFile, "spillFullContentToTempFile");
+function formatTruncationFooter(truncation, tempFile) {
+  const truncatedLines = truncation.totalLines - truncation.outputLines;
+  const truncatedBytes = truncation.totalBytes - truncation.outputBytes;
+  return `
+
+[Content truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}). ${truncatedLines} lines (${formatSize(truncatedBytes)}) omitted. Full content saved to: ${tempFile}]`;
+}
+__name(formatTruncationFooter, "formatTruncationFooter");
+function formatFetchHeader(url, title, contentType) {
+  const lines = [`**Fetched:** ${url}`];
+  if (title) lines.push(`**Title:** ${title}`);
+  if (contentType) lines.push(`**Content-Type:** ${contentType}`);
+  return `${lines.join("\n")}
+
+`;
+}
+__name(formatFetchHeader, "formatFetchHeader");
+function formatSearchResultsBody(response) {
+  let text = `**Search results for "${response.query}":**
+
+`;
+  response.results.forEach((r, i) => {
+    text += `${i + 1}. **${r.title}**
+   ${r.url}
+   ${r.snippet}
+
+`;
+  });
+  return text.trimEnd();
+}
+__name(formatSearchResultsBody, "formatSearchResultsBody");
+function buildEmptyResultsEnvelope(query, providerName) {
+  return {
+    content: [{ type: "text", text: `No results found for "${query}".` }],
+    details: { query, backend: providerName, resultCount: 0 }
+  };
+}
+__name(buildEmptyResultsEnvelope, "buildEmptyResultsEnvelope");
+function registerWebSearchTool(pi) {
+  const config = loadConfig();
+  const guidance = validateGuidanceFields(config.guidance?.web_search);
+  const visibleProviders = getVisibleProviderNames(config);
+  pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description: "Search the web for information. Returns a list of results with titles, URLs, and snippets. Use when you need current information not in your training data.",
+    promptSnippet: guidance.promptSnippet ?? DEFAULT_WEB_SEARCH_SNIPPET,
+    promptGuidelines: guidance.promptGuidelines ?? DEFAULT_WEB_SEARCH_GUIDELINES,
+    parameters: typebox_exports.Object({
+      query: typebox_exports.String({
+        description: "The search query. Be specific and use natural language."
+      }),
+      max_results: typebox_exports.Optional(
+        typebox_exports.Number({
+          description: `Maximum number of results to return (${MIN_SEARCH_RESULTS}-${MAX_SEARCH_RESULTS}). Default: ${DEFAULT_SEARCH_RESULTS}.`,
+          default: DEFAULT_SEARCH_RESULTS,
+          minimum: MIN_SEARCH_RESULTS,
+          maximum: MAX_SEARCH_RESULTS
+        })
+      ),
+      provider: typebox_exports.Optional(
+        typebox_exports.Union(
+          visibleProviders.names.map((name) => typebox_exports.Literal(name)),
+          { description: providerSelectionDescription(visibleProviders.names, visibleProviders.active) }
+        )
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+      const maxResults = clampSearchResultCount(params.max_results);
+      const config2 = loadConfig();
+      const { providerName, provider } = instantiateProvider(config2, params.provider);
+      onUpdate?.({
+        content: [{ type: "text", text: `Searching ${provider.label} for: "${params.query}"...` }],
+        details: { query: params.query, backend: providerName, resultCount: 0 }
+      });
+      const response = await provider.search(params.query, maxResults, signal);
+      if (response.results.length === 0) {
+        return buildEmptyResultsEnvelope(params.query, providerName);
+      }
+      return {
+        content: [{ type: "text", text: formatSearchResultsBody(response) }],
+        details: {
+          query: params.query,
+          backend: providerName,
+          resultCount: response.results.length,
+          results: response.results
+        }
+      };
+    },
+    renderCall(args, theme, _context) {
+      let text = theme.fg("toolTitle", theme.bold("WebSearch "));
+      text += theme.fg("accent", `"${args.query}"`);
+      if (args.provider) {
+        text += theme.fg("dim", ` via ${args.provider}`);
+      }
+      return new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme, _context) {
+      if (isPartial) {
+        return new Text(theme.fg("warning", "Searching..."), 0, 0);
+      }
+      const details = result.details;
+      const count = details?.resultCount ?? 0;
+      let text = theme.fg("success", `\u2713 ${count} result${count !== 1 ? "s" : ""}`);
+      if (expanded && details?.results) {
+        text += renderSearchResultsPreview(details.results, theme);
+      }
+      return new Text(text, 0, 0);
+    }
+  });
+}
+__name(registerWebSearchTool, "registerWebSearchTool");
+function renderSearchResultsPreview(results, theme) {
+  let text = "";
+  for (const r of results.slice(0, SEARCH_RESULT_PREVIEW_LIMIT)) {
+    text += `
+  ${theme.fg("dim", `\u2022 ${r.title}`)}`;
+  }
+  if (results.length > SEARCH_RESULT_PREVIEW_LIMIT) {
+    text += `
+  ${theme.fg("dim", `... and ${results.length - SEARCH_RESULT_PREVIEW_LIMIT} more`)}`;
+  }
+  return text;
+}
+__name(renderSearchResultsPreview, "renderSearchResultsPreview");
+function registerWebFetchTool(pi) {
+  const guidance = validateGuidanceFields(loadConfig().guidance?.web_fetch);
+  pi.registerTool({
+    name: "web_fetch",
+    label: "Web Fetch",
+    description: "Fetch the content of a specific URL. Returns text content for HTML pages (tags stripped), raw text for plain text or JSON. Supports http and https only. Content is truncated to avoid overwhelming the context window.",
+    promptSnippet: guidance.promptSnippet ?? DEFAULT_WEB_FETCH_SNIPPET,
+    promptGuidelines: guidance.promptGuidelines ?? DEFAULT_WEB_FETCH_GUIDELINES,
+    parameters: typebox_exports.Object({
+      url: typebox_exports.String({
+        description: "The URL to fetch. Must be http or https."
+      }),
+      raw: typebox_exports.Optional(
+        typebox_exports.Boolean({
+          description: "If true, return the raw HTML instead of extracted text. Default: false.",
+          default: false
+        })
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+      const { url, raw = false } = params;
+      parseAndAssertHttpUrl(url);
+      onUpdate?.({
+        content: [{ type: "text", text: `Fetching: ${url}...` }],
+        details: { url }
+      });
+      const config = loadConfig();
+      const { provider } = instantiateProvider(config);
+      let fetchResponse;
+      for (const interceptor of getInterceptors()) {
+        const r = await interceptor.intercept(url, { raw, signal });
+        if (r) {
+          fetchResponse = r;
+          break;
+        }
+      }
+      if (!fetchResponse && "fetch" in provider) {
+        fetchResponse = await provider.fetch(url, raw, signal);
+      }
+      if (!fetchResponse) {
+        fetchResponse = await fetchViaGenericHtml(url, raw, signal);
+      }
+      const { text: bodyText, title, contentType, contentLength } = fetchResponse;
+      const truncation = truncateHead(bodyText, {
+        maxLines: DEFAULT_MAX_LINES,
+        maxBytes: DEFAULT_MAX_BYTES
+      });
+      const details = {
+        url,
+        title,
+        contentType,
+        contentLength
+      };
+      let output = truncation.content;
+      if (truncation.truncated) {
+        const tempFile = await spillFullContentToTempFile(bodyText);
+        details.truncation = truncation;
+        details.fullOutputPath = tempFile;
+        output += formatTruncationFooter(truncation, tempFile);
+      }
+      return {
+        content: [{ type: "text", text: formatFetchHeader(url, title, contentType ?? "") + output }],
+        details
+      };
+    },
+    renderCall(args, theme, _context) {
+      let text = theme.fg("toolTitle", theme.bold("WebFetch "));
+      text += theme.fg("accent", args.url);
+      return new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme, _context) {
+      if (isPartial) {
+        return new Text(theme.fg("warning", "Fetching..."), 0, 0);
+      }
+      const details = result.details;
+      let text = theme.fg("success", "\u2713 Fetched");
+      if (details?.title) text += theme.fg("muted", `: ${details.title}`);
+      if (details?.truncation?.truncated) text += theme.fg("warning", " (truncated)");
+      if (expanded) {
+        const content = result.content[0];
+        if (content?.type === "text") {
+          text += renderFetchedContentPreview(content.text, theme);
+        }
+      }
+      return new Text(text, 0, 0);
+    }
+  });
+}
+__name(registerWebFetchTool, "registerWebFetchTool");
+function renderFetchedContentPreview(content, theme) {
+  const lines = content.split("\n");
+  const visible = lines.slice(0, FETCH_PREVIEW_LINE_LIMIT);
+  let text = "";
+  for (const line of visible) {
+    text += `
+  ${theme.fg("dim", line)}`;
+  }
+  if (lines.length > FETCH_PREVIEW_LINE_LIMIT) {
+    text += `
+  ${theme.fg("muted", "... (use read tool to see full content)")}`;
+  }
+  return text;
+}
+__name(renderFetchedContentPreview, "renderFetchedContentPreview");
+function formatShowConfigMessage(current) {
+  const lines = ["Web search config:", `  config file: ${CONFIG_PATH}`];
+  const { name: providerName, source: providerSource } = resolveActiveProviderName(current);
+  lines.push(`  active provider: ${providerName} (source: ${providerSource})`);
+  for (const meta of PROVIDERS) {
+    const envKey = meta.envVar ? process.env[meta.envVar]?.trim() : void 0;
+    const configKey = current.apiKeys?.[meta.name]?.trim();
+    const legacyKey = meta.name === LEGACY_TOP_LEVEL_KEY_PROVIDER ? current.apiKey?.trim() : void 0;
+    const resolved = envKey ?? configKey ?? legacyKey;
+    lines.push(
+      `  ${meta.name}: ${maskApiKey(resolved)} (env: ${maskApiKey(envKey)}, config: ${maskApiKey(configKey ?? legacyKey)})`
+    );
+  }
+  for (const meta of PROVIDERS) {
+    if (!meta.baseUrlEnvVar) continue;
+    const envUrl = process.env[meta.baseUrlEnvVar]?.trim();
+    const configUrl = current.baseUrls?.[meta.name]?.trim();
+    const resolvedUrl = envUrl || configUrl || meta.defaultBaseUrl || "";
+    const urlSource = envUrl ? "env" : configUrl ? "config" : "default";
+    lines.push(`  ${meta.name} url: ${resolvedUrl} (source: ${urlSource})`);
+  }
+  lines.push("");
+  lines.push("URL interceptors:");
+  const githubInterceptor = getActiveGitHubInterceptor();
+  if (githubInterceptor) {
+    const opts = githubInterceptor.resolvedOptions;
+    const token = process.env[GITHUB_TOKEN_ENV_VAR]?.trim();
+    lines.push(
+      `  github: enabled (${GITHUB_TOKEN_ENV_VAR}: ${maskApiKey(token)}, maxRepoSizeMB: ${opts.maxRepoSizeMB}, clonePath: ${opts.clonePath})`
+    );
+  } else {
+    lines.push("  github: disabled");
+    lines.push('  \u21B3 enable:  add  "interceptors": { "github": true }   to config.json');
+    lines.push('  \u21B3 disable: set  "interceptors": { "github": false }  to override a consumer-enabled default');
+  }
+  return lines.join("\n");
+}
+__name(formatShowConfigMessage, "formatShowConfigMessage");
+function refreshWebSearchSchema(pi) {
+  registerWebSearchTool(pi);
+}
+__name(refreshWebSearchSchema, "refreshWebSearchSchema");
+function registerWebSearchConfigCommand(pi) {
+  pi.registerCommand(WEB_TOOLS_COMMAND_NAME, {
+    description: "Configure the search provider and API key used by web_search",
+    handler: /* @__PURE__ */ __name(async (args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui?.notify?.(`/${WEB_TOOLS_COMMAND_NAME} requires interactive mode`, "error");
+        return;
+      }
+      const current = loadConfig();
+      if (typeof args === "string" && args.includes(SHOW_FLAG)) {
+        ctx.ui.notify(formatShowConfigMessage(current), "info");
+        return;
+      }
+      const activeProvider = resolveActiveProviderName(current).name;
+      const orderedMetas = [
+        ...PROVIDERS.filter((p) => p.name === activeProvider),
+        ...PROVIDERS.filter((p) => p.name !== activeProvider)
+      ];
+      const hasKey = /* @__PURE__ */ __name((p) => isProviderConfigured(p, current), "hasKey");
+      const labelOf = /* @__PURE__ */ __name((p) => {
+        const markers = [];
+        if (p.name === activeProvider) markers.push("\u2713");
+        if (hasKey(p)) markers.push("(configured)");
+        return markers.length > 0 ? `${p.label} ${markers.join(" ")}` : p.label;
+      }, "labelOf");
+      const selectedLabel = await ctx.ui.select("Search provider", orderedMetas.map(labelOf), {});
+      if (selectedLabel === void 0 || selectedLabel === null) {
+        ctx.ui.notify("Web search config unchanged", "info");
+        return;
+      }
+      const selectedMeta = PROVIDERS.find(
+        (p) => selectedLabel === p.label || selectedLabel.startsWith(`${p.label} `)
+      );
+      if (!selectedMeta) {
+        ctx.ui.notify("Web search config unchanged", "info");
+        return;
+      }
+      const selectedProvider = selectedMeta.name;
+      if (selectedMeta.configure) {
+        const result = await selectedMeta.configure(ctx.ui, {
+          baseUrl: current.baseUrls?.[selectedProvider],
+          apiKey: current.apiKeys?.[selectedProvider]
+        });
+        if (!result) {
+          ctx.ui.notify("Web search config unchanged", "info");
+          return;
+        }
+        const toSave2 = {
+          ...current,
+          provider: selectedProvider,
+          ...result.baseUrl !== void 0 && {
+            baseUrls: { ...current.baseUrls, [selectedProvider]: result.baseUrl }
+          },
+          ...result.apiKey ? { apiKeys: { ...current.apiKeys, [selectedProvider]: result.apiKey } } : {}
+        };
+        delete toSave2.apiKey;
+        if (!saveConfig(toSave2)) {
+          ctx.ui.notify(
+            `Failed to save ${selectedMeta.label} config to ${CONFIG_PATH} \u2014 disk write failed`,
+            "error"
+          );
+          return;
+        }
+        refreshWebSearchSchema(pi);
+        ctx.ui.notify(
+          result.baseUrl ? `Saved ${selectedMeta.label} config (url: ${result.baseUrl}) to ${CONFIG_PATH}` : `Saved ${selectedMeta.label} config to ${CONFIG_PATH}`,
+          "info"
+        );
+        return;
+      }
+      const existingKey = current.apiKeys?.[selectedProvider] ?? (selectedProvider === LEGACY_TOP_LEVEL_KEY_PROVIDER ? current.apiKey : void 0);
+      const input = await ctx.ui.input(
+        `${selectedMeta.label} API key`,
+        existingKey ? `Press Enter to keep current (${maskApiKey(existingKey)}), or type new key` : "..."
+      );
+      if (input === void 0 || input === null) {
+        ctx.ui.notify("Web search config unchanged", "info");
+        return;
+      }
+      const trimmed = input.trim();
+      const keyToWrite = trimmed || existingKey;
+      if (!keyToWrite) {
+        ctx.ui.notify("Web search config unchanged", "info");
+        return;
+      }
+      const toSave = {
+        ...current,
+        provider: selectedProvider,
+        apiKeys: { ...current.apiKeys, [selectedProvider]: keyToWrite }
+      };
+      delete toSave.apiKey;
+      if (!saveConfig(toSave)) {
+        ctx.ui.notify(
+          `Failed to save ${selectedMeta.label} API key to ${CONFIG_PATH} \u2014 disk write failed`,
+          "error"
+        );
+        return;
+      }
+      refreshWebSearchSchema(pi);
+      ctx.ui.notify(
+        trimmed ? `Saved ${selectedMeta.label} API key to ${CONFIG_PATH}` : `Active provider set to ${selectedMeta.label}; existing key kept`,
+        "info"
+      );
+    }, "handler")
+  });
+}
+__name(registerWebSearchConfigCommand, "registerWebSearchConfigCommand");
+
+// node_modules/@juicesharp/rpiv-web-tools/index.ts?ext=privateer-web
+function registerWebTools(pi, opts) {
+  buildInterceptors(opts?.interceptors);
+  registerWebSearchTool(pi);
+  registerWebFetchTool(pi);
+  registerWebSearchConfigCommand(pi);
+}
+__name(registerWebTools, "registerWebTools");
+export {
+  DEFAULT_WEB_FETCH_GUIDELINES,
+  DEFAULT_WEB_FETCH_SNIPPET,
+  DEFAULT_WEB_SEARCH_GUIDELINES,
+  DEFAULT_WEB_SEARCH_SNIPPET,
+  GITHUB_TOKEN_ENV_VAR,
+  GitHubInterceptor,
+  createSearchProvider,
+  registerWebTools as default,
+  parseGitHubUrl,
+  registerWebFetchTool,
+  registerWebSearchConfigCommand,
+  registerWebSearchTool,
+  resolveGitHubOptions
+};