pi-web-providers 2.2.0 → 2.3.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 Type15 } from "@sinclair/typebox";
 
 // src/config.ts
 import { execSync } from "node:child_process";
@@ -41,8 +41,9 @@ 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"],
   tavily: ["search", "contents"],
   valyu: ["search", "contents", "answer", "research"]
 };
@@ -86,8 +87,9 @@ var PROVIDER_IDS = [
   "firecrawl",
   "gemini",
   "linkup",
-  "perplexity",
+  "openai",
   "parallel",
+  "perplexity",
   "tavily",
   "valyu"
 ];
@@ -271,6 +273,18 @@ 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":
@@ -4082,12 +4096,528 @@ function toDate(value, name) {
   return date;
 }
 
-// src/providers/parallel.ts
+// src/providers/openai.ts
 import { Type as Type10 } from "@sinclair/typebox";
+import OpenAI from "openai";
+var DEFAULT_SEARCH_MODEL2 = "gpt-4.1";
+var DEFAULT_ANSWER_MODEL2 = "gpt-4.1";
+var DEFAULT_RESEARCH_MODEL = "o4-mini-deep-research";
+var openaiSearchOptionsSchema = Type10.Object(
+  {
+    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: "OpenAI search options." }
+);
+var openaiAnswerOptionsSchema = Type10.Object(
+  {
+    model: Type10.Optional(
+      Type10.String({
+        description: "OpenAI model to use for grounded answers (for example 'gpt-4.1')."
+      })
+    ),
+    instructions: Type10.Optional(
+      Type10.String({
+        description: "Optional instructions that shape the answer structure, tone, and source selection."
+      })
+    )
+  },
+  { description: "OpenAI answer options." }
+);
+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 openaiSearchOptionsSchema;
+      case "answer":
+        return openaiAnswerOptionsSchema;
+      case "research":
+        return openaiResearchOptionsSchema;
+      default:
+        return void 0;
+    }
+  },
+  createTemplate() {
+    return {
+      apiKey: "OPENAI_API_KEY",
+      options: {
+        search: {
+          model: DEFAULT_SEARCH_MODEL2
+        },
+        answer: {
+          model: DEFAULT_ANSWER_MODEL2
+        },
+        research: {
+          model: DEFAULT_RESEARCH_MODEL
+        }
+      }
+    };
+  },
+  getConfigForCapability(capability, config) {
+    switch (capability) {
+      case "search":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.search,
+          settings: config.settings
+        };
+      case "answer":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.answer,
+          settings: config.settings
+        };
+      case "research":
+        return {
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          options: config.options?.research,
+          settings: config.settings
+        };
+      default:
+        return config;
+    }
+  },
+  getCapabilityStatus(config) {
+    return getApiKeyStatus(config?.apiKey);
+  },
+  buildPlan(request, config) {
+    return buildProviderPlan({
+      request,
+      config,
+      providerId: openaiAdapter.id,
+      providerLabel: openaiAdapter.label,
+      handlers: {
+        search: {
+          execute: (searchRequest, providerConfig, context) => openaiAdapter.search(
+            searchRequest.query,
+            searchRequest.maxResults,
+            providerConfig,
+            context,
+            searchRequest.options
+          )
+        },
+        answer: {
+          execute: (answerRequest, providerConfig, context) => openaiAdapter.answer(
+            answerRequest.query,
+            providerConfig,
+            context,
+            answerRequest.options
+          )
+        },
+        research: {
+          execute: (researchRequest, providerConfig, context) => openaiAdapter.research(
+            researchRequest.input,
+            providerConfig,
+            context,
+            researchRequest.options
+          )
+        }
+      }
+    });
+  },
+  async search(query2, maxResults, config, context, options) {
+    const client = createClient5(config);
+    const response = await client.responses.create(
+      buildOpenAISearchRequest(query2, maxResults, config, options),
+      buildRequestOptions2(context.signal, context.idempotencyKey)
+    );
+    return parseSearchResponse2(response, maxResults);
+  },
+  async answer(query2, config, context, options) {
+    const client = createClient5(config);
+    const response = await client.responses.create(
+      buildOpenAIAnswerRequest(query2, config, options),
+      buildRequestOptions2(context.signal, context.idempotencyKey)
+    );
+    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)
+    );
+    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 {
+      status: "in_progress",
+      statusText: status
+    };
+  }
+};
+function createClient5(config) {
+  const apiKey = resolveConfigValue(config.apiKey);
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  const baseUrl = resolveConfigValue(config.baseUrl);
+  return new OpenAI({
+    apiKey,
+    ...baseUrl ? { baseURL: baseUrl } : {}
+  });
+}
+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 } : {}
+  };
+}
+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 = Type10.Object(
+var parallelSearchOptionsSchema = Type11.Object(
   {
-    mode: Type10.Optional(
+    mode: Type11.Optional(
       literalUnion(["agentic", "one-shot"], {
         description: "Parallel search mode."
       })
@@ -4095,13 +4625,13 @@ var parallelSearchOptionsSchema = Type10.Object(
   },
   { description: "Parallel search options." }
 );
-var parallelExtractOptionsSchema = Type10.Object(
+var parallelExtractOptionsSchema = Type11.Object(
   {
-    excerpts: Type10.Optional(
-      Type10.Boolean({ description: "Include excerpts in extraction results." })
+    excerpts: Type11.Optional(
+      Type11.Boolean({ description: "Include excerpts in extraction results." })
     ),
-    full_content: Type10.Optional(
-      Type10.Boolean({
+    full_content: Type11.Optional(
+      Type11.Boolean({
         description: "Include full page content in extraction results."
       })
     )
@@ -4188,7 +4718,7 @@ var parallelAdapter = {
     });
   },
   async search(query2, maxResults, config, context, options) {
-    const client = createClient5(config);
+    const client = createClient6(config);
     const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.search)) ?? {};
     const response = await client.beta.search(
       {
@@ -4197,7 +4727,7 @@ var parallelAdapter = {
         objective: query2,
         max_results: maxResults
       },
-      buildRequestOptions2(context)
+      buildRequestOptions3(context)
     );
     return {
       provider: parallelAdapter.id,
@@ -4209,7 +4739,7 @@ var parallelAdapter = {
     };
   },
   async contents(urls, config, context, options) {
-    const client = createClient5(config);
+    const client = createClient6(config);
     const defaults = stripLocalExecutionOptions(asJsonObject(config.options?.extract)) ?? {};
     const response = await client.beta.extract(
       {
@@ -4217,7 +4747,7 @@ var parallelAdapter = {
         ...options ?? {},
         urls
       },
-      buildRequestOptions2(context)
+      buildRequestOptions3(context)
     );
     const resultsByUrl = new Map(
       response.results.map((result) => [result.url, result])
@@ -4248,7 +4778,7 @@ var parallelAdapter = {
     };
   }
 };
-function createClient5(config) {
+function createClient6(config) {
   const apiKey = resolveConfigValue(config.apiKey);
   if (!apiKey) {
     throw new Error("is missing an API key");
@@ -4258,48 +4788,48 @@ function createClient5(config) {
     baseURL: resolveConfigValue(config.baseUrl)
   });
 }
-function buildRequestOptions2(context) {
+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 Type11 } from "@sinclair/typebox";
-var DEFAULT_ANSWER_MODEL2 = "sonar";
-var DEFAULT_RESEARCH_MODEL = "sonar-deep-research";
-var perplexitySearchOptionsSchema = Type11.Object(
+import { Type as Type12 } from "@sinclair/typebox";
+var DEFAULT_ANSWER_MODEL3 = "sonar";
+var DEFAULT_RESEARCH_MODEL2 = "sonar-deep-research";
+var perplexitySearchOptionsSchema = Type12.Object(
   {
-    country: Type11.Optional(
-      Type11.String({ description: "Country hint for search results." })
+    country: Type12.Optional(
+      Type12.String({ description: "Country hint for search results." })
     ),
-    search_mode: Type11.Optional(
-      Type11.String({ description: "Perplexity search mode." })
+    search_mode: Type12.Optional(
+      Type12.String({ description: "Perplexity search mode." })
     ),
-    search_domain_filter: Type11.Optional(
-      Type11.Array(Type11.String(), {
+    search_domain_filter: Type12.Optional(
+      Type12.Array(Type12.String(), {
         description: "Restrict search results to these domains."
       })
     ),
-    search_recency_filter: Type11.Optional(
-      Type11.String({ description: "Recency filter for search results." })
+    search_recency_filter: Type12.Optional(
+      Type12.String({ description: "Recency filter for search results." })
     )
   },
   { description: "Perplexity search options." }
 );
-var perplexityAnswerOptionsSchema = Type11.Object(
+var perplexityAnswerOptionsSchema = Type12.Object(
   {
-    model: Type11.Optional(
-      Type11.String({
+    model: Type12.Optional(
+      Type12.String({
         description: "Perplexity model to use (for example 'sonar' or 'sonar-pro')."
       })
     )
   },
   { description: "Perplexity answer options." }
 );
-var perplexityResearchOptionsSchema = Type11.Object(
+var perplexityResearchOptionsSchema = Type12.Object(
   {
-    model: Type11.Optional(
-      Type11.String({
+    model: Type12.Optional(
+      Type12.String({
         description: "Perplexity model to use (for example 'sonar-deep-research')."
       })
     )
@@ -4328,10 +4858,10 @@ var perplexityAdapter = {
       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 +4905,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 +4914,7 @@ var perplexityAdapter = {
     };
     const response = await client.search.create(
       request,
-      buildRequestOptions3(context)
+      buildRequestOptions4(context)
     );
     return {
       provider: perplexityAdapter.id,
@@ -4404,7 +4934,7 @@ var perplexityAdapter = {
       query2,
       config,
       context,
-      DEFAULT_ANSWER_MODEL2,
+      DEFAULT_ANSWER_MODEL3,
       "Answer",
       options
     );
@@ -4414,14 +4944,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 +4964,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 +4985,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 +4996,7 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
   };
   const stream = await client.chat.completions.create(
     request,
-    buildRequestOptions3(context)
+    buildRequestOptions4(context)
   );
   let partialText = "";
   let lastChunk;
@@ -4496,7 +5026,7 @@ async function runStreamingForegroundChatTool(input, config, context, fallbackMo
     itemCount: dedupedSources.length
   };
 }
-function createClient6(config) {
+function createClient7(config) {
   const apiKey = resolveConfigValue(config.apiKey);
   if (!apiKey) {
     throw new Error("is missing an API key");
@@ -4573,60 +5103,60 @@ function extractSources(response) {
     return url ? [{ title: url, url }] : [];
   }) ?? [];
 }
-function buildRequestOptions3(context) {
+function buildRequestOptions4(context) {
   return context.signal ? { signal: context.signal } : void 0;
 }
 
 // src/providers/tavily.ts
-import { Type as Type12 } from "@sinclair/typebox";
+import { Type as Type13 } from "@sinclair/typebox";
 import {
   tavily
 } from "@tavily/core";
-var tavilySearchOptionsSchema = Type12.Object(
+var tavilySearchOptionsSchema = Type13.Object(
   {
-    topic: Type12.Optional(
+    topic: Type13.Optional(
       literalUnion(["general", "news", "finance"], {
         description: "Category of the search query."
       })
     ),
-    searchDepth: Type12.Optional(
+    searchDepth: Type13.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: Type13.Optional(
+      Type13.String({ description: "Named time range filter." })
     ),
-    country: Type12.Optional(
-      Type12.String({ description: "Country hint for search results." })
+    country: Type13.Optional(
+      Type13.String({ description: "Country hint for search results." })
     ),
-    exactMatch: Type12.Optional(
-      Type12.Boolean({ description: "Prefer exact matches." })
+    exactMatch: Type13.Optional(
+      Type13.Boolean({ description: "Prefer exact matches." })
     ),
-    includeAnswer: Type12.Optional(
-      Type12.Boolean({ description: "Include a short AI-generated answer." })
+    includeAnswer: Type13.Optional(
+      Type13.Boolean({ description: "Include a short AI-generated answer." })
     ),
-    includeRawContent: Type12.Optional(
-      Type12.Boolean({ description: "Include raw page content in results." })
+    includeRawContent: Type13.Optional(
+      Type13.Boolean({ description: "Include raw page content in results." })
     ),
-    includeImages: Type12.Optional(
-      Type12.Boolean({ description: "Include related images." })
+    includeImages: Type13.Optional(
+      Type13.Boolean({ description: "Include related images." })
     ),
-    includeFavicon: Type12.Optional(
-      Type12.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type13.Optional(
+      Type13.Boolean({ description: "Include favicon URLs." })
     ),
-    includeDomains: Type12.Optional(
-      Type12.Array(Type12.String(), {
+    includeDomains: Type13.Optional(
+      Type13.Array(Type13.String(), {
         description: "Restrict results to these domains."
       })
     ),
-    excludeDomains: Type12.Optional(
-      Type12.Array(Type12.String(), {
+    excludeDomains: Type13.Optional(
+      Type13.Array(Type13.String(), {
         description: "Exclude these domains from results."
       })
     ),
-    days: Type12.Optional(
-      Type12.Integer({
+    days: Type13.Optional(
+      Type13.Integer({
         minimum: 1,
         description: "Limit results to the last N days."
       })
@@ -4634,27 +5164,27 @@ var tavilySearchOptionsSchema = Type12.Object(
   },
   { description: "Tavily search options." }
 );
-var tavilyExtractOptionsSchema = Type12.Object(
+var tavilyExtractOptionsSchema = Type13.Object(
   {
-    extractDepth: Type12.Optional(
-      Type12.String({ description: "Depth setting for extraction." })
+    extractDepth: Type13.Optional(
+      Type13.String({ description: "Depth setting for extraction." })
     ),
-    format: Type12.Optional(
+    format: Type13.Optional(
       literalUnion(["markdown", "text"], {
         description: "Output format for extracted content."
       })
     ),
-    includeImages: Type12.Optional(
-      Type12.Boolean({ description: "Include extracted images." })
+    includeImages: Type13.Optional(
+      Type13.Boolean({ description: "Include extracted images." })
     ),
-    query: Type12.Optional(
-      Type12.String({ description: "Optional query to focus extraction." })
+    query: Type13.Optional(
+      Type13.String({ description: "Optional query to focus extraction." })
     ),
-    chunksPerSource: Type12.Optional(
-      Type12.Integer({ minimum: 1, description: "Maximum chunks per source." })
+    chunksPerSource: Type13.Optional(
+      Type13.Integer({ minimum: 1, description: "Maximum chunks per source." })
     ),
-    includeFavicon: Type12.Optional(
-      Type12.Boolean({ description: "Include favicon URLs." })
+    includeFavicon: Type13.Optional(
+      Type13.Boolean({ description: "Include favicon URLs." })
     )
   },
   { description: "Tavily extract options." }
@@ -4739,7 +5269,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 +5288,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 +5326,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 +5358,48 @@ function buildExtractMetadata(response, result) {
 }
 
 // src/providers/valyu.ts
-import { Type as Type13 } from "@sinclair/typebox";
+import { Type as Type14 } from "@sinclair/typebox";
 import { Valyu as ValyuClient } from "valyu-js";
-var valyuSearchOptionsSchema = Type13.Object(
+var valyuSearchOptionsSchema = Type14.Object(
   {
-    searchType: Type13.Optional(
+    searchType: Type14.Optional(
       literalUnion(["all", "web", "proprietary", "news"], {
         description: "Valyu search type."
       })
     ),
-    responseLength: Type13.Optional(
+    responseLength: Type14.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope search results." })
+    countryCode: Type14.Optional(
+      Type14.String({ description: "Country code to scope search results." })
     )
   },
   { description: "Valyu search options." }
 );
-var valyuAnswerOptionsSchema = Type13.Object(
+var valyuAnswerOptionsSchema = Type14.Object(
   {
-    responseLength: Type13.Optional(
+    responseLength: Type14.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for answers."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope answer results." })
+    countryCode: Type14.Optional(
+      Type14.String({ description: "Country code to scope answer results." })
     )
   },
   { description: "Valyu answer options." }
 );
-var valyuResearchOptionsSchema = Type13.Object(
+var valyuResearchOptionsSchema = Type14.Object(
   {
-    responseLength: Type13.Optional(
+    responseLength: Type14.Optional(
       literalUnion(["short", "medium", "large", "max"], {
         description: "Response length for research."
       })
     ),
-    countryCode: Type13.Optional(
-      Type13.String({ description: "Country code to scope research results." })
+    countryCode: Type14.Optional(
+      Type14.String({ description: "Country code to scope research results." })
     )
   },
   { description: "Valyu research options." }
@@ -4982,7 +5512,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 +5535,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 +5569,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 +5608,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 +5620,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 +5663,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 +5674,16 @@ 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,
   tavily: tavilyAdapter,
   valyu: valyuAdapter
 };
@@ -6226,8 +6757,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
         setValue: (config, value) => {
           setCustomEnv(config, "research", value);
         }
-      }),
-      ...requestSettings("custom")
+      })
     ]
   },
   exa: {
@@ -6355,10 +6885,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: {
@@ -6428,11 +7059,7 @@ var PROVIDER_CONFIG_MANIFESTS = {
     ]
   },
   tavily: {
-    settings: [
-      apiKeySetting(),
-      baseUrlSetting(),
-      ...requestSettings("tavily")
-    ]
+    settings: [apiKeySetting(), baseUrlSetting()]
   },
   valyu: {
     settings: [
@@ -6539,88 +7166,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 +7187,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") {
@@ -6649,10 +7208,6 @@ function readString4(value) {
 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 +7372,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 +7577,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: 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: Type14.Optional(
-        Type14.Integer({
+      maxResults: Type15.Optional(
+        Type15.Integer({
           minimum: 1,
           maximum: MAX_ALLOWED_RESULTS,
           description: `Maximum number of results to return (default: ${DEFAULT_MAX_RESULTS})`
@@ -7048,8 +7633,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: Type15.Object({
+      urls: Type15.Array(Type15.String({ minLength: 1 }), {
         minItems: 1,
         description: "One or more URLs to extract"
       }),
@@ -7099,8 +7684,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: Type15.Object({
+      queries: Type15.Array(Type15.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 +7739,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: Type15.Object({
+      input: Type15.String({ description: "Research brief or question" }),
       ...optionalField(
         "options",
         buildStructuredOptionsSchema("research", selectedProviderId)
@@ -7298,7 +7883,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 ? Type15.Optional(schema) : void 0;
 }
 function resolveProviderOptionsSchema(capability, providerId) {
   if (!providerId) {
@@ -8606,7 +9191,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 +9536,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 {