mixdog 0.9.52 → 0.9.54

package/scripts/provider-contract-test.mjs

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
 
 import {
     OpenAICompatProvider,
@@ -8,8 +12,14 @@ import {
     applyCompatProviderChatOptions,
     parseToolCalls,
 } from '../src/runtime/agent/orchestrator/providers/openai-compat.mjs';
-import { consumeCompatChatCompletionStream } from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import {
+    consumeCompatChatCompletionStream,
+    consumeCompatResponsesStream,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import { useXaiResponsesWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-compat-xai.mjs';
+import { classifyError } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
 import { GrokOAuthProvider } from '../src/runtime/agent/orchestrator/providers/grok-oauth.mjs';
+import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
     OpenCodeGoProvider,
     isAnthropicGoModel,
@@ -17,6 +27,11 @@ import {
     resolveOpenCodeGoBaseURLs,
 } from '../src/runtime/agent/orchestrator/providers/opencode-go.mjs';
 import { uncachedInputTokensForProvider } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
+import { resolveTraceUsageInput } from '../src/runtime/agent/orchestrator/agent-trace.mjs';
+import {
+    billableInputTokensForProvider,
+    isInclusiveProvider,
+} from '../src/runtime/shared/llm/cost.mjs';
 
 function stream(events) {
     return {
@@ -173,17 +188,143 @@ test('OpenCode Go normalizes both route families to inclusive provider usage', a
     provider.openai = { send: async () => openaiRaw };
     const anthropic = await provider.send([], 'minimax-m3', [], {});
     assert.equal(OpenCodeGoProvider.inputExcludesCache, false);
+    assert.equal(isInclusiveProvider('opencode-go'), true);
     assert.equal(anthropic.usage.inputTokens, 100);
     assert.equal(anthropic.usage.promptTokens, 100);
     assert.equal(uncachedInputTokensForProvider('opencode-go', anthropic.usage.inputTokens, 35, 5), 60);
+    assert.equal(billableInputTokensForProvider('opencode-go', 100, 35, 5), 60);
+    assert.deepEqual(resolveTraceUsageInput({
+        provider: 'opencode-go',
+        inputTokens: 60,
+        cachedTokens: 35,
+        cacheWriteTokens: 5,
+        inputTokensInclusive: false,
+    }), {
+        uncachedInputTokens: 60,
+        promptTokens: 100,
+    });
     assert.equal(anthropic.usage.inputTokens, 100, 'context footprint is inclusive');
 
     const openai = await provider.send([], 'glm-5.2', [], {});
     assert.equal(openai, openaiRaw);
     assert.equal(uncachedInputTokensForProvider('opencode-go', openai.usage.inputTokens, 40, 0), 60);
+    assert.equal(billableInputTokensForProvider('opencode-go', 100, 40, 0), 60);
+    assert.deepEqual(resolveTraceUsageInput({
+        provider: 'opencode-go',
+        inputTokens: 100,
+        cachedTokens: 40,
+        cacheWriteTokens: 0,
+    }), {
+        uncachedInputTokens: 60,
+        promptTokens: 100,
+    });
     assert.equal(openai.usage.inputTokens, 100, 'context footprint remains inclusive');
 });
 
+test('OpenCode Go Anthropic delegation traces additive inner usage before inclusive outer normalization', (t) => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'mixdog-opencode-go-trace-'));
+    const tracePath = join(tempDir, 'agent-trace.jsonl');
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const openCodeGoUrl = new URL('../src/runtime/agent/orchestrator/providers/opencode-go.mjs', import.meta.url).href;
+    const anthropicUrl = new URL('../src/runtime/agent/orchestrator/providers/anthropic.mjs', import.meta.url).href;
+    const traceUrl = new URL('../src/runtime/agent/orchestrator/agent-trace.mjs', import.meta.url).href;
+    const fixture = `
+        const { OpenCodeGoProvider } = await import(${JSON.stringify(openCodeGoUrl)});
+        const { AnthropicProvider } = await import(${JSON.stringify(anthropicUrl)});
+        const { drainAgentTrace } = await import(${JSON.stringify(traceUrl)});
+
+        const encoder = new TextEncoder();
+        const events = [
+            { type: 'message_start', message: {
+                model: 'minimax-m3',
+                usage: {
+                    input_tokens: 60,
+                    cache_read_input_tokens: 35,
+                    cache_creation_input_tokens: 5,
+                },
+            } },
+            { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 5 } },
+            { type: 'message_stop' },
+        ];
+        const chunks = events.map((event) => encoder.encode(
+            'event: ' + event.type + '\\ndata: ' + JSON.stringify(event) + '\\n\\n'
+        ));
+        let chunkIndex = 0;
+        const response = {
+            ok: true,
+            status: 200,
+            headers: new Map(),
+            body: { getReader() {
+                return {
+                    read() {
+                        return chunkIndex < chunks.length
+                            ? Promise.resolve({ done: false, value: chunks[chunkIndex++] })
+                            : Promise.resolve({ done: true, value: undefined });
+                    },
+                    cancel() { return Promise.resolve(); },
+                    releaseLock() {},
+                };
+            } },
+        };
+
+        const inner = Object.create(AnthropicProvider.prototype);
+        inner.name = 'opencode-go';
+        inner.config = { disableBetaHeaders: true };
+        inner.fastModeBetaHeaderLatched = false;
+        inner.client = { messages: { create() {
+            return { asResponse: async () => response };
+        } } };
+
+        const outer = Object.create(OpenCodeGoProvider.prototype);
+        outer.anthropic = inner;
+        outer.openai = { send() { throw new Error('wrong OpenCode Go route'); } };
+        const result = await outer.send(
+            [{ role: 'user', content: 'fixture' }],
+            'minimax-m3',
+            [],
+            { sessionId: 'opencode-go-additive-trace' },
+        );
+        await drainAgentTrace();
+        process.stdout.write(JSON.stringify(result.usage));
+    `;
+    const child = spawnSync(process.execPath, ['--input-type=module', '-e', fixture], {
+        cwd: new URL('..', import.meta.url),
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            MIXDOG_AGENT_TRACE_DISABLE: '0',
+            MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '0',
+            MIXDOG_AGENT_TRACE_PATH: tracePath,
+        },
+    });
+    assert.equal(child.status, 0, child.stderr || child.stdout);
+
+    const outerUsage = JSON.parse(child.stdout);
+    assert.deepEqual(outerUsage, {
+        inputTokens: 100,
+        outputTokens: 5,
+        cachedTokens: 35,
+        cacheWriteTokens: 5,
+        promptTokens: 100,
+    });
+    const traceRows = readFileSync(tracePath, 'utf8')
+        .trim()
+        .split(/\r?\n/)
+        .map((line) => JSON.parse(line));
+    const innerUsage = traceRows.find((row) => (
+        row.kind === 'usage_raw'
+        && row.session_id === 'opencode-go-additive-trace'
+    ));
+    assert.ok(innerUsage, 'delegated Anthropic route must emit usage_raw');
+    assert.equal(innerUsage.payload.provider, 'opencode-go');
+    assert.equal(innerUsage.input_tokens, 60);
+    assert.equal(innerUsage.cached_tokens, 35);
+    assert.equal(innerUsage.cache_write_tokens, 5);
+    assert.equal(innerUsage.uncached_input_tokens, 60);
+    assert.equal(innerUsage.prompt_tokens, 100);
+});
+
 test('constructing Grok OAuth is network inert', () => {
     const provider = new GrokOAuthProvider({
         preconnectFn: () => { throw new Error('constructor attempted outbound preconnect'); },
@@ -205,13 +346,18 @@ test('Grok OAuth end-to-end HTTP Responses path is hermetic through inner compat
         },
         responsesTransport: 'http',
     });
-    provider.ensureAuth = async () => ({ access_token: 'fixture-token' });
-    const inner = provider._ensureInner('fixture-token', 'grok-4.5');
-    assert.equal(inner.config.preconnect, false, 'Grok seam must propagate to inner compat');
-    assert.equal(typeof inner.config.preconnectFn, 'function');
-    inner.client = {
-        responses: {
-            create: async () => stream([
+    provider.ensureAuth = async () => ({ access_token: 'fixture-token', user_id: 'fixture-user' });
+    const ensureInner = provider._ensureInner.bind(provider);
+    let capturedInner = null;
+    let capturedParams = null;
+    provider._ensureInner = (...args) => {
+        const inner = ensureInner(...args);
+        capturedInner = inner;
+        inner.client = {
+            responses: {
+                create: async (params) => {
+                    capturedParams = params;
+                    return stream([
                 { type: 'response.created', response: { id: 'resp_fixture', model: 'grok-4.5' } },
                 { type: 'response.output_text.delta', delta: 'hermetic' },
                 {
@@ -224,20 +370,66 @@ test('Grok OAuth end-to-end HTTP Responses path is hermetic through inner compat
                         usage: { input_tokens: 3, output_tokens: 1 },
                     },
                 },
-            ]),
-        },
+                    ]);
+                },
+            },
+        };
+        return inner;
     };
 
     const result = await provider.send(
         [{ role: 'user', content: 'fixture' }],
         'grok-4.5',
         [],
-        { sessionId: 'hermetic-grok-contract' },
+        { sessionId: 'hermetic-grok-contract', iteration: 2 },
     );
     assert.equal(result.content, 'hermetic');
     assert.equal(result.usage.inputTokens, 3);
+    assert.equal(capturedInner.config.preconnect, false, 'Grok seam must propagate to inner compat');
+    assert.equal(typeof capturedInner.config.preconnectFn, 'function');
+    assert.equal(capturedInner.baseURL, 'https://cli-chat-proxy.grok.com/v1');
+    assert.equal(capturedInner.config.responsesTransport, 'http');
+    assert.equal(capturedInner.defaultHeaders['x-grok-conv-id'], undefined);
+    assert.equal(capturedInner.defaultHeaders['x-grok-session-id'], 'hermetic-grok-contract');
+    assert.match(capturedInner.defaultHeaders['x-grok-req-id'], /^[0-9a-f-]{36}$/);
+    assert.equal(capturedInner.defaultHeaders['x-grok-model-override'], 'grok-4.5');
+    assert.equal(capturedInner.defaultHeaders['x-grok-turn-idx'], '2');
+    assert.equal(capturedInner.defaultHeaders['x-grok-user-id'], 'fixture-user');
+    assert.equal(capturedParams.store, false);
+    assert.deepEqual(capturedParams.include, ['reasoning.encrypted_content']);
+    assert.equal(result.providerState.xaiResponses.store, false);
+    assert.equal(result.providerState.xaiResponses.previousResponseId, null);
 });
 
+test('xAI Responses defaults to HTTP and keeps WebSocket behind explicit opt-in', () => {
+    assert.equal(useXaiResponsesWebSocket({}, {}), false);
+    assert.equal(useXaiResponsesWebSocket({}, { responsesTransport: 'http' }), false);
+    assert.equal(useXaiResponsesWebSocket({}, { responsesTransport: 'websocket' }), true);
+});
+
+for (const event of [
+    { type: 'response.failed', response: { error: { message: 'forbidden' } } },
+    { type: 'error', message: 'forbidden' },
+]) {
+    test(`xAI ${event.type} stream event is retryable 500-equivalent without changing other compat labels`, async () => {
+        const xaiError = await consumeCompatResponsesStream(stream([event]), {
+            label: 'xai:responses',
+            parseResponsesToolCalls: () => [],
+            responseOutputText: () => '',
+        }).then(() => null, (err) => err);
+        assert.equal(xaiError.httpStatus, 500);
+        assert.equal(classifyError(xaiError), 'transient');
+
+        const otherError = await consumeCompatResponsesStream(stream([event]), {
+            label: 'other-compat',
+            parseResponsesToolCalls: () => [],
+            responseOutputText: () => '',
+        }).then(() => null, (err) => err);
+        assert.equal(otherError.httpStatus, 403);
+        assert.equal(classifyError(otherError), 'auth');
+    });
+}
+
 test('Grok OAuth does not refresh/replay a 401 after visible tool dispatch', async () => {
     const provider = Object.create(GrokOAuthProvider.prototype);
     provider.config = { preconnect: false };
@@ -266,3 +458,126 @@ test('Grok OAuth does not refresh/replay a 401 after visible tool dispatch', asy
     assert.equal(dispatched, 1);
     assert.equal(authCalls, 1);
 });
+
+test('xAI WS to HTTP fallback preserves completed warmup usage and cost ticks', 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 provider = new OpenAICompatProvider('xai', {
+        apiKey: 'fixture',
+        preconnect: false,
+        responsesTransport: 'websocket',
+    });
+    const warmup = {
+        requestBody: { generate: false },
+        usage: { inputTokens: 10, outputTokens: 1, cachedTokens: 4, promptTokens: 10, raw: { cost_in_usd_ticks: 100 } },
+    };
+    provider._doSendXaiResponsesWebSocket = async () => {
+        const err = Object.assign(new Error('upgrade required'), { httpStatus: 426 });
+        Object.defineProperty(err, '__warmup', { value: warmup });
+        throw err;
+    };
+    provider._doSendXaiResponses = async () => ({
+        content: 'fallback',
+        usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 5, promptTokens: 20, raw: { cost_in_usd_ticks: 200 }, costUsd: 0.00000002 },
+    });
+    const result = await provider._doSend([], 'grok-4.5', [], {});
+    assert.equal(result.usage.inputTokens, 30);
+    assert.equal(result.usage.mainInputTokens, 20);
+    assert.equal(result.usage.raw.cost_in_usd_ticks, 300);
+    assert.equal(result.usage.costUsd, 0.00000003);
+});
+
+test('xAI WS warmup billing exposes only main request usage as context', async () => {
+    let streams = 0;
+    const result = await sendViaWebSocket({
+        auth: { type: 'xai', apiKey: 'fixture' },
+        body: { model: 'grok-4.5', input: [{ role: 'user', content: 'main' }] },
+        sendOpts: {},
+        externalSignal: null,
+        poolKey: 'xai-warmup-accounting',
+        cacheKey: 'xai-warmup-accounting',
+        iteration: 1,
+        useModel: 'grok-4.5',
+        traceProvider: 'xai',
+        includeResponseId: true,
+        warmupBody: { model: 'grok-4.5', input: [], generate: false },
+        _acquireWithRetryFn: async () => ({ entry: { socket: { close() {} } }, reused: false }),
+        _sendFrameFn: async () => {},
+        _streamFn: async ({ state }) => {
+            streams += 1;
+            return state.warmup
+                ? {
+                    content: '',
+                    model: 'grok-4.5',
+                    toolCalls: [],
+                    usage: { inputTokens: 10, outputTokens: 1, cachedTokens: 4, promptTokens: 10, raw: { cost_in_usd_ticks: 100 } },
+                    responseId: 'warm',
+                    responseItems: [],
+                }
+                : {
+                    content: 'done',
+                    model: 'grok-4.5',
+                    toolCalls: [],
+                    usage: { inputTokens: 20, outputTokens: 2, cachedTokens: 5, promptTokens: 20, raw: { cost_in_usd_ticks: 200 } },
+                    responseId: 'main',
+                    responseItems: [],
+                    closeSocket: true,
+                };
+        },
+        _agentTraceFn: () => {},
+        _sendSpanTraceFn: () => {},
+    });
+    assert.equal(streams, 2);
+    assert.equal(result.usage.inputTokens, 30);
+    assert.equal(result.usage.mainInputTokens, 20);
+    assert.equal(result.usage.raw.cost_in_usd_ticks, 300);
+});
+
+test('xAI safe 401 replay carries completed warmup into the retry', async () => {
+    const provider = new OpenAICompatProvider('xai', { apiKey: 'fixture', preconnect: false });
+    const warmup = { usage: { inputTokens: 10 } };
+    let attempts = 0;
+    provider.reloadApiKey = () => {};
+    provider._doSend = async (_messages, _model, _tools, opts) => {
+        attempts += 1;
+        if (attempts === 1) {
+            const err = Object.assign(new Error('401'), { httpStatus: 401 });
+            Object.defineProperty(err, '__warmup', { value: warmup });
+            throw err;
+        }
+        assert.equal(opts._carriedWarmup, warmup);
+        return { content: 'retried' };
+    };
+    assert.equal((await provider.send([], 'grok-4.5', [], {})).content, 'retried');
+    assert.equal(attempts, 2);
+});
+
+for (const status of [401, 403]) {
+    test(`Grok OAuth safe ${status} replay carries completed warmup to refreshed xAI inner`, async () => {
+        const provider = Object.create(GrokOAuthProvider.prototype);
+        provider.config = { preconnect: false };
+        const warmup = { usage: { inputTokens: 10 } };
+        let authCalls = 0;
+        provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+            authCalls += 1;
+            return { access_token: forceRefresh ? 'fresh' : 'stale' };
+        };
+        provider._ensureInner = (token) => ({
+            _doSend: async (_messages, _model, _tools, opts) => {
+                if (token === 'stale') {
+                    const err = Object.assign(new Error(String(status)), { httpStatus: status });
+                    Object.defineProperty(err, '__warmup', { value: warmup });
+                    throw err;
+                }
+                assert.equal(opts._carriedWarmup, warmup);
+                return { content: 'retried' };
+            },
+        });
+        assert.equal((await provider.send([], 'grok-4.5', [], {})).content, 'retried');
+        assert.equal(authCalls, 2);
+    });
+}