mixdog 0.9.53 → 0.9.55

package/scripts/provider-contract-test.mjs

@@ -12,7 +12,12 @@ 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 {
@@ -341,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' },
                 {
@@ -360,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 };
@@ -500,26 +556,28 @@ test('xAI safe 401 replay carries completed warmup into the retry', async () =>
     assert.equal(attempts, 2);
 });
 
-test('Grok OAuth safe 401 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('401'), { httpStatus: 401 });
-                Object.defineProperty(err, '__warmup', { value: warmup });
-                throw err;
-            }
-            assert.equal(opts._carriedWarmup, warmup);
-            return { content: 'retried' };
-        },
+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);
     });
-    assert.equal((await provider.send([], 'grok-4.5', [], {})).content, 'retried');
-    assert.equal(authCalls, 2);
-});
+}

package/scripts/provider-toolcall-test.mjs

@@ -833,6 +833,89 @@ test('openai-compat/xai Responses: load_tool history replays as function_call',
     assert.equal(input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
 });
 
+test('openai-compat/xai store=false continuation replays the full conversation with encrypted reasoning', () => {
+    const encrypted = {
+        type: 'reasoning',
+        id: 'reasoning_1',
+        encrypted_content: 'opaque-ciphertext',
+        summary: [],
+    };
+    const { input, previousResponseId, startIndex } = _toXaiResponsesInputForTest([
+        { role: 'user', content: 'call read' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }],
+        },
+        { role: 'tool', toolCallId: 'call_1', content: 'contents' },
+    ], {
+        xaiResponses: {
+            previousResponseId: null,
+            responseId: 'resp_unstored',
+            store: false,
+            encryptedReasoningItems: [encrypted],
+            seenMessageCount: 1,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(startIndex, 0);
+    assert.equal(input[0].role, 'user');
+    assert.deepEqual(input[1], encrypted);
+    assert.equal(input[2].call_id, 'call_1');
+    assert.equal(input[3].call_id, 'call_1');
+});
+
+test('openai-compat/xai store=false second tool round retains original system/user and both tool results', () => {
+    const firstReasoning = {
+        type: 'reasoning',
+        id: 'reasoning_1',
+        encrypted_content: 'opaque-first',
+        summary: [],
+    };
+    const secondReasoning = {
+        type: 'reasoning',
+        id: 'reasoning_2',
+        encrypted_content: 'opaque-second',
+        summary: [],
+    };
+    const { input, previousResponseId, startIndex } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'original system' },
+        { role: 'user', content: 'original user request' },
+        { role: 'assistant', content: '', toolCalls: [{ id: 'call_1', name: 'read', arguments: { path: 'a' } }] },
+        { role: 'tool', toolCallId: 'call_1', content: 'first tool result' },
+        { role: 'assistant', content: '', toolCalls: [{ id: 'call_2', name: 'grep', arguments: { pattern: 'x' } }] },
+        { role: 'tool', toolCallId: 'call_2', content: 'second tool result' },
+    ], {
+        xaiResponses: {
+            previousResponseId: null,
+            responseId: 'resp_unstored_2',
+            store: false,
+            encryptedReasoningHistory: [
+                { messageIndex: 2, items: [firstReasoning] },
+                { messageIndex: 4, items: [secondReasoning] },
+            ],
+            seenMessageCount: 4,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(startIndex, 0);
+    assert.equal(input[0].role, 'system');
+    assert.equal(input[0].content[0].text, 'original system');
+    assert.equal(input[1].role, 'user');
+    assert.equal(input[1].content[0].text, 'original user request');
+    assert.deepEqual(input.filter((item) => item.type === 'reasoning'), [firstReasoning, secondReasoning]);
+    assert.deepEqual(
+        input.filter((item) => item.type === 'function_call').map((item) => item.call_id),
+        ['call_1', 'call_2'],
+    );
+    assert.deepEqual(
+        input.filter((item) => item.type === 'function_call_output').map((item) => item.output),
+        ['first tool result', 'second tool result'],
+    );
+});
+
 test('openai-compat/xai Responses: model switch drops prior tool transcript history', () => {
     const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
         { role: 'system', content: 'sys' },
@@ -2869,7 +2952,7 @@ test('openai-compat/xai: HTTP pin uses only the injected preconnect seam', async
     }
 });
 
-test('grok-oauth: all Grok models inherit global transport; explicit setting is the escape hatch', () => {
+test('grok-oauth: every OAuth model is pinned to the CLI proxy over HTTP/SSE', () => {
     const prevOaiTransport = process.env.MIXDOG_OAI_TRANSPORT;
     const prevResponsesTransport = process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT;
     const prevGrokTransport = process.env.MIXDOG_GROK_OAUTH_TRANSPORT;
@@ -2879,22 +2962,19 @@ test('grok-oauth: all Grok models inherit global transport; explicit setting is
         delete process.env.MIXDOG_GROK_OAUTH_TRANSPORT;
         const provider = new GrokOAuthProvider({});
 
-        const apiInner = provider._ensureInner('tok', 'grok-build-0.1');
-        assert.equal(apiInner.config.responsesTransport, undefined);
-
-        // No Grok-specific override: proxy-only grok-build now inherits the
-        // shared switch too (WS→api.x.ai), no implicit HTTP pin.
-        const proxyInner = provider._ensureInner('tok', 'grok-build');
-        assert.equal(proxyInner.config.responsesTransport, undefined);
-
-        // Escape hatch: an explicit Grok-specific http setting pins proxy-only
-        // models back onto the Grok CLI proxy over HTTP.
-        process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT = 'http';
-        const pinnedProvider = new GrokOAuthProvider({});
-        const pinnedProxy = pinnedProvider._ensureInner('tok', 'grok-build');
-        assert.equal(pinnedProxy.config.responsesTransport, 'http');
-        const pinnedApi = pinnedProvider._ensureInner('tok2', 'grok-build-0.1');
-        assert.equal(pinnedApi.config.responsesTransport, 'http');
+        for (const model of ['grok-build-0.1', 'grok-build', 'grok-4.5']) {
+            const inner = provider._ensureInner(`tok-${model}`, model);
+            assert.equal(inner.config.responsesTransport, 'http');
+            assert.equal(inner.baseURL, 'https://cli-chat-proxy.grok.com/v1');
+        }
+
+        // OAuth routing is a security boundary: even explicit WS settings
+        // cannot send the session bearer to the fixed api.x.ai WS endpoint.
+        process.env.MIXDOG_GROK_OAUTH_RESPONSES_TRANSPORT = 'websocket';
+        const pinnedProvider = new GrokOAuthProvider({ responsesTransport: 'websocket' });
+        const pinned = pinnedProvider._ensureInner('tok-explicit', 'grok-4.5');
+        assert.equal(pinned.config.responsesTransport, 'http');
+        assert.equal(pinned.baseURL, 'https://cli-chat-proxy.grok.com/v1');
     } finally {
         if (prevOaiTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
         else process.env.MIXDOG_OAI_TRANSPORT = prevOaiTransport;

package/scripts/streaming-tail-window-test.mjs

@@ -6,7 +6,21 @@ import {
 } from '../src/tui/markdown/streaming-markdown.mjs';
 import {
   measureStreamingMarkdownRenderedRows,
+  measureStreamingMarkdownRenderedRowsUncached,
 } from '../src/tui/markdown/measure-rendered-rows.mjs';
+import {
+  buildTranscriptRowIndex,
+  streamingRowEstimateStateForId,
+  streamingEstimateRows,
+  transcriptRenderWindow,
+} from '../src/tui/app/transcript-window.mjs';
+
+function assertCachedEqualsDirect(text, columns, key) {
+  const cached = measureStreamingMarkdownRenderedRows(text, columns, key);
+  const direct = measureStreamingMarkdownRenderedRowsUncached(text, columns, key);
+  assert.equal(cached, direct);
+  return cached;
+}
 
 test('bottom-pinned plain streaming text keeps only the visible suffix', () => {
   const lines = Array.from({ length: 100 }, (_, index) => `plain line ${index}`);
@@ -27,3 +41,135 @@ test('wrapped plain lines consume the streaming row budget', () => {
   assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 2), lines.slice(-1).join('\n'));
   assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 3), lines.slice(-2).join('\n'));
 });
+
+test('streaming row memo preserves plain append and resize measurements', () => {
+  const key = 'plain-row-memo';
+  const before = 'alpha\nbeta '.concat('x'.repeat(80));
+  const after = `${before}\ngamma ${'y'.repeat(120)}`;
+
+  assertCachedEqualsDirect(before, 40, key);
+  assertCachedEqualsDirect(after, 40, key);
+  assertCachedEqualsDirect(after, 24, key);
+});
+
+test('streaming row memo preserves markdown stable-prefix measurements', () => {
+  const key = 'markdown-row-memo';
+  const before = '# Heading\n\nSettled paragraph.\n\n**live';
+  const after = `${before} suffix**`;
+
+  assertCachedEqualsDirect(before, 48, key);
+  assertCachedEqualsDirect(after, 48, key);
+  assert.equal(
+    measureStreamingMarkdownRenderedRows(after, 48, key),
+    measureStreamingMarkdownRenderedRowsUncached(after, 48, key),
+  );
+});
+
+test('streaming row memo preserves fences, lists, and tables', () => {
+  const cases = [
+    ['fence', ['# Intro\n\n```js\nconst value = 1;', '# Intro\n\n```js\nconst value = 1;\nconsole.log(value);']],
+    ['list', ['- first item\n- second', '- first item\n- second item with wrapped detail '.repeat(3)]],
+    ['table', ['| A | B |\n| - | - |\n| one | two |', '| A | B |\n| - | - |\n| one | two |\n| three | four |']],
+  ];
+  for (const [name, values] of cases) {
+    for (const value of values) assertCachedEqualsDirect(value, 36, `shape-${name}`);
+  }
+});
+
+test('render-mode changes reset the streaming estimate high-water', () => {
+  const id = 'render-mode-flip';
+  streamingEstimateRows({
+    id,
+    kind: 'assistant',
+    streaming: false,
+    text: 'large settled markdown paragraph '.repeat(80),
+  }, 24, false);
+  const flipped = streamingEstimateRows({
+    id,
+    kind: 'assistant',
+    streaming: true,
+    text: 'short',
+  }, 24, false);
+  const fresh = streamingEstimateRows({
+    id: 'render-mode-fresh',
+    kind: 'assistant',
+    streaming: true,
+    text: 'short',
+  }, 24, false);
+  assert.equal(flipped, fresh);
+});
+
+test('stream estimate LRU evicts tail and high-water state in lockstep', () => {
+  const id = 'lru-evicted-stream';
+  streamingEstimateRows({
+    id,
+    kind: 'assistant',
+    streaming: true,
+    text: 'long streaming response '.repeat(80),
+  }, 24, false);
+  assert.deepEqual(streamingRowEstimateStateForId(id), {
+    tailEstimate: true,
+    highWater: true,
+  });
+
+  // Production cleanup when no measured-height layout effect runs: admitting
+  // eight newer stream ids evicts this oldest id from the bounded estimate LRU.
+  for (let index = 0; index < 8; index++) {
+    streamingEstimateRows({
+      id: `lru-newer-${index}`,
+      kind: 'assistant',
+      streaming: true,
+      text: `newer ${index}`,
+    }, 24, false);
+  }
+  assert.deepEqual(streamingRowEstimateStateForId(id), {
+    tailEstimate: false,
+    highWater: false,
+  });
+
+  // Reusing the evicted id must start from its new response, not retain the
+  // much taller high-water geometry from the aborted stream above.
+  const reused = streamingEstimateRows({
+    id,
+    kind: 'assistant',
+    streaming: true,
+    text: 'short',
+  }, 24, false);
+  const fresh = streamingEstimateRows({
+    id: 'lru-evicted-stream-fresh',
+    kind: 'assistant',
+    streaming: true,
+    text: 'short',
+  }, 24, false);
+  assert.equal(reused, fresh);
+});
+
+test('cached tail rows preserve rendered-window bytes', () => {
+  const items = Array.from({ length: 20 }, (_, index) => ({
+    id: `notice-${index}`,
+    kind: 'notice',
+    text: `notice ${index}`,
+  }));
+  const tail = {
+    id: 'window-byte-tail',
+    kind: 'assistant',
+    streaming: true,
+    text: '# Result\n\n- first\n- second\n\n| A | B |\n| - | - |\n| one | two |',
+  };
+  const allItems = [...items, tail];
+  const cachedIndex = buildTranscriptRowIndex(allItems, { columns: 36 });
+  const directTailRows = 1 + measureStreamingMarkdownRenderedRowsUncached(tail.text, 36, tail.id);
+  const directRows = [...cachedIndex.rows.slice(0, -1), directTailRows];
+  const directPrefix = [0];
+  for (const rows of directRows) directPrefix.push(directPrefix.at(-1) + rows);
+  const directIndex = {
+    rows: directRows,
+    prefixRows: directPrefix,
+    totalRows: directPrefix.at(-1),
+  };
+  const options = { scrollOffset: 4, viewportHeight: 8, columns: 36 };
+  assert.equal(
+    JSON.stringify(transcriptRenderWindow(allItems, { ...options, rowIndex: cachedIndex })),
+    JSON.stringify(transcriptRenderWindow(allItems, { ...options, rowIndex: directIndex })),
+  );
+});