mixdog 0.9.47 → 0.9.49

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

@@ -5,16 +5,27 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.mjs'
 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'
 
-test('core content aliases summary and derives a bounded element', () => {
+test('memory mutation schema omits category while recall keeps its internal filter', () => {
+  const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory')
+  const recallTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'recall')
+  assert.equal(Object.hasOwn(memoryTool.inputSchema.properties, 'category'), false)
+  assert.doesNotMatch(memoryTool.description, /category/i)
+  assert.equal(Object.hasOwn(recallTool.inputSchema.properties, 'category'), true)
+})
+
+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, category: 'preference' }, {
+  const input = normalizeCoreInput({ content }, {
     requireElement: true,
     requireSummary: true,
-    requireCategory: true,
+    requireCategory: false,
   })
   assert.equal(input.summary, content)
   assert.equal(input.element, content.slice(0, 40))
+  assert.equal(input.category, 'fact')
   assert.deepEqual(input.errors, [])
 })
 
@@ -34,12 +45,11 @@ test('core add reports every invalid field and cwd project hint together', async
       cwd,
       element: 'x'.repeat(41),
       summary: 'y'.repeat(101),
-      category: 'unknown',
     })
     assert.equal(result.isError, true)
     assert.equal(
       result.text,
-      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1); invalid category "unknown". Valid: rule, constraint, decision, fact, goal, preference, task, issue',
+      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1)',
     )
   } finally {
     await rm(cwd, { recursive: true, force: true })
@@ -58,13 +68,11 @@ test('core add rejects blank project_id in the batched error', async () => {
     project_id: ' ',
     element: 'x'.repeat(41),
     summary: 'y'.repeat(101),
-    category: 'unknown',
   })
   assert.equal(result.isError, true)
   assert.match(result.text, /^core add: project_id required —/)
   assert.match(result.text, /element too long \(41\/40 chars, remove 1\)/)
   assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-  assert.match(result.text, /invalid category "unknown"/)
 })
 
 test('core add folds project_id "*" into the batched error', async () => {
@@ -79,12 +87,10 @@ test('core add folds project_id "*" into the batched error', async () => {
     project_id: '*',
     element: 'x'.repeat(41),
     summary: 'y'.repeat(101),
-    category: 'unknown',
   })
   assert.equal(result.isError, true)
   assert.match(result.text, /^core add: project_id "\*" only valid for op="list"; element too long/)
   assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-  assert.match(result.text, /invalid category "unknown"/)
 })
 
 test('core add suppresses malformed cwd project hints', async () => {
@@ -103,7 +109,6 @@ test('core add suppresses malformed cwd project hints', async () => {
       cwd,
       element: 'durable preference',
       summary: 'Callers prefer concise answers.',
-      category: 'preference',
     })
     assert.equal(result.text, 'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool')
   } finally {
@@ -119,7 +124,7 @@ test('core edit by id succeeds without project_id', async () => {
     readMainConfig: () => ({}),
     editCoreImpl: async (dataDir, id, patch) => {
       call = { dataDir, id, patch }
-      return { id: Number(id), element: patch.element, summary: patch.summary, category: patch.category }
+      return { id: Number(id), element: patch.element, summary: patch.summary, category: 'preference' }
     },
   })
   const result = await handleMemoryAction({
@@ -128,10 +133,25 @@ test('core edit by id succeeds without project_id', async () => {
     id: 7,
     element: 'reply style',
     summary: 'Use concise answers.',
-    category: 'preference',
   })
   assert.equal(result.isError, undefined)
-  assert.equal(result.text, 'core edited (id=7): [preference] reply style — Use concise answers.')
+  assert.equal(result.text, 'core edited (id=7): reply style — Use concise answers.')
   assert.equal(call.id, 7)
   assert.equal(call.patch.project_id, undefined)
+  assert.equal(call.patch.category, undefined)
+})
+
+test('category-free core and candidate rows remain selectable in the TUI', () => {
+  const [core] = parseMemoryCoreRows('COMMON:\nid=7 reply style — Use concise answers.')
+  assert.equal(core._id, 7)
+  assert.equal(core._element, 'reply style')
+  assert.equal(core._summary, 'Use concise answers.')
+  assert.equal(Object.hasOwn(core, '_category'), false)
+
+  const [candidate] = parseMemoryCandidateRows(
+    'id=9 project=COMMON score=1.60 coding agent refs — Use C:\\Project\\refs. (durable)',
+  )
+  assert.equal(candidate._id, 9)
+  assert.equal(candidate.label, '#9 coding agent refs')
+  assert.equal(candidate._projectId, null)
 })

package/scripts/native-edit-wire-test.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { once } from 'node:events';
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  closeNativePatchServerForTests,
+  runServerEdit,
+} from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+const binary = process.env.MIXDOG_EDIT_NATIVE_BIN;
+assert.ok(binary, 'MIXDOG_EDIT_NATIVE_BIN must point to the release mixdog-patch binary');
+assert.ok(existsSync(binary), `native EDIT test binary does not exist: ${binary}`);
+
+const responseFields = [
+  'replacements',
+  'readMs',
+  'applyMs',
+  'writeMs',
+  'totalMs',
+  'tier',
+  'contentHash',
+  'roundtripMs',
+];
+
+function digest(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function assertCompleteResponse(response, { replacements, tier, content }) {
+  assert.deepEqual(Object.keys(response), responseFields, 'EDIT response must expose all eight decoded fields');
+  assert.equal(response.replacements, replacements);
+  assert.equal(response.tier, tier);
+  assert.match(response.contentHash, /^[a-f0-9]{64}$/);
+  assert.equal(response.contentHash, digest(content), 'EDIT response hash must describe the resulting bytes');
+  for (const field of ['readMs', 'applyMs', 'writeMs', 'totalMs', 'roundtripMs']) {
+    assert.ok(Number.isFinite(response[field]) && response[field] >= 0, `${field} must be a non-negative number`);
+  }
+}
+
+function edit(fullPath, oldString, newString, options = {}) {
+  return runServerEdit({
+    fullPath,
+    oldBuf: Buffer.from(oldString, 'utf8'),
+    newBuf: Buffer.from(newString, 'utf8'),
+    ...options,
+  });
+}
+
+async function rawEdit(fullPath, oldString, newString, { replaceAll = false, dryRun = false } = {}) {
+  const pathBuf = Buffer.from(fullPath, 'utf8');
+  const oldBuf = Buffer.from(oldString, 'utf8');
+  const newBuf = Buffer.from(newString, 'utf8');
+  const child = spawn(binary, ['--server'], { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on('data', (chunk) => stdout.push(chunk));
+  child.stderr.on('data', (chunk) => stderr.push(chunk));
+  child.stdin.end(Buffer.concat([
+    Buffer.from(`EDIT ${pathBuf.length} ${oldBuf.length} ${newBuf.length} ${replaceAll ? 1 : 0} ${dryRun ? 1 : 0}\n`),
+    pathBuf,
+    oldBuf,
+    newBuf,
+    Buffer.from('QUIT\n'),
+  ]));
+  const [code] = await once(child, 'exit');
+  assert.equal(code, 0, `raw native EDIT server failed: ${Buffer.concat(stderr).toString('utf8')}`);
+  return Buffer.concat(stdout).toString('utf8').trimEnd();
+}
+
+function assertRawResponse(line) {
+  const fields = line.split('\t');
+  assert.equal(fields.length, 8, 'raw EDIT response must contain exactly eight tab-delimited fields');
+  assert.equal(fields[0], 'OK');
+  for (const index of [2, 3, 4, 5]) {
+    assert.notEqual(fields[index], '', `raw EDIT timing field ${index} must be present`);
+    assert.match(fields[index], /^\d+(?:\.\d+)?$/, `raw EDIT timing field ${index} must be numeric`);
+  }
+}
+
+test('native EDIT production wire path preserves matching and response invariants', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-native-edit-wire-'));
+  try {
+    await t.test('rejects ambiguity, then reports the replace-all repeat count and full response', async () => {
+      const path = join(root, 'repeats.txt');
+      writeFileSync(path, 'token token token\n', 'utf8');
+
+      await assert.rejects(
+        edit(path, 'token', 'value'),
+        (error) => {
+          assert.equal(error.message, 'old_string found 3 times');
+          return true;
+        },
+      );
+      assert.equal(readFileSync(path, 'utf8'), 'token token token\n');
+
+      const expected = 'value value value\n';
+      assertRawResponse(await rawEdit(path, 'token', 'value', { replaceAll: true, dryRun: true }));
+      const response = await edit(path, 'token', 'value', { replaceAll: true });
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 3, tier: 'exact', content: expected });
+    });
+
+    await t.test('rejects a 30-line folded match without writing', async () => {
+      const path = join(root, 'folded-30.txt');
+      const source = Array.from({ length: 30 }, (_, i) => `line ${i + 1} “value”`).join('\n');
+      const foldedNeedle = Array.from({ length: 30 }, (_, i) => `line ${i + 1} "value"`).join('\n');
+      writeFileSync(path, source, 'utf8');
+
+      await assert.rejects(
+        edit(path, foldedNeedle, 'unsafe replacement'),
+        /old_string is 30 lines \(>= 30\)\./,
+      );
+      assert.equal(readFileSync(path, 'utf8'), source);
+    });
+
+    await t.test('absorbs the deleted line newline', async () => {
+      const path = join(root, 'delete-crlf.txt');
+      const source = 'keep\r\ndelete me\r\nafter\r\n';
+      const expected = 'keep\r\nafter\r\n';
+      writeFileSync(path, source, 'utf8');
+
+      const response = await edit(path, 'delete me', '');
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 1, tier: 'exact', content: expected });
+    });
+
+    await t.test('preserves CRLF while lowering an LF-authored replacement', async () => {
+      const path = join(root, 'preserve-crlf.txt');
+      const source = 'head\r\nold a\r\nold b\r\ntail\r\n';
+      const expected = 'head\r\nnew a\r\nnew b\r\ntail\r\n';
+      writeFileSync(path, source, 'utf8');
+
+      const response = await edit(path, 'old a\nold b', 'new a\nnew b');
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 1, tier: 'crlf', content: expected });
+    });
+  } finally {
+    await closeNativePatchServerForTests();
+    rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -2,7 +2,8 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
-import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+import { _sendFrame } from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
 
 function close1006() {
     const err = new Error('WebSocket closed abnormally');
@@ -27,28 +28,153 @@ function wsArgs(overrides = {}) {
     };
 }
 
+test('acquire timeout reconnects successfully with progress, not a terminal WS error', async () => {
+    const oldWrite = process.stderr.write;
+    const oldQuiet = process.env.MIXDOG_QUIET_PROVIDER_LOG;
+    let stderr = '';
+    let attempts = 0;
+    const stages = [];
+    try {
+        delete process.env.MIXDOG_QUIET_PROVIDER_LOG;
+        process.stderr.write = (chunk) => {
+            stderr += String(chunk);
+            return true;
+        };
+        const result = await sendViaWebSocket(wsArgs({
+            onStageChange: (stage, detail) => stages.push({ stage, detail }),
+            _acquireWithRetryFn: (opts) => _acquireWithRetry({
+                ...opts,
+                maxAttempts: 2,
+                _sleepFn: async () => {},
+                _acquire: async () => {
+                    attempts += 1;
+                    if (attempts === 1) {
+                        throw Object.assign(new Error('OpenAI OAuth WS acquire timed out before open'), {
+                            code: 'EWSACQUIRETIMEOUT',
+                        });
+                    }
+                    return { entry: entry(), reused: false };
+                },
+            }),
+            _streamFn: async () => ({
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: {},
+                closeSocket: true,
+            }),
+        }));
+        assert.equal(result.content, 'recovered');
+        assert.equal(attempts, 2);
+        assert.deepEqual(
+            stages.filter(({ stage }) => stage === 'reconnecting'),
+            [{ stage: 'reconnecting', detail: {
+                attempt: 1,
+                max: 1,
+                classifier: 'acquire_timeout',
+                message: 'Reconnecting... 1/1',
+            } }],
+        );
+        assert.doesNotMatch(stderr, /Reconnecting/);
+        assert.doesNotMatch(stderr, /acquire timed out|handshake failed|terminal/i);
+    } finally {
+        process.stderr.write = oldWrite;
+        if (oldQuiet == null) delete process.env.MIXDOG_QUIET_PROVIDER_LOG;
+        else process.env.MIXDOG_QUIET_PROVIDER_LOG = oldQuiet;
+    }
+});
+
+for (const failure of ['callback error', 'callback timeout']) {
+    test(`send ${failure} drops the socket and retries on a fresh one`, async () => {
+        const acquires = [];
+        const sockets = [];
+        let acquireIndex = 0;
+        const result = await sendViaWebSocket(wsArgs({
+            _acquireWithRetryFn: async (opts) => {
+                acquires.push(opts.forceFresh);
+                const isFirst = acquireIndex++ === 0;
+                const socket = {
+                    readyState: 1,
+                    terminated: false,
+                    send(_payload, callback) {
+                        if (!isFirst) queueMicrotask(() => callback());
+                        else if (failure === 'callback error') {
+                            queueMicrotask(() => callback(new Error('write failed')));
+                        }
+                    },
+                    terminate() {
+                        this.terminated = true;
+                        this.readyState = 3;
+                    },
+                    close() {
+                        this.readyState = 3;
+                    },
+                };
+                sockets.push(socket);
+                return { entry: { socket }, reused: false };
+            },
+            _sendFrameFn: (wsEntry, frame, span) => _sendFrame(wsEntry, frame, span, 10),
+            _streamFn: async () => ({
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: {},
+                closeSocket: true,
+            }),
+        }));
+
+        assert.equal(result.content, 'recovered');
+        assert.deepEqual(acquires, [false, true]);
+        assert.equal(sockets[0].terminated, true);
+        assert.notEqual(sockets[1], sockets[0]);
+    });
+}
+
 test('pre-response 1006 opens a fresh WS and replays the same request', async () => {
     const acquires = [];
     const frames = [];
+    const stages = [];
+    let stderr = '';
+    const oldWrite = process.stderr.write;
     let streams = 0;
-    const result = await sendViaWebSocket(wsArgs({
-        _acquireWithRetryFn: async (opts) => {
-            acquires.push(opts.forceFresh);
-            return { entry: entry(), reused: false };
-        },
-        _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
-        _streamFn: async () => {
-            streams += 1;
-            if (streams === 1) throw close1006();
-            return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
-        },
-    }));
+    let result;
+    try {
+        process.stderr.write = (chunk) => {
+            stderr += String(chunk);
+            return true;
+        };
+        result = await sendViaWebSocket(wsArgs({
+            onStageChange: (stage, detail) => stages.push({ stage, detail }),
+            _acquireWithRetryFn: async (opts) => {
+                acquires.push(opts.forceFresh);
+                return { entry: entry(), reused: false };
+            },
+            _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
+            _streamFn: async () => {
+                streams += 1;
+                if (streams === 1) throw close1006();
+                return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
+            },
+        }));
+    } finally {
+        process.stderr.write = oldWrite;
+    }
 
     assert.equal(result.content, 'recovered');
     assert.deepEqual(acquires, [false, true], 'retry must acquire a fresh socket');
     assert.equal(frames.length, 2);
     assert.deepEqual(frames[1].input, frames[0].input, 'retry must replay the same input');
     assert.equal(result.__midstreamRetries, 1);
+    assert.deepEqual(
+        stages.filter(({ stage }) => stage === 'reconnecting'),
+        [{ stage: 'reconnecting', detail: {
+            attempt: 1,
+            max: 4,
+            classifier: 'ws_1006',
+            message: 'Reconnecting... 1/4',
+        } }],
+    );
+    assert.doesNotMatch(stderr, /mid-stream recovered|Reconnecting/);
 });
 
 test('successful iteration emits one compact send-spans row', async () => {
@@ -97,7 +223,7 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
         provider.ensureAuth = async () => ({ access_token: 'test-token' });
         let streamAttempts = 0;
         let httpCalls = 0;
-        const result = await provider.send([], 'gpt-5.5', [], {
+        const sendOpts = {
             sessionId: 'openai-oauth-ws-1006-fallback-test',
             _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1006-fallback-test' },
             _sendViaWebSocketFn: (args) => sendViaWebSocket({
@@ -114,11 +240,14 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
                 httpCalls += 1;
                 return { content: 'http-recovered', toolCalls: [], usage: {} };
             },
-        });
+        };
+        const result = await provider.send([], 'gpt-5.5', [], sendOpts);
+        const stickyResult = await provider.send([], 'gpt-5.5', [], sendOpts);
 
         assert.equal(streamAttempts, 5, 'all bounded ws_1006 attempts must run before fallback');
-        assert.equal(httpCalls, 1);
+        assert.equal(httpCalls, 2);
         assert.equal(result.content, 'http-recovered');
+        assert.equal(stickyResult.content, 'http-recovered');
     } finally {
         for (const [name, value] of Object.entries(savedEnv)) {
             if (value == null) delete process.env[name];
@@ -127,6 +256,155 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
     }
 });
 
+test('sticky HTTP fallback is isolated by session and expired entries are cleaned', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_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_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        const wsCalls = [];
+        const httpCalls = [];
+        let sessionAFailed = false;
+        const sendFor = (sessionId) => provider.send([], 'gpt-5.5', [], {
+            sessionId,
+            _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: sessionId },
+            _sendViaWebSocketFn: async () => {
+                wsCalls.push(sessionId);
+                if (sessionId === 'sticky-session-a' && !sessionAFailed) {
+                    sessionAFailed = true;
+                    throw Object.assign(new Error('ws retries exhausted'), {
+                        code: 'ECONNRESET',
+                        retryClassifier: 'reset',
+                        wsRetriesExhausted: true,
+                    });
+                }
+                return { content: `ws-${sessionId}`, toolCalls: [], usage: {} };
+            },
+            _sendViaHttpSseFn: async () => {
+                httpCalls.push(sessionId);
+                return { content: `http-${sessionId}`, toolCalls: [], usage: {} };
+            },
+        });
+
+        assert.equal((await sendFor('sticky-session-a')).content, 'http-sticky-session-a');
+        assert.equal((await sendFor('sticky-session-b')).content, 'ws-sticky-session-b');
+        assert.equal((await sendFor('sticky-session-a')).content, 'http-sticky-session-a');
+        assert.deepEqual(wsCalls, ['sticky-session-a', 'sticky-session-b']);
+        assert.deepEqual(httpCalls, ['sticky-session-a', 'sticky-session-a']);
+
+        provider._httpFallbackUntilByPoolKey.set('sticky-session-a', Date.now() - 1);
+        assert.equal((await sendFor('sticky-session-a')).content, 'ws-sticky-session-a');
+        assert.equal(provider._httpFallbackUntilByPoolKey.has('sticky-session-a'), false);
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('close 1000 after tool dispatch refuses WS replay and HTTP fallback', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_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_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let acquires = 0;
+        let httpCalls = 0;
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: 'openai-oauth-ws-1000-tool-test',
+                _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1000-tool-test' },
+                _sendViaWebSocketFn: (args) => sendViaWebSocket({
+                    ...args,
+                    _acquireWithRetryFn: async () => {
+                        acquires += 1;
+                        return { entry: entry(), reused: false };
+                    },
+                    _sendFrameFn: async () => {},
+                    _streamFn: async ({ state }) => {
+                        state.sawResponseCreated = true;
+                        state.emittedToolCall = true;
+                        throw Object.assign(new Error('WebSocket closed normally before completion'), {
+                            wsCloseCode: 1000,
+                        });
+                    },
+                }),
+                _sendViaHttpSseFn: async () => {
+                    httpCalls += 1;
+                    return { content: 'unsafe fallback', toolCalls: [], usage: {} };
+                },
+            }),
+            (err) => err.wsCloseCode === 1000
+                && err.emittedToolCall === true
+                && err.unsafeToRetry === true,
+        );
+        assert.equal(acquires, 1);
+        assert.equal(httpCalls, 0);
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('post-tool unknown-model errors never refresh or recursively replay', async () => {
+    for (const shape of [
+        { httpStatus: 404, message: 'not found' },
+        { message: 'model_not_found: unavailable model' },
+    ]) {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let wsCalls = 0;
+        let refreshCalls = 0;
+        provider._refreshModelCache = async () => {
+            refreshCalls += 1;
+            return [];
+        };
+        const unsafe = Object.assign(new Error(shape.message), shape, {
+            emittedToolCall: true,
+            unsafeToRetry: true,
+        });
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: `post-tool-model-${shape.httpStatus || 'message'}`,
+                _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                _sendViaWebSocketFn: async () => {
+                    wsCalls += 1;
+                    throw unsafe;
+                },
+                _sendViaHttpSseFn: async () => {
+                    throw new Error('unsafe HTTP fallback');
+                },
+            }),
+            (err) => err === unsafe,
+        );
+        assert.equal(wsCalls, 1);
+        assert.equal(refreshCalls, 0);
+    }
+});
+
 test('post-emission 1006 refuses replay after text or tool output', async () => {
     for (const emitted of ['emittedText', 'emittedToolCall']) {
         let acquires = 0;