@qduc/term2 0.7.2 → 0.8.0

package/dist/providers/fallback-responses-model.test.js

@@ -1,39 +1,54 @@
-import test from 'ava';
-import { FallbackResponsesModel, isNetworkProtocolError } from './fallback-responses-model.js';
-function makeMockModel(options) {
-    return {
+import { it, expect } from 'vitest';
+import { FallbackResponsesModel, isNetworkProtocolError, ChainingTransportDowngradeError, DEFAULT_STREAM_MAX_RETRIES, } from './fallback-responses-model.js';
+function makeMockModel(options, className = 'MockModel') {
+    const model = {
         getResponse: options.getResponse || (async () => ({})),
         getStreamedResponse: options.getStreamedResponse || async function* () { },
+        ...(options.getRetryAdvice ? { getRetryAdvice: options.getRetryAdvice } : {}),
     };
+    Object.defineProperty(model, 'constructor', {
+        value: { name: className },
+        configurable: true,
+    });
+    return model;
 }
-test('isNetworkProtocolError correctly flags network protocol errors', (t) => {
+function createSleepRecorder() {
+    const delays = [];
+    return {
+        delays,
+        sleep: async (delayMs) => {
+            delays.push(delayMs);
+        },
+    };
+}
+it('isNetworkProtocolError correctly flags network protocol errors', () => {
     // System network errors
-    t.true(isNetworkProtocolError({ code: 'ENOTFOUND' }));
-    t.true(isNetworkProtocolError({ code: 'ECONNREFUSED' }));
-    t.true(isNetworkProtocolError({ code: 'ETIMEDOUT' }));
-    t.true(isNetworkProtocolError({ code: 'ECONNRESET' }));
+    expect(isNetworkProtocolError({ code: 'ENOTFOUND' })).toBe(true);
+    expect(isNetworkProtocolError({ code: 'ECONNREFUSED' })).toBe(true);
+    expect(isNetworkProtocolError({ code: 'ETIMEDOUT' })).toBe(true);
+    expect(isNetworkProtocolError({ code: 'ECONNRESET' })).toBe(true);
     // WebSocket message signatures
-    t.true(isNetworkProtocolError(new Error('Responses websocket connection closed before opening.')));
-    t.true(isNetworkProtocolError(new Error('Responses websocket connection closed before a terminal response event.')));
-    t.true(isNetworkProtocolError(new Error('Responses websocket is not open.')));
-    t.true(isNetworkProtocolError(new Error('unexpected server response: 502')));
-    t.true(isNetworkProtocolError(new Error('Responses websocket connection timed out before opening after 15000ms')));
-    t.true(isNetworkProtocolError(new Error('Responses websocket connection timed out')));
-    t.true(isNetworkProtocolError(new Error('WebSocket first frame timeout after 5000ms')));
-    t.true(isNetworkProtocolError({ name: 'InvalidStateError', message: 'Socket is closing' }));
+    expect(isNetworkProtocolError(new Error('Responses websocket connection closed before opening.'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('Responses websocket connection closed before a terminal response event.'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('Responses websocket is not open.'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 502'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('Responses websocket connection timed out before opening after 15000ms'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('Responses websocket connection timed out'))).toBe(true);
+    expect(isNetworkProtocolError(new Error('WebSocket first frame timeout after 5000ms'))).toBe(true);
+    expect(isNetworkProtocolError({ name: 'InvalidStateError', message: 'Socket is closing' })).toBe(true);
     // Exclusions (auth and rate limits)
-    t.false(isNetworkProtocolError(new Error('unexpected server response: 401')));
-    t.false(isNetworkProtocolError(new Error('unexpected server response: 403')));
-    t.false(isNetworkProtocolError(new Error('unexpected server response: 429')));
-    t.false(isNetworkProtocolError(new Error('unexpected server response: 400')));
-    t.false(isNetworkProtocolError(new Error('unexpected server response: 404')));
-    t.true(isNetworkProtocolError(new Error('unexpected server response: 502')));
+    expect(isNetworkProtocolError(new Error('unexpected server response: 401'))).toBe(false);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 403'))).toBe(false);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 429'))).toBe(false);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 400'))).toBe(false);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 404'))).toBe(false);
+    expect(isNetworkProtocolError(new Error('unexpected server response: 502'))).toBe(true);
     // Generic non-network errors
-    t.false(isNetworkProtocolError(new Error('Something else went wrong')));
-    t.false(isNetworkProtocolError({}));
-    t.false(isNetworkProtocolError(null));
+    expect(isNetworkProtocolError(new Error('Something else went wrong'))).toBe(false);
+    expect(isNetworkProtocolError({})).toBe(false);
+    expect(isNetworkProtocolError(null)).toBe(false);
 });
-test('FallbackResponsesModel.getResponse uses WS model by default and falls back on network error', async (t) => {
+it('FallbackResponsesModel.getResponse uses WS model by default and falls back on network error', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeLogged = false;
@@ -51,24 +66,27 @@ test('FallbackResponsesModel.getResponse uses WS model by default and falls back
             return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const sleep = createSleepRecorder();
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state, (err) => {
-        t.is(err, wsError);
+        expect(err).toBe(wsError);
         downgradeLogged = true;
-    });
+    }, undefined, undefined, undefined, { sleep: sleep.sleep, random: () => 0.5 });
     const result = await model.getResponse({});
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.true(downgradeLogged);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(downgradeLogged).toBe(true);
+    expect(result).toBe(expectedResponse);
+    expect(sleep.delays.length, 'should sleep between WS retries').toBe(DEFAULT_STREAM_MAX_RETRIES);
     // Subsequent call should skip WS model and go directly to HTTP model
     const result2 = await model.getResponse({});
-    t.is(wsCalled, 1); // still 1
-    t.is(httpCalled, 2);
-    t.is(result2, expectedResponse);
+    expect(wsCalled).toBe(expectedWsAttempts); // still same count
+    expect(httpCalled).toBe(2);
+    expect(result2).toBe(expectedResponse);
 });
-test('FallbackResponsesModel.getResponse immediately throws non-network errors without falling back', async (t) => {
+it('FallbackResponsesModel.getResponse immediately throws non-network errors without falling back', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const wsError = new Error('unexpected server response: 401');
@@ -86,14 +104,14 @@ test('FallbackResponsesModel.getResponse immediately throws non-network errors w
     });
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state);
-    await t.throwsAsync(async () => {
+    await expect(async () => {
         await model.getResponse({});
-    }, { message: 'unexpected server response: 401' });
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 0);
-    t.false(state.isDowngraded);
+    }).rejects.toThrow('unexpected server response: 401');
+    expect(wsCalled).toBe(1);
+    expect(httpCalled).toBe(0);
+    expect(state.isDowngraded).toBe(false);
 });
