From 6379587c83cd71f8fca91adbb2003df0fd61fd59 Mon Sep 17 00:00:00 2001 From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com> Date: Mon, 9 Nov 2026 20:39:43 -0800 Subject: [PATCH] fix: retain model discovery through demand-owned phase transitions --- .../AgentLaunchPickerMenu.search.test.tsx | 3 +- .../agent/agent-launch-picker-acquisition.ts | 35 ++- .../agent/agent-launch-picker-host-reads.ts | 17 +- ...agent-launch-picker-source-routing.test.ts | 22 +- .../agent/agent-picker-inventory-source.ts | 4 +- .../agent/agent-picker-source-demand.ts | 38 +++ .../routing/agent-launch-route-input.test.ts | 27 +- .../host-model-menu-catalog-lifecycle.test.ts | 22 +- .../host-model-menu-catalog-phases.test.ts | 258 +++++++++++++----- .../host-model-menu-catalog.test.ts | 23 +- .../model-catalogs/host-model-menu-catalog.ts | 178 ++++++------ .../host-model-menu-freshness.test.ts | 28 +- .../model-catalogs/host-model-menu-phases.ts | 189 +++++++++++++ .../host-model-menu-sources.test.ts | 23 +- .../host-model-runtime-invalidation.test.ts | 8 +- 15 files changed, 622 insertions(+), 253 deletions(-) create mode 100644 src/renderer/src/components/agent/agent-picker-source-demand.ts create mode 100644 src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-phases.ts diff --git a/src/renderer/src/components/agent/AgentLaunchPickerMenu.search.test.tsx b/src/renderer/src/components/agent/AgentLaunchPickerMenu.search.test.tsx index 0c0830d18b4..bfd1782bbe7 100644 --- a/src/renderer/src/components/agent/AgentLaunchPickerMenu.search.test.tsx +++ b/src/renderer/src/components/agent/AgentLaunchPickerMenu.search.test.tsx @@ -194,7 +194,8 @@ it('requests the CLI catalog when the subscribed new-tab menu opens on a termina expect(read).toHaveBeenCalledWith( expect.objectContaining({ agent: 'antigravity' }), false, - 'cli' + 'cli', + expect.any(AbortSignal) ) ) expect(await screen.findByRole('menuitem', { name: /Gemini 3.8 Flash \(Low\)/ })).toBeTruthy() diff --git a/src/renderer/src/components/agent/agent-launch-picker-acquisition.ts b/src/renderer/src/components/agent/agent-launch-picker-acquisition.ts index b3f400a50f4..9addcf97181 100644 --- a/src/renderer/src/components/agent/agent-launch-picker-acquisition.ts +++ b/src/renderer/src/components/agent/agent-launch-picker-acquisition.ts @@ -9,7 +9,7 @@ export { useAgentPickerInventoryEntries, type AgentPickerInventorySource } from './agent-picker-inventory-source' -import { modelCatalogSource } from '../../../../shared/agent-session/options/model-catalog-source' +import { AgentPickerSourceDemand, agentPickerCatalogDemanded } from './agent-picker-source-demand' import { shallow } from 'zustand/shallow' import type { AgentPickerEntry } from '../../../../shared/agent-launch/picker/agent-launch-picker' import type { @@ -29,6 +29,7 @@ class AgentPickerAcquisition { readonly observers = new Set() entries: AgentPickerEntry[] settingsPending = false + private demand = new AgentPickerSourceDemand() private outstanding = { catalog: 0, refresh: 0, support: 0 } private queued: Record> private supports = new Map() @@ -108,6 +109,7 @@ class AgentPickerAcquisition { this.entries = this.project() } const stopDemand = observer.subscribeDemand?.(() => { + this.demand.reconcile((index) => this.usesSource(index)) this.admit('catalog') this.admit('refresh') }) @@ -118,6 +120,7 @@ class AgentPickerAcquisition { return () => { stopDemand?.() this.observers.delete(observer) + this.demand.reconcile((index) => this.usesSource(index)) if (!this.observers.size) { this.catalogSubscriptions.forEach((stop) => stop()) this.catalogSubscriptions = [] @@ -181,10 +184,18 @@ class AgentPickerAcquisition { private async readCatalog(entry: AgentPickerEntry, index: number, waitForListing: boolean) { const job = this.jobs[index] - const catalog = await this.reads.catalog(entry, waitForListing, job.source) + const signal = this.demand.signal(index) + const catalog = await this.reads.catalog(entry, waitForListing, job.source, signal) + if (signal.aborted && (!catalog || catalog.listingInProgress)) { + this.queued.catalog.add(index) + } + if (signal.aborted && !catalog) { + return + } // An open picker waits on a running listing, and again when a wait used its whole budget. const refresh = - this.observers.size > 0 && + !signal.aborted && + this.usesSource(index) && (waitForListing ? catalog?.waitExpired : catalog?.listingInProgress) === true if (refresh) { this.queued.refresh.add(index) @@ -195,20 +206,18 @@ class AgentPickerAcquisition { }) } + private usesSource(index: number) { + const job = this.jobs[index] + return agentPickerCatalogDemanded(this.entries[job.index], job.source, this.observers) + } + private admit(kind: ReadKind) { while (this.observers.size && this.outstanding[kind] < 2 && this.queued[kind].size) { const usable = [...this.queued[kind]].filter((index) => { if (kind === 'support') { return true } - const job = this.jobs[index], - entry = this.entries[job.index] - return [...this.observers].some( - (observer) => - observer.usesSource?.(entry, job.source) ?? - (job.source !== 'cli' || - modelCatalogSource(entry.agent, entry.defaultSurface) === job.source) - ) + return this.usesSource(index) }) if (!usable.length) { break @@ -256,8 +265,8 @@ class AgentPickerAcquisition { this.outstanding[kind]-- this.publish() this.admit(kind) - if (kind === 'catalog') { - this.admit('refresh') + if (kind !== 'support') { + this.admit(kind === 'catalog' ? 'refresh' : 'catalog') } this.retire() }) diff --git a/src/renderer/src/components/agent/agent-launch-picker-host-reads.ts b/src/renderer/src/components/agent/agent-launch-picker-host-reads.ts index 82cf5d2ffc7..66682985193 100644 --- a/src/renderer/src/components/agent/agent-launch-picker-host-reads.ts +++ b/src/renderer/src/components/agent/agent-launch-picker-host-reads.ts @@ -55,13 +55,18 @@ export function agentPickerModelCatalogReads(input: { catalog: async ( entry: AgentPickerEntry, waitForListing = false, - source: ModelCatalogSource = 'structured' + source: ModelCatalogSource = 'structured', + signal: AbortSignal ) => - resolveScope(entry, source).then((scope) => - scope - ? hostModelMenuCatalog(scope).read(source === 'cli', waitForListing) - : { origin: 'unknown' as const } - ), + signal.aborted + ? Promise.resolve(undefined) + : resolveScope(entry, source).then((scope) => + signal.aborted + ? undefined + : scope + ? hostModelMenuCatalog(scope).read(source === 'cli', waitForListing, signal) + : { origin: 'unknown' as const } + ), observeCatalog: ( entry: AgentPickerEntry, publish: (snapshot: HostModelMenuSnapshot & { invalidated?: boolean }) => void, diff --git a/src/renderer/src/components/agent/agent-launch-picker-source-routing.test.ts b/src/renderer/src/components/agent/agent-launch-picker-source-routing.test.ts index 8543a2ba6d1..f62bbead6b8 100644 --- a/src/renderer/src/components/agent/agent-launch-picker-source-routing.test.ts +++ b/src/renderer/src/components/agent/agent-launch-picker-source-routing.test.ts @@ -72,11 +72,13 @@ it('uses the paired invocation eligibility and never forwards desktop command ov settings: { agentCmdOverrides: command ? { antigravity: command } : {} }, serverSettings: async () => ({ agentCmdOverrides: { antigravity: 'agy' } }) }) - expect(await reads('agy-beta').catalog(sourceEntry(), false, 'cli')).toEqual({ + expect( + await reads('agy-beta').catalog(sourceEntry(), false, 'cli', new AbortController().signal) + ).toEqual({ origin: 'unknown' }) expect(mocks.discover).not.toHaveBeenCalled() - await reads('agy').catalog(sourceEntry(), false, 'cli') + await reads('agy').catalog(sourceEntry(), false, 'cli', new AbortController().signal) expect(mocks.discover).toHaveBeenCalledWith({ ...cliContext, prefs: undefined }, 'antigravity') expect(mocks.structured).not.toHaveBeenCalled() }) @@ -96,7 +98,7 @@ it('uses the guest CLI route, retains its last good list on failure, and never f settings: {} }) const entry = { ...sourceEntry(), catalogRead: 'unsupported' as const } - const answer = await reads.catalog(entry, false, 'cli') + const answer = await reads.catalog(entry, false, 'cli', new AbortController().signal) expect(answer).toMatchObject({ models: [ { id: 'gemini-3.8-flash-high' }, @@ -107,7 +109,7 @@ it('uses the guest CLI route, retains its last good list on failure, and never f }) expect(mocks.discover).toHaveBeenCalledWith({ ...cliContext, prefs: undefined }, 'antigravity') mocks.discover.mockResolvedValueOnce({ success: false, error: 'offline' }) - expect(await reads.catalog(entry, false, 'cli')).toEqual(answer) + expect(await reads.catalog(entry, false, 'cli', new AbortController().signal)).toEqual(answer) mocks.discover.mockClear() const remote = { kind: 'environment', environmentId: 'remote-global' } as const const global = agentPickerModelCatalogReads({ @@ -118,7 +120,7 @@ it('uses the guest CLI route, retains its last good list on failure, and never f settings: {}, serverSettings: async () => ({}) }) - expect(await global.catalog(entry, false, 'cli')).toBeUndefined() + expect(await global.catalog(entry, false, 'cli', new AbortController().signal)).toBeUndefined() expect(mocks.discover).not.toHaveBeenCalled() const overridden = agentPickerModelCatalogReads({ target, @@ -127,7 +129,9 @@ it('uses the guest CLI route, retains its last good list on failure, and never f nativeRuntime: false, settings: { agentCmdOverrides: { antigravity: 'MODE=x agy' } } }) - expect(await overridden.catalog(entry, false, 'cli')).toEqual({ origin: 'unknown' }) + expect(await overridden.catalog(entry, false, 'cli', new AbortController().signal)).toEqual({ + origin: 'unknown' + }) expect(mocks.discover).not.toHaveBeenCalled() }) @@ -229,13 +233,13 @@ it('reuses a held CLI answer on reopen until account invalidation', async () => }) const entry = sourceEntry() const stop = reads.observeCatalog(entry, () => {}, 'cli') - const answer = await reads.catalog(entry, false, 'cli') + const answer = await reads.catalog(entry, false, 'cli', new AbortController().signal) stop() const stopReopened = reads.observeCatalog(entry, () => {}, 'cli') - expect(await reads.catalog(entry, false, 'cli')).toEqual(answer) + expect(await reads.catalog(entry, false, 'cli', new AbortController().signal)).toEqual(answer) expect(mocks.discover).toHaveBeenCalledTimes(1) forgetHostModelCatalogSnapshots(target, ['antigravity']) - await reads.catalog(entry, false, 'cli') + await reads.catalog(entry, false, 'cli', new AbortController().signal) expect(mocks.discover).toHaveBeenCalledTimes(2) stopReopened() }) diff --git a/src/renderer/src/components/agent/agent-picker-inventory-source.ts b/src/renderer/src/components/agent/agent-picker-inventory-source.ts index cff27c844a7..8da8334588b 100644 --- a/src/renderer/src/components/agent/agent-picker-inventory-source.ts +++ b/src/renderer/src/components/agent/agent-picker-inventory-source.ts @@ -53,6 +53,7 @@ export function createAgentPickerInventorySource( } else { demand.delete(agent) } + demandListeners.forEach((listener) => listener()) } }, subscribe: (listener) => { @@ -89,7 +90,8 @@ export type AgentPickerAcquisitionReads = { catalog: ( entry: AgentPickerEntry, waitForListing: boolean, - source?: ModelCatalogSource + source: ModelCatalogSource | undefined, + signal: AbortSignal ) => Promise observeCatalog?: ( entry: AgentPickerEntry, diff --git a/src/renderer/src/components/agent/agent-picker-source-demand.ts b/src/renderer/src/components/agent/agent-picker-source-demand.ts new file mode 100644 index 00000000000..ebaa7e437de --- /dev/null +++ b/src/renderer/src/components/agent/agent-picker-source-demand.ts @@ -0,0 +1,38 @@ +import { + modelCatalogSource, + type ModelCatalogSource +} from '../../../../shared/agent-session/options/model-catalog-source' +import type { AgentPickerEntry } from '../../../../shared/agent-launch/picker/agent-launch-picker' +import type { AgentPickerAcquisitionObserver } from './agent-picker-inventory-source' + +export function agentPickerCatalogDemanded( + entry: AgentPickerEntry, + source: ModelCatalogSource, + observers: Iterable +) { + return [...observers].some( + (observer) => + observer.usesSource?.(entry, source) ?? + (source !== 'cli' || modelCatalogSource(entry.agent, entry.defaultSurface) === source) + ) +} + +export class AgentPickerSourceDemand { + private controllers = new Map() + signal(index: number) { + let controller = this.controllers.get(index) + if (!controller) { + controller = new AbortController() + this.controllers.set(index, controller) + } + return controller.signal + } + reconcile(uses: (index: number) => boolean) { + for (const [index, controller] of this.controllers) { + if (!uses(index)) { + this.controllers.delete(index) + controller.abort() + } + } + } +} diff --git a/src/renderer/src/lib/agent-session/launch/routing/agent-launch-route-input.test.ts b/src/renderer/src/lib/agent-session/launch/routing/agent-launch-route-input.test.ts index cb4b1c903eb..70d040908d3 100644 --- a/src/renderer/src/lib/agent-session/launch/routing/agent-launch-route-input.test.ts +++ b/src/renderer/src/lib/agent-session/launch/routing/agent-launch-route-input.test.ts @@ -203,17 +203,22 @@ describe('buildAgentLaunchRouteInput', () => { nativeRuntime: agentPickerUsesNativeRuntime(route, 'win32', 'C:\\repo'), settings: {}, serverSettings: async () => ({}) - }).catalog({ - agent: 'codex', - catalogRead: 'pending', - label: 'Codex', - rows: [], - surfaces: ['chat', 'terminal'], - defaultSurface: 'chat', - terminal: {}, - structured: {}, - catalog: { origin: 'unknown' } - }) + }).catalog( + { + agent: 'codex', + catalogRead: 'pending', + label: 'Codex', + rows: [], + surfaces: ['chat', 'terminal'], + defaultSurface: 'chat', + terminal: {}, + structured: {}, + catalog: { origin: 'unknown' } + }, + false, + undefined, + new AbortController().signal + ) expect( modelMenuOptions(answer, { agent: 'codex', diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-lifecycle.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-lifecycle.test.ts index bcea8d2e283..1582ca6a54b 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-lifecycle.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-lifecycle.test.ts @@ -79,7 +79,7 @@ it('preserves scoped retirement across owner handoff and rejected reopen without expect(successor).not.toBe(a) expect(successor.snapshot.answer).toEqual(retired) mocks.call.mockRejectedValueOnce(new Error('reopen offline')) - await successor.read() + await successor.read(false, undefined, new AbortController().signal) expect(successor.snapshot.answer).toEqual(retired) recordHostModelCatalogSnapshot(target, 'codex', 'id:b', catalog('other-new')) expect(successor.snapshot.answer).toEqual(retired) @@ -114,7 +114,7 @@ it.each([ const owner = hostModelMenuCatalog(scope) const stop = owner.subscribe(() => {}) mocks.call.mockResolvedValueOnce(answer) - expect(await owner.read()).toEqual(answer) + expect(await owner.read(false, undefined, new AbortController().signal)).toEqual(answer) expect(owner.snapshot.answer).toEqual(answer) const read = () => readHostModelCatalogSnapshot(target, 'codex', { @@ -132,7 +132,7 @@ it.each([ const detach = successor.subscribe(() => {}) expect(successor).not.toBe(owner) mocks.call.mockRejectedValueOnce(new Error('reopen offline')) - expect(await successor.read()).toEqual(answer) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual(answer) recordHostModelCatalogSnapshot(target, 'codex', 'id:sibling', catalog('sibling')) expect(successor.snapshot.answer).toEqual(answer) expect( @@ -145,10 +145,10 @@ it.each([ mocks.call .mockResolvedValueOnce({ origin: 'unknown', listingInProgress: true }) .mockRejectedValueOnce(new Error('refresh offline')) - expect(await successor.read()).toEqual(answer) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual(answer) expect(read()).toEqual(answer) mocks.call.mockResolvedValueOnce(catalog('replacement')) - await successor.read() + await successor.read(false, undefined, new AbortController().signal) expect(successor.snapshot.answer).toMatchObject({ models: [{ id: 'replacement' }] }) forgetHostModelCatalogSnapshots(target) expect(successor.snapshot.answer).toBeUndefined() @@ -192,7 +192,7 @@ it.each(['codex', 'claude'])( } }) mocks.call.mockResolvedValueOnce(answer) - expect(await owner.read()).toEqual(expected) + expect(await owner.read(false, undefined, new AbortController().signal)).toEqual(expected) expect(owner.snapshot.answer).toEqual(expected) expect(settled).toEqual([expected]) const read = (worktree: string | null | undefined) => @@ -220,18 +220,20 @@ it.each(['codex', 'claude'])( const successor = hostModelMenuCatalog(scope) const detach = successor.subscribe(() => {}) mocks.call.mockRejectedValueOnce(new Error('reopen offline')) - expect(await successor.read()).toEqual(expected) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual(expected) for (const replacement of [ { origin: 'probe', fetchedAt: 4, models: [] }, { origin: 'unknown' } ] satisfies AgentSessionModelCatalogResult[]) { mocks.call.mockResolvedValueOnce(replacement) - expect(await successor.read()).toEqual(replacement) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual( + replacement + ) expect(successor.snapshot.answer).toEqual(replacement) } const universal = { ...answer, defaultHoldsInEveryWorkspace: true as const } mocks.call.mockResolvedValueOnce(universal) - expect(await successor.read()).toEqual(universal) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual(universal) forgetHostModelCatalogSnapshots(target) expect(read(null)).toBeUndefined() recordHostModelCatalogSnapshot(target, agent, 'id:only', answer) @@ -252,7 +254,7 @@ it('fences late negative account and workspace replies after invalidation', asyn const scope = { target, agent: 'codex', worktree } const owner = hostModelMenuCatalog(scope) const stop = owner.subscribe(() => {}) - const reading = owner.read() + const reading = owner.read(false, undefined, new AbortController().signal) await vi.waitFor(() => expect(mocks.call.mock.calls.at(-1)?.[2]).toEqual({ agent: 'codex', diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-phases.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-phases.test.ts index 8cf2bdd16af..910856bb667 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-phases.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog-phases.test.ts @@ -12,91 +12,203 @@ const models = (id: string): AgentSessionModelCatalogResult => ({ listingNamesConfiguredModel: false, models: [{ id, label: id, isDefault: false, efforts: [] }] }) +function transportReply() { + const result = Promise.withResolvers() + const started = Promise.withResolvers() + return { + ...result, + started: started.promise, + request: () => { + started.resolve() + return result.promise + } + } +} beforeEach(() => resetHostModelCatalogSnapshotsForTests()) -it('keeps the first timed-out list through failure without authorizing another refresh, then reopens', async () => { - const request = vi - .fn<(wait: boolean) => Promise>() - .mockResolvedValueOnce(listing) - .mockResolvedValueOnce({ ...models('gpt-6.1-sol'), listingInProgress: true, waitExpired: true }) - .mockRejectedValue(new Error('host offline')) - const scope = { target, agent: 'codex', worktree: 'id:expired-first-list', request } +it('withdraws abandoned queued upgrades and shares the surviving upgrade across reopen without listeners', async () => { + const first = transportReply(), + reopened = transportReply(), + wait = transportReply() + let reopening = false + const request = vi.fn<(waited: boolean) => Promise>((waited) => + reopening + ? waited + ? wait.request() + : reopened.request() + : waited + ? Promise.resolve(models('unwanted-orphan')) + : first.request() + ) + const scope = { target, agent: 'codex', worktree: 'id:queued-lifetime', request } const owner = hostModelMenuCatalog(scope) + const a = new AbortController(), + b = new AbortController() + const nextA = new AbortController(), + nextB = new AbortController() + const reads: Promise[] = [] + const stops: (() => void)[] = [] + const display = vi.fn() + stops.push(owner.subscribe(display)) + try { + const plain = owner.read(false, false, a.signal) + reads.push(plain) + await first.started + const queued = owner.read(false, true, b.signal) + reads.push(queued) + expect(request.mock.calls).toEqual([[false]]) + // The mounted display subscription owns no permission to continue either ended request. + a.abort() + b.abort() + stops[0]() + first.resolve(listing) + const ended = await Promise.all([plain, queued]) + expect(request.mock.calls).toEqual([[false]]) + expect(ended.every((answer) => !answer?.waitExpired)).toBe(true) + + reopening = true + const successor = hostModelMenuCatalog(scope) + stops.push(successor.subscribe(display)) + const plainA = successor.read(false, false, nextA.signal) + const plainB = successor.read(false, false, nextB.signal) + reads.push(plainA, plainB) + await reopened.started + expect(request.mock.calls).toEqual([[false], [false]]) + const waitA = successor.read(false, true, nextA.signal) + const waitB = successor.read(false, true, nextB.signal) + reads.push(waitA, waitB) + nextA.abort() + stops[1]() + reopened.resolve(listing) + await Promise.all([plainA, plainB]) + await wait.started + expect(request.mock.calls).toEqual([[false], [false], [true]]) + // The remaining request signal alone retains the registered owner and physical wait. + expect(hostModelMenuCatalog(scope)).toBe(successor) + expect(await successor.read(false, false, nextB.signal)).toEqual(listing) + expect(request.mock.calls).toEqual([[false], [false], [true]]) + stops.push(successor.subscribe(display)) + wait.resolve(models('fresh-after-reopen')) + expect(await waitB).toMatchObject({ models: [{ id: 'fresh-after-reopen' }] }) + expect(await waitA).toBeUndefined() + expect(successor.snapshot.answer).toMatchObject({ models: [{ id: 'fresh-after-reopen' }] }) + expect(display).toHaveBeenCalled() + } finally { + a.abort() + b.abort() + nextA.abort() + nextB.abort() + stops.forEach((stop) => stop()) + first.resolve(listing) + reopened.resolve(listing) + wait.resolve(models('cleanup')) + await Promise.allSettled(reads) + } +}) + +it('shares actual waits, stops after failure, follows open Settings to completion and never renews closed demand', async () => { + const plain = transportReply(), + firstWait = transportReply(), + failure = transportReply() + const reopenPlain = transportReply(), + reopenWait = transportReply(), + finalWait = transportReply() + const closingPlain = transportReply(), + closingWait = transportReply() + const ports = [ + plain, + firstWait, + failure, + reopenPlain, + reopenWait, + finalWait, + closingPlain, + closingWait + ] + const request = vi.fn<(waited: boolean) => Promise>() + for (const port of ports) { + request.mockImplementationOnce(port.request) + } + const scope = { target, agent: 'codex', worktree: 'id:phase-outcomes', request } + const owner = hostModelMenuCatalog(scope) + const settings = new AbortController(), + picker = new AbortController() + const reopened = new AbortController(), + explicit = new AbortController() + const closing = new AbortController(), + survivor = new AbortController() + const signals = [settings, picker, reopened, explicit, closing, survivor] + const reads: Promise[] = [] const stop = owner.subscribe(() => {}) try { - await owner.read(false, false) - let answer = await owner.read(false, true) - // One plain read, one genuinely expired wait, and one failed successor exhaust demand. - for (let attempts = 0; answer?.waitExpired && attempts < 2; attempts++) { - answer = await owner.read(false, true) + const automatic = owner.read(false, undefined, settings.signal) + const pickerPlain = owner.read(false, false, picker.signal) + const pickerWait = owner.read(false, true, picker.signal) + reads.push(automatic, pickerPlain, pickerWait) + await plain.started + plain.resolve(listing) + expect(await pickerPlain).toEqual(listing) + await firstWait.started + const provisional = owner.read(false, false, picker.signal) + reads.push(provisional) + firstWait.resolve({ ...models('gpt-6.1-sol'), listingInProgress: true, waitExpired: true }) + expect(await provisional).toEqual(listing) + expect(await pickerWait).toMatchObject({ models: [{ id: 'gpt-6.1-sol' }], waitExpired: true }) + await failure.started + const failedPicker = owner.read(false, true, picker.signal) + reads.push(failedPicker) + failure.reject(new Error('host offline')) + for (const answer of await Promise.all([automatic, failedPicker])) { + expect(answer).toMatchObject({ models: [{ id: 'gpt-6.1-sol' }] }) + expect(answer?.waitExpired).toBeUndefined() } expect(request.mock.calls).toEqual([[false], [true], [true]]) - expect(answer).toMatchObject({ models: [{ id: 'gpt-6.1-sol' }] }) - expect(answer?.waitExpired).toBeUndefined() expect(owner.snapshot.pending).toBe(false) - } finally { - stop() - } - request.mockResolvedValueOnce(models('reconnected')) - const successor = hostModelMenuCatalog(scope) - const stopSuccessor = successor.subscribe(() => {}) - try { - expect(await successor.read()).toMatchObject({ models: [{ id: 'reconnected' }] }) - expect(request.mock.calls).toEqual([[false], [true], [true], [false]]) - } finally { - stopSuccessor() - } -}) + settings.abort() + picker.abort() -it('gives a waiting caller a waited result and follows expired waits only while the menu stays open', async () => { - const plain = Promise.withResolvers() - const wait = Promise.withResolvers() - const request = vi - .fn<(wait: boolean) => Promise>() - .mockReturnValueOnce(plain.promise) - .mockReturnValueOnce(wait.promise) - .mockResolvedValueOnce(models('finally-listed')) - const owner = hostModelMenuCatalog({ target, agent: 'codex', worktree: 'id:phases', request }) - const stop = owner.subscribe(() => {}) - const open = new AbortController() - try { - const plainRead = owner.read(false, false) - const waitingRead = owner.read(false, true) - const automaticRead = owner.read(false, undefined, open.signal) - plain.resolve(listing) - expect(await plainRead).toMatchObject(listing) - await expect.poll(() => request.mock.calls).toEqual([[false], [true]]) - wait.resolve(expired) - expect(await waitingRead).toMatchObject({ listingInProgress: true, waitExpired: true }) - expect(await automaticRead).toMatchObject({ models: [{ id: 'finally-listed' }] }) + const follow = owner.read(false, undefined, reopened.signal) + const sharedWait = owner.read(false, true, explicit.signal) + reads.push(follow, sharedWait) + await reopenPlain.started + reopenPlain.resolve(listing) + await reopenWait.started + reopenWait.resolve(expired) + expect(await sharedWait).toMatchObject({ listingInProgress: true, waitExpired: true }) + await finalWait.started + finalWait.resolve(models('finally-listed')) + expect(await follow).toMatchObject({ models: [{ id: 'finally-listed' }] }) expect(owner.snapshot.answer).toMatchObject({ models: [{ id: 'finally-listed' }] }) - expect(request.mock.calls).toEqual([[false], [true], [true]]) - } finally { - open.abort() - stop() - plain.resolve(listing) - wait.resolve(expired) - } + expect(request.mock.calls).toEqual([[false], [true], [true], [false], [true], [true]]) + reopened.abort() + explicit.abort() - const closingWait = Promise.withResolvers() - const closingRequest = vi - .fn<(wait: boolean) => Promise>() - .mockResolvedValueOnce(listing) - .mockReturnValueOnce(closingWait.promise) - .mockResolvedValue(models('must-not-request')) - const closing = hostModelMenuCatalog({ target, agent: 'claude', request: closingRequest }) - const stopClosing = closing.subscribe(() => {}) - const closed = new AbortController() - try { - const reading = closing.read(false, undefined, closed.signal) - await expect.poll(() => closingRequest.mock.calls).toEqual([[false], [true]]) - closed.abort() + const ended = owner.read(false, undefined, closing.signal) + reads.push(ended) + await closingPlain.started + closingPlain.resolve(listing) + await closingWait.started + closing.abort() + stop() + expect(hostModelMenuCatalog(scope)).toBe(owner) + const stillShared = hostModelMenuCatalog(scope).read(false, true, survivor.signal) + reads.push(stillShared) closingWait.resolve(expired) - await reading - expect(closingRequest.mock.calls).toEqual([[false], [true]]) + await Promise.all([ended, stillShared]) + expect(request.mock.calls).toEqual([ + [false], + [true], + [true], + [false], + [true], + [true], + [false], + [true] + ]) } finally { - closed.abort() - stopClosing() - closingWait.resolve(expired) + signals.forEach((signal) => signal.abort()) + stop() + ports.forEach((port) => port.resolve({ origin: 'unknown' })) + await Promise.allSettled(reads) } }) diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.test.ts index 50b8190b99e..67d92a2a9c2 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.test.ts @@ -41,7 +41,7 @@ it.each([3, 30])( hostModelMenuCatalog({ target, agent: 'codex' }) ) const stops = owners.map((owner) => owner.subscribe(() => {})) - const reads = owners.map((owner) => owner.read()) + const reads = owners.map((owner) => owner.read(false, undefined, new AbortController().signal)) await vi.waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2)) expect(mocks.call.mock.calls.map((call) => call[2])).toEqual([ { agent: 'codex' }, @@ -78,10 +78,10 @@ it('drops a late reply after an account switch and consumes a plain legacy listi mocks.call.mockReturnValueOnce(old.promise).mockResolvedValueOnce(catalog('new-account')) const owner = hostModelMenuCatalog({ target, agent: 'codex' }) const stop = owner.subscribe(() => {}) - const pending = owner.read() + const pending = owner.read(false, undefined, new AbortController().signal) await vi.waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(1)) forgetHostModelCatalogSnapshots(target) - await owner.read() + await owner.read(false, undefined, new AbortController().signal) old.resolve(catalog('old-account')) await pending expect(owner.snapshot.answer).toMatchObject({ models: [{ id: 'new-account' }] }) @@ -98,8 +98,8 @@ it('keeps a last-good catalog through a pending refresh and transport failure', .mockReturnValueOnce(wait.promise) const owner = hostModelMenuCatalog({ target, agent: 'codex', worktree: 'id:refresh' }) const stop = owner.subscribe(() => {}) - await owner.read() - const refresh = owner.read() + await owner.read(false, undefined, new AbortController().signal) + const refresh = owner.read(false, undefined, new AbortController().signal) await vi.waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(3)) expect(owner.snapshot.answer).toMatchObject({ models: [{ id: 'last-good' }] }) expect(owner.snapshot.pending).toBe(true) @@ -123,8 +123,8 @@ it('never restores a catalog retired or invalidated during a failed refresh', as const worktree = `id:${invalidate}` const owner = hostModelMenuCatalog({ target, agent: 'codex', worktree }) const stop = owner.subscribe(() => {}) - await owner.read() - const refresh = owner.read() + await owner.read(false, undefined, new AbortController().signal) + const refresh = owner.read(false, undefined, new AbortController().signal) await vi.waitFor(() => expect(mocks.call.mock.calls.at(-1)?.[2].waitForListing).toBe(true)) if (invalidate !== 'account') { recordHostModelCatalogSnapshot( @@ -151,7 +151,7 @@ it('never restores a catalog retired or invalidated during a failed refresh', as mocks.call .mockResolvedValueOnce({ origin: 'unknown', listingInProgress: true }) .mockRejectedValueOnce(new Error('still offline')) - await owner.read() + await owner.read(false, undefined, new AbortController().signal) recordHostModelCatalogSnapshot(target, 'codex', 'id:unrelated', catalog('other')) expect(owner.snapshot.answer).toEqual({ origin: 'unknown' }) } @@ -262,7 +262,12 @@ it('keeps native-only answers out of guest and differing paired-command routes', serverSettings: async () => ({ agentCmdOverrides: { codex: '/server/codex' } }) } ]) { - const answer = await agentPickerModelCatalogReads(input).catalog(entry) + const answer = await agentPickerModelCatalogReads(input).catalog( + entry, + false, + undefined, + new AbortController().signal + ) const menu = modelMenuOptions(answer, { agent: 'codex', surface: 'terminal', diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.ts index bbf8fae80f8..b82fdd5dd07 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-catalog.ts @@ -1,4 +1,5 @@ import type { AgentSessionModelCatalogResult } from '../../../../../shared/agent-session/agent-session-wire' +import { HostModelMenuPhases } from './host-model-menu-phases' import type { RuntimeClientTarget } from '../../../../../shared/runtime-client-target' import { structuredAgentSessionHostKey } from '../host-capabilities/structured-agent-session-host-capability' import { callStructuredAgentSession } from '../requests/structured-agent-session-call' @@ -24,11 +25,6 @@ export type HostModelMenuSnapshot = { generation: number } type Reader = (waitForListing: boolean) => Promise -type PhaseResult = { - answer?: AgentSessionModelCatalogResult - reply?: AgentSessionModelCatalogResult - waited?: boolean -} const owners = new Map() function withoutWaitExpiry(answer: AgentSessionModelCatalogResult) { if (!answer.waitExpired) { @@ -69,7 +65,15 @@ const CLI_REUSE_INTERVAL_MS = 10 * 60 * 1000 class HostModelMenuCatalog { listeners = new Set<() => void>() snapshot: HostModelMenuSnapshot - private pending?: { waited: boolean; result: Promise } + private phases = new HostModelMenuPhases( + (waited, current) => this.requestPhase(waited, current), + () => ({ + ...withoutWaitExpiry(this.snapshot.answer ?? { origin: 'unknown' }), + listingInProgress: true + }), + () => this.reuseHeld(), + () => this.syncPhases() + ) private unsubscribe?: () => void constructor(readonly scope: HostModelMenuScope) { this.snapshot = { @@ -113,54 +117,47 @@ class HostModelMenuCatalog { } subscribe = (listener: () => void) => { this.listeners.add(listener) + this.watch() + return () => { + this.listeners.delete(listener) + this.retire() + } + } + private watch() { this.unsubscribe ??= subscribeHostModelCatalogSnapshot( this.scope.target, this.scope.agent, (change) => { if (change.forgotten) { - // An older account's physical read may finish, but cannot own this generation. - this.pending = undefined - this.publish({ pending: false }) + this.phases.invalidate() + this.syncPhases() } else { this.publish({ ...this.snapshot, answer: this.held() }) } }, this.scope.sourceKey ) - return () => { - this.listeners.delete(listener) - this.retire() - } } - async read( - reuseHeld = false, - waitForListing?: boolean, - signal?: AbortSignal - ): Promise { - const generation = this.snapshot.generation - let result = await this.readPhase(reuseHeld, waitForListing ?? false) - while ( - waitForListing === undefined && - result.reply?.listingInProgress && - (!result.waited || result.reply.waitExpired) && - generation === this.snapshot.generation && - !signal?.aborted && - (signal !== undefined || this.listeners.size > 0) - ) { - result = await this.readPhase(false, true) - } - return result.answer + private syncPhases() { + const generation = hostModelCatalogGeneration( + this.scope.target, + this.scope.agent, + this.scope.sourceKey + ) + this.publish({ + ...(this.snapshot.generation === generation ? this.snapshot : {}), + pending: this.phases.pending + }) + this.retire() } - private readPhase(reuseHeld: boolean, waitForListing: boolean): Promise { - const { target, agent, worktree } = this.scope - const generation = hostModelCatalogGeneration(target, agent, this.scope.sourceKey) - const current = () => - generation === hostModelCatalogGeneration(target, agent, this.scope.sourceKey) - if (this.pending) { - return waitForListing && !this.pending.waited - ? this.pending.result.then(() => (current() ? this.readPhase(false, true) : {})) - : this.pending.result + read(reuseHeld: boolean, waitForListing: boolean | undefined, signal: AbortSignal) { + if (signal.aborted) { + return Promise.resolve(undefined) } + this.watch() + return this.phases.read(reuseHeld, waitForListing, signal) + } + private reuseHeld() { const completedAt = this.scope.sourceKey ? hostModelCatalogCompletedAttempt( this.scope.target, @@ -169,16 +166,14 @@ class HostModelMenuCatalog { this.scope.sourceKey ) : undefined - if ( - reuseHeld && - waitForListing !== true && - completedAt !== undefined && - Date.now() - completedAt < CLI_REUSE_INTERVAL_MS - ) { + if (completedAt !== undefined && Date.now() - completedAt < CLI_REUSE_INTERVAL_MS) { this.publish({ ...this.snapshot, pending: false, attempted: true }) - this.retire() - return Promise.resolve({ answer: retained(this.held() ?? this.snapshot.answer) }) + return { answer: retained(this.held() ?? this.snapshot.answer) } } + return undefined + } + private async requestPhase(waitForListing: boolean, current: () => boolean) { + const { target, agent, worktree } = this.scope const request: Reader = this.scope.request ?? ((waitForListing) => @@ -187,58 +182,47 @@ class HostModelMenuCatalog { ...(worktree ? { worktree } : {}), ...(waitForListing ? { waitForListing: true } : {}) })) - this.publish({ ...this.snapshot, answer: retained(this.snapshot.answer), pending: true }) let contextUnresolved = false - const operation: Promise = Promise.resolve() - .then(() => request(waitForListing)) - .catch((error) => { - contextUnresolved = error instanceof ModelMenuContextUnresolvedError - return undefined - }) - .then((answer) => { - if (!current()) { - return this.pending?.result !== operation ? (this.pending?.result ?? {}) : {} - } - if (this.scope.sourceKey && !contextUnresolved && !answer?.listingInProgress) { - hostModelCatalogCompletedAttempt( - target, - agent, - worktree ?? null, - this.scope.sourceKey, - Date.now() - ) - } - if (answer) { - recordHostModelCatalogSnapshot( - target, - agent, - worktree ?? null, - withoutWaitExpiry(answer), - this.scope.sourceKey - ) - } - const shown = answer?.listingInProgress - ? withListingStatus(this.held() ?? answer, { - ...answer, - waitExpired: waitForListing && answer.waitExpired ? true : undefined - }) - : answer - ? this.held() - : retained(this.held() ?? this.snapshot.answer) - this.publish({ answer: shown, pending: false, attempted: true }) - return { answer: shown, reply: answer, waited: waitForListing } - }) - .finally(() => { - if (this.pending?.result === operation) { - this.pending = undefined - } - this.retire() - }) - this.pending = { waited: waitForListing, result: operation } - return operation + let answer: AgentSessionModelCatalogResult | undefined + try { + answer = await request(waitForListing) + } catch (error) { + contextUnresolved = error instanceof ModelMenuContextUnresolvedError + } + if (!current()) { + return {} + } + if (this.scope.sourceKey && !contextUnresolved && !answer?.listingInProgress) { + hostModelCatalogCompletedAttempt( + target, + agent, + worktree ?? null, + this.scope.sourceKey, + Date.now() + ) + } + if (answer) { + recordHostModelCatalogSnapshot( + target, + agent, + worktree ?? null, + withoutWaitExpiry(answer), + this.scope.sourceKey + ) + } + const shown = answer?.listingInProgress + ? withListingStatus(this.held() ?? answer, { + ...answer, + waitExpired: waitForListing && answer.waitExpired ? true : undefined + }) + : answer + ? this.held() + : retained(this.held() ?? this.snapshot.answer) + this.publish({ answer: shown, pending: this.phases.pending, attempted: true }) + return { answer: shown, reply: answer, waited: waitForListing } } private retire() { - if (!this.listeners.size && !this.pending) { + if (!this.listeners.size && !this.phases.busy) { this.unsubscribe?.() this.unsubscribe = undefined if (owners.get(keyOf(this.scope)) === this) { diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-freshness.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-freshness.test.ts index 115e3be1947..933dd05d055 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-freshness.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-freshness.test.ts @@ -45,28 +45,30 @@ it.each([ } let owner = hostModelMenuCatalog(scope) let stop = owner.subscribe(() => {}) - await owner.read(true) + await owner.read(true, undefined, new AbortController().signal) stop() now = 600000 owner = hostModelMenuCatalog(scope) stop = owner.subscribe(() => {}) - expect(await owner.read(true)).toEqual(held) + expect(await owner.read(true, undefined, new AbortController().signal)).toEqual(held) expect(request).toHaveBeenCalledTimes(1) now = 600001 - const refreshing = owner.read(true) + const refreshing = owner.read(true, undefined, new AbortController().signal) expect(owner.snapshot.answer).toEqual(held) await refreshing expect(owner.snapshot.answer).toEqual(held) - await owner.read(true) + await owner.read(true, undefined, new AbortController().signal) expect(request).toHaveBeenCalledTimes(2) now = 1200001 // Time alone does no work. expect(request).toHaveBeenCalledTimes(2) - expect(await owner.read(true)).toEqual(answer('new-model')) + expect(await owner.read(true, undefined, new AbortController().signal)).toEqual( + answer('new-model') + ) const notices = vi.fn() const detach = subscribeHostModelCatalogSnapshot(target, 'antigravity', notices, 'cli') now = 1800001 - await owner.read(true) + await owner.read(true, undefined, new AbortController().signal) expect(notices).not.toHaveBeenCalled() detach() stop() @@ -81,8 +83,10 @@ it('does not suppress a prompt retry after an unresolved WSL context', async () const scope = { target, agent: 'antigravity', sourceKey: 'cli-unresolved', request } const owner = hostModelMenuCatalog(scope) const stop = owner.subscribe(() => {}) - await owner.read(true) - expect(await owner.read(true)).toEqual(answer('ubuntu-model')) + await owner.read(true, undefined, new AbortController().signal) + expect(await owner.read(true, undefined, new AbortController().signal)).toEqual( + answer('ubuntu-model') + ) expect(request).toHaveBeenCalledTimes(2) stop() }) @@ -97,13 +101,15 @@ it('runtime invalidation bypasses reuse and fences an old native response', asyn const scope = { target, agent: 'antigravity', sourceKey: 'cli-switch', request } const owner = hostModelMenuCatalog(scope) const stop = owner.subscribe(() => {}) - await owner.read(true) - const nativePending = owner.read() + await owner.read(true, undefined, new AbortController().signal) + const nativePending = owner.read(false, undefined, new AbortController().signal) await Promise.resolve() // The real settings subscription drives this same host/agent invalidation on shell changes. forgetHostModelCatalogSnapshots(target) now = 2 - expect(await owner.read(true)).toEqual(answer('ubuntu-model')) + expect(await owner.read(true, undefined, new AbortController().signal)).toEqual( + answer('ubuntu-model') + ) old.resolve(answer('native-late')) await nativePending expect(owner.snapshot.answer).toEqual(answer('ubuntu-model')) diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-phases.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-phases.ts new file mode 100644 index 00000000000..b14b7842d8b --- /dev/null +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-phases.ts @@ -0,0 +1,189 @@ +import type { AgentSessionModelCatalogResult } from '../../../../../shared/agent-session/agent-session-wire' + +type PhaseResult = { + answer?: AgentSessionModelCatalogResult + reply?: AgentSessionModelCatalogResult + waited?: boolean + waiting?: Phase +} +type Claim = { + generation: number + signal: AbortSignal + end: () => void + withdraw?: () => void +} +type Phase = { + waited: boolean + generation: number + completion: ReturnType> + callers: Map void> + settled?: boolean +} + +export class HostModelMenuPhases { + private generation = 0 + private claims = new Set() + private physical = new Set() + private active?: Phase + private queued?: Phase + constructor( + private readonly perform: (waited: boolean, current: () => boolean) => Promise, + private readonly provisional: () => AgentSessionModelCatalogResult, + private readonly reuse: () => PhaseResult | undefined, + private readonly changed: () => void + ) {} + get pending() { + return this.active !== undefined + } + get busy() { + return this.claims.size > 0 || this.physical.size > 0 || this.queued !== undefined + } + invalidate() { + const claims = [...this.claims] + this.generation++ + this.active = undefined + const queued = this.queued + this.queued = undefined + if (queued) { + this.complete(queued, {}) + } + for (const claim of claims) { + claim.end() + } + } + async read(reuseHeld: boolean, waitForListing: boolean | undefined, signal: AbortSignal) { + if (signal.aborted) { + return undefined + } + const claim: Claim = { + generation: this.generation, + signal, + end: () => { + if (!this.claims.delete(claim)) { + return + } + claim.withdraw?.() + signal.removeEventListener('abort', claim.end) + this.changed() + } + } + this.claims.add(claim) + signal.addEventListener('abort', claim.end, { once: true }) + try { + const initial = this.phase(claim, waitForListing ?? false, reuseHeld) + let result = await (waitForListing === undefined && 'waiting' in initial && initial.waiting + ? this.join(initial.waiting, claim) + : initial) + while ( + waitForListing === undefined && + this.live(claim) && + result.reply?.listingInProgress && + (!result.waited || result.reply.waitExpired) + ) { + result = await this.phase(claim, true, false) + } + return this.live(claim) ? result.answer : undefined + } finally { + claim.end() + } + } + private live(claim: Claim) { + return !claim.signal.aborted && claim.generation === this.generation && this.claims.has(claim) + } + private phase( + claim: Claim, + waited: boolean, + reuseHeld: boolean + ): PhaseResult | Promise { + if (!this.live(claim)) { + return {} + } + if (this.active) { + if (this.active.waited && !waited) { + return { answer: this.provisional(), waiting: this.active } + } + if (!this.active.waited && waited) { + this.queued ??= this.create(true) + return this.join(this.queued, claim) + } + return this.join(this.active, claim) + } + const held = reuseHeld && !waited ? this.reuse() : undefined + if (held) { + return held + } + const phase = this.create(waited) + const result = this.join(phase, claim) + this.start(phase) + return result + } + private create(waited: boolean): Phase { + return { + waited, + generation: this.generation, + completion: Promise.withResolvers(), + callers: new Map() + } + } + private join(phase: Phase, claim: Claim): Promise { + if (!this.live(claim) || phase.generation !== this.generation) { + return Promise.resolve({}) + } + if (phase.settled) { + return phase.completion.promise + } + return new Promise((resolve) => { + const finish = (result: PhaseResult) => { + phase.callers.delete(claim) + claim.withdraw = undefined + resolve(result) + } + phase.callers.set(claim, finish) + claim.withdraw = () => { + phase.callers.delete(claim) + claim.withdraw = undefined + if (this.physical.has(phase)) { + void phase.completion.promise.then(() => resolve({})) + } else { + resolve({}) + } + if (this.queued === phase && !phase.callers.size) { + this.queued = undefined + this.complete(phase, {}) + } + } + }) + } + private complete(phase: Phase, result: PhaseResult) { + phase.settled = true + phase.completion.resolve(result) + for (const finish of phase.callers.values()) { + finish(result) + } + } + private start(phase: Phase) { + this.active = phase + this.physical.add(phase) + this.changed() + void Promise.resolve() + .then(() => + phase.generation === this.generation && [...phase.callers.keys()].some((c) => this.live(c)) + ? this.perform(phase.waited, () => phase.generation === this.generation) + : {} + ) + .catch(() => ({})) + .then((result) => { + this.physical.delete(phase) + if (this.active === phase) { + this.active = undefined + const queued = this.queued + if (queued) { + this.start(queued) + this.queued = undefined + } + } + this.complete(phase, result) + this.changed() + }) + } +} diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-sources.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-sources.test.ts index bce63ccc4c9..662c5a96d5d 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-sources.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-menu-sources.test.ts @@ -44,7 +44,10 @@ it.each([3, 30])( structured.subscribe(() => {}), terminal.subscribe(notices) ]).flat() - const reads = Array.from({ length: count }, () => [structured.read(), terminal.read()]).flat() + const reads = Array.from({ length: count }, () => [ + structured.read(false, undefined, new AbortController().signal), + terminal.read(false, undefined, new AbortController().signal) + ]).flat() stops.forEach((stop) => stop()) expect(hostModelMenuCatalog({ ...base, sourceKey: 'cli', request })).toBe(terminal) const stop = terminal.subscribe(notices) @@ -88,8 +91,8 @@ it.each(['structured-first', 'cli-first'])( terminal = hostModelMenuCatalog({ ...base, sourceKey: 'cli', request }) const stopChat = chat.subscribe(() => {}), stopCli = terminal.subscribe(() => {}) - const chatRead = chat.read(), - cliRead = terminal.read() + const chatRead = chat.read(false, undefined, new AbortController().signal), + cliRead = terminal.read(false, undefined, new AbortController().signal) if (order === 'structured-first') { acp.resolve(positive('base')) await chatRead @@ -116,7 +119,7 @@ it.each(['structured-first', 'cli-first'])( const successor = hostModelMenuCatalog({ ...base, sourceKey: 'cli', request }) const detach = successor.subscribe(() => {}) request.mockRejectedValueOnce(new Error('offline')) - expect(await successor.read()).toEqual(negative) + expect(await successor.read(false, undefined, new AbortController().signal)).toEqual(negative) expect( readHostModelCatalogSnapshot( target, @@ -146,7 +149,7 @@ it.each(['structured-first', 'cli-first'])( }) const closeReopened = reopened.subscribe(() => {}) request.mockRejectedValueOnce(new Error('reopen offline')) - expect(await reopened.read()).toEqual(negative) + expect(await reopened.read(false, undefined, new AbortController().signal)).toEqual(negative) closeReopened() detach() } @@ -154,7 +157,7 @@ it.each(['structured-first', 'cli-first'])( request.mockReturnValueOnce(late.promise) const owner = hostModelMenuCatalog({ ...base, sourceKey: 'cli', request }) const detach = owner.subscribe(() => {}) - const reading = owner.read() + const reading = owner.read(false, undefined, new AbortController().signal) await Promise.resolve() forgetHostModelCatalogSnapshots(target) late.resolve(positive('stale')) @@ -162,7 +165,9 @@ it.each(['structured-first', 'cli-first'])( expect(owner.snapshot.answer).toBeUndefined() expect(chat.snapshot.answer).toBeUndefined() request.mockResolvedValueOnce(positive('replacement')) - expect(await owner.read()).toMatchObject({ models: [{ id: 'replacement' }] }) + expect(await owner.read(false, undefined, new AbortController().signal)).toMatchObject({ + models: [{ id: 'replacement' }] + }) detach() stopChat() } @@ -180,7 +185,7 @@ it.each([3, 30])( request: async () => positive('variant') }) const stop = owner.subscribe(() => {}) - await owner.read() + await owner.read(false, undefined, new AbortController().signal) stop() forgetHostModelCatalogSnapshots(target, ['antigravity']) } @@ -199,7 +204,7 @@ it.each([3, 30])( } const old = hostModelMenuCatalog(scope) const stop = old.subscribe(() => {}) - const reading = old.read() + const reading = old.read(false, undefined, new AbortController().signal) await Promise.resolve() forgetHostModelCatalogSnapshots(target, ['antigravity']) stop() diff --git a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-runtime-invalidation.test.ts b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-runtime-invalidation.test.ts index de757638751..c617daf8f80 100644 --- a/src/renderer/src/runtime/native-chat/model-catalogs/host-model-runtime-invalidation.test.ts +++ b/src/renderer/src/runtime/native-chat/model-catalogs/host-model-runtime-invalidation.test.ts @@ -52,8 +52,8 @@ it('switching PowerShell to WSL invalidates a fresh native list and its in-fligh } const owner = hostModelMenuCatalog(scope) const stop = owner.subscribe(() => {}) - await owner.read(true) - const pending = owner.read() + await owner.read(true, undefined, new AbortController().signal) + const pending = owner.read(false, undefined, new AbortController().signal) await Promise.resolve() const successor = { ...previous, @@ -61,7 +61,9 @@ it('switching PowerShell to WSL invalidates a fresh native list and its in-fligh } store.getState.mockReturnValue(successor) change(successor, previous) - expect(await owner.read(true)).toMatchObject({ models: [{ id: 'ubuntu-model' }] }) + expect(await owner.read(true, undefined, new AbortController().signal)).toMatchObject({ + models: [{ id: 'ubuntu-model' }] + }) late.resolve(native) await pending expect(owner.snapshot.answer).toMatchObject({ models: [{ id: 'ubuntu-model' }] })