tau-coding-agent 0.1.5 → 0.2.0

package/extensions/websearch/providers/gemini.browser.ts

@@ -1,3 +1,5 @@
+import undici, { EnvHttpProxyAgent, type Dispatcher, type RequestInit } from "undici";
+
 import type { BrowserCookie, BrowserSession, WebsearchResult } from "../types.js";
 import {
   browserHeaders,
@@ -7,13 +9,11 @@ import {
   hasCookie,
 } from "../normalize.js";
 import { buildWebsearchPrompt } from "./search-prompt.shared.js";
-import { fetchText, withTimeout } from "./shared.js";
+import { withTimeout } from "./shared.js";
 
 const GEMINI_APP_URL = "https://gemini.google.com/app";
 const GEMINI_STREAM_GENERATE_URL =
   "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
-const GOOGLE_LIST_ACCOUNTS_URL =
-  "https://accounts.google.com/ListAccounts?gpsia=1&source=ChromiumBrowser&laf=b64bin&json=standard";
 const REQUIRED_COOKIE_NAMES = ["__Secure-1PSID", "__Secure-1PSIDTS"];
 
 export const browserGemini = {
@@ -30,27 +30,25 @@ export const browserGemini = {
       }
     }
 
-    const accessToken = await fetchAccessToken(session.cookies, signal);
-    let accountLabel: string | null | undefined;
-    void getActiveGoogleEmail(session.cookies, signal)
-      .then((value) => {
-        accountLabel = value;
-      })
-      .catch(() => {
-        accountLabel = null;
-      });
-
-    const answer = await queryGemini(query, session.cookies, accessToken, signal);
-
-    return {
-      backend: "gemini",
-      authSource: session.profile.family,
-      browserName: session.profile.browserName,
-      profile: session.profile.profileName,
-      accountLabel: accountLabel ?? undefined,
-      answer,
-      sources: dedupeSources(extractMarkdownSources(answer)),
-    };
+    const dispatcher = new EnvHttpProxyAgent({
+      maxHeaderSize: 64 * 1024,
+      allowH2: false,
+      proxyTunnel: true,
+    });
+    try {
+      const accessToken = await fetchAccessToken(session.cookies, dispatcher, signal);
+      const answer = await queryGemini(query, session.cookies, accessToken, dispatcher, signal);
+      return {
+        backend: "gemini",
+        authSource: session.profile.family,
+        browserName: session.profile.browserName,
+        profile: session.profile.profileName,
+        answer,
+        sources: dedupeSources(extractMarkdownSources(answer)),
+      };
+    } finally {
+      await dispatcher.close();
+    }
   },
 };
 
