fix: retain model discovery through demand-owned phase transitions

This commit is contained in:
Brennan Benson
2026-11-09 20:39:43 -08:00
parent c7f3dab2b5
commit 6379587c83
15 changed files with 622 additions and 253 deletions
@@ -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()
@@ -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<Observer>()
entries: AgentPickerEntry[]
settingsPending = false
private demand = new AgentPickerSourceDemand()
private outstanding = { catalog: 0, refresh: 0, support: 0 }
private queued: Record<ReadKind, Set<number>>
private supports = new Map<number, SupportRead>()
@@ -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()
})
@@ -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,
@@ -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()
})
@@ -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<AgentPickerEntry['catalog'] | undefined>
observeCatalog?: (
entry: AgentPickerEntry,
@@ -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<AgentPickerAcquisitionObserver>
) {
return [...observers].some(
(observer) =>
observer.usesSource?.(entry, source) ??
(source !== 'cli' || modelCatalogSource(entry.agent, entry.defaultSurface) === source)
)
}
export class AgentPickerSourceDemand {
private controllers = new Map<number, AbortController>()
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()
}
}
}
}
@@ -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',
@@ -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',
@@ -12,91 +12,203 @@ const models = (id: string): AgentSessionModelCatalogResult => ({
listingNamesConfiguredModel: false,
models: [{ id, label: id, isDefault: false, efforts: [] }]
})
function transportReply() {
const result = Promise.withResolvers<AgentSessionModelCatalogResult>()
const started = Promise.withResolvers<void>()
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<AgentSessionModelCatalogResult>>()
.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<AgentSessionModelCatalogResult>>((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<AgentSessionModelCatalogResult | undefined>[] = []
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<AgentSessionModelCatalogResult>>()
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<AgentSessionModelCatalogResult | undefined>[] = []
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<AgentSessionModelCatalogResult>()
const wait = Promise.withResolvers<AgentSessionModelCatalogResult>()
const request = vi
.fn<(wait: boolean) => Promise<AgentSessionModelCatalogResult>>()
.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<AgentSessionModelCatalogResult>()
const closingRequest = vi
.fn<(wait: boolean) => Promise<AgentSessionModelCatalogResult>>()
.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)
}
})
@@ -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',
@@ -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<AgentSessionModelCatalogResult | undefined>
type PhaseResult = {
answer?: AgentSessionModelCatalogResult
reply?: AgentSessionModelCatalogResult
waited?: boolean
}
const owners = new Map<string, HostModelMenuCatalog>()
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<PhaseResult> }
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<AgentSessionModelCatalogResult | undefined> {
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<PhaseResult> {
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<PhaseResult> = 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) {
@@ -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'))
@@ -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<typeof Promise.withResolvers<PhaseResult>>
callers: Map<Claim, (result: PhaseResult) => void>
settled?: boolean
}
export class HostModelMenuPhases {
private generation = 0
private claims = new Set<Claim>()
private physical = new Set<Phase>()
private active?: Phase
private queued?: Phase
constructor(
private readonly perform: (waited: boolean, current: () => boolean) => Promise<PhaseResult>,
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<PhaseResult> {
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<PhaseResult>(),
callers: new Map()
}
}
private join(phase: Phase, claim: Claim): Promise<PhaseResult> {
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()
})
}
}
@@ -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()
@@ -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' }] })