@coseung2/opencodex 2.8.0-cs.1 → 2.8.0-cs.10

package/src/providers/quota.ts

@@ -3,6 +3,7 @@ import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
 import { resolveEnvValue } from "../config";
 import { getValidAccessToken, getValidAccessTokenForAccount } from "../oauth";
 import { getAccountCredential, getAccountSet, getCredential } from "../oauth/store";
+import { readUsageEntries } from "../usage/log";
 import { antigravityUserAgent } from "../adapters/client-fingerprint";
 import { resolveKiroApiRegion, resolveKiroProfileArn } from "../oauth/kiro";
 import type { KiroOAuthMetadata } from "../oauth/types";
@@ -20,16 +21,52 @@ const ACCOUNT_TOKEN_SKEW_MS = 60_000;
 
 const CACHE_TTL_MS = 5 * 60_000;
 const REQUEST_TIMEOUT_MS = 8_000;
+/** Kiro's getUsageLimits endpoint cold-starts slowly after idle periods (>8s seen); keep a
+ *  dedicated, more generous bound so a flaky first hit does not drop the provider into the
+ *  "no quota" bucket for the rest of the negative-cache window. */
+const KIRO_QUOTA_TIMEOUT_MS = 20_000;
 const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
 const KIMI_CODE_USAGE_URL = `${KIMI_CODE_BASE_URL}/usages`;
 const KIRO_USAGE_LIMITS_PATH = "getUsageLimits";
 /** Keep a failed probe's previous row at most this long before dropping it. */
 const LAST_GOOD_MAX_AGE_MS = 30 * 60_000;
 