-test('FallbackResponsesModel.getResponse falls back to HTTP when WS returns response with undefined output (SDK convertToOutputItem crash)', async (t) => {
+it('FallbackResponsesModel.getResponse falls back to HTTP when WS returns response with undefined output (SDK convertToOutputItem crash)', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeFired = false;
@@ -116,13 +134,14 @@ test('FallbackResponsesModel.getResponse falls back to HTTP when WS returns resp
         downgradeFired = true;
     });
     const result = await model.getResponse({});
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 1);
-    t.is(result, httpResponse);
-    t.true(state.isDowngraded);
-    t.true(downgradeFired);
+    // SDK crash is deterministic — should fall back to HTTP immediately, not retry WS
+    expect(wsCalled).toBe(1);
+    expect(httpCalled).toBe(1);
+    expect(result).toBe(httpResponse);
+    expect(state.isDowngraded).toBe(true);
+    expect(downgradeFired).toBe(true);
 });
-test('FallbackResponsesModel.getStreamedResponse falls back seamlessly if error occurs before any events', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse falls back seamlessly if error occurs before any events', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeLogged = false;
@@ -140,22 +159,24 @@ test('FallbackResponsesModel.getStreamedResponse falls back seamlessly if error
             yield { type: 'output_text_delta', delta: 'Hello' };
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const sleep = createSleepRecorder();
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state, (err) => {
-        t.is(err, wsError);
+        expect(err).toBe(wsError);
         downgradeLogged = true;
-    });
+    }, undefined, undefined, undefined, { sleep: sleep.sleep, random: () => 0.5 });
     const events = [];
     for await (const event of model.getStreamedResponse({})) {
         events.push(event);
     }
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.true(downgradeLogged);
-    t.deepEqual(events, [{ type: 'response_started' }, { type: 'output_text_delta', delta: 'Hello' }]);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(downgradeLogged).toBe(true);
+    expect(events).toEqual([{ type: 'response_started' }, { type: 'output_text_delta', delta: 'Hello' }]);
 });
-test('FallbackResponsesModel.getStreamedResponse propagates error and does not fallback if any output already streamed', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse propagates error and does not fallback if any output already streamed', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeLogged = false;
@@ -175,22 +196,22 @@ test('FallbackResponsesModel.getStreamedResponse propagates error and does not f
     });
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state, (err) => {
-        t.is(err, wsError);
+        expect(err).toBe(wsError);
         downgradeLogged = true;
     });
     const events = [];
-    await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const event of model.getStreamedResponse({})) {
             events.push(event);
         }
