mixdog 0.9.52 → 0.9.54

package/scripts/memory-core-input-test.mjs

@@ -7,6 +7,7 @@ import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.
 import { createMemoryActionHandlers } from '../src/runtime/memory/lib/memory-action-handlers.mjs'
 import { TOOL_DEFS as MEMORY_TOOL_DEFS } from '../src/runtime/memory/tool-defs.mjs'
 import { parseMemoryCandidateRows, parseMemoryCoreRows } from '../src/tui/app/input-parsers.mjs'
+import { memoryToolArgsForCaller } from '../src/session-runtime/runtime-core.mjs'
 
 test('memory mutation schema omits category while recall keeps its internal filter', () => {
   const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory')
@@ -16,6 +17,15 @@ test('memory mutation schema omits category while recall keeps its internal filt
   assert.equal(Object.hasOwn(recallTool.inputSchema.properties, 'category'), true)
 })
 
+test('memory tool calls inherit the active caller cwd only when cwd is omitted', () => {
+  assert.deepEqual(memoryToolArgsForCaller({ action: 'status' }, '/active/project'), {
+    action: 'status',
+    cwd: '/active/project',
+  })
+  const explicit = { action: 'status', cwd: '/explicit/project' }
+  assert.equal(memoryToolArgsForCaller(explicit, '/active/project'), explicit)
+})
+
 test('core content aliases summary, derives an element, and accepts no category', () => {
   const content = 'A durable preference that callers should receive concise answers.'
   const input = normalizeCoreInput({ content }, {

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -4,7 +4,11 @@ import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
-import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import {
+    sendViaHttpSse,
+    _shouldUseOpenAIHttpFallback,
+} from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import { applyAskTerminalUsageTotals } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
 import {
     _clearWebSocketPoolForTest,
     _closeAllPooledSockets,
@@ -154,6 +158,83 @@ test('acquire timeout reconnects successfully with progress, not a terminal WS e
     }
 });
 
+test('OAuth WS-handshake HTTP 429 is terminal and cannot enter the HTTP fallback gate', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_WS_WARMUP',
+        'MIXDOG_AGENT_TRACE_DISABLE',
+    ].map((name) => [name, process.env[name]]));
+    Object.assign(process.env, {
+        MIXDOG_OAI_TRANSPORT: 'auto',
+        MIXDOG_OPENAI_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    let acquires = 0;
+    let sleeps = 0;
+    let httpCalls = 0;
+    const provider = new OpenAIOAuthProvider({});
+    provider.ensureAuth = async () => ({ access_token: 'test-token' });
+    try {
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: 'openai-oauth-ws-429-test',
+                _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                _sendViaWebSocketFn: async (args) => {
+                    try {
+                        return await sendViaWebSocket({
+                            ...args,
+                            _acquireWithRetryFn: async () => {
+                                acquires += 1;
+                                throw Object.assign(new Error('handshake rate limited'), { httpStatus: 429 });
+                            },
+                            _sleepFn: async () => { sleeps += 1; },
+                        });
+                    } catch (err) {
+                        // Force the provider's real exhausted-WS gate; the
+                        // OAuth predicate itself must still reject this 429.
+                        err.wsRetriesExhausted = true;
+                        throw err;
+                    }
+                },
+                _sendViaHttpSseFn: async () => {
+                    httpCalls += 1;
+                    return { content: 'must not fallback', toolCalls: [], usage: {} };
+                },
+            }),
+            (err) => err?.httpStatus === 429,
+        );
+        assert.equal(_shouldUseOpenAIHttpFallback({ httpStatus: 429, wsRetriesExhausted: true }), false);
+        assert.equal(acquires, 1, 'OAuth 429 must not consume the five-retry WS budget');
+        assert.equal(sleeps, 0, 'OAuth 429 must not schedule WS reconnect backoff');
+        assert.equal(httpCalls, 0, 'OAuth 429 must not enter HTTP/SSE fallback');
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('non-OAuth WS handshakes retain their existing 429 retry budget', async () => {
+    let acquires = 0;
+    await assert.rejects(
+        sendViaWebSocket(wsArgs({
+            traceProvider: 'xai',
+            _acquireWithRetryFn: async () => {
+                acquires += 1;
+                throw Object.assign(new Error('handshake rate limited'), { httpStatus: 429 });
+            },
+            _sleepFn: async () => {},
+        })),
+        (err) => err?.httpStatus === 429 && err?.wsRetriesExhausted === true,
+    );
+    assert.equal(acquires, 6, 'non-OAuth 429 preserves the five-retry WS budget');
+});
+
 for (const failure of ['callback error', 'callback timeout']) {
     test(`send ${failure} drops the socket and retries on a fresh one`, async () => {
         const acquires = [];
@@ -247,6 +328,42 @@ test('pre-response 1006 opens a fresh WS and replays the same request', async ()
     assert.doesNotMatch(stderr, /mid-stream recovered|Reconnecting/);
 });
 
+test('completed warmup usage survives a same-send WS retry exactly once', async () => {
+    let streams = 0;
+    const result = await sendViaWebSocket(wsArgs({
+        warmupBody: { model: 'gpt-5.5', instructions: 'base', input: [], generate: false },
+        _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
+        _streamFn: async ({ state }) => {
+            streams += 1;
+            if (state.warmup) {
+                return {
+                    content: '',
+                    model: 'gpt-5.5',
+                    toolCalls: [],
+                    usage: { inputTokens: 10, outputTokens: 0, cachedTokens: 4, promptTokens: 10 },
+                    responseId: 'warm-retry-1',
+                    responseItems: [],
+                };
+            }
+            if (streams === 2) throw close1006();
+            return {
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 8, promptTokens: 20 },
+                responseId: 'main-retry-1',
+                responseItems: [],
+                closeSocket: true,
+            };
+        },
+    }));
+    assert.equal(streams, 3, 'one warmup plus two main attempts');
+    assert.equal(result.usage.inputTokens, 30);
+    assert.equal(result.usage.outputTokens, 2);
+    assert.equal(result.usage.mainInputTokens, 20);
+    assert.equal(result.usage.warmupInputTokens, 10);
+});
+
 test('successful iteration emits one compact send-spans row', async () => {
     const rows = [];
     const result = await sendViaWebSocket(wsArgs({
@@ -311,7 +428,7 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
     Object.assign(process.env, {
         MIXDOG_OAI_TRANSPORT: 'auto',
         MIXDOG_OPENAI_HTTP_FALLBACK: '1',
-        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '1',
         MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK: '0',
         MIXDOG_AGENT_TRACE_DISABLE: '1',
     });
@@ -327,7 +444,17 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
                 ...args,
                 _acquireWithRetryFn: async () => ({ entry: entry(), reused: false }),
                 _sendFrameFn: async () => {},
-                _streamFn: async () => {
+                _streamFn: async ({ state }) => {
+                    if (state.warmup) {
+                        return {
+                            content: '',
+                            model: 'gpt-5.5',
+                            toolCalls: [],
+                            usage: { inputTokens: 10, outputTokens: 0, cachedTokens: 4, promptTokens: 10 },
+                            responseId: 'warm-fallback-1',
+                            responseItems: [],
+                        };
+                    }
                     streamAttempts += 1;
                     throw close1006();
                 },
@@ -335,7 +462,11 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
             }),
             _sendViaHttpSseFn: async () => {
                 httpCalls += 1;
-                return { content: 'http-recovered', toolCalls: [], usage: {} };
+                return {
+                    content: 'http-recovered',
+                    toolCalls: [],
+                    usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 8, promptTokens: 20 },
+                };
             },
         };
         const result = await provider.send([], 'gpt-5.5', [], sendOpts);
@@ -345,6 +476,15 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
         assert.equal(httpCalls, 2);
         assert.equal(result.content, 'http-recovered');
         assert.equal(stickyResult.content, 'http-recovered');
+        assert.equal(result.usage.inputTokens, 30, 'fallback bills the completed WS warmup once');
+        assert.equal(result.usage.mainInputTokens, 20, 'fallback context remains HTTP-main-only');
+        assert.equal(result.usage.warmupInputTokens, 10);
+        assert.equal(stickyResult.usage.inputTokens, 20, 'sticky HTTP sends do not rebill the old warmup');
+        assert.equal(stickyResult.usage.warmupInputTokens, undefined);
+        const session = { provider: 'openai-oauth' };
+        applyAskTerminalUsageTotals(session, { usage: result.usage, lastTurnUsage: result.usage });
+        assert.equal(session.totalInputTokens, 30, 'lifetime billing includes WS warmup plus HTTP main once');
+        assert.equal(session.lastContextTokens, 20, 'last context remains HTTP-main-only');
         assert.equal(provider._httpFallbackUntilByPoolKey.get(sendOpts.sessionId), Number.POSITIVE_INFINITY);
     } finally {
         for (const [name, value] of Object.entries(savedEnv)) {

package/scripts/openai-ws-early-settle-test.mjs

@@ -12,6 +12,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
+import { classifyMidstreamError, MIDSTREAM_RETRY_POLICY } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
 
 // Minimal fake WS: matches the .on/.off/.close/.ping surface _streamResponse
 // uses. close() is a no-op here -- the early-settle path sets done=true before
@@ -174,3 +175,42 @@ test('ws early settle: function args.done without item.done does NOT early-settl
     await assert.rejects(p, /inter-chunk inactivity/);
     assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'function item must stay active until output_item.done');
 });
+
+test('OpenAI WS rejects an oversized Buffer before UTF-8 conversion and marks it retryable', async () => {
+    const socket = new FakeSocket();
+    const state = { attemptIndex: 0 };
+    const payload = Buffer.alloc(33);
+    payload.toString = () => { throw new Error('oversized Buffer was decoded'); };
+    const p = _streamResponse({
+        entry: { socket },
+        state,
+        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 32 },
+    });
+    socket.emit('message', payload);
+    await assert.rejects(p, (error) => {
+        assert.equal(error.code, 'EOPENAIWSFRAMETOOLARGE');
+        assert.equal(error.retryable, true);
+        assert.match(error.message, /33 bytes; limit 32 bytes.*retryable/);
+        assert.equal(
+            classifyMidstreamError(error, state, MIDSTREAM_RETRY_POLICY.ws),
+            'ws_frame_too_large',
+        );
+        return true;
+    });
+    assert.deepEqual(socket.closed, { code: 1009, reason: 'frame_too_large' });
+});
+
+test('OpenAI WS preserves normal-size Buffer handling', async () => {
+    const socket = new FakeSocket();
+    const p = _streamResponse({
+        entry: { socket },
+        state: {},
+        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 1024 },
+    });
+    socket.emit('message', Buffer.from(JSON.stringify({
+        type: 'response.completed',
+        response: { id: 'resp_normal', model: 'gpt-5.5', output: [] },
+    })));
+    const result = await p;
+    assert.equal(result.responseId, 'resp_normal');
+});

package/scripts/parent-abort-link-test.mjs

@@ -6,6 +6,10 @@ import {
   markSessionCancelled,
   markSessionError,
 } from '../src/runtime/agent/orchestrator/session/manager.mjs';
+import {
+  _clearSessionRuntime,
+  _sweepTerminalSessionRuntimes,
+} from '../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs';
 
 test('markSessionError drops parent AbortSignal listener but keeps runtime entry', () => {
   const sessionId = `parent-abort-error-${Date.now()}`;
@@ -64,3 +68,23 @@ test('markSessionCancelled drops parent AbortSignal listener but keeps runtime e
   assert.equal(childAborted, false);
 });
 
+test('terminal runtime sweep drains the full backlog but preserves in-flight controllers', () => {
+  const prefix = `terminal-retention-${Date.now()}`;
+  const terminalIds = Array.from({ length: 40 }, (_, i) => `${prefix}-${i}`);
+  for (const id of terminalIds) {
+    linkParentSignalToSession(id, new AbortController().signal);
+    markSessionError(id, 'finished');
+    getSessionRuntime(id).controller = null;
+  }
+  const activeId = `${prefix}-active`;
+  linkParentSignalToSession(activeId, new AbortController().signal);
+  markSessionError(activeId, 'provider still unwinding');
+
+  const cleaned = _sweepTerminalSessionRuntimes();
+
+  assert.ok(cleaned >= terminalIds.length, 'one pass drains every settled terminal entry');
+  for (const id of terminalIds) assert.equal(getSessionRuntime(id), null);
+  assert.ok(getSessionRuntime(activeId)?.controller, 'active in-flight controller is retained');
+  _clearSessionRuntime(activeId);
+});
+

package/scripts/process-lifecycle-test.mjs

@@ -4,6 +4,7 @@ import {
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
   rmSync,
   unlinkSync,
   utimesSync,
@@ -103,71 +104,118 @@ test('vanished evidence uses only old-process fields and both ledger files stay
   }
 });
 
-test('PID reuse is detected by process identity while uncertain live identity is preserved', () => {
+test('PID reuse is detected once across a finish/rebegin while uncertain live identity is preserved', async () => {
   const root = tempRoot();
+  let child;
   try {
     const paths = lifecyclePathsForTest(root);
     mkdirSync(paths.markerDir, { recursive: true });
-    const seed = beginProcessLifecycle({ directory: root, configureReports: false });
-    const currentIdentity = JSON.parse(readFileSync(seed.markerPath, 'utf8')).processIdentity;
+    child = spawn(process.execPath, ['--input-type=module', '--eval', `
+      import { beginProcessLifecycle } from './src/runtime/shared/process-lifecycle.mjs';
+      beginProcessLifecycle({ directory: process.env.LEDGER_DIR, configureReports: false });
+      setTimeout(() => {}, 10000);
+    `], {
+      cwd: REPO_ROOT,
+      env: { ...process.env, LEDGER_DIR: root },
+      stdio: 'ignore',
+    });
+    let childMarker;
+    let currentIdentity;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const name = readdirSync(paths.markerDir).find((entry) => entry.startsWith(`${child.pid}-`));
+      if (name) {
+        childMarker = join(paths.markerDir, name);
+        try {
+          currentIdentity = JSON.parse(readFileSync(childMarker, 'utf8')).processIdentity;
+        } catch {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          continue;
+        }
+        if (currentIdentity?.kind === 'linux-start-ticks' || currentIdentity?.method === 'powershell') break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
     assert.ok(currentIdentity);
-    finishProcessLifecycle('clean-shutdown', 0);
-    const reused = join(paths.markerDir, `${process.pid}-reused.json`);
-    const matching = join(paths.markerDir, `${process.pid}-matching.json`);
-    const uncertain = join(paths.markerDir, `${process.pid}-uncertain.json`);
-    const malformed = join(paths.markerDir, `${process.pid}-malformed.json`);
-    const clockAmbiguous = join(paths.markerDir, `${process.pid}-clock.json`);
-    const differentKind = join(paths.markerDir, `${process.pid}-different-kind.json`);
+    if (process.platform === 'win32') assert.equal(currentIdentity.method, 'powershell');
+
+    const reused = join(paths.markerDir, `${child.pid}-reused.json`);
+    const matching = join(paths.markerDir, `${child.pid}-matching.json`);
+    const uncertain = join(paths.markerDir, `${child.pid}-uncertain.json`);
+    const malformed = join(paths.markerDir, `${child.pid}-malformed.json`);
+    const clockAmbiguous = join(paths.markerDir, `${child.pid}-clock.json`);
+    const differentKind = join(paths.markerDir, `${child.pid}-different-kind.json`);
+    const mixedTransient = join(paths.markerDir, `${child.pid}-mixed-transient.json`);
+    const samePidForeign = join(paths.markerDir, `${process.pid}-same-pid-foreign.json`);
     const reusedIdentity = currentIdentity.kind === 'linux-start-ticks'
       ? { kind: currentIdentity.kind, value: String(BigInt(currentIdentity.value) + 1n) }
-      : { kind: currentIdentity.kind, value: currentIdentity.value + 1 };
+      : { ...currentIdentity, value: currentIdentity.value + 1 };
     writeFileSync(reused, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'reused',
       processIdentity: reusedIdentity,
     }));
     writeFileSync(matching, JSON.stringify({
-      pid: process.pid,
+      pid: child.pid,
       token: 'matching',
       processIdentity: currentIdentity,
     }));
     writeFileSync(uncertain, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'uncertain',
     }));
     writeFileSync(malformed, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'malformed',
       processIdentity: process.platform === 'linux'
         ? { kind: 'linux-start-ticks', value: 'not-a-number' }
         : { kind: 'start-seconds', value: 'not-a-number' },
     }));
     writeFileSync(clockAmbiguous, JSON.stringify({
-      pid: process.pid,
-      ppid: process.ppid,
+      pid: child.pid,
       token: 'clock-adjusted',
       processIdentity: { kind: 'legacy-wall-clock', value: Date.now() + 86400000 },
     }));
     writeFileSync(differentKind, JSON.stringify({
-      pid: process.pid,
+      pid: child.pid,
       token: 'different-kind',
       processIdentity: currentIdentity.kind === 'linux-start-ticks'
         ? { kind: 'start-seconds', value: 1 }
         : { kind: 'linux-start-ticks', value: '1' },
     }));
+    if (currentIdentity.kind === 'start-seconds') {
+      writeFileSync(mixedTransient, JSON.stringify({
+        pid: child.pid,
+        token: 'mixed-transient',
+        processIdentity: { kind: currentIdentity.kind, value: currentIdentity.value + 1, method: 'uptime' },
+      }));
+    }
+    writeFileSync(samePidForeign, JSON.stringify({
+      pid: process.pid,
+      token: 'same-pid-foreign',
+      processIdentity: currentIdentity,
+    }));
+    beginProcessLifecycle({ directory: root, configureReports: false });
+    assert.equal(finishProcessLifecycle('clean-shutdown', 0), true);
     beginProcessLifecycle({ directory: root, configureReports: false });
+    const reapDeadline = Date.now() + 5000;
+    while (existsSync(reused) && Date.now() < reapDeadline) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
     finishProcessLifecycle('clean-shutdown', 0);
-    assert.equal(entries(paths.ledger).filter((row) => row.reason === 'prior-process-vanished').length, 1);
+    assert.equal(entries(paths.ledger).filter((row) => row.reason === 'prior-process-vanished').length, 2);
     assert.equal(existsSync(reused), false);
     assert.equal(existsSync(matching), true);
     assert.equal(existsSync(uncertain), true);
     assert.equal(existsSync(malformed), true);
     assert.equal(existsSync(clockAmbiguous), true);
     assert.equal(existsSync(differentKind), true);
+    assert.equal(existsSync(samePidForeign), false);
+    assert.equal(existsSync(childMarker), true);
+    if (currentIdentity.kind === 'start-seconds') assert.equal(existsSync(mixedTransient), true);
   } finally {
+    child?.kill();
+    if (child) await childExit(child);
     rmSync(root, { recursive: true, force: true });
   }
 });
