@bitkyc08/opencodex 2.6.7-preview.20260629 → 2.6.8-preview.20260630

package/src/providers/registry.ts

@@ -1,5 +1,6 @@
 import type { OcxProviderConfig } from "../types";
 import { KIRO_MODELS, KIRO_MODEL_CONTEXT_WINDOWS, KIRO_MODEL_REASONING_EFFORTS } from "./kiro-models";
+import { ANTIGRAVITY_MODELS, ANTIGRAVITY_MODEL_CONTEXT_WINDOWS } from "./antigravity-models";
 
 export type ProviderAuthKind = "forward" | "oauth" | "key" | "local";
 export type MetadataModelIdNormalize = "case-insensitive";
@@ -34,6 +35,9 @@ export interface ProviderRegistryEntry {
   jawcodeBundle?: string;
   extraMetadataAliases?: string[];
   metadataModelIdNormalize?: MetadataModelIdNormalize;
+  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
+  project?: string;
+  location?: string;
 }
 
 export type ProviderConfigSeed = Pick<
@@ -43,6 +47,7 @@ export type ProviderConfigSeed = Pick<
   | "reasoningEfforts" | "modelReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
   | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "escapeBuiltinToolNames"
+  | "googleMode" | "project" | "location"
 >;
 
 
@@ -260,6 +265,8 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   { id: "openrouter", label: "OpenRouter", adapter: "openai-chat", baseUrl: "https://openrouter.ai/api/v1", authKind: "key", featured: true, dashboardUrl: "https://openrouter.ai/keys", jawcodeBundle: "openrouter" },
   { id: "groq", label: "Groq", adapter: "openai-chat", baseUrl: "https://api.groq.com/openai/v1", authKind: "key", featured: true, dashboardUrl: "https://console.groq.com/keys" },
   { id: "google", label: "Google Gemini", adapter: "google", baseUrl: "https://generativelanguage.googleapis.com", authKind: "key", featured: true, dashboardUrl: "https://aistudio.google.com/apikey", defaultModel: "gemini-3-pro", jawcodeBundle: "google", extraMetadataAliases: ["gemini"] },
+  { id: "google-vertex", label: "Google Vertex AI", adapter: "google", baseUrl: "https://aiplatform.googleapis.com", authKind: "key", dashboardUrl: "https://console.cloud.google.com/vertex-ai", defaultModel: "gemini-3-pro", googleMode: "vertex", jawcodeBundle: "google", extraMetadataAliases: ["gemini-vertex"] },
+  { id: "google-antigravity", label: "Google Antigravity", adapter: "google", baseUrl: "https://daily-cloudcode-pa.googleapis.com", authKind: "oauth", dashboardUrl: "https://antigravity.google", models: ANTIGRAVITY_MODELS, defaultModel: "gemini-3.5-flash-low", modelContextWindows: ANTIGRAVITY_MODEL_CONTEXT_WINDOWS, googleMode: "cloud-code-assist", jawcodeBundle: "google", extraMetadataAliases: ["antigravity", "gemini-antigravity"] },
   { id: "azure-openai", label: "Azure OpenAI", adapter: "azure-openai", baseUrl: "https://{resource}.openai.azure.com/openai", authKind: "key", featured: true, dashboardUrl: "https://portal.azure.com" },
   { id: "ollama", label: "Ollama (local)", adapter: "openai-chat", baseUrl: "http://localhost:11434/v1", authKind: "local", featured: true, note: "Local — key usually blank", reasoningEffortMap: OLLAMA_REASONING_MAP },
   { id: "vllm", label: "vLLM (local)", adapter: "openai-chat", baseUrl: "http://localhost:8000/v1", authKind: "local", featured: true, note: "Local — key usually blank" },

package/src/redact.ts

@@ -69,3 +69,29 @@ export function redactUrlForLog(url: string): string {
     return redactSecretString(url.split("?")[0] ?? url);
   }
 }