-    }, { message: 'socket hang up' });
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 0); // No HTTP fallback!
-    t.true(state.isDowngraded); // Still downgrades for future requests!
-    t.true(downgradeLogged);
-    t.deepEqual(events, [{ type: 'output_text_delta', delta: 'Partial' }]);
+    }).rejects.toThrow('socket hang up');
+    expect(wsCalled).toBe(1);
+    expect(httpCalled).toBe(0); // No HTTP fallback!
+    expect(state.isDowngraded).toBe(false);
+    expect(downgradeLogged).toBe(false);
+    expect(events).toEqual([{ type: 'output_text_delta', delta: 'Partial' }]);
 });
-test('FallbackResponsesModel logs unary WS request start, success, and failure events', async (t) => {
+it('FallbackResponsesModel logs unary WS request start, success, and failure events', async () => {
     const wsModel = makeMockModel({
         getResponse: async () => {
             return {
@@ -199,12 +220,20 @@ test('FallbackResponsesModel logs unary WS request start, success, and failure e
                 providerData: { id: 'resp_ws_123' },
             };
         },
-    });
+    }, 'OpenAIResponsesWSModelWithPromptCacheKey');
+    wsModel._buildResponsesCreateRequest = (_request, _stream) => {
+        return {
+            requestData: { messages: [] },
+            sdkRequestHeaders: {
+                Authorization: 'Bearer ws-token-123',
+                'x-opencode-session': 'session-ws-abc',
+            },
+        };
+    };
     const httpModel = makeMockModel({});
     const state = { isDowngraded: false };
     const logs = [];
     const mockLogging = {
-        getTrafficContext: () => ({ sessionId: 'sess-123', sessionStartedAt: '2026-05-24T12:00:00Z' }),
         getCorrelationId: () => 'corr-123',
         debug: (msg, meta) => {
             logs.push({ level: 'debug', msg, meta });
@@ -213,7 +242,11 @@ test('FallbackResponsesModel logs unary WS request start, success, and failure e
             logs.push({ level: 'error', msg, meta });
         },
     };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, mockLogging, 'openai');
+    const mockSessionContext = {
+        getContext: () => ({ sessionId: 'sess-123', sessionStartedAt: '2026-05-24T12:00:00Z' }),
+        runWithContext: (_context, fn) => fn(),
+    };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, mockLogging, 'openai', mockSessionContext);
     const request = {
         input: 'Hello',
         modelSettings: { providerData: { model: 'gpt-4o' } },
@@ -223,16 +256,22 @@ test('FallbackResponsesModel logs unary WS request start, success, and failure e
         outputType: {},
     };
     await model.getResponse(request);
-    t.is(logs.length, 2);
-    t.is(logs[0].level, 'debug');
-    t.is(logs[0].meta.eventType, 'provider.request.started');
-    t.is(logs[0].meta.provider, 'openai');
-    t.is(logs[0].meta.model, 'gpt-4o');
-    t.is(logs[1].level, 'debug');
-    t.is(logs[1].meta.eventType, 'provider.response.received');
-    t.is(logs[1].meta.text, 'Hello back');
-    t.is(logs[1].meta.payload.transport, 'json');
-    t.is(logs[1].meta.payload.payload.id, 'resp_ws_123');
+    expect(logs.length).toBe(2);
+    expect(logs[0].level).toBe('debug');
+    expect(logs[0].meta.eventType).toBe('provider.request.started');
+    expect(logs[0].meta.provider).toBe('openai');
+    expect(logs[0].meta.model).toBe('gpt-4o');
+    expect(logs[0].meta.modelClass).toBe('OpenAIResponsesWSModelWithPromptCacheKey');
+    expect(logs[0].meta.modelWrapperClass).toBe('FallbackResponsesModel');
+    expect(logs[0].meta.headers).toEqual({
+        authorization: '[REDACTED]',
+        'x-opencode-session': 'session-ws-abc',
+    });
+    expect(logs[1].level).toBe('debug');
+    expect(logs[1].meta.eventType).toBe('provider.response.received');
+    expect(logs[1].meta.text).toBe('Hello back');
+    expect(logs[1].meta.payload.transport).toBe('json');
+    expect(logs[1].meta.payload.payload.id).toBe('resp_ws_123');
     // Test failure logging
     logs.length = 0;
     const failingWsModel = makeMockModel({
@@ -240,15 +279,21 @@ test('FallbackResponsesModel logs unary WS request start, success, and failure e
             throw new Error('websocket connection closed before opening');
         },
     });
-    const modelFail = new FallbackResponsesModel(failingWsModel, httpModel, state, undefined, mockLogging, 'openai');
+    const modelFail = new FallbackResponsesModel(failingWsModel, httpModel, state, undefined, mockLogging, 'openai', undefined, { sleep: async () => { }, random: () => 0.5 });
     await modelFail.getResponse(request);
-    t.is(logs.length, 2); // 1 request start, 1 failure complete (which falls back to HTTP, but httpModel is mock/empty)
-    t.is(logs[0].meta.eventType, 'provider.request.started');
-    t.is(logs[1].level, 'error');
-    t.is(logs[1].meta.eventType, 'provider.response.failed');
-    t.is(logs[1].meta.error, 'websocket connection closed before opening');
+    // 1 request start + DEFAULT_STREAM_MAX_RETRIES + 1 failure logs (one per WS attempt)
+    expect(logs.length).toBe(1 + DEFAULT_STREAM_MAX_RETRIES + 1);
+    expect(logs[0].meta.eventType).toBe('provider.request.started');
+    // Each retry attempt logs a failure
+    for (let i = 1; i <= DEFAULT_STREAM_MAX_RETRIES + 1; i++) {
+        expect(logs[i].level).toBe('error');
+        expect(logs[i].meta.eventType).toBe('provider.response.failed');
+        expect(logs[i].meta.error).toBe('websocket connection closed before opening');
+        expect(logs[i].meta.wsAttempt).toBe(i);
+        expect(logs[i].meta.wsMaxAttempts).toBe(DEFAULT_STREAM_MAX_RETRIES + 1);
+    }
 });
-test('FallbackResponsesModel falls back to HTTP when WebSocket times out', async (t) => {
+it('FallbackResponsesModel falls back to HTTP when WebSocket times out', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const wsError = new Error('WebSocket open timed out after 15000ms');
@@ -265,20 +310,24 @@ test('FallbackResponsesModel falls back to HTTP when WebSocket times out', async
             return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
     const result = await model.getResponse({});
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(result).toBe(expectedResponse);
     // Subsequent calls should skip WS and use HTTP directly
     const result2 = await model.getResponse({});
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 2);
-    t.is(result2, expectedResponse);
+    expect(wsCalled).toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(2);
+    expect(result2).toBe(expectedResponse);
 });
-test('FallbackResponsesModel logs streaming WS request start and response completion events', async (t) => {
+it('FallbackResponsesModel logs streaming WS request start and response completion events', async () => {
     const wsModel = makeMockModel({
         getStreamedResponse: async function* () {
             yield {
@@ -308,18 +357,21 @@ test('FallbackResponsesModel logs streaming WS request start and response comple
                 },
             };
         },
-    });
+    }, 'OpenAIResponsesWSModelWithPromptCacheKey');
     const httpModel = makeMockModel({});
     const state = { isDowngraded: false };
     const logs = [];
     const mockLogging = {
-        getTrafficContext: () => ({ sessionId: 'sess-123', sessionStartedAt: '2026-05-24T12:00:00Z' }),
         getCorrelationId: () => 'corr-123',
         debug: (msg, meta) => {
             logs.push({ level: 'debug', msg, meta });
         },
     };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, mockLogging, 'openai');
+    const mockSessionContext = {
+        getContext: () => ({ sessionId: 'sess-123', sessionStartedAt: '2026-05-24T12:00:00Z' }),
+        runWithContext: (_context, fn) => fn(),
+    };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, mockLogging, 'openai', mockSessionContext);
     const request = {
         input: 'Hello',
         modelSettings: { providerData: { model: 'gpt-4o' } },
@@ -331,14 +383,16 @@ test('FallbackResponsesModel logs streaming WS request start and response comple
     // Consume stream
     for await (const _ of model.getStreamedResponse(request)) {
     }
-    t.is(logs.length, 2);
-    t.is(logs[0].meta.eventType, 'provider.request.started');
-    t.is(logs[1].meta.eventType, 'provider.response.received');
-    t.is(logs[1].meta.text, 'Hello'); // parsed delta content
-    t.is(logs[1].meta.payload.transport, 'sse'); // parsed as text/event-stream sse
-    t.is(logs[1].meta.payload.payload.id, 'resp_ws_stream_123');
+    expect(logs.length).toBe(2);
+    expect(logs[0].meta.eventType).toBe('provider.request.started');
+    expect(logs[0].meta.modelClass).toBe('OpenAIResponsesWSModelWithPromptCacheKey');
+    expect(logs[0].meta.modelWrapperClass).toBe('FallbackResponsesModel');
+    expect(logs[1].meta.eventType).toBe('provider.response.received');
+    expect(logs[1].meta.text).toBe('Hello'); // parsed delta content
+    expect(logs[1].meta.payload.transport).toBe('sse'); // parsed as text/event-stream sse
+    expect(logs[1].meta.payload.payload.id).toBe('resp_ws_stream_123');
 });
-test('FallbackResponsesModel.getResponse retries WS up to 2 times on first-frame timeout then downgrades', async (t) => {
+it('FallbackResponsesModel.getResponse falls back after exhausting WS retries on pre-response failure', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeLogged = false;
@@ -356,18 +410,20 @@ test('FallbackResponsesModel.getResponse retries WS up to 2 times on first-frame
             return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const sleep = createSleepRecorder();
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state, () => {
         downgradeLogged = true;
-    });
+    }, undefined, undefined, undefined, { sleep: sleep.sleep, random: () => 0.5 });
     const result = await model.getResponse({});
-    t.is(wsCalled, 3, 'should attempt WS 3 times (initial + 2 retries)');
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.true(downgradeLogged);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(downgradeLogged).toBe(true);
+    expect(result).toBe(expectedResponse);
 });
-test('FallbackResponsesModel.getResponse succeeds on retry after first-frame timeout without downgrading', async (t) => {
+it('FallbackResponsesModel.getResponse retries first-frame timeout before falling back to HTTP', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const firstFrameError = new Error('WebSocket first frame timeout after 5000ms');
@@ -375,27 +431,28 @@ test('FallbackResponsesModel.getResponse succeeds on retry after first-frame tim
     const wsModel = makeMockModel({
         getResponse: async () => {
             wsCalled++;
-            if (wsCalled < 2) {
-                throw firstFrameError;
-            }
-            return expectedResponse;
+            throw firstFrameError;
         },
     });
     const httpModel = makeMockModel({
         getResponse: async () => {
             httpCalled++;
-            return {};
+            return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
     const result = await model.getResponse({});
-    t.is(wsCalled, 2);
-    t.is(httpCalled, 0);
-    t.false(state.isDowngraded);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should retry WS before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(result).toBe(expectedResponse);
 });
-test('FallbackResponsesModel.getResponse downgrades immediately on non-first-frame network errors', async (t) => {
+it('FallbackResponsesModel.getResponse falls back after exhausting WS retries for pre-response network errors', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const wsError = new Error('WebSocket idle timeout after 300000ms');
@@ -412,15 +469,19 @@ test('FallbackResponsesModel.getResponse downgrades immediately on non-first-fra
             return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
     const result = await model.getResponse({});
-    t.is(wsCalled, 1, 'idle timeout should not trigger first-frame retry path');
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(result).toBe(expectedResponse);
 });
-test('FallbackResponsesModel.getResponse retries abnormal websocket close 1006 before downgrading', async (t) => {
+it('FallbackResponsesModel.getResponse falls back after exhausting WS retries for abnormal websocket close 1006', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const abnormalCloseError = new Error('WebSocket connection closed before response completed (code=1006)');
@@ -428,27 +489,28 @@ test('FallbackResponsesModel.getResponse retries abnormal websocket close 1006 b
     const wsModel = makeMockModel({
         getResponse: async () => {
             wsCalled++;
-            if (wsCalled === 1) {
-                throw abnormalCloseError;
-            }
-            return expectedResponse;
+            throw abnormalCloseError;
         },
     });
     const httpModel = makeMockModel({
         getResponse: async () => {
             httpCalled++;
-            return {};
+            return expectedResponse;
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
     const result = await model.getResponse({});
-    t.is(wsCalled, 2);
-    t.is(httpCalled, 0);
-    t.false(state.isDowngraded);
-    t.is(result, expectedResponse);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(result).toBe(expectedResponse);
 });
-test('FallbackResponsesModel.getStreamedResponse retries WS up to 2 times on first-frame timeout then downgrades', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse falls back after exhausting WS retries on pre-stream failure', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     let downgradeLogged = false;
@@ -465,31 +527,30 @@ test('FallbackResponsesModel.getStreamedResponse retries WS up to 2 times on fir
             yield { type: 'response_started' };
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const sleep = createSleepRecorder();
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state, () => {
         downgradeLogged = true;
-    });
+    }, undefined, undefined, undefined, { sleep: sleep.sleep, random: () => 0.5 });
     const events = [];
     for await (const event of model.getStreamedResponse({})) {
         events.push(event);
     }
-    t.is(wsCalled, 3, 'should attempt WS 3 times (initial + 2 retries)');
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded);
-    t.true(downgradeLogged);
-    t.deepEqual(events, [{ type: 'response_started' }]);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(downgradeLogged).toBe(true);
+    expect(events).toEqual([{ type: 'response_started' }]);
 });
-test('FallbackResponsesModel.getStreamedResponse retries abnormal websocket close 1006 before downgrading', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse falls back after exhausting WS retries for abnormal websocket close 1006', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const abnormalCloseError = new Error('WebSocket connection closed before response completed (code=1006)');
     const wsModel = makeMockModel({
         getStreamedResponse: async function* () {
             wsCalled++;
-            if (wsCalled === 1) {
-                throw abnormalCloseError;
-            }
-            yield { type: 'response_started' };
+            throw abnormalCloseError;
         },
     });
     const httpModel = makeMockModel({
@@ -498,18 +559,22 @@ test('FallbackResponsesModel.getStreamedResponse retries abnormal websocket clos
             yield { type: 'output_text_delta', delta: 'fallback' };
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
     const events = [];
     for await (const event of model.getStreamedResponse({})) {
         events.push(event);
     }
-    t.is(wsCalled, 2);
-    t.is(httpCalled, 0);
-    t.false(state.isDowngraded);
-    t.deepEqual(events, [{ type: 'response_started' }]);
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(events).toEqual([{ type: 'output_text_delta', delta: 'fallback' }]);
 });
-test('FallbackResponsesModel.getStreamedResponse does not retry once events have been yielded', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse does not retry once events have been yielded', async () => {
     let wsCalled = 0;
     const firstFrameError = new Error('WebSocket first frame timeout after 5000ms');
     const wsModel = makeMockModel({
@@ -527,16 +592,16 @@ test('FallbackResponsesModel.getStreamedResponse does not retry once events have
     const state = { isDowngraded: false };
     const model = new FallbackResponsesModel(wsModel, httpModel, state);
     const events = [];
-    await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const event of model.getStreamedResponse({})) {
             events.push(event);
         }
-    }, { message: /first frame timeout/ });
-    t.is(wsCalled, 1, 'should not retry once a frame has been yielded');
-    t.true(state.isDowngraded, 'still flips downgrade flag for future requests');
-    t.deepEqual(events, [{ type: 'output_text_delta', delta: 'partial' }]);
+    }).rejects.toThrow(/first frame timeout/);
+    expect(wsCalled, 'should not retry once a frame has been yielded').toBe(1);
+    expect(state.isDowngraded).toBe(false);
+    expect(events).toEqual([{ type: 'output_text_delta', delta: 'partial' }]);
 });
-test('FallbackResponsesModel.getStreamedResponse does not flip downgrade flag on mid-stream idle timeout', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse does not flip downgrade flag on mid-stream idle timeout', async () => {
     let wsCalled = 0;
     let downgradeLogged = false;
     const idleError = new Error('WebSocket idle timeout after 300000ms');
@@ -557,17 +622,17 @@ test('FallbackResponsesModel.getStreamedResponse does not flip downgrade flag on
         downgradeLogged = true;
     });
     const events = [];
-    await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const event of model.getStreamedResponse({})) {
             events.push(event);
         }
-    }, { message: /idle timeout/ });
-    t.is(wsCalled, 1);
-    t.false(state.isDowngraded, 'one transient mid-stream stall should not flip the session-wide downgrade flag');
-    t.false(downgradeLogged);
-    t.deepEqual(events, [{ type: 'output_text_delta', delta: 'partial' }]);
+    }).rejects.toThrow(/idle timeout/);
+    expect(wsCalled).toBe(1);
+    expect(state.isDowngraded).toBe(false);
+    expect(downgradeLogged).toBe(false);
+    expect(events).toEqual([{ type: 'output_text_delta', delta: 'partial' }]);
 });
-test('FallbackResponsesModel.getStreamedResponse still flips downgrade on pre-stream idle timeout', async (t) => {
+it('FallbackResponsesModel.getStreamedResponse falls back after exhausting WS retries for pre-stream idle timeout', async () => {
     let wsCalled = 0;
     let httpCalled = 0;
     const idleError = new Error('WebSocket idle timeout after 300000ms');
@@ -583,15 +648,298 @@ test('FallbackResponsesModel.getStreamedResponse still flips downgrade on pre-st
             yield { type: 'response_started' };
         },
     });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
     const state = { isDowngraded: false };
-    const model = new FallbackResponsesModel(wsModel, httpModel, state);
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
+    const events = [];
+    for await (const event of model.getStreamedResponse({})) {
+        events.push(event);
+    }
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled).toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(events).toEqual([{ type: 'response_started' }]);
+});
+it('Codex getResponse throws ChainingTransportDowngradeError when WS fails on a chained request after exhausting retries', async () => {
+    let wsCalled = 0;
+    let httpCalled = 0;
+    const wsError = new Error('Responses websocket connection closed before opening.');
+    const wsModel = makeMockModel({
+        getResponse: async () => {
+            wsCalled++;
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getResponse: async () => {
+            httpCalled++;
+            return { usage: {}, output: [] };
+        },
+    });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, 'codex', undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
+    const chainedRequest = {
+        previousResponseId: 'resp_abc',
+        input: 'Hello',
+        modelSettings: { providerData: { model: 'gpt-5.5-codex' } },
+        tools: [],
+        handoffs: [],
+        tracing: false,
+        outputType: {},
+    };
+    let error;
+    try {
+        await model.getResponse(chainedRequest);
+    }
+    catch (e) {
+        error = e;
+    }
+    expect(error instanceof ChainingTransportDowngradeError).toBe(true);
+    expect(error.message).toBe('Codex WS connection failed; cannot chain via HTTP');
+    expect(error.cause).toBe(wsError);
+    expect(wsCalled, 'should exhaust WS retries before throwing chaining error').toBe(expectedWsAttempts);
+    expect(httpCalled, 'HTTP model should not be called when chaining breaks').toBe(0);
+    expect(state.isDowngraded).toBe(true);
+});
+it('Codex getStreamedResponse throws ChainingTransportDowngradeError when WS fails on a chained request after exhausting retries', async () => {
+    let wsCalled = 0;
+    let httpCalled = 0;
+    const wsError = new Error('Responses websocket connection closed before opening.');
+    const wsModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            wsCalled++;
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            httpCalled++;
+        },
+    });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, 'codex', undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
+    const chainedRequest = {
+        previousResponseId: 'resp_stream_abc',
+        input: 'Hello',
+        modelSettings: { providerData: { model: 'gpt-5.5-codex' } },
+        tools: [],
+        handoffs: [],
+        tracing: false,
+        outputType: {},
+    };
+    const events = [];
+    let error;
+    try {
+        for await (const event of model.getStreamedResponse(chainedRequest)) {
+            events.push(event);
+        }
+    }
+    catch (e) {
+        error = e;
+    }
+    expect(error instanceof ChainingTransportDowngradeError).toBe(true);
+    expect(error.message).toBe('Codex WS connection failed; cannot chain via HTTP');
+    expect(error.cause).toBe(wsError);
+    expect(wsCalled, 'should exhaust WS retries before throwing chaining error').toBe(expectedWsAttempts);
+    expect(httpCalled, 'HTTP stream should not be called when chaining breaks').toBe(0);
+    expect(state.isDowngraded).toBe(true);
+    expect(events).toEqual([]);
+});
+it('Codex getStreamedResponse still falls back to HTTP when WS fails on a non-chained request', async () => {
+    let wsCalled = 0;
+    let httpCalled = 0;
+    const wsError = new Error('Responses websocket connection closed before opening.');
+    const wsModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            wsCalled++;
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            httpCalled++;
+            yield { type: 'response_started' };
+        },
+    });
+    const expectedWsAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, 'codex', undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
+    // No previousResponseId = not a chained request
+    const nonChainedRequest = {
+        input: 'Hello',
+        modelSettings: { providerData: { model: 'gpt-5.5-codex' } },
+        tools: [],
+        handoffs: [],
+        tracing: false,
+        outputType: {},
+    };
+    const events = [];
+    for await (const event of model.getStreamedResponse(nonChainedRequest)) {
+        events.push(event);
+    }
+    expect(wsCalled, 'should exhaust WS retries before HTTP fallback').toBe(expectedWsAttempts);
+    expect(httpCalled, 'HTTP fallback should still happen for non-chained request').toBe(1);
+    expect(state.isDowngraded).toBe(true);
+    expect(events).toEqual([{ type: 'response_started' }]);
+});
+it('FallbackResponsesModel fires state.onDowngrade callback when downgrading', async () => {
+    let stateDowngradeFired = false;
+    let constructorDowngradeFired = false;
+    const wsError = new Error('Responses websocket connection closed before opening.');
+    const wsModel = makeMockModel({
+        getResponse: async () => {
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getResponse: async () => ({ usage: {}, output: [] }),
+    });
+    const state = {
+        isDowngraded: false,
+        onDowngrade: () => {
+            stateDowngradeFired = true;
+        },
+    };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, () => {
+        constructorDowngradeFired = true;
+    }, undefined, undefined, undefined, { sleep: async () => { }, random: () => 0.5 });
+    await model.getResponse({});
+    expect(state.isDowngraded).toBe(true);
+    expect(stateDowngradeFired).toBe(true);
+    expect(constructorDowngradeFired).toBe(true);
+});
+it('FallbackResponsesModel.getResponse succeeds on WS retry without falling back to HTTP', async () => {
+    let wsCalled = 0;
+    let httpCalled = 0;
+    const wsError = new Error('WebSocket first frame timeout after 5000ms');
+    const expectedResponse = { usage: {}, output: [] };
+    const wsModel = makeMockModel({
+        getResponse: async () => {
+            wsCalled++;
+            if (wsCalled <= 2) {
+                throw wsError;
+            }
+            return expectedResponse;
+        },
+    });
+    const httpModel = makeMockModel({
+        getResponse: async () => {
+            httpCalled++;
+            return { usage: {}, output: [] };
+        },
+    });
+    const sleep = createSleepRecorder();
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: sleep.sleep,
+        random: () => 0.5,
+    });
+    const result = await model.getResponse({});
+    expect(wsCalled, 'should retry WS and succeed on third attempt').toBe(3);
+    expect(httpCalled, 'should not fall back to HTTP when WS retry succeeds').toBe(0);
+    expect(state.isDowngraded).toBe(false);
+    expect(result).toBe(expectedResponse);
+    expect(sleep.delays.length, 'should sleep between WS retries').toBe(2);
+});
+it('FallbackResponsesModel.getStreamedResponse succeeds on WS retry without falling back to HTTP', async () => {
+    let wsCalled = 0;
+    let httpCalled = 0;
+    const wsError = new Error('WebSocket connection closed before response completed');
+    const wsModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            wsCalled++;
+            if (wsCalled <= 1) {
+                throw wsError;
+            }
+            yield { type: 'response_started' };
+            yield { type: 'output_text_delta', delta: 'retried' };
+        },
+    });
+    const httpModel = makeMockModel({
+        getStreamedResponse: async function* () {
+            httpCalled++;
+            yield { type: 'output_text_delta', delta: 'fallback' };
+        },
+    });
+    const sleep = createSleepRecorder();
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: sleep.sleep,
+        random: () => 0.5,
+    });
     const events = [];
     for await (const event of model.getStreamedResponse({})) {
         events.push(event);
     }
