pi-web-providers 2.2.0 → 2.4.0

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   visibleWidth,
   wrapTextWithAnsi
 } from "@mariozechner/pi-tui";
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type16 } from "@sinclair/typebox";
 
 // src/config.ts
 import { execSync } from "node:child_process";
@@ -41,8 +41,10 @@ var PROVIDER_TOOLS_BY_ID = {
   firecrawl: ["search", "contents"],
   gemini: ["search", "answer", "research"],
   linkup: ["search", "contents"],
-  perplexity: ["search", "answer", "research"],
+  openai: ["search", "answer", "research"],
   parallel: ["search", "contents"],
+  perplexity: ["search", "answer", "research"],
+  serper: ["search"],
   tavily: ["search", "contents"],
   valyu: ["search", "contents", "answer", "research"]
 };
@@ -86,8 +88,10 @@ var PROVIDER_IDS = [
   "firecrawl",
   "gemini",
   "linkup",
-  "perplexity",
+  "openai",
   "parallel",
+  "perplexity",
+  "serper",
   "tavily",
   "valyu"
 ];
@@ -271,10 +275,45 @@ function normalizeProvider(providerId, raw, source) {
         options: readOptionalObject,
         settings: parseOptionalExecutionSettings
       });
+    case "openai":
+      return parseProviderWithShape(raw, source, providerId, {
+        apiKey: readOptionalString,
+        baseUrl: readOptionalString,
+        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
+          value,
+          innerSource,
+          field,
+          ["search", "answer", "research"]
+        ),
+        settings: parseOptionalExecutionSettings
+      });
     case "firecrawl":
     case "linkup":
     case "parallel":
     case "perplexity":
