pi-web-providers 2.4.2 → 2.5.0

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   visibleWidth,
   wrapTextWithAnsi
 } from "@mariozechner/pi-tui";
-import { Type as Type16 } from "typebox";
+import { Type as Type15 } from "typebox";
 
 // src/config.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -95,6 +95,13 @@ function trimSnippet(input, maxLength = 300) {
   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 } : {};
 }
@@ -102,7 +109,38 @@ function formatJson(value) {
   return JSON.stringify(value, null, 2);
 }
 function getApiKeyStatus(apiKeyReference) {
-  return resolveConfigValue(apiKeyReference) ? { state: "ready" } : { state: "missing_api_key" };
+  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
@@ -186,7 +224,7 @@ var claudeOptionsSchema = Type2.Object(
   },
   { description: "Claude options." }
 );
-var claudeAdapter = {
+var claudeImplementation = {
   id: "claude",
   label: "Claude",
   docsUrl: "https://github.com/anthropics/claude-agent-sdk-typescript",
@@ -427,533 +465,207 @@ function readString(value, key) {
   }
   return entry;
 }
+var claudeProvider = defineProvider({
+  id: "claude",
+  label: claudeImplementation.label,
+  docsUrl: claudeImplementation.docsUrl,
+  config: {
+    createTemplate: () => claudeImplementation.createTemplate(),
+    fields: ["pathToClaudeCodeExecutable", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => claudeImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: claudeImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await claudeImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: claudeImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await claudeImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/cloudflare.ts
-import { Type as Type3 } from "typebox";
 import CloudflareClient from "cloudflare";
-
-// src/execution-policy-defaults.ts
-var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
-var DEFAULT_RETRY_COUNT = 3;
-var DEFAULT_RETRY_DELAY_MS = 2e3;
-var DEFAULT_RESEARCH_POLL_INTERVAL_MS = 3e3;
-var DEFAULT_RESEARCH_TIMEOUT_MS = 18e5;
-var DEFAULT_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS = 3;
-var DEFAULT_GEMINI_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS = 10;
-function createDefaultExecutionSettings(overrides = {}) {
-  return {
-    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
-    retryCount: DEFAULT_RETRY_COUNT,
-    retryDelayMs: DEFAULT_RETRY_DELAY_MS,
-    researchTimeoutMs: DEFAULT_RESEARCH_TIMEOUT_MS,
-    ...overrides
-  };
-}
-
-// src/provider-diagnostics.ts
-function normalizeDiagnosticDetail(detail) {
-  return detail.trim().replace(/[.\s]+$/u, "");
-}
-function startsWithProviderLabel(providerLabel, detail) {
-  return detail.toLowerCase().startsWith(providerLabel.toLowerCase());
-}
-function readsLikeProviderClause(detail) {
-  return /^(is|has|was|returned|did|does|could|cannot|must|should|search\b|contents\b|answer\b|research\b|output\b|response\b|result\b|query\b|no\b|missing\b|deep research\b)/iu.test(
-    detail
-  );
-}
-function formatProviderDiagnostic(providerLabel, detail) {
-  const normalized = normalizeDiagnosticDetail(detail);
-  if (!normalized) {
-    return `${providerLabel} failed.`;
-  }
-  if (startsWithProviderLabel(providerLabel, normalized)) {
-    return `${normalized}.`;
-  }
-  if (readsLikeProviderClause(normalized)) {
-    return `${providerLabel} ${normalized}.`;
-  }
-  return `${providerLabel}: ${normalized}.`;
-}
-function formatResearchTerminalDiagnostic(providerLabel, status, detail) {
-  const normalized = detail ? normalizeDiagnosticDetail(detail) : "";
-  if (!normalized) {
-    return status === "cancelled" ? `${providerLabel} research was canceled.` : `${providerLabel} research failed.`;
-  }
-  if (startsWithProviderLabel(providerLabel, normalized)) {
-    return `${normalized}.`;
+import { Type as Type3 } from "typebox";
+var cloudflareContentsOptionsSchema = Type3.Object(
+  {
+    gotoOptions: Type3.Optional(
+      Type3.Object(
+        {
+          waitUntil: Type3.Optional(
+            literalUnion(
+              ["load", "domcontentloaded", "networkidle0", "networkidle2"],
+              { description: "When to consider navigation complete." }
+            )
+          )
+        },
+        {
+          description: "Navigation options."
+        }
+      )
+    )
+  },
+  {
+    description: "Cloudflare Browser Rendering options."
   }
-  if (/^research\b/iu.test(normalized)) {
-    return `${providerLabel} ${normalized}.`;
+);
+var cloudflareImplementation = {
+  id: "cloudflare",
+  label: "Cloudflare",
+  docsUrl: "https://developers.cloudflare.com/browser-rendering/rest-api/markdown-endpoint/",
+  getToolOptionsSchema(capability) {
+    switch (capability) {
+      case "contents":
+        return cloudflareContentsOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
+      apiToken: "CLOUDFLARE_API_TOKEN",
+      accountId: "CLOUDFLARE_ACCOUNT_ID",
+      options: {
+        gotoOptions: {
+          waitUntil: "networkidle0"
+        }
+      }
+    };
+  },
+  getCapabilityStatus(config) {
+    const apiTokenStatus = getApiKeyStatus(config?.apiToken);
+    if (apiTokenStatus.state !== "ready") {
+      return apiTokenStatus;
+    }
+    try {
+      if (!resolveConfigValue(config?.accountId)) {
+        return { state: "invalid_config", detail: "Missing account ID" };
+      }
+    } catch (error) {
+      return {
+        state: "invalid_config",
+        detail: formatConfigValueError(error)
+      };
+    }
+    return { state: "ready" };
+  },
+  async contents(urls, config, context, options) {
+    const client = createClient(config);
+    const accountId = resolveConfigValue(config.accountId);
+    if (!accountId) {
+      throw new Error("is missing an account ID");
+    }
+    const defaults = asJsonObject(config.options);
+    const answers = await Promise.all(
+      urls.map(async (url) => {
+        try {
+          const markdown = await client.browserRendering.markdown.create(
+            {
+              ...defaults ?? {},
+              ...options ?? {},
+              account_id: accountId,
+              url
+            },
+            buildRequestOptions(context)
+          );
+          return {
+            url,
+            content: markdown
+          };
+        } catch (error) {
+          return {
+            url,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })
+    );
+    return {
+      provider: cloudflareImplementation.id,
+      answers
+    };
   }
-  return status === "cancelled" ? `${providerLabel} research was canceled: ${normalized}.` : `${providerLabel} research failed: ${normalized}.`;
-}
-
-// src/execution-policy.ts
-var MAX_RETRY_DELAY_MS = 3e4;
-var RequestTimeoutError = class extends Error {
-  name = "RequestTimeoutError";
 };
-function stripLocalExecutionOptions(options) {
-  if (!options) {
-    return void 0;
+function createClient(config) {
+  const apiToken = resolveConfigValue(config.apiToken);
+  if (!apiToken) {
+    throw new Error("is missing an API token");
   }
-  const {
-    requestTimeoutMs: _requestTimeoutMs,
-    retryCount: _retryCount,
-    retryDelayMs: _retryDelayMs,
-    prefetch: _prefetch,
-    ...rest
-  } = options;
-  return Object.keys(rest).length > 0 ? rest : void 0;
+  return new CloudflareClient({
+    apiToken
+  });
 }
-function parseLocalExecutionOptions(options) {
-  return {
-    requestTimeoutMs: parseOptionalPositiveIntegerOption(
-      options,
-      "requestTimeoutMs"
-    ),
-    retryCount: parseOptionalNonNegativeIntegerOption(options, "retryCount"),
-    retryDelayMs: parseOptionalPositiveIntegerOption(options, "retryDelayMs")
-  };
+function buildRequestOptions(context) {
+  return context.signal ? { signal: context.signal } : void 0;
 }
-async function runWithExecutionPolicy(label, operation, settings, context) {
-  const maxAttempts = Math.max(1, settings.retryCount + 1);
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    throwIfAborted(context.signal);
-    const {
-      context: attemptContext,
-      abort,
-      cleanup
-    } = createAttemptContext(context);
-    try {
-      const result = operation(attemptContext);
-      const timeoutMessage = settings.requestTimeoutMs === void 0 ? void 0 : `${label} timed out after ${formatDuration(settings.requestTimeoutMs)}.`;
-      return await withAbortAndOptionalTimeout(
-        result,
-        settings.requestTimeoutMs,
-        context.signal,
-        timeoutMessage,
-        timeoutMessage ? () => abort(new RequestTimeoutError(timeoutMessage)) : void 0
-      );
-    } catch (error) {
-      if (!shouldRetryError(error, settings) || attempt >= maxAttempts) {
-        throw error;
+var cloudflareProvider = defineProvider({
+  id: "cloudflare",
+  label: cloudflareImplementation.label,
+  docsUrl: cloudflareImplementation.docsUrl,
+  config: {
+    createTemplate: () => cloudflareImplementation.createTemplate(),
+    fields: ["apiToken", "accountId", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => cloudflareImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    contents: defineCapability({
+      options: cloudflareImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await cloudflareImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
       }
-      const delayMs = Math.min(
-        settings.retryDelayMs * 2 ** (attempt - 1),
-        MAX_RETRY_DELAY_MS
-      );
-      context.onProgress?.(
-        `${label} failed (${formatErrorMessage(error)}). Retrying in ${formatDuration(delayMs)} (attempt ${attempt + 1}/${maxAttempts}).`
-      );
-      await sleep(delayMs, context.signal);
-    } finally {
-      cleanup();
-    }
+    })
   }
-  throw new Error(`${label} failed.`);
-}
-async function executeAsyncResearch({
-  providerLabel,
-  providerId,
-  context,
-  pollIntervalMs = DEFAULT_RESEARCH_POLL_INTERVAL_MS,
-  timeoutMs = DEFAULT_RESEARCH_TIMEOUT_MS,
-  maxConsecutivePollErrors = DEFAULT_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS,
-  start,
-  poll
-}) {
-  const timeoutMessage = `${providerLabel} research exceeded ${formatDuration(timeoutMs)}.`;
-  const deadline = createDeadlineSignal(
-    context.signal,
-    timeoutMs,
-    timeoutMessage
-  );
-  const researchContext = {
-    ...context,
-    signal: deadline.signal
-  };
-  let lastStatus;
-  let lastProgressStatus;
-  const startedAt = Date.now();
-  try {
-    researchContext.onProgress?.(`Starting research via ${providerLabel}`);
-    const job = await withAbortAndOptionalTimeout(
-      start(researchContext),
-      void 0,
-      researchContext.signal,
-      void 0
-    );
-    const jobId = job.id;
-    if (!jobId) {
-      throw new Error(`${providerLabel} research did not return a job id.`);
-    }
-    researchContext.onProgress?.(`${providerLabel} research started: ${jobId}`);
-    let consecutivePollErrors = 0;
-    while (true) {
-      throwIfAborted(
-        researchContext.signal,
-        `${providerLabel} research aborted.`
-      );
-      try {
-        const result = await withAbortAndOptionalTimeout(
-          poll(jobId, researchContext),
-          void 0,
-          researchContext.signal,
-          void 0
-        );
-        consecutivePollErrors = 0;
-        const progressStatus = result.statusText ?? result.status;
-        if (result.status !== lastStatus || progressStatus !== lastProgressStatus) {
-          researchContext.onProgress?.(
-            `Research via ${providerLabel}: ${progressStatus} (${formatElapsed(Date.now() - startedAt)} elapsed)`
-          );
-          lastStatus = result.status;
-          lastProgressStatus = progressStatus;
-        }
-        if (result.status === "completed") {
-          return result.output ?? {
-            provider: providerId,
-            text: `${providerLabel} research completed without textual output.`
-          };
-        }
-        if (result.status === "failed" || result.status === "cancelled") {
-          throw new Error(
-            formatResearchTerminalDiagnostic(
-              providerLabel,
-              result.status,
-              result.error
-            )
-          );
-        }
-      } catch (error) {
-        if (isAbortErrorFromSignal(researchContext.signal, error)) {
-          throw error;
-        }
-        if (!isRetryableError(error)) {
-          throw normalizeError(error);
-        }
-        consecutivePollErrors += 1;
-        if (consecutivePollErrors >= maxConsecutivePollErrors) {
-          throw new Error(
-            `${providerLabel} research polling failed too many times in a row: ${formatErrorMessage(error)}`
-          );
-        }
-        researchContext.onProgress?.(
-          `${providerLabel} research poll is still retrying after transient errors (${consecutivePollErrors}/${maxConsecutivePollErrors} consecutive poll failures). Background job id: ${jobId}`
-        );
-      }
-      await sleep(pollIntervalMs, researchContext.signal);
-    }
-  } catch (error) {
-    if (isAbortErrorFromSignal(researchContext.signal, error)) {
-      throw new Error(
-        formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
-      );
-    }
-    throw new Error(
-      formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
-    );
-  } finally {
-    deadline.cleanup();
-  }
-}
-function shouldRetryError(error, settings) {
-  if (error instanceof RequestTimeoutError) {
-    return settings.retryOnTimeout === true;
-  }
-  return isRetryableError(error);
-}
-function isRetryableError(error) {
-  if (error instanceof RequestTimeoutError) {
-    return false;
-  }
-  const message = formatErrorMessage(error).toLowerCase();
-  if (!message || message === "operation aborted.") {
-    return false;
-  }
-  return /429|500|502|503|504|deadline exceeded|econnreset|ecanceled|ehostunreach|eai_again|enotfound|etimedout|fetch failed|gateway timeout|internal error|network|overloaded|rate limit|resource exhausted|socket hang up|temporarily unavailable|timeout|unavailable/.test(
-    message
-  );
-}
-function formatErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
-  }
-  return String(error);
-}
-function formatElapsed(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (minutes > 0) {
-    return `${minutes}m ${seconds}s`;
-  }
-  return `${totalSeconds}s`;
-}
-function formatDuration(ms) {
-  if (ms >= 6e4) {
-    return formatElapsed(ms);
-  }
-  if (ms >= 1e3) {
-    return `${Math.floor(ms / 1e3)}s`;
-  }
-  return `${ms}ms`;
-}
-async function sleep(ms, signal) {
-  throwIfAborted(signal);
-  await new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve2();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      reject(getAbortError(signal));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function throwIfAborted(signal, message = "Operation aborted.") {
-  if (signal?.aborted) {
-    throw getAbortError(signal, message);
-  }
-}
-function createAttemptContext(context) {
-  const controller = new AbortController();
-  if (context.signal?.aborted) {
-    controller.abort(getAbortError(context.signal));
-  }
-  const onAbort = () => {
-    controller.abort(getAbortError(context.signal));
-  };
-  context.signal?.addEventListener("abort", onAbort, { once: true });
-  return {
-    context: {
-      ...context,
-      signal: controller.signal
-    },
-    abort: (reason) => controller.abort(reason),
-    cleanup: () => context.signal?.removeEventListener("abort", onAbort)
-  };
-}
-async function withAbortAndOptionalTimeout(promise, timeoutMs, signal, message, onTimeout) {
-  if (timeoutMs === void 0 && !signal) {
-    return await promise;
-  }
-  throwIfAborted(signal);
-  return await new Promise((resolve2, reject) => {
-    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
-      onTimeout?.();
-      cleanup();
-      reject(
-        new RequestTimeoutError(
-          message ?? `Operation timed out after ${formatDuration(timeoutMs)}.`
-        )
-      );
-    }, timeoutMs);
-    const onAbort = () => {
-      cleanup();
-      reject(getAbortError(signal));
-    };
-    const cleanup = () => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      signal?.removeEventListener("abort", onAbort);
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        cleanup();
-        resolve2(value);
-      },
-      (error) => {
-        cleanup();
-        reject(error);
-      }
-    );
-  });
-}
-function getAbortError(signal, message = "Operation aborted.") {
-  const reason = signal?.reason;
-  if (reason instanceof Error) {
-    return reason;
-  }
-  if (typeof reason === "string" && reason.length > 0) {
-    return new Error(reason);
-  }
-  return new Error(message);
-}
-function isAbortErrorFromSignal(signal, error) {
-  return signal?.aborted === true && signal.reason === error;
-}
-function createDeadlineSignal(signal, timeoutMs, timeoutMessage) {
-  const controller = new AbortController();
-  if (signal?.aborted) {
-    controller.abort(getAbortError(signal));
-  }
-  const onAbort = () => {
-    controller.abort(getAbortError(signal));
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  const timer = setTimeout(() => {
-    controller.abort(new RequestTimeoutError(timeoutMessage));
-  }, timeoutMs);
-  return {
-    signal: controller.signal,
-    cleanup: () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-    }
-  };
-}
-function normalizeError(error) {
-  return error instanceof Error ? error : new Error(formatErrorMessage(error));
-}
-function parseOptionalPositiveIntegerOption(options, key) {
-  const value = options?.[key];
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
-    throw new Error(`options.${key} must be a positive integer.`);
-  }
-  return value;
-}
-function parseOptionalNonNegativeIntegerOption(options, key) {
-  const value = options?.[key];
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    throw new Error(`options.${key} must be a non-negative integer.`);
-  }
-  return value;
-}
-
-// src/providers/cloudflare.ts
-var cloudflareContentsOptionsSchema = Type3.Object(
-  {
-    gotoOptions: Type3.Optional(
-      Type3.Object(
-        {
-          waitUntil: Type3.Optional(
-            literalUnion(
-              ["load", "domcontentloaded", "networkidle0", "networkidle2"],
-              { description: "When to consider navigation complete." }
-            )
-          )
-        },
-        {
-          description: "Navigation options."
-        }
-      )
-    )
-  },
-  {
-    description: "Cloudflare Browser Rendering options."
-  }
-);
-var cloudflareAdapter = {
-  id: "cloudflare",
-  label: "Cloudflare",
-  docsUrl: "https://developers.cloudflare.com/browser-rendering/rest-api/markdown-endpoint/",
-  getToolOptionsSchema(capability) {
-    switch (capability) {
-      case "contents":
-        return cloudflareContentsOptionsSchema;
-      default:
-        return void 0;
-    }
-  },
-  createTemplate() {
-    return {
-      apiToken: "CLOUDFLARE_API_TOKEN",
-      accountId: "CLOUDFLARE_ACCOUNT_ID",
-      options: {
-        gotoOptions: {
-          waitUntil: "networkidle0"
-        }
-      }
-    };
-  },
-  getCapabilityStatus(config) {
-    if (!resolveConfigValue(config?.apiToken)) {
-      return { state: "missing_api_key" };
-    }
-    if (!resolveConfigValue(config?.accountId)) {
-      return { state: "invalid_config", detail: "Missing account ID" };
-    }
-    return { state: "ready" };
-  },
-  async contents(urls, config, context, options) {
-    const client = createClient(config);
-    const accountId = resolveConfigValue(config.accountId);
-    if (!accountId) {
-      throw new Error("is missing an account ID");
-    }
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options));
-    const answers = await Promise.all(
-      urls.map(async (url) => {
-        try {
-          const markdown = await client.browserRendering.markdown.create(
-            {
-              ...defaults ?? {},
-              ...options ?? {},
-              account_id: accountId,
-              url
-            },
-            buildRequestOptions(context)
-          );
-          return {
-            url,
-            content: markdown
-          };
-        } catch (error) {
-          return {
-            url,
-            error: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })
-    );
-    return {
-      provider: cloudflareAdapter.id,
-      answers
-    };
-  }
-};
-function createClient(config) {
-  const apiToken = resolveConfigValue(config.apiToken);
-  if (!apiToken) {
-    throw new Error("is missing an API token");
-  }
-  return new CloudflareClient({
-    apiToken
-  });
-}
-function buildRequestOptions(context) {
-  return context.signal ? { signal: context.signal } : void 0;
-}
+});
 
 // src/providers/codex.ts
 import { Codex as CodexClient } from "@openai/codex-sdk";
 import { Type as Type4 } from "typebox";
-var codexOutputSchema = Type4.Object({
-  sources: Type4.Array(
-    Type4.Object({
-      title: Type4.String(),
-      url: Type4.String(),
-      snippet: Type4.String()
-    })
-  )
-});
+var codexOutputSchema = Type4.Object(
+  {
+    sources: Type4.Array(
+      Type4.Object(
+        {
+          title: Type4.String(),
+          url: Type4.String(),
+          snippet: Type4.String()
+        },
+        { additionalProperties: false }
+      )
+    )
+  },
+  { additionalProperties: false }
+);
 var codexSearchOptionsSchema = Type4.Object(
   {
     model: Type4.Optional(Type4.String({ description: "Codex model override." })),
@@ -982,7 +694,7 @@ var codexSearchOptionsSchema = Type4.Object(
   },
   { description: "Codex search options." }
 );
-var codexAdapter = {
+var codexImplementation = {
   id: "codex",
   label: "Codex",
   docsUrl: "https://github.com/openai/codex/tree/main/sdk/typescript",
@@ -995,492 +707,955 @@ var codexAdapter = {
     }
   },
   createTemplate() {
-    return {
-      options: {
-        networkAccessEnabled: true,
-        webSearchEnabled: true,
-        webSearchMode: "live"
-      }
-    };
+    return {
+      options: {
+        networkAccessEnabled: true,
+        webSearchEnabled: true,
+        webSearchMode: "live"
+      }
+    };
+  },
+  getCapabilityStatus(config, _cwd) {
+    const effectiveConfig = config ?? codexImplementation.createTemplate();
+    try {
+      new CodexClient({
+        codexPathOverride: effectiveConfig.codexPath,
+        config: effectiveConfig.config
+      });
+    } catch (error) {
+      return {
+        state: "invalid_config",
+        detail: error.message
+      };
+    }
+    return { state: "ready" };
+  },
+  async search(query2, maxResults, config, context, options) {
+    const codex = new CodexClient({
+      codexPathOverride: config.codexPath,
+      baseUrl: config.baseUrl,
+      apiKey: resolveConfigValue(config.apiKey),
+      config: config.config,
+      env: resolveEnvMap(config.env)
+    });
+    const thread = codex.startThread(
+      buildCodexSearchThreadOptions(config, context.cwd, options)
+    );
+    const prompt = [
+      "You are performing web research for another coding agent.",
+      "Search the public web and return only a JSON object matching the provided schema.",
+      "Do not include markdown fences or extra commentary.",
+      `Return at most ${maxResults} sources.`,
+      "Prefer primary or official sources when they are available.",
+      "Each snippet should be short and specific.",
+      "",
+      `User query: ${query2}`
+    ].join("\n");
+    const streamed = await thread.runStreamed(prompt, {
+      outputSchema: codexOutputSchema,
+      signal: context.signal
+    });
+    let finalResponse = "";
+    for await (const event of streamed.events) {
+      if (event.type === "item.completed" && event.item.type === "agent_message") {
+        finalResponse = event.item.text;
+      }
+      if (event.type === "turn.failed") {
+        throw new Error(event.error.message);
+      }
+    }
+    const parsed = parseOutput(finalResponse);
+    return {
+      provider: codexImplementation.id,
+      results: parsed.sources.slice(0, maxResults).map((source) => ({
+        title: source.title.trim(),
+        url: source.url.trim(),
+        snippet: trimSnippet(source.snippet)
+      }))
+    };
+  }
+};
+function buildCodexSearchThreadOptions(config, cwd, options) {
+  const callOptions = getCodexSearchCallOptions(options);
+  const providerOptions = config.options;
+  return {
+    additionalDirectories: providerOptions?.additionalDirectories,
+    approvalPolicy: "never",
+    model: callOptions.model ?? providerOptions?.model,
+    modelReasoningEffort: callOptions.modelReasoningEffort ?? providerOptions?.modelReasoningEffort,
+    networkAccessEnabled: providerOptions?.networkAccessEnabled ?? true,
+    sandboxMode: "read-only",
+    skipGitRepoCheck: true,
+    webSearchEnabled: providerOptions?.webSearchEnabled ?? true,
+    webSearchMode: callOptions.webSearchMode ?? providerOptions?.webSearchMode ?? "live",
+    workingDirectory: cwd
+  };
+}
+function getCodexSearchCallOptions(options) {
+  if (!options) {
+    return {};
+  }
+  const model = readNonEmptyString2(options.model);
+  const modelReasoningEffort = readEnum2(options.modelReasoningEffort, [
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ]);
+  const webSearchMode = readEnum2(options.webSearchMode, [
+    "disabled",
+    "cached",
+    "live"
+  ]);
+  return {
+    ...model ? { model } : {},
+    ...modelReasoningEffort ? { modelReasoningEffort } : {},
+    ...webSearchMode ? { webSearchMode } : {}
+  };
+}
+function readNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readEnum2(value, values) {
+  return typeof value === "string" && values.includes(value) ? value : void 0;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOutput(raw) {
+  const json = extractJsonObject(raw);
+  if (!isJsonObject(json) || !Array.isArray(json.sources) || json.sources.some(
+    (source) => !isJsonObject(source) || typeof source.title !== "string" || typeof source.url !== "string" || typeof source.snippet !== "string"
+  )) {
+    throw new Error("returned invalid JSON output");
+  }
+  return json;
+}
+function extractJsonObject(raw) {
+  if (!raw.trim()) {
+    throw new Error("returned an empty response");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) {
+      throw new Error("returned invalid JSON output");
+    }
+    try {
+      return JSON.parse(match[0]);
+    } catch {
+      throw new Error("returned invalid JSON output");
+    }
+  }
+}
+var codexProvider = defineProvider({
+  id: "codex",
+  label: codexImplementation.label,
+  docsUrl: codexImplementation.docsUrl,
+  config: {
+    createTemplate: () => codexImplementation.createTemplate(),
+    fields: [
+      "codexPath",
+      "baseUrl",
+      "apiKey",
+      "env",
+      "config",
+      "options",
+      "settings"
+    ]
+  },
+  getCapabilityStatus: (config, cwd, tool) => codexImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: codexImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await codexImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    })
+  }
+});
+
+// src/providers/cli-json.ts
+import { spawn } from "node:child_process";
+import { isAbsolute, resolve } from "node:path";
+async function runCliJsonCommand({
+  command,
+  payload,
+  context,
+  label
+}) {
+  const argv = normalizeArgv(command);
+  const cwd = resolveCommandCwd(command.cwd, context.cwd);
+  const env = {
+    ...process.env,
+    ...resolveEnvMap(command.env) ?? {}
+  };
+  return await new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    let abortTimer;
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const rejectOnce = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (abortTimer) {
+        clearTimeout(abortTimer);
+      }
+      context.signal?.removeEventListener("abort", onAbort);
+      rejectPromise(error);
+    };
+    const resolveOnce = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (abortTimer) {
+        clearTimeout(abortTimer);
+      }
+      context.signal?.removeEventListener("abort", onAbort);
+      resolvePromise(value);
+    };
+    const onAbort = () => {
+      child.kill("SIGTERM");
+      abortTimer = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 1e3);
+    };
+    if (context.signal?.aborted) {
+      onAbort();
+    } else {
+      context.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      rejectOnce(
+        new Error(
+          `${label} failed to start: ${error.message || String(error)}`
+        )
+      );
+    });
+    child.on("close", (code, signal) => {
+      if (context.signal?.aborted) {
+        rejectOnce(new Error(`${label} was aborted.`));
+        return;
+      }
+      if (code !== 0) {
+        const detail = stderr.trim() || `exit code ${code ?? "unknown"}`;
+        rejectOnce(
+          new Error(
+            signal ? `${label} exited via signal ${signal}: ${detail}` : `${label} failed with exit code ${code}: ${detail}`
+          )
+        );
+        return;
+      }
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        rejectOnce(new Error(`${label} did not write JSON to stdout.`));
+        return;
+      }
+      try {
+        resolveOnce(JSON.parse(trimmed));
+      } catch (error) {
+        rejectOnce(
+          new Error(
+            `${label} returned invalid JSON: ${error.message}`
+          )
+        );
+      }
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(`${JSON.stringify(payload)}
+`);
+  });
+}
+function normalizeArgv(command) {
+  const argv = command.argv?.filter((entry) => entry.trim().length > 0) ?? [];
+  if (argv.length === 0) {
+    throw new Error("command is missing argv");
+  }
+  return argv;
+}
+function resolveCommandCwd(commandCwd, fallbackCwd) {
+  if (!commandCwd || commandCwd.trim().length === 0) {
+    return fallbackCwd;
+  }
+  return isAbsolute(commandCwd) ? commandCwd : resolve(fallbackCwd, commandCwd);
+}
+
+// src/providers/custom.ts
+var customImplementation = {
+  id: "custom",
+  label: "Custom",
+  docsUrl: "https://github.com/mavam/pi-web-providers#custom-provider",
+  getToolOptionsSchema(_capability) {
+    return void 0;
+  },
+  createTemplate() {
+    return {};
   },
-  getCapabilityStatus(config, _cwd) {
-    const effectiveConfig = config ?? codexAdapter.createTemplate();
-    try {
-      new CodexClient({
-        codexPathOverride: effectiveConfig.codexPath,
-        config: effectiveConfig.config
-      });
-    } catch (error) {
-      return {
-        state: "invalid_config",
-        detail: error.message
-      };
+  getCapabilityStatus(config, _cwd, capability) {
+    if (capability) {
+      return hasCommandForCapability(config, capability) ? { state: "ready" } : { state: "missing_command" };
     }
-    return { state: "ready" };
+    return hasAnyCommand(config) ? { state: "ready" } : { state: "missing_command" };
   },
   async search(query2, maxResults, config, context, options) {
-    const codex = new CodexClient({
-      codexPathOverride: config.codexPath,
-      baseUrl: config.baseUrl,
-      apiKey: resolveConfigValue(config.apiKey),
-      config: config.config,
-      env: resolveEnvMap(config.env)
+    const output = await runCommand({
+      capability: "search",
+      payload: {
+        capability: "search",
+        query: query2,
+        maxResults,
+        ...options ? { options } : {}
+      },
+      config,
+      context
     });
-    const thread = codex.startThread(
-      buildCodexSearchThreadOptions(config, context.cwd, options)
-    );
-    const prompt = [
-      "You are performing web research for another coding agent.",
-      "Search the public web and return only a JSON object matching the provided schema.",
-      "Do not include markdown fences or extra commentary.",
-      `Return at most ${maxResults} sources.`,
-      "Prefer primary or official sources when they are available.",
-      "Each snippet should be short and specific.",
-      "",
-      `User query: ${query2}`
-    ].join("\n");
-    const streamed = await thread.runStreamed(prompt, {
-      outputSchema: codexOutputSchema,
-      signal: context.signal
+    return parseSearchResponse(output, customImplementation.id);
+  },
+  async contents(urls, config, context, options) {
+    const output = await runCommand({
+      capability: "contents",
+      payload: {
+        capability: "contents",
+        urls,
+        ...options ? { options } : {}
+      },
+      config,
+      context
     });
-    let finalResponse = "";
-    for await (const event of streamed.events) {
-      if (event.type === "item.completed" && event.item.type === "agent_message") {
-        finalResponse = event.item.text;
-      }
-      if (event.type === "turn.failed") {
-        throw new Error(event.error.message);
-      }
-    }
-    const parsed = parseOutput(finalResponse);
-    return {
-      provider: codexAdapter.id,
-      results: parsed.sources.slice(0, maxResults).map((source) => ({
-        title: source.title.trim(),
-        url: source.url.trim(),
-        snippet: trimSnippet(source.snippet)
-      }))
-    };
+    return parseContentsResponse(output, customImplementation.id);
+  },
+  async answer(query2, config, context, options) {
+    const output = await runCommand({
+      capability: "answer",
+      payload: {
+        capability: "answer",
+        query: query2,
+        ...options ? { options } : {}
+      },
+      config,
+      context
+    });
+    return parseToolOutput(output, customImplementation.id);
+  },
+  async research(input, config, context, options) {
+    const output = await runCommand({
+      capability: "research",
+      payload: {
+        capability: "research",
+        input,
+        ...options ? { options } : {}
+      },
+      config,
+      context
+    });
+    return parseToolOutput(output, customImplementation.id);
   }
 };
-function buildCodexSearchThreadOptions(config, cwd, options) {
-  const runtimeOptions = getCodexSearchRuntimeOptions(options);
-  const providerOptions = config.options;
+async function runCommand({
+  capability,
+  payload,
+  config,
+  context
+}) {
+  const command = getCommandConfig(config, capability);
+  if (!command) {
+    throw new Error(`has no command configured for ${capability}`);
+  }
+  return await runCliJsonCommand({
+    command,
+    payload: {
+      ...payload,
+      cwd: context.cwd
+    },
+    context,
+    label: `Custom ${capability}`
+  });
+}
+function getCommandConfig(config, capability) {
+  return config?.options?.[capability];
+}
+function hasCommandForCapability(config, capability) {
+  return normalizeConfiguredArgv(getCommandConfig(config, capability)).length > 0;
+}
+function hasAnyCommand(config) {
+  return hasCommandForCapability(config, "search") || hasCommandForCapability(config, "contents") || hasCommandForCapability(config, "answer") || hasCommandForCapability(config, "research");
+}
+function normalizeConfiguredArgv(command) {
+  return command?.argv?.filter((entry) => entry.trim().length > 0) ?? [];
+}
+function parseSearchResponse(value, providerId) {
+  const response = requireObject(value, "search output must be a JSON object");
+  if (!Array.isArray(response.results)) {
+    throw new Error("search output must include a 'results' array");
+  }
   return {
-    additionalDirectories: providerOptions?.additionalDirectories,
-    approvalPolicy: "never",
-    model: runtimeOptions.model ?? providerOptions?.model,
-    modelReasoningEffort: runtimeOptions.modelReasoningEffort ?? providerOptions?.modelReasoningEffort,
-    networkAccessEnabled: providerOptions?.networkAccessEnabled ?? true,
-    sandboxMode: "read-only",
-    skipGitRepoCheck: true,
-    webSearchEnabled: providerOptions?.webSearchEnabled ?? true,
-    webSearchMode: runtimeOptions.webSearchMode ?? providerOptions?.webSearchMode ?? "live",
-    workingDirectory: cwd
+    provider: providerId,
+    results: response.results.map(
+      (entry, index) => parseSearchResult(entry, index)
+    )
+  };
+}
+function parseSearchResult(entry, index) {
+  const value = requireObject(
+    entry,
+    `search result at index ${index} must be a JSON object`
+  );
+  const metadata = readLenientJsonObject(value.metadata);
+  return {
+    title: readRequiredString(value.title, `results[${index}].title`),
+    url: readRequiredString(value.url, `results[${index}].url`),
+    snippet: readRequiredString(value.snippet, `results[${index}].snippet`),
+    ...typeof value.score === "number" ? { score: value.score } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
+function parseContentsResponse(value, providerId) {
+  const response = requireObject(
+    value,
+    "contents output must be a JSON object"
+  );
+  if (!Array.isArray(response.answers)) {
+    throw new Error("contents output must include an 'answers' array");
+  }
+  return {
+    provider: providerId,
+    answers: response.answers.map(
+      (entry, index) => parseContentsAnswer(entry, index)
+    )
+  };
+}
+function parseContentsAnswer(entry, index) {
+  const value = requireObject(
+    entry,
+    `contents answer at index ${index} must be a JSON object`
+  );
+  const url = readRequiredString(value.url, `answers[${index}].url`);
+  const content = readOptionalString(
+    value.content,
+    `answers[${index}].content`
+  );
+  const summary = value.summary;
+  const metadata = readRequiredJsonObject(
+    value.metadata,
+    `answers[${index}].metadata`
+  );
+  const error = readOptionalString(value.error, `answers[${index}].error`);
+  if (content === void 0 && error === void 0) {
+    throw new Error(
+      `contents answer at index ${index} must include 'content' or 'error'`
+    );
+  }
+  return {
+    url,
+    ...content !== void 0 ? { content } : {},
+    ...summary !== void 0 ? { summary } : {},
+    ...metadata !== void 0 ? { metadata } : {},
+    ...error !== void 0 ? { error } : {}
+  };
+}
+function parseToolOutput(value, providerId) {
+  const output = requireObject(value, "output must be a JSON object");
+  const metadata = readLenientJsonObject(output.metadata);
+  return {
+    provider: providerId,
+    text: readRequiredString(output.text, "text"),
+    ...readOptionalNonNegativeInteger(output.itemCount),
+    ...metadata !== void 0 ? { metadata } : {}
   };
 }
-function getCodexSearchRuntimeOptions(options) {
-  if (!options) {
-    return {};
+function readRequiredJsonObject(value, field) {
+  if (value === void 0) {
+    return void 0;
   }
-  const model = readNonEmptyString2(options.model);
-  const modelReasoningEffort = readEnum2(options.modelReasoningEffort, [
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh"
-  ]);
-  const webSearchMode = readEnum2(options.webSearchMode, [
-    "disabled",
-    "cached",
-    "live"
-  ]);
+  return requireObject(value, `output field '${field}' must be a JSON object`);
+}
+function readLenientJsonObject(value) {
+  return isJsonObject2(value) ? value : void 0;
+}
+function readRequiredString(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`output field '${field}' must be a string`);
+  }
+  return value;
+}
+function readOptionalString(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return readRequiredString(value, field);
+}
+function readOptionalNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? { itemCount: value } : {};
+}
+function requireObject(value, message) {
+  if (!isJsonObject2(value)) {
+    throw new Error(message);
+  }
+  return value;
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var customProvider = defineProvider({
+  id: "custom",
+  label: customImplementation.label,
+  docsUrl: customImplementation.docsUrl,
+  config: {
+    createTemplate: () => customImplementation.createTemplate(),
+    fields: ["customOptions", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => customImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: customImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await customImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: customImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await customImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: customImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await customImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: customImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await customImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
+
+// src/providers/exa.ts
+import { Exa as ExaClient } from "exa-js";
+import { Type as Type5 } from "typebox";
+
+// src/execution-policy-defaults.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY_COUNT = 3;
+var DEFAULT_RETRY_DELAY_MS = 2e3;
+var DEFAULT_RESEARCH_POLL_INTERVAL_MS = 3e3;
+var DEFAULT_RESEARCH_TIMEOUT_MS = 18e5;
+var DEFAULT_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS = 3;
+var DEFAULT_GEMINI_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS = 10;
+function createDefaultExecutionSettings(overrides = {}) {
   return {
-    ...model ? { model } : {},
-    ...modelReasoningEffort ? { modelReasoningEffort } : {},
-    ...webSearchMode ? { webSearchMode } : {}
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    retryCount: DEFAULT_RETRY_COUNT,
+    retryDelayMs: DEFAULT_RETRY_DELAY_MS,
+    researchTimeoutMs: DEFAULT_RESEARCH_TIMEOUT_MS,
+    ...overrides
   };
 }
-function readNonEmptyString2(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+
+// src/provider-diagnostics.ts
+function normalizeDiagnosticDetail(detail) {
+  return detail.trim().replace(/[.\s]+$/u, "");
 }
-function readEnum2(value, values) {
-  return typeof value === "string" && values.includes(value) ? value : void 0;
+function startsWithProviderLabel(providerLabel, detail) {
+  return detail.toLowerCase().startsWith(providerLabel.toLowerCase());
 }
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function readsLikeProviderClause(detail) {
+  return /^(is|has|was|returned|did|does|could|cannot|must|should|search\b|contents\b|answer\b|research\b|output\b|response\b|result\b|query\b|no\b|missing\b|deep research\b)/iu.test(
+    detail
+  );
 }
-function parseOutput(raw) {
-  const json = extractJsonObject(raw);
-  if (!isJsonObject(json) || !Array.isArray(json.sources) || json.sources.some(
-    (source) => !isJsonObject(source) || typeof source.title !== "string" || typeof source.url !== "string" || typeof source.snippet !== "string"
-  )) {
-    throw new Error("returned invalid JSON output");
+function formatProviderDiagnostic(providerLabel, detail) {
+  const normalized = normalizeDiagnosticDetail(detail);
+  if (!normalized) {
+    return `${providerLabel} failed.`;
   }
-  return json;
+  if (startsWithProviderLabel(providerLabel, normalized)) {
+    return `${normalized}.`;
+  }
+  if (readsLikeProviderClause(normalized)) {
+    return `${providerLabel} ${normalized}.`;
+  }
+  return `${providerLabel}: ${normalized}.`;
 }
-function extractJsonObject(raw) {
-  if (!raw.trim()) {
-    throw new Error("returned an empty response");
+function formatResearchTerminalDiagnostic(providerLabel, status, detail) {
+  const normalized = detail ? normalizeDiagnosticDetail(detail) : "";
+  if (!normalized) {
+    return status === "cancelled" ? `${providerLabel} research was canceled.` : `${providerLabel} research failed.`;
   }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (!match) {
-      throw new Error("returned invalid JSON output");
-    }
-    try {
-      return JSON.parse(match[0]);
-    } catch {
-      throw new Error("returned invalid JSON output");
-    }
+  if (startsWithProviderLabel(providerLabel, normalized)) {
+    return `${normalized}.`;
+  }
+  if (/^research\b/iu.test(normalized)) {
+    return `${providerLabel} ${normalized}.`;
   }
+  return status === "cancelled" ? `${providerLabel} research was canceled: ${normalized}.` : `${providerLabel} research failed: ${normalized}.`;
 }
 
-// src/providers/cli-json.ts
-import { spawn } from "node:child_process";
-import { isAbsolute, resolve } from "node:path";
-async function runCliJsonCommand({
-  command,
-  payload,
-  context,
-  label
-}) {
-  const argv = normalizeArgv(command);
-  const cwd = resolveCommandCwd(command.cwd, context.cwd);
-  const env = {
-    ...process.env,
-    ...resolveEnvMap(command.env) ?? {}
-  };
-  return await new Promise((resolvePromise, rejectPromise) => {
-    let settled = false;
-    let stdout = "";
-    let stderr = "";
-    let abortTimer;
-    const child = spawn(argv[0], argv.slice(1), {
-      cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const rejectOnce = (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (abortTimer) {
-        clearTimeout(abortTimer);
-      }
-      context.signal?.removeEventListener("abort", onAbort);
-      rejectPromise(error);
-    };
-    const resolveOnce = (value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (abortTimer) {
-        clearTimeout(abortTimer);
+// src/execution-policy.ts
+var MAX_RETRY_DELAY_MS = 3e4;
+var RequestTimeoutError = class extends Error {
+  name = "RequestTimeoutError";
+};
+async function runWithExecutionPolicy(label, operation, settings, context) {
+  const maxAttempts = Math.max(1, settings.retryCount + 1);
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    throwIfAborted(context.signal);
+    const {
+      context: attemptContext,
+      abort,
+      cleanup
+    } = createAttemptContext(context);
+    try {
+      const result = operation(attemptContext);
+      const timeoutMessage = settings.requestTimeoutMs === void 0 ? void 0 : `${label} timed out after ${formatDuration(settings.requestTimeoutMs)}.`;
+      return await withAbortAndOptionalTimeout(
+        result,
+        settings.requestTimeoutMs,
+        context.signal,
+        timeoutMessage,
+        timeoutMessage ? () => abort(new RequestTimeoutError(timeoutMessage)) : void 0
+      );
+    } catch (error) {
+      if (!shouldRetryError(error, settings) || attempt >= maxAttempts) {
+        throw error;
       }
-      context.signal?.removeEventListener("abort", onAbort);
-      resolvePromise(value);
-    };
-    const onAbort = () => {
-      child.kill("SIGTERM");
-      abortTimer = setTimeout(() => {
-        child.kill("SIGKILL");
-      }, 1e3);
-    };
-    if (context.signal?.aborted) {
-      onAbort();
-    } else {
-      context.signal?.addEventListener("abort", onAbort, { once: true });
+      const delayMs = Math.min(
+        settings.retryDelayMs * 2 ** (attempt - 1),
+        MAX_RETRY_DELAY_MS
+      );
+      context.onProgress?.(
+        `${label} failed (${formatErrorMessage(error)}). Retrying in ${formatDuration(delayMs)} (attempt ${attempt + 1}/${maxAttempts}).`
+      );
+      await sleep(delayMs, context.signal);
+    } finally {
+      cleanup();
+    }
+  }
+  throw new Error(`${label} failed.`);
+}
+async function executeAsyncResearch({
+  providerLabel,
+  providerId,
+  context,
+  pollIntervalMs = DEFAULT_RESEARCH_POLL_INTERVAL_MS,
+  timeoutMs = DEFAULT_RESEARCH_TIMEOUT_MS,
+  maxConsecutivePollErrors = DEFAULT_RESEARCH_MAX_CONSECUTIVE_POLL_ERRORS,
+  start,
+  poll
+}) {
+  const timeoutMessage = `${providerLabel} research exceeded ${formatDuration(timeoutMs)}.`;
+  const deadline = createDeadlineSignal(
+    context.signal,
+    timeoutMs,
+    timeoutMessage
+  );
+  const researchContext = {
+    ...context,
+    signal: deadline.signal
+  };
+  let lastStatus;
+  let lastProgressStatus;
+  const startedAt = Date.now();
+  try {
+    researchContext.onProgress?.(`Starting research via ${providerLabel}`);
+    const job = await withAbortAndOptionalTimeout(
+      start(researchContext),
+      void 0,
+      researchContext.signal,
+      void 0
+    );
+    const jobId = job.id;
+    if (!jobId) {
+      throw new Error(`${providerLabel} research did not return a job id.`);
     }
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", (error) => {
-      rejectOnce(
-        new Error(
-          `${label} failed to start: ${error.message || String(error)}`
-        )
+    researchContext.onProgress?.(`${providerLabel} research started: ${jobId}`);
+    let consecutivePollErrors = 0;
+    while (true) {
+      throwIfAborted(
+        researchContext.signal,
+        `${providerLabel} research aborted.`
       );
-    });
-    child.on("close", (code, signal) => {
-      if (context.signal?.aborted) {
-        rejectOnce(new Error(`${label} was aborted.`));
-        return;
-      }
-      if (code !== 0) {
-        const detail = stderr.trim() || `exit code ${code ?? "unknown"}`;
-        rejectOnce(
-          new Error(
-            signal ? `${label} exited via signal ${signal}: ${detail}` : `${label} failed with exit code ${code}: ${detail}`
-          )
-        );
-        return;
-      }
-      const trimmed = stdout.trim();
-      if (!trimmed) {
-        rejectOnce(new Error(`${label} did not write JSON to stdout.`));
-        return;
-      }
       try {
-        resolveOnce(JSON.parse(trimmed));
+        const result = await withAbortAndOptionalTimeout(
+          poll(jobId, researchContext),
+          void 0,
+          researchContext.signal,
+          void 0
+        );
+        consecutivePollErrors = 0;
+        const progressStatus = result.statusText ?? result.status;
+        if (result.status !== lastStatus || progressStatus !== lastProgressStatus) {
+          researchContext.onProgress?.(
+            `Research via ${providerLabel}: ${progressStatus} (${formatElapsed(Date.now() - startedAt)} elapsed)`
+          );
+          lastStatus = result.status;
+          lastProgressStatus = progressStatus;
+        }
+        if (result.status === "completed") {
+          return result.output ?? {
+            provider: providerId,
+            text: `${providerLabel} research completed without textual output.`
+          };
+        }
+        if (result.status === "failed" || result.status === "cancelled") {
+          throw new Error(
+            formatResearchTerminalDiagnostic(
+              providerLabel,
+              result.status,
+              result.error
+            )
+          );
+        }
       } catch (error) {
-        rejectOnce(
-          new Error(
-            `${label} returned invalid JSON: ${error.message}`
-          )
+        if (isAbortErrorFromSignal(researchContext.signal, error)) {
+          throw error;
+        }
+        if (!isRetryableError(error)) {
+          throw normalizeError(error);
+        }
+        consecutivePollErrors += 1;
+        if (consecutivePollErrors >= maxConsecutivePollErrors) {
+          throw new Error(
+            `${providerLabel} research polling failed too many times in a row: ${formatErrorMessage(error)}`
+          );
+        }
+        researchContext.onProgress?.(
+          `${providerLabel} research poll is still retrying after transient errors (${consecutivePollErrors}/${maxConsecutivePollErrors} consecutive poll failures). Background job id: ${jobId}`
         );
       }
-    });
-    child.stdin.on("error", () => {
-    });
-    child.stdin.end(`${JSON.stringify(payload)}
-`);
-  });
-}
-function normalizeArgv(command) {
-  const argv = command.argv?.filter((entry) => entry.trim().length > 0) ?? [];
-  if (argv.length === 0) {
-    throw new Error("command is missing argv");
+      await sleep(pollIntervalMs, researchContext.signal);
+    }
+  } catch (error) {
+    if (isAbortErrorFromSignal(researchContext.signal, error)) {
+      throw new Error(
+        formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
+      );
+    }
+    throw new Error(
+      formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
+    );
+  } finally {
+    deadline.cleanup();
   }
-  return argv;
 }
-function resolveCommandCwd(commandCwd, fallbackCwd) {
-  if (!commandCwd || commandCwd.trim().length === 0) {
-    return fallbackCwd;
+function shouldRetryError(error, settings) {
+  if (error instanceof RequestTimeoutError) {
+    return settings.retryOnTimeout === true;
   }
-  return isAbsolute(commandCwd) ? commandCwd : resolve(fallbackCwd, commandCwd);
+  return isRetryableError(error);
 }
-
-// src/providers/custom.ts
-var customAdapter = {
-  id: "custom",
-  label: "Custom",
-  docsUrl: "https://github.com/mavam/pi-web-providers#custom-provider",
-  getToolOptionsSchema(_capability) {
-    return void 0;
-  },
-  createTemplate() {
-    return {};
-  },
-  getCapabilityStatus(config, _cwd, capability) {
-    if (capability) {
-      return hasCommandForCapability(config, capability) ? { state: "ready" } : { state: "missing_command" };
-    }
-    return hasAnyCommand(config) ? { state: "ready" } : { state: "missing_command" };
-  },
-  async search(query2, maxResults, config, context, options) {
-    const output = await runCommand({
-      capability: "search",
-      payload: {
-        capability: "search",
-        query: query2,
-        maxResults,
-        ...options ? { options } : {}
-      },
-      config,
-      context
-    });
-    return parseSearchResponse(output, customAdapter.id);
-  },
-  async contents(urls, config, context, options) {
-    const output = await runCommand({
-      capability: "contents",
-      payload: {
-        capability: "contents",
-        urls,
-        ...options ? { options } : {}
-      },
-      config,
-      context
-    });
-    return parseContentsResponse(output, customAdapter.id);
-  },
-  async answer(query2, config, context, options) {
-    const output = await runCommand({
-      capability: "answer",
-      payload: {
-        capability: "answer",
-        query: query2,
-        ...options ? { options } : {}
-      },
-      config,
-      context
-    });
-    return parseToolOutput(output, customAdapter.id);
-  },
-  async research(input, config, context, options) {
-    const output = await runCommand({
-      capability: "research",
-      payload: {
-        capability: "research",
-        input,
-        ...options ? { options } : {}
-      },
-      config,
-      context
-    });
-    return parseToolOutput(output, customAdapter.id);
+function isRetryableError(error) {
+  if (error instanceof RequestTimeoutError) {
+    return false;
   }
-};
-async function runCommand({
-  capability,
-  payload,
-  config,
-  context
-}) {
-  const command = getCommandConfig(config, capability);
-  if (!command) {
-    throw new Error(`has no command configured for ${capability}`);
+  const message = formatErrorMessage(error).toLowerCase();
+  if (!message || message === "operation aborted.") {
+    return false;
   }
-  return await runCliJsonCommand({
-    command,
-    payload: {
-      ...payload,
-      cwd: context.cwd
-    },
-    context,
-    label: `Custom ${capability}`
-  });
-}
-function getCommandConfig(config, capability) {
-  return config?.options?.[capability];
-}
-function hasCommandForCapability(config, capability) {
-  return normalizeConfiguredArgv(getCommandConfig(config, capability)).length > 0;
+  return /429|500|502|503|504|deadline exceeded|econnreset|ecanceled|ehostunreach|eai_again|enotfound|etimedout|fetch failed|gateway timeout|internal error|network|overloaded|rate limit|resource exhausted|socket hang up|temporarily unavailable|timeout|unavailable/.test(
+    message
+  );
 }
-function hasAnyCommand(config) {
-  return hasCommandForCapability(config, "search") || hasCommandForCapability(config, "contents") || hasCommandForCapability(config, "answer") || hasCommandForCapability(config, "research");
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
 }
-function normalizeConfiguredArgv(command) {
-  return command?.argv?.filter((entry) => entry.trim().length > 0) ?? [];
+function formatElapsed(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${totalSeconds}s`;
 }
-function parseSearchResponse(value, providerId) {
-  const response = requireObject(value, "search output must be a JSON object");
-  if (!Array.isArray(response.results)) {
-    throw new Error("search output must include a 'results' array");
+function formatDuration(ms) {
+  if (ms >= 6e4) {
+    return formatElapsed(ms);
   }
-  return {
-    provider: providerId,
-    results: response.results.map(
-      (entry, index) => parseSearchResult(entry, index)
-    )
-  };
+  if (ms >= 1e3) {
+    return `${Math.floor(ms / 1e3)}s`;
+  }
+  return `${ms}ms`;
 }
-function parseSearchResult(entry, index) {
-  const value = requireObject(
-    entry,
-    `search result at index ${index} must be a JSON object`
-  );
-  const metadata = readLenientJsonObject(value.metadata);
-  return {
-    title: readRequiredString(value.title, `results[${index}].title`),
-    url: readRequiredString(value.url, `results[${index}].url`),
-    snippet: readRequiredString(value.snippet, `results[${index}].snippet`),
-    ...typeof value.score === "number" ? { score: value.score } : {},
-    ...metadata !== void 0 ? { metadata } : {}
-  };
+async function sleep(ms, signal) {
+  throwIfAborted(signal);
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(getAbortError(signal));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
-function parseContentsResponse(value, providerId) {
-  const response = requireObject(
-    value,
-    "contents output must be a JSON object"
-  );
-  if (!Array.isArray(response.answers)) {
-    throw new Error("contents output must include an 'answers' array");
+function throwIfAborted(signal, message = "Operation aborted.") {
+  if (signal?.aborted) {
+    throw getAbortError(signal, message);
   }
-  return {
-    provider: providerId,
-    answers: response.answers.map(
-      (entry, index) => parseContentsAnswer(entry, index)
-    )
-  };
 }
-function parseContentsAnswer(entry, index) {
-  const value = requireObject(
-    entry,
-    `contents answer at index ${index} must be a JSON object`
-  );
-  const url = readRequiredString(value.url, `answers[${index}].url`);
-  const content = readOptionalString(
-    value.content,
-    `answers[${index}].content`
-  );
-  const summary = value.summary;
-  const metadata = readRequiredJsonObject(
-    value.metadata,
-    `answers[${index}].metadata`
-  );
-  const error = readOptionalString(value.error, `answers[${index}].error`);
-  if (content === void 0 && error === void 0) {
-    throw new Error(
-      `contents answer at index ${index} must include 'content' or 'error'`
-    );
+function createAttemptContext(context) {
+  const controller = new AbortController();
+  if (context.signal?.aborted) {
+    controller.abort(getAbortError(context.signal));
   }
-  return {
-    url,
-    ...content !== void 0 ? { content } : {},
-    ...summary !== void 0 ? { summary } : {},
-    ...metadata !== void 0 ? { metadata } : {},
-    ...error !== void 0 ? { error } : {}
+  const onAbort = () => {
+    controller.abort(getAbortError(context.signal));
   };
-}
-function parseToolOutput(value, providerId) {
-  const output = requireObject(value, "output must be a JSON object");
-  const metadata = readLenientJsonObject(output.metadata);
+  context.signal?.addEventListener("abort", onAbort, { once: true });
   return {
-    provider: providerId,
-    text: readRequiredString(output.text, "text"),
-    ...readOptionalNonNegativeInteger(output.itemCount),
-    ...metadata !== void 0 ? { metadata } : {}
+    context: {
+      ...context,
+      signal: controller.signal
+    },
+    abort: (reason) => controller.abort(reason),
+    cleanup: () => context.signal?.removeEventListener("abort", onAbort)
   };
 }
-function readRequiredJsonObject(value, field) {
-  if (value === void 0) {
-    return void 0;
+async function withAbortAndOptionalTimeout(promise, timeoutMs, signal, message, onTimeout) {
+  if (timeoutMs === void 0 && !signal) {
+    return await promise;
   }
-  return requireObject(value, `output field '${field}' must be a JSON object`);
-}
-function readLenientJsonObject(value) {
-  return isJsonObject2(value) ? value : void 0;
+  throwIfAborted(signal);
+  return await new Promise((resolve2, reject) => {
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      onTimeout?.();
+      cleanup();
+      reject(
+        new RequestTimeoutError(
+          message ?? `Operation timed out after ${formatDuration(timeoutMs)}.`
+        )
+      );
+    }, timeoutMs);
+    const onAbort = () => {
+      cleanup();
+      reject(getAbortError(signal));
+    };
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      signal?.removeEventListener("abort", onAbort);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        resolve2(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
 }
-function readRequiredString(value, field) {
-  if (typeof value !== "string") {
-    throw new Error(`output field '${field}' must be a string`);
+function getAbortError(signal, message = "Operation aborted.") {
+  const reason = signal?.reason;
+  if (reason instanceof Error) {
+    return reason;
   }
-  return value;
-}
-function readOptionalString(value, field) {
-  if (value === void 0) {
-    return void 0;
+  if (typeof reason === "string" && reason.length > 0) {
+    return new Error(reason);
   }
-  return readRequiredString(value, field);
+  return new Error(message);
 }
-function readOptionalNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? { itemCount: value } : {};
+function isAbortErrorFromSignal(signal, error) {
+  return signal?.aborted === true && signal.reason === error;
 }
-function requireObject(value, message) {
-  if (!isJsonObject2(value)) {
-    throw new Error(message);
+function createDeadlineSignal(signal, timeoutMs, timeoutMessage) {
+  const controller = new AbortController();
+  if (signal?.aborted) {
+    controller.abort(getAbortError(signal));
   }
-  return value;
+  const onAbort = () => {
+    controller.abort(getAbortError(signal));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => {
+    controller.abort(new RequestTimeoutError(timeoutMessage));
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  };
 }
-function isJsonObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(formatErrorMessage(error));
 }
 
 // src/providers/exa.ts
-import { Type as Type5 } from "typebox";
-import { Exa as ExaClient } from "exa-js";
 var exaSearchOptionsSchema = Type5.Object(
   {
     type: Type5.Optional(
@@ -1562,7 +1737,7 @@ var exaSearchOptionsSchema = Type5.Object(
   },
   { description: "Exa search options." }
 );
-var exaAdapter = {
+var exaImplementation = {
   id: "exa",
   label: "Exa",
   docsUrl: "https://exa.ai/docs/sdks/typescript-sdk-specification",
@@ -1593,13 +1768,13 @@ var exaAdapter = {
   async search(query2, maxResults, config, _context, searchOptions) {
     const client = createClient2(config);
     const options = {
-      ...stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {},
+      ...asJsonObject(config.options?.search) ?? {},
       ...searchOptions ?? {},
       numResults: maxResults
     };
     const response = await client.search(query2, options);
     return {
-      provider: exaAdapter.id,
+      provider: exaImplementation.id,
       results: (response.results ?? []).slice(0, maxResults).map((result) => ({
         title: String(result.title ?? result.url ?? "Untitled"),
         url: String(result.url ?? ""),
@@ -1615,7 +1790,7 @@ var exaAdapter = {
     const response = await client.getContents(urls, options);
     const results = response.results ?? [];
     return {
-      provider: exaAdapter.id,
+      provider: exaImplementation.id,
       answers: urls.map((url, index) => {
         const result = results[index];
         if (!result) {
@@ -1652,18 +1827,23 @@ var exaAdapter = {
       }
     }
     return {
-      provider: exaAdapter.id,
+      provider: exaImplementation.id,
       text: lines.join("\n").trimEnd(),
       itemCount: citations.length
     };
   },
   async research(input, config, context, options) {
     return await executeAsyncResearch({
-      providerLabel: exaAdapter.label,
-      providerId: exaAdapter.id,
+      providerLabel: exaImplementation.label,
+      providerId: exaImplementation.id,
       context,
-      start: (researchContext) => exaAdapter.startResearch(input, config, researchContext, options),
-      poll: (id, researchContext) => exaAdapter.pollResearch(id, config, researchContext, options)
+      start: (researchContext) => exaImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => exaImplementation.pollResearch(id, config, researchContext, options)
     });
   },
   async startResearch(input, config, _context, options) {
@@ -1682,7 +1862,7 @@ var exaAdapter = {
       return {
         status: "completed",
         output: {
-          provider: exaAdapter.id,
+          provider: exaImplementation.id,
           text: typeof content === "string" ? content : content !== void 0 ? formatJson(content) : "Exa research completed without textual output."
         }
       };
@@ -1709,6 +1889,69 @@ function createClient2(config) {
   }
   return new ExaClient(apiKey, resolveConfigValue(config.baseUrl));
 }
+var exaProvider = defineProvider({
+  id: "exa",
+  label: exaImplementation.label,
+  docsUrl: exaImplementation.docsUrl,
+  config: {
+    createTemplate: () => exaImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"],
+    optionCapabilities: ["search"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => exaImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: exaImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await exaImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: exaImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await exaImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: exaImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await exaImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: exaImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await exaImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/firecrawl.ts
 import FirecrawlClient from "@mendable/firecrawl-js";
@@ -1819,7 +2062,7 @@ var firecrawlScrapeOptionsSchema = Type6.Object(
   },
   { description: "Firecrawl scrape options." }
 );
-var firecrawlAdapter = {
+var firecrawlImplementation = {
   id: "firecrawl",
   label: "Firecrawl",
   docsUrl: "https://docs.firecrawl.dev/sdks/node",
@@ -1849,20 +2092,20 @@ var firecrawlAdapter = {
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient3(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const defaults = asJsonObject(config.options?.search) ?? {};
     const response = await client.search(query2, {
       ...defaults,
       ...options ?? {},
       limit: maxResults
     });
     return {
-      provider: firecrawlAdapter.id,
+      provider: firecrawlImplementation.id,
       results: flattenSearchResults(response).slice(0, maxResults)
     };
   },
   async contents(urls, config, _context, options) {
     const client = createClient3(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.scrape)) ?? {};
+    const defaults = asJsonObject(config.options?.scrape) ?? {};
     const scrapeOptions = {
       formats: ["markdown"],
       onlyMainContent: true,
@@ -1870,7 +2113,7 @@ var firecrawlAdapter = {
       ...options ?? {}
     };
     return {
-      provider: firecrawlAdapter.id,
+      provider: firecrawlImplementation.id,
       answers: await Promise.all(
         urls.map(async (url) => {
           try {
@@ -1956,6 +2199,46 @@ function asRecord(value) {
 function readString2(value) {
   return typeof value === "string" ? value : void 0;
 }
+var firecrawlProvider = defineProvider({
+  id: "firecrawl",
+  label: firecrawlImplementation.label,
+  docsUrl: firecrawlImplementation.docsUrl,
+  config: {
+    createTemplate: () => firecrawlImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => firecrawlImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: firecrawlImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await firecrawlImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: firecrawlImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await firecrawlImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/gemini.ts
 import { GoogleGenAI } from "@google/genai";
@@ -2025,7 +2308,7 @@ var geminiAgentConfigSchema = Type7.Object(
   },
   {
     additionalProperties: false,
-    description: "Safe Gemini deep-research agent configuration. The adapter adds the required type field."
+    description: "Safe Gemini deep-research agent configuration. The provider adds the required type field."
   }
 );
 var geminiSearchOptionsSchema = Type7.Object(
@@ -2056,7 +2339,7 @@ var geminiResearchOptionsSchema = Type7.Object(
   },
   { additionalProperties: false, description: "Gemini research options." }
 );
-var geminiAdapter = {
+var geminiImplementation = {
   id: "gemini",
   label: "Gemini",
   docsUrl: "https://github.com/googleapis/js-genai",
@@ -2704,12 +2987,63 @@ function getGeminiOptions(config) {
 function readNonEmptyString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
+var geminiProvider = defineProvider({
+  id: "gemini",
+  label: geminiImplementation.label,
+  docsUrl: geminiImplementation.docsUrl,
+  config: {
+    createTemplate: () => geminiImplementation.createTemplate(),
+    fields: ["apiKey", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => geminiImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: geminiImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await geminiImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: geminiImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await geminiImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: geminiImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await geminiImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/linkup.ts
-import { Type as Type8 } from "typebox";
 import {
   LinkupClient
 } from "linkup-sdk";
+import { Type as Type8 } from "typebox";
 var linkupSearchOptionsSchema = Type8.Object(
   {
     depth: Type8.Optional(
@@ -2753,7 +3087,7 @@ var linkupContentsOptionsSchema = Type8.Object(
   },
   { description: "Linkup fetch options." }
 );
-var linkupAdapter = {
+var linkupImplementation = {
   id: "linkup",
   label: "Linkup",
   docsUrl: "https://docs.linkup.so/pages/sdk/js/js",
@@ -2777,30 +3111,30 @@ var linkupAdapter = {
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient4(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const defaults = asJsonObject(config.options?.search) ?? {};
     const response = await client.search(
       buildSearchParams(query2, maxResults, {
         ...defaults,
-        ...stripLocalExecutionOptions(options) ?? {}
+        ...options ?? {}
       })
     );
     return {
-      provider: linkupAdapter.id,
+      provider: linkupImplementation.id,
       results: (response.results ?? []).map(toSearchResult2).filter((result) => result !== null).slice(0, maxResults)
     };
   },
   async contents(urls, config, _context, options) {
     const client = createClient4(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.fetch)) ?? {};
+    const defaults = asJsonObject(config.options?.fetch) ?? {};
     return {
-      provider: linkupAdapter.id,
+      provider: linkupImplementation.id,
       answers: await Promise.all(
         urls.map(async (url) => {
           try {
             const response = await client.fetch(
               buildFetchParams(url, {
                 ...defaults,
-                ...stripLocalExecutionOptions(options) ?? {}
+                ...options ?? {}
               })
             );
             return response.markdown ? {
@@ -2909,6 +3243,218 @@ function toDate(value, name) {
   }
   return date;
 }
+var linkupProvider = defineProvider({
+  id: "linkup",
+  label: linkupImplementation.label,
+  docsUrl: linkupImplementation.docsUrl,
+  config: {
+    createTemplate: () => linkupImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => linkupImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: linkupImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await linkupImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: linkupImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await linkupImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
+
+// src/providers/ollama.ts
+var DEFAULT_BASE_URL = "https://ollama.com";
+var WEB_SEARCH_PATH = "/api/web_search";
+var WEB_FETCH_PATH = "/api/web_fetch";
+var ollamaProvider = defineProvider({
+  id: "ollama",
+  label: "Ollama",
+  docsUrl: "https://docs.ollama.com/capabilities/web-search",
+  config: {
+    createTemplate() {
+      return {
+        apiKey: "OLLAMA_API_KEY"
+      };
+    },
+    fields: ["apiKey", "baseUrl", "settings"]
+  },
+  getCapabilityStatus(config) {
+    return getApiKeyStatus(config?.apiKey);
+  },
+  capabilities: {
+    search: defineCapability({
+      limits: {
+        maxResults: 10
+      },
+      async execute({ query: query2, maxResults }, { config, signal }) {
+        return await searchOllama(query2, maxResults, config, {
+          signal
+        });
+      }
+    }),
+    contents: defineCapability({
+      async execute({ urls }, { config, signal }) {
+        return await fetchOllamaContents(urls, config, { signal });
+      }
+    })
+  }
+});
+async function searchOllama(query2, maxResults, config, context) {
+  const apiKey = resolveApiKey(config);
+  const response = await fetch(
+    resolveEndpoint(config.baseUrl, WEB_SEARCH_PATH),
+    {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify({
+        query: query2,
+        max_results: clampMaxResults(maxResults)
+      }),
+      signal: context.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await buildHttpError(response));
+  }
+  const data = await response.json();
+  const results = Array.isArray(data.results) ? data.results : [];
+  return {
+    provider: ollamaProvider.id,
+    results: results.slice(0, clampMaxResults(maxResults)).map((result) => ({
+      title: result.title || result.url || "Untitled",
+      url: result.url ?? "",
+      snippet: trimSnippet(result.content)
+    }))
+  };
+}
+async function fetchOllamaContents(urls, config, context) {
+  const apiKey = resolveApiKey(config);
+  const endpoint = resolveEndpoint(config.baseUrl, WEB_FETCH_PATH);
+  return {
+    provider: ollamaProvider.id,
+    answers: await Promise.all(
+      urls.map(async (url) => {
+        try {
+          const response = await fetch(endpoint, {
+            method: "POST",
+            headers: buildHeaders(apiKey),
+            body: JSON.stringify({
+              url
+            }),
+            signal: context.signal
+          });
+          if (!response.ok) {
+            return {
+              url,
+              error: await buildHttpError(response)
+            };
+          }
+          const data = await response.json();
+          const content = normalizeContentText(data.content);
+          if (!content) {
+            return {
+              url,
+              error: "No content returned for this URL."
+            };
+          }
+          const metadata = buildFetchMetadata(data);
+          return {
+            url,
+            content,
+            ...metadata ? { metadata } : {}
+          };
+        } catch (error) {
+          return {
+            url,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })
+    )
+  };
+}
+function resolveApiKey(config) {
+  const apiKey = resolveConfigValue(config.apiKey);
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return apiKey;
+}
+function buildHeaders(apiKey) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    "content-type": "application/json"
+  };
+}
+function resolveEndpoint(baseUrlReference, endpointPath) {
+  const baseUrl = resolveConfigValue(baseUrlReference) ?? DEFAULT_BASE_URL;
+  const base = baseUrl.replace(/\/+$/, "");
+  const apiPath = endpointPath.replace(/^\/api\//, "");
+  if (base.endsWith(endpointPath)) {
+    return base;
+  }
+  if (base.endsWith("/api")) {
+    return `${base}/${apiPath}`;
+  }
+  return `${base}${endpointPath}`;
+}
+function clampMaxResults(value) {
+  return Math.max(1, Math.min(10, Math.trunc(value || 0)));
+}
+async function buildHttpError(response) {
+  const detail = await readErrorDetail(response);
+  const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  return detail ? `Ollama API request failed (${status}): ${detail}` : `Ollama API request failed (${status}).`;
+}
+async function readErrorDetail(response) {
+  const text = (await response.text()).trim();
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    for (const key of ["message", "error", "detail"]) {
+      if (typeof parsed[key] === "string" && parsed[key].trim()) {
+        return parsed[key];
+      }
+    }
+    return JSON.stringify(parsed);
+  } catch {
+    return text;
+  }
+}
+function buildFetchMetadata(data) {
+  const metadata = {};
+  if (data.title) {
+    metadata.title = data.title;
+  }
+  if (data.links?.length) {
+    metadata.links = data.links;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
 
 // src/providers/openai.ts
 import { Type as Type9 } from "typebox";
@@ -2987,7 +3533,7 @@ var searchResultSchema = {
     }
   }
 };
-var openaiAdapter = {
+var openaiImplementation = {
   id: "openai",
   label: "OpenAI",
   docsUrl: "https://platform.openai.com/docs/guides/deep-research",
@@ -3040,11 +3586,16 @@ var openaiAdapter = {
   },
   async research(input, config, context, options) {
     return await executeAsyncResearch({
-      providerLabel: openaiAdapter.label,
-      providerId: openaiAdapter.id,
+      providerLabel: openaiImplementation.label,
+      providerId: openaiImplementation.id,
       context,
-      start: (researchContext) => openaiAdapter.startResearch(input, config, researchContext, options),
-      poll: (id, researchContext) => openaiAdapter.pollResearch(id, config, researchContext, options)
+      start: (researchContext) => openaiImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => openaiImplementation.pollResearch(id, config, researchContext, options)
     });
   },
   async startResearch(input, config, context, options) {
@@ -3219,7 +3770,7 @@ function parseSearchResponse2(response, maxResults) {
   }
   const payload = parseSearchPayload(response.output_text);
   return {
-    provider: openaiAdapter.id,
+    provider: openaiImplementation.id,
     results: payload.sources.slice(0, maxResults).map((source) => ({
       title: source.title.trim(),
       url: source.url.trim(),
@@ -3258,7 +3809,7 @@ function formatResponseOutput(response, operation) {
     }
   }
   return {
-    provider: openaiAdapter.id,
+    provider: openaiImplementation.id,
     text: lines.join("\n").trimEnd(),
     itemCount: citations.length,
     metadata: {
@@ -3362,6 +3913,58 @@ function readPositiveInteger2(value) {
 function readInteger(value) {
   return typeof value === "number" && Number.isInteger(value) ? value : void 0;
 }
+var openaiProvider = defineProvider({
+  id: "openai",
+  label: openaiImplementation.label,
+  docsUrl: openaiImplementation.docsUrl,
+  config: {
+    createTemplate: () => openaiImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"],
+    optionCapabilities: ["search", "answer", "research"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => openaiImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: openaiImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await openaiImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: openaiImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await openaiImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: openaiImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await openaiImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/parallel.ts
 import { Type as Type10 } from "typebox";
@@ -3389,7 +3992,7 @@ var parallelExtractOptionsSchema = Type10.Object(
   },
   { description: "Parallel extract options." }
 );
-var parallelAdapter = {
+var parallelImplementation = {
   id: "parallel",
   label: "Parallel",
   docsUrl: "https://github.com/parallel-web/parallel-sdk-typescript",
@@ -3422,7 +4025,7 @@ var parallelAdapter = {
   },
   async search(query2, maxResults, config, context, options) {
     const client = createClient6(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const defaults = asJsonObject(config.options?.search) ?? {};
     const response = await client.beta.search(
       {
         ...defaults,
@@ -3433,7 +4036,7 @@ var parallelAdapter = {
       buildRequestOptions3(context)
     );
     return {
-      provider: parallelAdapter.id,
+      provider: parallelImplementation.id,
       results: response.results.slice(0, maxResults).map((result) => ({
         title: result.title ?? result.url,
         url: result.url,
@@ -3443,7 +4046,7 @@ var parallelAdapter = {
   },
   async contents(urls, config, context, options) {
     const client = createClient6(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
+    const defaults = asJsonObject(config.options?.extract) ?? {};
     const response = await client.beta.extract(
       {
         ...defaults,
@@ -3459,7 +4062,7 @@ var parallelAdapter = {
       response.errors.map((error) => [error.url, error])
     );
     return {
-      provider: parallelAdapter.id,
+      provider: parallelImplementation.id,
       answers: urls.map((url) => {
         const result = resultsByUrl.get(url);
         if (result) {
@@ -3494,6 +4097,46 @@ function createClient6(config) {
 function buildRequestOptions3(context) {
   return context.signal ? { signal: context.signal } : void 0;
 }
+var parallelProvider = defineProvider({
+  id: "parallel",
+  label: parallelImplementation.label,
+  docsUrl: parallelImplementation.docsUrl,
+  config: {
+    createTemplate: () => parallelImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => parallelImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: parallelImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await parallelImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: parallelImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await parallelImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/perplexity.ts
 import PerplexityClient from "@perplexity-ai/perplexity_ai";
@@ -3539,7 +4182,7 @@ var perplexityResearchOptionsSchema = Type11.Object(
   },
   { description: "Perplexity research options." }
 );
-var perplexityAdapter = {
+var perplexityImplementation = {
   id: "perplexity",
   label: "Perplexity",
   docsUrl: "https://docs.perplexity.ai/docs/sdk/overview.md",
@@ -3574,7 +4217,7 @@ var perplexityAdapter = {
   async search(query2, maxResults, config, context, options) {
     const client = createClient7(config);
     const request = {
-      ...stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {},
+      ...asJsonObject(config.options?.search) ?? {},
       ...options ?? {},
       query: query2,
       max_results: maxResults
@@ -3584,7 +4227,7 @@ var perplexityAdapter = {
       buildRequestOptions4(context)
     );
     return {
-      provider: perplexityAdapter.id,
+      provider: perplexityImplementation.id,
       results: response.results.slice(0, maxResults).map((result) => ({
         title: result.title,
         url: result.url,
@@ -3619,9 +4262,7 @@ var perplexityAdapter = {
 };
 async function runSilentForegroundChatTool(input, config, context, fallbackModel, label, options, isResearch = false) {
   const client = createClient7(config);
-  const defaults = stripLocalExecutionOptions(
-    isResearch ? asJsonObject(config.options?.research) : asJsonObject(config.options?.answer)
-  ) ?? {};
+  const defaults = (isResearch ? asJsonObject(config.options?.research) : asJsonObject(config.options?.answer)) ?? {};
   const request = {
     ...defaults,
     ...options ?? {},
@@ -3646,14 +4287,14 @@ async function runSilentForegroundChatTool(input, config, context, fallbackModel
     }
   }
   return {
-    provider: perplexityAdapter.id,
+    provider: perplexityImplementation.id,
     text: lines.join("\n").trimEnd(),
     itemCount: sources.length
   };
 }
 async function runStreamingForegroundChatTool(input, config, context, fallbackModel, label, options) {
   const client = createClient7(config);
-  const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.research)) ?? {};
+  const defaults = asJsonObject(config.options?.research) ?? {};
   const request = {
     ...defaults,
     ...options ?? {},
@@ -3688,7 +4329,7 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
     }
   }
   return {
-    provider: perplexityAdapter.id,
+    provider: perplexityImplementation.id,
     text: lines.join("\n").trimEnd(),
     itemCount: dedupedSources.length
   };
@@ -3773,10 +4414,61 @@ function extractSources(response) {
 function buildRequestOptions4(context) {
   return context.signal ? { signal: context.signal } : void 0;
 }
+var perplexityProvider = defineProvider({
+  id: "perplexity",
+  label: perplexityImplementation.label,
+  docsUrl: perplexityImplementation.docsUrl,
+  config: {
+    createTemplate: () => perplexityImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => perplexityImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: perplexityImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await perplexityImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: perplexityImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await perplexityImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: perplexityImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await perplexityImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/serper.ts
 import { Type as Type12 } from "typebox";
-var DEFAULT_BASE_URL = "https://google.serper.dev";
+var DEFAULT_BASE_URL2 = "https://google.serper.dev";
 var serperSearchOptionsSchema = Type12.Object(
   {
     gl: Type12.Optional(
@@ -3808,7 +4500,7 @@ var serperSearchOptionsSchema = Type12.Object(
   },
   { description: "Serper search options." }
 );
-var serperAdapter = {
+var serperImplementation = {
   id: "serper",
   label: "Serper",
   docsUrl: "https://serper.dev/",
@@ -3834,15 +4526,15 @@ var serperAdapter = {
     if (!apiKey) {
       throw new Error("is missing an API key");
     }
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
-    const runtimeOptions = stripLocalExecutionOptions(asJsonObject(options));
+    const defaults = asJsonObject(config.options?.search) ?? {};
+    const callOptions = asJsonObject(options);
     const {
       q: _ignoredQuery,
       num: _ignoredNum,
       ...providerOptions
     } = {
       ...defaults,
-      ...runtimeOptions ?? {}
+      ...callOptions ?? {}
     };
     const response = await fetch(joinUrl(resolveConfigValue(config.baseUrl)), {
       method: "POST",
@@ -3852,39 +4544,39 @@ var serperAdapter = {
       },
       body: JSON.stringify({
         q: query2,
-        num: clampMaxResults(maxResults),
+        num: clampMaxResults2(maxResults),
         ...providerOptions
       }),
       signal: context.signal
     });
     if (!response.ok) {
-      throw new Error(await buildHttpError(response));
+      throw new Error(await buildHttpError2(response));
     }
     const payload = await response.json();
     const responseRecord = asRecord3(payload) ?? {};
     const organic = asArray(responseRecord.organic) ?? [];
     const searchContext = buildSearchContext(responseRecord);
     return {
-      provider: serperAdapter.id,
+      provider: serperImplementation.id,
       results: organic.map((entry) => toSearchResult3(entry, searchContext)).filter(
         (result) => result !== null
-      ).slice(0, clampMaxResults(maxResults))
+      ).slice(0, clampMaxResults2(maxResults))
     };
   }
 };
 function joinUrl(baseUrl) {
-  const base = (baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const base = (baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
   return `${base}/search`;
 }
-function clampMaxResults(value) {
+function clampMaxResults2(value) {
   return Math.max(1, Math.min(20, Math.trunc(value || 0)));
 }
-async function buildHttpError(response) {
-  const detail = await readErrorDetail(response);
+async function buildHttpError2(response) {
+  const detail = await readErrorDetail2(response);
   const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
   return detail ? `Serper API request failed (${status}): ${detail}` : `Serper API request failed (${status}).`;
 }
-async function readErrorDetail(response) {
+async function readErrorDetail2(response) {
   const text = (await response.text()).trim();
   if (!text) {
     return void 0;
@@ -3971,6 +4663,36 @@ function readString4(value) {
 function readNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+var serperProvider = defineProvider({
+  id: "serper",
+  label: serperImplementation.label,
+  docsUrl: serperImplementation.docsUrl,
+  config: {
+    createTemplate: () => serperImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"],
+    optionCapabilities: ["search"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => serperImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: serperImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await serperImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/tavily.ts
 import { Type as Type13 } from "typebox";
@@ -4054,7 +4776,7 @@ var tavilyExtractOptionsSchema = Type13.Object(
   },
   { description: "Tavily extract options." }
 );
-var tavilyAdapter = {
+var tavilyImplementation = {
   id: "tavily",
   label: "Tavily",
   docsUrl: "https://docs.tavily.com/sdk/javascript/reference",
@@ -4087,14 +4809,14 @@ var tavilyAdapter = {
   },
   async search(query2, maxResults, config, _context, options) {
     const client = createClient8(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const defaults = asJsonObject(config.options?.search) ?? {};
     const response = await client.search(query2, {
       ...defaults,
       ...options ?? {},
       maxResults
     });
     return {
-      provider: tavilyAdapter.id,
+      provider: tavilyImplementation.id,
       results: response.results.slice(0, maxResults).map((result) => ({
         title: result.title || result.url || "Untitled",
         url: result.url || "",
@@ -4106,7 +4828,7 @@ var tavilyAdapter = {
   },
   async contents(urls, config, _context, options) {
     const client = createClient8(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
+    const defaults = asJsonObject(config.options?.extract) ?? {};
     const response = await client.extract(urls, {
       ...defaults,
       ...options ?? {}
@@ -4118,7 +4840,7 @@ var tavilyAdapter = {
       response.failedResults.map((result) => [result.url, result])
     );
     return {
-      provider: tavilyAdapter.id,
+      provider: tavilyImplementation.id,
       answers: urls.map((url) => {
         const result = resultsByUrl.get(url);
         if (result) {
@@ -4173,6 +4895,46 @@ function buildExtractMetadata(response, result) {
   };
   return Object.keys(metadata).length > 0 ? metadata : void 0;
 }
+var tavilyProvider = defineProvider({
+  id: "tavily",
+  label: tavilyImplementation.label,
+  docsUrl: tavilyImplementation.docsUrl,
+  config: {
+    createTemplate: () => tavilyImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => tavilyImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: tavilyImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await tavilyImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: tavilyImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await tavilyImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/valyu.ts
 import { Type as Type14 } from "typebox";
@@ -4221,7 +4983,7 @@ var valyuResearchOptionsSchema = Type14.Object(
   },
   { description: "Valyu research options." }
 );
-var valyuAdapter = {
+var valyuImplementation = {
   id: "valyu",
   label: "Valyu",
   docsUrl: "https://docs.valyu.ai/sdk/typescript-sdk",
@@ -4254,7 +5016,7 @@ var valyuAdapter = {
   async search(query2, maxResults, config, _context, searchOptions) {
     const client = createClient9(config);
     const options = {
-      ...stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {},
+      ...asJsonObject(config.options?.search) ?? {},
       ...searchOptions ?? {},
       maxNumResults: maxResults
     };
@@ -4263,7 +5025,7 @@ var valyuAdapter = {
       throw new Error(response.error || "search failed");
     }
     return {
-      provider: valyuAdapter.id,
+      provider: valyuImplementation.id,
       results: (response.results ?? []).slice(0, maxResults).map((result) => ({
         title: result.title,
         url: result.url,
@@ -4287,7 +5049,7 @@ var valyuAdapter = {
       )
     );
     return {
-      provider: valyuAdapter.id,
+      provider: valyuImplementation.id,
       answers: urls.map((url) => {
         const result = resultsByUrl.get(url);
         if (!result) {
@@ -4311,7 +5073,7 @@ var valyuAdapter = {
   async answer(query2, config, _context, options) {
     const client = createClient9(config);
     const response = await client.answer(query2, {
-      ...stripLocalExecutionOptions(asJsonObject(config.options?.answer)) ?? {},
+      ...asJsonObject(config.options?.answer) ?? {},
       ...options ?? {},
       streaming: false
     });
@@ -4333,25 +5095,30 @@ var valyuAdapter = {
       }
     }
     return {
-      provider: valyuAdapter.id,
+      provider: valyuImplementation.id,
       text: lines.join("\n").trimEnd(),
       itemCount: sources.length
     };
   },
   async research(input, config, context, options) {
     return await executeAsyncResearch({
-      providerLabel: valyuAdapter.label,
-      providerId: valyuAdapter.id,
+      providerLabel: valyuImplementation.label,
+      providerId: valyuImplementation.id,
       context,
-      start: (researchContext) => valyuAdapter.startResearch(input, config, researchContext, options),
-      poll: (id, researchContext) => valyuAdapter.pollResearch(id, config, researchContext, options)
+      start: (researchContext) => valyuImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => valyuImplementation.pollResearch(id, config, researchContext, options)
     });
   },
   async startResearch(input, config, _context, options) {
     const client = createClient9(config);
     const task = await client.deepresearch.create({
       input,
-      ...stripLocalExecutionOptions(asJsonObject(config.options?.research)) ?? {},
+      ...asJsonObject(config.options?.research) ?? {},
       ...options ?? {}
     });
     if (!task.success || !task.deepresearch_id) {
@@ -4382,7 +5149,7 @@ var valyuAdapter = {
       return {
         status: "completed",
         output: {
-          provider: valyuAdapter.id,
+          provider: valyuImplementation.id,
           text: lines.join("\n").trimEnd(),
           itemCount: sources.length
         }
@@ -4410,43 +5177,93 @@ function createClient9(config) {
   }
   return new ValyuClient(apiKey, resolveConfigValue(config.baseUrl));
 }
+var valyuProvider = defineProvider({
+  id: "valyu",
+  label: valyuImplementation.label,
+  docsUrl: valyuImplementation.docsUrl,
+  config: {
+    createTemplate: () => valyuImplementation.createTemplate(),
+    fields: ["apiKey", "baseUrl", "options", "settings"],
+    optionCapabilities: ["search", "answer", "research"]
+  },
+  getCapabilityStatus: (config, cwd, tool) => valyuImplementation.getCapabilityStatus(
+    config,
+    cwd,
+    tool
+  ),
+  capabilities: {
+    search: defineCapability({
+      options: valyuImplementation.getToolOptionsSchema?.("search"),
+      async execute(input, ctx) {
+        const { query: query2, maxResults, options } = input;
+        return await valyuImplementation.search(
+          query2,
+          maxResults,
+          ctx.config,
+          ctx,
+          options
+        );
+      }
+    }),
+    contents: defineCapability({
+      options: valyuImplementation.getToolOptionsSchema?.("contents"),
+      async execute(input, ctx) {
+        return await valyuImplementation.contents(
+          input.urls,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    answer: defineCapability({
+      options: valyuImplementation.getToolOptionsSchema?.("answer"),
+      async execute(input, ctx) {
+        return await valyuImplementation.answer(
+          input.query,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    }),
+    research: defineCapability({
+      options: valyuImplementation.getToolOptionsSchema?.("research"),
+      async execute(input, ctx) {
+        return await valyuImplementation.research(
+          input.input,
+          ctx.config,
+          ctx,
+          input.options
+        );
+      }
+    })
+  }
+});
 
 // src/providers/index.ts
-var ADAPTERS_BY_ID = {
-  claude: claudeAdapter,
-  codex: codexAdapter,
-  cloudflare: cloudflareAdapter,
-  custom: customAdapter,
-  exa: exaAdapter,
-  firecrawl: firecrawlAdapter,
-  gemini: geminiAdapter,
-  linkup: linkupAdapter,
-  openai: openaiAdapter,
-  parallel: parallelAdapter,
-  perplexity: perplexityAdapter,
-  serper: serperAdapter,
-  tavily: tavilyAdapter,
-  valyu: valyuAdapter
-};
-var ADAPTERS = Object.values(ADAPTERS_BY_ID);
+var PROVIDERS = defineProviders({
+  claude: claudeProvider,
+  codex: codexProvider,
+  cloudflare: cloudflareProvider,
+  custom: customProvider,
+  exa: exaProvider,
+  firecrawl: firecrawlProvider,
+  gemini: geminiProvider,
+  linkup: linkupProvider,
+  ollama: ollamaProvider,
+  openai: openaiProvider,
+  parallel: parallelProvider,
+  perplexity: perplexityProvider,
+  serper: serperProvider,
+  tavily: tavilyProvider,
+  valyu: valyuProvider
+});
+var PROVIDERS_BY_ID = PROVIDERS;
+var PROVIDER_LIST = Object.values(PROVIDERS);
+var PROVIDER_IDS = Object.keys(PROVIDERS);
 
 // src/types.ts
-var PROVIDER_IDS = [
-  "claude",
-  "cloudflare",
-  "codex",
-  "custom",
-  "exa",
-  "firecrawl",
-  "gemini",
-  "linkup",
-  "openai",
-  "parallel",
-  "perplexity",
-  "serper",
-  "tavily",
-  "valyu"
-];
 var TOOLS = ["search", "contents", "answer", "research"];
 
 // src/provider-tools.ts
@@ -4469,16 +5286,16 @@ var TOOL_INFO = {
   }
 };
 function supportsTool(providerId, toolId) {
-  return typeof ADAPTERS_BY_ID[providerId][toolId] === "function";
+  const capabilities = PROVIDERS[providerId].capabilities;
+  return capabilities[toolId] !== void 0;
 }
 function getProviderTools(providerId) {
-  const provider = ADAPTERS_BY_ID[providerId];
-  return TOOLS.filter((tool) => typeof provider[tool] === "function");
+  return TOOLS.filter((tool) => supportsTool(providerId, tool));
 }
 function getCompatibleProviders(toolId) {
-  return ADAPTERS.filter((provider) => supportsTool(provider.id, toolId)).map(
-    (provider) => provider.id
-  );
+  return PROVIDER_LIST.filter(
+    (provider) => supportsTool(provider.id, toolId)
+  ).map((provider) => provider.id);
 }
 function getMappedProviderForTool(config, tool) {
   return config.tools?.[tool];
@@ -4565,111 +5382,52 @@ function normalizeConfig(raw, source) {
   return config;
 }
 function normalizeProvider(providerId, raw, source) {
-  switch (providerId) {
-    case "claude":
-      return parseProviderWithShape(raw, source, providerId, {
-        pathToClaudeCodeExecutable: readOptionalString2,
-        options: readOptionalObject,
-        settings: parseOptionalExecutionSettings
-      });
-    case "cloudflare":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiToken: readOptionalString2,
-        accountId: readOptionalString2,
-        options: readOptionalObject,
-        settings: parseOptionalExecutionSettings
-      });
-    case "codex":
-      return parseProviderWithShape(raw, source, providerId, {
-        codexPath: readOptionalString2,
-        baseUrl: readOptionalString2,
-        apiKey: readOptionalString2,
-        env: readOptionalStringMap,
-        config: readOptionalObject,
-        options: readOptionalObject,
-        settings: parseOptionalExecutionSettings
-      });
-    case "exa":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        baseUrl: readOptionalString2,
-        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
-          value,
-          innerSource,
-          field,
-          ["search"]
-        ),
-        settings: parseOptionalExecutionSettings
-      });
-    case "valyu":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        baseUrl: readOptionalString2,
-        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
-          value,
-          innerSource,
-          field,
-          ["search", "answer", "research"]
-        ),
-        settings: parseOptionalExecutionSettings
-      });
-    case "gemini":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        options: readOptionalObject,
-        settings: parseOptionalExecutionSettings
-      });
-    case "openai":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        baseUrl: readOptionalString2,
-        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
-          value,
-          innerSource,
-          field,
-          ["search", "answer", "research"]
-        ),
-        settings: parseOptionalExecutionSettings
-      });
-    case "firecrawl":
-    case "linkup":
-    case "parallel":
-    case "perplexity":
-      return parseProviderWithShape(
-        raw,
+  const definition = PROVIDERS[providerId];
+  return parseProviderWithShape(
+    raw,
+    source,
+    providerId,
+    buildProviderConfigShape(
+      definition.config.fields,
+      definition.config.optionCapabilities
+    )
+  );
+}
+function buildProviderConfigShape(fields, optionCapabilities) {
+  return Object.fromEntries(
+    fields.map((field) => [
+      toProviderConfigKey(field),
+      getProviderConfigFieldParser(field, optionCapabilities)
+    ])
+  );
+}
+function toProviderConfigKey(field) {
+  return field === "customOptions" ? "options" : field;
+}
+function getProviderConfigFieldParser(field, optionCapabilities) {
+  switch (field) {
+    case "accountId":
+    case "apiKey":
+    case "apiToken":
+    case "baseUrl":
+    case "codexPath":
+    case "pathToClaudeCodeExecutable":
+      return readOptionalString2;
+    case "config":
+      return readOptionalObject;
+    case "customOptions":
+      return parseOptionalCustomProviderOptions;
+    case "env":
+      return readOptionalStringMap;
+    case "options":
+      return optionCapabilities ? (value, source, field2) => parseOptionalCapabilityOptions(
+        value,
         source,
-        providerId,
-        {
-          apiKey: readOptionalString2,
-          baseUrl: readOptionalString2,
-          options: readOptionalObject,
-          settings: parseOptionalExecutionSettings
-        }
-      );
-    case "serper":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        baseUrl: readOptionalString2,
-        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
-          value,
-          innerSource,
-          field,
-          ["search"]
-        ),
-        settings: parseOptionalExecutionSettings
-      });
-    case "tavily":
-      return parseProviderWithShape(raw, source, providerId, {
-        apiKey: readOptionalString2,
-        baseUrl: readOptionalString2,
-        options: readOptionalObject,
-        settings: parseOptionalExecutionSettings
-      });
-    case "custom":
-      return parseProviderWithShape(raw, source, providerId, {
-        options: parseOptionalCustomProviderOptions,
-        settings: parseOptionalExecutionSettings
-      });
+        field2,
+        optionCapabilities
+      ) : readOptionalObject;
+    case "settings":
+      return parseOptionalExecutionSettings;
   }
 }
 function parseProviderWithShape(raw, source, providerId, shape) {
@@ -4755,36 +5513,47 @@ function parseExecutionSettings(value, source, field, allowSearch) {
   if (unknownKeys.length > 0) {
     throw new Error(`'${field}' in ${source} must be a JSON object.`);
   }
-  const parsed = {
-    requestTimeoutMs: parseOptionalPositiveInteger(
-      settings.requestTimeoutMs,
-      source,
-      `${field}.requestTimeoutMs`
-    ),
-    retryCount: parseOptionalNonNegativeInteger(
-      settings.retryCount,
-      source,
-      `${field}.retryCount`
-    ),
-    retryDelayMs: parseOptionalPositiveInteger(
-      settings.retryDelayMs,
-      source,
-      `${field}.retryDelayMs`
-    ),
-    researchTimeoutMs: parseOptionalPositiveInteger(
-      settings.researchTimeoutMs,
+  const parsed = {};
+  const requestTimeoutMs = parseOptionalPositiveInteger(
+    settings.requestTimeoutMs,
+    source,
+    `${field}.requestTimeoutMs`
+  );
+  if (requestTimeoutMs !== void 0) {
+    parsed.requestTimeoutMs = requestTimeoutMs;
+  }
+  const retryCount = parseOptionalNonNegativeInteger(
+    settings.retryCount,
+    source,
+    `${field}.retryCount`
+  );
+  if (retryCount !== void 0) {
+    parsed.retryCount = retryCount;
+  }
+  const retryDelayMs = parseOptionalPositiveInteger(
+    settings.retryDelayMs,
+    source,
+    `${field}.retryDelayMs`
+  );
+  if (retryDelayMs !== void 0) {
+    parsed.retryDelayMs = retryDelayMs;
+  }
+  const researchTimeoutMs = parseOptionalPositiveInteger(
+    settings.researchTimeoutMs,
+    source,
+    `${field}.researchTimeoutMs`
+  );
+  if (researchTimeoutMs !== void 0) {
+    parsed.researchTimeoutMs = researchTimeoutMs;
+  }
+  if (allowSearch && settings.search !== void 0) {
+    parsed.search = parseSearchSettings(
+      settings.search,
       source,
-      `${field}.researchTimeoutMs`
-    ),
-    ...allowSearch && settings.search !== void 0 ? {
-      search: parseSearchSettings(
-        settings.search,
-        source,
-        `${field}.search`
-      )
-    } : {}
-  };
-  return Object.values(parsed).some((entry) => entry !== void 0) ? parsed : {};
+      `${field}.search`
+    );
+  }
+  return parsed;
 }
 function parseToolProviderMapping(value, source, field) {
   const mapping = requireObject2(
@@ -5118,93 +5887,39 @@ ${JSON.stringify(value, null, 2).trim()}
 }
 
 // src/options.ts
-import { Type as Type15 } from "typebox";
-var runtimeOptionFields = {
-  requestTimeoutMs: Type15.Optional(
-    Type15.Integer({
-      minimum: 1,
-      description: "Maximum time in milliseconds to wait for a single provider request."
-    })
-  ),
-  retryCount: Type15.Optional(
-    Type15.Integer({
-      minimum: 0,
-      description: "Number of times to retry transient failures."
-    })
-  ),
-  retryDelayMs: Type15.Optional(
-    Type15.Integer({
-      minimum: 1,
-      description: "Initial delay in milliseconds before retrying. Later retries back off automatically."
-    })
-  )
-};
-var runtimeOptionsSchema = Type15.Object(runtimeOptionFields, {
-  additionalProperties: false,
-  description: "Local runtime controls for this tool call."
-});
-var searchPrefetchOptionsSchema = Type15.Object(
-  {
-    provider: Type15.Optional(
-      Type15.Union([...PROVIDER_IDS.map((id) => Type15.Literal(id)), Type15.Null()], {
-        description: "Contents-capable provider to prefetch search result URLs. Set to enable prefetch."
-      })
-    ),
-    maxUrls: Type15.Optional(
-      Type15.Integer({
-        minimum: 1,
-        description: "Maximum number of search result URLs to prefetch."
-      })
-    ),
-    ttlMs: Type15.Optional(
-      Type15.Integer({
-        minimum: 1,
-        description: "How long prefetched contents stay reusable in the local cache, in milliseconds."
-      })
-    )
-  },
-  {
-    additionalProperties: false,
-    description: "Background contents prefetch for search result URLs. Only runs when provider is set."
-  }
-);
-var searchRuntimeOptionsSchema = Type15.Object(
-  {
-    ...runtimeOptionFields,
-    prefetch: Type15.Optional(searchPrefetchOptionsSchema)
-  },
-  {
-    additionalProperties: false,
-    description: "Local runtime controls for search."
-  }
-);
-function buildToolOptionsSchema(capability, providerSchema) {
-  const properties = {};
-  const runtimeSchema = getRuntimeOptionsSchema(capability);
-  if (runtimeSchema) {
-    properties.runtime = Type15.Optional(runtimeSchema);
-  }
-  if (providerSchema && Object.keys(providerSchema.properties).length > 0) {
-    properties.provider = Type15.Optional(providerSchema);
-  }
-  if (Object.keys(properties).length === 0) {
+function buildToolOptionsSchema(_capability, providerSchema) {
+  if (!providerSchema || Object.keys(providerSchema.properties).length === 0) {
     return void 0;
   }
-  return Type15.Object(properties, {
-    additionalProperties: false,
-    description: "Options for this tool call split into provider-facing settings and local runtime controls."
-  });
+  return closeObjectSchemas(providerSchema);
 }
-function getRuntimeOptionsSchema(capability) {
-  switch (capability) {
-    case "search":
-      return searchRuntimeOptionsSchema;
-    case "contents":
-    case "answer":
-      return runtimeOptionsSchema;
-    default:
-      return void 0;
+function closeObjectSchemas(schema) {
+  if (!isSchemaRecord(schema)) {
+    return schema;
   }
+  const properties = isSchemaRecord(schema.properties) ? Object.fromEntries(
+    Object.entries(schema.properties).map(([key, value]) => [
+      key,
+      closeObjectSchemas(value)
+    ])
+  ) : schema.properties;
+  const items = isSchemaRecord(schema.items) ? closeObjectSchemas(schema.items) : Array.isArray(schema.items) ? schema.items.map((item) => closeObjectSchemas(item)) : schema.items;
+  return {
+    ...schema,
+    ...properties ? { properties } : {},
+    ...items ? { items } : {},
+    ...mapSchemaArray(schema, "anyOf"),
+    ...mapSchemaArray(schema, "oneOf"),
+    ...mapSchemaArray(schema, "allOf"),
+    ...schema.type === "object" && isSchemaRecord(schema.properties) ? { additionalProperties: false } : {}
+  };
+}
+function mapSchemaArray(schema, key) {
+  const value = schema[key];
+  return Array.isArray(value) ? { [key]: value.map((entry) => closeObjectSchemas(entry)) } : {};
+}
+function isSchemaRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/prefetch-manager.ts
@@ -5212,19 +5927,16 @@ import { createHash } from "node:crypto";
 
 // src/provider-resolution.ts
 function supportsTool2(provider, tool) {
-  return typeof provider[tool] === "function";
+  return provider.capabilities[tool] !== void 0;
 }
 function resolveSearchProvider(config, cwd, explicit) {
   return resolveProviderForTool(config, cwd, "search", explicit);
 }
 function getEffectiveSharedSettings(config) {
-  return {
-    ...createDefaultExecutionSettings(),
-    ...config.settings ?? {}
-  };
+  return mergeExecutionSettings(createDefaultExecutionSettings(), config.settings) ?? createDefaultExecutionSettings();
 }
 function getEffectiveProviderConfig(config, providerId) {
-  const defaults = ADAPTERS_BY_ID[providerId].createTemplate();
+  const defaults = PROVIDERS[providerId].config.createTemplate();
   const overrides = config.providers?.[providerId] ?? {};
   const providerSettings = mergeExecutionSettings(
     defaults.settings,
@@ -5279,7 +5991,7 @@ function getMappedProviderIdForTool(config, tool) {
   return getMappedProviderForTool(config, tool);
 }
 function getProviderCapabilityStatus(config, cwd, providerId, tool) {
-  const provider = ADAPTERS_BY_ID[providerId];
+  const provider = PROVIDERS[providerId];
   return provider.getCapabilityStatus(
     getEffectiveProviderConfig(config, providerId),
     cwd,
@@ -5326,7 +6038,7 @@ function resolveProviderForTool(config, cwd, tool, explicit) {
       `No provider is configured for '${tool}'. Run /web-providers to configure tool mappings.`
     );
   }
-  const provider = ADAPTERS_BY_ID[providerId];
+  const provider = PROVIDERS[providerId];
   if (!supportsTool2(provider, tool)) {
     throw new Error(`Provider '${providerId}' does not support '${tool}'.`);
   }
@@ -5342,21 +6054,27 @@ function resolveProviderForTool(config, cwd, tool, explicit) {
 }
 
 // src/provider-runtime.ts
-async function executeProviderRequest(provider, config, request, options, context) {
+async function executeProviderRequest(provider, config, request, context) {
   return await executeProviderExecution(
     {
       capability: request.capability,
       providerLabel: provider.label,
       settings: config.settings,
-      execute: (executionContext) => executeProviderHandler(provider, config, request, executionContext)
+      execute: (executionContext) => executeProviderCapability(
+        provider,
+        request.capability,
+        providerInputFromRequest(request),
+        {
+          ...executionContext,
+          config
+        }
+      )
     },
-    options,
     context
   );
 }
-async function executeProviderExecution(execution, options, context) {
+async function executeProviderExecution(execution, context) {
   if (execution.capability === "research") {
-    rejectResearchExecutionControls(execution.providerLabel, options);
     const deadline = createResearchDeadlineSignal(
       context.signal,
       execution.providerLabel,
@@ -5379,7 +6097,7 @@ async function executeProviderExecution(execution, options, context) {
       deadline?.cleanup();
     }
   }
-  const requestPolicy = resolveExecutionPolicy(execution.settings, options);
+  const requestPolicy = resolveExecutionPolicy(execution.settings);
   try {
     return await runWithExecutionPolicy(
       `${execution.providerLabel} ${execution.capability} request`,
@@ -5396,65 +6114,36 @@ async function executeProviderExecution(execution, options, context) {
     );
   }
 }
-async function executeProviderHandler(provider, config, request, context) {
+function providerInputFromRequest(request) {
   switch (request.capability) {
-    case "search": {
-      if (!provider.search) {
-        throw unsupportedProviderTool(provider, request.capability);
-      }
-      return await provider.search(
-        request.query,
-        request.maxResults,
-        config,
-        context,
-        request.options
-      );
-    }
-    case "contents": {
-      if (!provider.contents) {
-        throw unsupportedProviderTool(provider, request.capability);
-      }
-      return await provider.contents(
-        request.urls,
-        config,
-        context,
-        request.options
-      );
-    }
-    case "answer": {
-      if (!provider.answer) {
-        throw unsupportedProviderTool(provider, request.capability);
-      }
-      return await provider.answer(
-        request.query,
-        config,
-        context,
-        request.options
-      );
-    }
-    case "research": {
-      if (!provider.research) {
-        throw unsupportedProviderTool(provider, request.capability);
-      }
-      return await provider.research(
-        request.input,
-        config,
-        context,
-        request.options
-      );
-    }
+    case "search":
+      return {
+        query: request.query,
+        maxResults: request.maxResults,
+        options: request.options
+      };
+    case "contents":
+      return {
+        urls: request.urls,
+        options: request.options
+      };
+    case "answer":
+      return {
+        query: request.query,
+        options: request.options
+      };
+    case "research":
+      return {
+        input: request.input,
+        options: request.options
+      };
   }
 }
-function unsupportedProviderTool(provider, tool) {
-  return new Error(`Provider '${provider.id}' does not support '${tool}'.`);
-}
-function resolveExecutionPolicy(defaults, options) {
-  validateRuntimeOptions(options);
-  const localOptions = parseLocalExecutionOptions(options);
+function resolveExecutionPolicy(defaults) {
   return {
-    requestTimeoutMs: localOptions.requestTimeoutMs ?? defaults?.requestTimeoutMs,
-    retryCount: localOptions.retryCount ?? defaults?.retryCount ?? 0,
-    retryDelayMs: localOptions.retryDelayMs ?? defaults?.retryDelayMs ?? 2e3
+    requestTimeoutMs: defaults?.requestTimeoutMs,
+    retryCount: defaults?.retryCount ?? 0,
+    retryDelayMs: defaults?.retryDelayMs ?? 2e3
   };
 }
 function createResearchDeadlineSignal(signal, providerLabel, timeoutMs) {
@@ -5522,26 +6211,6 @@ async function withAbortSignal(promise, signal) {
     );
   });
 }
-function rejectResearchExecutionControls(providerLabel, options) {
-  if (!options || Object.keys(options).length === 0) {
-    return;
-  }
-  throw new Error(`${providerLabel} research does not accept options.runtime.`);
-}
-function validateRuntimeOptions(options) {
-  if (!options) {
-    return;
-  }
-  const unsupportedKeys = Object.keys(options).filter(
-    (key) => key !== "requestTimeoutMs" && key !== "retryCount" && key !== "retryDelayMs"
-  );
-  if (unsupportedKeys.length === 0) {
-    return;
-  }
-  throw new Error(
-    `Unsupported runtime options: ${unsupportedKeys.join(", ")}.`
-  );
-}
 
 // src/prefetch-manager.ts
 var CONTENT_CACHE_VERSION = 2;
@@ -5596,7 +6265,6 @@ async function resolveContentsFromStore({
   config,
   cwd,
   options,
-  runtimeOptions,
   signal,
   onProgress
 }) {
@@ -5608,7 +6276,6 @@ async function resolveContentsFromStore({
       config,
       cwd,
       options,
-      runtimeOptions,
       signal,
       onProgress
     });
@@ -5619,28 +6286,10 @@ async function resolveContentsFromStore({
     config,
     cwd,
     options,
-    runtimeOptions,
     signal,
     onProgress
   });
 }
-function parseSearchContentsPrefetchOptions(options) {
-  const raw = options?.prefetch;
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!isJsonObject3(raw)) {
-    throw new Error("prefetch must be an object.");
-  }
-  const maxUrls = parseOptionalPositiveInteger2(raw.maxUrls, "maxUrls");
-  const provider = parseOptionalProviderId(raw.provider);
-  const ttlMs = parseOptionalPositiveInteger2(raw.ttlMs, "ttlMs");
-  return {
-    maxUrls,
-    provider,
-    ttlMs
-  };
-}
 function mergeSearchContentsPrefetchOptions(defaults, overrides) {
   if (!defaults && !overrides) {
     return void 0;
@@ -5651,13 +6300,6 @@ function mergeSearchContentsPrefetchOptions(defaults, overrides) {
     ttlMs: overrides?.ttlMs !== void 0 ? overrides.ttlMs : defaults?.ttlMs
   };
 }
-function stripSearchContentsPrefetchOptions(options) {
-  if (!options) {
-    return void 0;
-  }
-  const { prefetch: _prefetch, ...rest } = options;
-  return Object.keys(rest).length > 0 ? rest : void 0;
-}
 function resetContentStore() {
   contentStoreGeneration += 1;
   contentCache.clear();
@@ -5669,7 +6311,6 @@ async function resolvePerUrlContents({
   config,
   cwd,
   options,
-  runtimeOptions,
   signal,
   onProgress
 }) {
@@ -5681,7 +6322,6 @@ async function resolvePerUrlContents({
         config,
         cwd,
         options,
-        runtimeOptions,
         signal,
         onProgress
       })
@@ -5728,7 +6368,6 @@ async function fetchBatchContents({
   config,
   cwd,
   options,
-  runtimeOptions,
   signal,
   onProgress,
   ttlMs = DEFAULT_CONTENT_TTL_MS,
@@ -5744,7 +6383,6 @@ async function fetchBatchContents({
     config,
     cwd,
     options,
-    runtimeOptions,
     signal,
     onProgress
   });
@@ -5775,7 +6413,6 @@ async function ensureContentsStored({
   config,
   cwd,
   options,
-  runtimeOptions,
   signal,
   onProgress,
   ttlMs = DEFAULT_CONTENT_TTL_MS,
@@ -5800,7 +6437,6 @@ async function ensureContentsStored({
         config,
         cwd,
         options,
-        runtimeOptions,
         signal,
         onProgress
       });
@@ -5831,11 +6467,10 @@ async function fetchContentsViaProvider({
   config,
   cwd,
   options,
-  runtimeOptions,
   signal,
   onProgress
 }) {
-  const provider = ADAPTERS_BY_ID[providerId];
+  const provider = PROVIDERS_BY_ID[providerId];
   const providerConfig = getEffectiveProviderConfig(config, providerId);
   onProgress?.(
     `Fetching contents via ${provider.label} for ${urls.length} URL(s)`
@@ -5848,7 +6483,6 @@ async function fetchContentsViaProvider({
       urls,
       options
     },
-    runtimeOptions,
     {
       cwd,
       signal,
@@ -5948,7 +6582,7 @@ function resolveContentsProvider(config, cwd, explicitProvider) {
   if (!explicitProvider) {
     return void 0;
   }
-  const provider = ADAPTERS_BY_ID[explicitProvider];
+  const provider = PROVIDERS_BY_ID[explicitProvider];
   if (!supportsTool(explicitProvider, "contents")) {
     return void 0;
   }
@@ -6018,27 +6652,6 @@ function formatUnknownError(error) {
 function isJsonObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseOptionalPositiveInteger2(value, field) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (!Number.isInteger(value) || Number(value) <= 0) {
-    throw new Error(`prefetch.${field} must be a positive integer.`);
-  }
-  return Number(value);
-}
-function parseOptionalProviderId(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (value === null) {
-    return null;
-  }
-  if (isProviderId(value)) {
-    return value;
-  }
-  throw new Error("prefetch.provider must be a valid provider id or null.");
-}
 function isProviderId(value) {
   return typeof value === "string" && PROVIDER_IDS.includes(value);
 }
@@ -6050,7 +6663,7 @@ function isContentsAnswer(value) {
 }
 
 // src/provider-config-manifests.ts
-var PROVIDER_CONFIG_MANIFESTS = {
+var PROVIDER_SETTINGS = {
   claude: {
     settings: [
       stringSetting({
@@ -6475,6 +7088,9 @@ var PROVIDER_CONFIG_MANIFESTS = {
   linkup: {
     settings: [apiKeySetting(), baseUrlSetting()]
   },
+  ollama: {
+    settings: [apiKeySetting(), baseUrlSetting()]
+  },
   openai: {
     settings: [
       apiKeySetting(),
@@ -6711,9 +7327,20 @@ var PROVIDER_CONFIG_MANIFESTS = {
     ]
   }
 };
+var PROVIDER_CONFIG_MANIFESTS = deriveProviderConfigManifests();
 function getProviderConfigManifest(providerId) {
   return PROVIDER_CONFIG_MANIFESTS[providerId];
 }
+function deriveProviderConfigManifests() {
+  return Object.fromEntries(
+    Object.keys(PROVIDERS).map((providerId) => [
+      providerId,
+      {
+        settings: PROVIDER_SETTINGS[providerId]?.settings ?? []
+      }
+    ])
+  );
+}
 function stringSetting(setting) {
   return {
     kind: "text",
@@ -7084,10 +7711,6 @@ function webProvidersExtension(pi) {
       )
     );
   };
-  registerManagedTools(pi, {
-    activeWebResearchRequests,
-    updateWebResearchWidget
-  });
   if ("registerMessageRenderer" in pi) {
     pi.registerMessageRenderer(
       WEB_RESEARCH_RESULT_MESSAGE_TYPE,
@@ -7134,29 +7757,21 @@ function webProvidersExtension(pi) {
     stopWebResearchWidgetTimer();
     latestWidgetContext?.ui.setWidget(WEB_RESEARCH_WIDGET_KEY, void 0);
   });
-  registerManagedTools(pi, {
-    activeWebResearchRequests,
-    updateWebResearchWidget
-  });
 }
 function registerManagedTools(pi, webResearchLifecycle, providerIdsByCapability = {}) {
-  registerWebSearchTool(pi, providerIdsByCapability.search ?? PROVIDER_IDS);
-  registerWebContentsTool(
-    pi,
-    providerIdsByCapability.contents ?? getProviderIdsForCapability("contents")
-  );
-  registerWebAnswerTool(
-    pi,
-    providerIdsByCapability.answer ?? getProviderIdsForCapability("answer")
-  );
+  registerWebSearchTool(pi, providerIdsByCapability.search ?? []);
+  registerWebContentsTool(pi, providerIdsByCapability.contents ?? []);
+  registerWebAnswerTool(pi, providerIdsByCapability.answer ?? []);
   registerWebResearchTool(
     pi,
     webResearchLifecycle,
-    providerIdsByCapability.research ?? getProviderIdsForCapability("research")
+    providerIdsByCapability.research ?? []
   );
 }
 function registerWebSearchTool(pi, providerIds) {
-  const selectedProviderId = providerIds.length === 1 ? providerIds[0] : void 0;
+  if (providerIds.length !== 1) return;
+  const selectedProviderId = providerIds[0];
+  const maxAllowedResults = getSearchMaxResultsLimit(selectedProviderId);
   pi.registerTool({
     name: "web_search",
     label: "Web Search",
@@ -7164,24 +7779,27 @@ function registerWebSearchTool(pi, providerIds) {
     promptGuidelines: [
       "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: Type16.Object({
-      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: Type16.Optional(
-        Type16.Integer({
-          minimum: 1,
-          maximum: MAX_ALLOWED_RESULTS,
-          description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
-        })
-      ),
-      ...optionalField(
-        "options",
-        buildStructuredOptionsSchema("search", selectedProviderId)
-      )
-    }),
+    parameters: Type15.Object(
+      {
+        queries: Type15.Array(Type15.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({
+            minimum: 1,
+            maximum: maxAllowedResults,
+            description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
+          })
+        ),
+        ...optionalField(
+          "options",
+          buildStructuredOptionsSchema("search", selectedProviderId)
+        )
+      },
+      { additionalProperties: false }
+    ),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       return executeSearchTool({
         config: await loadConfig(),
@@ -7214,22 +7832,25 @@ function registerWebSearchTool(pi, providerIds) {
   });
 }
 function registerWebContentsTool(pi, providerIds) {
-  if (providerIds.length === 0) return;
-  const selectedProviderId = providerIds.length === 1 ? providerIds[0] : void 0;
+  if (providerIds.length !== 1) return;
+  const selectedProviderId = providerIds[0];
   pi.registerTool({
     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: Type16.Object({
-      urls: Type16.Array(Type16.String({ minLength: 1 }), {
-        minItems: 1,
-        description: "One or more URLs to extract"
-      }),
-      ...optionalField(
-        "options",
-        buildStructuredOptionsSchema("contents", selectedProviderId)
-      )
-    }),
+    parameters: Type15.Object(
+      {
+        urls: Type15.Array(Type15.String({ minLength: 1 }), {
+          minItems: 1,
+          description: "One or more URLs to extract"
+        }),
+        ...optionalField(
+          "options",
+          buildStructuredOptionsSchema("contents", selectedProviderId)
+        )
+      },
+      { additionalProperties: false }
+    ),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       return executeProviderTool({
         config: await loadConfig(),
@@ -7265,24 +7886,29 @@ function registerWebContentsTool(pi, providerIds) {
   });
 }
 function registerWebAnswerTool(pi, providerIds) {
-  if (providerIds.length === 0) return;
-  const selectedProviderId = providerIds.length === 1 ? providerIds[0] : void 0;
+  if (providerIds.length !== 1) return;
+  const selectedProviderId = providerIds[0];
   pi.registerTool({
     name: "web_answer",
     label: "Web Answer",
-    description: `Answer one or more questions using web-grounded evidence (up to ${MAX_SEARCH_QUERIES} per call).`,
-    parameters: Type16.Object({
-      queries: Type16.Array(Type16.String({ minLength: 1 }), {
-        minItems: 1,
-        maxItems: MAX_SEARCH_QUERIES,
-        description: `One or more questions to answer in one call (max ${MAX_SEARCH_QUERIES})`
-      }),
-      ...optionalField(
-        "options",
-        buildStructuredOptionsSchema("answer", selectedProviderId)
-      )
-    }),
+    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(
+      {
+        queries: Type15.Array(Type15.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})`
+        }),
+        ...optionalField(
+          "options",
+          buildStructuredOptionsSchema("answer", selectedProviderId)
+        )
+      },
+      { additionalProperties: false }
+    ),
     promptGuidelines: [
+      "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) {
@@ -7320,19 +7946,22 @@ function registerWebAnswerTool(pi, providerIds) {
   });
 }
 function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
-  if (providerIds.length === 0) return;
-  const selectedProviderId = providerIds.length === 1 ? providerIds[0] : void 0;
+  if (providerIds.length !== 1) return;
+  const selectedProviderId = providerIds[0];
   pi.registerTool({
     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: Type16.Object({
-      input: Type16.String({ description: "Research brief or question" }),
-      ...optionalField(
-        "options",
-        buildStructuredOptionsSchema("research", selectedProviderId)
-      )
-    }),
+    parameters: Type15.Object(
+      {
+        input: Type15.String({ description: "Research brief or question" }),
+        ...optionalField(
+          "options",
+          buildStructuredOptionsSchema("research", selectedProviderId)
+        )
+      },
+      { additionalProperties: false }
+    ),
     promptGuidelines: [
       "Use this tool for deep investigations that can finish asynchronously.",
       "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."
@@ -7459,10 +8088,9 @@ async function syncManagedToolAvailability(pi, nextActiveTools) {
     pi.setActiveTools(Array.from(nextActiveTools));
   }
 }
-function getProviderIdsForCapability(capability) {
-  return ADAPTERS.filter((provider) => supportsTool2(provider, capability)).map(
-    (provider) => provider.id
-  );
+function getSearchMaxResultsLimit(providerId) {
+  const capabilities = PROVIDERS_BY_ID[providerId].capabilities;
+  return capabilities.search?.limits?.maxResults ?? MAX_ALLOWED_RESULTS;
 }
 function optionalField(name, schema) {
   return schema ? { [name]: schema } : {};
@@ -7470,14 +8098,14 @@ function optionalField(name, schema) {
 function buildStructuredOptionsSchema(capability, providerId) {
   const providerSchema = resolveProviderOptionsSchema(capability, providerId);
   const schema = buildToolOptionsSchema(capability, providerSchema);
-  return schema ? Type16.Optional(schema) : void 0;
+  return schema ? Type15.Optional(schema) : void 0;
 }
 function resolveProviderOptionsSchema(capability, providerId) {
   if (!providerId) {
     return void 0;
   }
-  const adapter = ADAPTERS_BY_ID[providerId];
-  return adapter.getToolOptionsSchema?.(capability);
+  const provider = PROVIDERS_BY_ID[providerId];
+  return provider.capabilities[capability]?.options;
 }
 async function executeSearchTool({
   config,
@@ -7489,8 +8117,7 @@ async function executeSearchTool({
     ctx: { cwd: context.cwd },
     signal: context.signal,
     progress: context.progress,
-    providerOptions: request.options?.provider,
-    runtimeOptions: request.options?.runtime,
+    providerOptions: request.options,
     maxResults: request.maxResults,
     queries: request.queries
   });
@@ -7502,7 +8129,6 @@ async function executeSearchToolInternal({
   signal,
   progress,
   providerOptions,
-  runtimeOptions,
   maxResults,
   queries,
   executionOverrides
@@ -7512,7 +8138,7 @@ async function executeSearchToolInternal({
   const providerConfig = getEffectiveProviderConfig(config, provider.id);
   const prefetchOptions = mergeSearchContentsPrefetchOptions(
     getSearchPrefetchDefaults(config),
-    parseSearchContentsPrefetchOptions(runtimeOptions)
+    void 0
   );
   const searchQueries = resolveSearchQueries(queries);
   if (executionOverrides !== void 0 && executionOverrides.length !== searchQueries.length) {
@@ -7535,7 +8161,10 @@ async function executeSearchToolInternal({
     cwd: ctx.cwd,
     signal: signal ?? void 0
   };
-  const clampedMaxResults = clampResults(maxResults);
+  const clampedMaxResults = clampResults(
+    maxResults,
+    getSearchMaxResultsLimit(provider.id)
+  );
   let outcomes;
   try {
     batchProgress?.start();
@@ -7547,7 +8176,6 @@ async function executeSearchToolInternal({
           query: searchQuery,
           maxResults: clampedMaxResults,
           options: providerOptions,
-          runtimeOptions,
           providerContext,
           onProgress: searchQueries.length > 1 ? void 0 : progressReporter.report,
           executionOverride: executionOverrides?.[index]
@@ -7597,7 +8225,6 @@ async function executeRawProviderRequest({
   ctx,
   signal,
   options,
-  runtimeOptions,
   maxResults,
   urls,
   query: query2,
@@ -7610,9 +8237,11 @@ async function executeRawProviderRequest({
       provider: provider2,
       providerConfig: providerConfig2,
       query: query2 ?? "",
-      maxResults: clampResults(maxResults),
+      maxResults: clampResults(
+        maxResults,
+        getSearchMaxResultsLimit(provider2.id)
+      ),
       options,
-      runtimeOptions,
       providerContext: {
         cwd: ctx.cwd,
         signal: signal ?? void 0
@@ -7635,7 +8264,6 @@ async function executeRawProviderRequest({
       ctx,
       signal,
       options,
-      runtimeOptions,
       urls
     });
   }
@@ -7648,7 +8276,6 @@ async function executeRawProviderRequest({
       ctx,
       signal,
       options,
-      runtimeOptions,
       query: query2
     });
   }
@@ -7660,7 +8287,6 @@ async function executeRawProviderRequest({
     ctx,
     signal,
     options,
-    runtimeOptions,
     input
   });
 }
@@ -7682,7 +8308,6 @@ async function executeSingleSearchQuery({
   query: query2,
   maxResults,
   options,
-  runtimeOptions,
   providerContext,
   onProgress,
   executionOverride
@@ -7694,23 +8319,13 @@ async function executeSingleSearchQuery({
     options
   };
   onProgress?.(`Searching via ${provider.label}: ${query2}`);
-  const result = executionOverride ? await executeProviderExecution(
-    executionOverride,
-    stripSearchContentsPrefetchOptions(runtimeOptions),
-    {
-      ...providerContext,
-      onProgress
-    }
-  ) : await executeProviderRequest(
-    provider,
-    providerConfig,
-    request,
-    stripSearchContentsPrefetchOptions(runtimeOptions),
-    {
-      ...providerContext,
-      onProgress
-    }
-  );
+  const result = executionOverride ? await executeProviderExecution(executionOverride, {
+    ...providerContext,
+    onProgress
+  }) : await executeProviderRequest(provider, providerConfig, request, {
+    ...providerContext,
+    onProgress
+  });
   if (!isSearchResponse(result)) {
     throw new Error(`${provider.label} search returned an invalid result.`);
   }
@@ -7726,8 +8341,7 @@ async function executeAnswerTool({
     ctx: { cwd: context.cwd },
     signal: context.signal,
     progress: context.progress,
-    providerOptions: request.options?.provider,
-    runtimeOptions: request.options?.runtime,
+    providerOptions: request.options,
     queries: request.queries
   });
 }
@@ -7738,7 +8352,6 @@ async function executeAnswerToolInternal({
   signal,
   progress,
   providerOptions,
-  runtimeOptions,
   queries,
   executionOverrides
 }) {
@@ -7779,7 +8392,6 @@ async function executeAnswerToolInternal({
           ctx,
           signal,
           options: providerOptions,
-          runtimeOptions,
           query: answerQuery,
           onProgress: answerQueries.length > 1 ? void 0 : progressReporter.report,
           executionOverride: executionOverrides?.[index]
@@ -7861,7 +8473,6 @@ async function executeProviderOperation({
   ctx,
   signal,
   options,
-  runtimeOptions,
   urls,
   query: query2,
   input,
@@ -7881,7 +8492,6 @@ async function executeProviderOperation({
       config,
       cwd: ctx.cwd,
       options,
-      runtimeOptions,
       signal: signal ?? void 0,
       onProgress
     });
@@ -7895,21 +8505,15 @@ async function executeProviderOperation({
   } else if (capability === "research") {
     onProgress?.(`Researching via ${provider.label}`);
   }
-  const result = executionOverride ? await executeProviderExecution(executionOverride, runtimeOptions, {
+  const result = executionOverride ? await executeProviderExecution(executionOverride, {
     cwd: ctx.cwd,
     signal: signal ?? void 0,
     onProgress
-  }) : await executeProviderRequest(
-    provider,
-    providerConfig,
-    request,
-    runtimeOptions,
-    {
-      cwd: ctx.cwd,
-      signal: signal ?? void 0,
-      onProgress
-    }
-  );
+  }) : await executeProviderRequest(provider, providerConfig, request, {
+    cwd: ctx.cwd,
+    signal: signal ?? void 0,
+    onProgress
+  });
   if (isSearchResponse(result)) {
     throw new Error(
       `${provider.label} ${capability} returned an invalid result.`
@@ -7928,8 +8532,7 @@ async function executeProviderTool({
     ctx: { cwd: context.cwd },
     signal: context.signal,
     progress: context.progress,
-    providerOptions: request.options?.provider,
-    runtimeOptions: request.options?.runtime,
+    providerOptions: request.options,
     urls: request.urls,
     query: request.query,
     input: request.input
@@ -7943,7 +8546,6 @@ async function executeProviderToolInternal({
   signal,
   progress,
   providerOptions,
-  runtimeOptions,
   urls,
   query: query2,
   input,
@@ -7973,7 +8575,6 @@ async function executeProviderToolInternal({
         ctx,
         signal,
         options: providerOptions,
-        runtimeOptions,
         urls: urls ?? [],
         progressReport: progressReporter.report,
         executionOverrides
@@ -7985,7 +8586,6 @@ async function executeProviderToolInternal({
         ctx,
         signal,
         options: providerOptions,
-        runtimeOptions,
         urls,
         onProgress: progressReporter.report,
         executionOverride
@@ -7999,7 +8599,6 @@ async function executeProviderToolInternal({
         ctx,
         signal,
         options: providerOptions,
-        runtimeOptions,
         query: query2,
         input,
         onProgress: progressReporter.report,
@@ -8037,7 +8636,7 @@ async function dispatchWebResearch({
     updateWebResearchWidget,
     config,
     ctx: context,
-    providerOptions: request.options?.provider,
+    providerOptions: request.options,
     input: request.input
   });
 }
@@ -8181,7 +8780,7 @@ function slugifyWebResearchInput(input) {
 function buildWebResearchWidgetLines(requests, theme, now = Date.now()) {
   const lines = [theme.fg("accent", "Research jobs:")];
   for (const request of requests.slice().sort((left, right) => left.startedAt.localeCompare(right.startedAt)).slice(0, 3)) {
-    const providerLabel = ADAPTERS_BY_ID[request.provider]?.label ?? request.provider;
+    const providerLabel = PROVIDERS_BY_ID[request.provider]?.label ?? request.provider;
     const elapsed = formatCompactElapsed(now - Date.parse(request.startedAt));
     const icon = getWebResearchWidgetIcon(request, now);
     lines.push(
@@ -8257,7 +8856,7 @@ async function writeWebResearchArtifact(result, reportText) {
   );
 }
 function formatWebResearchArtifact(result, reportText) {
-  const providerLabel = ADAPTERS_BY_ID[result.provider]?.label ?? result.provider;
+  const providerLabel = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
   const lines = [
     "# Web research report",
     "",
@@ -8305,7 +8904,6 @@ async function executeBatchedContentsTool({
   ctx,
   signal,
   options,
-  runtimeOptions,
   urls,
   progressReport,
   executionOverrides
@@ -8332,7 +8930,6 @@ async function executeBatchedContentsTool({
         ctx,
         signal,
         options,
-        runtimeOptions,
         urls: [url],
         onProgress: void 0,
         executionOverride: executionOverrides?.[index]
@@ -8455,7 +9052,7 @@ function createToolProgressReporter(capability, providerId, progress) {
       if (Date.now() - lastUpdateAt < RESEARCH_HEARTBEAT_MS) {
         return;
       }
-      const providerLabel = ADAPTERS_BY_ID[providerId]?.label ?? providerId;
+      const providerLabel = PROVIDERS_BY_ID[providerId]?.label ?? providerId;
       const elapsed = formatElapsed(Date.now() - startedAt);
       emit(`Researching via ${providerLabel} (${elapsed} elapsed)`);
       lastUpdateAt = Date.now();
@@ -8558,7 +9155,7 @@ function renderWebResearchDispatchResult(result, expanded, theme) {
   if (expanded) {
     return renderBlockText(details?.input ?? text, theme, "toolOutput");
   }
-  const summary = details ? `Started web research via ${ADAPTERS_BY_ID[details.provider]?.label ?? details.provider}` : text;
+  const summary = details ? `Started web research via ${PROVIDERS_BY_ID[details.provider]?.label ?? details.provider}` : text;
   let summaryText = theme.fg("success", summary);
   summaryText += theme.fg("muted", ` (${getExpandHint()})`);
   return new Text(summaryText, 0, 0);
@@ -8581,7 +9178,7 @@ function renderWebResearchResultMessage(message, { expanded }, theme) {
   return box;
 }
 function buildWebResearchResultSummaryLines(result, theme) {
-  const providerLabel = ADAPTERS_BY_ID[result.provider]?.label ?? result.provider;
+  const providerLabel = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
   const statusLine = result.status === "completed" ? `Web research completed via ${providerLabel}` : `Web research failed via ${providerLabel}`;
   const lines = [
     theme.fg(result.status === "completed" ? "success" : "error", statusLine)
@@ -8621,7 +9218,7 @@ function renderProviderToolResult(result, expanded, isPartial, failureText, them
 }
 function renderCollapsedProviderToolSummary(details, text) {
   if (details?.tool === "web_answer" && typeof details.queryCount === "number" && details.queryCount > 1) {
-    const providerLabel = ADAPTERS_BY_ID[details.provider]?.label ?? details.provider;
+    const providerLabel = PROVIDERS_BY_ID[details.provider]?.label ?? details.provider;
     const failureSuffix = details.failedQueryCount && details.failedQueryCount > 0 ? `, ${details.failedQueryCount} failed` : "";
     return `${details.queryCount} questions via ${providerLabel}${failureSuffix}`;
   }
@@ -8695,12 +9292,12 @@ function renderSelectedEntryDescription(width, theme, entry) {
 }
 function formatProviderCapabilityChecks(providerId, theme) {
   return ["search", "contents", "answer", "research"].map(
-    (tool) => supportsTool2(ADAPTERS_BY_ID[providerId], tool) ? theme.fg("success", "\u2714") : " "
+    (tool) => supportsTool2(PROVIDERS_BY_ID[providerId], tool) ? theme.fg("success", "\u2714") : " "
   ).join(" ");
 }
 function resolveProviderSelectionValue(providerIds, value) {
   return providerIds.find(
-    (candidate) => ADAPTERS_BY_ID[candidate].label === value
+    (candidate) => PROVIDERS_BY_ID[candidate].label === value
   );
 }
 function getReadyCompatibleProvidersForTool(config, cwd, toolId) {
@@ -8714,7 +9311,7 @@ function getReadyCompatibleProvidersForTool(config, cwd, toolId) {
 }
 function sortProviderIdsForSettings(providerIds) {
   const displayOrder = new Map(
-    ADAPTERS.map((provider, index) => [provider.id, index])
+    PROVIDER_LIST.map((provider, index) => [provider.id, index])
   );
   return [...providerIds].sort(
     (left, right) => (displayOrder.get(left) ?? Number.MAX_SAFE_INTEGER) - (displayOrder.get(right) ?? Number.MAX_SAFE_INTEGER)
@@ -8819,9 +9416,13 @@ var WebProvidersSettingsView = class {
     this.activeProvider = initialProvider;
     this.selection.provider = Math.max(
       0,
-      ADAPTERS.findIndex((provider) => provider.id === initialProvider)
+      PROVIDER_LIST.findIndex((provider) => provider.id === initialProvider)
     );
   }
+  tui;
+  theme;
+  done;
+  ctx;
   config;
   activeProvider;
   activeSection = "tools";
@@ -8899,7 +9500,7 @@ var WebProvidersSettingsView = class {
     this.tui.requestRender();
   }
   buildProviderSectionItems() {
-    return ADAPTERS.map((provider) => {
+    return PROVIDER_LIST.map((provider) => {
       const setupState = getProviderSetupState(this.config, provider.id);
       const statusSummary = getProviderReadinessSummary(
         this.config,
@@ -8924,9 +9525,9 @@ var WebProvidersSettingsView = class {
         toolId
       );
       const mappedProviderId = getMappedProviderIdForTool(this.config, toolId);
-      const currentValue = mappedProviderId && readyCompatibleProviders.includes(mappedProviderId) ? ADAPTERS_BY_ID[mappedProviderId].label : "off";
+      const currentValue = mappedProviderId && readyCompatibleProviders.includes(mappedProviderId) ? PROVIDERS_BY_ID[mappedProviderId].label : "off";
       const compatibleLabels = readyCompatibleProviders.map(
-        (providerId) => ADAPTERS_BY_ID[providerId].label
+        (providerId) => PROVIDERS_BY_ID[providerId].label
       );
       return {
         id: `tool:${toolId}`,
@@ -9007,7 +9608,7 @@ var WebProvidersSettingsView = class {
     if (this.activeSection !== "provider") {
       return;
     }
-    const provider = ADAPTERS[this.selection.provider];
+    const provider = PROVIDER_LIST[this.selection.provider];
     if (!provider) {
       return;
     }
@@ -9169,6 +9770,13 @@ var ToolSettingsSubmenu = class {
     this.persist = persist;
     this.done = done;
   }
+  tui;
+  theme;
+  toolId;
+  cwd;
+  getConfig;
+  persist;
+  done;
   selection = 0;
   submenu;
   render(width) {
@@ -9237,9 +9845,11 @@ var ToolSettingsSubmenu = class {
     );
     const providerValues = [
       "off",
-      ...readyProviderIds.map((providerId) => ADAPTERS_BY_ID[providerId].label)
+      ...readyProviderIds.map(
+        (providerId) => PROVIDERS_BY_ID[providerId].label
+      )
     ];
-    const currentProviderValue = mappedProviderId && readyProviderIds.includes(mappedProviderId) ? ADAPTERS_BY_ID[mappedProviderId].label : "off";
+    const currentProviderValue = mappedProviderId && readyProviderIds.includes(mappedProviderId) ? PROVIDERS_BY_ID[mappedProviderId].label : "off";
     const entries = [
       {
         id: "provider",
@@ -9261,10 +9871,10 @@ var ToolSettingsSubmenu = class {
       const prefetchValues = [
         "off",
         ...prefetchProviderIds.map(
-          (providerId) => ADAPTERS_BY_ID[providerId].label
+          (providerId) => PROVIDERS_BY_ID[providerId].label
         )
       ];
-      const currentPrefetchProviderValue = prefetch?.provider && prefetchProviderIds.includes(prefetch.provider) ? ADAPTERS_BY_ID[prefetch.provider].label : "off";
+      const currentPrefetchProviderValue = prefetch?.provider && prefetchProviderIds.includes(prefetch.provider) ? PROVIDERS_BY_ID[prefetch.provider].label : "off";
       entries.push(
         {
           id: "prefetchProvider",
@@ -9394,13 +10004,19 @@ var ProviderSettingsSubmenu = class {
     this.persist = persist;
     this.done = done;
   }
+  tui;
+  theme;
+  providerId;
+  getProviderConfig;
+  persist;
+  done;
   selection = 0;
   submenu;
   render(width) {
     if (this.submenu) {
       return this.submenu.render(width);
     }
-    const provider = ADAPTERS_BY_ID[this.providerId];
+    const provider = PROVIDERS_BY_ID[this.providerId];
     const providerConfig = this.getProviderConfig();
     const entries = this.getEntries();
     const lines = [
@@ -9568,6 +10184,10 @@ var TextValueSubmenu = class {
       this.done(text.trim());
     };
   }
+  theme;
+  title;
+  help;
+  done;
   editor;
   render(width) {
     return [
@@ -9613,7 +10233,7 @@ function didContentsCacheInputsChange(previous, next) {
 }
 function getContentsCacheInputs(config) {
   const providers = {};
-  for (const provider of ADAPTERS) {
+  for (const provider of PROVIDER_LIST) {
     if (!supportsTool2(provider, "contents")) {
       continue;
     }
@@ -9655,8 +10275,8 @@ function getProviderReadinessSummary(config, cwd, providerId) {
   return formatProviderCapabilityStatus(statuses[0], providerId, tools[0]);
 }
 function getProviderReadinessSummaryForProviderConfig(providerId, providerConfig) {
-  const status = ADAPTERS_BY_ID[providerId].getCapabilityStatus(
-    providerConfig ?? ADAPTERS_BY_ID[providerId].createTemplate(),
+  const status = PROVIDERS_BY_ID[providerId].getCapabilityStatus(
+    providerConfig ?? PROVIDERS_BY_ID[providerId].config.createTemplate(),
     ""
   );
   return formatProviderCapabilityStatus(status, providerId);
@@ -9670,9 +10290,9 @@ function summarizeStringValue(value, secret) {
   }
   return truncateInline(value, 40);
 }
-function clampResults(value) {
-  if (value === void 0) return DEFAULT_MAX_RESULTS;
-  return Math.min(Math.max(Math.trunc(value), 1), MAX_ALLOWED_RESULTS);
+function clampResults(value, maximum = MAX_ALLOWED_RESULTS) {
+  if (value === void 0) return Math.min(DEFAULT_MAX_RESULTS, maximum);
+  return Math.min(Math.max(Math.trunc(value), 1), maximum);
 }
 function resolveSearchQueries(queries) {
   if (queries.length === 0) {
@@ -9789,7 +10409,7 @@ function renderCollapsedSearchSummary(details, text, theme) {
   const queryCount = typeof details?.queryCount === "number" ? details.queryCount : inferSearchQueryCount(text);
   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" ? ADAPTERS_BY_ID[details.provider]?.label ?? details.provider : void 0;
+  const providerLabel = typeof details?.provider === "string" ? PROVIDERS_BY_ID[details.provider]?.label ?? details.provider : void 0;
   let base = buildSearchSummaryText({
     queryCount,
     resultCount
@@ -9839,7 +10459,7 @@ function inferSearchFailureCount(text) {
   return failureMatches?.length;
 }
 function appendProviderSummary(summary, provider) {
-  const providerLabel = ADAPTERS_BY_ID[provider]?.label ?? provider;
+  const providerLabel = PROVIDERS_BY_ID[provider]?.label ?? provider;
   const providerSuffix = `via ${providerLabel}`;
   return summary.toLowerCase().includes(providerSuffix.toLowerCase()) ? summary : `${summary} ${providerSuffix}`;
 }
@@ -9969,7 +10589,6 @@ var __test__ = {
     signal,
     onUpdate,
     options,
-    runtimeOptions,
     queries,
     executionOverrides
   }) => executeAnswerToolInternal({
@@ -9979,7 +10598,6 @@ var __test__ = {
     signal,
     progress: createProgressEmitter(onUpdate),
     providerOptions: options,
-    runtimeOptions,
     queries,
     executionOverrides
   }),
@@ -9992,7 +10610,6 @@ var __test__ = {
     signal,
     onUpdate,
     options,
-    runtimeOptions,
     urls,
     query: query2,
     input,
@@ -10006,7 +10623,6 @@ var __test__ = {
     signal,
     progress: createProgressEmitter(onUpdate),
     providerOptions: options,
-    runtimeOptions,
     urls,
     query: query2,
     input,
@@ -10020,7 +10636,6 @@ var __test__ = {
     signal,
     onUpdate,
     options,
-    runtimeOptions,
     maxResults,
     queries,
     executionOverrides
@@ -10031,7 +10646,6 @@ var __test__ = {
     signal,
     progress: createProgressEmitter(onUpdate),
     providerOptions: options,
-    runtimeOptions,
     maxResults,
     queries,
     executionOverrides