pi-web-providers 0.1.0

package/dist/index.js

@@ -0,0 +1,2802 @@
+// src/index.ts
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  keyHint,
+  truncateHead
+} from "@mariozechner/pi-coding-agent";
+import { StringEnum } from "@mariozechner/pi-ai";
+import {
+  Editor,
+  Key,
+  Text,
+  getEditorKeybindings,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/config.ts
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { execSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+// src/provider-tools.ts
+var PROVIDER_TOOLS = {
+  codex: ["search"],
+  exa: ["search", "contents", "answer", "research"],
+  gemini: ["search", "answer", "research"],
+  parallel: ["search", "contents"],
+  valyu: ["search", "contents", "answer", "research"]
+};
+var PROVIDER_TOOL_META = {
+  search: {
+    label: "Search",
+    help: "Enable the provider's search tool."
+  },
+  contents: {
+    label: "Contents",
+    help: "Enable the provider's content extraction tool."
+  },
+  answer: {
+    label: "Answer",
+    help: "Enable the provider's answer generation tool."
+  },
+  research: {
+    label: "Research",
+    help: "Enable the provider's long-form research tool."
+  }
+};
+function supportsProviderTool(providerId, toolId) {
+  return PROVIDER_TOOLS[providerId].includes(toolId);
+}
+function isProviderToolEnabled(providerId, config, toolId) {
+  if (!supportsProviderTool(providerId, toolId)) {
+    return false;
+  }
+  const tools = config?.tools;
+  return tools?.[toolId] ?? true;
+}
+
+// src/config.ts
+var LEGACY_TOOL_ALIASES = {
+  exa: {
+    websetsPreview: null
+  },
+  valyu: {
+    deepResearch: "research"
+  }
+};
+var CONFIG_FILE_NAME = "web-providers.json";
+var VERSION = 1;
+function getConfigPath() {
+  return join(getAgentDir(), CONFIG_FILE_NAME);
+}
+async function loadConfig() {
+  return readConfigFile(getConfigPath());
+}
+async function readConfigFile(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return parseConfig(content, path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return emptyConfig();
+    }
+    throw error;
+  }
+}
+async function writeConfigFile(config) {
+  const path = getConfigPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, serializeConfig(config), "utf-8");
+  return path;
+}
+function parseConfig(text, source = CONFIG_FILE_NAME) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid JSON in ${source}: ${error.message}`);
+  }
+  return normalizeConfig(raw, source);
+}
+function serializeConfig(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function resolveConfigValue(reference) {
+  if (!reference) return void 0;
+  if (reference.startsWith("!")) {
+    const output = execSync(reference.slice(1), {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return output.length > 0 ? output : void 0;
+  }
+  const envValue = process.env[reference];
+  if (envValue !== void 0) {
+    return envValue;
+  }
+  if (/^[A-Z][A-Z0-9_]*$/.test(reference)) {
+    return void 0;
+  }
+  return reference;
+}
+function resolveEnvMap(envMap) {
+  if (!envMap) return void 0;
+  const resolved = Object.fromEntries(
+    Object.entries(envMap).map(([key, value]) => [key, resolveConfigValue(value)]).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+function emptyConfig() {
+  return { version: VERSION };
+}
+function normalizeConfig(raw, source) {
+  if (!isPlainObject(raw)) {
+    throw new Error(`Config in ${source} must be a JSON object.`);
+  }
+  const version = raw.version ?? VERSION;
+  if (version !== VERSION) {
+    throw new Error(
+      `Unsupported config version '${String(version)}' in ${source}. Expected ${VERSION}.`
+    );
+  }
+  const config = { version: VERSION };
+  if (raw.providers !== void 0) {
+    if (!isPlainObject(raw.providers)) {
+      throw new Error(`'providers' in ${source} must be a JSON object.`);
+    }
+    config.providers = {};
+    if (raw.providers.codex !== void 0) {
+      config.providers.codex = normalizeCodexProvider(
+        raw.providers.codex,
+        source
+      );
+    }
+    if (raw.providers.exa !== void 0) {
+      config.providers.exa = normalizeExaProvider(raw.providers.exa, source);
+    }
+    if (raw.providers.gemini !== void 0) {
+      config.providers.gemini = normalizeGeminiProvider(
+        raw.providers.gemini,
+        source
+      );
+    }
+    if (raw.providers.parallel !== void 0) {
+      config.providers.parallel = normalizeParallelProvider(
+        raw.providers.parallel,
+        source
+      );
+    }
+    if (raw.providers.valyu !== void 0) {
+      config.providers.valyu = normalizeValyuProvider(
+        raw.providers.valyu,
+        source
+      );
+    }
+    const unknownProviders = Object.keys(raw.providers).filter(
+      (key) => key !== "codex" && key !== "exa" && key !== "gemini" && key !== "parallel" && key !== "valyu"
+    );
+    if (unknownProviders.length > 0) {
+      throw new Error(
+        `Unknown providers in ${source}: ${unknownProviders.join(", ")}.`
+      );
+    }
+  }
+  return config;
+}
+function normalizeCodexProvider(raw, source) {
+  const provider = parseProviderObject(raw, source, "codex");
+  const defaults = parseOptionalJsonObject(
+    provider.defaults,
+    source,
+    "providers.codex.defaults"
+  );
+  return {
+    enabled: parseOptionalBoolean(
+      provider.enabled,
+      source,
+      "providers.codex.enabled"
+    ),
+    tools: parseOptionalProviderTools(
+      "codex",
+      provider.tools,
+      source,
+      "providers.codex.tools"
+    ),
+    codexPath: parseOptionalString(
+      provider.codexPath,
+      source,
+      "providers.codex.codexPath"
+    ),
+    baseUrl: parseOptionalString(
+      provider.baseUrl,
+      source,
+      "providers.codex.baseUrl"
+    ),
+    apiKey: parseOptionalString(
+      provider.apiKey,
+      source,
+      "providers.codex.apiKey"
+    ),
+    env: parseOptionalStringMap(provider.env, source, "providers.codex.env"),
+    config: parseOptionalJsonObject(
+      provider.config,
+      source,
+      "providers.codex.config"
+    ),
+    defaults: defaults === void 0 ? void 0 : {
+      model: parseOptionalString(
+        defaults.model,
+        source,
+        "providers.codex.defaults.model"
+      ),
+      modelReasoningEffort: parseOptionalLiteral(
+        defaults.modelReasoningEffort,
+        source,
+        "providers.codex.defaults.modelReasoningEffort",
+        ["minimal", "low", "medium", "high", "xhigh"]
+      ),
+      networkAccessEnabled: parseOptionalBoolean(
+        defaults.networkAccessEnabled,
+        source,
+        "providers.codex.defaults.networkAccessEnabled"
+      ),
+      webSearchMode: parseOptionalLiteral(
+        defaults.webSearchMode,
+        source,
+        "providers.codex.defaults.webSearchMode",
+        ["disabled", "cached", "live"]
+      ),
+      webSearchEnabled: parseOptionalBoolean(
+        defaults.webSearchEnabled,
+        source,
+        "providers.codex.defaults.webSearchEnabled"
+      ),
+      additionalDirectories: parseOptionalStringArray(
+        defaults.additionalDirectories,
+        source,
+        "providers.codex.defaults.additionalDirectories"
+      )
+    }
+  };
+}
+function normalizeExaProvider(raw, source) {
+  const provider = parseProviderObject(raw, source, "exa");
+  return {
+    enabled: parseOptionalBoolean(
+      provider.enabled,
+      source,
+      "providers.exa.enabled"
+    ),
+    tools: parseOptionalProviderTools(
+      "exa",
+      provider.tools,
+      source,
+      "providers.exa.tools"
+    ),
+    apiKey: parseOptionalString(
+      provider.apiKey,
+      source,
+      "providers.exa.apiKey"
+    ),
+    baseUrl: parseOptionalString(
+      provider.baseUrl,
+      source,
+      "providers.exa.baseUrl"
+    ),
+    defaults: parseOptionalJsonObject(
+      provider.defaults,
+      source,
+      "providers.exa.defaults"
+    )
+  };
+}
+function normalizeValyuProvider(raw, source) {
+  const provider = parseProviderObject(raw, source, "valyu");
+  return {
+    enabled: parseOptionalBoolean(
+      provider.enabled,
+      source,
+      "providers.valyu.enabled"
+    ),
+    tools: parseOptionalProviderTools(
+      "valyu",
+      provider.tools,
+      source,
+      "providers.valyu.tools"
+    ),
+    apiKey: parseOptionalString(
+      provider.apiKey,
+      source,
+      "providers.valyu.apiKey"
+    ),
+    baseUrl: parseOptionalString(
+      provider.baseUrl,
+      source,
+      "providers.valyu.baseUrl"
+    ),
+    defaults: parseOptionalJsonObject(
+      provider.defaults,
+      source,
+      "providers.valyu.defaults"
+    )
+  };
+}
+function normalizeGeminiProvider(raw, source) {
+  const provider = parseProviderObject(raw, source, "gemini");
+  const defaults = parseOptionalJsonObject(
+    provider.defaults,
+    source,
+    "providers.gemini.defaults"
+  );
+  return {
+    enabled: parseOptionalBoolean(
+      provider.enabled,
+      source,
+      "providers.gemini.enabled"
+    ),
+    tools: parseOptionalProviderTools(
+      "gemini",
+      provider.tools,
+      source,
+      "providers.gemini.tools"
+    ),
+    apiKey: parseOptionalString(
+      provider.apiKey,
+      source,
+      "providers.gemini.apiKey"
+    ),
+    defaults: defaults === void 0 ? void 0 : {
+      apiVersion: parseOptionalString(
+        defaults.apiVersion,
+        source,
+        "providers.gemini.defaults.apiVersion"
+      ),
+      searchModel: parseOptionalString(
+        defaults.searchModel,
+        source,
+        "providers.gemini.defaults.searchModel"
+      ),
+      answerModel: parseOptionalString(
+        defaults.answerModel,
+        source,
+        "providers.gemini.defaults.answerModel"
+      ),
+      researchAgent: parseOptionalString(
+        defaults.researchAgent,
+        source,
+        "providers.gemini.defaults.researchAgent"
+      )
+    }
+  };
+}
+function normalizeParallelProvider(raw, source) {
+  const provider = parseProviderObject(raw, source, "parallel");
+  const defaults = parseOptionalJsonObject(
+    provider.defaults,
+    source,
+    "providers.parallel.defaults"
+  );
+  return {
+    enabled: parseOptionalBoolean(
+      provider.enabled,
+      source,
+      "providers.parallel.enabled"
+    ),
+    tools: parseOptionalProviderTools(
+      "parallel",
+      provider.tools,
+      source,
+      "providers.parallel.tools"
+    ),
+    apiKey: parseOptionalString(
+      provider.apiKey,
+      source,
+      "providers.parallel.apiKey"
+    ),
+    baseUrl: parseOptionalString(
+      provider.baseUrl,
+      source,
+      "providers.parallel.baseUrl"
+    ),
+    defaults: defaults === void 0 ? void 0 : {
+      search: parseOptionalJsonObject(
+        defaults.search,
+        source,
+        "providers.parallel.defaults.search"
+      ),
+      extract: parseOptionalJsonObject(
+        defaults.extract,
+        source,
+        "providers.parallel.defaults.extract"
+      )
+    }
+  };
+}
+function parseProviderObject(raw, source, field) {
+  if (!isPlainObject(raw)) {
+    throw new Error(`'providers.${field}' in ${source} must be a JSON object.`);
+  }
+  return raw;
+}
+function parseOptionalJsonObject(value, source, field) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) {
+    throw new Error(`'${field}' in ${source} must be a JSON object.`);
+  }
+  return value;
+}
+function parseOptionalProviderTools(providerId, value, source, field) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) {
+    throw new Error(`'${field}' in ${source} must be a JSON object.`);
+  }
+  const parsed = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const normalizedKey = normalizeProviderToolKey(providerId, key);
+    if (normalizedKey === null) {
+      continue;
+    }
+    if (!supportsProviderTool(providerId, normalizedKey)) {
+      throw new Error(
+        `Unknown tools for ${providerId} in ${source}: ${key}.`
+      );
+    }
+    parsed[normalizedKey] = parseBoolean(entry, source, `${field}.${key}`);
+  }
+  const unknownTools = Object.keys(value).filter(
+    (toolId) => {
+      const normalizedKey = normalizeProviderToolKey(providerId, toolId);
+      return normalizedKey !== null && !PROVIDER_TOOLS[providerId].includes(normalizedKey);
+    }
+  );
+  if (unknownTools.length > 0) {
+    throw new Error(
+      `Unknown tools for ${providerId} in ${source}: ${unknownTools.join(", ")}.`
+    );
+  }
+  return parsed;
+}
+function normalizeProviderToolKey(providerId, key) {
+  const alias = LEGACY_TOOL_ALIASES[providerId]?.[key];
+  if (alias !== void 0) {
+    return alias;
+  }
+  return key;
+}
+function parseOptionalStringMap(value, source, field) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) {
+    throw new Error(
+      `'${field}' in ${source} must be a JSON object of strings.`
+    );
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      parseString(entry, source, `${field}.${key}`)
+    ])
+  );
+}
+function parseOptionalStringArray(value, source, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    throw new Error(`'${field}' in ${source} must be an array of strings.`);
+  }
+  return value.map(
+    (entry, index) => parseString(entry, source, `${field}[${index}]`)
+  );
+}
+function parseOptionalBoolean(value, source, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new Error(`'${field}' in ${source} must be a boolean.`);
+  }
+  return value;
+}
+function parseBoolean(value, source, field) {
+  if (typeof value !== "boolean") {
+    throw new Error(`'${field}' in ${source} must be a boolean.`);
+  }
+  return value;
+}
+function parseOptionalString(value, source, field) {
+  if (value === void 0) return void 0;
+  return parseString(value, source, field);
+}
+function parseString(value, source, field) {
+  if (typeof value !== "string") {
+    throw new Error(`'${field}' in ${source} must be a string.`);
+  }
+  return value;
+}
+function parseOptionalLiteral(value, source, field, allowed) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(
+      `'${field}' in ${source} must be one of: ${allowed.join(", ")}.`
+    );
+  }
+  return value;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/providers/codex.ts
+import { Codex } from "@openai/codex-sdk";
+
+// src/providers/shared.ts
+function trimSnippet(input, maxLength = 300) {
+  const text = (input ?? "").replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1)}\u2026`;
+}
+function asJsonObject(value) {
+  return value ? { ...value } : {};
+}
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+// src/providers/codex.ts
+var OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    sources: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          title: { type: "string" },
+          url: { type: "string" },
+          snippet: { type: "string" }
+        },
+        required: ["title", "url", "snippet"]
+      }
+    }
+  },
+  required: ["sources"]
+};
+var CodexProvider = class {
+  id = "codex";
+  label = "Codex";
+  docsUrl = "https://github.com/openai/codex/tree/main/sdk/typescript";
+  createTemplate() {
+    return {
+      enabled: true,
+      tools: {
+        search: true
+      },
+      defaults: {
+        networkAccessEnabled: true,
+        webSearchEnabled: true,
+        webSearchMode: "live"
+      }
+    };
+  }
+  getStatus(config, _cwd) {
+    if (!config) {
+      return { available: false, summary: "not configured" };
+    }
+    if (config.enabled === false) {
+      return { available: false, summary: "disabled" };
+    }
+    return { available: true, summary: "enabled" };
+  }
+  async search(query, maxResults, config, context) {
+    const codex = new Codex({
+      codexPathOverride: config.codexPath,
+      baseUrl: config.baseUrl,
+      apiKey: resolveConfigValue(config.apiKey),
+      config: config.config,
+      env: resolveEnvMap(config.env)
+    });
+    const thread = codex.startThread({
+      additionalDirectories: config.defaults?.additionalDirectories,
+      approvalPolicy: "never",
+      model: config.defaults?.model,
+      modelReasoningEffort: config.defaults?.modelReasoningEffort,
+      networkAccessEnabled: config.defaults?.networkAccessEnabled ?? true,
+      sandboxMode: "read-only",
+      skipGitRepoCheck: true,
+      webSearchEnabled: config.defaults?.webSearchEnabled ?? true,
+      webSearchMode: config.defaults?.webSearchMode ?? "live",
+      workingDirectory: context.cwd
+    });
+    const prompt = [
+      "You are performing web research for another coding agent.",
+      "Search the public web and return only a JSON object matching the provided schema.",
+      "Do not include markdown fences or extra commentary.",
+      `Return at most ${maxResults} sources.`,
+      "Prefer primary or official sources when they are available.",
+      "Each snippet should be short and specific.",
+      "",
+      `User query: ${query}`
+    ].join("\n");
+    const streamed = await thread.runStreamed(prompt, {
+      outputSchema: OUTPUT_SCHEMA,
+      signal: context.signal
+    });
+    let finalResponse = "";
+    const seenQueries = /* @__PURE__ */ new Set();
+    for await (const event of streamed.events) {
+      handleProgressEvent(event, seenQueries, context.onProgress);
+      if (event.type === "item.completed" && event.item.type === "agent_message") {
+        finalResponse = event.item.text;
+      }
+      if (event.type === "turn.failed") {
+        throw new Error(event.error.message);
+      }
+    }
+    const parsed = parseOutput(finalResponse);
+    return {
+      provider: this.id,
+      results: parsed.sources.slice(0, maxResults).map((source) => ({
+        title: source.title.trim(),
+        url: source.url.trim(),
+        snippet: trimSnippet(source.snippet)
+      }))
+    };
+  }
+};
+function handleProgressEvent(event, seenQueries, onProgress) {
+  if (!onProgress) return;
+  if (event.type === "item.completed" && event.item.type === "web_search" && !seenQueries.has(event.item.query)) {
+    seenQueries.add(event.item.query);
+    onProgress(`Codex web search ${seenQueries.size}: ${event.item.query}`);
+  }
+}
+function parseOutput(raw) {
+  if (!raw.trim()) {
+    throw new Error("Codex returned an empty response.");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) {
+      throw new Error("Codex returned invalid JSON output.");
+    }
+    return JSON.parse(match[0]);
+  }
+}
+
+// src/providers/exa.ts
+import { Exa } from "exa-js";
+var ExaProvider = class {
+  id = "exa";
+  label = "Exa";
+  docsUrl = "https://exa.ai/docs/sdks/typescript-sdk-specification";
+  createTemplate() {
+    return {
+      enabled: false,
+      tools: {
+        search: true,
+        contents: true,
+        answer: true,
+        research: true
+      },
+      apiKey: "EXA_API_KEY",
+      defaults: {
+        type: "auto",
+        contents: {
+          text: true
+        }
+      }
+    };
+  }
+  getStatus(config) {
+    if (!config) {
+      return { available: false, summary: "not configured" };
+    }
+    if (config.enabled === false) {
+      return { available: false, summary: "disabled" };
+    }
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      return { available: false, summary: "missing apiKey" };
+    }
+    return { available: true, summary: "enabled" };
+  }
+  async search(query, maxResults, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Exa is missing an API key.");
+    }
+    const client = new Exa(apiKey, config.baseUrl);
+    const options = {
+      ...asJsonObject(config.defaults),
+      numResults: maxResults
+    };
+    context.onProgress?.(`Searching Exa for: ${query}`);
+    const response = await client.search(query, options);
+    return {
+      provider: this.id,
+      results: (response.results ?? []).slice(0, maxResults).map((result) => ({
+        title: String(result.title ?? result.url ?? "Untitled"),
+        url: String(result.url ?? ""),
+        snippet: trimSnippet(
+          typeof result.text === "string" ? result.text : Array.isArray(result.highlights) ? result.highlights.join(" ") : typeof result.summary === "string" ? result.summary : ""
+        ),
+        score: typeof result.score === "number" ? result.score : void 0
+      }))
+    };
+  }
+  async contents(urls, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Exa is missing an API key.");
+    }
+    const client = new Exa(apiKey, config.baseUrl);
+    context.onProgress?.(`Fetching contents from Exa for ${urls.length} URL(s)`);
+    const response = await client.getContents(urls, options);
+    const lines = [];
+    for (const [index, result] of (response.results ?? []).entries()) {
+      lines.push(`${index + 1}. ${String(result.title ?? result.url ?? "Untitled")}`);
+      lines.push(`   ${String(result.url ?? "")}`);
+      const summary = typeof result.summary === "string" ? result.summary : result.summary ? formatJson(result.summary) : void 0;
+      const text = typeof result.text === "string" ? result.text : Array.isArray(result.highlights) ? result.highlights.join(" ") : "";
+      const body = trimSnippet(summary ?? text);
+      if (body) {
+        lines.push(`   ${body}`);
+      }
+      lines.push("");
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd() || "No contents found.",
+      summary: `${response.results?.length ?? 0} content result(s) via Exa`,
+      itemCount: response.results?.length ?? 0
+    };
+  }
+  async answer(query, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Exa is missing an API key.");
+    }
+    const client = new Exa(apiKey, config.baseUrl);
+    context.onProgress?.(`Getting Exa answer for: ${query}`);
+    const response = await client.answer(query, options);
+    const lines = [];
+    lines.push(
+      typeof response.answer === "string" ? response.answer : formatJson(response.answer)
+    );
+    const citations = response.citations ?? [];
+    if (citations.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, citation] of citations.entries()) {
+        lines.push(`${index + 1}. ${String(citation.title ?? citation.url ?? "Untitled")}`);
+        lines.push(`   ${String(citation.url ?? "")}`);
+      }
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd(),
+      summary: `Answer via Exa with ${citations.length} source(s)`,
+      itemCount: citations.length
+    };
+  }
+  async research(input, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Exa is missing an API key.");
+    }
+    const client = new Exa(apiKey, config.baseUrl);
+    context.onProgress?.("Creating Exa research task");
+    const task = await client.research.create({
+      instructions: input,
+      ...options ?? {}
+    });
+    const result = await client.research.pollUntilFinished(task.researchId, {
+      pollInterval: 3e3
+    });
+    if (result.status === "failed") {
+      throw new Error(result.error ?? "Exa research failed.");
+    }
+    if (result.status === "canceled") {
+      throw new Error("Exa research was canceled.");
+    }
+    return {
+      provider: this.id,
+      text: typeof result.output.content === "string" ? result.output.content : formatJson(result.output.content),
+      summary: "Research via Exa"
+    };
+  }
+};
+
+// src/providers/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var DEFAULT_SEARCH_MODEL = "gemini-2.5-flash";
+var DEFAULT_ANSWER_MODEL = "gemini-2.5-flash";
+var DEFAULT_RESEARCH_AGENT = "deep-research-pro-preview-12-2025";
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+var GeminiProvider = class {
+  id = "gemini";
+  label = "Gemini";
+  docsUrl = "https://github.com/googleapis/js-genai";
+  createTemplate() {
+    return {
+      enabled: false,
+      tools: {
+        search: true,
+        answer: true,
+        research: true
+      },
+      apiKey: "GOOGLE_API_KEY",
+      defaults: {
+        searchModel: DEFAULT_SEARCH_MODEL,
+        answerModel: DEFAULT_ANSWER_MODEL,
+        researchAgent: DEFAULT_RESEARCH_AGENT
+      }
+    };
+  }
+  getStatus(config) {
+    if (!config) {
+      return { available: false, summary: "not configured" };
+    }
+    if (config.enabled === false) {
+      return { available: false, summary: "disabled" };
+    }
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      return { available: false, summary: "missing apiKey" };
+    }
+    return { available: true, summary: "enabled" };
+  }
+  async search(query, maxResults, config, context) {
+    const ai = this.createClient(config);
+    const model = config.defaults?.searchModel ?? DEFAULT_SEARCH_MODEL;
+    context.onProgress?.(`Searching Gemini for: ${query}`);
+    const interaction = await ai.interactions.create({
+      model,
+      input: query,
+      tools: [{ type: "google_search" }],
+      generation_config: {
+        tool_choice: "any"
+      }
+    });
+    const results = extractGoogleSearchResults(interaction.outputs).slice(0, maxResults).map((result) => ({
+      title: result.title ?? result.url ?? "Untitled",
+      url: result.url ?? "",
+      snippet: trimSnippet(result.rendered_content ?? "")
+    }));
+    return {
+      provider: this.id,
+      results
+    };
+  }
+  async answer(query, options, config, context) {
+    const ai = this.createClient(config);
+    const model = config.defaults?.answerModel ?? DEFAULT_ANSWER_MODEL;
+    context.onProgress?.(`Getting Gemini answer for: ${query}`);
+    const response = await ai.models.generateContent({
+      model,
+      contents: query,
+      config: {
+        ...options ?? {},
+        tools: [{ googleSearch: {} }]
+      }
+    });
+    const lines = [];
+    lines.push(response.text?.trim() || "No answer returned.");
+    const sources = extractGroundingSources(
+      response.candidates?.[0]?.groundingMetadata?.groundingChunks
+    );
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, source] of sources.entries()) {
+        lines.push(`${index + 1}. ${source.title}`);
+        lines.push(`   ${source.url}`);
+      }
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd(),
+      summary: `Answer via Gemini with ${sources.length} source(s)`,
+      itemCount: sources.length
+    };
+  }
+  async research(input, options, config, context) {
+    const ai = this.createClient(config);
+    const agent = config.defaults?.researchAgent ?? DEFAULT_RESEARCH_AGENT;
+    const pollIntervalMs = getPollInterval(options);
+    const requestOptions = stripPollIntervalOption(options);
+    context.onProgress?.("Starting Gemini deep research");
+    const initialInteraction = await ai.interactions.create({
+      ...requestOptions,
+      input,
+      agent,
+      background: true
+    });
+    context.onProgress?.(`Gemini research started: ${initialInteraction.id}`);
+    while (true) {
+      if (context.signal?.aborted) {
+        throw new Error("Gemini research aborted.");
+      }
+      const interaction = await ai.interactions.get(initialInteraction.id);
+      context.onProgress?.(`Gemini research status: ${interaction.status}`);
+      if (interaction.status === "completed") {
+        const text = formatInteractionOutputs(interaction.outputs);
+        return {
+          provider: this.id,
+          text: text || "Gemini research completed without textual output.",
+          summary: "Research via Gemini"
+        };
+      }
+      if (interaction.status === "failed" || interaction.status === "cancelled") {
+        throw new Error(`Gemini research ${interaction.status}.`);
+      }
+      await sleep(pollIntervalMs, context.signal);
+    }
+  }
+  createClient(config) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Gemini is missing an API key.");
+    }
+    return new GoogleGenAI({
+      apiKey,
+      apiVersion: config.defaults?.apiVersion
+    });
+  }
+};
+function extractGoogleSearchResults(outputs) {
+  const results = [];
+  if (!Array.isArray(outputs)) {
+    return results;
+  }
+  for (const output of outputs) {
+    if (typeof output !== "object" || output === null) {
+      continue;
+    }
+    const content = output;
+    if (content.type !== "google_search_result") {
+      continue;
+    }
+    const items = Array.isArray(content.result) ? content.result : [];
+    for (const item of items) {
+      if (typeof item !== "object" || item === null) {
+        continue;
+      }
+      const record = item;
+      results.push({
+        title: typeof record.title === "string" ? record.title : void 0,
+        url: typeof record.url === "string" ? record.url : void 0,
+        rendered_content: typeof record.rendered_content === "string" ? record.rendered_content : void 0
+      });
+    }
+  }
+  return results;
+}
+function extractGroundingSources(chunks) {
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  if (!Array.isArray(chunks)) {
+    return sources;
+  }
+  for (const chunk of chunks) {
+    const web = typeof chunk === "object" && chunk !== null && "web" in chunk && typeof chunk.web === "object" && chunk.web !== null ? chunk.web : void 0;
+    if (!web) continue;
+    const url = typeof web.uri === "string" ? web.uri : void 0;
+    if (!url || seen.has(url)) continue;
+    seen.add(url);
+    sources.push({
+      title: typeof web.title === "string" ? web.title : url,
+      url
+    });
+  }
+  return sources;
+}
+function formatInteractionOutputs(outputs) {
+  const lines = [];
+  if (!Array.isArray(outputs)) {
+    return "";
+  }
+  for (const output of outputs) {
+    if (typeof output === "object" && output !== null && "type" in output && output.type === "text" && "text" in output && typeof output.text === "string") {
+      const text = output.text.trim();
+      if (text) {
+        lines.push(text);
+      }
+    }
+  }
+  return lines.join("\n\n").trim();
+}
+async function sleep(ms, signal) {
+  if (signal?.aborted) {
+    throw new Error("Operation aborted.");
+  }
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new Error("Operation aborted."));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function getPollInterval(options) {
+  const raw = options?.pollIntervalMs;
+  if (typeof raw === "number" && Number.isFinite(raw) && raw >= 1e3) {
+    return Math.trunc(raw);
+  }
+  return DEFAULT_POLL_INTERVAL_MS;
+}
+function stripPollIntervalOption(options) {
+  if (!options || !Object.hasOwn(options, "pollIntervalMs")) {
+    return options;
+  }
+  const { pollIntervalMs: _ignored, ...rest } = options;
+  return rest;
+}
+
+// src/providers/parallel.ts
+import Parallel from "parallel-web";
+var ParallelProvider = class {
+  id = "parallel";
+  label = "Parallel";
+  docsUrl = "https://github.com/parallel-web/parallel-sdk-typescript";
+  createTemplate() {
+    return {
+      enabled: false,
+      tools: {
+        search: true,
+        contents: true
+      },
+      apiKey: "PARALLEL_API_KEY",
+      defaults: {
+        search: {
+          mode: "agentic"
+        },
+        extract: {
+          excerpts: true,
+          full_content: false
+        }
+      }
+    };
+  }
+  getStatus(config) {
+    if (!config) {
+      return { available: false, summary: "not configured" };
+    }
+    if (config.enabled === false) {
+      return { available: false, summary: "disabled" };
+    }
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      return { available: false, summary: "missing apiKey" };
+    }
+    return { available: true, summary: "enabled" };
+  }
+  async search(query, maxResults, config, context) {
+    const client = this.createClient(config);
+    const defaults = asJsonObject(config.defaults?.search);
+    context.onProgress?.(`Searching Parallel for: ${query}`);
+    const response = await client.beta.search({
+      ...defaults,
+      objective: query,
+      max_results: maxResults
+    });
+    return {
+      provider: this.id,
+      results: response.results.slice(0, maxResults).map((result) => ({
+        title: result.title ?? result.url,
+        url: result.url,
+        snippet: trimSnippet(result.excerpts?.join(" ") ?? "")
+      }))
+    };
+  }
+  async contents(urls, options, config, context) {
+    const client = this.createClient(config);
+    const defaults = asJsonObject(config.defaults?.extract);
+    context.onProgress?.(
+      `Fetching contents from Parallel for ${urls.length} URL(s)`
+    );
+    const response = await client.beta.extract({
+      ...defaults,
+      ...options ?? {},
+      urls
+    });
+    const lines = [];
+    for (const [index, result] of response.results.entries()) {
+      lines.push(`${index + 1}. ${result.title ?? result.url}`);
+      lines.push(`   ${result.url}`);
+      const text = result.excerpts?.join(" ") ?? result.full_content ?? "";
+      const snippet = trimSnippet(text);
+      if (snippet) {
+        lines.push(`   ${snippet}`);
+      }
+      lines.push("");
+    }
+    for (const error of response.errors) {
+      lines.push(`Error: ${error.url}`);
+      lines.push(`   ${error.error_type}`);
+      if (error.content) {
+        lines.push(`   ${trimSnippet(error.content)}`);
+      }
+      lines.push("");
+    }
+    const itemCount = response.results.length;
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd() || "No contents found.",
+      summary: `${itemCount} content result(s) via Parallel`,
+      itemCount
+    };
+  }
+  createClient(config) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Parallel is missing an API key.");
+    }
+    return new Parallel({
+      apiKey,
+      baseURL: resolveConfigValue(config.baseUrl)
+    });
+  }
+};
+
+// src/providers/valyu.ts
+import { Valyu } from "valyu-js";
+var ValyuProvider = class {
+  id = "valyu";
+  label = "Valyu";
+  docsUrl = "https://docs.valyu.ai/sdk/typescript-sdk";
+  createTemplate() {
+    return {
+      enabled: false,
+      tools: {
+        search: true,
+        contents: true,
+        answer: true,
+        research: true
+      },
+      apiKey: "VALYU_API_KEY",
+      defaults: {
+        searchType: "all",
+        responseLength: "short"
+      }
+    };
+  }
+  getStatus(config) {
+    if (!config) {
+      return { available: false, summary: "not configured" };
+    }
+    if (config.enabled === false) {
+      return { available: false, summary: "disabled" };
+    }
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      return { available: false, summary: "missing apiKey" };
+    }
+    return { available: true, summary: "enabled" };
+  }
+  async search(query, maxResults, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Valyu is missing an API key.");
+    }
+    const client = new Valyu(apiKey, config.baseUrl);
+    const options = {
+      ...asJsonObject(config.defaults),
+      maxNumResults: maxResults
+    };
+    context.onProgress?.(`Searching Valyu for: ${query}`);
+    const response = await client.search(query, options);
+    if (!response.success) {
+      throw new Error(response.error || "Valyu search failed.");
+    }
+    return {
+      provider: this.id,
+      results: (response.results ?? []).slice(0, maxResults).map((result) => ({
+        title: result.title,
+        url: result.url,
+        snippet: trimSnippet(
+          result.description ?? (typeof result.content === "string" ? result.content : "")
+        ),
+        score: result.relevance_score
+      }))
+    };
+  }
+  async contents(urls, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Valyu is missing an API key.");
+    }
+    const client = new Valyu(apiKey, config.baseUrl);
+    context.onProgress?.(`Fetching contents from Valyu for ${urls.length} URL(s)`);
+    const response = await client.contents(urls, options);
+    const finalResponse = "jobId" in response ? await client.waitForJob(response.jobId, {
+      onProgress: (status) => context.onProgress?.(
+        `Valyu contents: ${status.urlsProcessed}/${status.urlsTotal} processed`
+      )
+    }) : response;
+    if (!finalResponse.success) {
+      throw new Error(finalResponse.error || "Valyu contents failed.");
+    }
+    const results = finalResponse.results ?? [];
+    const lines = [];
+    for (const [index, result] of results.entries()) {
+      lines.push(`${index + 1}. ${result.url}`);
+      if (result.status === "failed") {
+        lines.push(`   Failed: ${result.error}`);
+      } else {
+        const snippet = typeof result.summary === "string" ? result.summary : result.summary ? formatJson(result.summary) : typeof result.content === "string" || typeof result.content === "number" ? String(result.content) : formatJson(result.content);
+        if (result.title) {
+          lines.push(`   ${result.title}`);
+        }
+        lines.push(`   ${trimSnippet(snippet)}`);
+      }
+      lines.push("");
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd() || "No contents found.",
+      summary: `${results.length} content result(s) via Valyu`,
+      itemCount: results.length
+    };
+  }
+  async answer(query, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Valyu is missing an API key.");
+    }
+    const client = new Valyu(apiKey, config.baseUrl);
+    context.onProgress?.(`Getting Valyu answer for: ${query}`);
+    const response = await client.answer(query, {
+      ...options ?? {},
+      streaming: false
+    });
+    if (!("success" in response) || !response.success) {
+      throw new Error(
+        "error" in response && typeof response.error === "string" ? response.error : "Valyu answer failed."
+      );
+    }
+    const lines = [];
+    const contents = typeof response.contents === "string" ? response.contents : formatJson(response.contents);
+    lines.push(contents);
+    const sources = response.search_results ?? [];
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, result] of sources.entries()) {
+        lines.push(`${index + 1}. ${result.title}`);
+        lines.push(`   ${result.url}`);
+      }
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd(),
+      summary: `Answer via Valyu with ${sources.length} source(s)`,
+      itemCount: sources.length
+    };
+  }
+  async research(input, options, config, context) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("Valyu is missing an API key.");
+    }
+    const client = new Valyu(apiKey, config.baseUrl);
+    context.onProgress?.("Creating Valyu deep research task");
+    const task = await client.deepresearch.create({
+      input,
+      ...options ?? {}
+    });
+    if (!task.success || !task.deepresearch_id) {
+      throw new Error(task.error || "Valyu deep research creation failed.");
+    }
+    const result = await client.deepresearch.wait(task.deepresearch_id, {
+      onProgress: (status) => {
+        const progress = status.progress;
+        if (progress) {
+          context.onProgress?.(
+            `Valyu deep research: ${progress.current_step}/${progress.total_steps}`
+          );
+        }
+      }
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Valyu deep research failed.");
+    }
+    const lines = [];
+    lines.push(
+      typeof result.output === "string" ? result.output : formatJson(result.output)
+    );
+    const sources = result.sources ?? [];
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, source] of sources.entries()) {
+        lines.push(`${index + 1}. ${source.title}`);
+        lines.push(`   ${source.url}`);
+      }
+    }
+    return {
+      provider: this.id,
+      text: lines.join("\n").trimEnd(),
+      summary: `Research via Valyu with ${sources.length} source(s)`,
+      itemCount: sources.length
+    };
+  }
+};
+
+// src/providers/index.ts
+var PROVIDERS = [
+  new CodexProvider(),
+  new ExaProvider(),
+  new GeminiProvider(),
+  new ParallelProvider(),
+  new ValyuProvider()
+];
+var PROVIDER_MAP = {
+  codex: PROVIDERS[0],
+  exa: PROVIDERS[1],
+  gemini: PROVIDERS[2],
+  parallel: PROVIDERS[3],
+  valyu: PROVIDERS[4]
+};
+
+// src/provider-resolution.ts
+function resolveProviderChoice(config, explicit, cwd) {
+  return resolveProviderForCapability(config, explicit, cwd, "search");
+}
+function resolveProviderForCapability(config, explicit, cwd, capability) {
+  if (explicit) {
+    const provider = PROVIDER_MAP[explicit];
+    if (typeof provider[capability] !== "function") {
+      throw new Error(
+        `Provider '${explicit}' does not support '${capability}'.`
+      );
+    }
+    if (!isProviderToolEnabled(
+      explicit,
+      config.providers?.[explicit],
+      capability
+    )) {
+      throw new Error(
+        `Provider '${explicit}' has '${capability}' disabled in config.`
+      );
+    }
+    const status = provider.getStatus(
+      config.providers?.[explicit],
+      cwd
+    );
+    if (!status.available) {
+      throw new Error(
+        `Provider '${explicit}' is not available: ${status.summary}.`
+      );
+    }
+    return provider;
+  }
+  for (const provider of PROVIDERS) {
+    if (typeof provider[capability] !== "function") continue;
+    const providerConfig = config.providers?.[provider.id];
+    if (providerConfig?.enabled !== true) continue;
+    if (!isProviderToolEnabled(
+      provider.id,
+      providerConfig,
+      capability
+    )) {
+      continue;
+    }
+    const status = provider.getStatus(providerConfig, cwd);
+    if (status.available) return provider;
+  }
+  for (const provider of PROVIDERS) {
+    if (typeof provider[capability] !== "function") continue;
+    if (!isProviderToolEnabled(
+      provider.id,
+      config.providers?.[provider.id],
+      capability
+    )) {
+      continue;
+    }
+    const status = provider.getStatus(
+      config.providers?.[provider.id],
+      cwd
+    );
+    if (status.available) return provider;
+  }
+  throw new Error(
+    `No provider is configured for '${capability}'. Run /web-providers to create ~/.pi/agent/web-providers.json.`
+  );
+}
+
+// src/types.ts
+var PROVIDER_IDS = ["codex", "exa", "gemini", "parallel", "valyu"];
+
+// src/index.ts
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_ALLOWED_RESULTS = 20;
+function webProvidersExtension(pi) {
+  registerWebSearchTool(pi);
+  registerWebContentsTool(pi);
+  registerWebAnswerTool(pi);
+  registerWebResearchTool(pi);
+  pi.registerCommand("web-providers", {
+    description: "Configure web search providers",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("web-providers requires interactive mode", "error");
+        return;
+      }
+      await runWebProvidersConfig(ctx);
+    }
+  });
+}
+function registerWebSearchTool(pi) {
+  pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description: `Search the public web and return results with titles, URLs, and snippets. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)} when needed.`,
+    parameters: Type.Object({
+      query: Type.String({ description: "What to search for on the web" }),
+      maxResults: Type.Optional(
+        Type.Integer({
+          minimum: 1,
+          maximum: MAX_ALLOWED_RESULTS,
+          description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
+        })
+      ),
+      provider: Type.Optional(
+        StringEnum(PROVIDER_IDS, {
+          description: "Provider override. If omitted, uses the active configured provider or falls back to the first available provider alphabetically."
+        })
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const config = await loadConfig();
+      const provider = resolveProviderChoice(config, params.provider, ctx.cwd);
+      const maxResults = clampResults(params.maxResults);
+      const providerConfig = config.providers?.[provider.id];
+      if (!providerConfig) {
+        throw new Error(`Provider '${provider.id}' is not configured.`);
+      }
+      const response = await provider.search(
+        params.query,
+        maxResults,
+        providerConfig,
+        {
+          cwd: ctx.cwd,
+          signal: signal ?? void 0,
+          onProgress: (message) => onUpdate?.({
+            content: [{ type: "text", text: message }],
+            details: {}
+          })
+        }
+      );
+      const rendered = await truncateAndSave(
+        formatSearchResponse(response),
+        "web-search"
+      );
+      const details = {
+        tool: "web_search",
+        query: params.query,
+        provider: response.provider,
+        resultCount: response.results.length
+      };
+      return { content: [{ type: "text", text: rendered }], details };
+    },
+    renderCall(args, theme) {
+      return renderCallHeader(
+        args,
+        theme
+      );
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      const text = extractTextContent(result.content);
+      const isError = Boolean(result.isError);
+      if (isPartial) {
+        return renderSimpleText(text ?? "Searching\u2026", theme, "warning");
+      }
+      if (isError) {
+        return renderBlockText(text ?? "web_search failed", theme, "error");
+      }
+      const details = result.details;
+      if (!details) {
+        return renderBlockText(text ?? "", theme, "toolOutput");
+      }
+      if (expanded) {
+        return renderBlockText(text ?? "", theme, "toolOutput");
+      }
+      return renderCollapsedSearchSummary(details, text, theme);
+    }
+  });
+}
+function registerWebContentsTool(pi) {
+  const providerIds = getProviderIdsForCapability("contents");
+  if (providerIds.length === 0) return;
+  pi.registerTool({
+    name: "web_contents",
+    label: "Web Contents",
+    description: "Fetch extracted contents for one or more URLs using a configured provider.",
+    parameters: Type.Object({
+      urls: Type.Array(Type.String({ minLength: 1 }), {
+        minItems: 1,
+        description: "One or more URLs to extract"
+      }),
+      options: jsonOptionsSchema("Provider-specific extraction options."),
+      provider: providerEnum(
+        providerIds,
+        "Provider override. If omitted, uses the active configured provider that supports web contents."
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      return executeProviderTool({
+        capability: "contents",
+        config: await loadConfig(),
+        explicitProvider: params.provider,
+        ctx,
+        signal,
+        onUpdate,
+        invoke: (provider, providerConfig, context) => provider.contents(
+          params.urls,
+          normalizeOptions(params.options),
+          providerConfig,
+          context
+        )
+      });
+    },
+    renderCall(args, theme) {
+      return renderToolCallHeader(
+        "web_contents",
+        `${Array.isArray(args.urls) ? args.urls?.length ?? 0 : 0} url(s)`,
+        [
+          `provider=${String(args.provider ?? "auto")}`
+        ],
+        theme
+      );
+    },
+    renderResult(result, state, theme) {
+      return renderProviderToolResult(
+        result,
+        state.expanded,
+        state.isPartial,
+        "web_contents failed",
+        theme
+      );
+    }
+  });
+}
+function registerWebAnswerTool(pi) {
+  const providerIds = getProviderIdsForCapability("answer");
+  if (providerIds.length === 0) return;
+  pi.registerTool({
+    name: "web_answer",
+    label: "Web Answer",
+    description: "Get a provider-generated answer grounded in web results.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Question to answer" }),
+      options: jsonOptionsSchema("Provider-specific answer options."),
+      provider: providerEnum(
+        providerIds,
+        "Provider override. If omitted, uses the active configured provider that supports web answers."
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      return executeProviderTool({
+        capability: "answer",
+        config: await loadConfig(),
+        explicitProvider: params.provider,
+        ctx,
+        signal,
+        onUpdate,
+        invoke: (provider, providerConfig, context) => provider.answer(
+          params.query,
+          normalizeOptions(params.options),
+          providerConfig,
+          context
+        )
+      });
+    },
+    renderCall(args, theme) {
+      return renderToolCallHeader(
+        "web_answer",
+        `"${cleanSingleLine(String(args.query ?? "")).slice(0, 80)}"`,
+        [`provider=${String(args.provider ?? "auto")}`],
+        theme
+      );
+    },
+    renderResult(result, state, theme) {
+      return renderProviderToolResult(
+        result,
+        state.expanded,
+        state.isPartial,
+        "web_answer failed",
+        theme
+      );
+    }
+  });
+}
+function registerWebResearchTool(pi) {
+  const providerIds = getProviderIdsForCapability("research");
+  if (providerIds.length === 0) return;
+  pi.registerTool({
+    name: "web_research",
+    label: "Web Research",
+    description: "Run a longer-form research task using a provider that supports research.",
+    parameters: Type.Object({
+      input: Type.String({ description: "Research brief or question" }),
+      options: jsonOptionsSchema("Provider-specific research options."),
+      provider: providerEnum(
+        providerIds,
+        "Provider override. If omitted, uses the active configured provider that supports research."
+      )
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      return executeProviderTool({
+        capability: "research",
+        config: await loadConfig(),
+        explicitProvider: params.provider,
+        ctx,
+        signal,
+        onUpdate,
+        invoke: (provider, providerConfig, context) => provider.research(
+          params.input,
+          normalizeOptions(params.options),
+          providerConfig,
+          context
+        )
+      });
+    },
+    renderCall(args, theme) {
+      return renderToolCallHeader(
+        "web_research",
+        `"${cleanSingleLine(String(args.input ?? "")).slice(0, 80)}"`,
+        [`provider=${String(args.provider ?? "auto")}`],
+        theme
+      );
+    },
+    renderResult(result, state, theme) {
+      return renderProviderToolResult(
+        result,
+        state.expanded,
+        state.isPartial,
+        "web_research failed",
+        theme
+      );
+    }
+  });
+}
+async function runWebProvidersConfig(ctx) {
+  const config = await loadConfig();
+  const activeProvider = await getPreferredProvider(ctx.cwd);
+  await ctx.ui.custom(
+    (tui, theme, _keybindings, done) => new WebProvidersSettingsView(
+      tui,
+      theme,
+      done,
+      ctx,
+      config,
+      activeProvider
+    )
+  );
+}
+function getProviderIdsForCapability(capability) {
+  return PROVIDERS.filter(
+    (provider) => typeof provider[capability] === "function"
+  ).map((provider) => provider.id);
+}
+function providerEnum(providerIds, description) {
+  if (providerIds.length === 1) {
+    return Type.Optional(Type.Literal(providerIds[0], { description }));
+  }
+  return Type.Optional(
+    Type.Union(providerIds.map((id) => Type.Literal(id)), { description })
+  );
+}
+function jsonOptionsSchema(description) {
+  return Type.Optional(
+    Type.Object({}, {
+      additionalProperties: true,
+      description
+    })
+  );
+}
+async function executeProviderTool({
+  capability,
+  config,
+  explicitProvider,
+  ctx,
+  signal,
+  onUpdate,
+  invoke
+}) {
+  const provider = resolveProviderForCapability(
+    config,
+    explicitProvider,
+    ctx.cwd,
+    capability
+  );
+  const providerConfig = config.providers?.[provider.id];
+  if (!providerConfig) {
+    throw new Error(`Provider '${provider.id}' is not configured.`);
+  }
+  const response = await invoke(
+    provider,
+    providerConfig,
+    {
+      cwd: ctx.cwd,
+      signal: signal ?? void 0,
+      onProgress: (message) => onUpdate?.({
+        content: [{ type: "text", text: message }],
+        details: {}
+      })
+    }
+  );
+  const details = {
+    tool: `web_${capability}`,
+    provider: response.provider,
+    summary: response.summary,
+    itemCount: response.itemCount
+  };
+  return {
+    content: [{ type: "text", text: response.text }],
+    details
+  };
+}
+function normalizeOptions(value) {
+  return isJsonObject(value) ? value : void 0;
+}
+function renderToolCallHeader(toolName, primary, details, theme) {
+  return {
+    invalidate() {
+    },
+    render(width) {
+      let header = theme.fg("toolTitle", theme.bold(toolName));
+      if (primary.trim().length > 0) {
+        header += ` ${theme.fg("accent", primary)}`;
+      }
+      const lines = [];
+      const headerLine = truncateToWidth(header.trimEnd(), width);
+      lines.push(
+        headerLine + " ".repeat(Math.max(0, width - visibleWidth(headerLine)))
+      );
+      if (details.length > 0) {
+        const detailLine = truncateToWidth(
+          `  ${theme.fg("muted", details.join(" "))}`,
+          width
+        );
+        lines.push(
+          detailLine + " ".repeat(Math.max(0, width - visibleWidth(detailLine)))
+        );
+      }
+      return lines;
+    }
+  };
+}
+function renderProviderToolResult(result, expanded, isPartial, failureText, theme) {
+  const text = extractTextContent(result.content);
+  if (isPartial) {
+    return renderSimpleText(text ?? "Working\u2026", theme, "warning");
+  }
+  if (result.isError) {
+    return renderBlockText(text ?? failureText, theme, "error");
+  }
+  if (expanded) {
+    return renderBlockText(text ?? "", theme, "toolOutput");
+  }
+  const details = result.details;
+  const summary = details?.summary ?? getFirstLine(text) ?? `${details?.tool ?? "tool"} output available`;
+  let summaryText = theme.fg("success", summary);
+  summaryText += theme.fg("muted", ` (${getExpandHint()})`);
+  return new Text(summaryText, 0, 0);
+}
+function buildProviderToolMenuOptions(providerId) {
+  return PROVIDER_TOOLS[providerId].map((toolId) => ({
+    key: toolId,
+    label: PROVIDER_TOOL_META[toolId].label,
+    help: PROVIDER_TOOL_META[toolId].help
+  }));
+}
+function buildProviderMenuOptions(providerId) {
+  const options = [];
+  const pushText = (key, label, help) => {
+    options.push({
+      key,
+      label,
+      help,
+      kind: "text"
+    });
+  };
+  const pushValues = (key, label, help, values) => {
+    options.push({
+      key,
+      label,
+      help,
+      kind: "values",
+      values
+    });
+  };
+  if (providerId === "codex") {
+    pushText(
+      "model",
+      "Model",
+      "Optional Codex model override. Leave empty to use the local default."
+    );
+    pushValues(
+      "modelReasoningEffort",
+      "Reasoning effort",
+      "Reasoning depth for Codex. 'default' uses the SDK default.",
+      ["default", "minimal", "low", "medium", "high", "xhigh"]
+    );
+    pushValues(
+      "webSearchMode",
+      "Web search mode",
+      "How Codex should source web results. 'default' currently behaves like 'live'.",
+      ["default", "disabled", "cached", "live"]
+    );
+    pushValues(
+      "networkAccessEnabled",
+      "Network access",
+      "Allow Codex network access during search runs. 'default' currently behaves like 'true'.",
+      ["default", "true", "false"]
+    );
+    pushValues(
+      "webSearchEnabled",
+      "Web search",
+      "Enable Codex web search. 'default' currently behaves like 'true'.",
+      ["default", "true", "false"]
+    );
+    pushText(
+      "additionalDirectories",
+      "Additional dirs",
+      "Optional comma-separated directories that Codex may read in addition to the current working directory."
+    );
+    return options;
+  }
+  pushText(
+    "apiKey",
+    "API key",
+    "Provider API key. You can use a literal value, an env var name like EXA_API_KEY, or !command."
+  );
+  if (providerId !== "gemini") {
+    pushText("baseUrl", "Base URL", "Optional API base URL override.");
+  }
+  if (providerId === "exa") {
+    pushValues(
+      "exaSearchType",
+      "Search type",
+      "Exa search mode. 'default' uses the SDK default.",
+      [
+        "default",
+        "keyword",
+        "neural",
+        "auto",
+        "hybrid",
+        "fast",
+        "instant",
+        "deep",
+        "deep-reasoning",
+        "deep-max"
+      ]
+    );
+    pushValues(
+      "exaTextContents",
+      "Text contents",
+      "Whether Exa should include text contents in search results. 'default' uses the SDK default.",
+      ["default", "true", "false"]
+    );
+    return options;
+  }
+  if (providerId === "gemini") {
+    pushValues(
+      "geminiApiVersion",
+      "API version",
+      "Gemini API version. 'default' uses the SDK default beta endpoints.",
+      ["default", "v1alpha", "v1beta", "v1"]
+    );
+    pushText(
+      "geminiSearchModel",
+      "Search model",
+      "Model used for Gemini search interactions."
+    );
+    pushText(
+      "geminiAnswerModel",
+      "Answer model",
+      "Model used for grounded Gemini answers."
+    );
+    pushText(
+      "geminiResearchAgent",
+      "Research agent",
+      "Agent used for Gemini deep research runs."
+    );
+    return options;
+  }
+  if (providerId === "parallel") {
+    pushValues(
+      "parallelSearchMode",
+      "Search mode",
+      "Parallel search mode. 'default' uses the SDK default.",
+      ["default", "agentic", "one-shot"]
+    );
+    pushValues(
+      "parallelExtractExcerpts",
+      "Extract excerpts",
+      "Include excerpts in Parallel extraction results. 'default' uses the SDK default.",
+      ["default", "on", "off"]
+    );
+    pushValues(
+      "parallelExtractFullContent",
+      "Extract full content",
+      "Include full page content in Parallel extraction results. 'default' uses the SDK default.",
+      ["default", "on", "off"]
+    );
+    return options;
+  }
+  pushValues(
+    "valyuSearchType",
+    "Search type",
+    "Valyu search type. 'default' uses the SDK default.",
+    ["default", "all", "web", "proprietary", "news"]
+  );
+  pushValues(
+    "valyuResponseLength",
+    "Response length",
+    "Valyu response length. 'default' uses the SDK default.",
+    ["default", "short", "medium", "large", "max"]
+  );
+  return options;
+}
+var WebProvidersSettingsView = class {
+  constructor(tui, theme, done, ctx, initialConfig, initialProvider) {
+    this.tui = tui;
+    this.theme = theme;
+    this.done = done;
+    this.ctx = ctx;
+    this.config = structuredClone(initialConfig);
+    this.activeProvider = initialProvider;
+  }
+  config;
+  activeProvider;
+  activeSection = "provider";
+  selection = {
+    provider: 0,
+    tools: 0,
+    config: 0
+  };
+  submenu;
+  render(width) {
+    if (this.submenu) {
+      return this.submenu.render(width);
+    }
+    const lines = [];
+    const providerItems = this.buildProviderSectionItems();
+    lines.push(...this.renderSection(width, "Provider", "provider", providerItems));
+    lines.push("");
+    const toolItems = this.buildToolSectionItems();
+    lines.push(...this.renderSection(width, "Tools", "tools", toolItems));
+    lines.push("");
+    const configItems = this.buildConfigSectionItems();
+    lines.push(...this.renderSection(width, "Provider config", "config", configItems));
+    const selected = this.getSelectedEntry();
+    if (selected) {
+      lines.push("");
+      for (const line of wrapTextWithAnsi(selected.description, Math.max(10, width - 2))) {
+        lines.push(truncateToWidth(this.theme.fg("dim", line), width));
+      }
+    }
+    lines.push("");
+    lines.push(
+      truncateToWidth(
+        this.theme.fg(
+          "dim",
+          "\u2191\u2193 move \xB7 Tab/Shift+Tab switch section \xB7 Enter edit/toggle \xB7 Esc close"
+        ),
+        width
+      )
+    );
+    return lines;
+  }
+  invalidate() {
+    this.submenu?.invalidate();
+  }
+  handleInput(data) {
+    if (this.submenu) {
+      this.submenu.handleInput?.(data);
+      this.tui.requestRender();
+      return;
+    }
+    const kb = getEditorKeybindings();
+    const entries = this.getActiveSectionEntries();
+    if (kb.matches(data, "selectUp")) {
+      if (entries.length > 0) {
+        this.moveSelection(-1);
+      }
+    } else if (kb.matches(data, "selectDown")) {
+      if (entries.length > 0) {
+        this.moveSelection(1);
+      }
+    } else if (matchesKey(data, Key.tab)) {
+      this.moveSection(1);
+    } else if (matchesKey(data, Key.shift("tab"))) {
+      this.moveSection(-1);
+    } else if (kb.matches(data, "selectConfirm") || data === " ") {
+      void this.activateCurrentEntry();
+    } else if (kb.matches(data, "selectCancel")) {
+      this.done(void 0);
+      return;
+    }
+    this.tui.requestRender();
+  }
+  buildProviderSectionItems() {
+    return [
+      {
+        id: "provider",
+        label: "Engine",
+        currentValue: PROVIDER_MAP[this.activeProvider].label,
+        description: "Active web provider. Enter cycles through providers.",
+        kind: "cycle",
+        values: PROVIDERS.map((provider) => provider.label)
+      }
+    ];
+  }
+  buildToolSectionItems() {
+    const providerConfig = this.currentProviderConfig();
+    return buildProviderToolMenuOptions(this.activeProvider).map((option) => ({
+      id: `tool:${option.key}`,
+      label: option.label,
+      currentValue: isProviderToolEnabled(
+        this.activeProvider,
+        providerConfig,
+        option.key
+      ) ? "on" : "off",
+      description: option.help,
+      kind: "cycle",
+      values: ["on", "off"]
+    }));
+  }
+  buildConfigSectionItems() {
+    const providerConfig = this.currentProviderConfig();
+    return buildProviderMenuOptions(this.activeProvider).map(
+      (option) => this.buildProviderItem(option, providerConfig)
+    );
+  }
+  buildProviderItem(option, providerConfig) {
+    if (option.kind === "values") {
+      return {
+        id: option.key,
+        label: option.label,
+        currentValue: getProviderChoiceValue(
+          this.activeProvider,
+          providerConfig,
+          option.key
+        ),
+        values: option.values,
+        description: option.help,
+        kind: "cycle"
+      };
+    }
+    if (option.kind === "text") {
+      const key = option.key;
+      const currentValue = key === "model" || key === "additionalDirectories" ? getCodexTextSettingValue(
+        providerConfig,
+        key
+      ) : key === "geminiSearchModel" || key === "geminiAnswerModel" || key === "geminiResearchAgent" ? getGeminiTextSettingValue(
+        providerConfig,
+        key
+      ) : getProviderStringValue(
+        providerConfig,
+        key
+      );
+      const secret = key === "apiKey";
+      return {
+        id: key,
+        label: option.label,
+        currentValue: summarizeStringValue(currentValue, secret),
+        description: option.help,
+        kind: "text"
+      };
+    }
+    throw new Error(`Unsupported provider menu option: ${option.key}`);
+  }
+  currentProviderConfig() {
+    return this.config.providers?.[this.activeProvider];
+  }
+  getSectionEntries(section) {
+    if (section === "provider") return this.buildProviderSectionItems();
+    if (section === "tools") return this.buildToolSectionItems();
+    return this.buildConfigSectionItems();
+  }
+  getActiveSectionEntries() {
+    return this.getSectionEntries(this.activeSection);
+  }
+  getSelectedEntry() {
+    const entries = this.getActiveSectionEntries();
+    return entries[this.selection[this.activeSection]];
+  }
+  moveSection(direction) {
+    const sections = [
+      "provider",
+      "tools",
+      "config"
+    ];
+    let index = sections.indexOf(this.activeSection);
+    for (let offset = 1; offset <= sections.length; offset++) {
+      const next = sections[(index + offset * direction + sections.length) % sections.length];
+      if (this.getSectionEntries(next).length > 0) {
+        this.activeSection = next;
+        return;
+      }
+    }
+  }
+  moveSelection(direction) {
+    const sections = [
+      "provider",
+      "tools",
+      "config"
+    ];
+    const currentEntries = this.getActiveSectionEntries();
+    const currentIndex = this.selection[this.activeSection];
+    if (direction === -1 && currentIndex > 0) {
+      this.selection[this.activeSection] = currentIndex - 1;
+      return;
+    }
+    if (direction === 1 && currentIndex < currentEntries.length - 1) {
+      this.selection[this.activeSection] = currentIndex + 1;
+      return;
+    }
+    const startSectionIndex = sections.indexOf(this.activeSection);
+    for (let offset = 1; offset <= sections.length; offset++) {
+      const nextSection = sections[(startSectionIndex + offset * direction + sections.length) % sections.length];
+      const nextEntries = this.getSectionEntries(nextSection);
+      if (nextEntries.length === 0) continue;
+      this.activeSection = nextSection;
+      this.selection[nextSection] = direction === 1 ? 0 : nextEntries.length - 1;
+      return;
+    }
+  }
+  renderSection(width, title, section, entries) {
+    const lines = [
+      truncateToWidth(
+        this.activeSection === section ? this.theme.fg("accent", this.theme.bold(title)) : this.theme.bold(title),
+        width
+      )
+    ];
+    const labelWidth = Math.min(
+      20,
+      Math.max(...entries.map((entry) => entry.label.length), 0)
+    );
+    for (const [index, entry] of entries.entries()) {
+      const selected = this.activeSection === section && this.selection[section] === index;
+      const prefix = selected ? this.theme.fg("accent", "\u2192 ") : "  ";
+      const paddedLabel = entry.label.padEnd(labelWidth, " ");
+      const label = selected ? this.theme.fg("accent", paddedLabel) : paddedLabel;
+      const value = selected ? this.theme.fg("accent", entry.currentValue) : this.theme.fg("muted", entry.currentValue);
+      lines.push(truncateToWidth(`${prefix}${label}  ${value}`, width));
+    }
+    return lines;
+  }
+  async activateCurrentEntry() {
+    const entry = this.getSelectedEntry();
+    if (!entry) return;
+    if (entry.kind === "cycle" && entry.values && entry.values.length > 0) {
+      const currentIndex = entry.values.indexOf(entry.currentValue);
+      const nextValue = entry.values[(currentIndex + 1) % entry.values.length];
+      await this.handleChange(entry.id, nextValue);
+      return;
+    }
+    if (entry.kind === "text") {
+      const currentValue = this.getEntryRawValue(entry.id) ?? "";
+      this.submenu = new TextValueSubmenu(
+        this.tui,
+        this.theme,
+        entry.label,
+        currentValue,
+        entry.description,
+        (selectedValue) => {
+          this.submenu = void 0;
+          if (selectedValue !== void 0) {
+            void this.handleChange(entry.id, selectedValue);
+          }
+          this.tui.requestRender();
+        }
+      );
+      return;
+    }
+  }
+  getEntryRawValue(id) {
+    const providerConfig = this.currentProviderConfig();
+    if (id === "apiKey" || id === "baseUrl") {
+      return getProviderStringValue(providerConfig, id);
+    }
+    if (id === "model" || id === "additionalDirectories") {
+      return getCodexTextSettingValue(
+        providerConfig,
+        id
+      );
+    }
+    if (id === "geminiSearchModel" || id === "geminiAnswerModel" || id === "geminiResearchAgent") {
+      return getGeminiTextSettingValue(
+        providerConfig,
+        id
+      );
+    }
+    return void 0;
+  }
+  async handleChange(id, value) {
+    if (id === "provider") {
+      const nextProvider = PROVIDERS.find(
+        (provider) => provider.label === value
+      )?.id;
+      if (!nextProvider || nextProvider === this.activeProvider) {
+        return;
+      }
+      this.activeProvider = nextProvider;
+      await this.persist((config) => {
+        setActiveProvider(config, nextProvider);
+      });
+      this.selection.tools = 0;
+      this.selection.config = 0;
+      return;
+    }
+    await this.persist((config) => {
+      config.providers ??= {};
+      const providerConfig = getEditableProviderConfig(
+        this.activeProvider,
+        config.providers?.[this.activeProvider]
+      );
+      if (id.startsWith("tool:")) {
+        const toolId = id.slice("tool:".length);
+        const typedProviderConfig = providerConfig;
+        const tools = typedProviderConfig.tools ?? {};
+        tools[toolId] = value === "on";
+        typedProviderConfig.tools = tools;
+        config.providers[this.activeProvider] = typedProviderConfig;
+        return;
+      }
+      if (id === "apiKey" || id === "baseUrl") {
+        assignOptionalString(providerConfig, id, value);
+      } else if (this.activeProvider === "codex" && applyCodexSettingChange(
+        providerConfig,
+        id,
+        value
+      )) {
+      } else if (this.activeProvider === "exa" && applyExaSettingChange(
+        providerConfig,
+        id,
+        value
+      )) {
+      } else if (this.activeProvider === "gemini" && applyGeminiSettingChange(
+        providerConfig,
+        id,
+        value
+      )) {
+      } else if (this.activeProvider === "parallel" && applyParallelSettingChange(
+        providerConfig,
+        id,
+        value
+      )) {
+      } else if (this.activeProvider === "valyu" && applyValyuSettingChange(
+        providerConfig,
+        id,
+        value
+      )) {
+      } else {
+        throw new Error(`Unknown setting '${id}'.`);
+      }
+      config.providers[this.activeProvider] = providerConfig;
+    });
+  }
+  async persist(mutate) {
+    const nextConfig = structuredClone(this.config);
+    try {
+      mutate(nextConfig);
+      await writeConfigFile(nextConfig);
+      this.config = nextConfig;
+      this.tui.requestRender();
+    } catch (error) {
+      this.ctx.ui.notify(error.message, "error");
+    }
+  }
+};
+var TextValueSubmenu = class {
+  constructor(tui, theme, title, initialValue, help, done) {
+    this.theme = theme;
+    this.title = title;
+    this.help = help;
+    this.done = done;
+    const editorTheme = {
+      borderColor: (text) => this.theme.fg("accent", text),
+      selectList: {
+        selectedPrefix: (text) => this.theme.fg("accent", text),
+        selectedText: (text) => this.theme.fg("accent", text),
+        description: (text) => this.theme.fg("muted", text),
+        scrollInfo: (text) => this.theme.fg("dim", text),
+        noMatch: (text) => this.theme.fg("warning", text)
+      }
+    };
+    this.editor = new Editor(tui, editorTheme);
+    this.editor.setText(initialValue);
+    this.editor.onSubmit = (text) => {
+      this.done(text.trim());
+    };
+  }
+  editor;
+  render(width) {
+    return [
+      truncateToWidth(this.theme.fg("accent", this.title), width),
+      "",
+      ...this.editor.render(width),
+      "",
+      truncateToWidth(this.theme.fg("dim", this.help), width),
+      truncateToWidth(
+        this.theme.fg(
+          "dim",
+          "Enter to save \xB7 Shift+Enter for newline \xB7 Esc to cancel"
+        ),
+        width
+      )
+    ];
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+  handleInput(data) {
+    if (matchesKey(data, Key.escape)) {
+      this.done(void 0);
+      return;
+    }
+    this.editor.handleInput(data);
+  }
+};
+function getEditableProviderConfig(providerId, current) {
+  return structuredClone(
+    current ?? PROVIDER_MAP[providerId].createTemplate()
+  );
+}
+function setActiveProvider(config, providerId) {
+  const currentProviders = config.providers ?? {};
+  const candidateIds = /* @__PURE__ */ new Set([providerId]);
+  for (const id of Object.keys(currentProviders)) {
+    candidateIds.add(id);
+  }
+  config.providers ??= {};
+  for (const id of candidateIds) {
+    const providerConfig = getEditableProviderConfig(
+      id,
+      config.providers?.[id]
+    );
+    providerConfig.enabled = id === providerId;
+    config.providers[id] = providerConfig;
+  }
+}
+function getResolvedProviderChoice(effective, cwd) {
+  try {
+    return resolveProviderChoice(effective, void 0, cwd).id;
+  } catch {
+    return void 0;
+  }
+}
+async function getPreferredProvider(cwd) {
+  const current = await loadConfig();
+  return getResolvedProviderChoice(current, cwd) ?? "codex";
+}
+function summarizeStringValue(value, secret) {
+  if (!value) return "unset";
+  if (secret) {
+    if (value.startsWith("!")) return "!command";
+    if (/^[A-Z][A-Z0-9_]*$/.test(value)) return `env:${value}`;
+    return "literal";
+  }
+  return truncateInline(value, 40);
+}
+function getProviderStringValue(config, key) {
+  if (!config) return void 0;
+  const value = config[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getProviderChoiceValue(providerId, config, key) {
+  if (providerId === "codex") {
+    const defaults = config?.defaults;
+    if (key === "networkAccessEnabled" || key === "webSearchEnabled") {
+      const value = defaults?.[key];
+      return typeof value === "boolean" ? String(value) : "default";
+    }
+    if (key === "modelReasoningEffort" || key === "webSearchMode") {
+      const value = defaults?.[key];
+      return typeof value === "string" ? value : "default";
+    }
+  }
+  if (providerId === "exa") {
+    const defaults = config?.defaults;
+    if (key === "exaSearchType") {
+      return typeof defaults?.type === "string" ? defaults.type : "default";
+    }
+    if (key === "exaTextContents") {
+      const contents = isJsonObject(defaults?.contents) ? defaults.contents : void 0;
+      return typeof contents?.text === "boolean" ? String(contents.text) : "default";
+    }
+  }
+  if (providerId === "valyu") {
+    const defaults = config?.defaults;
+    if (key === "valyuSearchType") {
+      return typeof defaults?.searchType === "string" ? defaults.searchType : "default";
+    }
+    if (key === "valyuResponseLength") {
+      return typeof defaults?.responseLength === "string" ? defaults.responseLength : "default";
+    }
+  }
+  if (providerId === "gemini") {
+    const defaults = config?.defaults;
+    if (key === "geminiApiVersion") {
+      return typeof defaults?.apiVersion === "string" ? defaults.apiVersion : "default";
+    }
+  }
+  if (providerId === "parallel") {
+    const defaults = config?.defaults;
+    const search = isJsonObject(defaults?.search) ? defaults.search : void 0;
+    const extract = isJsonObject(defaults?.extract) ? defaults.extract : void 0;
+    if (key === "parallelSearchMode") {
+      return typeof search?.mode === "string" ? search.mode : "default";
+    }
+    if (key === "parallelExtractExcerpts") {
+      if (extract?.excerpts === void 0) return "default";
+      return extract.excerpts ? "on" : "off";
+    }
+    if (key === "parallelExtractFullContent") {
+      if (extract?.full_content === void 0) return "default";
+      return extract.full_content ? "on" : "off";
+    }
+  }
+  throw new Error(`Unsupported choice setting '${key}' for '${providerId}'.`);
+}
+function getCodexTextSettingValue(config, key) {
+  const defaults = config?.defaults;
+  if (!defaults) return void 0;
+  if (key === "additionalDirectories") {
+    return defaults.additionalDirectories?.join(", ");
+  }
+  return defaults.model;
+}
+function getGeminiTextSettingValue(config, key) {
+  const defaults = config?.defaults;
+  if (!defaults) return void 0;
+  if (key === "geminiSearchModel") return defaults.searchModel;
+  if (key === "geminiAnswerModel") return defaults.answerModel;
+  return defaults.researchAgent;
+}
+function assignOptionalString(target, key, value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    delete target[key];
+  } else {
+    target[key] = trimmed;
+  }
+}
+function applyCodexSettingChange(target, key, value) {
+  target.defaults ??= {};
+  switch (key) {
+    case "model":
+      assignOptionalString(
+        target.defaults,
+        "model",
+        value
+      );
+      cleanupCodexDefaults(target);
+      return true;
+    case "additionalDirectories": {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        delete target.defaults.additionalDirectories;
+      } else {
+        target.defaults.additionalDirectories = trimmed.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+      }
+      cleanupCodexDefaults(target);
+      return true;
+    }
+    case "modelReasoningEffort":
+    case "webSearchMode":
+      if (value === "default") {
+        delete target.defaults[key];
+      } else {
+        target.defaults[key] = value;
+      }
+      cleanupCodexDefaults(target);
+      return true;
+    case "networkAccessEnabled":
+    case "webSearchEnabled":
+      if (value === "default") {
+        delete target.defaults[key];
+      } else {
+        target.defaults[key] = value === "true";
+      }
+      cleanupCodexDefaults(target);
+      return true;
+    default:
+      return false;
+  }
+}
+function applyExaSettingChange(target, key, value) {
+  target.defaults = isJsonObject(target.defaults) ? { ...target.defaults } : {};
+  switch (key) {
+    case "exaSearchType":
+      if (value === "default") {
+        delete target.defaults.type;
+      } else {
+        target.defaults.type = value;
+      }
+      cleanupGenericDefaults(target);
+      return true;
+    case "exaTextContents": {
+      const contents = isJsonObject(target.defaults.contents) ? { ...target.defaults.contents } : {};
+      if (value === "default") {
+        delete contents.text;
+      } else {
+        contents.text = value === "true";
+      }
+      if (Object.keys(contents).length === 0) {
+        delete target.defaults.contents;
+      } else {
+        target.defaults.contents = contents;
+      }
+      cleanupGenericDefaults(target);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function applyValyuSettingChange(target, key, value) {
+  target.defaults = isJsonObject(target.defaults) ? { ...target.defaults } : {};
+  switch (key) {
+    case "valyuSearchType":
+      if (value === "default") {
+        delete target.defaults.searchType;
+      } else {
+        target.defaults.searchType = value;
+      }
+      cleanupGenericDefaults(target);
+      return true;
+    case "valyuResponseLength":
+      if (value === "default") {
+        delete target.defaults.responseLength;
+      } else {
+        target.defaults.responseLength = value;
+      }
+      cleanupGenericDefaults(target);
+      return true;
+    default:
+      return false;
+  }
+}
+function applyGeminiSettingChange(target, key, value) {
+  target.defaults ??= {};
+  switch (key) {
+    case "geminiApiVersion":
+      if (value === "default") {
+        delete target.defaults.apiVersion;
+      } else {
+        target.defaults.apiVersion = value;
+      }
+      cleanupGeminiDefaults(target);
+      return true;
+    case "geminiSearchModel":
+      assignOptionalString(
+        target.defaults,
+        "searchModel",
+        value
+      );
+      cleanupGeminiDefaults(target);
+      return true;
+    case "geminiAnswerModel":
+      assignOptionalString(
+        target.defaults,
+        "answerModel",
+        value
+      );
+      cleanupGeminiDefaults(target);
+      return true;
+    case "geminiResearchAgent":
+      assignOptionalString(
+        target.defaults,
+        "researchAgent",
+        value
+      );
+      cleanupGeminiDefaults(target);
+      return true;
+    default:
+      return false;
+  }
+}
+function applyParallelSettingChange(target, key, value) {
+  target.defaults ??= {};
+  target.defaults.search = isJsonObject(target.defaults.search) ? { ...target.defaults.search } : {};
+  target.defaults.extract = isJsonObject(target.defaults.extract) ? { ...target.defaults.extract } : {};
+  switch (key) {
+    case "parallelSearchMode":
+      if (value === "default") {
+        delete target.defaults.search.mode;
+      } else {
+        target.defaults.search.mode = value;
+      }
+      cleanupParallelDefaults(target);
+      return true;
+    case "parallelExtractExcerpts":
+      if (value === "default") {
+        delete target.defaults.extract.excerpts;
+      } else {
+        target.defaults.extract.excerpts = value === "on";
+      }
+      cleanupParallelDefaults(target);
+      return true;
+    case "parallelExtractFullContent":
+      if (value === "default") {
+        delete target.defaults.extract.full_content;
+      } else {
+        target.defaults.extract.full_content = value === "on";
+      }
+      cleanupParallelDefaults(target);
+      return true;
+    default:
+      return false;
+  }
+}
+function cleanupCodexDefaults(target) {
+  if (target.defaults && Object.keys(target.defaults).length === 0) {
+    delete target.defaults;
+  }
+}
+function cleanupGenericDefaults(target) {
+  if (target.defaults && Object.keys(target.defaults).length === 0) {
+    delete target.defaults;
+  }
+}
+function cleanupGeminiDefaults(target) {
+  if (target.defaults && Object.keys(target.defaults).length === 0) {
+    delete target.defaults;
+  }
+}
+function cleanupParallelDefaults(target) {
+  if (target.defaults?.search && Object.keys(target.defaults.search).length === 0) {
+    delete target.defaults.search;
+  }
+  if (target.defaults?.extract && Object.keys(target.defaults.extract).length === 0) {
+    delete target.defaults.extract;
+  }
+  if (target.defaults && Object.keys(target.defaults).length === 0) {
+    delete target.defaults;
+  }
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampResults(value) {
+  if (value === void 0) return DEFAULT_MAX_RESULTS;
+  return Math.min(Math.max(Math.trunc(value), 1), MAX_ALLOWED_RESULTS);
+}
+function extractTextContent(content) {
+  if (!content || content.length === 0) {
+    return void 0;
+  }
+  const text = content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text?.trimEnd() ?? "").join("\n").trim();
+  return text.length > 0 ? text : void 0;
+}
+function renderCallHeader(params, theme) {
+  return {
+    invalidate() {
+    },
+    render(width) {
+      let header = theme.fg("toolTitle", theme.bold("web_search"));
+      const query = cleanSingleLine(String(params.query ?? "")).trim();
+      if (query.length > 0) {
+        header += ` ${theme.fg("accent", `"${query.slice(0, 80)}"`)} `;
+      }
+      const lines = [];
+      const headerLine = truncateToWidth(header.trimEnd(), width);
+      lines.push(
+        headerLine + " ".repeat(Math.max(0, width - visibleWidth(headerLine)))
+      );
+      const detailParts = [
+        `provider=${params.provider ?? "auto"}`,
+        `maxResults=${params.maxResults ?? DEFAULT_MAX_RESULTS}`
+      ];
+      const details = truncateToWidth(
+        `  ${theme.fg("muted", detailParts.join(" "))}`,
+        width
+      );
+      lines.push(
+        details + " ".repeat(Math.max(0, width - visibleWidth(details)))
+      );
+      return lines;
+    }
+  };
+}
+function renderBlockText(text, theme, color) {
+  if (!text) {
+    return new Text("", 0, 0);
+  }
+  const rendered = text.split("\n").map((line) => theme.fg(color, line)).join("\n");
+  return new Text(`
+${rendered}`, 0, 0);
+}
+function renderSimpleText(text, theme, color) {
+  return new Text(theme.fg(color, text), 0, 0);
+}
+function renderCollapsedSearchSummary(details, text, theme) {
+  const count = `${details.resultCount} result${details.resultCount === 1 ? "" : "s"}`;
+  const base = getFirstLine(text) ?? `${count} via ${details.provider}`;
+  let summary = theme.fg("success", base);
+  summary += theme.fg("muted", ` (${getExpandHint()})`);
+  return new Text(summary, 0, 0);
+}
+function getFirstLine(text) {
+  if (!text) {
+    return void 0;
+  }
+  const firstLine = text.split("\n", 1)[0]?.trim();
+  return firstLine && firstLine.length > 0 ? firstLine : void 0;
+}
+function getExpandHint() {
+  try {
+    return keyHint("expandTools", "to expand");
+  } catch {
+    return "to expand";
+  }
+}
+function cleanSingleLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function formatSearchResponse(response) {
+  if (response.results.length === 0) {
+    return "No results found.";
+  }
+  const lines = [];
+  for (const [index, result] of response.results.entries()) {
+    lines.push(`${index + 1}. ${result.title}`);
+    lines.push(`   ${result.url}`);
+    if (result.snippet) {
+      lines.push(`   ${result.snippet}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+async function truncateAndSave(text, prefix) {
+  const truncation = truncateHead(text, {
+    maxLines: DEFAULT_MAX_LINES,
+    maxBytes: DEFAULT_MAX_BYTES
+  });
+  if (!truncation.truncated) return truncation.content;
+  const dir = join2(tmpdir(), `pi-web-providers-${prefix}-${Date.now()}`);
+  await mkdir2(dir, { recursive: true });
+  const fullPath = join2(dir, "output.txt");
+  await writeFile2(fullPath, text, "utf-8");
+  return truncation.content + `
+
+[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}). Full output saved to: ${fullPath}]`;
+}
+function truncateInline(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1)}\u2026`;
+}
+var __test__ = {
+  extractTextContent,
+  renderCallHeader,
+  renderCollapsedSearchSummary
+};
+export {
+  __test__,
+  webProvidersExtension as default
+};