+
+const USER_HOME_PATH_PATTERNS: Array<[RegExp, string]> = [
+  // Windows: C:\Users\<name>\...  ->  C:\Users\[USER]\...
+  [/([A-Za-z]:\\Users\\)[^\\/]+/gi, "$1[USER]"],
+  // POSIX: /Users/<name>/... (macOS) and /home/<name>/... (Linux)
+  [/(\/(?:Users|home)\/)[^/]+/gi, "$1[USER]"],
+];
+
+// Path segments whose name alone looks sensitive. Masked so a configured path
+// cannot surface a secret-flavored substring in diagnostics or logs.
+const SENSITIVE_SEGMENT_PATTERN = /(^|[\\/])([^\\/]*(?:secret|password|passwd|token|api[-_]?key|apikey|credential|email)[^\\/]*)(?=[\\/]|$)/gi;
+
+/**
+ * Mask the username segment of an absolute home path so diagnostics can print
+ * paths without leaking the OS account name, and mask any path segment whose
+ * name looks sensitive (token/secret/password/credential/email/...). Path-focused
+ * and secret-safe: also runs {@link redactSecretString} for token-shaped values.
+ */
+export function redactUserPath(path: string): string {
+  let masked = path;
+  for (const [pattern, replacement] of USER_HOME_PATH_PATTERNS) {
+    masked = masked.replace(pattern, replacement);
+  }
+  masked = masked.replace(SENSITIVE_SEGMENT_PATTERN, (_m, sep: string) => `${sep}[REDACTED]`);
+  return redactSecretString(masked);
+}

package/src/router.ts

@@ -94,6 +94,12 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
     baseUrl: registryEntry.baseUrl,
     authMode: canonicalAuthMode,
     apiKey: resolveEnvValue(provider.apiKey),
+    // Backfill the Google wire mode + Vertex project/location from the registry when the user
+    // config omits them, so a minimal `google-vertex`/`google-antigravity` entry still routes
+    // through the correct branch (CCA/Vertex) instead of falling back to AI Studio.
+    ...(provider.googleMode === undefined && registryEntry.googleMode !== undefined ? { googleMode: registryEntry.googleMode } : {}),
+    ...(provider.project === undefined && registryEntry.project !== undefined ? { project: registryEntry.project } : {}),
+    ...(provider.location === undefined && registryEntry.location !== undefined ? { location: registryEntry.location } : {}),
     ...(provider.contextWindow === undefined && registryEntry.contextWindow !== undefined ? { contextWindow: registryEntry.contextWindow } : {}),
     ...(provider.reasoningEfforts === undefined && registryEntry.reasoningEfforts !== undefined ? { reasoningEfforts: registryEntry.reasoningEfforts } : {}),
     ...(provider.escapeBuiltinToolNames === undefined && registryEntry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: registryEntry.escapeBuiltinToolNames } : {}),

package/src/server.ts

@@ -35,7 +35,7 @@ import { parseRequest } from "./responses/parser";
 import { routeModel } from "./router";
 import { namespacedToolName } from "./types";
 import {
-  clearLoginState, getLoginStatus, getValidAccessToken, isOAuthProvider,
+  clearLoginState, getLoginStatus, getOAuthCredentialProjectId, getValidAccessToken, isOAuthProvider,
   listOAuthProviders, reconcileOAuthProviders, startLoginFlow, UnsupportedOAuthProviderError, upsertOAuthProvider,
 } from "./oauth/index";
 import type { CatalogModel } from "./codex-catalog";
@@ -48,7 +48,7 @@ import { enrichProviderFromCatalog, listKeyLoginProviders } from "./oauth/key-pr
 import { deriveProviderPresets } from "./providers/derive";
 import type { AdapterEvent, OcxConfig, OcxProviderConfig } from "./types";
 import type { OcxUsage } from "./types";