-    t.is(wsCalled, 1);
-    t.is(httpCalled, 1);
-    t.true(state.isDowngraded, 'no events yielded → idle timeout still indicates a broken WS path');
-    t.deepEqual(events, [{ type: 'response_started' }]);
+    expect(wsCalled, 'should retry WS and succeed on second attempt').toBe(2);
+    expect(httpCalled, 'should not fall back to HTTP when WS retry succeeds').toBe(0);
+    expect(state.isDowngraded).toBe(false);
+    expect(events).toEqual([{ type: 'response_started' }, { type: 'output_text_delta', delta: 'retried' }]);
+    expect(sleep.delays.length, 'should sleep between WS retries').toBe(1);
+});
+it('FallbackResponsesModel.getResponse uses exponential backoff between WS retries', async () => {
+    let wsCalled = 0;
+    const wsError = new Error('WebSocket first frame timeout after 5000ms');
+    const wsModel = makeMockModel({
+        getResponse: async () => {
+            wsCalled++;
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getResponse: async () => ({ usage: {}, output: [] }),
+    });
+    const sleep = createSleepRecorder();
+    const state = { isDowngraded: false };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: sleep.sleep,
+        random: () => 0.5,
+    });
+    await model.getResponse({});
+    expect(sleep.delays.length, 'should sleep between each WS retry').toBe(DEFAULT_STREAM_MAX_RETRIES);
+    // With random=0.5 and jitter formula: baseDelay * jitter where jitter = 0.9 + 0.5*0.2 = 1.0
+    // attempt 1: min(500 * 2^0, 30000) * 1.0 = 500ms
+    // attempt 2: min(500 * 2^1, 30000) * 1.0 = 1000ms
+    // attempt 3: min(500 * 2^2, 30000) * 1.0 = 2000ms
+    // etc.
+    expect(sleep.delays[0], 'first retry delay').toBe(500);
+    expect(sleep.delays[1], 'second retry delay').toBe(1000);
+    expect(sleep.delays[2], 'third retry delay').toBe(2000);
+});
+it('FallbackResponsesModel invokes onRetry before each WS retry backoff', async () => {
+    let wsCalled = 0;
+    let retryCount = 0;
+    const wsError = new Error('WebSocket first frame timeout after 5000ms');
+    const wsModel = makeMockModel({
+        getResponse: async () => {
+            wsCalled++;
+            throw wsError;
+        },
+    });
+    const httpModel = makeMockModel({
+        getResponse: async () => ({ usage: {}, output: [] }),
+    });
+    const state = { isDowngraded: false, onRetry: () => retryCount++ };
+    const model = new FallbackResponsesModel(wsModel, httpModel, state, undefined, undefined, undefined, undefined, {
+        sleep: async () => { },
+        random: () => 0.5,
+    });
+    await model.getResponse({});
+    expect(wsCalled).toBe(DEFAULT_STREAM_MAX_RETRIES + 1);
+    expect(retryCount).toBe(DEFAULT_STREAM_MAX_RETRIES);
 });
 //# sourceMappingURL=fallback-responses-model.test.js.map