@@ -315,6 +363,27 @@ test('cleanup rejection and timeout are forced cleanup, not clean shutdown', asy
   }
 });
 
+test('uncaughtException synchronously restores terminal modes before cleanup', () => {
+  const source = `
+    import { installProcessSignalCleanup } from './src/runtime/shared/process-shutdown.mjs';
+    const reset = '\\x1b[?1000l\\x1b[?1002l\\x1b[?1006l\\x1b[?1049l';
+    installProcessSignalCleanup({
+      signals: [],
+      exit: false,
+      restoreTerminal: () => process.stdout.write(reset),
+      cleanup: async () => {},
+      log: () => {},
+    });
+    throw new Error('terminal fixture crash');
+  `;
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval', source], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stdout, '\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1049l');
+});
+
 test('Node report is compact, excludes environment, and rotates to one previous report', () => {
   const root = tempRoot();
   try {

package/scripts/provider-admission-scheduler-test.mjs

@@ -340,14 +340,14 @@ test('xAI legacy cache-lane knobs cannot create a secondary queue or timeout', a
     assert.deepEqual((await Promise.all([first, second])).map((item) => item.value), [0, 1]);
 });
 
-test('Anthropic providers retry request-local pre-output 429 responses', async () => {
+test('Anthropic OAuth subscription 429 fails fast while API-key 429 retries request-locally', async () => {
     const oauth = Object.create(AnthropicOAuthProvider.prototype);
     oauth.credentials = { accessToken: 'fixture', expiresAt: Date.now() + 60_000 };
     oauth.config = {};
     oauth.fastModeBetaHeaderLatched = false;
     oauth.ensureAuth = async () => oauth.credentials;
     let oauthAttempts = 0;
-    const oauthResult = await oauth.send([], 'claude-sonnet-4-5', [], {
+    await assert.rejects(oauth.send([], 'claude-sonnet-4-5', [], {
         _doRequestFn: async () => {
             oauthAttempts += 1;
             return {
@@ -364,9 +364,8 @@ test('Anthropic providers retry request-local pre-output 429 responses', async (
         _parseSSEFn: async () => ({
             content: 'oauth-ok', model: 'claude', toolCalls: [], usage: {},
         }),
-    });
-    assert.equal(oauthResult.content, 'oauth-ok');
-    assert.equal(oauthAttempts, 2);
+    }), (error) => error?.status === 429 && error?.retryAfterMs === 0);
+    assert.equal(oauthAttempts, 1);
 
     const direct = Object.create(AnthropicProvider.prototype);
     direct.name = 'anthropic';