+      return parseProviderWithShape(
+        raw,
+        source,
+        providerId,
+        {
+          apiKey: readOptionalString,
+          baseUrl: readOptionalString,
+          options: readOptionalObject,
+          settings: parseOptionalExecutionSettings
+        }
+      );
+    case "serper":
+      return parseProviderWithShape(raw, source, providerId, {
+        apiKey: readOptionalString,
+        baseUrl: readOptionalString,
+        options: (value, innerSource, field) => parseOptionalCapabilityOptions(
+          value,
+          innerSource,
+          field,
+          ["search"]
+        ),
+        settings: parseOptionalExecutionSettings
+      });
     case "tavily":
       return parseProviderWithShape(raw, source, providerId, {
         apiKey: readOptionalString,
@@ -4082,57 +4121,112 @@ function toDate(value, name) {
   return date;
 }
 
-// src/providers/parallel.ts
+// src/providers/openai.ts
 import { Type as Type10 } from "@sinclair/typebox";
-import ParallelClient from "parallel-web";
-var parallelSearchOptionsSchema = Type10.Object(
+import OpenAI from "openai";
+var DEFAULT_SEARCH_MODEL2 = "gpt-4.1";
+var DEFAULT_ANSWER_MODEL2 = "gpt-4.1";
+var DEFAULT_RESEARCH_MODEL = "o4-mini-deep-research";
+var openaiSearchOptionsSchema = Type10.Object(
   {
-    mode: Type10.Optional(
-      literalUnion(["agentic", "one-shot"], {
-        description: "Parallel search mode."
+    model: Type10.Optional(
+      Type10.String({
+        description: "OpenAI model to use for web search (for example 'gpt-4.1')."
+      })
+    ),
+    instructions: Type10.Optional(
+      Type10.String({
+        description: "Optional instructions that shape source selection and result style."
       })
     )
   },
-  { description: "Parallel search options." }
+  { description: "OpenAI search options." }
 );
-var parallelExtractOptionsSchema = Type10.Object(
+var openaiAnswerOptionsSchema = Type10.Object(
   {
-    excerpts: Type10.Optional(
-      Type10.Boolean({ description: "Include excerpts in extraction results." })
+    model: Type10.Optional(
+      Type10.String({
+        description: "OpenAI model to use for grounded answers (for example 'gpt-4.1')."
+      })
     ),
-    full_content: Type10.Optional(
-      Type10.Boolean({
-        description: "Include full page content in extraction results."
+    instructions: Type10.Optional(
+      Type10.String({
+        description: "Optional instructions that shape the answer structure, tone, and source selection."
       })
     )
   },
-  { description: "Parallel extract options." }
+  { description: "OpenAI answer options." }
 );
-var parallelAdapter = {
-  id: "parallel",
-  label: "Parallel",
-  docsUrl: "https://github.com/parallel-web/parallel-sdk-typescript",
-  tools: ["search", "contents"],
+var openaiResearchOptionsSchema = Type10.Object(
+  {
+    model: Type10.Optional(
+      Type10.String({
+        description: "OpenAI deep research model to use (for example 'o4-mini-deep-research')."
+      })
+    ),
+    instructions: Type10.Optional(
+      Type10.String({
+        description: "Optional instructions that shape the report structure, tone, and source selection."
+      })
+    ),
+    max_tool_calls: Type10.Optional(
+      Type10.Integer({
+        minimum: 1,
+        description: "Maximum number of built-in tool calls the model may make during the research run."
+      })
+    )
+  },
+  { description: "OpenAI deep research options." }
+);
+var searchResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["sources"],
+  properties: {
+    sources: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["title", "url", "snippet"],
+        properties: {
+          title: { type: "string" },
+          url: { type: "string" },
+          snippet: { type: "string" }
+        }
+      }
+    }
+  }
+};
+var openaiAdapter = {
+  id: "openai",
+  label: "OpenAI",
+  docsUrl: "https://platform.openai.com/docs/guides/deep-research",
+  tools: ["search", "answer", "research"],
   getToolOptionsSchema(capability) {
     switch (capability) {
       case "search":
-        return parallelSearchOptionsSchema;
-      case "contents":
-        return parallelExtractOptionsSchema;
+        return openaiSearchOptionsSchema;
+      case "answer":
+        return openaiAnswerOptionsSchema;
+      case "research":
+        return openaiResearchOptionsSchema;
       default:
         return void 0;
     }
   },
   createTemplate() {
     return {
-      apiKey: "PARALLEL_API_KEY",
+      apiKey: "OPENAI_API_KEY",
       options: {
         search: {
-          mode: "agentic"
+          model: DEFAULT_SEARCH_MODEL2
         },
-        extract: {
-          excerpts: false,
-          full_content: true
+        answer: {
+          model: DEFAULT_ANSWER_MODEL2
+        },
+        research: {
+          model: DEFAULT_RESEARCH_MODEL
         }
       }
     };
@@ -4146,11 +4240,18 @@ var parallelAdapter = {
           options: config.options?.search,
           settings: config.settings
         };
-      case "contents":
+      case "answer":
         return {
           apiKey: config.apiKey,
           baseUrl: config.baseUrl,
-          options: config.options?.extract,
+          options: config.options?.answer,
+          settings: config.settings
+        };
+      case "research":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.research,
           settings: config.settings
         };
       default:
@@ -4164,11 +4265,11 @@ var parallelAdapter = {
     return buildProviderPlan({
       request,
       config,
-      providerId: parallelAdapter.id,
-      providerLabel: parallelAdapter.label,
+      providerId: openaiAdapter.id,
+      providerLabel: openaiAdapter.label,
       handlers: {
         search: {
-          execute: (searchRequest, providerConfig, context) => parallelAdapter.search(
+          execute: (searchRequest, providerConfig, context) => openaiAdapter.search(
             searchRequest.query,
             searchRequest.maxResults,
             providerConfig,
@@ -4176,12 +4277,20 @@ var parallelAdapter = {
             searchRequest.options
           )
         },
-        contents: {
-          execute: (contentsRequest, providerConfig, context) => parallelAdapter.contents(
-            contentsRequest.urls,
+        answer: {
+          execute: (answerRequest, providerConfig, context) => openaiAdapter.answer(
+            answerRequest.query,
             providerConfig,
             context,
-            contentsRequest.options
+            answerRequest.options
+          )
+        },
+        research: {
+          execute: (researchRequest, providerConfig, context) => openaiAdapter.research(
+            researchRequest.input,
+            providerConfig,
+            context,
+            researchRequest.options
           )
         }
       }
@@ -4189,62 +4298,72 @@ var parallelAdapter = {
   },
   async search(query2, maxResults, config, context, options) {
     const client = createClient5(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
-    const response = await client.beta.search(
-      {
-        ...defaults,
-        ...options ?? {},
-        objective: query2,
-        max_results: maxResults
-      },
-      buildRequestOptions2(context)
+    const response = await client.responses.create(
+      buildOpenAISearchRequest(query2, maxResults, config, options),
+      buildRequestOptions2(context.signal, context.idempotencyKey)
     );
-    return {
-      provider: parallelAdapter.id,
-      results: response.results.slice(0, maxResults).map((result) => ({
-        title: result.title ?? result.url,
-        url: result.url,
-        snippet: trimSnippet(result.excerpts?.join(" ") ?? "")
-      }))
-    };
+    return parseSearchResponse2(response, maxResults);
   },
-  async contents(urls, config, context, options) {
+  async answer(query2, config, context, options) {
     const client = createClient5(config);
-    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
-    const response = await client.beta.extract(
-      {
-        ...defaults,
-        ...options ?? {},
-        urls
-      },
-      buildRequestOptions2(context)
+    const response = await client.responses.create(
+      buildOpenAIAnswerRequest(query2, config, options),
+      buildRequestOptions2(context.signal, context.idempotencyKey)
     );
-    const resultsByUrl = new Map(
-      response.results.map((result) => [result.url, result])
+    return ensureCompletedResponse(response, "answer");
+  },
+  async research(input, config, context, options) {
+    return await executeAsyncResearch({
+      providerLabel: openaiAdapter.label,
+      providerId: openaiAdapter.id,
+      context,
+      start: (researchContext) => openaiAdapter.startResearch(input, config, researchContext, options),
+      poll: (id, researchContext) => openaiAdapter.pollResearch(id, config, researchContext, options)
+    });
+  },
+  async startResearch(input, config, context, options) {
+    const client = createClient5(config);
+    const response = await client.responses.create(
+      buildOpenAIResearchRequest(input, config, options),
+      buildRequestOptions2(context.signal, context.idempotencyKey)
     );
-    const errorsByUrl = new Map(
-      response.errors.map((error) => [error.url, error])
+    return { id: response.id };
+  },
+  async pollResearch(id, config, context, _options) {
+    const client = createClient5(config);
+    const response = await client.responses.retrieve(
+      id,
+      void 0,
+      buildRequestOptions2(context.signal)
     );
+    const status = response.status ?? "completed";
+    if (status === "completed") {
+      return {
+        status: "completed",
+        output: formatResponseOutput(response, "research")
+      };
+    }
+    if (status === "failed") {
+      return {
+        status: "failed",
+        error: response.error?.message ?? "research failed"
+      };
+    }
+    if (status === "cancelled") {
+      return {
+        status: "cancelled",
+        error: "research was canceled"
+      };
+    }
+    if (status === "incomplete") {
+      return {
+        status: "failed",
+        error: formatIncompleteError(response, "research")
+      };
+    }
     return {
-      provider: parallelAdapter.id,
-      answers: urls.map((url) => {
-        const result = resultsByUrl.get(url);
-        if (result) {
-          return {
-            url,
-            content: result.full_content ?? result.excerpts?.join("\n\n") ?? void 0,
-            metadata: result
-          };
-        }
-        const error = errorsByUrl.get(url);
-        return error ? {
-          url,
-          error: formatJson(error)
-        } : {
-          url,
-          error: "No content returned for this URL."
-        };
-      })
+      status: "in_progress",
+      statusText: status
     };
   }
 };
@@ -4253,85 +4372,521 @@ function createClient5(config) {
   if (!apiKey) {
     throw new Error("is missing an API key");
   }
-  return new ParallelClient({
+  const baseUrl = resolveConfigValue(config.baseUrl);
+  return new OpenAI({
     apiKey,
-    baseURL: resolveConfigValue(config.baseUrl)
+    ...baseUrl ? { baseURL: baseUrl } : {}
   });
 }
-function buildRequestOptions2(context) {
-  return context.signal ? { signal: context.signal } : void 0;
+function buildOpenAISearchRequest(query2, maxResults, config, options) {
+  const mergedOptions = resolveOpenAISearchOptions(config, options);
+  const model = mergedOptions.model ?? DEFAULT_SEARCH_MODEL2;
+  const instructions = mergedOptions.instructions;
+  return {
+    model,
+    input: [
+      "Search the public web and return only the most relevant sources for the user's query.",
+      `Return at most ${maxResults} sources.`,
+      "Prefer official, primary, or highly reputable sources when available.",
+      "Each snippet should be short, specific, and grounded in the retrieved source.",
+      "Return only data matching the provided JSON schema.",
+      "",
+      `User query: ${query2}`
+    ].join("\n"),
+    tools: [{ type: "web_search_preview" }],
+    text: {
+      format: {
+        type: "json_schema",
+        name: "openai_web_search_results",
+        schema: searchResultSchema,
+        strict: true
+      }
+    },
+    ...instructions ? { instructions } : {}
+  };
 }
-
-// src/providers/perplexity.ts
-import PerplexityClient from "@perplexity-ai/perplexity_ai";
-import { Type as Type11 } from "@sinclair/typebox";
-var DEFAULT_ANSWER_MODEL2 = "sonar";
-var DEFAULT_RESEARCH_MODEL = "sonar-deep-research";
-var perplexitySearchOptionsSchema = Type11.Object(
-  {
-    country: Type11.Optional(
-      Type11.String({ description: "Country hint for search results." })
-    ),
-    search_mode: Type11.Optional(
-      Type11.String({ description: "Perplexity search mode." })
-    ),
-    search_domain_filter: Type11.Optional(
-      Type11.Array(Type11.String(), {
-        description: "Restrict search results to these domains."
-      })
-    ),
-    search_recency_filter: Type11.Optional(
-      Type11.String({ description: "Recency filter for search results." })
-    )
-  },
-  { description: "Perplexity search options." }
-);
-var perplexityAnswerOptionsSchema = Type11.Object(
-  {
-    model: Type11.Optional(
-      Type11.String({
-        description: "Perplexity model to use (for example 'sonar' or 'sonar-pro')."
-      })
-    )
-  },
-  { description: "Perplexity answer options." }
-);
-var perplexityResearchOptionsSchema = Type11.Object(
-  {
-    model: Type11.Optional(
-      Type11.String({
-        description: "Perplexity model to use (for example 'sonar-deep-research')."
-      })
-    )
-  },
-  { description: "Perplexity research options." }
-);
-var perplexityAdapter = {
-  id: "perplexity",
-  label: "Perplexity",
-  docsUrl: "https://docs.perplexity.ai/docs/sdk/overview.md",
-  tools: ["search", "answer", "research"],
-  getToolOptionsSchema(capability) {
-    switch (capability) {
-      case "search":
-        return perplexitySearchOptionsSchema;
-      case "answer":
-        return perplexityAnswerOptionsSchema;
-      case "research":
-        return perplexityResearchOptionsSchema;
-      default:
-        return void 0;
-    }
-  },
-  createTemplate() {
-    return {
+function buildOpenAIAnswerRequest(query2, config, options) {
+  const mergedOptions = resolveOpenAIAnswerOptions(config, options);
+  const model = mergedOptions.model ?? DEFAULT_ANSWER_MODEL2;
+  const instructions = mergedOptions.instructions;
+  return {
+    model,
+    input: query2,
+    tools: [{ type: "web_search_preview" }],
+    ...instructions ? { instructions } : {}
+  };
+}
+function buildOpenAIResearchRequest(input, config, options) {
+  const mergedOptions = resolveOpenAIResearchOptions(config, options);
+  const model = mergedOptions.model ?? DEFAULT_RESEARCH_MODEL;
+  const instructions = mergedOptions.instructions;
+  const maxToolCalls = mergedOptions.max_tool_calls;
+  return {
+    model,
+    input,
+    background: true,
+    tools: [{ type: "web_search_preview" }],
+    ...instructions ? { instructions } : {},
+    ...maxToolCalls ? { max_tool_calls: maxToolCalls } : {}
+  };
+}
+function resolveOpenAISearchOptions(config, options) {
+  const mergedOptions = {
+    ...config.options?.search ?? {},
+    ...options ?? {}
+  };
+  const model = readNonEmptyString4(mergedOptions.model);
+  const instructions = readNonEmptyString4(mergedOptions.instructions);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {}
+  };
+}
+function resolveOpenAIAnswerOptions(config, options) {
+  const mergedOptions = {
+    ...config.options?.answer ?? {},
+    ...options ?? {}
+  };
+  const model = readNonEmptyString4(mergedOptions.model);
+  const instructions = readNonEmptyString4(mergedOptions.instructions);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {}
+  };
+}
+function resolveOpenAIResearchOptions(config, options) {
+  const mergedOptions = {
+    ...config.options?.research ?? {},
+    ...options ?? {}
+  };
+  const model = readNonEmptyString4(mergedOptions.model);
+  const instructions = readNonEmptyString4(mergedOptions.instructions);
+  const maxToolCalls = readPositiveInteger2(mergedOptions.max_tool_calls);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {},
+    ...maxToolCalls ? { max_tool_calls: maxToolCalls } : {}
+  };
+}
+function buildRequestOptions2(signal, idempotencyKey) {
+  if (!signal && !idempotencyKey) {
+    return void 0;
+  }
+  return {
+    ...signal ? { signal } : {},
+    ...idempotencyKey ? { idempotencyKey } : {}
+  };
+}
+function parseSearchResponse2(response, maxResults) {
+  const status = response.status ?? "completed";
+  if (status === "failed") {
+    throw new Error(response.error?.message ?? "search failed");
+  }
+  if (status === "cancelled") {
+    throw new Error("search was canceled");
+  }
+  if (status === "incomplete") {
+    throw new Error(formatIncompleteError(response, "search"));
+  }
+  if (status !== "completed") {
+    throw new Error(`search did not complete (status: ${status})`);
+  }
+  const payload = parseSearchPayload(response.output_text);
+  return {
+    provider: openaiAdapter.id,
+    results: payload.sources.slice(0, maxResults).map((source) => ({
+      title: source.title.trim(),
+      url: source.url.trim(),
+      snippet: trimSnippet(source.snippet)
+    }))
+  };
+}
+function ensureCompletedResponse(response, operation) {
+  const status = response.status ?? "completed";
+  if (status === "completed") {
+    return formatResponseOutput(response, operation);
+  }
+  if (status === "failed") {
+    throw new Error(response.error?.message ?? `${operation} failed`);
+  }
+  if (status === "cancelled") {
+    throw new Error(`${operation} was canceled`);
+  }
+  if (status === "incomplete") {
+    throw new Error(formatIncompleteError(response, operation));
+  }
+  throw new Error(`${operation} did not complete (status: ${status})`);
+}
+function formatResponseOutput(response, operation) {
+  const lines = [];
+  lines.push(
+    response.output_text?.trim() || `OpenAI ${operation} completed without textual output.`
+  );
+  const citations = extractUrlCitations(response);
+  if (citations.length > 0) {
+    lines.push("");
+    lines.push("Sources:");
+    for (const [index, citation] of citations.entries()) {
+      lines.push(`${index + 1}. ${citation.title}`);
+      lines.push(`   ${citation.url}`);
+    }
+  }
+  return {
+    provider: openaiAdapter.id,
+    text: lines.join("\n").trimEnd(),
+    itemCount: citations.length,
+    metadata: {
+      responseId: response.id,
+      model: response.model,
+      citations
+    }
+  };
+}
+function extractUrlCitations(response) {
+  const citations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of response.output) {
+    if (item.type !== "message" || !item.content) {
+      continue;
+    }
+    for (const content of item.content) {
+      if (content.type !== "output_text" || !content.annotations) {
+        continue;
+      }
+      for (const annotation of content.annotations) {
+        if (annotation.type !== "url_citation") {
+          continue;
+        }
+        const title = readNonEmptyString4(annotation.title);
+        const url = readNonEmptyString4(annotation.url);
+        const startIndex = readInteger(annotation.start_index);
+        const endIndex = readInteger(annotation.end_index);
+        if (!title || !url || startIndex === void 0 || endIndex === void 0) {
+          continue;
+        }
+        const citation = {
+          title,
+          url,
+          startIndex,
+          endIndex
+        };
+        const key = [
+          citation.title,
+          citation.url,
+          String(citation.startIndex),
+          String(citation.endIndex)
+        ].join("::");
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        citations.push(citation);
+      }
+    }
+  }
+  return citations;
+}
+function parseSearchPayload(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text ?? "");
+  } catch (error) {
+    throw new Error(
+      `search returned invalid JSON: ${error.message}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || !("sources" in parsed) || !Array.isArray(parsed.sources)) {
+    throw new Error("search output must include a 'sources' array");
+  }
+  return {
+    sources: parsed.sources.map((source, index) => {
+      if (typeof source !== "object" || source === null) {
+        throw new Error(`search source at index ${index} must be an object`);
+      }
+      const entry = source;
+      const title = readNonEmptyString4(entry.title);
+      const url = readNonEmptyString4(entry.url);
+      const snippet = readNonEmptyString4(entry.snippet);
+      if (!title) {
+        throw new Error(`search source at index ${index} is missing title`);
+      }
+      if (!url) {
+        throw new Error(`search source at index ${index} is missing url`);
+      }
+      if (!snippet) {
+        throw new Error(`search source at index ${index} is missing snippet`);
+      }
+      return { title, url, snippet };
+    })
+  };
+}
+function formatIncompleteError(response, operation) {
+  const reason = response.incomplete_details?.reason;
+  if (reason) {
+    return `${operation} ended incomplete (${reason})`;
+  }
+  return `${operation} ended incomplete`;
+}
+function readNonEmptyString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readPositiveInteger2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function readInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : void 0;
+}
+
+// src/providers/parallel.ts
+import { Type as Type11 } from "@sinclair/typebox";
+import ParallelClient from "parallel-web";
+var parallelSearchOptionsSchema = Type11.Object(
+  {
+    mode: Type11.Optional(
+      literalUnion(["agentic", "one-shot"], {
+        description: "Parallel search mode."
+      })
+    )
+  },
+  { description: "Parallel search options." }
+);
+var parallelExtractOptionsSchema = Type11.Object(
+  {
+    excerpts: Type11.Optional(
+      Type11.Boolean({ description: "Include excerpts in extraction results." })
+    ),
+    full_content: Type11.Optional(
+      Type11.Boolean({
+        description: "Include full page content in extraction results."
+      })
+    )
+  },
+  { description: "Parallel extract options." }
+);
+var parallelAdapter = {
+  id: "parallel",
+  label: "Parallel",
+  docsUrl: "https://github.com/parallel-web/parallel-sdk-typescript",
+  tools: ["search", "contents"],
+  getToolOptionsSchema(capability) {
+    switch (capability) {
+      case "search":
+        return parallelSearchOptionsSchema;
+      case "contents":
+        return parallelExtractOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
+      apiKey: "PARALLEL_API_KEY",
+      options: {
+        search: {
+          mode: "agentic"
+        },
+        extract: {
+          excerpts: false,
+          full_content: true
+        }
+      }
+    };
+  },
+  getConfigForCapability(capability, config) {
+    switch (capability) {
+      case "search":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.search,
+          settings: config.settings
+        };
+      case "contents":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.extract,
+          settings: config.settings
+        };
+      default:
+        return config;
+    }
+  },
+  getCapabilityStatus(config) {
+    return getApiKeyStatus(config?.apiKey);
+  },
+  buildPlan(request, config) {
+    return buildProviderPlan({
+      request,
+      config,
+      providerId: parallelAdapter.id,
+      providerLabel: parallelAdapter.label,
+      handlers: {
+        search: {
+          execute: (searchRequest, providerConfig, context) => parallelAdapter.search(
+            searchRequest.query,
+            searchRequest.maxResults,
+            providerConfig,
+            context,
+            searchRequest.options
+          )
+        },
+        contents: {
+          execute: (contentsRequest, providerConfig, context) => parallelAdapter.contents(
+            contentsRequest.urls,
+            providerConfig,
+            context,
+            contentsRequest.options
+          )
+        }
+      }
+    });
+  },
+  async search(query2, maxResults, config, context, options) {
+    const client = createClient6(config);
+    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const response = await client.beta.search(
+      {
+        ...defaults,
+        ...options ?? {},
+        objective: query2,
+        max_results: maxResults
+      },
+      buildRequestOptions3(context)
+    );
+    return {
+      provider: parallelAdapter.id,
+      results: response.results.slice(0, maxResults).map((result) => ({
+        title: result.title ?? result.url,
+        url: result.url,
+        snippet: trimSnippet(result.excerpts?.join(" ") ?? "")
+      }))
+    };
+  },
+  async contents(urls, config, context, options) {
+    const client = createClient6(config);
+    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
+    const response = await client.beta.extract(
+      {
+        ...defaults,
+        ...options ?? {},
+        urls
+      },
+      buildRequestOptions3(context)
+    );
+    const resultsByUrl = new Map(
+      response.results.map((result) => [result.url, result])
+    );
+    const errorsByUrl = new Map(
+      response.errors.map((error) => [error.url, error])
+    );
+    return {
+      provider: parallelAdapter.id,
+      answers: urls.map((url) => {
+        const result = resultsByUrl.get(url);
+        if (result) {
+          return {
+            url,
+            content: result.full_content ?? result.excerpts?.join("\n\n") ?? void 0,
+            metadata: result
+          };
+        }
+        const error = errorsByUrl.get(url);
+        return error ? {
+          url,
+          error: formatJson(error)
+        } : {
+          url,
+          error: "No content returned for this URL."
+        };
+      })
+    };
+  }
+};
+function createClient6(config) {
+  const apiKey = resolveConfigValue(config.apiKey);
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new ParallelClient({
+    apiKey,
+    baseURL: resolveConfigValue(config.baseUrl)
+  });
+}
+function buildRequestOptions3(context) {
+  return context.signal ? { signal: context.signal } : void 0;
+}
+
+// src/providers/perplexity.ts
+import PerplexityClient from "@perplexity-ai/perplexity_ai";
+import { Type as Type12 } from "@sinclair/typebox";
+var DEFAULT_ANSWER_MODEL3 = "sonar";
+var DEFAULT_RESEARCH_MODEL2 = "sonar-deep-research";
+var perplexitySearchOptionsSchema = Type12.Object(
+  {
+    country: Type12.Optional(
+      Type12.String({ description: "Country hint for search results." })
+    ),
+    search_mode: Type12.Optional(
+      Type12.String({ description: "Perplexity search mode." })
+    ),
+    search_domain_filter: Type12.Optional(
+      Type12.Array(Type12.String(), {
+        description: "Restrict search results to these domains."
+      })
+    ),
+    search_recency_filter: Type12.Optional(
+      Type12.String({ description: "Recency filter for search results." })
+    )
+  },
+  { description: "Perplexity search options." }
+);
+var perplexityAnswerOptionsSchema = Type12.Object(
+  {
+    model: Type12.Optional(
+      Type12.String({
+        description: "Perplexity model to use (for example 'sonar' or 'sonar-pro')."
+      })
+    )
+  },
+  { description: "Perplexity answer options." }
+);
+var perplexityResearchOptionsSchema = Type12.Object(
+  {
+    model: Type12.Optional(
+      Type12.String({
+        description: "Perplexity model to use (for example 'sonar-deep-research')."
+      })
+    )
+  },
+  { description: "Perplexity research options." }
+);
+var perplexityAdapter = {
+  id: "perplexity",
+  label: "Perplexity",
+  docsUrl: "https://docs.perplexity.ai/docs/sdk/overview.md",
+  tools: ["search", "answer", "research"],
+  getToolOptionsSchema(capability) {
+    switch (capability) {
+      case "search":
+        return perplexitySearchOptionsSchema;
+      case "answer":
+        return perplexityAnswerOptionsSchema;
+      case "research":
+        return perplexityResearchOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
       apiKey: "PERPLEXITY_API_KEY",
       options: {
         answer: {
-          model: DEFAULT_ANSWER_MODEL2
+          model: DEFAULT_ANSWER_MODEL3
         },
         research: {
-          model: DEFAULT_RESEARCH_MODEL
+          model: DEFAULT_RESEARCH_MODEL2
         }
       }
     };
@@ -4375,7 +4930,7 @@ var perplexityAdapter = {
     });
   },
   async search(query2, maxResults, config, context, options) {
-    const client = createClient6(config);
+    const client = createClient7(config);
     const request = {
       ...stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {},
       ...options ?? {},
@@ -4384,7 +4939,7 @@ var perplexityAdapter = {
     };
     const response = await client.search.create(
       request,
-      buildRequestOptions3(context)
+      buildRequestOptions4(context)
     );
     return {
       provider: perplexityAdapter.id,
@@ -4404,7 +4959,7 @@ var perplexityAdapter = {
       query2,
       config,
       context,
-      DEFAULT_ANSWER_MODEL2,
+      DEFAULT_ANSWER_MODEL3,
       "Answer",
       options
     );
@@ -4414,14 +4969,14 @@ var perplexityAdapter = {
       input,
       config,
       context,
-      DEFAULT_RESEARCH_MODEL,
+      DEFAULT_RESEARCH_MODEL2,
       "Research",
       options
     );
   }
 };
 async function runSilentForegroundChatTool(input, config, context, fallbackModel, label, options, isResearch = false) {
-  const client = createClient6(config);
+  const client = createClient7(config);
   const defaults = stripLocalExecutionOptions(
     isResearch ? asJsonObject(config.options?.research) : asJsonObject(config.options?.answer)
   ) ?? {};
@@ -4434,7 +4989,7 @@ async function runSilentForegroundChatTool(input, config, context, fallbackModel
   };
   const response = await client.chat.completions.create(
     request,
-    buildRequestOptions3(context)
+    buildRequestOptions4(context)
   );
   const content = extractMessageText(response.choices[0]?.message?.content);
   const sources = dedupeSources(extractSources(response));
@@ -4455,7 +5010,7 @@ async function runSilentForegroundChatTool(input, config, context, fallbackModel
   };
 }
 async function runStreamingForegroundChatTool(input, config, context, fallbackModel, label, options) {
-  const client = createClient6(config);
+  const client = createClient7(config);
   const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.research)) ?? {};
   const request = {
     ...defaults,
@@ -4466,7 +5021,7 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
   };
   const stream = await client.chat.completions.create(
     request,
-    buildRequestOptions3(context)
+    buildRequestOptions4(context)
   );
   let partialText = "";
   let lastChunk;
@@ -4477,156 +5032,387 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
     if (deltaText) {
       partialText = `${partialText}${deltaText}`;
     }
-    sources.push(...extractSources(chunk));
+    sources.push(...extractSources(chunk));
+  }
+  const finalText = partialText.trim() || extractMessageText(lastChunk?.choices?.[0]?.message?.content) || `No ${label.toLowerCase()} returned.`;
+  const dedupedSources = dedupeSources(sources);
+  const lines = [finalText];
+  if (dedupedSources.length > 0) {
+    lines.push("");
+    lines.push("Sources:");
+    for (const [index, source] of dedupedSources.entries()) {
+      lines.push(`${index + 1}. ${source.title}`);
+      lines.push(`   ${source.url}`);
+    }
+  }
+  return {
+    provider: perplexityAdapter.id,
+    text: lines.join("\n").trimEnd(),
+    itemCount: dedupedSources.length
+  };
+}
+function createClient7(config) {
+  const apiKey = resolveConfigValue(config.apiKey);
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new PerplexityClient({
+    apiKey,
+    baseURL: resolveConfigValue(config.baseUrl)
+  });
+}
+function resolveModel(optionModel, defaultModel, fallbackModel) {
+  if (typeof optionModel === "string" && optionModel.trim().length > 0) {
+    return optionModel;
+  }
+  if (typeof defaultModel === "string" && defaultModel.trim().length > 0) {
+    return defaultModel;
+  }
+  return fallbackModel;
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.flatMap((chunk) => {
+    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
+      return [chunk.text.trim()];
+    }
+    return [];
+  }).filter((text) => text.length > 0).join("\n\n").trim();
+}
+function extractDeltaText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.flatMap((chunk) => {
+    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
+      return [chunk.text];
+    }
+    return [];
+  }).join("");
+}
+function dedupeSources(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const source of sources) {
+    const title = source.title.trim() || source.url.trim() || "Untitled";
+    const url = source.url.trim();
+    if (!url) continue;
+    const key = `${title.toLowerCase()}::${url.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push({ title, url });
+  }
+  return unique;
+}
+function extractSources(response) {
+  const searchResults = response.search_results?.flatMap((result) => {
+    const url = result.url?.trim() ?? "";
+    if (!url) {
+      return [];
+    }
+    return [{ title: result.title?.trim() ?? url, url }];
+  }) ?? [];
+  if (searchResults.length > 0) {
+    return searchResults;
+  }
+  return response.citations?.flatMap((citation) => {
+    const url = citation?.trim() ?? "";
+    return url ? [{ title: url, url }] : [];
+  }) ?? [];
+}
+function buildRequestOptions4(context) {
+  return context.signal ? { signal: context.signal } : void 0;
+}
+
+// src/providers/serper.ts
+import { Type as Type13 } from "@sinclair/typebox";
+var DEFAULT_BASE_URL = "https://google.serper.dev";
+var serperSearchOptionsSchema = Type13.Object(
+  {
+    gl: Type13.Optional(
+      Type13.String({
+        description: "Country code hint for Google results (for example 'us')."
+      })
+    ),
+    hl: Type13.Optional(
+      Type13.String({
+        description: "Language code hint for Google results (for example 'en')."
+      })
+    ),
+    location: Type13.Optional(
+      Type13.String({
+        description: "Geographic location hint for Google results."
+      })
+    ),
+    page: Type13.Optional(
+      Type13.Integer({
+        minimum: 1,
+        description: "1-based results page to request from Serper."
+      })
+    ),
+    autocorrect: Type13.Optional(
+      Type13.Boolean({
+        description: "Enable or disable Serper query autocorrection."
+      })
+    )
+  },
+  { description: "Serper search options." }
+);
+var serperAdapter = {
+  id: "serper",
+  label: "Serper",
+  docsUrl: "https://serper.dev/",
+  tools: ["search"],
+  getToolOptionsSchema(capability) {
+    switch (capability) {
+      case "search":
+        return serperSearchOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
+      apiKey: "SERPER_API_KEY",
+      options: {}
+    };
+  },
+  getConfigForCapability(capability, config) {
+    switch (capability) {
+      case "search":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.search,
+          settings: config.settings
+        };
+      default:
+        return config;
+    }
+  },
+  getCapabilityStatus(config) {
+    return getApiKeyStatus(config?.apiKey);
+  },
+  buildPlan(request, config) {
+    return buildProviderPlan({
+      request,
+      config,
+      providerId: serperAdapter.id,
+      providerLabel: serperAdapter.label,
+      handlers: {
+        search: {
+          execute: (searchRequest, providerConfig, context) => serperAdapter.search(
+            searchRequest.query,
+            searchRequest.maxResults,
+            providerConfig,
+            context,
+            searchRequest.options
+          )
+        }
+      }
+    });
+  },
+  async search(query2, maxResults, config, context, options) {
+    const apiKey = resolveConfigValue(config.apiKey);
+    if (!apiKey) {
+      throw new Error("is missing an API key");
+    }
+    const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
+    const runtimeOptions = stripLocalExecutionOptions(asJsonObject(options));
+    const {
+      q: _ignoredQuery,
+      num: _ignoredNum,
+      ...providerOptions
+    } = {
+      ...defaults,
+      ...runtimeOptions ?? {}
+    };
+    const response = await fetch(joinUrl(resolveConfigValue(config.baseUrl)), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({
+        q: query2,
+        num: clampMaxResults(maxResults),
+        ...providerOptions
+      }),
+      signal: context.signal
+    });
+    if (!response.ok) {
+      throw new Error(await buildHttpError(response));
+    }
+    const payload = await response.json();
+    const responseRecord = asRecord3(payload) ?? {};
+    const organic = asArray(responseRecord.organic) ?? [];
+    const searchContext = buildSearchContext(responseRecord);
+    return {
+      provider: serperAdapter.id,
+      results: organic.map((entry) => toSearchResult3(entry, searchContext)).filter(
+        (result) => result !== null
+      ).slice(0, clampMaxResults(maxResults))
+    };
   }
-  const finalText = partialText.trim() || extractMessageText(lastChunk?.choices?.[0]?.message?.content) || `No ${label.toLowerCase()} returned.`;
-  const dedupedSources = dedupeSources(sources);
-  const lines = [finalText];
-  if (dedupedSources.length > 0) {
-    lines.push("");
-    lines.push("Sources:");
-    for (const [index, source] of dedupedSources.entries()) {
-      lines.push(`${index + 1}. ${source.title}`);
-      lines.push(`   ${source.url}`);
+};
+function joinUrl(baseUrl) {
+  const base = (baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  return `${base}/search`;
+}
+function clampMaxResults(value) {
+  return Math.max(1, Math.min(20, Math.trunc(value || 0)));
+}
+async function buildHttpError(response) {
+  const detail = await readErrorDetail(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) {
+  const text = (await response.text()).trim();
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const record = asRecord3(parsed);
+    const detail = readString4(record?.message) ?? readString4(record?.error) ?? readString4(record?.detail);
+    if (detail) {
+      return detail;
     }
+    return JSON.stringify(parsed);
+  } catch {
+    return text;
+  }
+}
+function toSearchResult3(entry, searchContext) {
+  const record = asRecord3(entry);
+  if (!record) {
+    return null;
   }
+  const url = readString4(record.link) ?? "";
+  const title = readString4(record.title) || url || "Untitled";
+  const snippet = trimSnippet(
+    readString4(record.snippet) ?? readString4(record.richSnippet) ?? readString4(record.date) ?? ""
+  );
+  const metadata = omitUndefined({
+    source: "organic",
+    position: readNumber(record.position),
+    date: readString4(record.date),
+    attributes: asRecord3(record.attributes),
+    sitelinks: asArray(record.sitelinks),
+    rating: readNumber(record.rating),
+    ratingCount: readNumber(record.ratingCount),
+    cid: readString4(record.cid),
+    ...extractExtraMetadata(record, ["title", "link", "snippet"]),
+    ...searchContext ? { searchContext } : {}
+  });
   return {
-    provider: perplexityAdapter.id,
-    text: lines.join("\n").trimEnd(),
-    itemCount: dedupedSources.length
+    title,
+    url,
+    snippet,
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
   };
 }
-function createClient6(config) {
-  const apiKey = resolveConfigValue(config.apiKey);
-  if (!apiKey) {
-    throw new Error("is missing an API key");
-  }
-  return new PerplexityClient({
-    apiKey,
-    baseURL: resolveConfigValue(config.baseUrl)
+function buildSearchContext(response) {
+  const context = omitUndefined({
+    searchParameters: asRecord3(response.searchParameters),
+    searchInformation: asRecord3(response.searchInformation),
+    credits: readNumber(response.credits),
+    answerBox: asRecord3(response.answerBox),
+    knowledgeGraph: asRecord3(response.knowledgeGraph),
+    peopleAlsoAsk: asArray(response.peopleAlsoAsk),
+    relatedSearches: asArray(response.relatedSearches),
+    topStories: asArray(response.topStories),
+    news: asArray(response.news),
+    images: asArray(response.images),
+    videos: asArray(response.videos),
+    places: asArray(response.places)
   });
+  return Object.keys(context).length > 0 ? context : void 0;
 }
-function resolveModel(optionModel, defaultModel, fallbackModel) {
-  if (typeof optionModel === "string" && optionModel.trim().length > 0) {
-    return optionModel;
-  }
-  if (typeof defaultModel === "string" && defaultModel.trim().length > 0) {
-    return defaultModel;
-  }
-  return fallbackModel;
+function extractExtraMetadata(record, ignoredKeys) {
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      ([key, value]) => !ignoredKeys.includes(key) && value !== void 0
+    )
+  );
 }
-function extractMessageText(content) {
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  return content.flatMap((chunk) => {
-    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
-      return [chunk.text.trim()];
-    }
-    return [];
-  }).filter((text) => text.length > 0).join("\n\n").trim();
+function omitUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
 }
-function extractDeltaText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  return content.flatMap((chunk) => {
-    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
-      return [chunk.text];
-    }
-    return [];
-  }).join("");
+function asRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function dedupeSources(sources) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const source of sources) {
-    const title = source.title.trim() || source.url.trim() || "Untitled";
-    const url = source.url.trim();
-    if (!url) continue;
-    const key = `${title.toLowerCase()}::${url.toLowerCase()}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push({ title, url });
-  }
-  return unique;
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
 }
-function extractSources(response) {
-  const searchResults = response.search_results?.flatMap((result) => {
-    const url = result.url?.trim() ?? "";
-    if (!url) {
-      return [];
-    }
-    return [{ title: result.title?.trim() ?? url, url }];
-  }) ?? [];
-  if (searchResults.length > 0) {
-    return searchResults;
-  }
-  return response.citations?.flatMap((citation) => {
-    const url = citation?.trim() ?? "";
-    return url ? [{ title: url, url }] : [];
-  }) ?? [];
+function readString4(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function buildRequestOptions3(context) {
-  return context.signal ? { signal: context.signal } : void 0;
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 
 // src/providers/tavily.ts
-import { Type as Type12 } from "@sinclair/typebox";
+import { Type as Type14 } from "@sinclair/typebox";
 import {
   tavily
 } from "@tavily/core";
-var tavilySearchOptionsSchema = Type12.Object(
+var tavilySearchOptionsSchema = Type14.Object(
   {
-    topic: Type12.Optional(
+    topic: Type14.Optional(
       literalUnion(["general", "news", "finance"], {
         description: "Category of the search query."
       })
     ),
-    searchDepth: Type12.Optional(
+    searchDepth: Type14.Optional(
       literalUnion(["basic", "advanced"], {
         description: "Depth of the search. 'advanced' is slower but more thorough."
       })
     ),
-    timeRange: Type12.Optional(
-      Type12.String({ description: "Named time range filter." })
+    timeRange: Type14.Optional(
+      Type14.String({ description: "Named time range filter." })
     ),
-    country: Type12.Optional(
-      Type12.String({ description: "Country hint for search results." })
+    country: Type14.Optional(
+      Type14.String({ description: "Country hint for search results." })
     ),
-    exactMatch: Type12.Optional(
-      Type12.Boolean({ description: "Prefer exact matches." })
+    exactMatch: Type14.Optional(
+      Type14.Boolean({ description: "Prefer exact matches." })
     ),
-    includeAnswer: Type12.Optional(
-      Type12.Boolean({ description: "Include a short AI-generated answer." })
+    includeAnswer: Type14.Optional(
+      Type14.Boolean({ description: "Include a short AI-generated answer." })
     ),
-    includeRawContent: Type12.Optional(
-      Type12.Boolean({ description: "Include raw page content in results." })
+    includeRawContent: Type14.Optional(
+      Type14.Boolean({ description: "Include raw page content in results." })
     ),
-    includeImages: Type12.Optional(
-      Type12.Boolean({ description: "Include related images." })
+    includeImages: Type14.Optional(
+      Type14.Boolean({ description: "Include related images." })
     ),
-    includeFavicon: Type12.Optional(
-      Type12.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type14.Optional(
+      Type14.Boolean({ description: "Include favicon URLs." })
     ),
-    includeDomains: Type12.Optional(
-      Type12.Array(Type12.String(), {
+    includeDomains: Type14.Optional(
+      Type14.Array(Type14.String(), {
         description: "Restrict results to these domains."
       })
     ),
-    excludeDomains: Type12.Optional(
-      Type12.Array(Type12.String(), {
+    excludeDomains: Type14.Optional(
+      Type14.Array(Type14.String(), {
         description: "Exclude these domains from results."
       })
     ),
-    days: Type12.Optional(
-      Type12.Integer({
+    days: Type14.Optional(
+      Type14.Integer({
         minimum: 1,
         description: "Limit results to the last N days."
       })
@@ -4634,27 +5420,27 @@ var tavilySearchOptionsSchema = Type12.Object(
   },
   { description: "Tavily search options." }
 );
-var tavilyExtractOptionsSchema = Type12.Object(
+var tavilyExtractOptionsSchema = Type14.Object(
   {
-    extractDepth: Type12.Optional(
-      Type12.String({ description: "Depth setting for extraction." })
+    extractDepth: Type14.Optional(
+      Type14.String({ description: "Depth setting for extraction." })
     ),
-    format: Type12.Optional(
+    format: Type14.Optional(
       literalUnion(["markdown", "text"], {
         description: "Output format for extracted content."
       })
     ),
-    includeImages: Type12.Optional(
-      Type12.Boolean({ description: "Include extracted images." })
+    includeImages: Type14.Optional(
+      Type14.Boolean({ description: "Include extracted images." })
     ),
-    query: Type12.Optional(
-      Type12.String({ description: "Optional query to focus extraction." })
+    query: Type14.Optional(
+      Type14.String({ description: "Optional query to focus extraction." })
     ),
-    chunksPerSource: Type12.Optional(
-      Type12.Integer({ minimum: 1, description: "Maximum chunks per source." })
+    chunksPerSource: Type14.Optional(
+      Type14.Integer({ minimum: 1, description: "Maximum chunks per source." })
     ),
-    includeFavicon: Type12.Optional(
-      Type12.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type14.Optional(
+      Type14.Boolean({ description: "Include favicon URLs." })
     )
   },
   { description: "Tavily extract options." }
@@ -4739,7 +5525,7 @@ var tavilyAdapter = {
     });
   },
   async search(query2, maxResults, config, _context, options) {
-    const client = createClient7(config);
+    const client = createClient8(config);
     const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
     const response = await client.search(query2, {
       ...defaults,
@@ -4758,7 +5544,7 @@ var tavilyAdapter = {
     };
   },
   async contents(urls, config, _context, options) {
-    const client = createClient7(config);
+    const client = createClient8(config);
     const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
     const response = await client.extract(urls, {
       ...defaults,
@@ -4796,7 +5582,7 @@ var tavilyAdapter = {
     };
   }
 };
-function createClient7(config) {
+function createClient8(config) {
   const apiKey = resolveConfigValue(config.apiKey);
   if (!apiKey) {
     throw new Error("is missing an API key");
@@ -4828,48 +5614,48 @@ function buildExtractMetadata(response, result) {
 }
 
 // src/providers/valyu.ts
-import { Type as Type13 } from "@sinclair/typebox";
+import { Type as Type15 } from "@sinclair/typebox";
 import { Valyu as ValyuClient } from "valyu-js";
-var valyuSearchOptionsSchema = Type13.Object(
+var valyuSearchOptionsSchema = Type15.Object(
   {
-    searchType: Type13.Optional(
+    searchType: Type15.Optional(
       literalUnion(["all", "web", "proprietary", "news"], {
         description: "Valyu search type."
       })
     ),
-    responseLength: Type13.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope search results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope search results." })
     )
   },
   { description: "Valyu search options." }
 );
-var valyuAnswerOptionsSchema = Type13.Object(
+var valyuAnswerOptionsSchema = Type15.Object(
   {
-    responseLength: Type13.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for answers."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope answer results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope answer results." })
     )
   },
   { description: "Valyu answer options." }
 );
-var valyuResearchOptionsSchema = Type13.Object(
+var valyuResearchOptionsSchema = Type15.Object(
   {
-    responseLength: Type13.Optional(
+    responseLength: Type15.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for research."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope research results." })
+    countryCode: Type15.Optional(
+      Type15.String({ description: "Country code to scope research results." })
     )
   },
   { description: "Valyu research options." }
@@ -4982,7 +5768,7 @@ var valyuAdapter = {
     });
   },
   async search(query2, maxResults, config, _context, searchOptions) {
-    const client = createClient8(config);
+    const client = createClient9(config);
     const options = {
       ...stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {},
       ...searchOptions ?? {},
@@ -5005,7 +5791,7 @@ var valyuAdapter = {
     };
   },
   async contents(urls, config, _context, options) {
-    const client = createClient8(config);
+    const client = createClient9(config);
     const response = await client.contents(urls, options);
     const finalResponse = "jobId" in response ? await client.waitForJob(response.jobId, {}) : response;
     if (!finalResponse.success) {
@@ -5039,7 +5825,7 @@ var valyuAdapter = {
     };
   },
   async answer(query2, config, _context, options) {
-    const client = createClient8(config);
+    const client = createClient9(config);
     const response = await client.answer(query2, {
       ...stripLocalExecutionOptions(asJsonObject(config.options?.answer)) ?? {},
       ...options ?? {},
@@ -5078,7 +5864,7 @@ var valyuAdapter = {
     });
   },
   async startResearch(input, config, _context, options) {
-    const client = createClient8(config);
+    const client = createClient9(config);
     const task = await client.deepresearch.create({
       input,
       ...stripLocalExecutionOptions(asJsonObject(config.options?.research)) ?? {},
@@ -5090,7 +5876,7 @@ var valyuAdapter = {
     return { id: task.deepresearch_id };
   },
   async pollResearch(id, config, _context, _options) {
-    const client = createClient8(config);
+    const client = createClient9(config);
     const result = await client.deepresearch.status(id);
     if (!result.success) {
       throw new Error(result.error || "deep research failed");
@@ -5133,7 +5919,7 @@ var valyuAdapter = {
     return { status: "in_progress" };
   }
 };
-function createClient8(config) {
+function createClient9(config) {
   const apiKey = resolveConfigValue(config.apiKey);
   if (!apiKey) {
     throw new Error("is missing an API key");
@@ -5144,15 +5930,17 @@ function createClient8(config) {
 // src/providers/index.ts
 var ADAPTERS_BY_ID = {
   claude: claudeAdapter,
-  cloudflare: cloudflareAdapter,
   codex: codexAdapter,
+  cloudflare: cloudflareAdapter,
   custom: customAdapter,
   exa: exaAdapter,
   firecrawl: firecrawlAdapter,
   gemini: geminiAdapter,
   linkup: linkupAdapter,
-  perplexity: perplexityAdapter,
+  openai: openaiAdapter,
   parallel: parallelAdapter,
+  perplexity: perplexityAdapter,
+  serper: serperAdapter,
   tavily: tavilyAdapter,
   valyu: valyuAdapter
 };
@@ -6226,8 +7014,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         setValue: (config, value) => {
           setCustomEnv(config, "research", value);
         }
-      }),
-      ...requestSettings("custom")
+      })
     ]
   },
   exa: {
@@ -6250,7 +7037,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
           "deep-reasoning",
           "deep-max"
         ],
-        getValue: (config) => readString4(getExaSearchOptions(config)?.type) ?? "default",
+        getValue: (config) => readString5(getExaSearchOptions(config)?.type) ?? "default",
         setValue: (config, value) => {
           const options = ensureExaSearchOptions(config);
           if (value === "default") {
@@ -6355,10 +7142,111 @@ var PROVIDER_CONFIG_MANIFESTS = {
     ]
   },
   linkup: {
+    settings: [apiKeySetting(), baseUrlSetting()]
+  },
+  openai: {
     settings: [
       apiKeySetting(),
       baseUrlSetting(),
-      ...requestSettings("linkup")
+      stringSetting({
+        id: "openaiSearchModel",
+        label: "Search model",
+        help: "Model used for OpenAI web search runs.",
+        getValue: (config) => getOpenAISearchOptions(config)?.model,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAISearchOptions(config),
+            "model",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiSearchInstructions",
+        label: "Search instructions",
+        help: "Optional default instructions for OpenAI web search runs.",
+        getValue: (config) => getOpenAISearchOptions(config)?.instructions,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAISearchOptions(config),
+            "instructions",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiAnswerModel",
+        label: "Answer model",
+        help: "Model used for OpenAI grounded answers.",
+        getValue: (config) => getOpenAIAnswerOptions(config)?.model,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAIAnswerOptions(config),
+            "model",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiAnswerInstructions",
+        label: "Answer instructions",
+        help: "Optional default instructions for OpenAI grounded answers.",
+        getValue: (config) => getOpenAIAnswerOptions(config)?.instructions,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAIAnswerOptions(config),
+            "instructions",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiResearchModel",
+        label: "Research model",
+        help: "Model used for OpenAI deep research runs.",
+        getValue: (config) => getOpenAIResearchOptions(config)?.model,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAIResearchOptions(config),
+            "model",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiResearchInstructions",
+        label: "Research instructions",
+        help: "Optional default instructions for OpenAI deep research runs.",
+        getValue: (config) => getOpenAIResearchOptions(config)?.instructions,
+        setValue: (config, value) => {
+          assignOptionalString(
+            ensureOpenAIResearchOptions(config),
+            "instructions",
+            value
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      }),
+      stringSetting({
+        id: "openaiResearchMaxToolCalls",
+        label: "Research max tool calls",
+        help: "Optional default maximum number of built-in tool calls for OpenAI deep research runs.",
+        getValue: (config) => getIntegerString(getOpenAIResearchOptions(config)?.max_tool_calls),
+        setValue: (config, value) => {
+          assignOptionalInteger(
+            ensureOpenAIResearchOptions(config),
+            "max_tool_calls",
+            value,
+            "OpenAI research max tool calls must be a positive integer."
+          );
+          cleanupCapabilityOptions(config, ["search", "answer", "research"]);
+        }
+      })
     ]
   },
   perplexity: {
@@ -6373,7 +7261,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         label: "Search mode",
         help: "Parallel search mode. 'default' uses the SDK default.",
         values: ["default", "agentic", "one-shot"],
-        getValue: (config) => readString4(getParallelOptions(config)?.search?.mode) ?? "default",
+        getValue: (config) => readString5(getParallelOptions(config)?.search?.mode) ?? "default",
         setValue: (config, value) => {
           const options = ensureParallelOptions(config);
           options.search = asJsonObject2(options.search) ?? {};
@@ -6427,12 +7315,11 @@ var PROVIDER_CONFIG_MANIFESTS = {
       })
     ]
   },
+  serper: {
+    settings: [apiKeySetting(), baseUrlSetting()]
+  },
   tavily: {
-    settings: [
-      apiKeySetting(),
-      baseUrlSetting(),
-      ...requestSettings("tavily")
-    ]
+    settings: [apiKeySetting(), baseUrlSetting()]
   },
   valyu: {
     settings: [
@@ -6443,7 +7330,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         label: "Search type",
         help: "Valyu search type. 'default' uses the SDK default.",
         values: ["default", "all", "web", "proprietary", "news"],
-        getValue: (config) => readString4(getValyuCapabilityOptions(config, "search")?.searchType) ?? "default",
+        getValue: (config) => readString5(getValyuCapabilityOptions(config, "search")?.searchType) ?? "default",
         setValue: (config, value) => {
           const options = ensureValyuCapabilityOptions(config, "search");
           if (value === "default") {
@@ -6459,7 +7346,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         label: "Search response length",
         help: "Valyu search response length. 'default' uses the SDK default.",
         values: ["default", "short", "medium", "large", "max"],
-        getValue: (config) => readString4(
+        getValue: (config) => readString5(
           getValyuCapabilityOptions(config, "search")?.responseLength
         ) ?? "default",
         setValue: (config, value) => {
@@ -6471,7 +7358,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         label: "Answer response length",
         help: "Valyu answer response length. 'default' uses the SDK default.",
         values: ["default", "short", "medium", "large", "max"],
-        getValue: (config) => readString4(
+        getValue: (config) => readString5(
           getValyuCapabilityOptions(config, "answer")?.responseLength
         ) ?? "default",
         setValue: (config, value) => {
@@ -6483,7 +7370,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         label: "Research response length",
         help: "Valyu research response length. 'default' uses the SDK default.",
         values: ["default", "short", "medium", "large", "max"],
-        getValue: (config) => readString4(
+        getValue: (config) => readString5(
           getValyuCapabilityOptions(config, "research")?.responseLength
         ) ?? "default",
         setValue: (config, value) => {
@@ -6539,88 +7426,20 @@ function baseUrlSetting() {
     }
   });
 }
-function requestSettings(providerId) {
-  const settings = [
-    stringSetting({
-      id: "requestTimeoutMs",
-      label: "Request timeout (ms)",
-      help: "Maximum time to wait for each command before failing that attempt for this provider. Leave empty to inherit the shared setting.",
-      getValue: (config) => getIntegerString(config?.settings?.requestTimeoutMs),
-      setValue: (config, value) => {
-        assignOptionalInteger(
-          ensureSettings(config),
-          "requestTimeoutMs",
-          value,
-          "Request timeout must be a positive integer."
-        );
-        cleanupEmpty(config, "settings");
-      }
-    }),
-    stringSetting({
-      id: "retryCount",
-      label: "Retry count",
-      help: "How many times to retry transient command failures for this provider. Leave empty to inherit the shared setting.",
-      getValue: (config) => getIntegerString(config?.settings?.retryCount),
-      setValue: (config, value) => {
-        assignOptionalInteger(
-          ensureSettings(config),
-          "retryCount",
-          value,
-          "Retry count must be a non-negative integer.",
-          { allowZero: true }
-        );
-        cleanupEmpty(config, "settings");
-      }
-    }),
-    stringSetting({
-      id: "retryDelayMs",
-      label: "Retry delay (ms)",
-      help: "Initial delay before retrying command failures for this provider. Leave empty to inherit the shared setting.",
-      getValue: (config) => getIntegerString(config?.settings?.retryDelayMs),
-      setValue: (config, value) => {
-        assignOptionalInteger(
-          ensureSettings(config),
-          "retryDelayMs",
-          value,
-          "Retry delay must be a positive integer."
-        );
-        cleanupEmpty(config, "settings");
-      }
-    })
-  ];
-  if (supportsTool(providerId, "research")) {
-    settings.push(
-      stringSetting({
-        id: "researchTimeoutMs",
-        label: "Research timeout (ms)",
-        help: "Maximum total time to allow long-running web research for this provider before aborting it. Leave empty to inherit the shared setting.",
-        getValue: (config) => getIntegerString(config?.settings?.researchTimeoutMs),
-        setValue: (config, value) => {
-          assignOptionalInteger(
-            ensureSettings(config),
-            "researchTimeoutMs",
-            value,
-            "Research timeout must be a positive integer."
-          );
-          cleanupEmpty(config, "settings");
-        }
-      })
-    );
-  }
-  return settings;
-}
 function assignOptionalString(target, key, value) {
+  const record = target;
   const trimmed = value.trim();
   if (!trimmed) {
-    delete target[key];
+    delete record[key];
   } else {
-    target[key] = trimmed;
+    record[key] = trimmed;
   }
 }
 function assignOptionalInteger(target, key, value, errorMessage, options) {
+  const record = target;
   const trimmed = value.trim();
   if (!trimmed) {
-    delete target[key];
+    delete record[key];
     return;
   }
   const parsed = Number(trimmed);
@@ -6628,7 +7447,7 @@ function assignOptionalInteger(target, key, value, errorMessage, options) {
   if (!Number.isInteger(parsed) || parsed < minimum) {
     throw new Error(errorMessage);
   }
-  target[key] = parsed;
+  record[key] = parsed;
 }
 function assignOptionalBoolean(target, key, value) {
   if (value === "default") {
@@ -6643,16 +7462,12 @@ function getIntegerString(value) {
 function getBooleanValue(value) {
   return typeof value === "boolean" ? String(value) : "default";
 }
-function readString4(value) {
+function readString5(value) {
   return typeof value === "string" ? value : void 0;
 }
 function asJsonObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function ensureSettings(config) {
-  config.settings = { ...config.settings ?? {} };
-  return config.settings;
-}
 function cleanupEmpty(config, key) {
   const value = asJsonObject2(config[key]);
   if (value && Object.keys(value).length === 0) {
@@ -6817,6 +7632,36 @@ function ensureExaSearchOptions(config) {
   };
   return config.options.search;
 }
+function getOpenAISearchOptions(config) {
+  return config?.options?.search;
+}
+function ensureOpenAISearchOptions(config) {
+  config.options = {
+    ...config.options ?? {},
+    search: { ...config.options?.search ?? {} }
+  };
+  return config.options.search ?? (config.options.search = {});
+}
+function getOpenAIAnswerOptions(config) {
+  return config?.options?.answer;
+}
+function ensureOpenAIAnswerOptions(config) {
+  config.options = {
+    ...config.options ?? {},
+    answer: { ...config.options?.answer ?? {} }
+  };
+  return config.options.answer ?? (config.options.answer = {});
+}
+function getOpenAIResearchOptions(config) {
+  return config?.options?.research;
+}
+function ensureOpenAIResearchOptions(config) {
+  config.options = {
+    ...config.options ?? {},
+    research: { ...config.options?.research ?? {} }
+  };
+  return config.options.research ?? (config.options.research = {});
+}
 function getValyuCapabilityOptions(config, capability) {
   return config?.options?.[capability];
 }
@@ -6992,14 +7837,14 @@ 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: Type14.Object({
-      queries: Type14.Array(Type14.String({ minLength: 1 }), {
+    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: Type14.Optional(
-        Type14.Integer({
+      maxResults: Type16.Optional(
+        Type16.Integer({
           minimum: 1,
           maximum: MAX_ALLOWED_RESULTS,
           description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
@@ -7048,8 +7893,8 @@ function registerWebContentsTool(pi, providerIds) {
     name: "web_contents",
     label: "Web Contents",
     description: "Read and extract the main contents of one or more web pages. Batch related pages together, or use separate sibling calls when each page can be acted on independently.",
-    parameters: Type14.Object({
-      urls: Type14.Array(Type14.String({ minLength: 1 }), {
+    parameters: Type16.Object({
+      urls: Type16.Array(Type16.String({ minLength: 1 }), {
         minItems: 1,
         description: "One or more URLs to extract"
       }),
@@ -7099,8 +7944,8 @@ function registerWebAnswerTool(pi, providerIds) {
     name: "web_answer",
     label: "Web Answer",
     description: `Answer one or more questions using web-grounded evidence (up to ${MAX_SEARCH_QUERIES} per call).`,
-    parameters: Type14.Object({
-      queries: Type14.Array(Type14.String({ minLength: 1 }), {
+    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})`
@@ -7154,8 +7999,8 @@ function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
     name: "web_research",
     label: "Web Research",
     description: "Start a long-running web research job. Returns immediately with a dispatch notice; the final report is saved to a file and posted later as a custom message.",
-    parameters: Type14.Object({
-      input: Type14.String({ description: "Research brief or question" }),
+    parameters: Type16.Object({
+      input: Type16.String({ description: "Research brief or question" }),
       ...optionalField(
         "options",
         buildStructuredOptionsSchema("research", selectedProviderId)
@@ -7298,7 +8143,7 @@ function optionalField(name, schema) {
 function buildStructuredOptionsSchema(capability, providerId) {
   const providerSchema = resolveProviderOptionsSchema(capability, providerId);
   const schema = buildToolOptionsSchema(capability, providerSchema);
-  return schema ? Type14.Optional(schema) : void 0;
+  return schema ? Type16.Optional(schema) : void 0;
 }
 function resolveProviderOptionsSchema(capability, providerId) {
   if (!providerId) {
@@ -8606,7 +9451,7 @@ function getSharedSettingRawValue(config, id) {
   const value = config.settings?.[id];
   return typeof value === "number" ? String(value) : "";
 }
-function ensureSettings2(config) {
+function ensureSettings(config) {
   config.settings = { ...config.settings ?? {} };
   return config.settings;
 }
@@ -8951,7 +9796,7 @@ var WebProvidersSettingsView = class {
   async handleSharedSettingChange(id, value) {
     await this.persist((config) => {
       const parsed = SETTING_META[id].parse(value);
-      const settings = ensureSettings2(config);
+      const settings = ensureSettings(config);
       if (parsed === void 0) {
         delete settings[id];
       } else {