@yansigit/opencodex 2.32.0 → 2.33.1

package/src/usage/summary.ts

@@ -94,6 +94,7 @@ export interface UsageProvider {
 
 export interface UsageAccount {
   accountLogLabel: string;
+  provider?: string;
   ambiguous: boolean;
   requests: number;
   attemptCount: number;
@@ -684,12 +685,25 @@ function legacyCodexAccountLabel(provider: string): string | null {
   return suffix ?? LEGACY_AMBIGUOUS_ACCOUNT_LABEL;
 }
 
-function accountLabelForAttribution(provider: string, explicit: unknown): string | null {
-  if (isCodexUsageAccountLogLabel(explicit)) return explicit;
-  return legacyCodexAccountLabel(provider);
+export function accountLabelForAttribution(
+  provider: string,
+  explicit: unknown,
+  fallbackAccountByProvider?: Record<string, string>,
+): string | null {
+  if (typeof explicit === "string" && explicit.trim().length > 0) return explicit.trim();
+  const legacy = legacyCodexAccountLabel(provider);
+  if (legacy) return legacy;
+  const base = baseProviderLabel(provider);
+  if (fallbackAccountByProvider && fallbackAccountByProvider[base]) {
+    return fallbackAccountByProvider[base];
+  }
+  return null;
 }
 
-function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
+function buildAccounts(
+  entries: PersistedUsageEntry[],
+  fallbackAccountByProvider?: Record<string, string>,
+): UsageAccount[] {
   const byLabel = new Map<string, UsageAccount>();
   const requestIds = new Map<string, Set<string>>();
 
@@ -702,12 +716,13 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
     totalTokens?: number;
     estimate: ReturnType<typeof estimateRequestCost>;
   }): void => {
-    const label = accountLabelForAttribution(input.provider, input.accountLogLabel);
+    const label = accountLabelForAttribution(input.provider, input.accountLogLabel, fallbackAccountByProvider);
     if (!label) return;
     let row = byLabel.get(label);
     if (!row) {
       row = {
         accountLogLabel: label,
+        provider: baseProviderLabel(input.provider),
         ambiguous: label === LEGACY_AMBIGUOUS_ACCOUNT_LABEL,
         requests: 0,
         attemptCount: 0,
@@ -808,6 +823,7 @@ export function summarizeUsage(
   range: UsageRange,
   now: number,
   surface: UsageSurface = "all",
+  fallbackAccountByProvider?: Record<string, string>,
 ): UsageSummary {
   const { since } = rangeWindow(range, now);
   const filteredEntries = entries.filter(entry => {
@@ -837,7 +853,7 @@ export function summarizeUsage(
     days: buildDayGrid(range, since, now, filteredEntries),
     models: buildModels(filteredEntries, totals.totalTokens),
     providers: buildProviders(filteredEntries, totals.totalTokens),
-    accounts: buildAccounts(filteredEntries),
+    accounts: buildAccounts(filteredEntries, fallbackAccountByProvider),
   };
 }
 
@@ -869,12 +885,14 @@ function normalizeFilterValue(input: string | null | undefined): string | null {
  */
 export function projectUsageSummary<T extends UsageSummary>(
   summary: T,
-  filter: { provider?: string | null; model?: string | null },
+  filter: { provider?: string | null; model?: string | null; account?: string | null },
   entries?: PersistedUsageEntry[],
+  fallbackAccountByProvider?: Record<string, string>,
 ): T & { filter?: UsageFilterEcho } {
   const provider = normalizeFilterValue(filter.provider);
   const model = normalizeFilterValue(filter.model);
-  if (provider === null && model === null) return summary;
+  const account = normalizeFilterValue(filter.account);
+  if (provider === null && model === null && account === null) return summary;
 
   // Re-summarise from the entries the summary was built from, rather than
   // projecting over its rows.
@@ -891,9 +909,13 @@ export function projectUsageSummary<T extends UsageSummary>(
   //
   // The entries are already in hand on every path that filters, so the honest
   // computation is also the simple one.
-  const matches = (rowProvider: string, rowModel: string): boolean => {
+  const matches = (rowProvider: string, rowModel: string, rowAccount?: string | null): boolean => {
     if (provider !== null && baseProviderLabel(rowProvider).toLowerCase() !== provider) return false;
     if (model !== null && rowModel.toLowerCase() !== model) return false;
+    if (account !== null && rowAccount !== undefined) {
+      const effectiveAccount = accountLabelForAttribution(rowProvider, rowAccount, fallbackAccountByProvider);
+      if (!effectiveAccount || effectiveAccount.toLowerCase() !== account) return false;
+    }
     return true;
   };
 
@@ -909,10 +931,10 @@ export function projectUsageSummary<T extends UsageSummary>(
   const filtered: PersistedUsageEntry[] = [];
   for (const entry of source) {
     if (!entry.attempts?.length) {
-      if (matches(entry.provider, antigravityUsageModel(entry.provider, entry.model))) filtered.push(entry);
+      if (matches(entry.provider, antigravityUsageModel(entry.provider, entry.model), entry.accountLogLabel)) filtered.push(entry);
       continue;
     }
-    const attempts = entry.attempts.filter(a => matches(a.provider, antigravityUsageModel(a.provider, a.model)));
+    const attempts = entry.attempts.filter(a => matches(a.provider, antigravityUsageModel(a.provider, a.model), a.accountLogLabel ?? entry.accountLogLabel));
     if (attempts.length === 0) continue;
     // A combo is still counted once per participating model, so a filtered
     // request count can exceed the number of distinct requests. That is the
@@ -921,7 +943,7 @@ export function projectUsageSummary<T extends UsageSummary>(
     filtered.push({ ...entry, attempts });
   }
 
-  const projected = summarizeUsage(filtered, summary.range, summary.generatedAt, summary.surface);
+  const projected = summarizeUsage(filtered, summary.range, summary.generatedAt, summary.surface, fallbackAccountByProvider);
   // matched reflects usage inside the requested WINDOW, not anywhere in the
   // log: summarizeUsage applies the range and surface predicates, and the CLI
   // uses this flag to decide between a table and "no usage recorded".

package/src/web-search/gemini-executor.ts

@@ -14,13 +14,14 @@ import { fetchWithResetRetry } from "../lib/upstream-retry";
 import { cancelBodyOnAbort, signalWithTimeout } from "../lib/abort";
 import { readBoundedResponseBytes } from "../lib/bounded-body";
 import { sidecarEnter } from "../lib/sidecar-tracker";
-import { redactSecretString } from "../lib/redact";
+import { redactErrorMessage, redactSecretString } from "../lib/redact";
 import { ANTIGRAVITY_REQUEST_UA } from "../adapters/google-antigravity-wire";
 import { resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
 import { getProviderRegistryEntry } from "../providers/registry";
 import { MAX_SIDECAR_RESPONSE_BYTES, type WebSearchSource } from "./parse";
 import { appendSafeWebSearchSource } from "./sources";
 import { BASE_INSTRUCTION, IMAGE_INSTRUCTION, type SidecarOutcome, type SidecarSettings } from "./executor";
+import { providerFetch } from "../server/responses/fetch-helpers";
 
 const CCA_FALLBACK_BASE = "https://daily-cloudcode-pa.googleapis.com";
 
@@ -31,7 +32,7 @@ function isRec(v: unknown): v is Record<string, unknown> {
 export async function runGeminiWebSearch(
   query: string,
   providerName: string,
-  _provider: OcxProviderConfig,
+  provider: OcxProviderConfig,
   settings: SidecarSettings,
   abortSignal?: AbortSignal,
 ): Promise<SidecarOutcome> {
@@ -68,9 +69,10 @@ export async function runGeminiWebSearch(
   const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
   const sidecarExit = sidecarEnter("web-search");
   const t0 = Date.now();
+  const executor = providerFetch(provider, undefined, { providerName, modelId: settings.model });
   try {
     const res = await fetchWithResetRetry(
-      () => fetch(`${base}/v1internal:generateContent`, {
+      () => executor(`${base}/v1internal:generateContent`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -110,7 +112,7 @@ export async function runGeminiWebSearch(
   } catch (e) {
     const kind = e instanceof Error && e.name === "TimeoutError" ? "timeout" : "connect_error";
     console.warn(`[web-search] gemini sidecar ${kind} (${Date.now() - t0}ms)`);
-    return { text: "", sources: [], error: redactSecretString(e instanceof Error ? e.message : String(e)) };
+    return { text: "", sources: [], error: redactErrorMessage(e instanceof Error ? e.message : String(e)) };
   } finally {
     sidecarExit();
     linkedSignal.cleanup();

package/src/web-search/index.ts

@@ -9,6 +9,7 @@ import { validateXaiSearchOptions, type XaiSearchOptions } from "./xai-executor"
 import type { OcxWebSearchSidecarConfig } from "../types";
 import { DEFAULT_STALL_TIMEOUT_SEC } from "../stall-timeout";
 import { buildWebSearchTool, extractHostedWebSearch, WEB_SEARCH_TOOL_NAME } from "./synthetic-tool";
+import { estimateInputTokens } from "../server/responses/input-admission";
 
 export { runWithWebSearch } from "./loop";
 export { buildWebSearchTool, extractHostedWebSearch, WEB_SEARCH_TOOL_NAME };
@@ -44,13 +45,19 @@ const STALL_MARGIN_SEC = 30;
  * deliberately permissive, so malformed values fall back locally without rejecting or rewriting
  * the caller's config object.
  */
-export function resolveRoutedModelStallTimeoutMs(value: unknown): number {
-  return typeof value === "number"
+export function resolveRoutedModelStallTimeoutMs(value: unknown, estimatedInputTokens?: number): number {
+  if (typeof value === "number"
     && Number.isInteger(value)
     && value >= 1
-    && value <= MAX_ROUTED_MODEL_STALL_TIMEOUT_MS
-    ? value
-    : DEFAULT_ROUTED_MODEL_STALL_TIMEOUT_MS;
+    && value <= MAX_ROUTED_MODEL_STALL_TIMEOUT_MS) {
+    return value;
+  }
+  const base = DEFAULT_ROUTED_MODEL_STALL_TIMEOUT_MS;
+  if (typeof estimatedInputTokens === "number" && Number.isFinite(estimatedInputTokens) && estimatedInputTokens > 100_000) {
+    const extraBlocks = Math.ceil((estimatedInputTokens - 100_000) / 100_000);
+    return Math.min(MAX_ROUTED_MODEL_STALL_TIMEOUT_MS, base + extraBlocks * 60_000);
+  }
+  return base;
 }
 
 function finiteCeil(value: number | undefined, fallback: number): number {
@@ -305,9 +312,10 @@ export function planWebSearch(
   const cfg = config.webSearchSidecar ?? {};
   if (cfg.enabled === false) return undefined;
   const timeoutMs = cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const routedModelStallTimeoutMs = resolveRoutedModelStallTimeoutMs(cfg.routedModelStallTimeoutMs);
-  // Same `?? 200_000` default the server applies when threading connectTimeoutMs into the loop.
-  const connectTimeoutMs = config.connectTimeoutMs ?? 200_000;
+  const safeModelId = typeof modelId === "string" ? modelId : "";
+  const estimatedInputTokens = estimateInputTokens(parsed, safeModelId);
+  const routedModelStallTimeoutMs = resolveRoutedModelStallTimeoutMs(cfg.routedModelStallTimeoutMs, estimatedInputTokens);
+  const connectTimeoutMs = config.connectTimeoutMs ?? Math.max(200_000, routedModelStallTimeoutMs);
   // Shared auth state (#2188): presence only — backend PREFERENCE stays with
   // resolveSidecarBackend's explicit-or-openai contract.
   const auth = resolveSidecarAuth(config);

package/src/web-search/loop.ts

@@ -3,7 +3,7 @@ import type { AdapterEvent, OcxMessage, OcxParsedRequest, OcxProviderConfig, Ocx
 import { namespacedToolName, toolChoiceToolPredicate } from "../types";
 import { cloneProviderOpaqueToolCallMetadata } from "../responses/provider-opaque-metadata";
 import type { AttemptRecoveryKind } from "../usage/log";
-import { bridgeToResponsesSSE } from "../bridge";
+import { bridgeToResponsesSSE, diagnoseAdapterEvent, type BridgeDiagnosticContext } from "../bridge";
 import { runWebSearch, type SidecarOutcome, type SidecarOutcomeRecorder, type SidecarSettings } from "./executor";
 import { runAnthropicWebSearch } from "./anthropic-executor";
 import { runXaiWebSearch, type XaiSearchOptions } from "./xai-executor";
@@ -23,6 +23,7 @@ import {
 import { formatWebSearchResults } from "./format-result";
 import { parseStreamWithProgress, RoutedModelInactivityError, WebSearchStreamProtocolError } from "./progress-stream";
 import { WEB_SEARCH_TOOL_NAME } from "./synthetic-tool";
+import { OcxRequestValidationError } from "../lib/errors";
 
 const SSE_HEADERS = {
   "Content-Type": "text/event-stream",
@@ -230,8 +231,14 @@ function forcedAnswerNudge(): OcxMessage {
   };
 }
 
-function jsonError(status: number, message: string): Response {
-  return new Response(JSON.stringify({ error: { message, type: "upstream_error", code: null } }), {
+function jsonError(status: number, message: string, errorType = "upstream_error", code: string | null = null): Response {
+  return new Response(JSON.stringify({
+    error: {
+      message,
+      type: errorType,
+      code,
+    },
+  }), {
     status,
     headers: { "Content-Type": "application/json" },
   });
@@ -240,7 +247,12 @@ function jsonError(status: number, message: string): Response {
 /** Hard provider/parse failure inside an iteration. The eager first iteration converts it to a
  *  non-200 jsonError; later (already-streaming) iterations surface it as an in-stream error event. */
 class LoopError extends Error {
-  constructor(readonly status: number, message: string) {
+  constructor(
+    readonly status: number,
+    message: string,
+    readonly errorType?: string,
+    readonly code?: string,
+  ) {
     super(message);
     this.name = "LoopError";
   }
@@ -301,6 +313,8 @@ export interface WebSearchLoopDeps {
   onUsage?: (usage: OcxUsage | undefined) => void;
   /** Observe the exact adapter request selected for each routed-model iteration. */
   onRequestBuilt?: (request: AdapterRequest) => void;
+  /** Validate the final adapter before every cached replay or request build. */
+  validateAdapter?: (parsed: OcxParsedRequest, adapter: ProviderAdapter) => void;
   /** Called before each routed-model dispatch in the loop, for attempt telemetry. Same-target 429 replays pass the `rate-limit-429` recovery kind. */
   onAttemptSend?: (recovery?: AttemptRecoveryKind) => void;
   /**
@@ -314,6 +328,8 @@ export interface WebSearchLoopDeps {
   onCompletedResponse?: (response: Record<string, unknown>) => void;
   /** OAuth account identity forwarded to AdapterFetchContext for provider-local cooldown bookkeeping. */
   accountId?: string;
+  /** Internal, opt-in structural stream diagnostics shared with the final bridge. */
+  diagnostic?: BridgeDiagnosticContext;
 }
 
 /**
@@ -422,6 +438,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
        * header deadline. The caller owns same-target 429 replays and key rotation around it.
        */
       const fetchOnce = async (requestAdapter: ProviderAdapter, recovery?: AttemptRecoveryKind): Promise<IterationResponse> => {
+        deps.validateAdapter?.(iterParsed, requestAdapter);
         let request: AdapterRequest;
         if (cachedRequest !== undefined && cachedAdapter === requestAdapter) {
           request = cachedRequest;
@@ -553,6 +570,9 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       return prepared;
     } catch (error) {
       if (isTranslatorBudgetExceededError(error)) throw error;
+      if (error instanceof OcxRequestValidationError) {
+        throw new LoopError(error.status, error.message, "invalid_request_error", "invalid_request_error");
+      }
       if (headerDeadline.didExpire()) {
         throw new LoopError(504, `Provider response-header timeout after ${connectTimeoutMs}ms during web-search`);
       }
@@ -595,6 +615,10 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         inactivityTimeoutMs: routedModelStallTimeoutMs,
         translatorBudget,
       })) {
+        if (deps.diagnostic) {
+          deps.diagnostic.adapterName = prepared.responseAdapter.name;
+          diagnoseAdapterEvent(deps.diagnostic, event);
+        }
         if (event.type === "heartbeat") yield event;
         // Kiro's explicit-completion protocol marks ordinary assistant text as commentary while
         // it performs a bounded final-answer retry. That text is safe to surface immediately and
@@ -779,7 +803,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     firstPrepared = await prepareIterationDrained(false);
   } catch (e) {
     if (abortSignal) abortSignal.removeEventListener("abort", linkAbort);
-    if (e instanceof LoopError) return jsonError(e.status, e.message);
+    if (e instanceof LoopError) return jsonError(e.status, e.message, e.errorType, e.code ?? null);
     throw e;
   }
 
@@ -863,7 +887,18 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
               message: "upstream translation buffer exceeded the safe limit",
             };
           } else {
-            yield { type: "error", message: e instanceof LoopError ? e.message : (e instanceof Error ? e.message : String(e)) };
+            const message = e instanceof LoopError ? e.message : (e instanceof Error ? e.message : String(e));
+            yield {
+              type: "error",
+              ...(e instanceof LoopError ? {
+                status: e.status,
+                ...(e.errorType !== undefined || e.status === 400
+                  ? { errorType: e.errorType ?? "upstream_error" }
+                  : {}),
+                ...(e.code !== undefined ? { code: e.code } : {}),
+              } : {}),
+              message,
+            };
           }
           return;
         }
@@ -890,6 +925,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       ...(deps.onFirstOutput ? { onFirstOutput: deps.onFirstOutput } : {}),
       ...(deps.onUsage ? { onUsage: deps.onUsage } : {}),
       ...(deps.onCompletedResponse ? { onCompletedResponse: deps.onCompletedResponse } : {}),
+      ...(deps.diagnostic ? { diagnostic: deps.diagnostic } : {}),
     },
   );
   return new Response(sse, { headers: SSE_HEADERS });