mixdog 0.9.50 → 0.9.52

package/scripts/provider-toolcall-test.mjs

@@ -10,6 +10,9 @@
 // documented inline per provider block below.
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { parse } from 'acorn';
+import { analyze } from 'eslint-scope';
 
 import {
     OpenAICompatProvider,
@@ -37,6 +40,7 @@ import {
 import {
     _cacheObservationForTest,
     _cacheContinuityResetReasonForTest,
+    sendViaWebSocket,
 } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
     _withCodexWsClientMetadata,
@@ -69,9 +73,198 @@ import { PATCH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/patch-t
 import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
 import { buildRequestBody as buildOpenAIOAuthRequestBody } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _convertMessagesToResponsesInputForTest } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
+import { OpenAIDirectProvider } from '../src/runtime/agent/orchestrator/providers/openai-ws.mjs';
 
 // --- Helpers ---------------------------------------------------------------
 
+test('OpenAI API-key request keeps public defaults without network under every transport mode', async (t) => {
+    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    t.after(() => {
+        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
+    });
+    const provider = new OpenAIDirectProvider({ apiKey: 'fixture-openai-key' });
+    for (const mode of ['auto', 'ws-full', 'ws-delta', 'http-sse']) {
+        process.env.MIXDOG_OAI_TRANSPORT = mode;
+        const calls = [];
+        let captured = null;
+        const result = await provider.send(
+            [{ role: 'user', content: 'fixture' }],
+            'gpt-5.4',
+            [],
+            {
+                sessionId: `direct-request-defaults-${mode}`,
+                _fetchFn: async () => { throw new Error('global fetch seam must not run'); },
+                _sendViaWebSocketFn: async (request) => {
+                    calls.push('ws');
+                    captured = request;
+                    return { content: 'ws-ok', toolCalls: [] };
+                },
+                _sendViaHttpSseFn: async (request) => {
+                    calls.push('http');
+                    captured = request;
+                    return { content: 'http-ok', toolCalls: [] };
+                },
+            },
+        );
+        assert.deepEqual(calls, mode === 'http-sse' ? ['http'] : ['ws'], mode);
+        assert.equal(result.content, mode === 'http-sse' ? 'http-ok' : 'ws-ok');
+        assert.equal(captured.auth.type, 'openai-direct');
+        assert.equal(captured.auth.apiKey, 'fixture-openai-key');
+        if (mode !== 'http-sse') assert.equal(captured.traceProvider, 'openai-direct');
+        assert.equal(captured.body.store, true);
+        assert.equal(captured.body.prompt_cache_retention, '24h');
+        assert.equal(captured.body.stream, true);
+    }
+});
+
+function directHandshakeError(status) {
+    return Object.assign(new Error(`handshake ${status}`), { httpStatus: status });
+}
+
+function directWsEntry() {
+    return { socket: { close() {} }, ephemeral: true };
+}
+
+test('OpenAI API-key unsupported handshake 403/404/429 falls back once without nested WS retries', async (t) => {
+    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    process.env.MIXDOG_OAI_TRANSPORT = 'auto';
+    t.after(() => {
+        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
+    });
+    for (const status of [403, 404, 429]) {
+        const provider = new OpenAIDirectProvider({ apiKey: 'fixture-openai-key' });
+        let acquires = 0;
+        let httpCalls = 0;
+        const result = await provider.send([], 'gpt-5.4', [], {
+            _fetchFn: async () => { throw new Error('global fetch seam must not run'); },
+            _webSocketTestSeams: {
+                // Neither null nor an inverted caller policy may override the
+                // direct provider's mandatory handshake policy.
+                handshakeErrorPolicy: status === 403
+                    ? null
+                    : () => ({ retry: true, httpFallback: false }),
+                _acquireWithRetryFn: async () => {
+                    acquires += 1;
+                    throw directHandshakeError(status);
+                },
+                _sleepFn: async () => {},
+                _sendSpanTraceFn: () => {},
+                _agentTraceFn: () => {},
+            },
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                return { content: `http-${status}`, toolCalls: [] };
+            },
+        });
+        assert.equal(result.content, `http-${status}`);
+        assert.equal(acquires, 1, `handshake ${status} must not retry WS`);
+        assert.equal(httpCalls, 1, `handshake ${status} gets one HTTP fallback`);
+    }
+});
+
+test('OpenAI API-key every application 4xx and exposed output never replay or fall back', async (t) => {
+    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    process.env.MIXDOG_OAI_TRANSPORT = 'auto';
+    t.after(() => {
+        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
+    });
+    const cases = [
+        ...[400, 401, 402, 403, 404, 409, 418, 422, 429, 451, 499]
+            .map((status) => ({ status, exposed: null })),
+        { status: 500, exposed: 'text' },
+        { status: 500, exposed: 'tool' },
+    ];
+    for (const { status, exposed } of cases) {
+        const provider = new OpenAIDirectProvider({ apiKey: 'fixture-openai-key' });
+        let acquires = 0;
+        let streams = 0;
+        let httpCalls = 0;
+        let reloads = 0;
+        let visibleTextDeltas = 0;
+        let dispatchedToolCalls = 0;
+        provider.reloadApiKey = () => {
+            reloads += 1;
+            return 'replacement-key';
+        };
+        await assert.rejects(provider.send([], 'gpt-5.4', [], {
+            onTextDelta: () => { visibleTextDeltas += 1; },
+            onToolCall: () => { dispatchedToolCalls += 1; },
+            _fetchFn: async () => { throw new Error('global fetch seam must not run'); },
+            _webSocketTestSeams: {
+                _acquireWithRetryFn: async () => {
+                    acquires += 1;
+                    return { entry: directWsEntry(), reused: false };
+                },
+                _sendFrameFn: async () => {},
+                _streamFn: async ({ state, onTextDelta, onToolCall }) => {
+                    streams += 1;
+                    if (exposed === 'text') {
+                        onTextDelta?.('visible-once');
+                        state.emittedText = true;
+                    }
+                    if (exposed === 'tool') {
+                        onToolCall?.({ id: 'tool-once', name: 'read', arguments: {} });
+                        state.emittedToolCall = true;
+                    }
+                    throw Object.assign(new Error(`application ${status} ${exposed || ''}`), { httpStatus: status });
+                },
+                _sleepFn: async () => {},
+                _sendSpanTraceFn: () => {},
+                _agentTraceFn: () => {},
+            },
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                throw new Error('application/visible output must not reach HTTP');
+            },
+        }), new RegExp(`application ${status}`));
+        assert.equal(acquires, 1);
+        assert.equal(streams, 1);
+        assert.equal(httpCalls, 0);
+        assert.equal(reloads, 0);
+        assert.equal(visibleTextDeltas, exposed === 'text' ? 1 : 0);
+        assert.equal(dispatchedToolCalls, exposed === 'tool' ? 1 : 0);
+    }
+});
+
+test('Anthropic API-key gates deferred beta to requests that carry deferred tools', async () => {
+    const provider = Object.create((await import('../src/runtime/agent/orchestrator/providers/anthropic.mjs')).AnthropicProvider.prototype);
+    provider.name = 'anthropic';
+    provider.config = {};
+    provider.fastModeBetaHeaderLatched = false;
+    const calls = [];
+    provider.client = { messages: { create(params, options) {
+        calls.push({ params, options });
+        return { asResponse: async () => ({
+            ...anthropicSseResponse([
+                { type: 'message_start', message: { model: params.model, usage: { input_tokens: 1 } } },
+                { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
+                { type: 'message_stop' },
+            ]),
+            ok: true,
+            status: 200,
+            headers: new Map(),
+        }) };
+    } } };
+
+    await provider._doSend([{ role: 'user', content: 'plain' }], 'claude-sonnet-4-6', [], {});
+    assert.doesNotMatch(calls[0].options.headers['anthropic-beta'], /advanced-tool-use/);
+
+    const active = [{ name: 'load_tool', description: 'load', inputSchema: { type: 'object', properties: {} } }];
+    const deferred = { name: 'mcp__demo__ping', description: 'ping', inputSchema: { type: 'object', properties: {} } };
+    await provider._doSend([{ role: 'user', content: 'load' }], 'claude-sonnet-4-6', active, {
+        session: {
+            deferredNativeTools: true,
+            deferredDiscoveredTools: [deferred.name],
+            deferredToolCatalog: [...active, deferred],
+        },
+    });
+    assert.match(calls[1].options.headers['anthropic-beta'], /advanced-tool-use/);
+    assert.equal(calls[1].params.tools.find((tool) => tool.name === deferred.name)?.defer_loading, true);
+});
+
 test('native deferred history normalizes per provider without leaking OpenAI variants to xAI', () => {
     const nativePayload = {
         provider: 'openai-oauth',
@@ -1045,6 +1238,43 @@ test('anthropic API-key and OAuth lower plain signed thinkingBlocks before text
     }
 });
 
+test('anthropic API-key and OAuth lower interrupted tool results with is_error', () => {
+    const history = [
+        { role: 'user', content: 'run a tool' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'toolu_interrupted_1', name: 'read', arguments: { path: 'x' } }],
+        },
+        {
+            role: 'tool',
+            content: 'Interrupted by user',
+            toolCallId: 'toolu_interrupted_1',
+            toolKind: 'error',
+        },
+        { role: 'user', content: '[Request interrupted by user]' },
+    ];
+    const apiKeyMessages = _toAnthropicMessagesForTest(history);
+    const oauthMessages = _buildRequestBodyForCacheSmoke(
+        history,
+        'claude-sonnet-4-6',
+        [],
+        {},
+    ).messages;
+
+    for (const lowered of [apiKeyMessages, oauthMessages]) {
+        const toolResult = lowered
+            .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+            .find((block) => (
+                block?.type === 'tool_result'
+                && block.tool_use_id === 'toolu_interrupted_1'
+            ));
+        assert.ok(toolResult);
+        assert.equal(toolResult.is_error, true);
+        assert.equal(JSON.stringify(lowered).includes('[Request interrupted by user]'), true);
+    }
+});
+
 test('anthropic effort: legacy claude-3-7-sonnet gets NO adaptive thinking / effort beta', () => {
     const model = 'claude-3-7-sonnet-20250219';
     assert.equal(modelSupportsEffort(model), false);
@@ -1786,13 +2016,23 @@ test('openai oauth ws delta: ws-delta mode uses previous_response_id without tur
             entry: {
                 ...entry,
                 lastRequestInput: [body.input[0]],
-                lastResponseItems: [{ type: 'function_call', call_id: 'call_1', name: 'tool', arguments: '{}' }],
+                lastResponseItems: [{
+                    type: 'function_call',
+                    call_id: 'call_1',
+                    name: 'tool',
+                    arguments: '{"api_key":"provider-function-secret","nested":{"z":2,"a":1}}',
+                }],
             },
             body: {
                 ...body,
                 input: [
                     body.input[0],
-                    { type: 'function_call', call_id: 'call_other', name: 'tool', arguments: '{}' },
+                    {
+                        type: 'function_call',
+                        call_id: 'call_other',
+                        name: 'tool',
+                        arguments: '{"nested":{"a":1,"z":2},"api_key":"replayed-function-secret"}',
+                    },
                     body.input[1],
                 ],
             },
@@ -1800,6 +2040,193 @@ test('openai oauth ws delta: ws-delta mode uses previous_response_id without tur
         assert.equal(responseMismatch.mode, 'full');
         assert.equal(responseMismatch.reason, 'response_output_mismatch:function_call');
         assert.equal(responseMismatch.frame.previous_response_id, undefined);
+        const mismatch = responseMismatch.responseOutputMismatch;
+        assert.deepEqual({
+            expectedType: mismatch.response_output_mismatch_expected_type,
+            actualType: mismatch.response_output_mismatch_actual_type,
+            expectedCount: mismatch.response_output_mismatch_expected_response_item_count,
+            actualCount: mismatch.response_output_mismatch_actual_replayed_input_item_count,
+        }, {
+            expectedType: 'function_call',
+            actualType: 'function_call',
+            expectedCount: 1,
+            actualCount: 2,
+        });
+        assert.match(mismatch.response_output_mismatch_expected_hash, /^[a-f0-9]{64}$/);
+        assert.match(mismatch.response_output_mismatch_actual_hash, /^[a-f0-9]{64}$/);
+        const traceSafe = JSON.stringify(mismatch);
+        assert.equal(traceSafe.includes('call_other'), false);
+        assert.equal(traceSafe.includes('provider-function-secret'), false);
+        assert.equal(traceSafe.includes('replayed-function-secret'), false);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: message mismatch diagnostics hash normalized content without tracing it', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const expected = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'provider secret' }] };
+        const actual = { type: 'message', role: 'assistant', content: [{ type: 'input_text', text: 'replayed secret' }] };
+        const delta = _computeDelta({
+            entry: {
+                lastRequestSansInput: '{"model":"gpt-5.5"}',
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            },
+            body: { model: 'gpt-5.5', input: [prior, actual] },
+        });
+        const mismatch = delta.responseOutputMismatch;
+        assert.equal(delta.reason, 'response_output_mismatch:message');
+        assert.equal(mismatch.response_output_mismatch_expected_type, 'message');
+        assert.equal(mismatch.response_output_mismatch_actual_type, 'message');
+        assert.notEqual(mismatch.response_output_mismatch_expected_hash, mismatch.response_output_mismatch_actual_hash);
+        const traceSafe = JSON.stringify(mismatch);
+        assert.equal(traceSafe.includes('provider secret'), false);
+        assert.equal(traceSafe.includes('replayed secret'), false);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: diagnostic hashes normalize equivalent message and function-call forms', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const mismatch = (expected, actual) => _computeDelta({
+            entry: {
+                lastRequestSansInput: '{"model":"gpt-5.5"}',
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            },
+            body: { model: 'gpt-5.5', input: [prior, actual] },
+        }).responseOutputMismatch;
+        const message = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'same sensitive message' }] };
+        const messageExpected = mismatch(message, {
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'different message' }],
+        });
+        const messageActual = mismatch({
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'different message' }],
+        }, {
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'input_text', text: 'same sensitive message' }],
+        });
+        assert.equal(
+            messageExpected.response_output_mismatch_expected_hash,
+            messageActual.response_output_mismatch_actual_hash,
+        );
+
+        const functionExpected = (argumentsValue) => mismatch({
+            type: 'function_call',
+            call_id: 'call_same',
+            name: 'tool',
+            arguments: argumentsValue,
+        }, {
+            type: 'function_call',
+            call_id: 'call_different',
+            name: 'tool',
+            arguments: '{"ignored":"replayed-function-secret"}',
+        });
+        assert.equal(
+            functionExpected('{"api_key":"function-secret","nested":{"z":2,"a":1}}').response_output_mismatch_expected_hash,
+            functionExpected('{"nested":{"a":1,"z":2},"api_key":"function-secret"}').response_output_mismatch_expected_hash,
+        );
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: mismatch diagnostics reach transport and cache_break without sensitive values', async () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const rows = [];
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const cases = [{
+            expected: {
+                type: 'function_call',
+                call_id: 'call_expected',
+                name: 'tool',
+                arguments: '{"api_key":"provider-function-secret","nested":{"z":2,"a":1}}',
+            },
+            actual: {
+                type: 'function_call',
+                call_id: 'call_actual',
+                name: 'tool',
+                arguments: '{"nested":{"a":1,"z":2},"api_key":"replayed-function-secret"}',
+            },
+        }, {
+            expected: {
+                type: 'custom_tool_call',
+                call_id: 'custom_expected',
+                name: 'apply_patch',
+                input: 'provider-custom-input-secret',
+            },
+            actual: {
+                type: 'custom_tool_call',
+                call_id: 'custom_actual',
+                name: 'apply_patch',
+                input: 'replayed-custom-input-secret',
+            },
+        }];
+        for (const { expected, actual } of cases) {
+            const body = { model: 'gpt-5.5', input: [prior, actual] };
+            const entry = {
+                socket: { close() {} },
+                lastRequestSansInput: _stableStringify(_sansInput(body)),
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            };
+            const expectedDiagnostics = _computeDelta({ entry, body }).responseOutputMismatch;
+            await sendViaWebSocket({
+                auth: { type: 'xai', access_token: 'test-token' },
+                body,
+                poolKey: `mismatch-trace-${expected.type}`,
+                cacheKey: 'mismatch-trace-test',
+                iteration: 1,
+                useModel: 'gpt-5.5',
+                traceProvider: 'xai',
+                _acquireWithRetryFn: async () => ({ entry, reused: false }),
+                _sendFrameFn: async () => {},
+                _streamFn: async () => ({
+                    content: 'ok',
+                    model: 'gpt-5.5',
+                    toolCalls: [],
+                    usage: {},
+                    responseId: 'resp_next',
+                    responseItems: [],
+                    closeSocket: true,
+                }),
+                _agentTraceFn: (row) => rows.push(row),
+            });
+            const emitted = rows.filter((row) => row.payload?.response_output_mismatch_expected_type === expected.type);
+            assert.deepEqual(emitted.map((row) => row.kind).sort(), ['cache_break', 'transport']);
+            for (const row of emitted) assert.deepEqual(
+                Object.fromEntries(Object.keys(expectedDiagnostics).map((key) => [key, row.payload[key]])),
+                expectedDiagnostics,
+            );
+        }
+        const traceText = JSON.stringify(rows);
+        for (const secret of [
+            'provider-function-secret',
+            'replayed-function-secret',
+            'provider-custom-input-secret',
+            'replayed-custom-input-secret',
+        ]) assert.equal(traceText.includes(secret), false);
     } finally {
         if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
         else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
@@ -2165,13 +2592,100 @@ test('responses transport policy: xai ws-full → WS, http-sse → HTTP', () =>
     assert.equal(http.allowHttpFallback, false);
 });
 
