tau-all-agent 0.2.0 → 0.3.0

package/extensions/usage/README.md

@@ -0,0 +1,5 @@
+# Usage
+
+Run `/usage` for historical usage and supported providers' live quotas.
+
+Live Codex quotas require `openai-codex` credentials, not `/login openai` credentials. History works without quota access.

package/extensions/usage/index.ts

@@ -8,9 +8,11 @@ import {
   Key,
   matchesKey,
   type Component,
+  type KeybindingsManager,
   type TUI,
   truncateToWidth,
   visibleWidth,
+  wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 import { createHash } from "node:crypto";
 import { createReadStream, type Dirent } from "node:fs";
@@ -1599,15 +1601,11 @@ function formatUsageHeader(
   };
 }
 
-function renderUsageHeader(
-  plan: string | undefined,
-  fetchedAt: Date | undefined,
-  width: number,
-): string {
+function renderUsageHeader(plan: string | undefined, fetchedAt: Date | undefined): string {
   const header = formatUsageHeader(plan, fetchedAt);
   let text = bold(header.title);
   if (header.fetched) text += `  ${dim(header.fetched)}`;
-  return truncateToWidth(text, width);
+  return text;
 }
 
 type ResolvedLiveUsageState =
@@ -1669,31 +1667,25 @@ function renderLiveUsageLines(
 
   const resolved = resolveLiveUsageState(tab, liveState);
   if (resolved.kind === "loading") {
-    return [truncateToWidth(`${bold("Usage")} ${dim(resolved.message)}`, width)];
+    return [`${bold("Usage")} ${dim(resolved.message)}`];
   }
 
   const lines: string[] = [
     renderUsageHeader(
       resolved.kind === "ok" ? resolved.snapshot.plan : undefined,
       resolved.kind === "ok" ? resolved.snapshot.fetchedAt : undefined,
-      width,
     ),
   ];
   if (resolved.kind === "message") {
     const message =
       resolved.tone === "error" ? ansiFg(ERROR_COLOR, resolved.message) : dim(resolved.message);
-    lines.push(truncateToWidth(message, width));
+    lines.push(message);
     return lines;
   }
 
   for (const item of resolved.snapshot.items) {
     lines.push("");
-    lines.push(
-      truncateToWidth(
-        formatLiveUsageItemLine(item, { dimReset: true, emphasizeStatValue: true }),
-        width,
-      ),
-    );
+    lines.push(formatLiveUsageItemLine(item, { dimReset: true, emphasizeStatValue: true }));
     if (item.kind === "meter" && tab.liveProvider) {
       lines.push(renderUsageMeterBar(tab.liveProvider.id, item, width));
     }
@@ -1752,12 +1744,17 @@ class UsageBreakdownComponent implements Component {
   private rangeIndex = 1;
   private measurement: MeasurementMode = "tokens";
   private view: BreakdownView = "model";
+  private renderWidth?: number;
   private cachedWidth?: number;
   private cachedLines?: string[];
+  private scrollOffset = 0;
+  private viewportHeight = 0;
+  private maxScroll = 0;
 
   constructor(
     data: BreakdownData,
     tui: TUI,
+    private readonly keybindings: KeybindingsManager,
     onDone: () => void,
     loadLiveUsage: (
       provider: UsageProviderDefinition,
@@ -1771,55 +1768,6 @@ class UsageBreakdownComponent implements Component {
     this.ensureLiveUsageLoaded();
   }
 
-  private async close(): Promise<void> {
-    if (this.closing) return;
-    this.closing = true;
-    for (const controller of this.liveUsageControllers.values()) {
-      controller.abort();
-    }
-    await Promise.allSettled(this.liveUsageRequests.values());
-    this.onDone();
-  }
-
-  private ensureLiveUsageLoaded(): void {
-    const tab = this.data.tabs[this.tabIndex];
-    const provider = tab?.liveProvider;
-    if (!provider) return;
-
-    const current = this.data.liveUsage.get(provider.id);
-    if (current && current.status !== "loading") return;
-    if (this.liveUsageRequests.has(provider.id)) return;
-
-    const controller = new AbortController();
-    this.liveUsageControllers.set(provider.id, controller);
-    this.data.liveUsage.set(provider.id, { status: "loading" });
-    this.invalidate();
-    this.tui.requestRender();
-
-    const request = this.loadLiveUsage(provider, controller.signal)
-      .then((state) => {
-        if (controller.signal.aborted) return;
-        this.data.liveUsage.set(provider.id, state);
-      })
-      .catch((error) => {
-        if (controller.signal.aborted) return;
-        this.data.liveUsage.set(provider.id, {
-          status: "error",
-          error: error instanceof Error ? error.message : String(error),
-        });
-      })
-      .finally(() => {
-        this.liveUsageRequests.delete(provider.id);
-        this.liveUsageControllers.delete(provider.id);
-        if (!controller.signal.aborted) {
-          this.invalidate();
-          this.tui.requestRender();
-        }
-      });
-
-    this.liveUsageRequests.set(provider.id, request);
-  }
-
   invalidate(): void {
     this.cachedWidth = undefined;
     this.cachedLines = undefined;
@@ -1836,6 +1784,29 @@ class UsageBreakdownComponent implements Component {
       return;
     }
 
+    const width = Math.min(
+      this.renderWidth ?? this.tui.terminal.columns - 2,
+      this.tui.terminal.columns - 2,
+    );
+    if (width < 24 || this.tui.terminal.rows < 7) return;
+
+    const scrollActions = [
+      ["tui.altScreen.pageUp", -this.viewportHeight],
+      ["tui.altScreen.pageDown", this.viewportHeight],
+      ["tui.altScreen.halfPageUp", -Math.max(1, Math.floor(this.viewportHeight / 2))],
+      ["tui.altScreen.halfPageDown", Math.max(1, Math.floor(this.viewportHeight / 2))],
+      ["tui.altScreen.lineUp", -1],
+      ["tui.altScreen.lineDown", 1],
+      ["tui.altScreen.top", -Infinity],
+      ["tui.altScreen.bottom", Infinity],
+    ] as const;
+    for (const [action, delta] of scrollActions) {
+      if (!this.keybindings.matches(data, action)) continue;
+      this.scrollOffset = Math.max(0, Math.min(this.maxScroll, this.scrollOffset + delta));
+      this.tui.requestRender();
+      return;
+    }
+
     if (
       matchesKey(data, Key.tab) ||
       matchesKey(data, Key.shift("tab")) ||
@@ -1845,6 +1816,7 @@ class UsageBreakdownComponent implements Component {
       const index = Math.max(0, order.indexOf(this.measurement));
       const direction = matchesKey(data, Key.shift("tab")) ? -1 : 1;
       this.measurement = order[(index + order.length + direction) % order.length] ?? "tokens";
+      this.scrollOffset = 0;
       this.invalidate();
       this.tui.requestRender();
       return;
@@ -1858,6 +1830,7 @@ class UsageBreakdownComponent implements Component {
     ) {
       const direction = matchesKey(data, Key.left) || data.toLowerCase() === "h" ? -1 : 1;
       this.rangeIndex = (this.rangeIndex + RANGE_DAYS.length + direction) % RANGE_DAYS.length;
+      this.scrollOffset = 0;
       this.invalidate();
       this.tui.requestRender();
       return;
@@ -1866,6 +1839,7 @@ class UsageBreakdownComponent implements Component {
     if (data === "[" || data === "]" || data.toLowerCase() === "p" || data.toLowerCase() === "n") {
       const direction = data === "[" || data.toLowerCase() === "p" ? -1 : 1;
       this.tabIndex = (this.tabIndex + this.data.tabs.length + direction) % this.data.tabs.length;
+      this.scrollOffset = 0;
       this.ensureLiveUsageLoaded();
       this.invalidate();
       this.tui.requestRender();
@@ -1882,6 +1856,7 @@ class UsageBreakdownComponent implements Component {
       const index = views.indexOf(this.view);
       const direction = matchesKey(data, Key.up) || data.toLowerCase() === "k" ? -1 : 1;
       this.view = views[(index + views.length + direction) % views.length] ?? "model";
+      this.scrollOffset = 0;
       this.invalidate();
       this.tui.requestRender();
       return;
@@ -1890,12 +1865,93 @@ class UsageBreakdownComponent implements Component {
     const rangeByKey: Record<string, number> = { "1": 0, "2": 1, "3": 2 };
     if (Object.hasOwn(rangeByKey, data)) {
       this.rangeIndex = rangeByKey[data]!;
+      this.scrollOffset = 0;
       this.invalidate();
       this.tui.requestRender();
     }
   }
 
   render(width: number): string[] {
+    this.renderWidth = width;
+    const height = Math.max(0, this.tui.terminal.rows - 2);
+    // Four chrome rows plus at least one document row. Margins are supplied by the overlay.
+    if (height < 5 || width < 24) {
+      this.viewportHeight = 0;
+      return ["q close · resize", "Usage needs 26×7"]
+        .slice(0, height)
+        .map((line) => truncateToWidth(line, width));
+    }
+    const document = this.renderDocument(width);
+    const body = document.slice(2);
+    this.viewportHeight = height - 4;
+    this.maxScroll = Math.max(0, body.length - this.viewportHeight);
+    this.scrollOffset = Math.min(this.scrollOffset, this.maxScroll);
+    const visible = body.slice(this.scrollOffset, this.scrollOffset + this.viewportHeight);
+    const keys = (action: "pageUp" | "pageDown") =>
+      this.keybindings.getKeys(`tui.altScreen.${action}`).join("/") || "unbound";
+    return [
+      ...document.slice(0, 2),
+      ...visible,
+      truncateToWidth(dim(`${keys("pageUp")}/${keys("pageDown")} scroll`), width),
+      truncateToWidth(
+        dim(
+          `q close · ${this.scrollOffset + 1}–${this.scrollOffset + visible.length}/${body.length}`,
+        ),
+        width,
+      ),
+    ];
+  }
+
+  private async close(): Promise<void> {
+    if (this.closing) return;
+    this.closing = true;
+    for (const controller of this.liveUsageControllers.values()) {
+      controller.abort();
+    }
+    await Promise.allSettled(this.liveUsageRequests.values());
+    this.onDone();
+  }
+
+  private ensureLiveUsageLoaded(): void {
+    const tab = this.data.tabs[this.tabIndex];
+    const provider = tab?.liveProvider;
+    if (!provider) return;
+
+    const current = this.data.liveUsage.get(provider.id);
+    if (current && current.status !== "loading") return;
+    if (this.liveUsageRequests.has(provider.id)) return;
+
+    const controller = new AbortController();
+    this.liveUsageControllers.set(provider.id, controller);
+    this.data.liveUsage.set(provider.id, { status: "loading" });
+    this.invalidate();
+    this.tui.requestRender();
+
+    const request = this.loadLiveUsage(provider, controller.signal)
+      .then((state) => {
+        if (controller.signal.aborted) return;
+        this.data.liveUsage.set(provider.id, state);
+      })
+      .catch((error) => {
+        if (controller.signal.aborted) return;
+        this.data.liveUsage.set(provider.id, {
+          status: "error",
+          error: error instanceof Error ? error.message : String(error),
+        });
+      })
+      .finally(() => {
+        this.liveUsageRequests.delete(provider.id);
+        this.liveUsageControllers.delete(provider.id);
+        if (!controller.signal.aborted) {
+          this.invalidate();
+          this.tui.requestRender();
+        }
+      });
+
+    this.liveUsageRequests.set(provider.id, request);
+  }
+
+  private renderDocument(width: number): string[] {
     if (this.cachedWidth === width && this.cachedLines) return this.cachedLines;
 
     const tab = this.data.tabs[this.tabIndex]!;
@@ -1938,26 +1994,25 @@ class UsageBreakdownComponent implements Component {
       `${viewTab("model", "model")}${viewTab("cwd", "cwd")}${viewTab("dow", "dow")}${viewTab("tod", "tod")}`;
 
     const lines: string[] = [];
-    lines.push(truncateToWidth(header, width));
-    lines.push(
-      truncateToWidth(dim("[/] provider · ←/→ range · ↑/↓ view · tab metric · q to close"), width),
-    );
-    lines.push(truncateToWidth(`${bold(tab.label)}  ${dim(historySemanticsText(tab))}`, width));
+    const compactHeader = `${bold("Usage")}  ${providerBadge} [${selectedDays}d] [${this.measurement === "sessions" ? "sess" : this.measurement === "messages" ? "msg" : "tok"}] [${this.view}]`;
+    lines.push(truncateToWidth(visibleWidth(header) <= width ? header : compactHeader, width));
+    const navigation = dim("[/] provider · ←/→ range · ↑/↓ view · tab metric · q to close");
+    lines.push(truncateToWidth(navigation, width));
+    if (visibleWidth(compactHeader) > width) lines.push(compactHeader);
+    if (visibleWidth(navigation) > width) lines.push(navigation);
+    lines.push(`${bold(tab.label)}  ${dim(historySemanticsText(tab))}`);
     lines.push("");
 
     const liveLines = renderLiveUsageLines(tab, liveState, width);
     if (liveLines.length > 0) {
-      for (const line of liveLines) lines.push(truncateToWidth(line, width));
+      lines.push(...liveLines);
       lines.push("");
     }
 
     const graphDescriptor =
       this.view === "dow" ? `share of ${metric.kind} by weekday` : `${metric.kind}/day`;
     lines.push(
-      truncateToWidth(
-        `${rangeSummary(range, selectedDays, metric.kind)}${dim(`   (graph: ${graphDescriptor})`)}`,
-        width,
-      ),
+      `${rangeSummary(range, selectedDays, metric.kind)}${dim(`   (graph: ${graphDescriptor})`)}`,
     );
     lines.push("");
 
@@ -2078,16 +2133,19 @@ class UsageBreakdownComponent implements Component {
             : this.view === "cwd"
               ? "Top directories (30d palette):"
               : "Time of day:";
-        lines.push(truncateToWidth(dim(legendTitle), width));
-        for (const item of legendItems) lines.push(truncateToWidth(item, width));
+        lines.push(dim(legendTitle));
+        lines.push(...legendItems);
       }
     }
 
     lines.push("");
-    for (const line of tableLines) lines.push(truncateToWidth(line, width));
+    lines.push(...tableLines);
 
     this.cachedWidth = width;
-    this.cachedLines = lines;
+    this.cachedLines = [
+      ...lines.slice(0, 2),
+      ...lines.slice(2).flatMap((line) => wrapTextWithAnsi(line, width)),
+    ];
     return this.cachedLines;
   }
 }
@@ -2197,10 +2255,11 @@ export default function usageBreakdownExtension(pi: ExtensionAPI) {
       }
 
       await ctx.ui.custom<void>(
-        (tui, _theme, _kb, done) =>
-          new UsageBreakdownComponent(data, tui, done, (provider, signal) =>
+        (tui, _theme, keybindings, done) =>
+          new UsageBreakdownComponent(data, tui, keybindings, done, (provider, signal) =>
             fetchLiveUsageForProvider(provider, liveUsageAvailability, ctx, signal),
           ),
+        { overlay: true, overlayOptions: { width: "100%", maxHeight: "100%", margin: 1 } },
       );
     },
   });

package/extensions/websearch/README.md

@@ -8,7 +8,14 @@ Optionally create `websearch.json` in your Pi agent directory (normally `~/.pi/a
 
 ```json
 {
-  "routes": ["pi:openai-codex", "pi:anthropic", "pi:gemini", "firefox:gemini", "chromium:gemini"],
+  "routes": [
+    "pi:openai-codex",
+    "pi:openai",
+    "pi:anthropic",
+    "pi:gemini",
+    "firefox:gemini",
+    "chromium:gemini"
+  ],
   "profiles": {
     "firefox": "default-release",
     "chromium": "Default"

package/extensions/websearch/config.ts

@@ -8,6 +8,7 @@ const WEBSEARCH_CONFIG_PATH = path.join(getAgentDir(), "websearch.json");
 
 const DEFAULT_ROUTES: WebsearchRouteId[] = [
   "pi:openai-codex",
+  "pi:openai",
   "pi:anthropic",
   "pi:gemini",
   "firefox:gemini",
@@ -26,7 +27,7 @@ function sanitizeRoutes(value: unknown): WebsearchRouteId[] {
   for (const item of value) {
     if (item === "firefox:openai-codex" || item === "chromium:openai-codex") {
       throw new Error(
-        `Invalid websearch route: ${item} (removed). Use pi:openai-codex and sign in with Pi /login.`,
+        `Invalid websearch route: ${item} (removed). Use pi:openai-codex or pi:openai and sign in with Pi /login.`,
       );
     }
     if (typeof item !== "string" || !valid.has(item as WebsearchRouteId)) {

package/extensions/websearch/index.ts

@@ -19,7 +19,11 @@ import { limitOutput } from "./output.js";
 import { isPiAnthropicModel, searchWithPiAnthropic } from "./providers/anthropic.pi.js";
 import { browserGemini } from "./providers/gemini.browser.js";
 import { isPiGeminiModel, searchWithPiGemini } from "./providers/gemini.pi.js";
-import { isPiOpenAICodexModel, searchWithPiOpenAICodex } from "./providers/openai-codex.pi.js";
+import {
+  isPiOpenAICodexModel,
+  isPiOpenAIModel,
+  searchWithPiOpenAI,
+} from "./providers/openai.pi.js";
 import type { PiModelSelection } from "./providers/pi-model.shared.js";
 import { getPiModelCandidates, selectNextPiModel } from "./providers/pi-model.shared.js";
 import { isModelUnavailableError } from "./providers/shared.js";
@@ -37,8 +41,13 @@ type PiRouteId = `pi:${WebsearchBackendId}`;
 const PI_ROUTE_HANDLERS: Record<PiRouteId, PiRouteHandler> = {
   "pi:openai-codex": {
     predicate: isPiOpenAICodexModel,
-    search: searchWithPiOpenAICodex,
-    fallbackModels: ["gpt-5.6-luna", "gpt-5.5"],
+    search: searchWithPiOpenAI,
+    fallbackModels: ["gpt-6-luna", "gpt-6.1-sol"],
+  },
+  "pi:openai": {
+    predicate: isPiOpenAIModel,
+    search: searchWithPiOpenAI,
+    fallbackModels: ["gpt-6-luna", "gpt-6.1-sol"],
   },
   "pi:anthropic": {
     predicate: isPiAnthropicModel,
@@ -246,24 +255,24 @@ export default function (pi: ExtensionAPI) {
         query: Type.String({ description: "What to search for" }),
       }),
       renderShell: "self",
-      renderCall(args, theme) {
-        return new Text(formatWebsearchCall(args.query, theme), 0, 0);
+      renderCall(args, theme, { outputPad }) {
+        return new Text(formatWebsearchCall(args.query, theme), outputPad, 0);
       },
-      renderResult(result, { expanded }, theme) {
+      renderResult(result, { expanded }, theme, { outputPad }) {
         const content = result.content.find((item) => item.type === "text");
         const text = content?.type === "text" ? content.text : "";
 
         if (!expanded) {
-          return new Text(formatCollapsedWebsearchResult(text, theme), 0, 0);
+          return new Text(formatCollapsedWebsearchResult(text, theme), outputPad, 0);
         }
 
         if (!text.trim()) {
-          return new Text(`\n${theme.fg("muted", "(no output)")}`, 0, 0);
+          return new Text(`\n${theme.fg("muted", "(no output)")}`, outputPad, 0);
         }
 
         const container = new Container();
         container.addChild(new Spacer(1));
-        container.addChild(new Markdown(text.trim(), 0, 0, getMarkdownTheme()));
+        container.addChild(new Markdown(text.trim(), outputPad, 0, getMarkdownTheme()));
         return container;
       },
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/extensions/websearch/providers/{openai-codex.pi.ts → openai.pi.ts}

@@ -6,19 +6,20 @@ import type { PiModelSelection } from "./pi-model.shared.js";
 import { buildWebsearchPrompt, WEBSEARCH_SYSTEM_PROMPT } from "./search-prompt.shared.js";
 import { applyResolvedHeaders, getResolvedHeader, readEventStream, withTimeout } from "./shared.js";
 
-export async function searchWithPiOpenAICodex(
+export async function searchWithPiOpenAI(
   selection: PiModelSelection,
   query: string,
   signal?: AbortSignal,
 ): Promise<WebsearchResult> {
   const apiKey = resolveApiKey(selection);
   if (!apiKey) {
-    throw new Error("OpenAI Codex auth is not configured.");
+    throw new Error("OpenAI auth is not configured.");
   }
 
-  const result = await runOpenAICodexSearch({
+  const backend = selection.model.provider === "openai-codex" ? "openai-codex" : "openai";
+  const result = await runOpenAISearch({
     apiKey,
-    accountId: decodeJwtAccountId(apiKey),
+    backend,
     model: selection.model.id,
     query,
     baseUrl: selection.model.baseUrl,
@@ -27,13 +28,17 @@ export async function searchWithPiOpenAICodex(
   });
 
   return {
-    backend: "openai-codex",
+    backend,
     authSource: "pi",
     answer: result.answer,
     sources: result.sources,
   };
 }
 
+export function isPiOpenAIModel(model: Model<Api>): boolean {
+  return model.api === "openai-responses" && model.provider === "openai";
+}
+
 export function isPiOpenAICodexModel(model: Model<Api>): boolean {
   return model.api === "openai-codex-responses" && model.provider === "openai-codex";
 }
@@ -48,25 +53,27 @@ function resolveApiKey(selection: PiModelSelection): string | undefined {
   return match?.[1];
 }
 
-async function runOpenAICodexSearch(options: {
+async function runOpenAISearch(options: {
   apiKey: string;
+  backend: "openai" | "openai-codex";
   model: string;
   query: string;
   baseUrl?: string;
-  accountId?: string;
   headers?: Record<string, string | null>;
   signal?: AbortSignal;
 }): Promise<{ answer: string; sources: WebsearchSource[] }> {
-  const response = await fetch(resolveCodexUrl(options.baseUrl), {
+  const codex = options.backend === "openai-codex";
+  const accountId = codex ? decodeJwtAccountId(options.apiKey) : undefined;
+  const url = codex ? resolveCodexUrl(options.baseUrl) : resolveResponsesUrl(options.baseUrl);
+  const response = await fetch(url, {
     method: "POST",
     headers: applyResolvedHeaders(
       {
         authorization: `Bearer ${options.apiKey}`,
-        ...(options.accountId ? { "chatgpt-account-id": options.accountId } : {}),
+        ...(accountId ? { "chatgpt-account-id": accountId } : {}),
         "content-type": "application/json",
         accept: "text/event-stream",
-        "OpenAI-Beta": "responses=experimental",
-        originator: "pi-websearch",
+        ...(codex ? { "OpenAI-Beta": "responses=experimental", originator: "pi-websearch" } : {}),
       },
       options.headers,
     ),
@@ -82,6 +89,7 @@ async function runOpenAICodexSearch(options: {
     signal: withTimeout(options.signal, 120_000),
   });
 
+  const sources: WebsearchSource[] = [];
   let answer = "";
   let fallbackAnswer = "";
   let completed = false;
@@ -110,6 +118,7 @@ async function runOpenAICodexSearch(options: {
           .filter((text): text is string => typeof text === "string")
           .join("\n");
         if (fullText) fallbackAnswer = fullText;
+        sources.push(...extractAnnotationSources(content));
       }
 
       if (
@@ -119,7 +128,7 @@ async function runOpenAICodexSearch(options: {
       ) {
         const result = event.response as Record<string, unknown> | undefined;
         if (event.type === "response.incomplete" || result?.status !== "completed") {
-          throw new Error("OpenAI Codex search did not complete successfully.");
+          throw new Error("OpenAI search did not complete successfully.");
         }
         completed = true;
       }
@@ -137,7 +146,7 @@ async function runOpenAICodexSearch(options: {
             throw new Error((error as Record<string, unknown>).message as string);
           }
         }
-        throw new Error(eventMessage ?? "OpenAI Codex search failed.");
+        throw new Error(eventMessage ?? "OpenAI search failed.");
       }
     } catch (error) {
       if (error instanceof SyntaxError) return;
@@ -146,20 +155,46 @@ async function runOpenAICodexSearch(options: {
   });
 
   if (!completed) {
-    throw new Error("OpenAI Codex stream ended before search completed.");
+    throw new Error("OpenAI stream ended before search completed.");
   }
 
   const finalAnswer = (answer || fallbackAnswer).trim();
   if (!finalAnswer) {
-    throw new Error("OpenAI Codex returned an empty response.");
+    throw new Error("OpenAI returned an empty response.");
   }
 
   return {
     answer: finalAnswer,
-    sources: dedupeSources(extractMarkdownSources(finalAnswer)),
+    sources: dedupeSources([...sources, ...extractMarkdownSources(finalAnswer)]),
   };
 }
 
+function extractAnnotationSources(content: unknown[]): WebsearchSource[] {
+  const sources: WebsearchSource[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object" || !("annotations" in part)) continue;
+    if (!Array.isArray(part.annotations)) continue;
+    for (const annotation of part.annotations) {
+      if (
+        annotation?.type !== "url_citation" ||
+        typeof annotation.url !== "string" ||
+        !/^https?:\/\//i.test(annotation.url)
+      )
+        continue;
+      sources.push({
+        url: annotation.url,
+        title: typeof annotation.title === "string" ? annotation.title : "",
+      });
+    }
+  }
+  return sources;
+}
+
+function resolveResponsesUrl(baseUrl?: string): string {
+  const normalized = (baseUrl || "https://api.openai.com/v1").replace(/\/+$/, "");
+  return normalized.endsWith("/responses") ? normalized : `${normalized}/responses`;
+}
+
 function resolveCodexUrl(baseUrl = "https://chatgpt.com/backend-api"): string {
   const normalized = String(baseUrl || "https://chatgpt.com/backend-api").replace(/\/+$/, "");
   if (normalized.endsWith("/codex/responses")) return normalized;

package/extensions/websearch/providers/shared.ts

@@ -7,15 +7,22 @@ export function isModelUnavailableError(error: unknown, model: Model<Api>): bool
   if (!isRecord(error.body)) return false;
 
   const detail = isRecord(error.body.error) ? error.body.error : undefined;
-  if (model.provider === "openai-codex" && model.api === "openai-codex-responses") {
+  const codex = model.provider === "openai-codex" && model.api === "openai-codex-responses";
+  const openai = model.provider === "openai" && model.api === "openai-responses";
+  if (codex || openai) {
     return (
-      (error.status === 400 &&
+      (codex &&
+        error.status === 400 &&
         Boolean(model.id) &&
         error.body.detail ===
           `The '${model.id}' model is not supported when using Codex with a ChatGPT account.`) ||
       detail?.code === "model_not_found" ||
       detail?.code === "model_not_supported" ||
-      detail?.code === "unsupported_model"
+      detail?.code === "unsupported_model" ||
+      (openai &&
+        error.status === 400 &&
+        detail?.code === "subscription_sharing_unsupported_capability" &&
+        detail.param === "model")
     );
   }
 

package/extensions/websearch/types.ts

@@ -1,8 +1,9 @@
-export type WebsearchBackendId = "openai-codex" | "anthropic" | "gemini";
+export type WebsearchBackendId = "openai-codex" | "openai" | "anthropic" | "gemini";
 export type WebsearchAuthSource = "pi" | "firefox" | "chromium";
 export type WebsearchBrowserFamily = "firefox" | "chromium";
 export type WebsearchRouteId =
   | "pi:openai-codex"
+  | "pi:openai"
   | "pi:anthropic"
   | "pi:gemini"
   | "firefox:gemini"