mixdog 0.9.152 → 0.9.154

package/src/runtime/agent/orchestrator/providers/openai-codex-model.test.mjs

@@ -1,24 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import {
-    _codexMaxContextWindow,
-    _normalizeCodexModel,
-} from './openai-codex-model.mjs';
-
-test('validated GPT-5.6 Codex models expose a 272k default and 1M maximum', () => {
-    for (const id of ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna']) {
-        const model = _normalizeCodexModel({
-            slug: id,
-            context_window: 272_000,
-            max_context_window: 272_000,
-        });
-        assert.equal(model.contextWindow, 272_000);
-        assert.equal(model.maxContextWindow, 1_000_000);
-    }
-});
-
-test('Codex maximum overrides preserve larger provider values and unrelated models', () => {
-    assert.equal(_codexMaxContextWindow('gpt-5.6-sol', 1_050_000), 1_050_000);
-    assert.equal(_codexMaxContextWindow('gpt-5.5', 272_000), 272_000);
-});

package/src/runtime/agent/orchestrator/providers/openai-ws-delta-parity.test.mjs

@@ -1,190 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import {
-    _computeDelta,
-    _sansInput,
-    _stableStringify,
-} from './openai-ws-delta.mjs';
-import { _applyReasoningReplayPolicy } from './openai-oauth-ws.mjs';
-import { _captureTurnStateFromEvent } from './openai-ws-stream.mjs';
-import { _convertMessagesToResponsesInputForTest } from './openai-responses-payload.mjs';
-
-// A turn may reason, speak, then reason again before calling a tool. Replaying
-// every retained item in front of the text invents an order the response never
-// produced, and the next request's incremental check fails on the message item.
-test('a turn that reasons, speaks, then reasons again replays in that order', () => {
-    const beforeText = { id: 'rs-1', encrypted_content: 'e1', summary: [] };
-    const afterText = { id: 'rs-2', encrypted_content: 'e2', summary: [], afterText: true };
-    const input = _convertMessagesToResponsesInputForTest([
-        { role: 'user', content: 'task' },
-        {
-            role: 'assistant',
-            content: 'looking now',
-            reasoningItems: [beforeText, afterText],
-            toolCalls: [{ id: 'call-1', name: 'read', arguments: { path: 'a' } }],
-        },
-        { role: 'tool', toolCallId: 'call-1', content: 'contents' },
-    ], { replayEncryptedReasoning: true });
-
-    assert.deepEqual(input.map((item) => item.type ?? 'message'), [
-        'message',
-        'reasoning',
-        'message',
-        'reasoning',
-        'function_call',
-        'function_call_output',
-    ]);
-    assert.equal(input[1].id, 'rs-1');
-    assert.equal(input[3].id, 'rs-2');
-    // The ordering marker is bookkeeping, never a wire field.
-    assert.equal(input[3].afterText, undefined);
-});
-
-// A live chain's sticky-routing token can never be swapped mid-session: the
-// entry holds it write-once, whichever path first supplied it.
-test('a live turn-state token is never replaced by a later event token', () => {
-    const entry = {};
-    _captureTurnStateFromEvent(entry, {
-        type: 'response.created',
-        headers: { 'x-codex-turn-state': 'handshake-token' },
-    });
-    _captureTurnStateFromEvent(entry, {
-        type: 'response.created',
-        headers: { 'x-codex-turn-state': 'later-token' },
-    });
-    assert.equal(entry.turnState, 'handshake-token');
-});
-
-// The logical request history always carries retained reasoning — a pooled
-// entry with a live chain included. Only the duplicate-rejection retry drops it.
-test('reasoning stays in the logical history on every send', () => {
-    const reasoning = {
-        type: 'reasoning',
-        id: 'rs-1',
-        encrypted_content: 'encrypted',
-        summary: [],
-    };
-    const toolOutput = { type: 'function_call_output', call_id: 'call-1', output: 'ok' };
-    const body = { input: [reasoning, toolOutput] };
-    const entry = { lastResponseId: 'resp-1', lastRequestInput: [] };
-
-    const retained = _applyReasoningReplayPolicy(entry, body);
-    assert.equal(retained, body);
-    assert.equal(retained.input[0], reasoning);
-    assert.equal(entry.replayReasoning, true);
-
-    const suppressed = _applyReasoningReplayPolicy(entry, body, { suppress: true });
-    assert.equal(entry.replayReasoning, false);
-    assert.deepEqual(suppressed.input, [toolOutput]);
-});
-
-test('Codex delta parity falls back when a previous response item is absent', (t) => {
-    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
-    process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
-    t.after(() => {
-        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
-        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
-    });
-
-    const previousInput = [{
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'task' }],
-    }];
-    const previousCall = {
-        type: 'function_call',
-        call_id: 'call-1',
-        name: 'read',
-        arguments: '{"path":"/app/input.txt"}',
-    };
-    const body = {
-        model: 'gpt-5.6-sol',
-        input: [
-            ...previousInput,
-            // The reasoning item from the previous response is missing here.
-            previousCall,
-            {
-                type: 'function_call_output',
-                call_id: 'call-1',
-                output: 'fixture',
-            },
-        ],
-    };
-    const entry = {
-        lastRequestSansInput: _stableStringify(_sansInput({
-            model: body.model,
-            input: previousInput,
-        })),
-        lastRequestInput: previousInput,
-        lastResponseId: 'resp-1',
-        lastResponseItems: [
-            {
-                type: 'reasoning',
-                id: 'rs-1',
-                encrypted_content: 'encrypted',
-            },
-            previousCall,
-        ],
-        turnState: 'sticky',
-    };
-
-    const delta = _computeDelta({ entry, body, traceProvider: 'openai-oauth' });
-    assert.equal(delta.mode, 'full');
-    assert.equal(delta.reason, 'response_output_mismatch:reasoning');
-    assert.equal(delta.frame.previous_response_id, undefined);
-    assert.deepEqual(delta.frame.input, body.input);
-});
-
-// Retained reasoning rides the logical history, and the delta builder is what
-// keeps it off the wire: it belongs to the anchored previous response, so the
-// frame carries only what is genuinely new. This is the whole reason the
-// history keeps the item instead of dropping it before the delta runs.
-test('the delta frame drops the anchored reasoning item from the wire tail', (t) => {
-    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
-    process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
-    t.after(() => {
-        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
-        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
-    });
-
-    const previousInput = [{
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'task' }],
-    }];
-    const reasoning = { type: 'reasoning', id: 'rs-1', encrypted_content: 'encrypted' };
-    const previousCall = {
-        type: 'function_call',
-        call_id: 'call-1',
-        name: 'read',
-        arguments: '{"path":"/app/input.txt"}',
-    };
-    const toolOutput = {
-        type: 'function_call_output',
-        call_id: 'call-1',
-        output: 'fixture',
-    };
-    const body = {
-        model: 'gpt-5.6-sol',
-        input: [...previousInput, reasoning, previousCall, toolOutput],
-    };
-    const entry = {
-        lastRequestSansInput: _stableStringify(_sansInput({
-            model: body.model,
-            input: previousInput,
-        })),
-        lastRequestInput: previousInput,
-        lastResponseId: 'resp-1',
-        lastResponseItems: [reasoning, previousCall],
-        replayReasoning: true,
-        turnState: 'sticky',
-    };
-
-    const delta = _computeDelta({ entry, body, traceProvider: 'openai-oauth' });
-    assert.equal(delta.mode, 'delta');
-    assert.equal(delta.reason, null);
-    assert.equal(delta.frame.previous_response_id, 'resp-1');
-    assert.deepEqual(delta.frame.input, [toolOutput]);
-    assert.equal(delta.strippedResponseItems, 2);
-});