-test('openai-compat/xai: provider-local HTTP pin beats global OAI ws-delta', async () => {
+test('openai-compat/xai: HTTP pin uses only the injected preconnect seam', async () => {
     const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    const prevFetch = globalThis.fetch;
+    let outboundFetchAttempts = 0;
+    let injectedPreconnectCalls = 0;
     try {
         process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        globalThis.fetch = async () => {
+            outboundFetchAttempts += 1;
+            throw new Error('provider transport test attempted outbound fetch');
+        };
+
+        // Resolve the actual imported binding and inspect _doSend before
+        // invoking any outbound-capable provider path. AST traversal naturally
+        // excludes comments/strings and catches direct, aliased, parenthesized,
+        // optional, or assigned references.
+        const compatSource = readFileSync(
+            new URL('../src/runtime/agent/orchestrator/providers/openai-compat.mjs', import.meta.url),
+            'utf8',
+        );
+        const compatAst = parse(compatSource, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            locations: true,
+            ranges: true,
+        });
+        const preconnectImport = compatAst.body
+            .filter(node => node.type === 'ImportDeclaration')
+            .flatMap(node => node.specifiers)
+            .find(specifier =>
+                specifier.type === 'ImportSpecifier'
+                && specifier.imported.name === 'preconnect',
+            );
+        assert.ok(preconnectImport, 'shared preconnect import binding must be resolvable');
+        const scopeManager = analyze(compatAst, { ecmaVersion: 2022, sourceType: 'module' });
+        const moduleScope = scopeManager.scopes.find(scope => scope.type === 'module');
+        const preconnectBinding = moduleScope?.set.get(preconnectImport.local.name);
+        assert.ok(preconnectBinding, 'shared preconnect source binding must be resolvable');
+
+        const providerClass = compatAst.body
+            .map(node => node.type === 'ExportNamedDeclaration' ? node.declaration : node)
+            .find(node =>
+                node?.type === 'ClassDeclaration'
+                && node.id?.name === 'OpenAICompatProvider',
+            );
+        assert.ok(providerClass, 'OpenAICompatProvider class must be resolvable');
+        const doSendMethod = providerClass.body.body.find(node =>
+            node.type === 'MethodDefinition'
+            && node.key?.type === 'Identifier'
+            && node.key.name === '_doSend',
+        );
+        assert.ok(doSendMethod, 'OpenAICompatProvider._doSend must be resolvable');
+
+        let callsInjectedInstanceMember = false;
+        const visit = node => {
+            if (!node || typeof node !== 'object') return;
+            if (
+                node.type === 'CallExpression'
+                && node.callee?.type === 'MemberExpression'
+                && node.callee.object?.type === 'ThisExpression'
+                && node.callee.computed === false
+                && node.callee.property?.name === '_preconnectFn'
+            ) {
+                callsInjectedInstanceMember = true;
+            }
+            for (const [key, value] of Object.entries(node)) {
+                if (key === 'start' || key === 'end') continue;
+                if (Array.isArray(value)) value.forEach(visit);
+                else if (value && typeof value === 'object') visit(value);
+            }
+        };
+        visit(doSendMethod.value.body);
+        const importedBindingReferences = preconnectBinding.references.filter(reference =>
+            reference.identifier.start >= doSendMethod.value.body.start
+            && reference.identifier.end <= doSendMethod.value.body.end,
+        );
+        assert.equal(
+            importedBindingReferences.length,
+            0,
+            '_doSend must not reference the shared preconnect import binding',
+        );
+        assert.equal(
+            callsInjectedInstanceMember,
+            true,
+            '_doSend must call the instance preconnect seam',
+        );
+
         const provider = new OpenAICompatProvider('xai', {
             apiKey: 'xai-test',
             responsesTransport: 'http',
+            preconnect: true,
+            preconnectFn: () => {
+                injectedPreconnectCalls += 1;
+            },
         });
         let httpCalled = false;
         provider._doSendXaiResponses = async () => {
@@ -2184,7 +2698,10 @@ test('openai-compat/xai: provider-local HTTP pin beats global OAI ws-delta', asy
         const result = await provider._doSend([{ role: 'user', content: 'hi' }], 'grok-build', [], {});
         assert.equal(result.content, 'ok');
         assert.equal(httpCalled, true);
+        assert.equal(injectedPreconnectCalls, 1, 'only the injected preconnect seam must run');
+        assert.equal(outboundFetchAttempts, 0, 'stubbed provider test must remain network hermetic');
     } finally {
+        globalThis.fetch = prevFetch;
         if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
         else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
     }

package/scripts/reactive-compact-persist-smoke.mjs

@@ -141,4 +141,63 @@ assert(reloaded.compaction?.lastStage === 'overflow_failed', `compaction lastSta
 assert(reloaded.providerState?.xaiResponses?.previousResponseId === 'stale-after-compact',
   'providerState should remain when a failed reactive compact leaves the transcript unchanged');
 
+// Successful pre-send compaction must persist an explicit providerState clear.
+// The following ask then proves the stale continuation is absent from the
+// provider options, not merely absent from the first loop's local variable.
+let successfulCompactSends = 0;
+const nextAskStates = [];
+provider.send = async (_sentMessages, _model, _tools, opts = {}) => {
+  if (String(opts?.sessionId || '').endsWith(':compact')) {
+    successfulCompactSends += 1;
+    return {
+      content: [
+        '## Goal',
+        '- verify provider state clear',
+        '',
+        '## Progress',
+        '### Done',
+        '- old history compacted',
+        '',
+        '## Next Steps',
+        '- continue',
+      ].join('\n'),
+    };
+  }
+  nextAskStates.push(opts.providerState);
+  return { content: 'successful answer', stopReason: 'end_turn' };
+};
+const clearSessionId = `sess_provider_state_clear_${process.pid}_${Date.now()}`;
+const clearMessages = [{ role: 'system', content: 'rules' }];
+for (let i = 0; i < 10; i += 1) {
+  clearMessages.push({ role: 'user', content: `old ${i} ${'x '.repeat(500)}` });
+  clearMessages.push({ role: 'assistant', content: `answer ${i} ${'y '.repeat(500)}` });
+}
+await saveSessionAsync({
+  id: clearSessionId,
+  provider: 'openai-oauth',
+  model: 'provider-state-clear-smoke',
+  owner: 'agent',
+  agent: 'heavy-worker',
+  messages: clearMessages,
+  tools: [],
+  generation: 0,
+  closed: false,
+  contextWindow: 12_000,
+  rawContextWindow: 12_000,
+  compactBoundaryTokens: 12_000,
+  autoCompactTokenLimit: 4_000,
+  compaction: { auto: true, semantic: true, recallFastTrack: false, type: 1, compactType: 1 },
+  cwd: process.cwd(),
+  sessionStartMetaInjected: true,
+  providerState: { xaiResponses: { previousResponseId: 'must-clear' } },
+}, { expectedGeneration: 0 });
+await askSession(clearSessionId, 'first ask', null, null, process.cwd());
+const afterClear = loadSession(clearSessionId);
+assert(!Object.hasOwn(afterClear, 'providerState'), 'successful compact must remove providerState from persisted session');
+await askSession(clearSessionId, 'second ask', null, null, process.cwd());
+assert(successfulCompactSends >= 1, 'fixture must perform successful semantic compaction');
+assert(nextAskStates.length >= 2, 'both asks must reach provider');
+assert(nextAskStates[0] === undefined, 'post-compact send must receive cleared providerState');
+assert(nextAskStates[1] === undefined, 'next ask must not resurrect stale providerState');
+
 process.stdout.write('reactive-compact-persist smoke passed ✓\n');