+const OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+const OPENCODE_GO_COST_WINDOW_MS = 30 * 86_400_000;
+const OPENCODE_GO_FIVE_HOUR_MS = 5 * 3_600_000;
+const OPENCODE_GO_WEEK_MS = 7 * 86_400_000;
+const OPENCODE_GO_USAGE_PATH = "/usage";
+
+/** opencode.go published request limits per window (1x tier), opencode.ai/docs/go. */
+const OPENCODE_GO_LIMITS: Record<string, { label: string; fiveHour: number; weekly: number; monthly: number }> = {
+  "grok-4.5": { label: "Grok 4.5", fiveHour: 120, weekly: 300, monthly: 600 },
+  "gpt-5.6-luna": { label: "GPT 5.6 Luna", fiveHour: 2_050, weekly: 5_100, monthly: 10_250 },
+  "glm-5.2": { label: "GLM-5.2", fiveHour: 880, weekly: 2_150, monthly: 4_300 },
+  "glm-5.1": { label: "GLM-5.1", fiveHour: 880, weekly: 2_150, monthly: 4_300 },
+  "kimi-k3": { label: "Kimi K3", fiveHour: 110, weekly: 250, monthly: 490 },
+  "kimi-k2.7-code": { label: "Kimi K2.7 Code", fiveHour: 1_350, weekly: 3_380, monthly: 6_750 },
+  "kimi-k2.6": { label: "Kimi K2.6", fiveHour: 1_150, weekly: 2_880, monthly: 5_750 },
+  "mimo-v2.5": { label: "MiMo-V2.5", fiveHour: 30_100, weekly: 75_200, monthly: 150_400 },
+  "mimo-v2.5-pro": { label: "MiMo-V2.5 Pro", fiveHour: 3_250, weekly: 8_150, monthly: 16_300 },
+  "minimax-m3": { label: "MiniMax M3", fiveHour: 3_200, weekly: 8_000, monthly: 16_000 },
+  "minimax-m2.7": { label: "MiniMax M2.7", fiveHour: 3_400, weekly: 8_500, monthly: 17_000 },
+  "qwen3.8-max": { label: "Qwen3.8 Max", fiveHour: 160, weekly: 400, monthly: 810 },
+  "qwen3.7-max": { label: "Qwen3.7 Max", fiveHour: 340, weekly: 840, monthly: 1_690 },
+  "qwen3.7-plus": { label: "Qwen3.7 Plus", fiveHour: 4_300, weekly: 10_800, monthly: 21_600 },
+  "qwen3.6-plus": { label: "Qwen3.6 Plus", fiveHour: 3_300, weekly: 8_200, monthly: 16_300 },
+  "deepseek-v4-pro": { label: "DeepSeek V4 Pro", fiveHour: 3_450, weekly: 8_550, monthly: 17_150 },
+  "deepseek-v4-flash": { label: "DeepSeek V4 Flash", fiveHour: 31_650, weekly: 79_050, monthly: 158_150 },
+  "hy3": { label: "Hy3", fiveHour: 4_300, weekly: 10_750, monthly: 21_500 },
+};
+
 export interface ProviderQuotaWindow {
   label: string;
   percent: number;
   resetAt?: number;
+  /** Text value shown instead of a percent bar (e.g. an estimated cost). */
+  valueLabel?: string;
+  /** Compact percent segments rendered as narrow bars on ONE row (label/percent per segment). */
+  segments?: { label: string; percent: number; resetAt?: number }[];
 }
 
 export interface ProviderQuota {
@@ -81,7 +118,8 @@ function hasQuotaRows(quota: ProviderQuota | null | undefined): quota is Provide
   return typeof quota.fiveHourPercent === "number"
     || typeof quota.weeklyPercent === "number"
     || typeof quota.monthlyPercent === "number"
-    || !!quota.customWindows?.some(window => typeof window.percent === "number");
+    || !!quota.customWindows?.some(window =>
+      typeof window.percent === "number" || typeof window.valueLabel === "string");
 }
 
 function providerLabel(providerId: string): string {
@@ -118,6 +156,13 @@ function normalizePercent(value: unknown): number | undefined {
   return numeric === undefined ? undefined : Math.max(0, Math.min(100, numeric));
 }
 
+/** Numeric value from a billing object ({ val: 123 }) or a bare number. */
+function billingValue(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const record = asRecord(value);
+  return toFiniteNumber(record?.val);
+}
+
 function asRecord(value: unknown): Record<string, unknown> | null {
   return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
 }
@@ -157,11 +202,6 @@ async function fetchChatGptForwardQuota(
   return quota ? report(provider, "chatgpt:wham", quota) : null;
 }
 
-function centsValue(value: unknown): number | undefined {
-  const rec = asRecord(value);
-  return rec ? toFiniteNumber(rec.val) : undefined;
-}
-
 async function fetchXaiQuota(provider: string): Promise<ProviderQuotaReport | null> {
   let accessToken: string;
   try {
@@ -169,25 +209,50 @@ async function fetchXaiQuota(provider: string): Promise<ProviderQuotaReport | nu
   } catch {
     return null;
   }
-  const response = await fetch("https://cli-chat-proxy.grok.com/v1/billing", {
-    headers: { Accept: "application/json", Authorization: `Bearer ${accessToken}` },
+  const response = await fetch("https://cli-chat-proxy.grok.com/v1/billing?format=credits", {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${accessToken}`,
+      "X-XAI-Token-Auth": "xai-grok-cli",
+      "x-grok-client-mode": "cli",
+    },
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
   });
   if (!response.ok) return null;
   const body = asRecord(await response.json().catch(() => null));
   const config = asRecord(body?.config);
-  if (!config) return null;
-  const limitCents = centsValue(config.monthlyLimit);
-  const usedCents = centsValue(config.used);
-  if (limitCents === undefined || usedCents === undefined || limitCents <= 0) return null;
-  const percent = normalizePercent((usedCents / limitCents) * 100);
-  if (percent === undefined) return null;
+  const currentPeriod = asRecord(config?.currentPeriod);
+  // A weekly window is the meter contract; other shapes (spend-cap etc.) fail closed.
+  if (currentPeriod?.type !== "USAGE_PERIOD_TYPE_WEEKLY") return null;
+  if (typeof currentPeriod.end !== "string" || !currentPeriod.end.trim()) return null;
+  const resetAt = normalizeResetAt(currentPeriod.end);
+  if (resetAt === undefined) return null;
+
+  let weeklyPercent: number | undefined;
+  if (typeof config?.creditUsagePercent === "number"
+    && Number.isFinite(config.creditUsagePercent)
+    && config.creditUsagePercent >= 0
+    && config.creditUsagePercent <= 100) {
+    weeklyPercent = config.creditUsagePercent;
+  } else {
+    // Unified-billing shape exposes on-demand usage vs cap as { val } objects.
+    const cap = billingValue(config?.onDemandCap);
+    const used = billingValue(config?.onDemandUsed);
+    if (cap !== undefined && cap > 0 && used !== undefined) {
+      weeklyPercent = normalizePercent((used / cap) * 100);
+    } else if (used === 0) {
+      // A zero-usage unified account still owns the weekly meter; report 0% so the
+      // provider stays in the usage section instead of being reclassified as no-quota.
+      weeklyPercent = 0;
+    }
+  }
+  if (weeklyPercent === undefined) return null;
   const quota: ProviderQuota = {
-    monthlyPercent: percent,
-    monthlyResetAt: normalizeResetAt(config.billingPeriodEnd),
+    weeklyPercent,
+    weeklyResetAt: resetAt,
     updatedAt: Date.now(),
   };
-  return report(provider, "xai:grok-billing", quota);
+  return report(provider, "xai:grok-credits", quota);
 }
 
 function parseClaudeBucket(value: unknown): { percent?: number; resetAt?: number } | null {
@@ -225,7 +290,7 @@ async function fetchKiroUsageQuota(
 
   const response = await fetch(url, {
     headers: { Accept: "application/json", Authorization: `Bearer ${accessToken}` },
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    signal: AbortSignal.timeout(KIRO_QUOTA_TIMEOUT_MS),
   });
   if (!response.ok) return null;
   const body = asRecord(await response.json().catch(() => null));
@@ -701,6 +766,230 @@ async function fetchKimiQuota(provider: string, config: OcxProviderConfig): Prom
   return quota ? report(provider, "kimi:usages", quota) : null;
 }
 
+function isCanonicalOpencodeGoBaseUrl(baseUrl: string | undefined): boolean {
+  return normalizedBaseUrl(baseUrl ?? "") === normalizedBaseUrl(OPENCODE_GO_BASE_URL);
+}
+
+interface OpencodeGoUsageEstimate {
+  /** model -> request count in each window (status 200). */
+  fiveHourCounts: Map<string, number>;
+  weeklyCounts: Map<string, number>;
+  monthlyCounts: Map<string, number>;
+  /** key id -> 30-day request count (all traffic attributed to the active key). */
+  perKeyMonthlyCounts: Map<string, number>;
+}
+
+/**
+ * Read the local usage log once and count opencode.go requests per model per window.
+ * The console's allocation percent is request-count based (each model has published
+ * 5h/week/month request limits on opencode.ai/docs/go), so we compare like with like.
+ *
+ * Attribution: the pool's ACTIVE key serves every provider-bound request (loopback
+ * traffic carries no client key id), so all rows are charged to it. Rows written before
+ * a key switch stay with the currently active key — an intentional approximation.
+ */
+function estimateOpencodeGoUsage(name: string, config: OcxProviderConfig): OpencodeGoUsageEstimate | null {
+  if (!isCanonicalOpencodeGoBaseUrl(config.baseUrl)) return null;
+  const now = Date.now();
+  const fiveHourAgo = now - OPENCODE_GO_FIVE_HOUR_MS;
+  const monthAgo = now - OPENCODE_GO_COST_WINDOW_MS;
+  const pool = config.apiKeyPool ?? [];
+  const activeKey = resolveEnvValue(config.apiKey)?.trim() ?? config.apiKey;
+  const activeKeyId = activeKey ? pool.find(entry => entry.key === activeKey)?.id : undefined;
+
+  const estimate: OpencodeGoUsageEstimate = {
+    fiveHourCounts: new Map(),
+    weeklyCounts: new Map(),
+    monthlyCounts: new Map(),
+    perKeyMonthlyCounts: new Map(pool.map(entry => [entry.id, 0])),
+  };
+  for (const entry of readUsageEntries()) {
+    if (entry.provider !== name || entry.status !== 200) continue;
+    const timestamp = entry.timestamp ?? 0;
+    if (!OPENCODE_GO_LIMITS[entry.model]) continue;
+    if (timestamp >= fiveHourAgo) {
+      estimate.fiveHourCounts.set(entry.model, (estimate.fiveHourCounts.get(entry.model) ?? 0) + 1);
+    }
+    if (timestamp >= now - OPENCODE_GO_WEEK_MS) {
+      estimate.weeklyCounts.set(entry.model, (estimate.weeklyCounts.get(entry.model) ?? 0) + 1);
+    }
+    if (timestamp >= monthAgo && activeKeyId) {
+      estimate.monthlyCounts.set(entry.model, (estimate.monthlyCounts.get(entry.model) ?? 0) + 1);
+      estimate.perKeyMonthlyCounts.set(activeKeyId, (estimate.perKeyMonthlyCounts.get(activeKeyId) ?? 0) + 1);
+    }
+  }
+  return estimate;
+}
+
+interface OpencodeGoUsageWindow {
+  percent?: number;
+  resetAt?: number;
+}
+
+/**
+ * Real allocation windows from the opencode.go usage endpoint (key-scoped).
+ * The console shows exactly these percents and reset times, so this replaces the
+ * local estimate whenever the endpoint answers.
+ */
+async function fetchOpencodeGoUsageApi(apiKey: string | undefined): Promise<{
+  fiveHour: OpencodeGoUsageWindow;
+  weekly: OpencodeGoUsageWindow;
+  monthly: OpencodeGoUsageWindow;
+} | null> {
+  if (!apiKey?.trim()) return null;
+  const response = await fetch(`${OPENCODE_GO_BASE_URL}${OPENCODE_GO_USAGE_PATH}`, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey.trim()}`,
+    },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) return null;
+  const body = asRecord(await response.json().catch(() => null));
+  const usage = asRecord(body?.usage);
+  if (!usage) return null;
+  const parse = (raw: unknown): OpencodeGoUsageWindow => {
+    const window = asRecord(raw);
+    const percent = normalizePercent(toFiniteNumber(window?.percent));
+    const resetAt = normalizeResetAt(window?.resetsAt);
+    return {
+      ...(percent !== undefined ? { percent } : {}),
+      ...(resetAt !== undefined ? { resetAt } : {}),
+    };
+  };
+  const fiveHour = parse(usage.rolling);
+  const weekly = parse(usage.weekly);
+  const monthly = parse(usage.monthly);
+  if (fiveHour.percent === undefined && weekly.percent === undefined && monthly.percent === undefined) {
+    return null;
+  }
+  return { fiveHour, weekly, monthly };
+}
+
+function opencodeGoSegments(api: NonNullable<Awaited<ReturnType<typeof fetchOpencodeGoUsageApi>>>): NonNullable<ProviderQuotaWindow["segments"]> {
+  const segments: NonNullable<ProviderQuotaWindow["segments"]> = [];
+  const push = (label: string, window: OpencodeGoUsageWindow) => {
+    if (window.percent === undefined) return;
+    segments.push({
+      label,
+      percent: window.percent,
+      ...(window.resetAt !== undefined ? { resetAt: window.resetAt } : {}),
+    });
+  };
+  push("5h", api.fiveHour);
+  push("Weekly", api.weekly);
+  push("Monthly", api.monthly);
+  return segments;
+}
+
+/**
+ * opencode.go allocation: prefer the key-scoped usage endpoint (exact console
+ * percents + real reset times); fall back to the local request-count estimate
+ * against published limits when the endpoint is unreachable or rejects.
+ */
+async function fetchOpencodeGoQuota(name: string, config: OcxProviderConfig): Promise<ProviderQuotaReport | null> {
+  const activeKey = resolveEnvValue(config.apiKey)?.trim() ?? config.apiKey;
+  const api = await fetchOpencodeGoUsageApi(activeKey).catch(() => null);
+  if (api) {
+    const segments = opencodeGoSegments(api);
+    if (segments.length > 0) {
+      return report(name, "opencode-go:usage-api", {
+        customWindows: [{
+          // Row label intentionally empty: the segments carry their own labels.
+          label: "",
+          percent: 0,
+          segments,
+        }],
+        updatedAt: Date.now(),
+      });
+    }
+  }
+
+  // Fallback: dominant model's local request counts against published limits.
+  const estimate = estimateOpencodeGoUsage(name, config);
+  if (!estimate) return null;
+  const dominant = [...estimate.monthlyCounts.entries()]
+    .sort((a, b) => b[1] - a[1] || (estimate.weeklyCounts.get(b[0]) ?? 0) - (estimate.weeklyCounts.get(a[0]) ?? 0))[0]?.[0];
+  if (!dominant) return null;
+  const { fiveHour, weekly, monthly } = OPENCODE_GO_LIMITS[dominant]!;
+  const now = Date.now();
+  return report(name, "opencode-go:docs-estimate", {
+    customWindows: [{
+      label: "",
+      percent: 0,
+      segments: [
+        {
+          label: "5h",
+          percent: normalizePercent(((estimate.fiveHourCounts.get(dominant) ?? 0) / fiveHour) * 100) ?? 0,
+          resetAt: now + OPENCODE_GO_FIVE_HOUR_MS,
+        },
+        {
+          label: "Weekly",
+          percent: normalizePercent(((estimate.weeklyCounts.get(dominant) ?? 0) / weekly) * 100) ?? 0,
+          resetAt: now + OPENCODE_GO_WEEK_MS,
+        },
+        {
+          label: "Monthly",
+          percent: normalizePercent(((estimate.monthlyCounts.get(dominant) ?? 0) / monthly) * 100) ?? 0,
+          resetAt: now + OPENCODE_GO_COST_WINDOW_MS,
+        },
+      ],
+    }],
+    updatedAt: now,
+  });
+}
+
+/**
+ * Per-key monthly-allocation percent for every connected key: the usage endpoint
+ * answers per key, so each pool key reports its own real monthly percent. Keys the
+ * endpoint rejects fall back to the local 30-day request estimate.
+ */
+export async function opencodeGoKeyQuotaEstimates(config: OcxConfig, name: string): Promise<Record<string, ProviderQuota> | null> {
+  const provider = config.providers[name];
+  if (!provider) return null;
+  const now = Date.now();
+  const out: Record<string, ProviderQuota> = {};
+  const pool = provider.apiKeyPool ?? [];
+  if (pool.length > 0) {
+    const results = await Promise.all(pool.map(async entry => {
+      const api = await fetchOpencodeGoUsageApi(entry.key).catch(() => null);
+      return [entry.id, api?.monthly] as const;
+    }));
+    for (const [keyId, monthly] of results) {
+      if (monthly?.percent === undefined) continue;
+      out[keyId] = {
+        customWindows: [{
+          label: "월간 할당",
+          percent: monthly.percent,
+          ...(monthly.resetAt !== undefined ? { resetAt: monthly.resetAt } : {}),
+        }],
+        updatedAt: now,
+      };
+    }
+  }
+  // Fallback for keys the endpoint did not answer.
+  const estimate = estimateOpencodeGoUsage(name, provider);
+  if (estimate) {
+    const dominant = [...estimate.monthlyCounts.entries()]
+      .sort((a, b) => b[1] - a[1])[0]?.[0];
+    if (dominant) {
+      const monthlyLimit = OPENCODE_GO_LIMITS[dominant]!.monthly;
+      for (const [keyId, count] of estimate.perKeyMonthlyCounts) {
+        if (out[keyId]) continue;
+        out[keyId] = {
+          customWindows: [{
+            label: "월간 할당",
+            percent: normalizePercent((count / monthlyLimit) * 100) ?? 0,
+            resetAt: now + OPENCODE_GO_COST_WINDOW_MS,
+          }],
+          updatedAt: now,
+        };
+      }
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
 /** Cursor included usage via api2.cursor.sh (Bearer from OAuth) — unofficial, may change. */
 async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport | null> {
   let accessToken: string;
@@ -981,6 +1270,11 @@ async function maybeFetchProviderQuota(
     if (provider.authMode === "oauth" && name === "kiro") return fetchKiroQuota(name, forceRefresh);
     if (provider.authMode === "oauth" && name === "cursor") return fetchCursorQuota(name);
     if (provider.authMode === "oauth" && name === "google-antigravity") return fetchAntigravityQuota(name, provider);
+    // opencode.go is a key-auth subscription: estimate usage locally from the traffic log.
+    if (provider.authMode !== "oauth" && provider.authMode !== "forward"
+      && isCanonicalOpencodeGoBaseUrl(provider.baseUrl)) {
+      return fetchOpencodeGoQuota(name, provider);
+    }
     // Kimi Code `/usages` accepts OAuth or coding-plan API keys, but only on the canonical
     // host and only for real key auth — forward/local modes carry no credential of ours.
     if (provider.authMode === "oauth" && name === "kimi") return fetchKimiQuota(name, provider);

package/src/providers/registry.ts

@@ -728,6 +728,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     baseUrl: "https://runtime.us-east-1.kiro.dev",
     authKind: "oauth",
     oauthId: "kiro",
+    dashboardPreset: true,
     note: "Import-first: reuses your installed and signed-in Kiro CLI session (requires `kiro-cli login`). Add account logs `kiro-cli` out, switches it through a fresh browser login, stores the account by profile ARN, and restores the previous CLI session on cancellation or failure. Experimental third-party harness — see Kiro ToS.",
     models: KIRO_MODELS,
     defaultModel: "kiro-auto",

package/src/responses/parser.ts

@@ -267,6 +267,7 @@ const REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "
 
 export function parseRequest(body: unknown): OcxParsedRequest {
   const replayedInputPrefixLength = previousResponseReplayPrefixLength(body);
+  let replayedMessagePrefixLength = 0;
   const parsed = responsesRequestSchema.safeParse(body);
   if (!parsed.success) {
     throw new Error(`responses parse error: ${parsed.error.message}`);
@@ -305,6 +306,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
     messages.push({ role: "user", content: data.input, timestamp: now });
   } else if (data.input) {
     for (let inputIndex = 0; inputIndex < data.input.length; inputIndex++) {
+      if (inputIndex === replayedInputPrefixLength) replayedMessagePrefixLength = messages.length;
       const item = data.input[inputIndex];
       const effectiveType = (item as { type?: string }).type ?? ("role" in item ? "message" : undefined);
 
@@ -571,6 +573,9 @@ export function parseRequest(body: unknown): OcxParsedRequest {
         });
       }
     }
+    if (replayedInputPrefixLength > 0 && replayedInputPrefixLength >= data.input.length) {
+      replayedMessagePrefixLength = messages.length;
+    }
   }
 
   const declaredTools = buildTools(data.tools as unknown[] | undefined) ?? [];
@@ -637,7 +642,10 @@ export function parseRequest(body: unknown): OcxParsedRequest {
     stream: data.stream === true,
     options,
     _rawBody: body,
-    ...(replayedInputPrefixLength > 0 ? { _replayPrefixLen: replayedInputPrefixLength } : {}),
+    ...(replayedInputPrefixLength > 0 ? {
+      _replayPrefixLen: replayedInputPrefixLength,
+      _replayMessagePrefixLen: replayedMessagePrefixLength,
+    } : {}),
     ...(webSearch ? { _webSearch: webSearch } : {}),
     ...(imageGen ? { _imageGeneration: imageGen } : {}),
     ...(structuredOutput ? { _structuredOutput: true } : {}),

package/src/responses/state.ts

@@ -1,5 +1,6 @@
 import { chmodSync, existsSync, lstatSync, mkdirSync, opendirSync, readFileSync, rmSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { atomicWriteFileAsync, getConfigDir } from "../config";
 import { enforceAppOwnedMemoryBudget, type RetainedStoreSnapshot } from "../lib/app-owned-memory";
 import type { OcxProviderContinuationState } from "../types";
@@ -584,6 +585,14 @@ function inputItems(input: unknown): unknown[] {
   return [input];
 }
 
+function startsWithReplayPrefix(input: unknown[], prefix: unknown[]): boolean {
+  if (prefix.length === 0 || input.length < prefix.length) return false;
+  for (let index = 0; index < prefix.length; index++) {
+    if (!isDeepStrictEqual(input[index], prefix[index])) return false;
+  }
+  return true;
+}
+
 function pruneResponses(at = now()): void {
   for (const [id, state] of states) {
     if (at - state.createdAt > RESPONSE_TTL_MS) deleteEntry(id);
@@ -710,11 +719,19 @@ export function expandPreviousResponseInput(body: unknown): unknown {
     replayFailures.set(request, materialized.failure);
     return body;
   }
+  const previousItems = materialized.state.items;
+  const currentItems = inputItems(request.input);
+  // Some Responses clients send the complete prior input while still supplying
+  // previous_response_id. Treat an exact stored prefix as already expanded instead of prepending
+  // it a second time; keep the provenance marker so downstream adapters can distinguish replayed
+  // history from this turn's new input.
   const expanded = {
     ...request,
-    input: [...materialized.state.items, ...inputItems(request.input)],
+    input: startsWithReplayPrefix(currentItems, previousItems)
+      ? [...currentItems]
+      : [...previousItems, ...currentItems],
   };
-  replayedInputPrefixLengths.set(expanded, materialized.state.items.length);
+  replayedInputPrefixLengths.set(expanded, previousItems.length);
   return expanded;
 }
 

package/src/server/lifecycle.ts

@@ -34,6 +34,8 @@ export interface ActiveTurnLease extends AdmissionLease {
 const activeTurns = new Map<AbortController, ActiveTurnLease>();
 const admittedTurns = new Set<ActiveTurnLease>();
 const knownTurnControllers = new WeakSet<AbortController>();
+export type ActiveTurnsIdleListener = () => void;
+const activeTurnsIdleListeners = new Set<ActiveTurnsIdleListener>();
 let turnReleaseMisses = 0;
 let draining = false;
 let recyclingForExit = false;
@@ -41,6 +43,26 @@ let _serverRef: ReturnType<typeof Bun.serve> | undefined;
 
 export function setServerRef(server: ReturnType<typeof Bun.serve> | undefined): void { _serverRef = server; }
 export function setDraining(value: boolean): void { draining = value; }
+/**
+ * Subscribe to the synchronous transition where the final admitted turn is
+ * released. The callback runs after the lease and admission gate are settled,
+ * so an observer can perform an idle-only action without racing a request on
+ * the event loop. Returns an unsubscribe function for bounded observers.
+ */
+export function onActiveTurnsIdle(listener: ActiveTurnsIdleListener): () => void {
+  activeTurnsIdleListeners.add(listener);
+  return () => { activeTurnsIdleListeners.delete(listener); };
+}
+function notifyActiveTurnsIdle(): void {
+  if (admittedTurns.size !== 0) return;
+  for (const listener of [...activeTurnsIdleListeners]) {
+    try {
+      listener();
+    } catch {
+      // An idle observer must never break turn release or request teardown.
+    }
+  }
+}
 export function tryAdmitTurn(): ActiveTurnLease | null {
   const gateLease = turnGate.tryAcquire();
   if (!gateLease) return null;
@@ -68,6 +90,7 @@ export function tryAdmitTurn(): ActiveTurnLease | null {
       }
       controllers.clear();
       gateLease.release();
+      notifyActiveTurnsIdle();
     },
   };
   admittedTurns.add(lease);

package/src/server/management/oauth-account-routes.ts

@@ -417,7 +417,17 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
     const name = (url.searchParams.get("name") ?? "").trim();
     if (!name || !isValidProviderName(name) || !hasOwnProvider(config.providers, name)) return jsonResponse({ error: "unknown provider" }, 404);
     const { listProviderApiKeys } = await import("../../providers/api-keys");
-    return jsonResponse(listProviderApiKeys(config, name));
+    const { opencodeGoKeyQuotaEstimates } = await import("../../providers/quota");
+    const result = listProviderApiKeys(config, name);
+    const keyQuotas = await opencodeGoKeyQuotaEstimates(config, name);
+    if (!keyQuotas) return jsonResponse(result);
+    return jsonResponse({
+      ...result,
+      keys: result.keys.map(key => ({
+        ...key,
+        ...(keyQuotas[key.id] ? { quota: keyQuotas[key.id] } : {}),
+      })),
+    });
   }
   if (url.pathname === "/api/providers/keys" && req.method === "POST") {
     const body = await readManagementJsonBodyOr(req, {}) as { name?: string; key?: string; label?: string };