mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
fix: retain model discovery through demand-owned phase transitions
This commit is contained in:
@@ -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()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+16
-11
@@ -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',
|
||||
|
||||
+12
-10
@@ -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',
|
||||
|
||||
+185
-73
@@ -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)
|
||||
}
|
||||
})
|
||||
|
||||
+14
-9
@@ -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) {
|
||||
|
||||
+17
-11
@@ -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()
|
||||
})
|
||||
}
|
||||
}
|
||||
+14
-9
@@ -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()
|
||||
|
||||
+5
-3
@@ -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' }] })
|
||||
|
||||
Reference in New Issue
Block a user