@@ -58,6 +56,7 @@ async function queryGemini(
   query: string,
   cookies: BrowserCookie[],
   accessToken: string,
+  dispatcher: Dispatcher,
   signal?: AbortSignal,
 ): Promise<string> {
   const body = new URLSearchParams();
@@ -67,7 +66,7 @@ async function queryGemini(
     JSON.stringify([null, JSON.stringify([[buildWebsearchPrompt(query)], null, null])]),
   );
 
-  const rawText = await fetchText(GEMINI_STREAM_GENERATE_URL, {
+  const rawText = await fetchGeminiText(GEMINI_STREAM_GENERATE_URL, dispatcher, {
     method: "POST",
     headers: {
       ...browserHeaders({
@@ -83,16 +82,15 @@ async function queryGemini(
     signal: withTimeout(signal, 120_000),
   });
 
-  const parsed = parseGeminiResponse(rawText);
-  if (!parsed.trim()) {
-    throw new Error("Gemini Web returned an empty response.");
-  }
-
-  return parsed.trim();
+  return parseGeminiResponse(rawText);
 }
 
-async function fetchAccessToken(cookies: BrowserCookie[], signal?: AbortSignal): Promise<string> {
-  const html = await fetchText(GEMINI_APP_URL, {
+async function fetchAccessToken(
+  cookies: BrowserCookie[],
+  dispatcher: Dispatcher,
+  signal?: AbortSignal,
+): Promise<string> {
+  const html = await fetchGeminiText(GEMINI_APP_URL, dispatcher, {
     headers: browserHeaders({
       cookieHeader: buildCookieHeader(GEMINI_APP_URL, cookies),
       origin: "https://gemini.google.com",
@@ -110,24 +108,17 @@ async function fetchAccessToken(cookies: BrowserCookie[], signal?: AbortSignal):
   throw new Error("Could not authenticate with Gemini Web.");
 }
 
-async function getActiveGoogleEmail(
-  cookies: BrowserCookie[],
-  signal?: AbortSignal,
-): Promise<string | null> {
-  try {
-    const response = await fetchText(GOOGLE_LIST_ACCOUNTS_URL, {
-      headers: browserHeaders({
-        cookieHeader: buildCookieHeader(GOOGLE_LIST_ACCOUNTS_URL, cookies),
-        origin: "https://accounts.google.com",
-        referer: "https://accounts.google.com/",
-      }),
-      signal: withTimeout(signal, 10_000),
-    });
-
-    return findFirstEmail(response);
-  } catch {
-    return null;
+async function fetchGeminiText(
+  url: string,
+  dispatcher: Dispatcher,
+  options: RequestInit,
+): Promise<string> {
+  const response = await undici.fetch(url, { ...options, dispatcher });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
   }
+  return text;
 }
 
 function parseGeminiResponse(rawText: string): string {
@@ -140,29 +131,39 @@ function parseGeminiResponse(rawText: string): string {
   const responseJson = JSON.parse(rawText.slice(start, end + 1));
   const parts = Array.isArray(responseJson) ? responseJson : [];
 
+  let answer: string | undefined;
+  let completed = false;
   for (const part of parts) {
+    const errorCode = getNestedValue(part, [5, 2, 0, 1, 0]);
+    if (getNestedValue(part, [0]) === "er" || (typeof errorCode === "number" && errorCode !== 0)) {
+      throw new Error(
+        `Gemini Web request failed${typeof errorCode === "number" ? ` (code ${errorCode})` : ""}.`,
+      );
+    }
+
     const payload = getNestedValue(part, [2]);
     if (typeof payload !== "string") continue;
 
-    try {
-      const parsed = JSON.parse(payload);
-      const candidateList = getNestedValue(parsed, [4]);
-      const firstCandidate = Array.isArray(candidateList) ? candidateList[0] : undefined;
-      const text = getNestedValue(firstCandidate, [1, 0]);
-      if (typeof text === "string" && text.trim().length > 0) {
-        return text;
-      }
-
-      const alternateText = getNestedValue(firstCandidate, [22, 0]);
-      if (typeof alternateText === "string" && alternateText.trim().length > 0) {
-        return alternateText;
-      }
-    } catch {
-      // Ignore non-message chunks.
-    }
+    const parsed: unknown = JSON.parse(payload);
+    const candidate = getNestedValue(parsed, [4, 0]);
+    if (!Array.isArray(candidate)) continue;
+
+    // Candidates are cumulative snapshots. Status 1 is streaming, while 2 is complete.
+    completed = getNestedValue(candidate, [8, 0]) === 2;
+    const text = getNestedValue(candidate, [1, 0]);
+    const alternateText = getNestedValue(candidate, [22, 0]);
+    answer =
+      typeof text === "string" && text.trim()
+        ? text
+        : typeof alternateText === "string"
+          ? alternateText
+          : undefined;
   }
 
-  throw new Error("Gemini Web returned no assistant text.");
+  if (!completed) throw new Error("Gemini Web response ended before generation completed.");
+  const text = answer?.trim();
+  if (!text) throw new Error("Gemini Web returned no assistant text.");
+  return text;
 }
 
 function getNestedValue(value: unknown, path: number[]): unknown {
@@ -173,13 +174,3 @@ function getNestedValue(value: unknown, path: number[]): unknown {
   }
   return current;
 }
-
-function findFirstEmail(value: string): string | null {
-  const normalized = value
-    .replace(/\\u0040/gi, "@")
-    .replace(/\\x40/gi, "@")
-    .replace(/&#64;/gi, "@")
-    .replace(/&commat;/gi, "@");
-  const match = normalized.match(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i);
-  return match?.[0] ?? null;
-}

package/extensions/websearch/providers/gemini.pi.ts

@@ -4,7 +4,13 @@ import { dedupeSources, extractMarkdownSources, normalizeSourceTitle } from "../
 import type { WebsearchResult, WebsearchSource } from "../types.js";
 import type { PiModelSelection } from "./pi-model.shared.js";
 import { buildWebsearchPrompt } from "./search-prompt.shared.js";
-import { fetchJson, withTimeout } from "./shared.js";
+import { applyResolvedHeaders, fetchJson, withTimeout } from "./shared.js";
+
+interface GeminiSearchRequest {
+  model: string;
+  input: string;
+  tools: Array<{ type: "google_search" }>;
+}
 
 export async function searchWithPiGemini(
   selection: PiModelSelection,
@@ -19,8 +25,8 @@ export async function searchWithPiGemini(
       body: JSON.stringify({
         model: selection.model.id,
         input: buildWebsearchPrompt(query),
-        tools: [{ googleSearch: {} }],
-      }),
+        tools: [{ type: "google_search" }],
+      } satisfies GeminiSearchRequest),
       signal: withTimeout(signal, 120_000),
     },
   );
@@ -65,20 +71,14 @@ function resolveGeminiInteractionsUrl(baseUrl?: string): string {
 }
 
 function buildGeminiHeaders(selection: PiModelSelection): Record<string, string> {
-  const headers = { ...selection.headers };
-
-  return {
-    ...headers,
-    ...(hasHeader(headers, "x-goog-api-key") || !selection.apiKey
-      ? {}
-      : { "x-goog-api-key": selection.apiKey }),
-    "content-type": "application/json",
-    accept: "application/json",
-  };
-}
-
-function hasHeader(headers: Record<string, string>, name: string): boolean {
-  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+  return applyResolvedHeaders(
+    {
+      ...(selection.apiKey ? { "x-goog-api-key": selection.apiKey } : {}),
+      "content-type": "application/json",
+      accept: "application/json",
+    },
+    selection.headers,
+  );
 }
 
 function extractAnnotationSources(output: {

package/extensions/websearch/providers/openai-codex.pi.ts

@@ -1,8 +1,10 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 
-import type { WebsearchResult } from "../types.js";
-import { decodeJwtAccountId, runOpenAICodexSearch } from "./openai-codex.shared.js";
+import { dedupeSources, extractMarkdownSources } from "../normalize.js";
+import type { WebsearchResult, WebsearchSource } from "../types.js";
 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(
   selection: PiModelSelection,
@@ -32,18 +34,154 @@ export async function searchWithPiOpenAICodex(
   };
 }
 
+export function isPiOpenAICodexModel(model: Model<Api>): boolean {
+  return model.api === "openai-codex-responses" && model.provider === "openai-codex";
+}
+
 function resolveApiKey(selection: PiModelSelection): string | undefined {
   if (selection.apiKey) return selection.apiKey;
 
-  const authorization = Object.entries(selection.headers ?? {}).find(
-    ([name]) => name.toLowerCase() === "authorization",
-  )?.[1];
+  const authorization = getResolvedHeader(selection.headers, "authorization");
   if (!authorization) return undefined;
 
   const match = authorization.match(/^Bearer\s+(.+)$/i);
   return match?.[1];
 }
 
-export function isPiOpenAICodexModel(model: Model<Api>): boolean {
-  return model.api === "openai-codex-responses" && model.provider === "openai-codex";
+async function runOpenAICodexSearch(options: {
+  apiKey: string;
+  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), {
+    method: "POST",
+    headers: applyResolvedHeaders(
+      {
+        authorization: `Bearer ${options.apiKey}`,
+        ...(options.accountId ? { "chatgpt-account-id": options.accountId } : {}),
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        "OpenAI-Beta": "responses=experimental",
+        originator: "pi-websearch",
+      },
+      options.headers,
+    ),
+    body: JSON.stringify({
+      model: options.model,
+      store: false,
+      stream: true,
+      instructions: WEBSEARCH_SYSTEM_PROMPT,
+      input: [{ role: "user", content: buildWebsearchPrompt(options.query) }],
+      tools: [{ type: "web_search" }],
+      tool_choice: "auto",
+    }),
+    signal: withTimeout(options.signal, 120_000),
+  });
+
+  let answer = "";
+  let fallbackAnswer = "";
+  let completed = false;
+
+  await readEventStream(response, ({ data }) => {
+    if (!data.trim()) return;
+
+    try {
+      const event = JSON.parse(data) as Record<string, unknown>;
+
+      if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
+        answer += event.delta;
+      }
+
+      if (event.type === "response.output_item.done") {
+        const item = event.item as Record<string, unknown> | undefined;
+        const content = Array.isArray(item?.content) ? item.content : [];
+        const fullText = content
+          .filter(
+            (part) =>
+              part &&
+              typeof part === "object" &&
+              (part as Record<string, unknown>).type === "output_text",
+          )
+          .map((part) => (part as Record<string, unknown>).text)
+          .filter((text): text is string => typeof text === "string")
+          .join("\n");
+        if (fullText) fallbackAnswer = fullText;
+      }
+
+      if (
+        event.type === "response.completed" ||
+        event.type === "response.done" ||
+        event.type === "response.incomplete"
+      ) {
+        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.");
+        }
+        completed = true;
+      }
+
+      if (event.type === "response.failed" || event.type === "error") {
+        const failedResponse = event.response;
+        const eventMessage = typeof event.message === "string" ? event.message : undefined;
+        if (failedResponse && typeof failedResponse === "object") {
+          const error = (failedResponse as Record<string, unknown>).error;
+          if (
+            error &&
+            typeof error === "object" &&
+            typeof (error as Record<string, unknown>).message === "string"
+          ) {
+            throw new Error((error as Record<string, unknown>).message as string);
+          }
+        }
+        throw new Error(eventMessage ?? "OpenAI Codex search failed.");
+      }
+    } catch (error) {
+      if (error instanceof SyntaxError) return;
+      throw error;
+    }
+  });
+
+  if (!completed) {
+    throw new Error("OpenAI Codex stream ended before search completed.");
+  }
+
+  const finalAnswer = (answer || fallbackAnswer).trim();
+  if (!finalAnswer) {
+    throw new Error("OpenAI Codex returned an empty response.");
+  }
+
+  return {
+    answer: finalAnswer,
+    sources: dedupeSources(extractMarkdownSources(finalAnswer)),
+  };
+}
+
+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;
+  if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+  return `${normalized}/codex/responses`;
+}
+
+function decodeJwtAccountId(jwt: string | undefined): string | undefined {
+  if (!jwt || typeof jwt !== "string") return undefined;
+
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return undefined;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8")) as Record<
+      string,
+      unknown
+    >;
+    const auth = payload["https://api.openai.com/auth"];
+    return auth && typeof auth === "object"
+      ? ((auth as Record<string, unknown>).chatgpt_account_id as string | undefined)
+      : undefined;
+  } catch {
+    return undefined;
+  }
 }

package/extensions/websearch/providers/pi-model.shared.ts

@@ -1,39 +1,43 @@
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 export interface PiModelSelection {
   model: Model<Api>;
   apiKey?: string;
-  headers?: Record<string, string>;
+  headers?: ProviderHeaders;
+  env?: Record<string, string>;
 }
 
-export async function selectCurrentPiModel(
+export function getPiModelCandidates(
   ctx: ExtensionContext,
   predicate: (model: Model<Api>) => boolean,
-): Promise<PiModelSelection | null> {
-  if (!ctx.model || !predicate(ctx.model)) return null;
-
-  return resolvePiModelSelection(ctx.model, ctx);
+  fallbackModels?: readonly string[],
+): Model<Api>[] {
+  const available = ctx.modelRegistry.getAvailable().filter(predicate);
+  const fallbacks = fallbackModels
+    ? fallbackModels.flatMap((id) => available.filter((model) => model.id === id))
+    : available.sort(comparePiModels);
+  const candidates = ctx.model && predicate(ctx.model) ? [ctx.model, ...fallbacks] : fallbacks;
+  const seen = new Set<string>();
+  return candidates.filter((model) => {
+    const key = `${model.provider}:${model.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
 
-export async function selectFallbackPiModel(
+/** Consume candidates lazily so unused routes and alternate models never resolve credentials. */
+export async function selectNextPiModel(
   ctx: ExtensionContext,
-  predicate: (model: Model<Api>) => boolean,
+  remaining: Model<Api>[],
+  signal?: AbortSignal,
 ): Promise<PiModelSelection | null> {
-  const currentKey =
-    ctx.model && predicate(ctx.model) ? `${ctx.model.provider}:${ctx.model.id}` : null;
-  const candidates = rankPiModels(
-    ctx.modelRegistry.getAvailable().filter((model) => {
-      if (!predicate(model)) return false;
-      return `${model.provider}:${model.id}` !== currentKey;
-    }),
-  );
-
-  for (const model of candidates) {
-    const selection = await resolvePiModelSelection(model, ctx);
+  while (remaining.length > 0) {
+    signal?.throwIfAborted();
+    const selection = await resolvePiModelSelection(remaining.shift()!, ctx);
     if (selection) return selection;
   }
-
   return null;
 }
 
@@ -42,20 +46,28 @@ async function resolvePiModelSelection(
   ctx: Pick<ExtensionContext, "modelRegistry">,
 ): Promise<PiModelSelection | null> {
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers } : null;
+  return auth.ok
+    ? {
+        model: resolveModelEndpoint(model, auth.baseUrl, auth.env),
+        apiKey: auth.apiKey,
+        headers: auth.headers,
+        env: auth.env,
+      }
+    : null;
 }
 
-function rankPiModels(models: Model<Api>[]): Model<Api>[] {
-  const seen = new Set<string>();
+function resolveModelEndpoint(
+  model: Model<Api>,
+  resolvedBaseUrl?: string,
+  env?: Record<string, string>,
+): Model<Api> {
+  let baseUrl = resolvedBaseUrl ?? model.baseUrl;
+  if (!baseUrl) return model;
 
-  return [...models]
-    .filter((model) => {
-      const key = `${model.provider}:${model.id}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    })
-    .sort(comparePiModels);
+  for (const [name, value] of Object.entries(env ?? {})) {
+    baseUrl = baseUrl.replaceAll(`{${name}}`, value);
+  }
+  return baseUrl === model.baseUrl ? model : { ...model, baseUrl };
 }
 
 function comparePiModels(left: Model<Api>, right: Model<Api>): number {

package/extensions/websearch/providers/shared.ts

@@ -1,3 +1,69 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+export function isModelUnavailableError(error: unknown, model: Model<Api>): boolean {
+  if (!(error instanceof HttpError) || (error.status !== 400 && error.status !== 404)) {
+    return false;
+  }
+  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") {
+    return (
+      (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"
+    );
+  }
+
+  if (error.status !== 404 || !detail) return false;
+  if (model.provider === "anthropic" && model.api === "anthropic-messages") {
+    return (
+      error.body.type === "error" &&
+      detail.type === "not_found_error" &&
+      Boolean(model.id) &&
+      typeof detail.message === "string" &&
+      detail.message.trim() === `model: ${model.id}`
+    );
+  }
+
+  if (model.provider === "google" && model.api === "google-generative-ai") {
+    return detail.code === "model_not_found";
+  }
+
+  return false;
+}
+
+export function applyResolvedHeaders(
+  defaults: Record<string, string>,
+  overrides?: Record<string, string | null>,
+): Record<string, string> {
+  const headers = { ...defaults };
+
+  for (const [name, value] of Object.entries(overrides ?? {})) {
+    const existingName = Object.keys(headers).find(
+      (candidate) => candidate.toLowerCase() === name.toLowerCase(),
+    );
+    if (existingName) delete headers[existingName];
+    if (value !== null) headers[name] = value;
+  }
+
+  return headers;
+}
+
+export function getResolvedHeader(
+  headers: Record<string, string | null> | undefined,
+  name: string,
+): string | undefined {
+  const entry = Object.entries(headers ?? {}).find(
+    ([candidate]) => candidate.toLowerCase() === name.toLowerCase(),
+  );
+  return entry?.[1] ?? undefined;
+}
+
 export function withTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal {
   return signal
     ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
@@ -12,7 +78,7 @@ export async function fetchText(url: string, options: RequestInit = {}): Promise
   const response = await fetch(url, options);
   const text = await response.text();
   if (!response.ok) {
-    throw new Error(`${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
+    throw new HttpError(response, text);
   }
   return text;
 }
@@ -23,7 +89,7 @@ export async function readEventStream(
 ): Promise<void> {
   if (!response.ok) {
     const text = await response.text();
-    throw new Error(`${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
+    throw new HttpError(response, text);
   }
 
   if (!response.body) {
@@ -53,6 +119,25 @@ export async function readEventStream(
   }
 }
 
+class HttpError extends Error {
+  readonly status: number;
+  readonly body: unknown;
+
+  constructor(response: Response, text: string) {
+    super(`${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
+    this.status = response.status;
+    try {
+      this.body = JSON.parse(text);
+    } catch {
+      this.body = undefined;
+    }
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 function emitEventBlock(
   block: string,
   onEvent: (event: { event?: string; data: string }) => void,

package/extensions/websearch/types.ts

@@ -5,9 +5,7 @@ export type WebsearchRouteId =
   | "pi:openai-codex"
   | "pi:anthropic"
   | "pi:gemini"
-  | "firefox:openai-codex"
   | "firefox:gemini"
-  | "chromium:openai-codex"
   | "chromium:gemini";
 
 export interface BrowserCookie {
@@ -46,7 +44,6 @@ export interface WebsearchResult {
   authSource: WebsearchAuthSource;
   browserName?: string;
   profile?: string;
-  accountLabel?: string;
   answer: string;
   sources: WebsearchSource[];
 }