package/src/runtime/agent/orchestrator/providers/provider-replay.test.mjs

@@ -1,235 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import {
-    createProviderReplay,
-    providerReplayItems,
-} from './lib/provider-replay.mjs';
-import { toAnthropicMessages } from './lib/anthropic-request-utils.mjs';
-import { parseSSEStream as parseAnthropicSSEStream } from './anthropic-sse.mjs';
-import { toGeminiContents } from './gemini-schema.mjs';
-import { convertMessagesToResponsesInput } from './openai-responses-payload.mjs';
-import { toOpenAIMessages, toXaiResponsesInput } from './openai-compat-wire.mjs';
-import { estimateMessagesTokens } from '../session/context-utils.mjs';
-import { _sessionForDisk } from '../session/store/serialize.mjs';
-
-function interleavedAnthropicBlocks() {
-    const blocks = [{ type: 'thinking', thinking: '', signature: 'sig-a' }];
-    for (let index = 1; index <= 10; index += 1) {
-        blocks.push({
-            type: 'tool_use',
-            id: `toolu_${index}`,
-            name: 'read',
-            input: { index },
-        });
-    }
-    blocks.push({ type: 'thinking', thinking: '', signature: 'sig-b' });
-    blocks.push({
-        type: 'tool_use',
-        id: 'toolu_11',
-        name: 'read',
-        input: { index: 11 },
-    });
-    return blocks;
-}
-
-function interleavedResponsesItems() {
-    const items = [{
-        type: 'reasoning',
-        id: 'rs_1',
-        encrypted_content: 'cipher-a',
-        summary: [],
-    }];
-    for (let index = 1; index <= 10; index += 1) {
-        items.push({
-            type: 'function_call',
-            call_id: `call_${index}`,
-            name: 'read',
-            arguments: JSON.stringify({ index }),
-        });
-    }
-    items.push({
-        type: 'reasoning',
-        id: 'rs_2',
-        encrypted_content: 'cipher-b',
-        summary: [],
-    });
-    items.push({
-        type: 'function_call',
-        call_id: 'call_11',
-        name: 'read',
-        arguments: '{"index":11}',
-    });
-    return items;
-}
-
-function anthropicSseResponse(events) {
-    const body = events
-        .map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
-        .join('');
-    return new Response(body, { headers: { 'content-type': 'text/event-stream' } });
-}
-
-test('provider replay is detached and scoped to its originating provider', () => {
-    const source = [{ type: 'thinking', thinking: 'plan', signature: 'sig' }];
-    const replay = createProviderReplay('anthropic', source);
-    source[0].signature = 'mutated';
-
-    assert.equal(replay.items[0].signature, 'sig');
-    assert.deepEqual(providerReplayItems({ providerReplay: replay }, 'anthropic'), replay.items);
-    assert.equal(providerReplayItems({ providerReplay: replay }, 'gemini'), undefined);
-});
-
-test('Anthropic keeps interleaved thinking at content[11]', () => {
-    const blocks = interleavedAnthropicBlocks();
-    const message = {
-        role: 'assistant',
-        content: '',
-        toolCalls: blocks
-            .filter((block) => block.type === 'tool_use')
-            .map((block) => ({
-                id: block.id,
-                name: block.name,
-                arguments: block.input,
-            })),
-        providerReplay: createProviderReplay('anthropic', blocks),
-    };
-    const lowered = toAnthropicMessages([message]);
-
-    assert.deepEqual(lowered[0].content, blocks);
-    assert.equal(lowered[0].content[11].type, 'thinking');
-    assert.equal(lowered[0].content[11].signature, 'sig-b');
-});
-
-test('Anthropic SSE parse to next-request replay keeps content[11] unchanged', async () => {
-    const events = [
-        { type: 'message_start', message: { model: 'claude-test', usage: { input_tokens: 1 } } },
-        { type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } },
-        { type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'sig-a' } },
-        { type: 'content_block_stop', index: 0 },
-    ];
-    for (let index = 1; index <= 10; index += 1) {
-        events.push(
-            {
-                type: 'content_block_start',
-                index,
-                content_block: { type: 'tool_use', id: `toolu_${index}`, name: 'read' },
-            },
-            {
-                type: 'content_block_delta',
-                index,
-                delta: { type: 'input_json_delta', partial_json: JSON.stringify({ index }) },
-            },
-            { type: 'content_block_stop', index },
-        );
-    }
-    events.push(
-        { type: 'content_block_start', index: 11, content_block: { type: 'thinking', thinking: '' } },
-        { type: 'content_block_delta', index: 11, delta: { type: 'signature_delta', signature: 'sig-b' } },
-        { type: 'content_block_stop', index: 11 },
-        {
-            type: 'content_block_start',
-            index: 12,
-            content_block: { type: 'tool_use', id: 'toolu_11', name: 'read' },
-        },
-        {
-            type: 'content_block_delta',
-            index: 12,
-            delta: { type: 'input_json_delta', partial_json: '{"index":11}' },
-        },
-        { type: 'content_block_stop', index: 12 },
-        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 1 } },
-        { type: 'message_stop' },
-    );
-    const parsed = await parseAnthropicSSEStream(
-        anthropicSseResponse(events),
-        null,
-        () => {},
-        () => {},
-        () => {},
-        {},
-        null,
-        new Set(['read']),
-    );
-    const lowered = toAnthropicMessages([{
-        role: 'assistant',
-        content: parsed.content || '',
-        toolCalls: parsed.toolCalls,
-        providerReplay: parsed.providerReplay,
-    }]);
-
-    assert.equal(parsed.providerReplay.items[11].type, 'thinking');
-    assert.deepEqual(lowered[0].content, parsed.providerReplay.items);
-});
-
-test('Gemini keeps signed thought Parts interleaved with function calls', () => {
-    const parts = [{ text: 'plan-a', thought: true, thoughtSignature: 'sig-a' }];
-    for (let index = 1; index <= 10; index += 1) {
-        parts.push({ functionCall: { id: `call_${index}`, name: 'read', args: { index } } });
-    }
-    parts.push({ text: 'plan-b', thought: true, thoughtSignature: 'sig-b' });
-    parts.push({ functionCall: { id: 'call_11', name: 'read', args: { index: 11 } } });
-    const contents = toGeminiContents([{
-        role: 'assistant',
-        content: '',
-        toolCalls: [],
-        providerReplay: createProviderReplay('gemini', parts),
-    }], 'gemini-3-pro');
-
-    assert.deepEqual(contents[0].parts, parts);
-    assert.equal(contents[0].parts[11].thoughtSignature, 'sig-b');
-});
-
-test('OpenAI Responses recovery keeps reasoning between function calls', () => {
-    const items = interleavedResponsesItems();
-    const input = convertMessagesToResponsesInput([{
-        role: 'assistant',
-        content: '',
-        toolCalls: [],
-        providerReplay: createProviderReplay('openai-responses', items),
-    }], { replayEncryptedReasoning: true });
-
-    assert.deepEqual(input, items);
-    assert.equal(input[11].type, 'reasoning');
-    assert.equal(input[11].id, 'rs_2');
-});
-
-test('xAI stateless recovery keeps encrypted reasoning output order', () => {
-    const items = interleavedResponsesItems();
-    const result = toXaiResponsesInput([{
-        role: 'assistant',
-        content: '',
-        toolCalls: [],
-        providerReplay: createProviderReplay('xai-responses', items),
-    }], null);
-
-    assert.deepEqual(result.input, items);
-    assert.equal(result.input[11].type, 'reasoning');
-});
-
-test('OpenRouter reasoning_details remains an unmodified assistant field', () => {
-    const reasoningDetails = [
-        { type: 'reasoning.text', text: 'plan', signature: 'opaque' },
-        { type: 'reasoning.encrypted', data: 'ciphertext' },
-    ];
-    const wire = toOpenAIMessages([{
-        role: 'assistant',
-        content: '',
-        toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }],
-        providerMetadata: { openrouter: { reasoning_details: reasoningDetails } },
-    }], 'openrouter');
-
-    assert.equal(wire[0].reasoning_details, reasoningDetails);
-});
-
-test('provider replay survives disk projection and contributes to context size', () => {
-    const providerReplay = createProviderReplay('openai-responses', interleavedResponsesItems());
-    const message = { role: 'assistant', content: '', providerReplay };
-    const stored = _sessionForDisk({ id: 's', messages: [message] });
-
-    assert.deepEqual(stored.messages[0].providerReplay, providerReplay);
-    assert.ok(
-        estimateMessagesTokens([message])
-        > estimateMessagesTokens([{ role: 'assistant', content: '' }]),
-    );
-});