-import { DEFAULT_PROVIDER_CONTEXT_CAP, providerContextCap, providerContextCaps, setProviderContextCap } from "./provider-context-cap";
+import { DEFAULT_PROVIDER_CONTEXT_CAP, globalContextCapValue, providerContextCap, providerContextCaps, setAllProviderContextCaps, setGlobalContextCapValue, setProviderContextCap } from "./provider-context-cap";
 import {
   appendUsageEntry,
   readUsageEntries,
@@ -423,6 +423,12 @@ async function handleResponses(
   if (route.provider.authMode === "oauth") {
     try {
       route.provider = { ...route.provider, apiKey: await getValidAccessToken(route.providerName) };
+      // Antigravity (cloud-code-assist) needs the discovered Cloud Code Assist project id in the
+      // CCA envelope; the server injects only the bare token, so pull project from the credential.
+      if (route.provider.googleMode === "cloud-code-assist" && !route.provider.project) {
+        const projectId = getOAuthCredentialProjectId(route.providerName);
+        if (projectId) route.provider = { ...route.provider, project: projectId };
+      }
     } catch (err) {
       if (err instanceof UnsupportedOAuthProviderError) {
         return formatErrorResponse(
@@ -449,7 +455,7 @@ async function handleResponses(
   const recordTerminalOutcomes = options.recordTerminalOutcomes !== false;
 
   if ("passthrough" in adapter && adapter.passthrough) {
-    const request = adapter.buildRequest(parsed, { headers: selectedForwardHeaders });
+    const request = await adapter.buildRequest(parsed, { headers: selectedForwardHeaders });
     // Abort the upstream if the client disconnects. A directly-relayed body does not propagate the
     // consumer's cancel to a signalled fetch, so we pass the signal and relay through relayWithAbort,
     // whose cancel() aborts the upstream — preventing leaked connections (RC2, passthrough path).
@@ -589,7 +595,7 @@ async function handleResponses(
   const cleanupUpstreamAbort = linkAbortSignal(upstream, options.abortSignal);
   const connectMs = config.connectTimeoutMs ?? 100_000;
 
-  const request = adapter.buildRequest(parsed, { headers: selectedForwardHeaders });
+  const request = await adapter.buildRequest(parsed, { headers: selectedForwardHeaders });
   if (typeof request.usageLog?.inputTokens === "number") {
     logCtx.usageLogInputTokens = request.usageLog.inputTokens;
   }
@@ -1802,12 +1808,44 @@ async function handleManagementAPI(req: Request, url: URL, config: OcxConfig): P
   }
 
   if (url.pathname === "/api/provider-context-caps" && req.method === "GET") {
-    return jsonResponse({ cap: DEFAULT_PROVIDER_CONTEXT_CAP, caps: providerContextCaps(config) });
+    return jsonResponse({ cap: DEFAULT_PROVIDER_CONTEXT_CAP, value: globalContextCapValue(config), caps: providerContextCaps(config) });
   }
 
   if (url.pathname === "/api/provider-context-caps" && req.method === "PUT") {
-    let body: { provider?: unknown; enabled?: unknown };
+    let body: { provider?: unknown; enabled?: unknown; value?: unknown; setAll?: unknown };
     try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    const { saveConfig: save } = await import("./config");
+    const { clearModelCache } = await import("./model-cache");
+    const respond = () => jsonResponse({ ok: true, cap: DEFAULT_PROVIDER_CONTEXT_CAP, value: globalContextCapValue(config), caps: providerContextCaps(config) });
+
+    // Branch 1: set the global cap value and re-point every enabled provider to it.
+    if (body.value !== undefined) {
+      if (typeof body.value !== "number" || !Number.isFinite(body.value) || body.value <= 0) {
+        return jsonResponse({ error: "value must be a positive number" }, 400);
+      }
+      const affected = Object.keys(providerContextCaps(config));
+      setGlobalContextCapValue(config, body.value);
+      save(config);
+      for (const provider of affected) clearModelCache(provider);
+      await refreshCodexCatalogBestEffort();
+      return respond();
+    }
+
+    // Branch 2: enable/clear the cap for every provider at once.
+    if (body.setAll !== undefined) {
+      if (typeof body.setAll !== "boolean") {
+        return jsonResponse({ error: "setAll must be a boolean" }, 400);
+      }
+      const before = Object.keys(providerContextCaps(config));
+      const names = Object.keys(config.providers);
+      setAllProviderContextCaps(config, names, body.setAll);
+      save(config);
+      for (const provider of new Set([...before, ...names])) clearModelCache(provider);
+      await refreshCodexCatalogBestEffort();
+      return respond();
+    }
+
+    // Branch 3: existing per-provider toggle (enable writes the current global value).
     if (typeof body.provider !== "string" || typeof body.enabled !== "boolean") {
       return jsonResponse({ error: "provider string and enabled boolean are required" }, 400);
     }
@@ -1819,12 +1857,10 @@ async function handleManagementAPI(req: Request, url: URL, config: OcxConfig): P
       return jsonResponse({ error: "unknown provider" }, 404);
     }
     setProviderContextCap(config, provider, body.enabled);
-    const { saveConfig: save } = await import("./config");
     save(config);
-    const { clearModelCache } = await import("./model-cache");
     clearModelCache(provider);
     await refreshCodexCatalogBestEffort();
-    return jsonResponse({ ok: true, cap: DEFAULT_PROVIDER_CONTEXT_CAP, caps: providerContextCaps(config) });
+    return respond();
   }
 
   // Enable/disable models: which routed models Codex sees. PUT hides them from the catalog +

package/src/star-prompt.ts

@@ -8,6 +8,19 @@ const REPO = "lidge-jun/opencodex";
 /** Fires exactly once from the first interactive `ocx start`. */
 const MARKER = ".star-prompted";
 
+/**
+ * True once the one-time star prompt has already fired (marker written). The
+ * update prompt uses this to yield on a user's very first run so two prompts
+ * never stack on a fresh install.
+ */
+export function hasStarPromptRun(): boolean {
+  try {
+    return existsSync(join(getConfigDir(), MARKER));
+  } catch {
+    return false;
+  }
+}
+
 function ghAvailable(): boolean {
   const r = spawnSync("gh", ["--version"], { stdio: "ignore", timeout: 3000, windowsHide: true });
   return !r.error && r.status === 0;

package/src/types.ts

@@ -207,6 +207,8 @@ export interface OcxConfig {
   disabledModels?: string[];
   /** Provider-level Codex-visible context caps. Values only lower known model context windows. */
   providerContextCaps?: Record<string, number>;
+  /** Global Codex-visible context cap value (tokens). Falls back to DEFAULT_PROVIDER_CONTEXT_CAP. */
+  contextCapValue?: number;
   /** Bind hostname. Default "127.0.0.1" (loopback only). Set "0.0.0.0" to expose on all interfaces. */
   hostname?: string;
   /** Upstream stall timeout (seconds). After this many seconds of no upstream data, emits response.incomplete. Default 90. Min 1. */
@@ -326,6 +328,16 @@ export interface OcxProviderConfig {
    * attached images are described by a gpt vision model and replaced with text before the call.
    */
   noVisionModels?: string[];
+  /**
+   * Google adapter mode. "ai-studio" (default) = Generative Language API + x-goog-api-key.
+   * "vertex" = Vertex AI project/location endpoints with GCP ADC (or x-goog-api-key).
+   * "cloud-code-assist" = Google Antigravity (Cloud Code Assist) OAuth + CCA envelope.
+   */
+  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
+  /** Vertex AI GCP project id (or GOOGLE_CLOUD_PROJECT / GCLOUD_PROJECT env). */
+  project?: string;
+  /** Vertex AI location, e.g. "us-central1" or "global" (or GOOGLE_CLOUD_LOCATION env). */
+  location?: string;
 }
 
 export interface CodexAccount {

package/src/update-notify.ts

@@ -0,0 +1,257 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { atomicWriteFile, getConfigDir } from "./config";
+import { hasStarPromptRun } from "./star-prompt";
+import {
+  type Channel,
+  currentVersion,
+  detectInstall,
+  latestVersion,
+  runUpdate,
+  updateCommandStr,
+  updateTag,
+} from "./update";
+
+const VERSION_FILENAME = "version.json";
+const REFRESH_INTERVAL_MS = 20 * 60 * 60 * 1000; // 20h, matching codex-rs
+const RELEASE_NOTES_URL = "https://github.com/lidge-jun/opencodex/releases/latest";
+
+export interface VersionCache {
+  latest_version: string;
+  /** ISO-8601 (RFC3339) timestamp of the last successful registry check. */
+  last_checked_at: string;
+  dismissed_version?: string;
+  tag: Channel;
+}
+
+function versionFilePath(): string {
+  return join(getConfigDir(), VERSION_FILENAME);
+}
+
+/**
+ * Read the cached version info. Returns null on any error or when the cached
+ * channel differs from the current one (so a stable<->preview switch re-fetches
+ * instead of comparing across channels).
+ */
+export function readVersionCache(channel: Channel): VersionCache | null {
+  try {
+    const raw = readFileSync(versionFilePath(), "utf8");
+    const parsed = JSON.parse(raw) as Partial<VersionCache>;
+    if (typeof parsed.latest_version !== "string" || typeof parsed.last_checked_at !== "string") return null;
+    if (parsed.tag !== channel) return null;
+    return {
+      latest_version: parsed.latest_version,
+      last_checked_at: parsed.last_checked_at,
+      dismissed_version: typeof parsed.dismissed_version === "string" ? parsed.dismissed_version : undefined,
+      tag: parsed.tag,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function writeVersionCache(cache: VersionCache): void {
+  try {
+    atomicWriteFile(versionFilePath(), `${JSON.stringify(cache)}\n`);
+  } catch {
+    /* best-effort; never block startup */
+  }
+}
+
+function parseStable(v: string): [number, number, number] | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+function parsePreview(v: string): [number, number, number, number] | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)-preview\.(\d+)$/.exec(v.trim());
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+}
+
+function gt(a: number[], b: number[]): boolean {
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av !== bv) return av > bv;
+  }
+  return false;
+}
+
+/**
+ * Channel-aware "is latest newer than current?".
+ * - latest channel: compare maj.min.pat only; prereleases are never "newer"
+ *   (parity with codex-rs), so stable users are not pushed onto previews.
+ * - preview channel: preview-vs-preview compares the trailing -preview.N; a
+ *   stable release with a strictly higher base counts as newer (O3), while a
+ *   stable release with the same base as the current preview does not.
+ */
+export function isNewer(latest: string, current: string, channel: Channel): boolean {
+  if (channel === "latest") {
+    const l = parseStable(latest);
+    const c = parseStable(current);
+    if (!l || !c) return false;
+    return gt(l, c);
+  }
+  // preview channel
+  const lPre = parsePreview(latest);
+  const cPre = parsePreview(current);
+  if (lPre && cPre) return gt(lPre, cPre);
+
+  const lStable = parseStable(latest);
+  if (lStable && cPre) {
+    // Stable release vs current preview: newer only if the base is strictly
+    // higher than the preview's base (equal base would be a downgrade nag).
+    return gt(lStable, [cPre[0], cPre[1], cPre[2]]);
+  }
+  const cStable = parseStable(current);
+  if (lStable && cStable) return gt(lStable, cStable);
+  return false;
+}
+
+export function isSourceBuildVersion(v: string): boolean {
+  return v.trim() === "0.0.0";
+}
+
+/** The interactive/TTY + install-method gate shared with the star prompt. */
+function interactiveGuardOk(): boolean {
+  return !(process.env.OCX_SERVICE || !process.stdin.isTTY || !process.stdout.isTTY);
+}
+
+/**
+ * Decide whether this run should even consider showing the prompt. Returns the
+ * channel + current version when eligible, else null. Eligibility requires a
+ * real global install, a non-source version, the interactive guard, and that
+ * the one-time star prompt has already run (first-run yield, O1).
+ */
+export function shouldConsider(): { channel: Channel; current: string } | null {
+  if (detectInstall() === "source") return null;
+  const current = currentVersion();
+  if (current === "?" || isSourceBuildVersion(current)) return null;
+  if (!interactiveGuardOk()) return null;
+  if (!hasStarPromptRun()) return null; // yield on the very first run
+  return { channel: updateTag(current), current };
+}
+
+/** The cached upgrade version to surface, honoring the user's dismissal. */
+export function getUpgradeVersionForPopup(
+  cache: VersionCache | null,
+  current: string,
+  channel: Channel,
+): string | null {
+  if (!cache) return null;
+  if (!isNewer(cache.latest_version, current, channel)) return null;
+  if (cache.dismissed_version === cache.latest_version) return null;
+  return cache.latest_version;
+}
+
+function cacheIsStale(cache: VersionCache | null): boolean {
+  if (!cache) return true;
+  const checked = Date.parse(cache.last_checked_at);
+  if (!Number.isFinite(checked)) return true;
+  return Date.now() - checked > REFRESH_INTERVAL_MS;
+}
+
+/**
+ * If the cache is missing or older than 20h, kick off a detached helper to
+ * refresh it without blocking this (soon-to-be daemon) process. Fire-and-forget.
+ */
+export function triggerBackgroundRefreshIfStale(channel: Channel, cache: VersionCache | null): void {
+  if (!cacheIsStale(cache)) return;
+  try {
+    const entry = process.argv[1];
+    if (!entry || !existsSync(entry)) return;
+    const child = spawn(process.execPath, [entry, "__refresh-version", channel], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: { ...process.env, OCX_SERVICE: "1" }, // never let the helper prompt
+    });
+    child.unref();
+  } catch {
+    /* best-effort */
+  }
+}
+
+/**
+ * Body of the hidden `__refresh-version` subcommand: fetch the latest version
+ * for the channel and persist it. Only advances `last_checked_at` on success so
+ * a failed fetch retries on the next start.
+ */
+export async function refreshVersionCache(channel: Channel): Promise<void> {
+  const latest = latestVersion(channel);
+  if (!latest) return; // do not dirty the cache or advance the timestamp
+  const prev = readVersionCache(channel);
+  writeVersionCache({
+    latest_version: latest,
+    last_checked_at: new Date().toISOString(),
+    dismissed_version: prev?.dismissed_version,
+    tag: channel,
+  });
+}
+
+/** Persist a dismissal so this exact version stops prompting. */
+function dismissVersion(channel: Channel, version: string): void {
+  const cache = readVersionCache(channel);
+  if (!cache) return;
+  writeVersionCache({ ...cache, dismissed_version: version });
+}
+
+function renderPrompt(current: string, latest: string, channel: Channel): string {
+  const command = updateCommandStr(detectInstall(), channel);
+  return [
+    "",
+    `  \x1b[38;5;141m✨ Update available!\x1b[0m  \x1b[2m${current} -> ${latest}\x1b[0m`,
+    "",
+    `  \x1b[2mRelease notes:\x1b[0m ${RELEASE_NOTES_URL}`,
+    "",
+    `  1) Update now (runs \`${command}\`)`,
+    "  2) Skip",
+    "  3) Skip until next version",
+    "",
+    "  [1/2/3] (default 1): ",
+  ].join("\n");
+}
+
+/**
+ * Interactive-only update prompt for `ocx start`. Must be called BEFORE the
+ * server binds a port / writes a PID, because "Update now" installs globally
+ * and exits. No-op for service/daemon/non-TTY runs and source checkouts.
+ * Never throws.
+ */
+export async function maybeShowUpdatePrompt(): Promise<void> {
+  try {
+    const eligible = shouldConsider();
+    if (!eligible) return;
+    const { channel, current } = eligible;
+
+    const cache = readVersionCache(channel);
+    triggerBackgroundRefreshIfStale(channel, cache);
+
+    const latest = getUpgradeVersionForPopup(cache, current, channel);
+    if (!latest) return;
+
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    let answer = "";
+    try {
+      answer = (await rl.question(renderPrompt(current, latest, channel))).trim();
+    } finally {
+      rl.close();
+    }
+
+    const choice = answer === "" ? "1" : answer;
+    if (choice === "1") {
+      await runUpdate();
+      console.log("\nRestart the proxy:  ocx start");
+      process.exit(0);
+    } else if (choice === "3") {
+      dismissVersion(channel, latest);
+    }
+    // "2" (or anything else) -> Skip: continue this run unchanged.
+  } catch {
+    /* never let the update prompt disrupt startup */
+  }
+}

package/src/update.ts

@@ -3,18 +3,19 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
-const PKG = "@bitkyc08/opencodex";
+export const PKG = "@bitkyc08/opencodex";
 const HERE = dirname(fileURLToPath(import.meta.url)); // .../opencodex/src
 
-type Installer = "bun" | "npm" | "source";
+export type Installer = "bun" | "npm" | "source";
+export type Channel = "latest" | "preview";
 
 /** Infer how opencodex is installed from the running module's path. */
-function detectInstall(): Installer {
+export function detectInstall(): Installer {
   if (!HERE.includes("node_modules")) return "source"; // a git checkout, not a global install
   return HERE.includes(".bun") ? "bun" : "npm";
 }
 
-function currentVersion(): string {
+export function currentVersion(): string {
   try {
     return (JSON.parse(readFileSync(join(HERE, "..", "package.json"), "utf8")).version as string) ?? "?";
   } catch {
@@ -22,18 +23,34 @@ function currentVersion(): string {
   }
 }
 
-function updateTag(current: string): string {
+export function updateTag(current: string): Channel {
   const tagIndex = process.argv.indexOf("--tag");
-  if (tagIndex !== -1 && process.argv[tagIndex + 1]) return process.argv[tagIndex + 1];
+  const explicit = tagIndex !== -1 ? process.argv[tagIndex + 1] : undefined;
+  if (explicit === "preview" || explicit === "latest") return explicit;
   return current.includes("-preview.") ? "preview" : "latest";
 }
 
 /** Latest published version from the registry (best-effort; null if npm isn't available). */
-function latestVersion(tag: string): string | null {
+export function latestVersion(tag: string): string | null {
   const r = spawnSync("npm", ["view", `${PKG}@${tag}`, "version"], { encoding: "utf8", timeout: 12000, windowsHide: true });
   return r.status === 0 ? r.stdout.trim() : null;
 }
 
+/** The global-install command opencodex would run to update on this channel. */
+export function updateCommand(installer: Installer, tag: Channel): { bin: string; args: string[] } {
+  const bin = installer === "bun" ? "bun" : "npm";
+  const args = installer === "bun"
+    ? ["add", "-g", `${PKG}@${tag}`]
+    : ["install", "-g", `${PKG}@${tag}`];
+  return { bin, args };
+}
+
+/** Human-readable form of {@link updateCommand}, used in the update prompt label. */
+export function updateCommandStr(installer: Installer, tag: Channel): string {
+  const { bin, args } = updateCommand(installer, tag);
+  return `${bin} ${args.join(" ")}`;
+}
+
 /**
  * `ocx update` fallback for source checkouts and Bun global installs. npm global installs are updated
  * in the Node bin launcher before Bun starts, so Windows does not replace the running Bun binary.
@@ -55,10 +72,7 @@ export async function runUpdate(): Promise<void> {
     return;
   }
 
-  const bin = installer === "bun" ? "bun" : "npm";
-  const cmdArgs = installer === "bun"
-    ? ["add", "-g", `${PKG}@${tag}`]
-    : ["install", "-g", `${PKG}@${tag}`];
+  const { bin, args: cmdArgs } = updateCommand(installer, tag);
   console.log(`Updating${latest ? ` to v${latest}` : ""}…\n$ ${bin} ${cmdArgs.join(" ")}`);
 
   const r = spawnSync(bin, cmdArgs, { stdio: "inherit", timeout: 180000, windowsHide: true });

package/src/usage-summary.ts

@@ -22,6 +22,14 @@ export interface UsageDay {
   requests: number;
   reportedRequests: number;
   totalTokens: number;
+  models: UsageDayModel[];
+}
+
+export interface UsageDayModel {
+  model: string;
+  provider: string;
+  requests: number;
+  totalTokens: number;
 }
 
 export interface UsageModel {
@@ -124,24 +132,43 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
   const window = rangeWindow(range, now);
   const days = range === "all" ? dayCountForAllRange(entries, now) : window.days;
   const grid = new Map<string, UsageDay>();
+  // Per-day model breakdown accumulator, keyed by day then provider/model, so the 7d bar chart can
+  // render a per-model stacked bar with a hover tooltip without a second pass over the entries.
+  const dayModels = new Map<string, Map<string, UsageDayModel>>();
+  const bumpDayModel = (dayKey: string, entry: PersistedUsageEntry): void => {
+    let models = dayModels.get(dayKey);
+    if (!models) { models = new Map(); dayModels.set(dayKey, models); }
+    const mKey = `${entry.provider}/${entry.model}`;
+    let m = models.get(mKey);
+    if (!m) { m = { model: entry.model, provider: entry.provider, requests: 0, totalTokens: 0 }; models.set(mKey, m); }
+    m.requests += 1;
+    if (typeof entry.totalTokens === "number") m.totalTokens += entry.totalTokens;
+    else if (entry.usage) m.totalTokens += entry.usage.inputTokens + entry.usage.outputTokens;
+  };
   for (let i = days - 1; i >= 0; i--) {
     const key = localDateKey(now - i * DAY_MS);
-    grid.set(key, { date: key, requests: 0, reportedRequests: 0, totalTokens: 0 });
+    grid.set(key, { date: key, requests: 0, reportedRequests: 0, totalTokens: 0, models: [] });
   }
   for (const entry of entries) {
     const key = localDateKey(entry.timestamp);
     let day = grid.get(key);
     if (!day) {
-      day = { date: key, requests: 0, reportedRequests: 0, totalTokens: 0 };
+      day = { date: key, requests: 0, reportedRequests: 0, totalTokens: 0, models: [] };
       grid.set(key, day);
     }
     day.requests += 1;
     if (entry.usageStatus === "reported") day.reportedRequests += 1;
     if (typeof entry.totalTokens === "number") day.totalTokens += entry.totalTokens;
     else if (entry.usage) day.totalTokens += entry.usage.inputTokens + entry.usage.outputTokens;
+    bumpDayModel(key, entry);
   }
   void since;
-  return [...grid.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const out = [...grid.values()].sort((a, b) => a.date.localeCompare(b.date));
+  for (const day of out) {
+    const models = dayModels.get(day.date);
+    if (models) day.models = [...models.values()].sort((a, b) => b.requests - a.requests);
+  }
+  return out;
 }
 
 function buildModels(entries: PersistedUsageEntry[], totalRequests: number): UsageModel[] {

package/src/web-search/loop.ts

@@ -130,7 +130,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       ...parsed, stream: false,
       context: { ...parsed.context, messages, tools: forceAnswer ? toolsNoWebSearch : allTools },
     };
-    const request = adapter.buildRequest(iterParsed, { headers: selectedForwardHeaders });
+    const request = await adapter.buildRequest(iterParsed, { headers: selectedForwardHeaders });
     let resp: Response;
     try {
       resp = adapter.fetchResponse