[Alexandru Dima (alexdima)]

Follow-up to #342698.

Problem

The local model bridge tests waited with two helpers from fakeLlamaServer.ts. settle(rounds = 5) yielded to setImmediate a fixed number of times. waitFor(predicate, timeoutMs = 10_000) re-checked a predicate after each setImmediate until a real-time deadline. On origin/main eeedb17 there were 105 waitFor and 27 settle calls: 26 and 5 in serverSupervisor.test.ts, 79 and 20 in shimLocalModelProvider.test.ts, and 2 settle calls in servingAccessImpl.test.ts. Four loops were built on settle: the record-and-lock loop of the supervisor's dispose test, the supervisor's driveProbeRetries, and the two polls < 50 health-poll loops in the shim tests. local/code-no-timeout-polling-loop reports none of them, because the polling happens inside the helpers.

How long these waits lasted depended on how many event-loop turns the code under test happened to take. The fixed-turn settle() calls were mostly negative checks, and how strong they were depended on that same timing. Two examples: when user drains were given a timeout, the update test's "after an hour" check still passed (M6). When an Auto session ignored "Use in Auto" being off, the Auto test still passed (M11).

Change

Wait	Waited for	Now awaits
waitFor on supervisor.state (24, supervisor tests)	supervisor state	waitForState(supervisor.state, ...)
waitFor on the provider's status (63, shim tests)	status, through family() and activeReady()	whenStatus(harness, predicate), a waitForState on harness.provider.status
status stopped after provider.stop() (5)	the user stop has ended	whenStopped(harness): the stop promise of the harness's new RecordingSupervisor, then the status
downloader.requests.length === n (3)	a download was requested	FakeDownloader.whenRequested(n), deferreds completed by the fake
runtime.listDevicesWaiting (2)	a load is held in its device probe	FakeRuntime.listDevicesHeld, a deferred completed at the gate
processes[0].hasExited && server === 'stopped' (2)	the cancelled load's process exited and the server stopped	await process.exited, then waitForState(supervisor.state, ...)
!fs.existsSync(<old version>) (1)	the update pruned the old version	nothing more (see below)
health-poll loops (2, shim tests) and driveProbeRetries	the server's health is polled on the fake clock	pollUntil(harness, predicate) and driveProbeRetries race the result with FakeClock.whenTimerDue(<poll interval>), and advance one poll only when one is pending
dispose test: settle() and the loop on the record file and the lock, with a 10 s deadline	the supervisor's record deletion and lock release	recordWorkDone(supervisor): a no-op queued on the supervisor's _recordIo sequencer, which runs that work; after the exit, await child.exited first
crash during a user drain: settle()	the supervisor's exit handler	await child.exited
stopOutcome: waitFor(() => outcome !== 'pending', 2_000)	the stop settles, with a readable pending otherwise	raceTimeout(stop, 2_000)
"after an hour" checks (3): waitFor(() => true) or settle()	negative: the drain has no timeout	FakeClock.advance now returns how many timers ran; the snapshot asserts timersRun: 0
idle timeout with a hold: settle()	negative: no idle unload	the server state and telemetry events right after the advance; the idle timer's callback decides and reports idleUnload synchronously
settle() after an Auto session with Use in Auto off, after endTurn, and after a stale or cancelled preparation completes (4)	negative: nothing loads	pendingLoad(harness), the provider's in-flight _start promise, captured before the gate opens in the two preparation tests
device change test: waitFor(server stopped && family gone) and two settle(20)	the swap goes on after its drain; then a start and a direct request	pendingSwap(harness) (the swap's settled), and pendingLoad(harness) after the start and after the direct request
settle() after the context size reload	negative: exactly one reload	pendingSwap(harness)
servingAccessImpl.test.ts (2)	ensureStarted has decided	clock.whenTimerDue(LOAD_TIMEOUT_MS): waiting for a swap or for a start arms the load deadline
other settle() calls (9)	nothing that decides the result	removed (see below)

settle() and waitFor() are removed from fakeLlamaServer.ts.

Details worth a look:

• The provider's stop. The status reads stopped as soon as the supervisor publishes it. The provider still refuses background loads until the supervisor's stop promise settles and its .finally clears _userStopPending. A first draft that waited only for the status made three tests time out, because start() or updateLiveConfig() came too early (M12b). RecordingSupervisor overrides stop() to keep the latest stop promise. Awaiting that promise runs after the provider's .finally.
• Private state in three helpers. recordWorkDone, pendingLoad and pendingSwap read _recordIo, _start and _swap through element access. None of them has a public completion signal. Each line disables local/code-no-bracket-notation-for-identifiers with a reason, as 17 other test files do.
• Negative checks. Every timeout here would be a timer on the injected clock, which fires synchronously in advance(), so timersRun: 0 holds deterministically. Under M6 all three "after an hour" tests fail; with the original tests, the update test passes. The idle check asserts the unload decision, not the timer. M7b, which arms the idle timer while the server is held and still refuses the unload, passes. pendingLoad and pendingSwap wait until a load that should not happen has either happened or given up (M9 to M11).
• Removed settle() calls.
  • Four come after dispose(), where the aborted download rejects in its abort listener and nothing is persisted after disposal.
  • Two come after setContextSize(), which begins the reload swap, or records the pending size, before it returns. The phases autorun sees a new swap synchronously.
  • One comes after a start whose stored replace record is dropped. The operations come from _restoreOperations, which runs synchronously at the end of initialization.
  • One comes after the consent outcome reaches the status. The download count is final by then.
  • One comes after a cancel during the first load. _pauseByUser persists the record synchronously.
• The prune wait. _completeAcquisition awaits pruneOwnedVersions before _removeOperation. So the preceding wait for "no operation" already implies that the old version directory is gone. versions: ['2'] stays asserted.
• The update test now waits for the drain itself (phase === 'draining' && !!active.drain). Waiting only for the provider's draining phase resumes before the supervisor's queued _doStop publishes stopping.
• pollUntil currently never advances in the two shim tests. whenStatus resumes before the spawned server's record write completes, so the tests release the server before its first health check. It still advances whenever a poll is pending, and M5 shows the same mechanism is required in the supervisor probe tests.
• The remaining setImmediate, in FakeLlamaSpawner.spawn, defers behavior until the supervisor has attached its listeners. It is a one-shot deferral, not a wait.
• Shared fakes. FakeClock is shared with copilotRequestHandler.test.ts, routeTable.test.ts and an integration test. The whole folder passes: 276 passing, 1 pending, which is a Windows-only test.skip.
• Assertions. All scenarios and assertions are kept. afterAnHour and whileDraining gain timersRun, and afterIdleTimeout now also lists the telemetry events.
• Overlap. The hunk of agentHost: Forward client certificates to WSL and local containers #343431 in shimLocalModelProvider.test.ts applies on top of this change with a 23-line offset.

There are no product-code changes. The extended rule (agents/no-timeout-polling-rule-v2) has not landed, and eslint.config.js has no exclude entries for these files.

Validation

The change was rebased onto 53b7b19, the live tip of main. None of the 10 commits since eeedb17 touch these files, the shim product code or the rule. The machine was shared, so load averages (1, 5 and 15 min) are given with each timed run.

• Baseline on eeedb17, ./scripts/test.sh --run src/vs/platform/agentHost/test/node/localModelBridge/serverSupervisor.test.ts --run src/vs/platform/agentHost/test/node/localModelBridge/shimLocalModelProvider.test.ts --run src/vs/platform/agentHost/test/node/localModelBridge/servingAccessImpl.test.ts: 103 passing, 0 pending, 6 s Mocha time, 19 s wall, load 18.4 rising to 22.6.
• git grep -n "settle\|waitFor\|setImmediate" -- src/vs/platform/agentHost/test/node/localModelBridge/:
  • Before: 162 lines, with 105 waitFor( calls, 27 settle( calls, the two helper definitions and 3 setImmediate.
  • After: 55 lines, with no settle( or waitFor( calls and 1 setImmediate, the spawn deferral.
  • The other matches are waitForState, and the words "settled" and "settles" in copilotRequestHandler.test.ts, modelCatalog.test.ts and these files.
• npx eslint --rule '{"local/code-no-timeout-polling-loop": ["warn", {"exclude": []}]}' <the five changed files>: 0 problems before and after, because the current rule cannot see these waits. I also applied the in-progress v2 rule from agents/no-timeout-polling-rule-v2 temporarily. It reports 2 warnings on the original fakeLlamaServer.ts (settle and waitFor) and none on the changed files.
• 10 runs on cef3bbc, for i in $(seq 10); do ./scripts/test.sh --run <the three files> 2>&1 | grep -E 'passing|failing'; done: 10/10 with 103 passing. Mocha time was 2 to 4 s and wall time 4 to 6 s, at a 1-minute load of 4.6 to 5.5. An earlier batch on the change before its last three edits (the idle check, the serving waits and moving RecordingSupervisor) also passed 10/10, with Mocha time of 3 to 19 s while other sessions raised the 1-minute load from 8 to 35.
• Under CPU load with 18 yes processes, lockf -t 3600 /tmp/vscode-no-timeout-polling-stress.lock bash -c 'pids=(); for i in $(seq 18); do yes > /dev/null & pids+=($!); done; ./scripts/test.sh --run <the three files> 2>&1 | grep -E "passing|failing"; kill "${pids[@]}"':
  • cef3bbc: 103 passing twice. Mocha time was 27 s and 21 s, wall time 37 s and 35 s, and load rose from 5.4 to 22.3, then from 22.3 to 27.9.
  • For comparison, on the change before its last three edits, at load 32 to 40: the new tests had 103 passing twice (37 s and 16 s Mocha time). The original tests had 103 passing twice (20 s and 16 s Mocha time, 51 s wall each). There was no meaningful difference at this load.
• Mutation checks. Each was applied by a script and run with --grep on the three files, then restored from a backup, with the diff hash checked after each. They ran before the rebase. The code they touch is the same in cef3bbc, except M7, M7b, M15 and M15b, which ran after the last edits.
  • M1, supervisor state: without the drain wait, "a user stop completes when the last running response ends …" fails with drainedStreams: 0 instead of 1.
  • M2, provider status: without the ready wait after turning Use in Auto on, the Auto test fails with spawns: 1 instead of 2.
  • M3, fake downloader: with whenRequested never completing, "model A keeps serving while B downloads …" hits the Mocha timeout.
  • M4, fake runtime: with listDevicesHeld never completing, both preparation tests hit the Mocha timeout.
  • M5, fake clock: with whenTimerDue never resolving, both supervisor tests that use driveProbeRetries hit the Mocha timeout. The two shim pollUntil tests still pass (see above).
  • M6, negative check in virtual time: with user drains given the system drain timeout, "a user stop drains with no timeout …", "concurrent swap requests share one operation …" and "update: a newer build …" fail with timersRun: 1. With the original tests, the update test passes under this mutation.
  • M7 and M7b, idle unload: with the idle unload ignoring holds (_onUseReleased, _armIdle, its callback and _doStop), the hold test hits the Mocha timeout at its later drain wait. The original test does the same. With only the timer armed while held, and the unload still refused (M7b), the test passes.
  • M8a and M8b, record and lock work: with dispose() deleting the record and releasing the lock at once, the dispose test fails with record: false, lockFree: true. Without the waits after the exit (M8b), it fails with the record present and the lock held.
  • M9, stale load: with a cancelled preparation no longer treated as superseded (the superseded() guard and the plan's signal removed), "cancelling a swap while its load is still being prepared …" fails: example-coder spawns and the server is ready. The original test also fails, with the server starting. "a load still being prepared never overtakes a swap" passes under this mutation, because the active-family check and the supervisor's refusal to replace a server with running responses still hold.
  • M10, swap: with the device check removed from _startActive, the device change test fails with server: 'error' instead of 'stopped'. The original test hits the Mocha timeout.
  • M11, Auto: with Auto sessions ignoring Use in Auto, the Auto test fails with spawns: 2, server: 'ready'. The original test passes.
  • M12 and M12b, provider stop: with lastStop never settling, "with Use in Auto off …", "publishes the load step …" and "a load still being prepared …" hit the Mocha timeout. With whenStopped waiting only for the status (M12b), the same three tests time out, because the provider still refuses the next load.
  • M13, raceTimeout: with a crash no longer ending the drain, the crash test fails after 2 s with outcome: 'pending'.
  • M14: without await child.exited, the crash test still passes. That wait orders the scenario, so that the exit is handled before the clock advances, but it does not decide the result.
  • M15 and M15b, serving access: with ensureStarted deciding one microtask later, both serving tests pass. With the same change and the new wait removed from the load-deadline test (M15b), that test hits the Mocha timeout.
• lockf -t 3600 /tmp/vscode-no-timeout-polling-typecheck.lock npm run typecheck-client on cef3bbc: no errors in the changed files. It reports 20 errors in untouched files, because the shared node_modules predates two recent pins: 19 fusionTier errors in Copilot SDK consumers, and 1 setParentWindow error in terminalProcess.ts from Parent the ConPTY console window to the VS Code window #342784.
• npm run eslint -- <the five changed files>: no problems.
• Self-review with the code-review skill: it moved RecordingSupervisor away from the lines agentHost: Forward client certificates to WSL and local containers #343431 changes, and found no other actionable defects.

[Copilot]

🟢 Approval recommended

The test-only replacements align with the relevant completion ordering, with no unresolved correctness issues identified.

No open issues 🎉

What changed in this PR

This test-only follow-up to #342698 replaces polling and fixed event-loop waits in the Agent Host local model bridge tests with explicit completion signals. No product code changes are included.

Changes:

• Await observable state, operation promises, and fake download or runtime signals.
• Extend the fake clock with timer notifications and execution counts to make timeout assertions deterministic.
• Remove obsolete polling helpers while preserving test scenarios and strengthening negative checks.

No actionable findings remain.

File	Description
src/​vs/​platform/​agentHost/​test/​node/​localModelBridge/​shimLocalModelProvider.test.ts	Synchronizes provider tests with status, download, load, swap, and stop completion.
src/​vs/​platform/​agentHost/​test/​node/​localModelBridge/​servingAccessImpl.test.ts	Waits for load deadlines to be armed before continuing.
src/​vs/​platform/​agentHost/​test/​node/​localModelBridge/​serverSupervisor.test.ts	Uses state and lifecycle signals; strengthens drain and idle assertions.
src/​vs/​platform/​agentHost/​test/​node/​localModelBridge/​fakeServingAccess.ts	Adds pending-timer notifications and counts executed timers.
src/​vs/​platform/​agentHost/​test/​node/​localModelBridge/​fakeLlamaServer.ts	Removes the fixed-turn and predicate-polling helpers.

_{Review effort: Balanced}