From f67f20721fdbfc39592a5b0ee77bed7fd14875e7 Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:01:44 +0800 Subject: [PATCH 1/6] fix(renderer): stop Codex draft quota refresh loops --- .../src/renderer-binding-probe.ts | 58 +++++------ ...enderer-binding-probe-host-catalog.test.ts | 98 +++++++++++++++++++ 2 files changed, 128 insertions(+), 28 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index c8f6eca47d..5631d6be55 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -779,7 +779,12 @@ export function installRendererBindingProbe( const catalogRequests = new WeakMap(); const draftUsageRequests = new WeakMap< MountedComposer, - { client: RendererModelClient | null; generation: number; pending: boolean } + { + client: RendererModelClient | null; + accountId: string | null; + generation: number; + pending: boolean; + } >(); const pendingReplacements = new Map(); let disposed = false; @@ -1240,35 +1245,35 @@ export function installRendererBindingProbe( } }; + const canRefreshDraftUsage = (mounted: MountedComposer): boolean => + controller.get(mounted.composer).phase === "draft" && + !controller.isSwitching(mounted.composer) && + !controller.isSubmissionPending(mounted.composer) && + threadIdFromComposerModelTarget(mounted.modelTarget) === null; + const refreshDraftUsage = async (mounted: MountedComposer): Promise => { - const state = controller.get(mounted.composer); - if ( - state.phase !== "draft" || - controller.isSwitching(mounted.composer) || - controller.isSubmissionPending(mounted.composer) || - threadIdFromComposerModelTarget(mounted.modelTarget) - ) - return; - const agent = state.agent; + if (!canRefreshDraftUsage(mounted)) return; + const agent = controller.get(mounted.composer).agent; const accounts = agent === "codex" ? composerCodexAccounts(mounted.composer) : null; - const accountId = accounts?.readyAccountId; + const accountId = accounts?.readyAccountId ?? null; const client = composerClient(mounted); const hostId = mounted.hostId; const previous = draftUsageRequests.get(mounted); - if ( - agent !== "codex" && - previous?.pending && + const sameScope = + previous?.generation === mounted.usageRequestGeneration && previous.client === client && - previous.generation === mounted.usageRequestGeneration - ) - return; + previous.accountId === accountId; + if (sameScope && previous.pending) return; const generation = ++mounted.usageRequestGeneration; - const request = { client, generation, pending: true }; + const request = { client, accountId, generation, pending: true }; draftUsageRequests.set(mounted, request); mounted.draftUsageClient = null; - mounted.usage = null; - mounted.accountCredits = null; - mounted.accountCreditsSupported = false; + // Keep the last snapshot on screen while the same Codex Account refreshes. + if (!sameScope || accountId === null) { + mounted.usage = null; + mounted.accountCredits = null; + mounted.accountCreditsSupported = false; + } renderMounted(mounted); const isCurrent = (): boolean => !disposed && @@ -1278,10 +1283,7 @@ export function installRendererBindingProbe( mountedByComposer.get(mounted.composer) === mounted && mounted.usageRequestGeneration === generation && controller.get(mounted.composer).agent === agent && - controller.get(mounted.composer).phase === "draft" && - !controller.isSwitching(mounted.composer) && - !controller.isSubmissionPending(mounted.composer) && - !threadIdFromComposerModelTarget(mounted.modelTarget); + canRefreshDraftUsage(mounted); try { if (!client) return; if (agent === "codex") { @@ -2715,18 +2717,18 @@ export function installRendererBindingProbe( reloadMountedOwnershipForHost(); // Draft quota follows the concrete client, including connections without notifications. for (const mounted of mountedByComposer.values()) { + if (!canRefreshDraftUsage(mounted)) continue; const client = composerClient(mounted); const request = draftUsageRequests.get(mounted); - const state = controller.get(mounted.composer); if ( - state.phase === "draft" && mounted.draftUsageClient !== client && (!request || request.client !== client || request.generation !== mounted.usageRequestGeneration || (retryDraftUsage && !request.pending)) ) { - if (state.agent === "codex") void loadCodexAccountsForHost(mounted.hostId); + if (controller.get(mounted.composer).agent === "codex") + void loadCodexAccountsForHost(mounted.hostId); else void refreshDraftUsage(mounted); } } diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index 39174c9cb2..6cd75377a7 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -3,6 +3,9 @@ import { harnessPluginDescriptorSchema, harnessModelRefSchema, harnessThinkingOptionIdSchema, + type AccountCreditsSnapshot, + type CodexAccountListResult, + type CodexAccountUsageResult, } from "@codexhost/shared-contracts"; import { afterEach, assert, describe, expect, it, vi } from "vitest"; @@ -12,6 +15,7 @@ import { rendererModelSelectionFailed, type RendererModelControlView, } from "../src/renderer-model-picker.js"; +import type { RendererModelClient } from "../src/renderer-model-client.js"; import type { RendererRequestOptions } from "../src/renderer-request-sender.js"; import type { installRendererSidebarAgentIcons } from "../src/renderer-sidebar-agent-icons.js"; import type { RendererConnectionDiagnostics } from "../src/settings/connections-page.js"; @@ -23,6 +27,7 @@ const testState = vi.hoisted(() => ({ editor: null as unknown as Element, sendButton: null as unknown as HTMLButtonElement, renderedModelViews: [] as RendererModelControlView[], + renderedCredits: [] as Array, selectModel: null as null | ((modelId: string) => void), selectThinking: null as null | ((thinkingOptionId: string) => void), getConnectionDiagnostics: null as null | (() => RendererConnectionDiagnostics | null), @@ -82,8 +87,12 @@ vi.mock("../src/renderer-composer-dom.js", async (importOriginal) => { _switching: unknown, _availability: unknown, modelView: RendererModelControlView, + _permissionModeView: unknown, + _usage: unknown, + accountCredits: AccountCreditsSnapshot | null, ) => { testState.renderedModelViews.push({ ...modelView }); + testState.renderedCredits.push(accountCredits); }, reconcileComposerNativeControls: vi.fn(), disposeComposerAgentControl: vi.fn(), @@ -214,6 +223,7 @@ function installFakeBrowser(): void { testState.editor = editor; testState.sendButton = sendButton; testState.renderedModelViews = []; + testState.renderedCredits = []; testState.selectModel = null; testState.selectThinking = null; testState.getConnectionDiagnostics = null; @@ -295,6 +305,94 @@ afterEach(() => { vi.clearAllMocks(); }); +describe("Renderer binding Codex draft quota", () => { + const account: CodexAccountListResult = { + version: 2, + currentAccountId: "test-account", + phase: "ready", + revision: 1, + accounts: [{ accountId: "test-account", label: "Test account" }], + }; + + async function mountWithAccountClient( + accountClient: Pick, + ): Promise { + const host = { + listHarnessPlugins: async () => ({ plugins: [] }), + inspectThread: async () => { + throw new Error("Thread ownership unavailable"); + }, + ...accountClient, + }; + const { installRendererBindingProbe } = await import("../src/renderer-binding-probe.js"); + const probe = installRendererBindingProbe({ enabledAgents: ["codex"], defaultAgent: "codex" }); + probe.setAdapter( + { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, + undefined, + undefined, + { currentHostId: () => "local", clientForHost: () => host } as never, + ); + } + + it("does not retry the account list on DOM changes for an existing Thread with failed ownership", async () => { + installFakeBrowser(); + const listCodexAccounts = vi.fn(async () => account); + await mountWithAccountClient({ listCodexAccounts }); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalled()); + await new Promise((resolve) => setImmediate(resolve)); + + const readsBeforeScan = listCodexAccounts.mock.calls.length; + const notify = testState.notifyMutations; + assert(notify); + notify([{ type: "attributes", target: testState.composer } as MutationRecord]); + for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); + await new Promise((resolve) => setImmediate(resolve)); + + expect(listCodexAccounts).toHaveBeenCalledTimes(readsBeforeScan); + }); + + it("keeps the same Codex Account's quota visible while refreshing it", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const initial: CodexAccountUsageResult = { + accountId: "test-account", + usage: null, + accountCredits: { usedPercent: 8, periodType: "weekly" }, + freshness: "live", + observedAt: null, + }; + const inspectCodexAccountUsage = vi.fn(async () => initial); + await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(initial.accountCredits), + ); + + const pending = Promise.withResolvers(); + inspectCodexAccountUsage.mockReturnValue(pending.promise); + const readsBeforeFocus = inspectCodexAccountUsage.mock.calls.length; + const rendersBeforeFocus = testState.renderedCredits.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(readsBeforeFocus + 1), + ); + const hidQuota = testState.renderedCredits + .slice(rendersBeforeFocus) + .some((credits) => credits === null); + const updated = { + ...initial, + accountCredits: { usedPercent: 18, periodType: "weekly" as const }, + }; + pending.resolve(updated); + expect(hidQuota).toBe(false); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(updated.accountCredits), + ); + }); +}); + describe("Renderer binding Host-scoped Claude catalogs", () => { it("loads remote sidebar artwork before any Composer opens on that Host", async () => { installFakeBrowser(); From 035ada252f75d4a87d593eef4425ad97d459cf81 Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:17:36 +0800 Subject: [PATCH 2/6] fix(renderer): scope draft quota to the account lifetime --- .../src/renderer-binding-probe.ts | 64 ++++++---- .../src/renderer-codex-account-state.ts | 31 ++++- ...enderer-binding-probe-host-catalog.test.ts | 119 ++++++++++++++---- .../test/renderer-codex-account-state.test.ts | 44 ++++++- 4 files changed, 213 insertions(+), 45 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index 5631d6be55..dec8ab1c7d 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -603,6 +603,7 @@ interface MountedComposer { hostId: string | null; usageRequestGeneration: number; draftUsageClient: RendererModelClient | null; + draftUsageAccount: RendererCodexAccountState["usageAccount"]; commandRequestGeneration: number; } @@ -781,7 +782,7 @@ export function installRendererBindingProbe( MountedComposer, { client: RendererModelClient | null; - accountId: string | null; + account: RendererCodexAccountState["usageAccount"]; generation: number; pending: boolean; } @@ -935,10 +936,9 @@ export function installRendererBindingProbe( const state = hostHarnessAvailabilityState(hostId); if (state.codexAccounts?.client !== client) { state.codexAccounts?.dispose(); - state.codexAccounts = new RendererCodexAccountState(client, () => { + const accounts = new RendererCodexAccountState(client, () => { queueMicrotask(() => { - if (disposed || hostHarnessAvailabilityState(hostId).codexAccounts?.client !== client) - return; + if (disposed || harnessAvailabilityByHost.get(hostId)?.codexAccounts !== accounts) return; for (const mounted of mountedByComposer.values()) { if (mounted.hostId !== hostId) continue; renderMounted(mounted); @@ -946,6 +946,7 @@ export function installRendererBindingProbe( } }); }); + state.codexAccounts = accounts; } return state.codexAccounts; }; @@ -1063,6 +1064,13 @@ export function installRendererBindingProbe( : "installing"; }; + const clearDraftUsageSnapshot = (mounted: MountedComposer): void => { + mounted.draftUsageAccount = null; + mounted.usage = null; + mounted.accountCredits = null; + mounted.accountCreditsSupported = false; + }; + const renderMounted = (mounted: MountedComposer): void => { if (!isMountedComposer(mounted.composer)) return; restorePendingDraftPreference(mounted); @@ -1075,12 +1083,21 @@ export function installRendererBindingProbe( : EMPTY_PLUGINS, ); const accounts = composerCodexAccounts(mounted.composer); + const selection = controller.get(mounted.composer); + if ( + selection.agent === "codex" && + threadIdFromComposerModelTarget(mounted.modelTarget) === null && + mounted.draftUsageAccount && + mounted.draftUsageAccount !== accounts?.usageAccount + ) { + clearDraftUsageSnapshot(mounted); + } const currentCodexAccount = accounts?.accounts.find( ({ accountId }) => accountId === accounts.readyAccountId, ); const externalSubmissionReady = renderComposerAgentControl( mounted.control, - controller.get(mounted.composer), + selection, composerAdapterState(mounted), controller.isSwitching(mounted.composer) || mounted.ownershipStatus === "loading", composerAvailability(mounted), @@ -1255,24 +1272,22 @@ export function installRendererBindingProbe( if (!canRefreshDraftUsage(mounted)) return; const agent = controller.get(mounted.composer).agent; const accounts = agent === "codex" ? composerCodexAccounts(mounted.composer) : null; - const accountId = accounts?.readyAccountId ?? null; + const account = accounts?.usageAccount ?? null; const client = composerClient(mounted); const hostId = mounted.hostId; const previous = draftUsageRequests.get(mounted); const sameScope = previous?.generation === mounted.usageRequestGeneration && previous.client === client && - previous.accountId === accountId; + previous.account === account; if (sameScope && previous.pending) return; const generation = ++mounted.usageRequestGeneration; - const request = { client, accountId, generation, pending: true }; + const request = { client, account, generation, pending: true }; draftUsageRequests.set(mounted, request); mounted.draftUsageClient = null; // Keep the last snapshot on screen while the same Codex Account refreshes. - if (!sameScope || accountId === null) { - mounted.usage = null; - mounted.accountCredits = null; - mounted.accountCreditsSupported = false; + if (account === null || mounted.draftUsageAccount !== account) { + clearDraftUsageSnapshot(mounted); } renderMounted(mounted); const isCurrent = (): boolean => @@ -1287,15 +1302,17 @@ export function installRendererBindingProbe( try { if (!client) return; if (agent === "codex") { - if (!accountId || !client.inspectCodexAccountUsage) return; - const result = await client.inspectCodexAccountUsage({ accountId }); + if (!account) return; + const usageRequest = accounts?.inspectUsage(account); + if (!usageRequest) return; + const result = await usageRequest; if ( !isCurrent() || - composerCodexAccounts(mounted.composer) !== accounts || - accounts?.readyAccountId !== accountId || - result.accountId !== accountId + composerCodexAccounts(mounted.composer)?.usageAccount !== account || + result.accountId !== account.accountId ) return; + mounted.draftUsageAccount = account; mounted.usage = result.usage; mounted.accountCredits = result.accountCredits ?? null; } else { @@ -1310,7 +1327,7 @@ export function installRendererBindingProbe( mounted.draftUsageClient = client; renderMounted(mounted); } catch { - // Unknown quota stays empty instead of retaining another Account or Harness's values. + // A failed refresh leaves the current snapshot intact. Scope changes clear it above. } finally { request.pending = false; } @@ -2306,9 +2323,7 @@ export function installRendererBindingProbe( for (const candidate of mountedByComposer.values()) { if (controller.get(candidate.composer).composerId !== composerId) continue; candidate.usageRequestGeneration += 1; - candidate.usage = null; - candidate.accountCredits = null; - candidate.accountCreditsSupported = false; + clearDraftUsageSnapshot(candidate); usageRefreshAttempts.delete(candidate.composer); const timer = usageRefreshTimers.get(candidate.composer); if (timer !== undefined) { @@ -2718,6 +2733,12 @@ export function installRendererBindingProbe( // Draft quota follows the concrete client, including connections without notifications. for (const mounted of mountedByComposer.values()) { if (!canRefreshDraftUsage(mounted)) continue; + if ( + mounted.draftUsageAccount && + mounted.draftUsageAccount !== composerCodexAccounts(mounted.composer)?.usageAccount + ) { + renderMounted(mounted); + } const client = composerClient(mounted); const request = draftUsageRequests.get(mounted); if ( @@ -2988,6 +3009,7 @@ export function installRendererBindingProbe( hostId: inherited?.hostId ?? hostId, usageRequestGeneration: 0, draftUsageClient: null, + draftUsageAccount: inherited?.draftUsageAccount ?? null, commandRequestGeneration: 0, }; mountedByComposer.set(composer, mounted); diff --git a/packages/renderer-extension/src/renderer-codex-account-state.ts b/packages/renderer-extension/src/renderer-codex-account-state.ts index dc94a1d04e..d9b01e21a7 100644 --- a/packages/renderer-extension/src/renderer-codex-account-state.ts +++ b/packages/renderer-extension/src/renderer-codex-account-state.ts @@ -1,4 +1,8 @@ -import type { CodexAccountListResult, CodexAccountSummary } from "@codexhost/shared-contracts"; +import type { + CodexAccountListResult, + CodexAccountSummary, + CodexAccountUsageResult, +} from "@codexhost/shared-contracts"; import type { RendererModelClient } from "./renderer-model-client.js"; export function resolveCurrentCodexAccountId( @@ -21,6 +25,8 @@ export function shouldApplyCodexAccountSnapshot( return next.revision >= current.revision; } +type CodexUsageAccount = { readonly accountId: string }; + /** One Host-wide current Account snapshot; no Composer or draft override. */ export class RendererCodexAccountState { accounts: readonly CodexAccountSummary[] = []; @@ -30,6 +36,8 @@ export class RendererCodexAccountState { instanceId: string | undefined; #hasSnapshot = false; #request: Promise | null = null; + #usageAccount: (CodexUsageAccount & { pending: Promise | null }) | null = + null; readonly #unsubscribe: (() => void) | undefined; constructor( @@ -54,6 +62,22 @@ export class RendererCodexAccountState { ); } + /** Identity of the ready Account on this Host instance. */ + get usageAccount(): CodexUsageAccount | null { + return this.#usageAccount; + } + + inspectUsage(account: CodexUsageAccount): Promise | null { + const current = this.#usageAccount; + if (current !== account || !this.client.inspectCodexAccountUsage) return null; + current.pending ??= this.client + .inspectCodexAccountUsage({ accountId: current.accountId }) + .finally(() => { + current.pending = null; + }); + return current.pending; + } + refresh(): Promise { if (this.#request) return this.#request; this.#request = Promise.resolve() @@ -84,12 +108,17 @@ export class RendererCodexAccountState { ) { return false; } + const instanceChanged = this.instanceId !== result.instanceId; this.#hasSnapshot = true; this.accounts = result.accounts; this.currentAccountId = result.currentAccountId; this.phase = result.phase; this.revision = result.revision; this.instanceId = result.instanceId; + const accountId = this.readyAccountId; + if (instanceChanged || (this.#usageAccount?.accountId ?? null) !== accountId) { + this.#usageAccount = accountId === null ? null : { accountId, pending: null }; + } return true; } } diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index 6cd75377a7..34258f33d4 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -306,6 +306,10 @@ afterEach(() => { }); describe("Renderer binding Codex draft quota", () => { + type AccountClient = Pick< + RendererModelClient, + "listCodexAccounts" | "inspectCodexAccountUsage" | "subscribeCodexAccounts" + >; const account: CodexAccountListResult = { version: 2, currentAccountId: "test-account", @@ -313,25 +317,37 @@ describe("Renderer binding Codex draft quota", () => { revision: 1, accounts: [{ accountId: "test-account", label: "Test account" }], }; + const quota = (usedPercent: number): CodexAccountUsageResult => ({ + accountId: "test-account", + usage: null, + accountCredits: { usedPercent, periodType: "weekly" }, + freshness: "live", + observedAt: null, + }); async function mountWithAccountClient( - accountClient: Pick, - ): Promise { - const host = { + accountClient: AccountClient, + ): Promise<(replacement?: AccountClient) => void> { + const hostDefaults = { listHarnessPlugins: async () => ({ plugins: [] }), inspectThread: async () => { throw new Error("Thread ownership unavailable"); }, - ...accountClient, }; + let host = { ...hostDefaults, ...accountClient }; const { installRendererBindingProbe } = await import("../src/renderer-binding-probe.js"); const probe = installRendererBindingProbe({ enabledAgents: ["codex"], defaultAgent: "codex" }); - probe.setAdapter( - { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, - undefined, - undefined, - { currentHostId: () => "local", clientForHost: () => host } as never, - ); + const setAdapter = (replacement?: AccountClient): void => { + if (replacement) host = { ...hostDefaults, ...replacement }; + probe.setAdapter( + { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, + undefined, + undefined, + { currentHostId: () => "local", clientForHost: () => host } as never, + ); + }; + setAdapter(); + return setAdapter; } it("does not retry the account list on DOM changes for an existing Thread with failed ownership", async () => { @@ -344,7 +360,7 @@ describe("Renderer binding Codex draft quota", () => { const readsBeforeScan = listCodexAccounts.mock.calls.length; const notify = testState.notifyMutations; assert(notify); - notify([{ type: "attributes", target: testState.composer } as MutationRecord]); + notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); await new Promise((resolve) => setImmediate(resolve)); @@ -354,13 +370,7 @@ describe("Renderer binding Codex draft quota", () => { it("keeps the same Codex Account's quota visible while refreshing it", async () => { installFakeBrowser(); testState.modelTarget = ["default", "client-new-thread:quota"]; - const initial: CodexAccountUsageResult = { - accountId: "test-account", - usage: null, - accountCredits: { usedPercent: 8, periodType: "weekly" }, - freshness: "live", - observedAt: null, - }; + const initial = quota(8); const inspectCodexAccountUsage = vi.fn(async () => initial); await mountWithAccountClient({ listCodexAccounts: async () => account, @@ -381,16 +391,81 @@ describe("Renderer binding Codex draft quota", () => { const hidQuota = testState.renderedCredits .slice(rendersBeforeFocus) .some((credits) => credits === null); - const updated = { - ...initial, - accountCredits: { usedPercent: 18, periodType: "weekly" as const }, - }; + const updated = quota(18); pending.resolve(updated); expect(hidQuota).toBe(false); await vi.waitFor(() => expect(testState.renderedCredits.at(-1)).toEqual(updated.accountCredits), ); }); + + it.each(["adapter", "Host epoch"])( + "starts a new quota request after changing the %s on the same client", + async (change) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const currentQuota = quota(18); + const inspectCodexAccountUsage = vi + .fn(async () => currentQuota) + .mockReturnValueOnce(oldQuota.promise); + let notifyAccount: ((snapshot: CodexAccountListResult) => void) | undefined; + const setAdapter = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + subscribeCodexAccounts: (listener) => { + notifyAccount = listener; + return () => undefined; + }, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + + if (change === "adapter") { + setAdapter(); + } else { + assert(notifyAccount); + notifyAccount({ ...account, instanceId: "next-host" }); + } + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + oldQuota.resolve(quota(8)); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18); + }, + ); + + it("hides old quota while the replacement client reads its Account list", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const initial = quota(8); + const inspectCodexAccountUsage = vi.fn(async () => initial); + const setAdapter = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(initial.accountCredits), + ); + inspectCodexAccountUsage.mockReturnValue(oldQuota.promise); + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2)); + + const replacementAccount = Promise.withResolvers(); + const replacementQuota = quota(18); + setAdapter({ + listCodexAccounts: () => replacementAccount.promise, + inspectCodexAccountUsage: async () => replacementQuota, + }); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + oldQuota.resolve(initial); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + replacementAccount.resolve(account); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(replacementQuota.accountCredits), + ); + }); }); describe("Renderer binding Host-scoped Claude catalogs", () => { diff --git a/packages/renderer-extension/test/renderer-codex-account-state.test.ts b/packages/renderer-extension/test/renderer-codex-account-state.test.ts index a43e94f6f9..b0bedb0d92 100644 --- a/packages/renderer-extension/test/renderer-codex-account-state.test.ts +++ b/packages/renderer-extension/test/renderer-codex-account-state.test.ts @@ -1,4 +1,4 @@ -import { describe, expect, it, vi } from "vitest"; +import { assert, describe, expect, it, vi } from "vitest"; import { RendererCodexAccountState, shouldApplyCodexAccountSnapshot, @@ -39,6 +39,48 @@ describe("Host-scoped Codex Account state", () => { expect(state.readyAccountId).toBe("default"); }); + it.each([ + ["Account", snapshot("other", 3)], + ["Host instance", snapshot("default", 1, "host-b")], + ] as const)("shares pending usage across drafts until the %s changes", async (_, replacement) => { + let accounts = snapshot("default", 1); + const oldUsage = Promise.withResolvers(); + const newUsage = Promise.withResolvers(); + const inspectUsage = vi + .fn<() => Promise>() + .mockReturnValueOnce(oldUsage.promise) + .mockReturnValueOnce(newUsage.promise); + const state = createState(async (method) => { + return method === "codexhost/account/list" ? accounts : inspectUsage(); + }); + await state.refresh(); + const firstAccount = state.usageAccount; + assert(firstAccount); + const first = state.inspectUsage(firstAccount); + assert(first); + + accounts = snapshot("default", 2); + await state.refresh(); + expect(state.inspectUsage(firstAccount)).toBe(first); + expect(inspectUsage).toHaveBeenCalledTimes(1); + + accounts = replacement; + await state.refresh(); + const nextAccount = state.usageAccount; + assert(nextAccount); + expect(state.inspectUsage(firstAccount)).toBeNull(); + const next = state.inspectUsage(nextAccount); + assert(next); + + const usage = { accountId: "default", usage: null, freshness: "live", observedAt: null }; + oldUsage.resolve(usage); + await first; + expect(state.inspectUsage(nextAccount)).toBe(next); + newUsage.resolve({ ...usage, accountId: replacement.currentAccountId }); + await next; + expect(inspectUsage).toHaveBeenCalledTimes(2); + }); + it("does not inherit another Host's Account state when the remote API is absent", async () => { const local = createState(async () => snapshot("default", 1)); const remote = createState(async () => { From 923a577bcec5373916b64ec5ef010f61132db07e Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:30:55 +0800 Subject: [PATCH 3/6] fix(renderer): reload changed account quota when drafts resume --- .../src/renderer-binding-probe.ts | 23 ++++++--- .../src/renderer-codex-account-state.ts | 18 +++++-- ...enderer-binding-probe-host-catalog.test.ts | 51 +++++++++++++++++++ .../test/renderer-codex-account-state.test.ts | 21 ++++++-- 4 files changed, 97 insertions(+), 16 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index dec8ab1c7d..e05c034f0d 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -2733,14 +2733,19 @@ export function installRendererBindingProbe( // Draft quota follows the concrete client, including connections without notifications. for (const mounted of mountedByComposer.values()) { if (!canRefreshDraftUsage(mounted)) continue; - if ( - mounted.draftUsageAccount && - mounted.draftUsageAccount !== composerCodexAccounts(mounted.composer)?.usageAccount - ) { + const agent = controller.get(mounted.composer).agent; + const request = draftUsageRequests.get(mounted); + const account = + agent === "codex" ? composerCodexAccounts(mounted.composer)?.usageAccount : null; + // The Account can change while submission prevents the draft from refreshing. + if (account && request && request.account !== account) { + void refreshDraftUsage(mounted); + continue; + } + if (mounted.draftUsageAccount && mounted.draftUsageAccount !== account) { renderMounted(mounted); } const client = composerClient(mounted); - const request = draftUsageRequests.get(mounted); if ( mounted.draftUsageClient !== client && (!request || @@ -2748,8 +2753,7 @@ export function installRendererBindingProbe( request.generation !== mounted.usageRequestGeneration || (retryDraftUsage && !request.pending)) ) { - if (controller.get(mounted.composer).agent === "codex") - void loadCodexAccountsForHost(mounted.hostId); + if (agent === "codex") void loadCodexAccountsForHost(mounted.hostId); else void refreshDraftUsage(mounted); } } @@ -3243,7 +3247,10 @@ export function installRendererBindingProbe( const onBeforeInput = (event: InputEvent): void => { const composer = composerForTarget(event.target); if (!composer) return; - controller.clearPendingSubmission(composer); + if (controller.isSubmissionPending(composer)) { + controller.clearPendingSubmission(composer); + scheduleScan(); + } const mounted = mountedByComposer.get(composer); if (mounted) pendingDefaultPreferences.set(controller.get(mounted.composer).composerId, false); if (mounted && isOwnershipSubmissionBlocked(mounted.ownershipStatus)) return; diff --git a/packages/renderer-extension/src/renderer-codex-account-state.ts b/packages/renderer-extension/src/renderer-codex-account-state.ts index d9b01e21a7..0d2e394704 100644 --- a/packages/renderer-extension/src/renderer-codex-account-state.ts +++ b/packages/renderer-extension/src/renderer-codex-account-state.ts @@ -36,8 +36,12 @@ export class RendererCodexAccountState { instanceId: string | undefined; #hasSnapshot = false; #request: Promise | null = null; - #usageAccount: (CodexUsageAccount & { pending: Promise | null }) | null = - null; + #usageAccount: + | (CodexUsageAccount & { + email: string | undefined; + pending: Promise | null; + }) + | null = null; readonly #unsubscribe: (() => void) | undefined; constructor( @@ -116,8 +120,14 @@ export class RendererCodexAccountState { this.revision = result.revision; this.instanceId = result.instanceId; const accountId = this.readyAccountId; - if (instanceChanged || (this.#usageAccount?.accountId ?? null) !== accountId) { - this.#usageAccount = accountId === null ? null : { accountId, pending: null }; + // Some native Accounts share the fallback ID "current". + const email = this.accounts.find(({ accountId: id }) => id === accountId)?.email; + if ( + instanceChanged || + (this.#usageAccount?.accountId ?? null) !== accountId || + this.#usageAccount?.email !== email + ) { + this.#usageAccount = accountId === null ? null : { accountId, email, pending: null }; } return true; } diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index 34258f33d4..1dbf73a731 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -466,6 +466,57 @@ describe("Renderer binding Codex draft quota", () => { expect(testState.renderedCredits.at(-1)).toEqual(replacementQuota.accountCredits), ); }); + + it("loads a changed Account once when typing resumes after an abandoned submission", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + let currentAccount = account; + let notifyAccount: ((snapshot: CodexAccountListResult) => void) | undefined; + const inspectCodexAccountUsage = vi.fn(async ({ accountId }: { accountId: string }) => ({ + ...quota(accountId === "test-account" ? 8 : 18), + accountId, + })); + await mountWithAccountClient({ + listCodexAccounts: async () => currentAccount, + inspectCodexAccountUsage, + subscribeCodexAccounts: (listener) => { + notifyAccount = listener; + return () => undefined; + }, + }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + const submit = testState.documentListeners.get("submit"); + const beforeInput = testState.documentListeners.get("beforeinput"); + assert(submit && beforeInput && notifyAccount); + const flushFrame = () => { + for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); + }; + const event = new Event("submit", { cancelable: true }); + submit(event); + expect(event.defaultPrevented).toBe(false); + currentAccount = { + ...account, + currentAccountId: "new-account", + revision: 2, + accounts: [{ accountId: "new-account", label: "New account" }], + }; + notifyAccount(currentAccount); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + beforeInput(new Event("beforeinput")); + flushFrame(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + const notify = testState.notifyMutations; + assert(notify); + notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); + flushFrame(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + expect(inspectCodexAccountUsage).toHaveBeenLastCalledWith({ accountId: "new-account" }); + }); }); describe("Renderer binding Host-scoped Claude catalogs", () => { diff --git a/packages/renderer-extension/test/renderer-codex-account-state.test.ts b/packages/renderer-extension/test/renderer-codex-account-state.test.ts index b0bedb0d92..9ab1541855 100644 --- a/packages/renderer-extension/test/renderer-codex-account-state.test.ts +++ b/packages/renderer-extension/test/renderer-codex-account-state.test.ts @@ -19,6 +19,15 @@ const snapshot = (currentAccountId: string | null, revision: number, instanceId accounts: currentAccountId ? [account(currentAccountId)] : [], }); +const fallbackAccountSnapshot = ( + revision: number, + instanceId?: string, + email = "first@example.test", +) => ({ + ...snapshot("current", revision, instanceId), + accounts: [{ ...account("current"), email }], +}); + function createState(sendRequest: (method: string, params: unknown) => Promise) { const client = createRendererModelClient([{ sendRequest }]); if (!client) throw new Error("Test client is unavailable"); @@ -41,9 +50,13 @@ describe("Host-scoped Codex Account state", () => { it.each([ ["Account", snapshot("other", 3)], - ["Host instance", snapshot("default", 1, "host-b")], + [ + "Account email under the fallback ID", + fallbackAccountSnapshot(3, "host-a", "second@example.test"), + ], + ["Host instance", fallbackAccountSnapshot(1, "host-b")], ] as const)("shares pending usage across drafts until the %s changes", async (_, replacement) => { - let accounts = snapshot("default", 1); + let accounts: ReturnType = fallbackAccountSnapshot(1); const oldUsage = Promise.withResolvers(); const newUsage = Promise.withResolvers(); const inspectUsage = vi @@ -59,7 +72,7 @@ describe("Host-scoped Codex Account state", () => { const first = state.inspectUsage(firstAccount); assert(first); - accounts = snapshot("default", 2); + accounts = fallbackAccountSnapshot(2); await state.refresh(); expect(state.inspectUsage(firstAccount)).toBe(first); expect(inspectUsage).toHaveBeenCalledTimes(1); @@ -72,7 +85,7 @@ describe("Host-scoped Codex Account state", () => { const next = state.inspectUsage(nextAccount); assert(next); - const usage = { accountId: "default", usage: null, freshness: "live", observedAt: null }; + const usage = { accountId: "current", usage: null, freshness: "live", observedAt: null }; oldUsage.resolve(usage); await first; expect(state.inspectUsage(nextAccount)).toBe(next); From c0b4d4667e5d7c3a2ad3fa6a04110f9c4ab20a17 Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:40:10 +0800 Subject: [PATCH 4/6] fix(renderer): restore quota after interrupted draft submissions --- .../src/renderer-binding-probe.ts | 51 +++---- ...enderer-binding-probe-host-catalog.test.ts | 127 ++++++++++++++---- 2 files changed, 128 insertions(+), 50 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index e05c034f0d..878ccaaf4a 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -607,6 +607,13 @@ interface MountedComposer { commandRequestGeneration: number; } +interface DraftUsageRequest { + client: RendererModelClient | null; + account: RendererCodexAccountState["usageAccount"]; + generation: number; + status: "pending" | "settled" | "deferred"; +} + interface MountedCatalogRequest { client: RendererModelClient; hostId: string; @@ -778,15 +785,7 @@ export function installRendererBindingProbe( // composerId belongs to the logical draft and survives DOM replacement. const pendingDefaultPreferences = new Map(); const catalogRequests = new WeakMap(); - const draftUsageRequests = new WeakMap< - MountedComposer, - { - client: RendererModelClient | null; - account: RendererCodexAccountState["usageAccount"]; - generation: number; - pending: boolean; - } - >(); + const draftUsageRequests = new WeakMap(); const pendingReplacements = new Map(); let disposed = false; const disposeReasoningSoftWrap = installReasoningTranscriptSoftWrap(document); @@ -1280,9 +1279,9 @@ export function installRendererBindingProbe( previous?.generation === mounted.usageRequestGeneration && previous.client === client && previous.account === account; - if (sameScope && previous.pending) return; + if (sameScope && previous.status === "pending") return; const generation = ++mounted.usageRequestGeneration; - const request = { client, account, generation, pending: true }; + const request: DraftUsageRequest = { client, account, generation, status: "pending" }; draftUsageRequests.set(mounted, request); mounted.draftUsageClient = null; // Keep the last snapshot on screen while the same Codex Account refreshes. @@ -1297,8 +1296,7 @@ export function installRendererBindingProbe( mounted.composer.isConnected && mountedByComposer.get(mounted.composer) === mounted && mounted.usageRequestGeneration === generation && - controller.get(mounted.composer).agent === agent && - canRefreshDraftUsage(mounted); + controller.get(mounted.composer).agent === agent; try { if (!client) return; if (agent === "codex") { @@ -1312,6 +1310,10 @@ export function installRendererBindingProbe( result.accountId !== account.accountId ) return; + if (!canRefreshDraftUsage(mounted)) { + if (controller.isSubmissionPending(mounted.composer)) request.status = "deferred"; + return; + } mounted.draftUsageAccount = account; mounted.usage = result.usage; mounted.accountCredits = result.accountCredits ?? null; @@ -1321,7 +1323,7 @@ export function installRendererBindingProbe( harnessId: harnessIdSchema.parse(agent), refresh: true, }); - if (!isCurrent() || result.harnessId !== agent) return; + if (!isCurrent() || !canRefreshDraftUsage(mounted) || result.harnessId !== agent) return; mounted.accountCredits = result.account?.credits ?? null; } mounted.draftUsageClient = client; @@ -1329,7 +1331,7 @@ export function installRendererBindingProbe( } catch { // A failed refresh leaves the current snapshot intact. Scope changes clear it above. } finally { - request.pending = false; + if (request.status === "pending") request.status = "settled"; } }; @@ -2732,26 +2734,27 @@ export function installRendererBindingProbe( reloadMountedOwnershipForHost(); // Draft quota follows the concrete client, including connections without notifications. for (const mounted of mountedByComposer.values()) { - if (!canRefreshDraftUsage(mounted)) continue; const agent = controller.get(mounted.composer).agent; + const isCodexDraft = + agent === "codex" && threadIdFromComposerModelTarget(mounted.modelTarget) === null; + const account = isCodexDraft ? composerCodexAccounts(mounted.composer)?.usageAccount : null; + if (isCodexDraft && mounted.draftUsageAccount && mounted.draftUsageAccount !== account) { + renderMounted(mounted); + } + if (!canRefreshDraftUsage(mounted)) continue; const request = draftUsageRequests.get(mounted); - const account = - agent === "codex" ? composerCodexAccounts(mounted.composer)?.usageAccount : null; - // The Account can change while submission prevents the draft from refreshing. - if (account && request && request.account !== account) { + // Submission can defer a ready Account's quota refresh or its reply. + if (account && request && (request.account !== account || request.status === "deferred")) { void refreshDraftUsage(mounted); continue; } - if (mounted.draftUsageAccount && mounted.draftUsageAccount !== account) { - renderMounted(mounted); - } const client = composerClient(mounted); if ( mounted.draftUsageClient !== client && (!request || request.client !== client || request.generation !== mounted.usageRequestGeneration || - (retryDraftUsage && !request.pending)) + (retryDraftUsage && request.status !== "pending")) ) { if (agent === "codex") void loadCodexAccountsForHost(mounted.hostId); else void refreshDraftUsage(mounted); diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index 1dbf73a731..ec935f3981 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -325,9 +325,7 @@ describe("Renderer binding Codex draft quota", () => { observedAt: null, }); - async function mountWithAccountClient( - accountClient: AccountClient, - ): Promise<(replacement?: AccountClient) => void> { + async function mountWithAccountClient(accountClient: AccountClient) { const hostDefaults = { listHarnessPlugins: async () => ({ plugins: [] }), inspectThread: async () => { @@ -337,8 +335,11 @@ describe("Renderer binding Codex draft quota", () => { let host = { ...hostDefaults, ...accountClient }; const { installRendererBindingProbe } = await import("../src/renderer-binding-probe.js"); const probe = installRendererBindingProbe({ enabledAgents: ["codex"], defaultAgent: "codex" }); + const replaceClient = (replacement: AccountClient): void => { + host = { ...hostDefaults, ...replacement }; + }; const setAdapter = (replacement?: AccountClient): void => { - if (replacement) host = { ...hostDefaults, ...replacement }; + if (replacement) replaceClient(replacement); probe.setAdapter( { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, undefined, @@ -347,7 +348,33 @@ describe("Renderer binding Codex draft quota", () => { ); }; setAdapter(); - return setAdapter; + return { setAdapter, replaceClient }; + } + + function flushFrame(): void { + for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); + } + + function scanAfterMutation(): void { + const notify = testState.notifyMutations; + assert(notify); + notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); + flushFrame(); + } + + function submitDraft(): void { + const submit = testState.documentListeners.get("submit"); + assert(submit); + const event = new Event("submit", { cancelable: true }); + submit(event); + expect(event.defaultPrevented).toBe(false); + } + + function resumeDraft(): void { + const beforeInput = testState.documentListeners.get("beforeinput"); + assert(beforeInput); + beforeInput(new Event("beforeinput")); + flushFrame(); } it("does not retry the account list on DOM changes for an existing Thread with failed ownership", async () => { @@ -358,10 +385,7 @@ describe("Renderer binding Codex draft quota", () => { await new Promise((resolve) => setImmediate(resolve)); const readsBeforeScan = listCodexAccounts.mock.calls.length; - const notify = testState.notifyMutations; - assert(notify); - notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); - for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); + scanAfterMutation(); await new Promise((resolve) => setImmediate(resolve)); expect(listCodexAccounts).toHaveBeenCalledTimes(readsBeforeScan); @@ -410,7 +434,7 @@ describe("Renderer binding Codex draft quota", () => { .fn(async () => currentQuota) .mockReturnValueOnce(oldQuota.promise); let notifyAccount: ((snapshot: CodexAccountListResult) => void) | undefined; - const setAdapter = await mountWithAccountClient({ + const { setAdapter } = await mountWithAccountClient({ listCodexAccounts: async () => account, inspectCodexAccountUsage, subscribeCodexAccounts: (listener) => { @@ -440,7 +464,7 @@ describe("Renderer binding Codex draft quota", () => { const oldQuota = Promise.withResolvers(); const initial = quota(8); const inspectCodexAccountUsage = vi.fn(async () => initial); - const setAdapter = await mountWithAccountClient({ + const { setAdapter } = await mountWithAccountClient({ listCodexAccounts: async () => account, inspectCodexAccountUsage, }); @@ -485,15 +509,8 @@ describe("Renderer binding Codex draft quota", () => { }, }); await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); - const submit = testState.documentListeners.get("submit"); - const beforeInput = testState.documentListeners.get("beforeinput"); - assert(submit && beforeInput && notifyAccount); - const flushFrame = () => { - for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); - }; - const event = new Event("submit", { cancelable: true }); - submit(event); - expect(event.defaultPrevented).toBe(false); + assert(notifyAccount); + submitDraft(); currentAccount = { ...account, currentAccountId: "new-account", @@ -506,17 +523,75 @@ describe("Renderer binding Codex draft quota", () => { expect(testState.renderedCredits.at(-1)).toBeNull(); expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); - beforeInput(new Event("beforeinput")); - flushFrame(); + resumeDraft(); await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); - const notify = testState.notifyMutations; - assert(notify); - notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); - flushFrame(); + scanAfterMutation(); await new Promise((resolve) => setImmediate(resolve)); expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); expect(inspectCodexAccountUsage).toHaveBeenLastCalledWith({ accountId: "new-account" }); }); + + it.each([ + { completion: "during", expectedUsage: 18, expectedReads: 2 }, + { completion: "after", expectedUsage: 8, expectedReads: 1 }, + { completion: "failed", expectedUsage: undefined, expectedReads: 1 }, + ] as const)( + "reconciles quota on resuming an abandoned submission ($completion)", + async ({ completion, expectedUsage, expectedReads }) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const firstQuota = Promise.withResolvers(); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockReturnValueOnce(firstQuota.promise); + await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + submitDraft(); + if (completion !== "after") { + if (completion === "during") firstQuota.resolve(quota(8)); + else firstQuota.reject(new Error("Usage query failed")); + await new Promise((resolve) => setImmediate(resolve)); + } + flushFrame(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + if (completion === "after") firstQuota.resolve(quota(8)); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(expectedUsage), + ); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(expectedReads); + }, + ); + + it("invalidates old quota when the Host client changes during submission", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const { replaceClient } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage: async () => quota(8), + }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + submitDraft(); + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)); + replaceClient({ listCodexAccounts, inspectCodexAccountUsage }); + scanAfterMutation(); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + await new Promise((resolve) => setImmediate(resolve)); + expect(listCodexAccounts).not.toHaveBeenCalled(); + expect(inspectCodexAccountUsage).not.toHaveBeenCalled(); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + }); }); describe("Renderer binding Host-scoped Claude catalogs", () => { From 9792aae0cdd086a7abd3551ff220ed81691b1efa Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:49:44 +0800 Subject: [PATCH 5/6] fix(renderer): retry deferred quota after reconnect or focus --- .../src/renderer-binding-probe.ts | 32 +++++++-- ...enderer-binding-probe-host-catalog.test.ts | 70 ++++++++++++++++++- 2 files changed, 96 insertions(+), 6 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index 878ccaaf4a..4fa24e6a59 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -931,7 +931,14 @@ export function installRendererBindingProbe( const codexAccountsForHost = (hostId: string | null): RendererCodexAccountState | null => { if (!hostId) return null; const client = modelClientForHost(hostId); - if (!client) return null; + if (!client) { + const state = harnessAvailabilityByHost.get(hostId); + if (state?.codexAccounts) { + state.codexAccounts.dispose(); + state.codexAccounts = null; + } + return null; + } const state = hostHarnessAvailabilityState(hostId); if (state.codexAccounts?.client !== client) { state.codexAccounts?.dispose(); @@ -1090,6 +1097,8 @@ export function installRendererBindingProbe( mounted.draftUsageAccount !== accounts?.usageAccount ) { clearDraftUsageSnapshot(mounted); + mounted.draftUsageClient = null; + mounted.usageRequestGeneration += 1; } const currentCodexAccount = accounts?.accounts.find( ({ accountId }) => accountId === accounts.readyAccountId, @@ -1268,13 +1277,24 @@ export function installRendererBindingProbe( threadIdFromComposerModelTarget(mounted.modelTarget) === null; const refreshDraftUsage = async (mounted: MountedComposer): Promise => { - if (!canRefreshDraftUsage(mounted)) return; const agent = controller.get(mounted.composer).agent; + const previous = draftUsageRequests.get(mounted); + if (!canRefreshDraftUsage(mounted)) { + if ( + agent === "codex" && + threadIdFromComposerModelTarget(mounted.modelTarget) === null && + controller.isSubmissionPending(mounted.composer) && + previous?.status === "settled" && + previous.generation === mounted.usageRequestGeneration + ) { + previous.status = "deferred"; + } + return; + } const accounts = agent === "codex" ? composerCodexAccounts(mounted.composer) : null; const account = accounts?.usageAccount ?? null; const client = composerClient(mounted); const hostId = mounted.hostId; - const previous = draftUsageRequests.get(mounted); const sameScope = previous?.generation === mounted.usageRequestGeneration && previous.client === client && @@ -2737,7 +2757,11 @@ export function installRendererBindingProbe( const agent = controller.get(mounted.composer).agent; const isCodexDraft = agent === "codex" && threadIdFromComposerModelTarget(mounted.modelTarget) === null; - const account = isCodexDraft ? composerCodexAccounts(mounted.composer)?.usageAccount : null; + const accounts = isCodexDraft ? composerCodexAccounts(mounted.composer) : null; + const account = accounts?.usageAccount; + if (isCodexDraft && !accounts && draftUsageRequests.delete(mounted)) { + mounted.draftUsageClient = null; + } if (isCodexDraft && mounted.draftUsageAccount && mounted.draftUsageAccount !== account) { renderMounted(mounted); } diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index ec935f3981..ff0cd26783 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -333,6 +333,7 @@ describe("Renderer binding Codex draft quota", () => { }, }; let host = { ...hostDefaults, ...accountClient }; + let connected = true; const { installRendererBindingProbe } = await import("../src/renderer-binding-probe.js"); const probe = installRendererBindingProbe({ enabledAgents: ["codex"], defaultAgent: "codex" }); const replaceClient = (replacement: AccountClient): void => { @@ -344,11 +345,17 @@ describe("Renderer binding Codex draft quota", () => { { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, undefined, undefined, - { currentHostId: () => "local", clientForHost: () => host } as never, + { currentHostId: () => "local", clientForHost: () => (connected ? host : null) } as never, ); }; setAdapter(); - return { setAdapter, replaceClient }; + return { + setAdapter, + replaceClient, + setConnected(value: boolean) { + connected = value; + }, + }; } function flushFrame(): void { @@ -592,6 +599,65 @@ describe("Renderer binding Codex draft quota", () => { await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); }); + + it.each(["loaded", "pending"] as const)( + "reloads %s quota after the same client reconnects during submission", + async (status) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockReturnValueOnce(oldQuota.promise); + const { setConnected } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + if (status === "loaded") { + oldQuota.resolve(quota(8)); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + } + submitDraft(); + + setConnected(false); + scanAfterMutation(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + setConnected(true); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + if (status === "pending") oldQuota.resolve(quota(8)); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + }, + ); + + it("performs one deferred focus refresh after the draft resumes", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)).mockResolvedValueOnce(quota(8)); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + submitDraft(); + const accountReads = listCodexAccounts.mock.calls.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(accountReads + 1)); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + }); }); describe("Renderer binding Host-scoped Claude catalogs", () => { From 3c57295cf67b208badf789e1436efd0c9b06f43d Mon Sep 17 00:00:00 2001 From: AABIBER <267599584+aabiberyi-prog@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:59:18 +0800 Subject: [PATCH 6/6] fix(renderer): preserve deferred draft quota refreshes --- .../src/renderer-binding-probe.ts | 35 +++++++---- ...enderer-binding-probe-host-catalog.test.ts | 63 +++++++++++++++++++ 2 files changed, 85 insertions(+), 13 deletions(-) diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index 4fa24e6a59..eb8b687d42 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -611,7 +611,7 @@ interface DraftUsageRequest { client: RendererModelClient | null; account: RendererCodexAccountState["usageAccount"]; generation: number; - status: "pending" | "settled" | "deferred"; + pending: boolean; } interface MountedCatalogRequest { @@ -786,6 +786,7 @@ export function installRendererBindingProbe( const pendingDefaultPreferences = new Map(); const catalogRequests = new WeakMap(); const draftUsageRequests = new WeakMap(); + const deferredCodexDraftUsage = new WeakSet(); const pendingReplacements = new Map(); let disposed = false; const disposeReasoningSoftWrap = installReasoningTranscriptSoftWrap(document); @@ -1278,16 +1279,13 @@ export function installRendererBindingProbe( const refreshDraftUsage = async (mounted: MountedComposer): Promise => { const agent = controller.get(mounted.composer).agent; - const previous = draftUsageRequests.get(mounted); if (!canRefreshDraftUsage(mounted)) { if ( agent === "codex" && threadIdFromComposerModelTarget(mounted.modelTarget) === null && - controller.isSubmissionPending(mounted.composer) && - previous?.status === "settled" && - previous.generation === mounted.usageRequestGeneration + controller.isSubmissionPending(mounted.composer) ) { - previous.status = "deferred"; + deferredCodexDraftUsage.add(mounted); } return; } @@ -1295,13 +1293,15 @@ export function installRendererBindingProbe( const account = accounts?.usageAccount ?? null; const client = composerClient(mounted); const hostId = mounted.hostId; + const previous = draftUsageRequests.get(mounted); const sameScope = previous?.generation === mounted.usageRequestGeneration && previous.client === client && previous.account === account; - if (sameScope && previous.status === "pending") return; + if (sameScope && previous.pending) return; + deferredCodexDraftUsage.delete(mounted); const generation = ++mounted.usageRequestGeneration; - const request: DraftUsageRequest = { client, account, generation, status: "pending" }; + const request: DraftUsageRequest = { client, account, generation, pending: true }; draftUsageRequests.set(mounted, request); mounted.draftUsageClient = null; // Keep the last snapshot on screen while the same Codex Account refreshes. @@ -1331,9 +1331,11 @@ export function installRendererBindingProbe( ) return; if (!canRefreshDraftUsage(mounted)) { - if (controller.isSubmissionPending(mounted.composer)) request.status = "deferred"; + if (controller.isSubmissionPending(mounted.composer)) + deferredCodexDraftUsage.add(mounted); return; } + deferredCodexDraftUsage.delete(mounted); mounted.draftUsageAccount = account; mounted.usage = result.usage; mounted.accountCredits = result.accountCredits ?? null; @@ -1351,7 +1353,11 @@ export function installRendererBindingProbe( } catch { // A failed refresh leaves the current snapshot intact. Scope changes clear it above. } finally { - if (request.status === "pending") request.status = "settled"; + request.pending = false; + // A failed in-flight read may still have a later refresh waiting on it. + if (deferredCodexDraftUsage.has(mounted) && isCurrent() && canRefreshDraftUsage(mounted)) { + scheduleScan(); + } } }; @@ -2768,7 +2774,10 @@ export function installRendererBindingProbe( if (!canRefreshDraftUsage(mounted)) continue; const request = draftUsageRequests.get(mounted); // Submission can defer a ready Account's quota refresh or its reply. - if (account && request && (request.account !== account || request.status === "deferred")) { + if ( + account && + (deferredCodexDraftUsage.has(mounted) || (request && request.account !== account)) + ) { void refreshDraftUsage(mounted); continue; } @@ -2778,7 +2787,7 @@ export function installRendererBindingProbe( (!request || request.client !== client || request.generation !== mounted.usageRequestGeneration || - (retryDraftUsage && request.status !== "pending")) + (retryDraftUsage && !request.pending)) ) { if (agent === "codex") void loadCodexAccountsForHost(mounted.hostId); else void refreshDraftUsage(mounted); @@ -3276,7 +3285,7 @@ export function installRendererBindingProbe( if (!composer) return; if (controller.isSubmissionPending(composer)) { controller.clearPendingSubmission(composer); - scheduleScan(); + scheduleScan(true); } const mounted = mountedByComposer.get(composer); if (mounted) pendingDefaultPreferences.set(controller.get(mounted.composer).composerId, false); diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index ff0cd26783..1e6cd5c419 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -658,6 +658,69 @@ describe("Renderer binding Codex draft quota", () => { await new Promise((resolve) => setImmediate(resolve)); expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); }); + + it.each(["fails", "succeeds"] as const)( + "settles a deferred focus refresh when the in-flight quota request %s after resuming", + async (outcome) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const inFlight = Promise.withResolvers(); + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockResolvedValueOnce(quota(8)) + .mockReturnValueOnce(inFlight.promise); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2)); + submitDraft(); + const accountReads = listCodexAccounts.mock.calls.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(accountReads + 1)); + await new Promise((resolve) => setImmediate(resolve)); + + resumeDraft(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + if (outcome === "fails") inFlight.reject(new Error("Usage query failed")); + else inFlight.resolve(quota(12)); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(outcome === "fails" ? 18 : 12), + ); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(outcome === "fails" ? 3 : 2); + }, + ); + + it.each(["draft", "Thread"] as const)( + "uses the ready Account without reading its list again when the composer resumes as a %s", + async (target) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const firstAccount = Promise.withResolvers(); + const listCodexAccounts = vi.fn(() => firstAccount.promise); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(1)); + submitDraft(); + firstAccount.resolve(account); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + expect(inspectCodexAccountUsage).not.toHaveBeenCalled(); + + if (target === "Thread") testState.modelTarget = ["conversation", "thread-a"]; + resumeDraft(); + if (target === "draft") { + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + } + await new Promise((resolve) => setImmediate(resolve)); + expect(listCodexAccounts).toHaveBeenCalledTimes(1); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(target === "draft" ? 1 : 0); + }, + ); }); describe("Renderer binding Host-scoped Claude catalogs", () => {