pi-web-providers 2.5.0 → 3.0.0

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   visibleWidth,
   wrapTextWithAnsi
 } from "@mariozechner/pi-tui";
-import { Type as Type15 } from "typebox";
+import { Type as Type16 } from "typebox";
 
 // src/config.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -42,107 +42,1219 @@ function resolveConfigValue(reference) {
       }
       return cached.value;
     }
-    try {
-      const output = execSync(reference.slice(1), {
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"]
-      }).trim();
-      const value = output.length > 0 ? output : void 0;
-      commandValueCache.set(reference, { value });
-      return value;
-    } catch (error) {
-      const errorMessage = error.message;
-      commandValueCache.set(reference, { errorMessage });
-      throw error;
+    try {
+      const output = execSync(reference.slice(1), {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim();
+      const value = output.length > 0 ? output : void 0;
+      commandValueCache.set(reference, { value });
+      return value;
+    } catch (error) {
+      const errorMessage = error.message;
+      commandValueCache.set(reference, { errorMessage });
+      throw error;
+    }
+  }
+  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;
+}
+
+// src/providers/brave.ts
+import { Type } from "typebox";
+
+// src/providers/definition.ts
+function defineCapability(definition) {
+  return definition;
+}
+function defineProvider(definition) {
+  return definition;
+}
+function defineProviders(providers) {
+  return providers;
+}
+async function executeProviderCapability(definition, capability, input, context) {
+  const handler = definition.capabilities[capability];
+  if (!handler) {
+    throw new Error(
+      `Provider '${definition.id}' does not support '${capability}'.`
+    );
+  }
+  return await handler.execute(input, context);
+}
+
+// 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 normalizeContentText(input) {
+  const text = (input ?? "").replace(/\r/g, "").trim();
+  if (!text) {
+    return "";
+  }
+  return text.split("\n").map((line) => line.replace(/[ \t]+$/g, "")).join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function asJsonObject(value) {
+  return value ? { ...value } : {};
+}
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function getApiKeyStatus(apiKeyReference) {
+  try {
+    return resolveConfigValue(apiKeyReference) ? { state: "ready" } : { state: "missing_api_key" };
+  } catch (error) {
+    return {
+      state: "invalid_config",
+      detail: formatConfigValueError(error)
+    };
+  }
+}
+function formatConfigValueError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/\s+/g, " ").trim() || "Failed to resolve config value";
+}
+
+// src/providers/brave.ts
+var DEFAULT_BASE_URL = "https://api.search.brave.com";
+var BRAVE_API_VERSION = void 0;
+var countryOption = Type.Optional(
+  Type.String({
+    description: "Country code used to localize Brave results, for example 'US'."
+  })
+);
+var searchLangOption = Type.Optional(
+  Type.String({
+    description: "Content language for Brave results, for example 'en'."
+  })
+);
+var uiLangOption = Type.Optional(
+  Type.String({
+    description: "UI language for response metadata, for example 'en-US'."
+  })
+);
+var freshnessOption = Type.Optional(
+  Type.String({
+    description: "Freshness filter such as 'pd' (24h), 'pw' (7d), 'pm' (31d), 'py' (year), or a Brave date range."
+  })
+);
+var safesearchOption = Type.Optional(
+  Type.Enum({ off: "off", moderate: "moderate", strict: "strict" }, {
+    description: "Safe-search filtering level."
+  })
+);
+var spellcheckOption = Type.Optional(
+  Type.Boolean({ description: "Whether Brave may spellcheck the query." })
+);
+var countOption = Type.Optional(
+  Type.Integer({
+    minimum: 1,
+    maximum: 50,
+    description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+  })
+);
+var offsetOption = Type.Optional(
+  Type.Integer({
+    minimum: 0,
+    description: "Brave result page offset for paginated requests."
+  })
+);
+var gogglesOption = Type.Optional(
+  Type.String({ description: "Brave Goggles URL or inline definition." })
+);
+var extraSnippetsOption = Type.Optional(
+  Type.Boolean({ description: "Whether to ask Brave for extra snippets." })
+);
+var braveSearchOptionsSchema = Type.Object(
+  {
+    mode: Type.Optional(
+      Type.Enum(
+        {
+          web: "web",
+          llm_context: "llm_context",
+          news: "news",
+          videos: "videos",
+          images: "images",
+          places: "places"
+        },
+        {
+          description: "Brave search mode. Use 'news' for recent journalism or current events, 'videos' for clips/tutorials, 'images' for visual references, 'places' for local businesses, venues, cafes, restaurants, hotels, shops, or near/in-location searches, and 'llm_context' for retrieval context."
+        }
+      )
+    ),
+    common: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption
+        },
+        {
+          description: "Common Brave query options merged into the selected mode's options."
+        }
+      )
+    ),
+    web: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          freshness: freshnessOption,
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          goggles: gogglesOption,
+          extra_snippets: extraSnippetsOption,
+          offset: offsetOption,
+          enable_rich_callback: Type.Optional(
+            Type.Boolean({
+              description: "Whether to enable Brave rich callback metadata."
+            })
+          )
+        },
+        { description: "Options for Brave Web Search mode." }
+      )
+    ),
+    llmContext: Type.Optional(
+      Type.Object(
+        {
+          count: countOption,
+          maximum_number_of_urls: Type.Optional(
+            Type.Integer({ minimum: 1, description: "Maximum source URLs." })
+          ),
+          maximum_number_of_tokens: Type.Optional(
+            Type.Integer({
+              minimum: 1,
+              description: "Maximum context tokens."
+            })
+          ),
+          maximum_number_of_snippets: Type.Optional(
+            Type.Integer({ minimum: 1, description: "Maximum snippets." })
+          ),
+          maximum_number_of_tokens_per_url: Type.Optional(
+            Type.Integer({
+              minimum: 1,
+              description: "Maximum context tokens per URL."
+            })
+          ),
+          maximum_number_of_snippets_per_url: Type.Optional(
+            Type.Integer({
+              minimum: 1,
+              description: "Maximum snippets per URL."
+            })
+          ),
+          context_threshold_mode: Type.Optional(
+            Type.String({ description: "Brave LLM Context threshold mode." })
+          ),
+          enable_local: Type.Optional(
+            Type.Boolean({ description: "Whether to include local results." })
+          ),
+          enable_source_metadata: Type.Optional(
+            Type.Boolean({
+              description: "Whether to include source metadata in grounding."
+            })
+          ),
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          freshness: freshnessOption,
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          goggles: gogglesOption
+        },
+        { description: "Options for Brave LLM Context mode." }
+      )
+    ),
+    news: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          freshness: freshnessOption,
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          goggles: gogglesOption,
+          extra_snippets: extraSnippetsOption,
+          offset: offsetOption,
+          count: countOption
+        },
+        { description: "Options for Brave News Search mode." }
+      )
+    ),
+    videos: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          freshness: freshnessOption,
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          offset: offsetOption,
+          count: countOption
+        },
+        { description: "Options for Brave Video Search mode." }
+      )
+    ),
+    images: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          count: countOption
+        },
+        { description: "Options for Brave Image Search mode." }
+      )
+    ),
+    places: Type.Optional(
+      Type.Object(
+        {
+          country: countryOption,
+          search_lang: searchLangOption,
+          ui_lang: uiLangOption,
+          latitude: Type.Optional(
+            Type.Number({ description: "Latitude for local place search." })
+          ),
+          longitude: Type.Optional(
+            Type.Number({ description: "Longitude for local place search." })
+          ),
+          location: Type.Optional(
+            Type.String({
+              description: "Human-readable local search location, e.g. 'Eppendorf, Hamburg, Germany'. Use with mode='places' for neighborhood or near-me style searches."
+            })
+          ),
+          radius: Type.Optional(
+            Type.Number({ description: "Local search radius." })
+          ),
+          units: Type.Optional(
+            Type.String({ description: "Distance units for local search." })
+          ),
+          safesearch: safesearchOption,
+          spellcheck: spellcheckOption,
+          geoloc: Type.Optional(
+            Type.String({
+              description: "Optional geolocation token used to refine results."
+            })
+          ),
+          count: countOption,
+          includeDetails: Type.Optional(
+            Type.Boolean({
+              description: "Places mode only. Fetch detailed POI metadata when the task needs contact info, opening hours, ratings/review counts, photos, profiles, or richer address/distance data. Leave off for simple place listings to avoid extra latency and quota usage."
+            })
+          ),
+          includeDescriptions: Type.Optional(
+            Type.Boolean({
+              description: "Places mode only. Fetch AI-generated POI descriptions when the task needs qualitative summaries or short explanations of places. Leave off for simple nearby/place listing queries to avoid extra latency and quota usage."
+            })
+          )
+        },
+        { description: "Options for Brave Local Place Search mode." }
+      )
+    )
+  },
+  { description: "Brave search options." }
+);
+var braveSearchPromptGuidelines = [
+  "Use Brave places mode for direct point-of-interest listings such as restaurants, cafes, hotels, shops, landmarks, or venues.",
+  "Prefer Brave places mode over llm_context when the user asks for nearby businesses or wants names, addresses, ratings, opening hours, categories, or contact details.",
+  "In Brave places mode, set places.includeDetails when the task needs POI attributes beyond the basic result list, such as contact info, opening hours, ratings/review counts, photos, profiles, or richer address/distance metadata.",
+  "In Brave places mode, set places.includeDescriptions when the task needs qualitative summaries or short explanations of places. Leave it off for simple nearby/place listing queries to avoid extra latency and quota usage.",
+  "Use Brave llm_context mode when the agent needs extracted source context for reasoning, synthesis, RAG-style grounding, or source-material collection.",
+  "In Brave llm_context mode, set llmContext.enable_local=true for local or near-me queries where POI/map grounding may be useful."
+];
+var braveAnswerOptionsSchema = Type.Object(
+  {
+    country: Type.Optional(Type.String()),
+    language: Type.Optional(Type.String()),
+    enable_citations: Type.Optional(Type.Boolean()),
+    enable_entities: Type.Optional(Type.Boolean()),
+    max_completion_tokens: Type.Optional(Type.Integer({ minimum: 1 }))
+  },
+  { description: "Brave answer options." }
+);
+var braveResearchOptionsSchema = Type.Object(
+  {
+    country: Type.Optional(Type.String()),
+    language: Type.Optional(Type.String()),
+    enable_entities: Type.Optional(Type.Boolean()),
+    enable_citations: Type.Optional(
+      Type.Boolean({
+        description: "Accepted for compatibility but forced to false for Brave research mode."
+      })
+    ),
+    max_completion_tokens: Type.Optional(Type.Integer({ minimum: 1 })),
+    research_allow_thinking: Type.Optional(Type.Boolean()),
+    research_maximum_number_of_tokens_per_query: Type.Optional(
+      Type.Integer({ minimum: 1 })
+    ),
+    research_maximum_number_of_queries: Type.Optional(
+      Type.Integer({ minimum: 1 })
+    ),
+    research_maximum_number_of_iterations: Type.Optional(
+      Type.Integer({ minimum: 1 })
+    ),
+    research_maximum_number_of_seconds: Type.Optional(
+      Type.Integer({ minimum: 1 })
+    ),
+    research_maximum_number_of_results_per_query: Type.Optional(
+      Type.Integer({ minimum: 1 })
+    )
+  },
+  { description: "Brave research options." }
+);
+var braveImplementation = {
+  id: "brave",
+  label: "Brave",
+  docsUrl: "https://api-dashboard.search.brave.com/app/documentation",
+  getToolOptionsSchema(capability) {
+    switch (capability) {
+      case "search":
+        return braveSearchOptionsSchema;
+      case "answer":
+        return braveAnswerOptionsSchema;
+      case "research":
+        return braveResearchOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
+      credentials: {
+        search: "BRAVE_SEARCH_API_KEY",
+        answers: "BRAVE_ANSWERS_API_KEY"
+      },
+      options: {}
+    };
+  },
+  getCapabilityStatus(config, _cwd, tool) {
+    const key = tool === "answer" || tool === "research" ? config?.credentials?.answers : config?.credentials?.search;
+    try {
+      if (tool)
+        return resolveConfigValue(key) ? { state: "ready" } : { state: "missing_api_key" };
+      return [
+        config?.credentials?.search,
+        config?.credentials?.answers,
+        config?.credentials?.autosuggest
+      ].some((v) => resolveConfigValue(v)) ? { state: "ready" } : { state: "missing_api_key" };
+    } catch (error) {
+      return { state: "invalid_config", detail: formatConfigValueError(error) };
+    }
+  },
+  async search(query2, maxResults, config, context, options) {
+    const apiKey = requireKey(config.credentials?.search, "Brave search");
+    const defaults = asJsonObject(
+      config.options?.search
+    );
+    const callOptions = { ...defaults, ...options ?? {} };
+    const mode = readMode(callOptions.mode);
+    if (mode === "llm_context")
+      return await llmContext(
+        query2,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "news")
+      return await news(
+        query2,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "videos")
+      return await videos(
+        query2,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "images")
+      return await images(
+        query2,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "places")
+      return await places(
+        query2,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    return await web(query2, maxResults, config, context, apiKey, callOptions);
+  },
+  async answer(query2, config, context, options) {
+    const raw = {
+      ...asJsonObject(
+        config.options?.answer
+      ),
+      ...options ?? {}
+    };
+    return await completion(query2, config, context, buildAnswerRequest(raw));
+  },
+  async research(input, config, context, options) {
+    const raw = {
+      ...asJsonObject(
+        config.options?.research
+      ),
+      ...options ?? {}
+    };
+    return await completion(input, config, context, buildResearchRequest(raw));
+  }
+};
+function requireKey(ref, label) {
+  const key = resolveConfigValue(ref);
+  if (!key) throw new Error(`${label} is missing an API key`);
+  return key;
+}
+function base(config) {
+  return (resolveConfigValue(config.baseUrl) ?? DEFAULT_BASE_URL).replace(
+    /\/+$/,
+    ""
+  );
+}
+function clamp(n, max = 20) {
+  return Math.max(1, Math.min(max, Math.trunc(n || 0)));
+}
+function readMode(v) {
+  return v === "llm_context" || v === "news" || v === "videos" || v === "images" || v === "places" ? v : "web";
+}
+function obj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function arr(v) {
+  return Array.isArray(v) ? v : [];
+}
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function pick(source, allowed) {
+  return Object.fromEntries(
+    allowed.filter((k) => source[k] !== void 0).map((k) => [k, source[k]])
+  );
+}
+function mergeOptions(options, key, allowed) {
+  return pick({ ...obj(options.common), ...obj(options[key]) }, allowed);
+}
+function headers(key, json = false) {
+  const result = { "X-Subscription-Token": key };
+  if (BRAVE_API_VERSION) {
+    result["Api-Version"] = BRAVE_API_VERSION;
+  }
+  if (json) {
+    result["content-type"] = "application/json";
+  }
+  return result;
+}
+function url(config, path, params) {
+  const u = new URL(`${base(config)}${path}`);
+  for (const [k, v] of Object.entries(params))
+    if (v !== void 0)
+      u.searchParams.set(k, Array.isArray(v) ? v.join(",") : String(v));
+  return u;
+}
+async function httpError(response) {
+  const text = (await response.text()).trim();
+  return `Brave API request failed (${response.status}${response.statusText ? ` ${response.statusText}` : ""})${text ? `: ${text}` : "."}`;
+}
+async function web(query2, maxResults, config, context, key, options) {
+  const params = {
+    q: query2,
+    count: clamp(maxResults),
+    text_decorations: false,
+    ...mergeOptions(options, "web", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles",
+      "extra_snippets",
+      "offset",
+      "enable_rich_callback"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/web/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(obj(p.web).results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          str(x.description) ?? arr(x.extra_snippets).join(" ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+async function llmContext(query2, maxResults, config, context, key, options) {
+  const params = {
+    q: query2,
+    count: clamp(maxResults),
+    maximum_number_of_urls: clamp(maxResults),
+    maximum_number_of_tokens: 8192,
+    enable_source_metadata: true,
+    ...mergeOptions(options, "llmContext", [
+      "count",
+      "maximum_number_of_urls",
+      "maximum_number_of_tokens",
+      "maximum_number_of_snippets",
+      "maximum_number_of_tokens_per_url",
+      "maximum_number_of_snippets_per_url",
+      "context_threshold_mode",
+      "enable_local",
+      "enable_source_metadata",
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/llm/context", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: collectLlmContextEntries(obj(p.grounding)).map((e) => {
+      const x = obj(e);
+      const snippets = arr(x.snippets).map(String);
+      const source = obj(x.source);
+      const u = str(x.url) ?? str(source.url) ?? "";
+      return {
+        title: str(x.title) ?? str(x.name) ?? str(source.title) ?? (u || "Untitled"),
+        url: u,
+        snippet: trimSnippet(snippets.join("\n\n"), 1200),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+function collectLlmContextEntries(grounding) {
+  const entries = [];
+  for (const value of [grounding.generic, grounding.map]) {
+    entries.push(...arr(value).map(obj));
+  }
+  const poiEntries = Array.isArray(grounding.poi) ? grounding.poi.map(obj) : [obj(grounding.poi)];
+  entries.push(...poiEntries.filter((entry) => Object.keys(entry).length > 0));
+  return entries;
+}
+async function news(query2, maxResults, config, context, key, options) {
+  const params = {
+    q: query2,
+    count: clamp(maxResults, 50),
+    ...mergeOptions(options, "news", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles",
+      "extra_snippets",
+      "offset",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/news/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      const source = str(x.source) ?? str(x.source_name);
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            str(x.description) ?? arr(x.extra_snippets).join(" "),
+            source,
+            str(x.age) ?? str(x.page_age)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults, 50))
+  };
+}
+async function videos(query2, maxResults, config, context, key, options) {
+  const params = {
+    q: query2,
+    count: clamp(maxResults, 50),
+    ...mergeOptions(options, "videos", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "offset",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/videos/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      const video = obj(x.video);
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            str(x.description),
+            str(video.creator) ?? str(x.creator),
+            str(video.duration) ?? str(x.duration),
+            num(video.views) ? `${num(video.views)} views` : void 0,
+            str(x.age) ?? str(x.page_age)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults, 50))
+  };
+}
+async function images(query2, maxResults, config, context, key, options) {
+  const params = {
+    q: query2,
+    count: clamp(maxResults),
+    ...mergeOptions(options, "images", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "safesearch",
+      "spellcheck",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/images/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const props = obj(x.properties);
+      const page = str(x.url) ?? str(x.source) ?? str(props.url) ?? "";
+      const image = str(props.url);
+      return {
+        title: str(x.title) || page || "Untitled",
+        url: page || image || "",
+        snippet: trimSnippet(
+          [str(x.description), str(x.publisher), image].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+async function places(query2, maxResults, config, context, key, options) {
+  const placeOptions = obj(options.places);
+  const params = {
+    q: query2,
+    count: clamp(maxResults),
+    ...mergeOptions(options, "places", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "latitude",
+      "longitude",
+      "location",
+      "radius",
+      "units",
+      "safesearch",
+      "spellcheck",
+      "geoloc",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/local/place_search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const p = obj(await r.json());
+  const rows = arr(p.results).slice(0, clamp(maxResults));
+  const ids = rows.map((e) => str(obj(e).id)).filter((id) => id !== void 0);
+  const [detailsById, descriptionsById] = await Promise.all([
+    placeOptions.includeDetails && ids.length > 0 ? fetchPlaceDetails(
+      config,
+      context,
+      key,
+      ids,
+      pick(params, ["search_lang", "ui_lang", "units"])
+    ) : Promise.resolve(/* @__PURE__ */ new Map()),
+    placeOptions.includeDescriptions && ids.length > 0 ? fetchPlaceDescriptions(config, context, key, ids) : Promise.resolve(/* @__PURE__ */ new Map())
+  ]);
+  return {
+    provider: "brave",
+    results: rows.map((e) => {
+      const x = obj(e);
+      const id = str(x.id);
+      const details = id ? detailsById.get(id) : void 0;
+      const description = id ? descriptionsById.get(id) : void 0;
+      const u = str(x.url) ?? str(x.provider_url) ?? "";
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            placeDescriptionText(description) ?? str(x.description),
+            placeAddress(x, details),
+            arr(x.categories).join(", "),
+            placeRating(x, details)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: {
+          ...x,
+          ...details ? { poiDetails: details } : {},
+          ...description ? { poiDescription: description } : {}
+        }
+      };
+    })
+  };
+}
+async function fetchPlaceDetails(config, context, key, ids, options) {
+  const r = await fetch(
+    urlWithRepeatedArrays(config, "/res/v1/local/pois", {
+      ids: ids.slice(0, 20),
+      ...options
+    }),
+    {
+      headers: headers(key),
+      signal: context.signal
+    }
+  );
+  if (!r.ok) throw new Error(await httpError(r));
+  return indexById(arr(obj(await r.json()).results));
+}
+async function fetchPlaceDescriptions(config, context, key, ids) {
+  const r = await fetch(
+    urlWithRepeatedArrays(config, "/res/v1/local/descriptions", {
+      ids: ids.slice(0, 20)
+    }),
+    {
+      headers: headers(key),
+      signal: context.signal
+    }
+  );
+  if (!r.ok) throw new Error(await httpError(r));
+  return indexById(arr(obj(await r.json()).results));
+}
+function urlWithRepeatedArrays(config, path, params) {
+  const u = new URL(`${base(config)}${path}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        u.searchParams.append(k, String(item));
+      }
+    } else {
+      u.searchParams.set(k, String(v));
+    }
+  }
+  return u;
+}
+function indexById(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const entry = obj(value);
+    const id = str(entry.id);
+    if (id) {
+      result.set(id, entry);
+    }
+  }
+  return result;
+}
+function placeDescriptionText(description) {
+  if (!description) return void 0;
+  return str(description.description) ?? str(description.text) ?? str(description.summary) ?? str(obj(description.description).text);
+}
+function placeAddress(place, details) {
+  return str(place.address) ?? str(obj(place.postal_address).displayAddress) ?? str(details?.address) ?? str(obj(details?.postal_address).displayAddress);
+}
+function placeRating(place, details) {
+  const rating = num(place.rating) ?? num(obj(place.rating).ratingValue) ?? num(details?.rating) ?? num(obj(details?.rating).ratingValue);
+  return rating === void 0 ? void 0 : `Rating: ${rating}`;
+}
+function buildAnswerRequest(raw) {
+  const answerOptions = pick(raw, [
+    "country",
+    "language",
+    "safesearch",
+    "enable_entities",
+    "enable_citations"
+  ]);
+  if (answerOptions.enable_citations === void 0) {
+    answerOptions.enable_citations = true;
+  }
+  const stream = answerOptions.enable_citations === true || answerOptions.enable_entities === true;
+  return {
+    stream,
+    ...pick(raw, ["max_completion_tokens", "metadata", "seed"]),
+    ...answerOptions
+  };
+}
+function buildResearchRequest(raw) {
+  const researchOptions = pick(raw, [
+    "country",
+    "language",
+    "safesearch",
+    "enable_entities",
+    "research_allow_thinking",
+    "research_maximum_number_of_tokens_per_query",
+    "research_maximum_number_of_queries",
+    "research_maximum_number_of_iterations",
+    "research_maximum_number_of_seconds",
+    "research_maximum_number_of_results_per_query"
+  ]);
+  return {
+    stream: true,
+    ...pick(raw, ["max_completion_tokens", "metadata", "seed"]),
+    ...researchOptions,
+    enable_research: true,
+    enable_citations: false
+  };
+}
+async function completion(input, config, context, request) {
+  const key = requireKey(config.credentials?.answers, "Brave Answers");
+  const body = {
+    model: "brave",
+    messages: [{ role: "user", content: input }],
+    ...request
+  };
+  const r = await fetch(`${base(config)}/res/v1/chat/completions`, {
+    method: "POST",
+    headers: headers(key, true),
+    body: JSON.stringify(body),
+    signal: context.signal
+  });
+  if (!r.ok) throw new Error(await httpError(r));
+  const text = await r.text();
+  const parsed = body.stream === false ? parseAnswerJson(text) : parseAnswerStream(text);
+  const lines = [parsed.answer.trim() || text.trim()];
+  if (parsed.citations.length) {
+    lines.push("", "Sources:");
+    parsed.citations.forEach((c, i) => {
+      lines.push(`${i + 1}. ${c.title ?? c.url ?? "Source"}`);
+      if (c.url) lines.push(`   ${c.url}`);
+    });
+  }
+  const metadata = buildAnswerMetadata(parsed);
+  return {
+    provider: "brave",
+    text: lines.join("\n").trimEnd(),
+    itemCount: parsed.citations.length,
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildAnswerMetadata(parsed) {
+  const metadata = {};
+  if (parsed.usage) {
+    metadata.usage = parsed.usage;
+  }
+  if (parsed.entities.length) {
+    metadata.entities = parsed.entities;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function parseAnswerJson(text) {
+  const payload = obj(JSON.parse(text));
+  const choice = obj(arr(payload.choices)[0]);
+  const message = obj(choice.message);
+  const content = str(message.content) ?? "";
+  const tags = extractBraveTags(content);
+  return {
+    answer: tags.text,
+    citations: dedupeCitations(tags.citations),
+    entities: tags.entities,
+    usage: payload.usage ?? tags.usage
+  };
+}
+function parseAnswerStream(text) {
+  let rawAnswer = "";
+  for (const line of text.split(/\r?\n/)) {
+    const data = line.startsWith("data:") ? line.slice(5).trim() : line.trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      const parsed = obj(JSON.parse(data));
+      const choice = obj(arr(parsed.choices)[0]);
+      const delta = str(obj(choice.delta).content);
+      if (delta) {
+        rawAnswer += delta;
+      }
+    } catch {
+      rawAnswer += data;
+    }
+  }
+  const tags = extractBraveTags(rawAnswer);
+  return {
+    answer: tags.text,
+    citations: dedupeCitations(tags.citations),
+    entities: tags.entities,
+    usage: tags.usage
+  };
+}
+function extractBraveTags(text) {
+  const citations = [];
+  const entities = [];
+  let usage;
+  let cleaned = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const tagStart = text.indexOf("<", offset);
+    if (tagStart === -1) {
+      cleaned += text.slice(offset);
+      break;
+    }
+    const parsedTag = readBraveTagStart(text, tagStart);
+    if (!parsedTag) {
+      cleaned += text.slice(offset, tagStart + 1);
+      offset = tagStart + 1;
+      continue;
+    }
+    const jsonEnd = findJsonValueEnd(text, parsedTag.jsonStart);
+    if (jsonEnd === -1) {
+      cleaned += text.slice(offset);
+      break;
+    }
+    cleaned += text.slice(offset, tagStart);
+    const json = text.slice(parsedTag.jsonStart, jsonEnd + 1);
+    try {
+      const parsed = JSON.parse(json);
+      if (parsedTag.tag === "answer") {
+        cleaned += str(parsed.answer) ?? str(parsed.text) ?? "";
+      } else if (parsedTag.tag === "citation") {
+        citations.push({
+          title: str(parsed.title),
+          url: str(parsed.url)
+        });
+      } else if (parsedTag.tag === "enum_item") {
+        const item = obj(parsed);
+        entities.push(item);
+        cleaned += str(item.original_tokens) ?? str(item.name) ?? str(item.href) ?? "";
+      } else if (parsedTag.tag === "usage") {
+        usage = parsed;
+      }
+    } catch {
+    }
+    const closing = `</${parsedTag.tag}>`;
+    const abbreviatedClosing = `</${parsedTag.tag}`;
+    if (text.startsWith(closing, jsonEnd + 1)) {
+      offset = jsonEnd + 1 + closing.length;
+    } else if (text.startsWith(abbreviatedClosing, jsonEnd + 1)) {
+      offset = jsonEnd + 1 + abbreviatedClosing.length;
+    } else {
+      offset = jsonEnd + 1;
+    }
+  }
+  return { text: cleaned, citations, entities, usage };
+}
+var BRAVE_STRUCTURED_TAGS = /* @__PURE__ */ new Set([
+  "analyzing",
+  "answer",
+  "blindspots",
+  "citation",
+  "enum_item",
+  "progress",
+  "queries",
+  "thinking",
+  "usage"
+]);
+function readBraveTagStart(text, tagStart) {
+  const match = /^<([A-Za-z_][A-Za-z0-9_-]*)(>)?[{[]/.exec(
+    text.slice(tagStart)
+  );
+  if (!match) return void 0;
+  const tag = match[1];
+  if (!BRAVE_STRUCTURED_TAGS.has(tag)) return void 0;
+  return {
+    tag,
+    jsonStart: tagStart + match[0].length - 1
+  };
+}
+function findJsonValueEnd(text, start) {
+  const first = text[start];
+  const closing = first === "{" ? "}" : first === "[" ? "]" : void 0;
+  if (!closing) return -1;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index++) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "{") {
+      stack.push("}");
+    } else if (char === "[") {
+      stack.push("]");
+    } else if (char === "}" || char === "]") {
+      if (stack.pop() !== char) return -1;
+      if (stack.length === 0) return index;
     }
   }
-  const envValue = process.env[reference];
-  if (envValue !== void 0) {
-    return envValue;
-  }
-  if (/^[A-Z][A-Z0-9_]*$/.test(reference)) {
-    return void 0;
-  }
-  return reference;
+  return -1;
 }
-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 dedupeCitations(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return citations.filter((citation) => {
+    const key = citation.url ?? citation.title;
+    if (!key) return false;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
+var braveProvider = defineProvider({
+  id: "brave",
+  label: braveImplementation.label,
+  docsUrl: braveImplementation.docsUrl,
+  config: {
+    createTemplate: () => braveImplementation.createTemplate(),
+    fields: ["credentials", "baseUrl", "options", "settings"],
+    credentials: {
+      search: "BRAVE_SEARCH_API_KEY",
+      answers: "BRAVE_ANSWERS_API_KEY",
+      autosuggest: "BRAVE_AUTOSUGGEST_API_KEY"
+    },
+    optionCapabilities: ["search", "answer", "research"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => braveImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: braveImplementation.getToolOptionsSchema("search"),
+      promptGuidelines: braveSearchPromptGuidelines,
+      async execute(input, ctx) {
+        return await braveImplementation.search(
+          input.query,
+          input.maxResults,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: braveImplementation.getToolOptionsSchema("answer"),
+      async execute(input, ctx) {
+        return await braveImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: braveImplementation.getToolOptionsSchema("research"),
+      async execute(input, ctx) {
+        return await braveImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/claude.ts
 import { existsSync } from "node:fs";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { Type as Type2 } from "typebox";
+import { Type as Type3 } from "typebox";
 
 // src/providers/schema.ts
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 function literalUnion(values, options) {
-  return Type.Union(
-    values.map((value) => Type.Literal(value)),
+  return Type2.Union(
+    values.map((value) => Type2.Literal(value)),
     options
   );
 }
 
-// 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 normalizeContentText(input) {
-  const text = (input ?? "").replace(/\r/g, "").trim();
-  if (!text) {
-    return "";
-  }
-  return text.split("\n").map((line) => line.replace(/[ \t]+$/g, "")).join("\n").replace(/\n{3,}/g, "\n\n");
-}
-function asJsonObject(value) {
-  return value ? { ...value } : {};
-}
-function formatJson(value) {
-  return JSON.stringify(value, null, 2);
-}
-function getApiKeyStatus(apiKeyReference) {
-  try {
-    return resolveConfigValue(apiKeyReference) ? { state: "ready" } : { state: "missing_api_key" };
-  } catch (error) {
-    return {
-      state: "invalid_config",
-      detail: formatConfigValueError(error)
-    };
-  }
-}
-function formatConfigValueError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.replace(/\s+/g, " ").trim() || "Failed to resolve config value";
-}
-
-// src/providers/definition.ts
-function defineCapability(definition) {
-  return definition;
-}
-function defineProvider(definition) {
-  return definition;
-}
-function defineProviders(providers) {
-  return providers;
-}
-async function executeProviderCapability(definition, capability, input, context) {
-  const handler = definition.capabilities[capability];
-  if (!handler) {
-    throw new Error(
-      `Provider '${definition.id}' does not support '${capability}'.`
-    );
-  }
-  return await handler.execute(input, context);
-}
-
 // src/providers/claude.ts
 var SEARCH_OUTPUT_SCHEMA = {
   type: "object",
@@ -184,36 +1296,36 @@ var ANSWER_OUTPUT_SCHEMA = {
   },
   required: ["answer", "sources"]
 };
-var claudeOptionsSchema = Type2.Object(
+var claudeOptionsSchema = Type3.Object(
   {
-    model: Type2.Optional(
-      Type2.String({ description: "Claude model override." })
+    model: Type3.Optional(
+      Type3.String({ description: "Claude model override." })
     ),
-    effort: Type2.Optional(
+    effort: Type3.Optional(
       literalUnion(["low", "medium", "high", "max"], {
         description: "How much effort Claude should use."
       })
     ),
-    maxTurns: Type2.Optional(
-      Type2.Integer({
+    maxTurns: Type3.Optional(
+      Type3.Integer({
         minimum: 1,
         description: "Maximum number of Claude turns."
       })
     ),
-    maxThinkingTokens: Type2.Optional(
-      Type2.Integer({ minimum: 0, description: "Maximum thinking tokens." })
+    maxThinkingTokens: Type3.Optional(
+      Type3.Integer({ minimum: 0, description: "Maximum thinking tokens." })
     ),
-    maxBudgetUsd: Type2.Optional(
-      Type2.Number({
+    maxBudgetUsd: Type3.Optional(
+      Type3.Number({
         exclusiveMinimum: 0,
         description: "Maximum budget in USD."
       })
     ),
-    thinking: Type2.Optional(
-      Type2.Object(
+    thinking: Type3.Optional(
+      Type3.Object(
         {
-          type: Type2.Optional(
-            Type2.String({ description: "Claude thinking mode." })
+          type: Type3.Optional(
+            Type3.String({ description: "Claude thinking mode." })
           )
         },
         {
@@ -508,13 +1620,13 @@ var claudeProvider = defineProvider({
 
 // src/providers/cloudflare.ts
 import CloudflareClient from "cloudflare";
-import { Type as Type3 } from "typebox";
-var cloudflareContentsOptionsSchema = Type3.Object(
+import { Type as Type4 } from "typebox";
+var cloudflareContentsOptionsSchema = Type4.Object(
   {
-    gotoOptions: Type3.Optional(
-      Type3.Object(
+    gotoOptions: Type4.Optional(
+      Type4.Object(
         {
-          waitUntil: Type3.Optional(
+          waitUntil: Type4.Optional(
             literalUnion(
               ["load", "domcontentloaded", "networkidle0", "networkidle2"],
               { description: "When to consider navigation complete." }
@@ -545,7 +1657,7 @@ var cloudflareImplementation = {
   },
   createTemplate() {
     return {
-      apiToken: "CLOUDFLARE_API_TOKEN",
+      credentials: { api: "CLOUDFLARE_API_TOKEN" },
       accountId: "CLOUDFLARE_ACCOUNT_ID",
       options: {
         gotoOptions: {
@@ -555,7 +1667,7 @@ var cloudflareImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    const apiTokenStatus = getApiKeyStatus(config?.apiToken);
+    const apiTokenStatus = getApiKeyStatus(config?.credentials?.api);
     if (apiTokenStatus.state !== "ready") {
       return apiTokenStatus;
     }
@@ -579,24 +1691,24 @@ var cloudflareImplementation = {
     }
     const defaults = asJsonObject(config.options);
     const answers = await Promise.all(
-      urls.map(async (url) => {
+      urls.map(async (url2) => {
         try {
           const markdown = await client.browserRendering.markdown.create(
             {
               ...defaults ?? {},
               ...options ?? {},
               account_id: accountId,
-              url
+              url: url2
             },
             buildRequestOptions(context)
           );
           return {
-            url,
+            url: url2,
             content: markdown
           };
         } catch (error) {
           return {
-            url,
+            url: url2,
             error: error instanceof Error ? error.message : String(error)
           };
         }
@@ -609,7 +1721,7 @@ var cloudflareImplementation = {
   }
 };
 function createClient(config) {
-  const apiToken = resolveConfigValue(config.apiToken);
+  const apiToken = resolveConfigValue(config.credentials?.api);
   if (!apiToken) {
     throw new Error("is missing an API token");
   }
@@ -626,7 +1738,7 @@ var cloudflareProvider = defineProvider({
   docsUrl: cloudflareImplementation.docsUrl,
   config: {
     createTemplate: () => cloudflareImplementation.createTemplate(),
-    fields: ["apiToken", "accountId", "options", "settings"]
+    fields: ["credentials", "accountId", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => cloudflareImplementation.getCapabilityStatus(
     config,
@@ -650,15 +1762,15 @@ var cloudflareProvider = defineProvider({
 
 // src/providers/codex.ts
 import { Codex as CodexClient } from "@openai/codex-sdk";
-import { Type as Type4 } from "typebox";
-var codexOutputSchema = Type4.Object(
+import { Type as Type5 } from "typebox";
+var codexOutputSchema = Type5.Object(
   {
-    sources: Type4.Array(
-      Type4.Object(
+    sources: Type5.Array(
+      Type5.Object(
         {
-          title: Type4.String(),
-          url: Type4.String(),
-          snippet: Type4.String()
+          title: Type5.String(),
+          url: Type5.String(),
+          snippet: Type5.String()
         },
         { additionalProperties: false }
       )
@@ -666,29 +1778,31 @@ var codexOutputSchema = Type4.Object(
   },
   { additionalProperties: false }
 );
-var codexSearchOptionsSchema = Type4.Object(
+var codexSearchOptionsSchema = Type5.Object(
   {
-    model: Type4.Optional(Type4.String({ description: "Codex model override." })),
-    modelReasoningEffort: Type4.Optional(
-      Type4.Union(
+    model: Type5.Optional(Type5.String({ description: "Codex model override." })),
+    modelReasoningEffort: Type5.Optional(
+      Type5.Union(
         [
-          Type4.Literal("minimal"),
-          Type4.Literal("low"),
-          Type4.Literal("medium"),
-          Type4.Literal("high"),
-          Type4.Literal("xhigh")
+          Type5.Literal("minimal"),
+          Type5.Literal("low"),
+          Type5.Literal("medium"),
+          Type5.Literal("high"),
+          Type5.Literal("xhigh")
         ],
         { description: "Reasoning depth for Codex." }
       )
     ),
-    webSearchMode: Type4.Optional(
-      Type4.Union(
+    webSearchMode: Type5.Optional(
+      Type5.Union(
         [
-          Type4.Literal("disabled"),
-          Type4.Literal("cached"),
-          Type4.Literal("live")
+          Type5.Literal("disabled"),
+          Type5.Literal("cached"),
+          Type5.Literal("live")
         ],
-        { description: "How Codex should source web results." }
+        {
+          description: "How Codex should source web results. Use 'live' for current information, 'cached' when freshness is less important, and 'disabled' only when web access should not be used."
+        }
       )
     )
   },
@@ -734,7 +1848,7 @@ var codexImplementation = {
     const codex = new CodexClient({
       codexPathOverride: config.codexPath,
       baseUrl: config.baseUrl,
-      apiKey: resolveConfigValue(config.apiKey),
+      apiKey: resolveConfigValue(config.credentials?.api),
       config: config.config,
       env: resolveEnvMap(config.env)
     });
@@ -859,7 +1973,7 @@ var codexProvider = defineProvider({
     fields: [
       "codexPath",
       "baseUrl",
-      "apiKey",
+      "credentials",
       "env",
       "config",
       "options",
@@ -1159,7 +2273,7 @@ function parseContentsAnswer(entry, index) {
     entry,
     `contents answer at index ${index} must be a JSON object`
   );
-  const url = readRequiredString(value.url, `answers[${index}].url`);
+  const url2 = readRequiredString(value.url, `answers[${index}].url`);
   const content = readOptionalString(
     value.content,
     `answers[${index}].content`
@@ -1176,7 +2290,7 @@ function parseContentsAnswer(entry, index) {
     );
   }
   return {
-    url,
+    url: url2,
     ...content !== void 0 ? { content } : {},
     ...summary !== void 0 ? { summary } : {},
     ...metadata !== void 0 ? { metadata } : {},
@@ -1291,7 +2405,7 @@ var customProvider = defineProvider({
 
 // src/providers/exa.ts
 import { Exa as ExaClient } from "exa-js";
-import { Type as Type5 } from "typebox";
+import { Type as Type6 } from "typebox";
 
 // src/execution-policy-defaults.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
@@ -1656,9 +2770,9 @@ function normalizeError(error) {
 }
 
 // src/providers/exa.ts
-var exaSearchOptionsSchema = Type5.Object(
+var exaSearchOptionsSchema = Type6.Object(
   {
-    type: Type5.Optional(
+    type: Type6.Optional(
       literalUnion(
         [
           "keyword",
@@ -1674,41 +2788,41 @@ var exaSearchOptionsSchema = Type5.Object(
         { description: "Exa search mode." }
       )
     ),
-    category: Type5.Optional(
-      Type5.String({
+    category: Type6.Optional(
+      Type6.String({
         description: "Filter by category (e.g., 'company', 'research paper')."
       })
     ),
-    includeDomains: Type5.Optional(
-      Type5.Array(Type5.String(), {
+    includeDomains: Type6.Optional(
+      Type6.Array(Type6.String(), {
         description: "Restrict results to these domains."
       })
     ),
-    excludeDomains: Type5.Optional(
-      Type5.Array(Type5.String(), { description: "Exclude these domains." })
+    excludeDomains: Type6.Optional(
+      Type6.Array(Type6.String(), { description: "Exclude these domains." })
     ),
-    startPublishedDate: Type5.Optional(
-      Type5.String({
+    startPublishedDate: Type6.Optional(
+      Type6.String({
         description: "ISO date string for earliest publish date."
       })
     ),
-    endPublishedDate: Type5.Optional(
-      Type5.String({ description: "ISO date string for latest publish date." })
+    endPublishedDate: Type6.Optional(
+      Type6.String({ description: "ISO date string for latest publish date." })
     ),
-    userLocation: Type5.Optional(
-      Type5.Object(
+    userLocation: Type6.Optional(
+      Type6.Object(
         {
-          country: Type5.Optional(
-            Type5.String({ description: "Country hint for the user location." })
+          country: Type6.Optional(
+            Type6.String({ description: "Country hint for the user location." })
           ),
-          region: Type5.Optional(
-            Type5.String({ description: "Region hint for the user location." })
+          region: Type6.Optional(
+            Type6.String({ description: "Region hint for the user location." })
           ),
-          city: Type5.Optional(
-            Type5.String({ description: "City hint for the user location." })
+          city: Type6.Optional(
+            Type6.String({ description: "City hint for the user location." })
           ),
-          timezone: Type5.Optional(
-            Type5.String({
+          timezone: Type6.Optional(
+            Type6.String({
               description: "Timezone hint for the user location."
             })
           )
@@ -1718,17 +2832,17 @@ var exaSearchOptionsSchema = Type5.Object(
         }
       )
     ),
-    contents: Type5.Optional(
-      Type5.Object(
+    contents: Type6.Optional(
+      Type6.Object(
         {
-          text: Type5.Optional(
-            Type5.Boolean({ description: "Include text content." })
+          text: Type6.Optional(
+            Type6.Boolean({ description: "Include text content." })
           ),
-          highlights: Type5.Optional(
-            Type5.Boolean({ description: "Include highlighted excerpts." })
+          highlights: Type6.Optional(
+            Type6.Boolean({ description: "Include highlighted excerpts." })
           ),
-          summary: Type5.Optional(
-            Type5.Boolean({ description: "Include AI-generated summary." })
+          summary: Type6.Optional(
+            Type6.Boolean({ description: "Include AI-generated summary." })
           )
         },
         { description: "What content to include in results." }
@@ -1751,7 +2865,7 @@ var exaImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "EXA_API_KEY",
+      credentials: { api: "EXA_API_KEY" },
       options: {
         search: {
           type: "auto",
@@ -1763,7 +2877,7 @@ var exaImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, _context, searchOptions) {
     const client = createClient2(config);
@@ -1791,16 +2905,16 @@ var exaImplementation = {
     const results = response.results ?? [];
     return {
       provider: exaImplementation.id,
-      answers: urls.map((url, index) => {
+      answers: urls.map((url2, index) => {
         const result = results[index];
         if (!result) {
           return {
-            url,
+            url: url2,
             error: "No content returned for this URL."
           };
         }
         return {
-          url,
+          url: url2,
           ...typeof result.text === "string" ? { content: result.text } : {},
           ...result.summary !== void 0 ? { summary: result.summary } : {},
           metadata: result
@@ -1883,7 +2997,7 @@ var exaImplementation = {
   }
 };
 function createClient2(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -1895,7 +3009,7 @@ var exaProvider = defineProvider({
   docsUrl: exaImplementation.docsUrl,
   config: {
     createTemplate: () => exaImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"],
+    fields: ["credentials", "baseUrl", "options", "settings"],
     optionCapabilities: ["search"]
   },
   getCapabilityStatus: (config, cwd, tool) => exaImplementation.getCapabilityStatus(
@@ -1955,55 +3069,55 @@ var exaProvider = defineProvider({
 
 // src/providers/firecrawl.ts
 import FirecrawlClient from "@mendable/firecrawl-js";
-import { Type as Type6 } from "typebox";
-var firecrawlSearchOptionsSchema = Type6.Object(
+import { Type as Type7 } from "typebox";
+var firecrawlSearchOptionsSchema = Type7.Object(
   {
-    lang: Type6.Optional(
-      Type6.String({
+    lang: Type7.Optional(
+      Type7.String({
         description: "Language code for search results (for example 'en')."
       })
     ),
-    country: Type6.Optional(
-      Type6.String({
+    country: Type7.Optional(
+      Type7.String({
         description: "Country code for search results (for example 'us')."
       })
     ),
-    sources: Type6.Optional(
-      Type6.Array(Type6.String(), {
+    sources: Type7.Optional(
+      Type7.Array(Type7.String(), {
         description: "Search source groups to include."
       })
     ),
-    categories: Type6.Optional(
-      Type6.Array(Type6.String(), {
+    categories: Type7.Optional(
+      Type7.Array(Type7.String(), {
         description: "Search categories to include."
       })
     ),
-    location: Type6.Optional(
-      Type6.Object(
+    location: Type7.Optional(
+      Type7.Object(
         {
-          country: Type6.Optional(Type6.String({ description: "Country hint." })),
-          region: Type6.Optional(Type6.String({ description: "Region hint." })),
-          city: Type6.Optional(Type6.String({ description: "City hint." }))
+          country: Type7.Optional(Type7.String({ description: "Country hint." })),
+          region: Type7.Optional(Type7.String({ description: "Region hint." })),
+          city: Type7.Optional(Type7.String({ description: "City hint." }))
         },
         { description: "Location hint for search." }
       )
     ),
-    timeout: Type6.Optional(
-      Type6.Integer({
+    timeout: Type7.Optional(
+      Type7.Integer({
         minimum: 0,
         description: "Request timeout in milliseconds."
       })
     ),
-    scrapeOptions: Type6.Optional(
-      Type6.Object(
+    scrapeOptions: Type7.Optional(
+      Type7.Object(
         {
-          formats: Type6.Optional(
-            Type6.Array(literalUnion(["markdown", "html", "rawHtml"]), {
+          formats: Type7.Optional(
+            Type7.Array(literalUnion(["markdown", "html", "rawHtml"]), {
               description: "Output formats."
             })
           ),
-          onlyMainContent: Type6.Optional(
-            Type6.Boolean({ description: "Extract only the main content." })
+          onlyMainContent: Type7.Optional(
+            Type7.Boolean({ description: "Extract only the main content." })
           )
         },
         {
@@ -2014,48 +3128,48 @@ var firecrawlSearchOptionsSchema = Type6.Object(
   },
   { description: "Firecrawl search options." }
 );
-var firecrawlScrapeOptionsSchema = Type6.Object(
+var firecrawlScrapeOptionsSchema = Type7.Object(
   {
-    formats: Type6.Optional(
-      Type6.Array(literalUnion(["markdown", "html", "rawHtml"]), {
+    formats: Type7.Optional(
+      Type7.Array(literalUnion(["markdown", "html", "rawHtml"]), {
         description: "Output formats for scraping."
       })
     ),
-    onlyMainContent: Type6.Optional(
-      Type6.Boolean({ description: "Extract only the main content." })
+    onlyMainContent: Type7.Optional(
+      Type7.Boolean({ description: "Extract only the main content." })
     ),
-    includeTags: Type6.Optional(
-      Type6.Array(Type6.String(), { description: "CSS selectors to include." })
+    includeTags: Type7.Optional(
+      Type7.Array(Type7.String(), { description: "CSS selectors to include." })
     ),
-    excludeTags: Type6.Optional(
-      Type6.Array(Type6.String(), { description: "CSS selectors to exclude." })
+    excludeTags: Type7.Optional(
+      Type7.Array(Type7.String(), { description: "CSS selectors to exclude." })
     ),
-    waitFor: Type6.Optional(
-      Type6.Integer({
+    waitFor: Type7.Optional(
+      Type7.Integer({
         minimum: 0,
         description: "Milliseconds to wait before scraping."
       })
     ),
-    headers: Type6.Optional(
-      Type6.Record(Type6.String(), Type6.String(), {
+    headers: Type7.Optional(
+      Type7.Record(Type7.String(), Type7.String(), {
         description: "Headers to send when scraping."
       })
     ),
-    location: Type6.Optional(
-      Type6.Object(
+    location: Type7.Optional(
+      Type7.Object(
         {
-          country: Type6.Optional(Type6.String({ description: "Country hint." })),
-          region: Type6.Optional(Type6.String({ description: "Region hint." })),
-          city: Type6.Optional(Type6.String({ description: "City hint." }))
+          country: Type7.Optional(Type7.String({ description: "Country hint." })),
+          region: Type7.Optional(Type7.String({ description: "Region hint." })),
+          city: Type7.Optional(Type7.String({ description: "City hint." }))
         },
         { description: "Location hint for scraping." }
       )
     ),
-    mobile: Type6.Optional(
-      Type6.Boolean({ description: "Use a mobile browser profile." })
+    mobile: Type7.Optional(
+      Type7.Boolean({ description: "Use a mobile browser profile." })
     ),
-    proxy: Type6.Optional(
-      Type6.String({
+    proxy: Type7.Optional(
+      Type7.String({
         description: "Proxy mode passed through to the Firecrawl SDK."
       })
     )
@@ -2078,7 +3192,7 @@ var firecrawlImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "FIRECRAWL_API_KEY",
+      credentials: { api: "FIRECRAWL_API_KEY" },
       options: {
         scrape: {
           formats: ["markdown"],
@@ -2088,7 +3202,7 @@ var firecrawlImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient3(config);
@@ -2115,23 +3229,23 @@ var firecrawlImplementation = {
     return {
       provider: firecrawlImplementation.id,
       answers: await Promise.all(
-        urls.map(async (url) => {
+        urls.map(async (url2) => {
           try {
-            const document = await client.scrape(url, scrapeOptions);
+            const document = await client.scrape(url2, scrapeOptions);
             const content = getDocumentContent(document);
             return content ? {
-              url,
+              url: url2,
               content,
               ...document.metadata ? {
                 metadata: document.metadata
               } : {}
             } : {
-              url,
+              url: url2,
               error: "No content returned for this URL."
             };
           } catch (error) {
             return {
-              url,
+              url: url2,
               error: error instanceof Error ? error.message : String(error)
             };
           }
@@ -2141,7 +3255,7 @@ var firecrawlImplementation = {
   }
 };
 function createClient3(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -2161,8 +3275,8 @@ function toSearchResult(source, value) {
     return null;
   }
   const metadata = asRecord(entry.metadata);
-  const url = readString2(entry.url) ?? readString2(metadata?.sourceURL) ?? readString2(entry.imageUrl) ?? "";
-  const title = readString2(entry.title) ?? readString2(metadata?.title) ?? url;
+  const url2 = readString2(entry.url) ?? readString2(metadata?.sourceURL) ?? readString2(entry.imageUrl) ?? "";
+  const title = readString2(entry.title) ?? readString2(metadata?.title) ?? url2;
   const snippet = trimSnippet(
     readString2(entry.description) ?? readString2(entry.snippet) ?? readString2(entry.markdown) ?? readString2(metadata?.description) ?? ""
   );
@@ -2176,7 +3290,7 @@ function toSearchResult(source, value) {
   };
   return {
     title: title || "Untitled",
-    url,
+    url: url2,
     snippet,
     metadata: Object.keys(resultMetadata).length > 1 ? resultMetadata : void 0
   };
@@ -2205,7 +3319,7 @@ var firecrawlProvider = defineProvider({
   docsUrl: firecrawlImplementation.docsUrl,
   config: {
     createTemplate: () => firecrawlImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"]
+    fields: ["credentials", "baseUrl", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => firecrawlImplementation.getCapabilityStatus(
     config,
@@ -2242,29 +3356,29 @@ var firecrawlProvider = defineProvider({
 
 // src/providers/gemini.ts
 import { GoogleGenAI } from "@google/genai";
-import { Type as Type7 } from "typebox";
+import { Type as Type8 } from "typebox";
 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 geminiGenerationConfigSchema = Type7.Object(
+var geminiGenerationConfigSchema = Type8.Object(
   {
-    temperature: Type7.Optional(
-      Type7.Number({ description: "Sampling temperature." })
+    temperature: Type8.Optional(
+      Type8.Number({ description: "Sampling temperature." })
     ),
-    topP: Type7.Optional(Type7.Number({ description: "Top-p sampling value." })),
-    topK: Type7.Optional(
-      Type7.Integer({ minimum: 0, description: "Top-k sampling value." })
+    topP: Type8.Optional(Type8.Number({ description: "Top-p sampling value." })),
+    topK: Type8.Optional(
+      Type8.Integer({ minimum: 0, description: "Top-k sampling value." })
     ),
-    candidateCount: Type7.Optional(
-      Type7.Integer({
+    candidateCount: Type8.Optional(
+      Type8.Integer({
         minimum: 1,
         description: "Number of candidates to generate."
       })
     ),
-    maxOutputTokens: Type7.Optional(
-      Type7.Integer({ minimum: 1, description: "Maximum output tokens." })
+    maxOutputTokens: Type8.Optional(
+      Type8.Integer({ minimum: 1, description: "Maximum output tokens." })
     ),
-    tool_choice: Type7.Optional(
+    tool_choice: Type8.Optional(
       literalUnion(["auto", "any", "none"], {
         description: "Tool choice mode for Gemini search interactions."
       })
@@ -2272,35 +3386,35 @@ var geminiGenerationConfigSchema = Type7.Object(
   },
   { description: "Gemini generation configuration." }
 );
-var geminiAnswerConfigSchema = Type7.Object(
+var geminiAnswerConfigSchema = Type8.Object(
   {
-    labels: Type7.Optional(
-      Type7.Record(Type7.String(), Type7.String(), {
+    labels: Type8.Optional(
+      Type8.Record(Type8.String(), Type8.String(), {
         description: "Request labels to attach to the Gemini call."
       })
     ),
-    temperature: Type7.Optional(
-      Type7.Number({ description: "Sampling temperature." })
+    temperature: Type8.Optional(
+      Type8.Number({ description: "Sampling temperature." })
     ),
-    topP: Type7.Optional(Type7.Number({ description: "Top-p sampling value." })),
-    topK: Type7.Optional(
-      Type7.Integer({ minimum: 0, description: "Top-k sampling value." })
+    topP: Type8.Optional(Type8.Number({ description: "Top-p sampling value." })),
+    topK: Type8.Optional(
+      Type8.Integer({ minimum: 0, description: "Top-k sampling value." })
     ),
-    candidateCount: Type7.Optional(
-      Type7.Integer({
+    candidateCount: Type8.Optional(
+      Type8.Integer({
         minimum: 1,
         description: "Number of candidates to generate."
       })
     ),
-    maxOutputTokens: Type7.Optional(
-      Type7.Integer({ minimum: 1, description: "Maximum output tokens." })
+    maxOutputTokens: Type8.Optional(
+      Type8.Integer({ minimum: 1, description: "Maximum output tokens." })
     )
   },
   { description: "Gemini generate-content config overrides." }
 );
-var geminiAgentConfigSchema = Type7.Object(
+var geminiAgentConfigSchema = Type8.Object(
   {
-    thinking_summaries: Type7.Optional(
+    thinking_summaries: Type8.Optional(
       literalUnion(["auto", "none"], {
         description: "Whether to include thought summaries in the response."
       })
@@ -2311,31 +3425,31 @@ var geminiAgentConfigSchema = Type7.Object(
     description: "Safe Gemini deep-research agent configuration. The provider adds the required type field."
   }
 );
-var geminiSearchOptionsSchema = Type7.Object(
+var geminiSearchOptionsSchema = Type8.Object(
   {
-    model: Type7.Optional(
-      Type7.String({
+    model: Type8.Optional(
+      Type8.String({
         description: "Gemini model for search (for example 'gemini-2.5-flash')."
       })
     ),
-    generation_config: Type7.Optional(geminiGenerationConfigSchema)
+    generation_config: Type8.Optional(geminiGenerationConfigSchema)
   },
   { description: "Gemini search options." }
 );
-var geminiAnswerOptionsSchema = Type7.Object(
+var geminiAnswerOptionsSchema = Type8.Object(
   {
-    model: Type7.Optional(
-      Type7.String({
+    model: Type8.Optional(
+      Type8.String({
         description: "Gemini model for answers (for example 'gemini-2.5-flash')."
       })
     ),
-    config: Type7.Optional(geminiAnswerConfigSchema)
+    config: Type8.Optional(geminiAnswerConfigSchema)
   },
   { description: "Gemini answer options." }
 );
-var geminiResearchOptionsSchema = Type7.Object(
+var geminiResearchOptionsSchema = Type8.Object(
   {
-    agent_config: Type7.Optional(geminiAgentConfigSchema)
+    agent_config: Type8.Optional(geminiAgentConfigSchema)
   },
   { additionalProperties: false, description: "Gemini research options." }
 );
@@ -2357,7 +3471,7 @@ var geminiImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "GOOGLE_API_KEY",
+      credentials: { api: "GOOGLE_API_KEY" },
       options: {
         searchModel: DEFAULT_SEARCH_MODEL,
         answerModel: DEFAULT_ANSWER_MODEL,
@@ -2366,7 +3480,7 @@ var geminiImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, context, options) {
     const ai = this.createClient(config);
@@ -2505,7 +3619,7 @@ var geminiImplementation = {
     return status === "in_progress" ? { status: "in_progress" } : { status: "in_progress", statusText: status };
   },
   createClient(config) {
-    const apiKey = resolveConfigValue(config.apiKey);
+    const apiKey = resolveConfigValue(config.credentials?.api);
     if (!apiKey) {
       throw new Error("is missing an API key");
     }
@@ -2649,11 +3763,11 @@ function normalizeHtmlAttributeValue(value) {
   return readNonEmptyString3(value);
 }
 function normalizeSearchUrl(value) {
-  const url = normalizeHtmlAttributeValue(value);
-  if (!url || url.startsWith("#") || /^javascript:/i.test(url)) {
+  const url2 = normalizeHtmlAttributeValue(value);
+  if (!url2 || url2.startsWith("#") || /^javascript:/i.test(url2)) {
     return void 0;
   }
-  return url;
+  return url2;
 }
 function decodeHtmlEntities(text) {
   return text.replace(
@@ -2688,20 +3802,20 @@ function extractGroundingSources(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 rawUrl = typeof web.uri === "string" ? web.uri : "";
+    const web2 = typeof chunk === "object" && chunk !== null && "web" in chunk && typeof chunk.web === "object" && chunk.web !== null ? chunk.web : void 0;
+    if (!web2) continue;
+    const rawUrl = typeof web2.uri === "string" ? web2.uri : "";
     const title = formatGroundingSourceTitle(
-      typeof web.title === "string" ? web.title : rawUrl,
+      typeof web2.title === "string" ? web2.title : rawUrl,
       rawUrl
     );
-    const url = formatGroundingSourceUrl(rawUrl);
-    const key = [title.toLowerCase(), url.toLowerCase()].join("::");
+    const url2 = formatGroundingSourceUrl(rawUrl);
+    const key = [title.toLowerCase(), url2.toLowerCase()].join("::");
     if (seen.has(key)) continue;
     seen.add(key);
     sources.push({
       title,
-      url
+      url: url2
     });
     if (sources.length >= maxSources) {
       break;
@@ -2724,32 +3838,32 @@ function formatInteractionOutputs(outputs) {
   }
   return lines.join("\n\n").trim();
 }
-function formatGroundingSourceTitle(title, url) {
+function formatGroundingSourceTitle(title, url2) {
   const trimmedTitle = title?.trim();
   if (trimmedTitle) {
     return trimmedTitle;
   }
-  if (url) {
+  if (url2) {
     try {
-      return new URL(url).hostname;
+      return new URL(url2).hostname;
     } catch {
-      return url;
+      return url2;
     }
   }
   return "Untitled";
 }
-function formatGroundingSourceUrl(url) {
-  if (!url) {
+function formatGroundingSourceUrl(url2) {
+  if (!url2) {
     return "";
   }
-  if (isGoogleGroundingRedirect(url)) {
+  if (isGoogleGroundingRedirect(url2)) {
     return "";
   }
-  return url;
+  return url2;
 }
-function isGoogleGroundingRedirect(url) {
+function isGoogleGroundingRedirect(url2) {
   try {
-    const parsed = new URL(url);
+    const parsed = new URL(url2);
     return parsed.hostname === "vertexaisearch.cloud.google.com" && parsed.pathname.startsWith("/grounding-api-redirect/");
   } catch {
     return false;
@@ -2870,22 +3984,22 @@ function isBuiltInToolChoiceError(error) {
   }
   return false;
 }
-async function resolveGoogleSearchUrl(url, signal) {
-  if (!url) {
+async function resolveGoogleSearchUrl(url2, signal) {
+  if (!url2) {
     return void 0;
   }
-  if (!isGoogleGroundingRedirect(url)) {
-    return url;
+  if (!isGoogleGroundingRedirect(url2)) {
+    return url2;
   }
   try {
-    const response = await fetch(url, {
+    const response = await fetch(url2, {
       method: "HEAD",
       redirect: "manual",
       signal
     });
-    return response.headers.get("location") || url;
+    return response.headers.get("location") || url2;
   } catch {
-    return url;
+    return url2;
   }
 }
 function buildGeminiSearchRequest(query2, defaultModel, options) {
@@ -2993,7 +4107,7 @@ var geminiProvider = defineProvider({
   docsUrl: geminiImplementation.docsUrl,
   config: {
     createTemplate: () => geminiImplementation.createTemplate(),
-    fields: ["apiKey", "options", "settings"]
+    fields: ["credentials", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => geminiImplementation.getCapabilityStatus(
     config,
@@ -3043,46 +4157,46 @@ var geminiProvider = defineProvider({
 import {
   LinkupClient
 } from "linkup-sdk";
-import { Type as Type8 } from "typebox";
-var linkupSearchOptionsSchema = Type8.Object(
+import { Type as Type9 } from "typebox";
+var linkupSearchOptionsSchema = Type9.Object(
   {
-    depth: Type8.Optional(
+    depth: Type9.Optional(
       literalUnion(["standard", "deep"], {
         description: "Search depth. 'deep' is slower but more thorough."
       })
     ),
-    includeImages: Type8.Optional(
-      Type8.Boolean({ description: "Include images in search results." })
+    includeImages: Type9.Optional(
+      Type9.Boolean({ description: "Include images in search results." })
     ),
-    includeDomains: Type8.Optional(
-      Type8.Array(Type8.String(), {
+    includeDomains: Type9.Optional(
+      Type9.Array(Type9.String(), {
         description: "Restrict results to these domains."
       })
     ),
-    excludeDomains: Type8.Optional(
-      Type8.Array(Type8.String(), { description: "Exclude these domains." })
+    excludeDomains: Type9.Optional(
+      Type9.Array(Type9.String(), { description: "Exclude these domains." })
     ),
-    fromDate: Type8.Optional(
-      Type8.String({ description: "ISO date string for earliest result date." })
+    fromDate: Type9.Optional(
+      Type9.String({ description: "ISO date string for earliest result date." })
     ),
-    toDate: Type8.Optional(
-      Type8.String({ description: "ISO date string for latest result date." })
+    toDate: Type9.Optional(
+      Type9.String({ description: "ISO date string for latest result date." })
     )
   },
   { description: "Linkup search options." }
 );
-var linkupContentsOptionsSchema = Type8.Object(
+var linkupContentsOptionsSchema = Type9.Object(
   {
-    renderJs: Type8.Optional(
-      Type8.Boolean({
+    renderJs: Type9.Optional(
+      Type9.Boolean({
         description: "Render JavaScript before extracting content."
       })
     ),
-    includeRawHtml: Type8.Optional(
-      Type8.Boolean({ description: "Include raw HTML in the response." })
+    includeRawHtml: Type9.Optional(
+      Type9.Boolean({ description: "Include raw HTML in the response." })
     ),
-    extractImages: Type8.Optional(
-      Type8.Boolean({ description: "Extract images from the page." })
+    extractImages: Type9.Optional(
+      Type9.Boolean({ description: "Extract images from the page." })
     )
   },
   { description: "Linkup fetch options." }
@@ -3103,11 +4217,11 @@ var linkupImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "LINKUP_API_KEY"
+      credentials: { api: "LINKUP_API_KEY" }
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient4(config);
@@ -3129,24 +4243,24 @@ var linkupImplementation = {
     return {
       provider: linkupImplementation.id,
       answers: await Promise.all(
-        urls.map(async (url) => {
+        urls.map(async (url2) => {
           try {
             const response = await client.fetch(
-              buildFetchParams(url, {
+              buildFetchParams(url2, {
                 ...defaults,
                 ...options ?? {}
               })
             );
             return response.markdown ? {
-              url,
+              url: url2,
               content: response.markdown
             } : {
-              url,
+              url: url2,
               error: "No content returned for this URL."
             };
           } catch (error) {
             return {
-              url,
+              url: url2,
               error: error instanceof Error ? error.message : String(error)
             };
           }
@@ -3185,20 +4299,20 @@ function buildSearchParams(query2, maxResults, options) {
     ...searchOptions.toDate !== void 0 ? { toDate: toDate(searchOptions.toDate, "toDate") } : {}
   };
 }
-function buildFetchParams(url, options) {
+function buildFetchParams(url2, options) {
   const fetchOptions = options;
   if (fetchOptions.url !== void 0) {
     throw new Error("Linkup fetch options cannot override the managed URL.");
   }
   return {
-    url,
+    url: url2,
     ...fetchOptions.renderJs !== void 0 ? { renderJs: fetchOptions.renderJs } : {},
     ...fetchOptions.includeRawHtml !== void 0 ? { includeRawHtml: fetchOptions.includeRawHtml } : {},
     ...fetchOptions.extractImages !== void 0 ? { extractImages: fetchOptions.extractImages } : {}
   };
 }
 function createClient4(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -3212,8 +4326,8 @@ function toSearchResult2(value) {
   if (!entry) {
     return null;
   }
-  const url = readString3(entry.url) ?? "";
-  const title = readString3(entry.name) ?? (url || "Untitled");
+  const url2 = readString3(entry.url) ?? "";
+  const title = readString3(entry.name) ?? (url2 || "Untitled");
   const type = readString3(entry.type);
   const favicon = readString3(entry.favicon);
   const snippet = type === "text" ? trimSnippet(readString3(entry.content) ?? "") : "";
@@ -3223,7 +4337,7 @@ function toSearchResult2(value) {
   };
   return {
     title,
-    url,
+    url: url2,
     snippet,
     metadata: Object.keys(metadata).length > 0 ? metadata : void 0
   };
@@ -3249,7 +4363,7 @@ var linkupProvider = defineProvider({
   docsUrl: linkupImplementation.docsUrl,
   config: {
     createTemplate: () => linkupImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"]
+    fields: ["credentials", "baseUrl", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => linkupImplementation.getCapabilityStatus(
     config,
@@ -3285,7 +4399,7 @@ var linkupProvider = defineProvider({
 });
 
 // src/providers/ollama.ts
-var DEFAULT_BASE_URL = "https://ollama.com";
+var DEFAULT_BASE_URL2 = "https://ollama.com";
 var WEB_SEARCH_PATH = "/api/web_search";
 var WEB_FETCH_PATH = "/api/web_fetch";
 var ollamaProvider = defineProvider({
@@ -3295,13 +4409,13 @@ var ollamaProvider = defineProvider({
   config: {
     createTemplate() {
       return {
-        apiKey: "OLLAMA_API_KEY"
+        credentials: { api: "OLLAMA_API_KEY" }
       };
     },
-    fields: ["apiKey", "baseUrl", "settings"]
+    fields: ["credentials", "baseUrl", "settings"]
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   capabilities: {
     search: defineCapability({
@@ -3355,19 +4469,19 @@ async function fetchOllamaContents(urls, config, context) {
   return {
     provider: ollamaProvider.id,
     answers: await Promise.all(
-      urls.map(async (url) => {
+      urls.map(async (url2) => {
         try {
           const response = await fetch(endpoint, {
             method: "POST",
             headers: buildHeaders(apiKey),
             body: JSON.stringify({
-              url
+              url: url2
             }),
             signal: context.signal
           });
           if (!response.ok) {
             return {
-              url,
+              url: url2,
               error: await buildHttpError(response)
             };
           }
@@ -3375,19 +4489,19 @@ async function fetchOllamaContents(urls, config, context) {
           const content = normalizeContentText(data.content);
           if (!content) {
             return {
-              url,
+              url: url2,
               error: "No content returned for this URL."
             };
           }
           const metadata = buildFetchMetadata(data);
           return {
-            url,
+            url: url2,
             content,
             ...metadata ? { metadata } : {}
           };
         } catch (error) {
           return {
-            url,
+            url: url2,
             error: error instanceof Error ? error.message : String(error)
           };
         }
@@ -3396,7 +4510,7 @@ async function fetchOllamaContents(urls, config, context) {
   };
 }
 function resolveApiKey(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -3409,16 +4523,16 @@ function buildHeaders(apiKey) {
   };
 }
 function resolveEndpoint(baseUrlReference, endpointPath) {
-  const baseUrl = resolveConfigValue(baseUrlReference) ?? DEFAULT_BASE_URL;
-  const base = baseUrl.replace(/\/+$/, "");
+  const baseUrl = resolveConfigValue(baseUrlReference) ?? DEFAULT_BASE_URL2;
+  const base2 = baseUrl.replace(/\/+$/, "");
   const apiPath = endpointPath.replace(/^\/api\//, "");
-  if (base.endsWith(endpointPath)) {
-    return base;
+  if (base2.endsWith(endpointPath)) {
+    return base2;
   }
-  if (base.endsWith("/api")) {
-    return `${base}/${apiPath}`;
+  if (base2.endsWith("/api")) {
+    return `${base2}/${apiPath}`;
   }
-  return `${base}${endpointPath}`;
+  return `${base2}${endpointPath}`;
 }
 function clampMaxResults(value) {
   return Math.max(1, Math.min(10, Math.trunc(value || 0)));
@@ -3457,55 +4571,55 @@ function buildFetchMetadata(data) {
 }
 
 // src/providers/openai.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type10 } from "typebox";
 import OpenAI from "openai";
 var DEFAULT_SEARCH_MODEL2 = "gpt-4.1";
 var DEFAULT_ANSWER_MODEL2 = "gpt-4.1";
 var DEFAULT_RESEARCH_MODEL = "o4-mini-deep-research";
-var openaiSearchOptionsSchema = Type9.Object(
+var openaiSearchOptionsSchema = Type10.Object(
   {
-    model: Type9.Optional(
-      Type9.String({
+    model: Type10.Optional(
+      Type10.String({
         description: "OpenAI model to use for web search (for example 'gpt-4.1')."
       })
     ),
-    instructions: Type9.Optional(
-      Type9.String({
+    instructions: Type10.Optional(
+      Type10.String({
         description: "Optional instructions that shape source selection and result style."
       })
     )
   },
   { description: "OpenAI search options." }
 );
-var openaiAnswerOptionsSchema = Type9.Object(
+var openaiAnswerOptionsSchema = Type10.Object(
   {
-    model: Type9.Optional(
-      Type9.String({
+    model: Type10.Optional(
+      Type10.String({
         description: "OpenAI model to use for grounded answers (for example 'gpt-4.1')."
       })
     ),
-    instructions: Type9.Optional(
-      Type9.String({
+    instructions: Type10.Optional(
+      Type10.String({
         description: "Optional instructions that shape the answer structure, tone, and source selection."
       })
     )
   },
   { description: "OpenAI answer options." }
 );
-var openaiResearchOptionsSchema = Type9.Object(
+var openaiResearchOptionsSchema = Type10.Object(
   {
-    model: Type9.Optional(
-      Type9.String({
+    model: Type10.Optional(
+      Type10.String({
         description: "OpenAI deep research model to use (for example 'o4-mini-deep-research')."
       })
     ),
-    instructions: Type9.Optional(
-      Type9.String({
+    instructions: Type10.Optional(
+      Type10.String({
         description: "Optional instructions that shape the report structure, tone, and source selection."
       })
     ),
-    max_tool_calls: Type9.Optional(
-      Type9.Integer({
+    max_tool_calls: Type10.Optional(
+      Type10.Integer({
         minimum: 1,
         description: "Maximum number of built-in tool calls the model may make during the research run."
       })
@@ -3551,7 +4665,7 @@ var openaiImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "OPENAI_API_KEY",
+      credentials: { api: "OPENAI_API_KEY" },
       options: {
         search: {
           model: DEFAULT_SEARCH_MODEL2
@@ -3566,7 +4680,7 @@ var openaiImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, context, options) {
     const client = createClient5(config);
@@ -3645,7 +4759,7 @@ var openaiImplementation = {
   }
 };
 function createClient5(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -3835,15 +4949,15 @@ function extractUrlCitations(response) {
           continue;
         }
         const title = readNonEmptyString4(annotation.title);
-        const url = readNonEmptyString4(annotation.url);
+        const url2 = readNonEmptyString4(annotation.url);
         const startIndex = readInteger(annotation.start_index);
         const endIndex = readInteger(annotation.end_index);
-        if (!title || !url || startIndex === void 0 || endIndex === void 0) {
+        if (!title || !url2 || startIndex === void 0 || endIndex === void 0) {
           continue;
         }
         const citation = {
           title,
-          url,
+          url: url2,
           startIndex,
           endIndex
         };
@@ -3882,18 +4996,18 @@ function parseSearchPayload(text) {
       }
       const entry = source;
       const title = readNonEmptyString4(entry.title);
-      const url = readNonEmptyString4(entry.url);
+      const url2 = readNonEmptyString4(entry.url);
       const snippet = readNonEmptyString4(entry.snippet);
       if (!title) {
         throw new Error(`search source at index ${index} is missing title`);
       }
-      if (!url) {
+      if (!url2) {
         throw new Error(`search source at index ${index} is missing url`);
       }
       if (!snippet) {
         throw new Error(`search source at index ${index} is missing snippet`);
       }
-      return { title, url, snippet };
+      return { title, url: url2, snippet };
     })
   };
 }
@@ -3919,7 +5033,7 @@ var openaiProvider = defineProvider({
   docsUrl: openaiImplementation.docsUrl,
   config: {
     createTemplate: () => openaiImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"],
+    fields: ["credentials", "baseUrl", "options", "settings"],
     optionCapabilities: ["search", "answer", "research"]
   },
   getCapabilityStatus: (config, cwd, tool) => openaiImplementation.getCapabilityStatus(
@@ -3967,25 +5081,25 @@ var openaiProvider = defineProvider({
 });
 
 // src/providers/parallel.ts
-import { Type as Type10 } from "typebox";
 import ParallelClient from "parallel-web";
-var parallelSearchOptionsSchema = Type10.Object(
+import { Type as Type11 } from "typebox";
+var parallelSearchOptionsSchema = Type11.Object(
   {
-    mode: Type10.Optional(
+    mode: Type11.Optional(
       literalUnion(["agentic", "one-shot"], {
-        description: "Parallel search mode."
+        description: "Parallel search mode. Use 'agentic' for exploratory or multi-step source discovery and 'one-shot' for direct, simple searches."
       })
     )
   },
   { description: "Parallel search options." }
 );
-var parallelExtractOptionsSchema = Type10.Object(
+var parallelExtractOptionsSchema = Type11.Object(
   {
-    excerpts: Type10.Optional(
-      Type10.Boolean({ description: "Include excerpts in extraction results." })
+    excerpts: Type11.Optional(
+      Type11.Boolean({ description: "Include excerpts in extraction results." })
     ),
-    full_content: Type10.Optional(
-      Type10.Boolean({
+    full_content: Type11.Optional(
+      Type11.Boolean({
         description: "Include full page content in extraction results."
       })
     )
@@ -4008,7 +5122,7 @@ var parallelImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "PARALLEL_API_KEY",
+      credentials: { api: "PARALLEL_API_KEY" },
       options: {
         search: {
           mode: "agentic"
@@ -4021,7 +5135,7 @@ var parallelImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, context, options) {
     const client = createClient6(config);
@@ -4063,21 +5177,21 @@ var parallelImplementation = {
     );
     return {
       provider: parallelImplementation.id,
-      answers: urls.map((url) => {
-        const result = resultsByUrl.get(url);
+      answers: urls.map((url2) => {
+        const result = resultsByUrl.get(url2);
         if (result) {
           return {
-            url,
+            url: url2,
             content: result.full_content ?? result.excerpts?.join("\n\n") ?? void 0,
             metadata: result
           };
         }
-        const error = errorsByUrl.get(url);
+        const error = errorsByUrl.get(url2);
         return error ? {
-          url,
+          url: url2,
           error: formatJson(error)
         } : {
-          url,
+          url: url2,
           error: "No content returned for this URL."
         };
       })
@@ -4085,7 +5199,7 @@ var parallelImplementation = {
   }
 };
 function createClient6(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -4103,7 +5217,7 @@ var parallelProvider = defineProvider({
   docsUrl: parallelImplementation.docsUrl,
   config: {
     createTemplate: () => parallelImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"]
+    fields: ["credentials", "baseUrl", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => parallelImplementation.getCapabilityStatus(
     config,
@@ -4140,42 +5254,44 @@ var parallelProvider = defineProvider({
 
 // src/providers/perplexity.ts
 import PerplexityClient from "@perplexity-ai/perplexity_ai";
-import { Type as Type11 } from "typebox";
+import { Type as Type12 } from "typebox";
 var DEFAULT_ANSWER_MODEL3 = "sonar";
 var DEFAULT_RESEARCH_MODEL2 = "sonar-deep-research";
-var perplexitySearchOptionsSchema = Type11.Object(
+var perplexitySearchOptionsSchema = Type12.Object(
   {
-    country: Type11.Optional(
-      Type11.String({ description: "Country hint for search results." })
+    country: Type12.Optional(
+      Type12.String({ description: "Country hint for search results." })
     ),
-    search_mode: Type11.Optional(
-      Type11.String({ description: "Perplexity search mode." })
+    search_mode: Type12.Optional(
+      Type12.String({
+        description: "Perplexity search mode. Choose the provider mode that best matches the user's intent, such as broad web search versus academic or other specialized retrieval modes supported by Perplexity."
+      })
     ),
-    search_domain_filter: Type11.Optional(
-      Type11.Array(Type11.String(), {
+    search_domain_filter: Type12.Optional(
+      Type12.Array(Type12.String(), {
         description: "Restrict search results to these domains."
       })
     ),
-    search_recency_filter: Type11.Optional(
-      Type11.String({ description: "Recency filter for search results." })
+    search_recency_filter: Type12.Optional(
+      Type12.String({ description: "Recency filter for search results." })
     )
   },
   { description: "Perplexity search options." }
 );
-var perplexityAnswerOptionsSchema = Type11.Object(
+var perplexityAnswerOptionsSchema = Type12.Object(
   {
-    model: Type11.Optional(
-      Type11.String({
+    model: Type12.Optional(
+      Type12.String({
         description: "Perplexity model to use (for example 'sonar' or 'sonar-pro')."
       })
     )
   },
   { description: "Perplexity answer options." }
 );
-var perplexityResearchOptionsSchema = Type11.Object(
+var perplexityResearchOptionsSchema = Type12.Object(
   {
-    model: Type11.Optional(
-      Type11.String({
+    model: Type12.Optional(
+      Type12.String({
         description: "Perplexity model to use (for example 'sonar-deep-research')."
       })
     )
@@ -4200,7 +5316,7 @@ var perplexityImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "PERPLEXITY_API_KEY",
+      credentials: { api: "PERPLEXITY_API_KEY" },
       options: {
         answer: {
           model: DEFAULT_ANSWER_MODEL3
@@ -4212,7 +5328,7 @@ var perplexityImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, context, options) {
     const client = createClient7(config);
@@ -4335,7 +5451,7 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
   };
 }
 function createClient7(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -4386,29 +5502,29 @@ function dedupeSources(sources) {
   const unique = [];
   for (const source of sources) {
     const title = source.title.trim() || source.url.trim() || "Untitled";
-    const url = source.url.trim();
-    if (!url) continue;
-    const key = `${title.toLowerCase()}::${url.toLowerCase()}`;
+    const url2 = source.url.trim();
+    if (!url2) continue;
+    const key = `${title.toLowerCase()}::${url2.toLowerCase()}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    unique.push({ title, url });
+    unique.push({ title, url: url2 });
   }
   return unique;
 }
 function extractSources(response) {
   const searchResults = response.search_results?.flatMap((result) => {
-    const url = result.url?.trim() ?? "";
-    if (!url) {
+    const url2 = result.url?.trim() ?? "";
+    if (!url2) {
       return [];
     }
-    return [{ title: result.title?.trim() ?? url, url }];
+    return [{ title: result.title?.trim() ?? url2, url: url2 }];
   }) ?? [];
   if (searchResults.length > 0) {
     return searchResults;
   }
   return response.citations?.flatMap((citation) => {
-    const url = citation?.trim() ?? "";
-    return url ? [{ title: url, url }] : [];
+    const url2 = citation?.trim() ?? "";
+    return url2 ? [{ title: url2, url: url2 }] : [];
   }) ?? [];
 }
 function buildRequestOptions4(context) {
@@ -4420,7 +5536,7 @@ var perplexityProvider = defineProvider({
   docsUrl: perplexityImplementation.docsUrl,
   config: {
     createTemplate: () => perplexityImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"]
+    fields: ["credentials", "baseUrl", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => perplexityImplementation.getCapabilityStatus(
     config,
@@ -4467,33 +5583,33 @@ var perplexityProvider = defineProvider({
 });
 
 // src/providers/serper.ts
-import { Type as Type12 } from "typebox";
-var DEFAULT_BASE_URL2 = "https://google.serper.dev";
-var serperSearchOptionsSchema = Type12.Object(
+import { Type as Type13 } from "typebox";
+var DEFAULT_BASE_URL3 = "https://google.serper.dev";
+var serperSearchOptionsSchema = Type13.Object(
   {
-    gl: Type12.Optional(
-      Type12.String({
+    gl: Type13.Optional(
+      Type13.String({
         description: "Country code hint for Google results (for example 'us')."
       })
     ),
-    hl: Type12.Optional(
-      Type12.String({
+    hl: Type13.Optional(
+      Type13.String({
         description: "Language code hint for Google results (for example 'en')."
       })
     ),
-    location: Type12.Optional(
-      Type12.String({
+    location: Type13.Optional(
+      Type13.String({
         description: "Geographic location hint for Google results."
       })
     ),
-    page: Type12.Optional(
-      Type12.Integer({
+    page: Type13.Optional(
+      Type13.Integer({
         minimum: 1,
         description: "1-based results page to request from Serper."
       })
     ),
-    autocorrect: Type12.Optional(
-      Type12.Boolean({
+    autocorrect: Type13.Optional(
+      Type13.Boolean({
         description: "Enable or disable Serper query autocorrection."
       })
     )
@@ -4514,15 +5630,15 @@ var serperImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "SERPER_API_KEY",
+      credentials: { api: "SERPER_API_KEY" },
       options: {}
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, context, options) {
-    const apiKey = resolveConfigValue(config.apiKey);
+    const apiKey = resolveConfigValue(config.credentials?.api);
     if (!apiKey) {
       throw new Error("is missing an API key");
     }
@@ -4565,8 +5681,8 @@ var serperImplementation = {
   }
 };
 function joinUrl(baseUrl) {
-  const base = (baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
-  return `${base}/search`;
+  const base2 = (baseUrl ?? DEFAULT_BASE_URL3).replace(/\/+$/, "");
+  return `${base2}/search`;
 }
 function clampMaxResults2(value) {
   return Math.max(1, Math.min(20, Math.trunc(value || 0)));
@@ -4598,8 +5714,8 @@ function toSearchResult3(entry, searchContext) {
   if (!record) {
     return null;
   }
-  const url = readString4(record.link) ?? "";
-  const title = readString4(record.title) || url || "Untitled";
+  const url2 = readString4(record.link) ?? "";
+  const title = readString4(record.title) || url2 || "Untitled";
   const snippet = trimSnippet(
     readString4(record.snippet) ?? readString4(record.richSnippet) ?? readString4(record.date) ?? ""
   );
@@ -4617,7 +5733,7 @@ function toSearchResult3(entry, searchContext) {
   });
   return {
     title,
-    url,
+    url: url2,
     snippet,
     ...Object.keys(metadata).length > 0 ? { metadata } : {}
   };
@@ -4669,7 +5785,7 @@ var serperProvider = defineProvider({
   docsUrl: serperImplementation.docsUrl,
   config: {
     createTemplate: () => serperImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"],
+    fields: ["credentials", "baseUrl", "options", "settings"],
     optionCapabilities: ["search"]
   },
   getCapabilityStatus: (config, cwd, tool) => serperImplementation.getCapabilityStatus(
@@ -4695,55 +5811,55 @@ var serperProvider = defineProvider({
 });
 
 // src/providers/tavily.ts
-import { Type as Type13 } from "typebox";
 import {
   tavily
 } from "@tavily/core";
-var tavilySearchOptionsSchema = Type13.Object(
+import { Type as Type14 } from "typebox";
+var tavilySearchOptionsSchema = Type14.Object(
   {
-    topic: Type13.Optional(
+    topic: Type14.Optional(
       literalUnion(["general", "news", "finance"], {
-        description: "Category of the search query."
+        description: "Category of the search query. Use 'news' for recent journalism or current events, 'finance' for markets or company financial data, and 'general' for broad web search."
       })
     ),
-    searchDepth: Type13.Optional(
+    searchDepth: Type14.Optional(
       literalUnion(["basic", "advanced"], {
         description: "Depth of the search. 'advanced' is slower but more thorough."
       })
     ),
-    timeRange: Type13.Optional(
-      Type13.String({ description: "Named time range filter." })
+    timeRange: Type14.Optional(
+      Type14.String({ description: "Named time range filter." })
     ),
-    country: Type13.Optional(
-      Type13.String({ description: "Country hint for search results." })
+    country: Type14.Optional(
+      Type14.String({ description: "Country hint for search results." })
     ),
-    exactMatch: Type13.Optional(
-      Type13.Boolean({ description: "Prefer exact matches." })
+    exactMatch: Type14.Optional(
+      Type14.Boolean({ description: "Prefer exact matches." })
     ),
-    includeAnswer: Type13.Optional(
-      Type13.Boolean({ description: "Include a short AI-generated answer." })
+    includeAnswer: Type14.Optional(
+      Type14.Boolean({ description: "Include a short AI-generated answer." })
     ),
-    includeRawContent: Type13.Optional(
-      Type13.Boolean({ description: "Include raw page content in results." })
+    includeRawContent: Type14.Optional(
+      Type14.Boolean({ description: "Include raw page content in results." })
     ),
-    includeImages: Type13.Optional(
-      Type13.Boolean({ description: "Include related images." })
+    includeImages: Type14.Optional(
+      Type14.Boolean({ description: "Include related images." })
     ),
-    includeFavicon: Type13.Optional(
-      Type13.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type14.Optional(
+      Type14.Boolean({ description: "Include favicon URLs." })
     ),
-    includeDomains: Type13.Optional(
-      Type13.Array(Type13.String(), {
+    includeDomains: Type14.Optional(
+      Type14.Array(Type14.String(), {
         description: "Restrict results to these domains."
       })
     ),
-    excludeDomains: Type13.Optional(
-      Type13.Array(Type13.String(), {
+    excludeDomains: Type14.Optional(
+      Type14.Array(Type14.String(), {
         description: "Exclude these domains from results."
       })
     ),
-    days: Type13.Optional(
-      Type13.Integer({
+    days: Type14.Optional(
+      Type14.Integer({
         minimum: 1,
         description: "Limit results to the last N days."
       })
@@ -4751,27 +5867,27 @@ var tavilySearchOptionsSchema = Type13.Object(
   },
   { description: "Tavily search options." }
 );
-var tavilyExtractOptionsSchema = Type13.Object(
+var tavilyExtractOptionsSchema = Type14.Object(
   {
-    extractDepth: Type13.Optional(
-      Type13.String({ description: "Depth setting for extraction." })
+    extractDepth: Type14.Optional(
+      Type14.String({ description: "Depth setting for extraction." })
     ),
-    format: Type13.Optional(
+    format: Type14.Optional(
       literalUnion(["markdown", "text"], {
         description: "Output format for extracted content."
       })
     ),
-    includeImages: Type13.Optional(
-      Type13.Boolean({ description: "Include extracted images." })
+    includeImages: Type14.Optional(
+      Type14.Boolean({ description: "Include extracted images." })
     ),
-    query: Type13.Optional(
-      Type13.String({ description: "Optional query to focus extraction." })
+    query: Type14.Optional(
+      Type14.String({ description: "Optional query to focus extraction." })
     ),
-    chunksPerSource: Type13.Optional(
-      Type13.Integer({ minimum: 1, description: "Maximum chunks per source." })
+    chunksPerSource: Type14.Optional(
+      Type14.Integer({ minimum: 1, description: "Maximum chunks per source." })
     ),
-    includeFavicon: Type13.Optional(
-      Type13.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type14.Optional(
+      Type14.Boolean({ description: "Include favicon URLs." })
     )
   },
   { description: "Tavily extract options." }
@@ -4792,7 +5908,7 @@ var tavilyImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "TAVILY_API_KEY",
+      credentials: { api: "TAVILY_API_KEY" },
       options: {
         search: {
           includeFavicon: true
@@ -4805,7 +5921,7 @@ var tavilyImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient8(config);
@@ -4841,24 +5957,24 @@ var tavilyImplementation = {
     );
     return {
       provider: tavilyImplementation.id,
-      answers: urls.map((url) => {
-        const result = resultsByUrl.get(url);
+      answers: urls.map((url2) => {
+        const result = resultsByUrl.get(url2);
         if (result) {
           return {
-            url,
+            url: url2,
             ...typeof result.rawContent === "string" ? { content: result.rawContent } : {},
             metadata: buildExtractMetadata(response, result)
           };
         }
-        const failedResult = failedResultsByUrl.get(url);
+        const failedResult = failedResultsByUrl.get(url2);
         if (failedResult) {
           return {
-            url,
+            url: url2,
             error: failedResult.error || "Content extraction failed."
           };
         }
         return {
-          url,
+          url: url2,
           error: "No content returned for this URL."
         };
       })
@@ -4866,7 +5982,7 @@ var tavilyImplementation = {
   }
 };
 function createClient8(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -4901,7 +6017,7 @@ var tavilyProvider = defineProvider({
   docsUrl: tavilyImplementation.docsUrl,
   config: {
     createTemplate: () => tavilyImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"]
+    fields: ["credentials", "baseUrl", "options", "settings"]
   },
   getCapabilityStatus: (config, cwd, tool) => tavilyImplementation.getCapabilityStatus(
     config,
@@ -4937,48 +6053,48 @@ var tavilyProvider = defineProvider({
 });
 
 // src/providers/valyu.ts
-import { Type as Type14 } from "typebox";
+import { Type as Type15 } from "typebox";
 import { Valyu as ValyuClient } from "valyu-js";
-var valyuSearchOptionsSchema = Type14.Object(
+var valyuSearchOptionsSchema = Type15.Object(
   {
-    searchType: Type14.Optional(
+    searchType: Type15.Optional(
       literalUnion(["all", "web", "proprietary", "news"], {
-        description: "Valyu search type."
+        description: "Valyu search type. Use 'news' for recent journalism or current events, 'web' for public web results, 'proprietary' for Valyu proprietary sources, and 'all' when both public and proprietary sources are useful."
       })
     ),
-    responseLength: Type14.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length."
       })
     ),
-    countryCode: Type14.Optional(
-      Type14.String({ description: "Country code to scope search results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope search results." })
     )
   },
   { description: "Valyu search options." }
 );
-var valyuAnswerOptionsSchema = Type14.Object(
+var valyuAnswerOptionsSchema = Type15.Object(
   {
-    responseLength: Type14.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for answers."
       })
     ),
-    countryCode: Type14.Optional(
-      Type14.String({ description: "Country code to scope answer results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope answer results." })
     )
   },
   { description: "Valyu answer options." }
 );
-var valyuResearchOptionsSchema = Type14.Object(
+var valyuResearchOptionsSchema = Type15.Object(
   {
-    responseLength: Type14.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for research."
       })
     ),
-    countryCode: Type14.Optional(
-      Type14.String({ description: "Country code to scope research results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope research results." })
     )
   },
   { description: "Valyu research options." }
@@ -5001,7 +6117,7 @@ var valyuImplementation = {
   },
   createTemplate() {
     return {
-      apiKey: "VALYU_API_KEY",
+      credentials: { api: "VALYU_API_KEY" },
       options: {
         search: {
           searchType: "all",
@@ -5011,7 +6127,7 @@ var valyuImplementation = {
     };
   },
   getCapabilityStatus(config) {
-    return getApiKeyStatus(config?.apiKey);
+    return getApiKeyStatus(config?.credentials?.api);
   },
   async search(query2, maxResults, config, _context, searchOptions) {
     const client = createClient9(config);
@@ -5050,19 +6166,19 @@ var valyuImplementation = {
     );
     return {
       provider: valyuImplementation.id,
-      answers: urls.map((url) => {
-        const result = resultsByUrl.get(url);
+      answers: urls.map((url2) => {
+        const result = resultsByUrl.get(url2);
         if (!result) {
           return {
-            url,
+            url: url2,
             error: "No content returned for this URL."
           };
         }
         return result.status === "failed" ? {
-          url,
+          url: url2,
           error: result.error ?? formatJson(result)
         } : {
-          url,
+          url: url2,
           ...typeof result.content === "string" || typeof result.content === "number" ? { content: String(result.content) } : {},
           ...result.summary !== void 0 ? { summary: result.summary } : {},
           metadata: result
@@ -5171,7 +6287,7 @@ var valyuImplementation = {
   }
 };
 function createClient9(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
+  const apiKey = resolveConfigValue(config.credentials?.api);
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
@@ -5183,7 +6299,7 @@ var valyuProvider = defineProvider({
   docsUrl: valyuImplementation.docsUrl,
   config: {
     createTemplate: () => valyuImplementation.createTemplate(),
-    fields: ["apiKey", "baseUrl", "options", "settings"],
+    fields: ["credentials", "baseUrl", "options", "settings"],
     optionCapabilities: ["search", "answer", "research"]
   },
   getCapabilityStatus: (config, cwd, tool) => valyuImplementation.getCapabilityStatus(
@@ -5243,6 +6359,7 @@ var valyuProvider = defineProvider({
 
 // src/providers/index.ts
 var PROVIDERS = defineProviders({
+  brave: braveProvider,
   claude: claudeProvider,
   codex: codexProvider,
   cloudflare: cloudflareProvider,
@@ -5312,7 +6429,13 @@ async function loadConfig() {
 async function readConfigFile(path) {
   try {
     const content = await readFile(path, "utf-8");
-    return parseConfig(content, path);
+    const raw = parseJson(content, path);
+    const migrated = migrateLegacyCredentialConfig(raw);
+    const config = normalizeConfig(migrated.config, path);
+    if (migrated.changed) {
+      await writeFile(path, serializeConfig(config), "utf-8");
+    }
+    return config;
   } catch (error) {
     if (error.code === "ENOENT") {
       return {};
@@ -5328,9 +6451,6 @@ async function writeConfigFile(config) {
   await writeFile(path, serializeConfig(cleaned), "utf-8");
   return path;
 }
-function parseConfig(text, source = CONFIG_FILE_NAME) {
-  return normalizeConfig(parseJson(text, source), source);
-}
 function serializeConfig(config) {
   return `${JSON.stringify(toPublicConfig(config), null, 2)}
 `;
@@ -5342,6 +6462,32 @@ function parseJson(text, source) {
     throw new Error(`Invalid JSON in ${source}: ${error.message}`);
   }
 }
+function migrateLegacyCredentialConfig(raw) {
+  if (!isPlainObject3(raw) || !isPlainObject3(raw.providers)) {
+    return { config: raw, changed: false };
+  }
+  let changed = false;
+  const config = structuredClone(raw);
+  const providers = config.providers;
+  for (const [providerId, provider] of Object.entries(providers)) {
+    if (!isPlainObject3(provider)) {
+      continue;
+    }
+    const legacyKey = providerId === "cloudflare" ? "apiToken" : "apiKey";
+    const legacyValue = provider[legacyKey];
+    if (legacyValue === void 0) {
+      continue;
+    }
+    const credentials = isPlainObject3(provider.credentials) ? { ...provider.credentials } : {};
+    if (credentials.api === void 0) {
+      credentials.api = legacyValue;
+    }
+    provider.credentials = credentials;
+    delete provider[legacyKey];
+    changed = true;
+  }
+  return { config, changed };
+}
 function normalizeConfig(raw, source) {
   const configObject = requireObject2(
     raw,
@@ -5407,8 +6553,6 @@ function toProviderConfigKey(field) {
 function getProviderConfigFieldParser(field, optionCapabilities) {
   switch (field) {
     case "accountId":
-    case "apiKey":
-    case "apiToken":
     case "baseUrl":
     case "codexPath":
     case "pathToClaudeCodeExecutable":
@@ -5417,6 +6561,7 @@ function getProviderConfigFieldParser(field, optionCapabilities) {
       return readOptionalObject;
     case "customOptions":
       return parseOptionalCustomProviderOptions;
+    case "credentials":
     case "env":
       return readOptionalStringMap;
     case "options":
@@ -5701,8 +6846,7 @@ function toPublicProviderConfig(provider) {
     } : {},
     ..."codexPath" in provider && provider.codexPath !== void 0 ? { codexPath: provider.codexPath } : {},
     ..."baseUrl" in provider && provider.baseUrl !== void 0 ? { baseUrl: provider.baseUrl } : {},
-    ..."apiKey" in provider && provider.apiKey !== void 0 ? { apiKey: provider.apiKey } : {},
-    ..."apiToken" in provider && provider.apiToken !== void 0 ? { apiToken: provider.apiToken } : {},
+    ...provider.credentials ? { credentials: provider.credentials } : {},
     ..."accountId" in provider && provider.accountId !== void 0 ? { accountId: provider.accountId } : {},
     ..."env" in provider && provider.env !== void 0 ? { env: provider.env } : {},
     ..."config" in provider && provider.config !== void 0 ? { config: provider.config } : {},
@@ -5945,6 +7089,10 @@ function getEffectiveProviderConfig(config, providerId) {
   const resolved = {
     ...defaults,
     ...overrides,
+    credentials: mergeNestedObjects(
+      defaults.credentials,
+      overrides.credentials
+    ),
     options: mergeNestedObjects(defaults.options, overrides.options)
   };
   const effectiveSettings = mergeExecutionSettings(
@@ -5958,26 +7106,26 @@ function getEffectiveProviderConfig(config, providerId) {
   }
   return resolved;
 }
-function mergeExecutionSettings(base, overrides) {
+function mergeExecutionSettings(base2, overrides) {
   const merged = {
-    requestTimeoutMs: overrides?.requestTimeoutMs ?? base?.requestTimeoutMs,
-    retryCount: overrides?.retryCount ?? base?.retryCount,
-    retryDelayMs: overrides?.retryDelayMs ?? base?.retryDelayMs,
-    researchTimeoutMs: overrides?.researchTimeoutMs ?? base?.researchTimeoutMs
+    requestTimeoutMs: overrides?.requestTimeoutMs ?? base2?.requestTimeoutMs,
+    retryCount: overrides?.retryCount ?? base2?.retryCount,
+    retryDelayMs: overrides?.retryDelayMs ?? base2?.retryDelayMs,
+    researchTimeoutMs: overrides?.researchTimeoutMs ?? base2?.researchTimeoutMs
   };
   return Object.values(merged).some((value) => value !== void 0) ? merged : void 0;
 }
-function mergeNestedObjects(base, overrides) {
-  if (base === void 0) {
+function mergeNestedObjects(base2, overrides) {
+  if (base2 === void 0) {
     return overrides;
   }
   if (overrides === void 0) {
-    return base;
+    return base2;
   }
-  if (!isPlainObject4(base) || !isPlainObject4(overrides)) {
+  if (!isPlainObject4(base2) || !isPlainObject4(overrides)) {
     return overrides;
   }
-  const result = { ...base };
+  const result = { ...base2 };
   for (const [key, value] of Object.entries(overrides)) {
     const baseValue = result[key];
     result[key] = isPlainObject4(baseValue) && isPlainObject4(value) ? mergeNestedObjects(baseValue, value) : value;
@@ -6013,9 +7161,9 @@ function getProviderSetupState(config, providerId) {
     return Object.keys(providerConfig).length > 0 ? "configured" : "none";
   }
   if (providerId === "cloudflare") {
-    return providerConfig.apiToken !== void 0 || providerConfig.accountId !== void 0 ? "configured" : "none";
+    return providerConfig.credentials !== void 0 || providerConfig.accountId !== void 0 ? "configured" : "none";
   }
-  return providerConfig.apiKey !== void 0 ? "configured" : "none";
+  return providerConfig.credentials !== void 0 ? "configured" : "none";
 }
 function formatProviderCapabilityStatus(status, providerId, tool) {
   switch (status.state) {
@@ -6242,8 +7390,8 @@ async function startContentsPrefetch({
   const ttlMs = clampTtlMs(options.ttlMs);
   void Promise.allSettled(
     selectedUrls.map(
-      (url) => ensureContentsStored({
-        url,
+      (url2) => ensureContentsStored({
+        url: url2,
         providerId: provider.id,
         config,
         cwd,
@@ -6269,7 +7417,7 @@ async function resolveContentsFromStore({
   onProgress
 }) {
   cleanupExpiredEntries();
-  if (urls.length <= 1 || urls.some((url) => hasReusableContents(url, providerId, options))) {
+  if (urls.length <= 1 || urls.some((url2) => hasReusableContents(url2, providerId, options))) {
     return await resolvePerUrlContents({
       urls,
       providerId,
@@ -6316,8 +7464,8 @@ async function resolvePerUrlContents({
 }) {
   const settled = await Promise.allSettled(
     urls.map(
-      (url) => ensureContentsStored({
-        url,
+      (url2) => ensureContentsStored({
+        url: url2,
         providerId,
         config,
         cwd,
@@ -6408,7 +7556,7 @@ async function fetchBatchContents({
   };
 }
 async function ensureContentsStored({
-  url,
+  url: url2,
   providerId,
   config,
   cwd,
@@ -6418,7 +7566,7 @@ async function ensureContentsStored({
   ttlMs = DEFAULT_CONTENT_TTL_MS,
   generation = contentStoreGeneration
 }) {
-  const canonicalUrl = canonicalizeUrl(url);
+  const canonicalUrl = canonicalizeUrl(url2);
   const key = buildContentsCacheKey(canonicalUrl, providerId, options);
   const cached = getCachedContents(key);
   if (cached) {
@@ -6501,8 +7649,8 @@ function cleanupExpiredEntries(now = Date.now()) {
     }
   }
 }
-function hasReusableContents(url, providerId, options) {
-  const key = buildContentsCacheKey(canonicalizeUrl(url), providerId, options);
+function hasReusableContents(url2, providerId, options) {
+  const key = buildContentsCacheKey(canonicalizeUrl(url2), providerId, options);
   return getCachedContents(key) !== void 0 || inFlightContents.has(key);
 }
 function getCachedContents(key) {
@@ -6521,8 +7669,8 @@ function setCachedContents(key, value, generation) {
     contentCache.set(key, value);
   }
 }
-function findAnswerForUrl(answers, url) {
-  return answers.find((answer) => canonicalizeUrl(answer.url) === url);
+function findAnswerForUrl(answers, url2) {
+  return answers.find((answer) => canonicalizeUrl(answer.url) === url2);
 }
 function toStoredContentItem(answer) {
   return {
@@ -6550,8 +7698,8 @@ function orderContentsForRequest(answers, urls) {
     }
   }
   const ordered = [];
-  for (const url of urls) {
-    const bucket = byUrl.get(canonicalizeUrl(url));
+  for (const url2 of urls) {
+    const bucket = byUrl.get(canonicalizeUrl(url2));
     const next = bucket?.shift();
     if (next) {
       ordered.push(next);
@@ -6563,12 +7711,12 @@ function orderContentsForRequest(answers, urls) {
   ordered.push(...extras);
   return ordered.length > 0 ? ordered : answers;
 }
-function buildContentsCacheKey(url, providerId, options) {
+function buildContentsCacheKey(url2, providerId, options) {
   return [
     "web-contents",
     `v${CONTENT_CACHE_VERSION}`,
     providerId,
-    hashString(url),
+    hashString(url2),
     hashOptions(options)
   ].join(":");
 }
@@ -6594,24 +7742,24 @@ function resolveContentsProvider(config, cwd, explicitProvider) {
   );
   return isProviderCapabilityReady(status) ? provider : void 0;
 }
-function canonicalizeUrl(url) {
+function canonicalizeUrl(url2) {
   try {
-    const parsed = new URL(url);
+    const parsed = new URL(url2);
     parsed.hash = "";
     return parsed.toString();
   } catch {
-    return url.trim();
+    return url2.trim();
   }
 }
 function normalizeBatchUrls(urls) {
-  return [...new Set(urls.map((url) => canonicalizeUrl(url)).filter(Boolean))].filter((url) => /^https?:\/\//i.test(url)).sort();
+  return [...new Set(urls.map((url2) => canonicalizeUrl(url2)).filter(Boolean))].filter((url2) => /^https?:\/\//i.test(url2)).sort();
 }
 function selectPrefetchUrls(urls, maxUrls) {
   const limit = clampPrefetchUrlCount(maxUrls);
   const seen = /* @__PURE__ */ new Set();
   const selected = [];
-  for (const url of urls) {
-    const canonical = canonicalizeUrl(url);
+  for (const url2 of urls) {
+    const canonical = canonicalizeUrl(url2);
     if (!/^https?:\/\//i.test(canonical) || seen.has(canonical)) {
       continue;
     }
@@ -6664,6 +7812,23 @@ function isContentsAnswer(value) {
 
 // src/provider-config-manifests.ts
 var PROVIDER_SETTINGS = {
+  brave: {
+    settings: [
+      credentialSetting({
+        id: "credentials.search",
+        name: "search",
+        label: "Search API key",
+        help: "Brave Search API key. You can use a literal value, an env var name like BRAVE_SEARCH_API_KEY, or !command."
+      }),
+      credentialSetting({
+        id: "credentials.answers",
+        name: "answers",
+        label: "Answers API key",
+        help: "Brave Answers API key. You can use a literal value, an env var name like BRAVE_ANSWERS_API_KEY, or !command."
+      }),
+      baseUrlSetting()
+    ]
+  },
   claude: {
     settings: [
       stringSetting({
@@ -6724,19 +7889,10 @@ var PROVIDER_SETTINGS = {
   },
   cloudflare: {
     settings: [
-      stringSetting({
-        id: "apiToken",
+      credentialSetting({
+        id: "credentials.api",
         label: "API token",
-        help: "Cloudflare API token for Browser Rendering. The token needs the permission `Account | Browser Rendering | Edit`. You can use a literal value, an env var name like CLOUDFLARE_API_TOKEN, or !command.",
-        secret: true,
-        getValue: (config) => config?.apiToken,
-        setValue: (config, value) => {
-          assignOptionalString(
-            config,
-            "apiToken",
-            value
-          );
-        }
+        help: "Cloudflare API token for Browser Rendering. The token needs the permission `Account | Browser Rendering | Edit`. You can use a literal value, an env var name like CLOUDFLARE_API_TOKEN, or !command."
       }),
       stringSetting({
         id: "accountId",
@@ -6963,7 +8119,7 @@ var PROVIDER_SETTINGS = {
   },
   exa: {
     settings: [
-      apiKeySetting(),
+      credentialSetting(),
       baseUrlSetting(),
       valuesSetting({
         id: "exaSearchType",
@@ -7020,11 +8176,11 @@ var PROVIDER_SETTINGS = {
     ]
   },
   firecrawl: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   gemini: {
     settings: [
-      apiKeySetting(),
+      credentialSetting(),
       valuesSetting({
         id: "geminiApiVersion",
         label: "API version",
@@ -7086,14 +8242,14 @@ var PROVIDER_SETTINGS = {
     ]
   },
   linkup: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   ollama: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   openai: {
     settings: [
-      apiKeySetting(),
+      credentialSetting(),
       baseUrlSetting(),
       stringSetting({
         id: "openaiSearchModel",
@@ -7197,11 +8353,11 @@ var PROVIDER_SETTINGS = {
     ]
   },
   perplexity: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   parallel: {
     settings: [
-      apiKeySetting(),
+      credentialSetting(),
       baseUrlSetting(),
       valuesSetting({
         id: "parallelSearchMode",
@@ -7263,14 +8419,14 @@ var PROVIDER_SETTINGS = {
     ]
   },
   serper: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   tavily: {
-    settings: [apiKeySetting(), baseUrlSetting()]
+    settings: [credentialSetting(), baseUrlSetting()]
   },
   valyu: {
     settings: [
-      apiKeySetting(),
+      credentialSetting(),
       baseUrlSetting(),
       valuesSetting({
         id: "valyuSearchType",
@@ -7353,19 +8509,22 @@ function valuesSetting(setting) {
     ...setting
   };
 }
-function apiKeySetting() {
+function credentialSetting(options = {}) {
+  const name = options.name ?? "api";
   return stringSetting({
-    id: "apiKey",
-    label: "API key",
-    help: "Provider API key. You can use a literal value, an env var name like EXA_API_KEY, or !command.",
+    id: options.id ?? `credentials.${name}`,
+    label: options.label ?? "API key",
+    help: options.help ?? "Provider credential. You can use a literal value, an env var name like EXA_API_KEY, or !command.",
     secret: true,
-    getValue: (config) => config?.apiKey,
+    getValue: (config) => config?.credentials?.[name],
     setValue: (config, value) => {
-      assignOptionalString(
-        config,
-        "apiKey",
-        value
-      );
+      const trimmed = value.trim();
+      if (!trimmed) {
+        delete config.credentials?.[name];
+      } else {
+        config.credentials = { ...config.credentials ?? {}, [name]: trimmed };
+      }
+      cleanupEmpty(config, "credentials");
     }
   });
 }
@@ -7776,18 +8935,18 @@ function registerWebSearchTool(pi, providerIds) {
     name: "web_search",
     label: "Web Search",
     description: `Find likely sources on the public web for up to ${MAX_SEARCH_QUERIES} queries in a single call and return titles, URLs, and snippets grouped by query. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)} when needed.`,
-    promptGuidelines: [
+    promptGuidelines: buildPromptGuidelines("search", selectedProviderId, [
       "Batch related searches when grouped comparison matters; use separate sibling web_search calls when independent results should surface as soon as they are ready."
-    ],
-    parameters: Type15.Object(
+    ]),
+    parameters: Type16.Object(
       {
-        queries: Type15.Array(Type15.String({ minLength: 1 }), {
+        queries: Type16.Array(Type16.String({ minLength: 1 }), {
           minItems: 1,
           maxItems: MAX_SEARCH_QUERIES,
           description: `One or more search queries to run in one call (max ${MAX_SEARCH_QUERIES})`
         }),
-        maxResults: Type15.Optional(
-          Type15.Integer({
+        maxResults: Type16.Optional(
+          Type16.Integer({
             minimum: 1,
             maximum: maxAllowedResults,
             description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
@@ -7838,9 +8997,9 @@ function registerWebContentsTool(pi, providerIds) {
     name: "web_contents",
     label: "Web Contents",
     description: "Read and extract the main contents of one or more web pages. Batch related pages together, or use separate sibling calls when each page can be acted on independently.",
-    parameters: Type15.Object(
+    parameters: Type16.Object(
       {
-        urls: Type15.Array(Type15.String({ minLength: 1 }), {
+        urls: Type16.Array(Type16.String({ minLength: 1 }), {
           minItems: 1,
           description: "One or more URLs to extract"
         }),
@@ -7851,6 +9010,7 @@ function registerWebContentsTool(pi, providerIds) {
       },
       { additionalProperties: false }
     ),
+    promptGuidelines: buildPromptGuidelines("contents", selectedProviderId, []),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       return executeProviderTool({
         config: await loadConfig(),
@@ -7892,9 +9052,9 @@ function registerWebAnswerTool(pi, providerIds) {
     name: "web_answer",
     label: "Web Answer",
     description: `Answer one or more simple factual questions using web-grounded evidence (up to ${MAX_SEARCH_QUERIES} per call). Prefer web_search plus web_contents when source selection matters, and web_research for multi-step investigations.`,
-    parameters: Type15.Object(
+    parameters: Type16.Object(
       {
-        queries: Type15.Array(Type15.String({ minLength: 1 }), {
+        queries: Type16.Array(Type16.String({ minLength: 1 }), {
           minItems: 1,
           maxItems: MAX_SEARCH_QUERIES,
           description: `One or more simple factual questions to answer in one call (max ${MAX_SEARCH_QUERIES})`
@@ -7906,11 +9066,11 @@ function registerWebAnswerTool(pi, providerIds) {
       },
       { additionalProperties: false }
     ),
-    promptGuidelines: [
+    promptGuidelines: buildPromptGuidelines("answer", selectedProviderId, [
       "Use web_answer as a quick grounded-answer shortcut for simple factual questions, not as a replacement for inspecting sources or doing deeper research.",
       "Prefer web_search plus web_contents when source selection matters or primary sources need direct inspection; prefer web_research for open-ended, controversial, or multi-step investigations.",
       "Batch related questions when the answers belong together; use separate sibling web_answer calls when earlier independent answers can unblock the next step."
-    ],
+    ]),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       return executeAnswerTool({
         config: await loadConfig(),
@@ -7952,9 +9112,9 @@ function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
     name: "web_research",
     label: "Web Research",
     description: "Start a long-running web research job. Returns immediately with a dispatch notice; the final report is saved to a file and posted later as a custom message.",
-    parameters: Type15.Object(
+    parameters: Type16.Object(
       {
-        input: Type15.String({ description: "Research brief or question" }),
+        input: Type16.String({ description: "Research brief or question" }),
         ...optionalField(
           "options",
           buildStructuredOptionsSchema("research", selectedProviderId)
@@ -7962,10 +9122,11 @@ function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
       },
       { additionalProperties: false }
     ),
-    promptGuidelines: [
+    promptGuidelines: buildPromptGuidelines("research", selectedProviderId, [
       "Use this tool for deep investigations that can finish asynchronously.",
+      "Pass only input unless the user explicitly requests provider options.",
       "Do not expect the final report in the same turn; tell the user that web research has started and wait for the completion message with the saved report path."
-    ],
+    ]),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       return dispatchWebResearch({
         pi,
@@ -8092,13 +9253,23 @@ function getSearchMaxResultsLimit(providerId) {
   const capabilities = PROVIDERS_BY_ID[providerId].capabilities;
   return capabilities.search?.limits?.maxResults ?? MAX_ALLOWED_RESULTS;
 }
+function buildPromptGuidelines(capability, providerId, baseGuidelines) {
+  return [
+    ...baseGuidelines,
+    ...getProviderCapabilityPromptGuidelines(capability, providerId)
+  ];
+}
+function getProviderCapabilityPromptGuidelines(capability, providerId) {
+  const capabilities = PROVIDERS_BY_ID[providerId].capabilities;
+  return capabilities[capability]?.promptGuidelines ?? [];
+}
 function optionalField(name, schema) {
   return schema ? { [name]: schema } : {};
 }
 function buildStructuredOptionsSchema(capability, providerId) {
   const providerSchema = resolveProviderOptionsSchema(capability, providerId);
   const schema = buildToolOptionsSchema(capability, providerSchema);
-  return schema ? Type15.Optional(schema) : void 0;
+  return schema ? Type16.Optional(schema) : void 0;
 }
 function resolveProviderOptionsSchema(capability, providerId) {
   if (!providerId) {
@@ -8447,8 +9618,11 @@ function formatAnswerResponses(outcomes) {
   ).join("\n\n");
 }
 function formatAnswerOutcomeSection(outcome, index, total) {
-  const heading = total > 1 ? `## Question ${index + 1}: ${formatAnswerHeading(outcome.query)}` : `## ${formatAnswerHeading(outcome.query)}`;
   const body = outcome.response ? outcome.response.text : `Answer failed: ${outcome.error ?? "Unknown error."}`;
+  if (total === 1) {
+    return body;
+  }
+  const heading = `## Question ${index + 1}: ${formatAnswerHeading(outcome.query)}`;
   return `${heading}
 
 ${body}`;
@@ -8501,7 +9675,7 @@ async function executeProviderOperation({
       `Fetching contents via ${provider.label} for ${(urls ?? []).length} URL(s)`
     );
   } else if (capability === "answer") {
-    onProgress?.(`Answering via ${provider.label}: ${query2 ?? ""}`);
+    onProgress?.(`Answering via ${provider.label}`);
   } else if (capability === "research") {
     onProgress?.(`Researching via ${provider.label}`);
   }
@@ -8922,7 +10096,7 @@ async function executeBatchedContentsTool({
   batchProgress.start();
   const settled = await Promise.allSettled(
     urls.map(
-      (url, index) => executeProviderOperation({
+      (url2, index) => executeProviderOperation({
         capability: "contents",
         config,
         provider,
@@ -8930,7 +10104,7 @@ async function executeBatchedContentsTool({
         ctx,
         signal,
         options,
-        urls: [url],
+        urls: [url2],
         onProgress: void 0,
         executionOverride: executionOverrides?.[index]
       }).then(
@@ -8989,9 +10163,9 @@ async function executeBatchedContentsTool({
   }
   return {
     provider: successful[0]?.response.provider ?? provider.id,
-    answers: urls.map((url) => {
-      return answersByUrl.get(url) ?? {
-        url,
+    answers: urls.map((url2) => {
+      return answersByUrl.get(url2) ?? {
+        url: url2,
         error: "No content returned for this URL."
       };
     })
@@ -9094,13 +10268,21 @@ function renderListCallHeader(toolName, items, theme, suffix, options = {}) {
         headerLine + " ".repeat(Math.max(0, width - visibleWidth(headerLine)))
       );
       for (const item of normalizedItems) {
-        const itemLine = truncateToWidth(
-          `  ${theme.fg("accent", truncateInline(item, 120))}`,
-          width
-        );
-        lines.push(
-          itemLine + " ".repeat(Math.max(0, width - visibleWidth(itemLine)))
-        );
+        const itemLines = options.forceMultiline ? wrapTextWithAnsi(
+          theme.fg("accent", item),
+          Math.max(1, width - 2)
+        ).map((line) => `  ${line}`) : [
+          truncateToWidth(
+            `  ${theme.fg("accent", truncateInline(item, 120))}`,
+            width
+          )
+        ];
+        for (const itemLine of itemLines) {
+          const line = truncateToWidth(itemLine, width);
+          lines.push(
+            line + " ".repeat(Math.max(0, width - visibleWidth(line)))
+          );
+        }
       }
       return lines;
     }
@@ -9124,15 +10306,7 @@ function renderQuestionCallHeader(params, theme) {
   );
 }
 function renderResearchCallHeader(params, theme) {
-  return renderListCallHeader(
-    "web_research",
-    [params.input],
-    theme,
-    void 0,
-    {
-      forceMultiline: true
-    }
-  );
+  return renderListCallHeader("web_research", [params.input], theme);
 }
 function renderSearchToolResult(result, expanded, isPartial, theme) {
   const text = extractTextContent(result.content);
@@ -9153,7 +10327,18 @@ function renderWebResearchDispatchResult(result, expanded, theme) {
   const text = extractTextContent(result.content) ?? "Started web research.";
   const details = isWebResearchRequest(result.details) ? result.details : void 0;
   if (expanded) {
-    return renderBlockText(details?.input ?? text, theme, "toolOutput");
+    const expandedText = details ? [
+      text,
+      "",
+      "## Research brief",
+      "",
+      details.input,
+      "",
+      "## Report path",
+      "",
+      `\`${details.outputPath}\``
+    ].join("\n") : text;
+    return renderMarkdownBlock(expandedText);
   }
   const summary = details ? `Started web research via ${PROVIDERS_BY_ID[details.provider]?.label ?? details.provider}` : text;
   let summaryText = theme.fg("success", summary);
@@ -10410,17 +11595,17 @@ function renderCollapsedSearchSummary(details, text, theme) {
   const resultCount = typeof details?.resultCount === "number" ? details.resultCount : inferSearchResultCount(text);
   const failedQueryCount = typeof details?.failedQueryCount === "number" ? details.failedQueryCount : inferSearchFailureCount(text);
   const providerLabel = typeof details?.provider === "string" ? PROVIDERS_BY_ID[details.provider]?.label ?? details.provider : void 0;
-  let base = buildSearchSummaryText({
+  let base2 = buildSearchSummaryText({
     queryCount,
     resultCount
   });
   if (providerLabel) {
-    base = `${base} via ${providerLabel}`;
+    base2 = `${base2} via ${providerLabel}`;
   }
   if (failedQueryCount && failedQueryCount > 0) {
-    base += `, ${failedQueryCount} failed`;
+    base2 += `, ${failedQueryCount} failed`;
   }
-  let summary = theme.fg("success", base);
+  let summary = theme.fg("success", base2);
   summary += theme.fg("muted", ` (${getExpandHint()})`);
   return new Text(summary, 0, 0);
 }
@@ -10500,8 +11685,11 @@ function formatSearchResponses(outcomes, prefetch) {
 Background contents prefetch started via ${prefetch.provider} for ${prefetch.urlCount} URL(s).`;
 }
 function formatSearchOutcomeSection(outcome, index, total) {
-  const heading = total > 1 ? `## Query ${index + 1}: ${formatSearchHeading(outcome.query)}` : `## ${formatSearchHeading(outcome.query)}`;
   const body = outcome.response ? formatSearchResponseMarkdown(outcome.response) : `Search failed: ${outcome.error ?? "Unknown error."}`;
+  if (total === 1) {
+    return body;
+  }
+  const heading = `## Query ${index + 1}: ${formatSearchHeading(outcome.query)}`;
   return `${heading}
 
 ${body}`;
@@ -10531,8 +11719,8 @@ function formatSearchResponseMarkdown(response) {
     return lines.join("\n");
   }).join("\n\n");
 }
-function formatMarkdownLink(label, url) {
-  return `[${escapeMarkdownLinkLabel(label)}](<${url}>)`;
+function formatMarkdownLink(label, url2) {
+  return `[${escapeMarkdownLinkLabel(label)}](<${url2}>)`;
 }
 function escapeMarkdownLinkLabel(text) {
   return cleanSingleLine(text).replaceAll("\\", "\\\\").replaceAll("]", "\\]");