mixdog 0.9.50 → 0.9.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.50",
+  "version": "0.9.51",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/hook-bus-test.mjs

@@ -60,6 +60,29 @@ if (command.includes('rm -rf')) {
   }
 });
 
+test('standard PreToolUse hook can replace the tool name', async () => {
+  const root = tempRoot();
+  const hookScript = join(root, 'rename.mjs');
+  writeFileSync(hookScript, `console.log(JSON.stringify({ hookSpecificOutput: {
+    hookEventName: 'PreToolUse',
+    updatedToolName: 'local_fetch'
+  }}));\n`, 'utf8');
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, { hooks: { PreToolUse: [{ matcher: 'web_fetch', hooks: [{ type: 'command', command: process.execPath, args: [hookScript] }] }] } });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const decision = await createStandaloneHookBus({ dataDir: root }).beforeTool({
+      cwd: root, name: 'web_fetch', args: { url: 'http://localhost:3000/' },
+    });
+    assert.equal(decision.action, 'modify');
+    assert.equal(decision.name, 'local_fetch');
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
 test('UserPromptSubmit hook returns additional context', async () => {
   const root = tempRoot();
   const hookScript = join(root, 'prompt.mjs');

package/scripts/internal-tools-normalization-test.mjs

@@ -50,3 +50,13 @@ test('isError:false output stays normal', async () => {
     assert.equal(result, 'search complete');
     assert.equal(classifyResultKind(result), 'normal');
 });
+
+test('structured image output survives internal tool normalization', async () => {
+    const input = {
+        content: [
+            { type: 'text', text: 'downloaded' },
+            { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'YWJj' } },
+        ],
+    };
+    assert.deepEqual(await normalizeToolResult(input), input);
+});

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -1,9 +1,16 @@
 // Regression: OpenAI OAuth WS abnormal-close recovery before visible output.
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
-import { _sendFrame } from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
+import {
+    _clearWebSocketPoolForTest,
+    _seedWebSocketEntryForTest,
+    acquireWebSocket,
+    releaseWebSocket,
+    _sendFrame,
+} from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
 
 function close1006() {
     const err = new Error('WebSocket closed abnormally');
@@ -28,6 +35,65 @@ function wsArgs(overrides = {}) {
     };
 }
 
+class PoolSocket extends EventEmitter {
+    constructor() {
+        super();
+        this.readyState = 1;
+        this._socket = { ref() {}, unref() {} };
+    }
+    close() { this.readyState = 3; }
+    ping() { queueMicrotask(() => this.emit('pong')); }
+}
+
+function poolEntry(responseId) {
+    return {
+        socket: new PoolSocket(),
+        busy: true,
+        closing: false,
+        ephemeral: false,
+        lastResponseId: responseId,
+    };
+}
+
+test('pool release/acquire preserves latest compatible chain and auth/cache boundaries', async (t) => {
+    t.after(() => _clearWebSocketPoolForTest());
+    const poolKey = 'reused-session-id';
+    const authA = { account_id: 'account-a', access_token: 'token-a' };
+    const authB = { account_id: 'account-b', access_token: 'token-b' };
+    const oldest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-old'),
+    });
+    const latest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-latest'),
+    });
+    const otherAccount = _seedWebSocketEntryForTest({
+        poolKey, auth: authB, cacheKey: 'cache-a', entry: poolEntry('resp-account-b'),
+    });
+    const otherCache = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-b', entry: poolEntry('resp-cache-b'),
+    });
+
+    releaseWebSocket({ entry: oldest, poolKey, keep: true });
+    releaseWebSocket({ entry: otherAccount, poolKey, keep: true });
+    releaseWebSocket({ entry: otherCache, poolKey, keep: true });
+    releaseWebSocket({ entry: latest, poolKey, keep: true });
+
+    const first = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(first.entry, latest, 'latest completed compatible chain wins');
+    assert.equal(first.reused, true);
+    assert.equal(latest.busy, true, 'acquire reserves the selected entry');
+
+    const second = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(second.entry, oldest, 'reserved latest entry cannot be acquired concurrently');
+    assert.equal(second.entry.lastResponseId, 'resp-old');
+    assert.notEqual(second.entry, otherAccount);
+    assert.notEqual(second.entry, otherCache);
+});
+
 test('acquire timeout reconnects successfully with progress, not a terminal WS error', async () => {
     const oldWrite = process.stderr.write;
     const oldQuiet = process.env.MIXDOG_QUIET_PROVIDER_LOG;

package/scripts/provider-toolcall-test.mjs

@@ -37,6 +37,7 @@ import {
 import {
     _cacheObservationForTest,
     _cacheContinuityResetReasonForTest,
+    sendViaWebSocket,
 } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
     _withCodexWsClientMetadata,
@@ -1786,13 +1787,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 +1811,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;

package/scripts/session-bench-cache-break-test.mjs

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+test('root session bench promotes actionable compact mismatches without hiding intentional transitions', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-session-bench-'));
+  const trace = join(dir, 'trace.jsonl');
+  const sessionId = 'cache-break-observability';
+  const rows = [
+    ...Array.from({ length: 4 }, (_, index) => ({
+      ts: index + 1, sessionId, iteration: index + 1, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'automatic_compaction' },
+    })),
+    ...Array.from({ length: 2 }, (_, index) => ({
+      ts: index + 5, sessionId, iteration: index + 5, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'transcript_rebuild' },
+    })),
+    ...Array.from({ length: 2 }, (_, index) => ({
+      ts: index + 7, sessionId, iteration: index + 7, kind: 'cache_break',
+      payload: {
+        reason: 'request_properties_changed',
+        intentional_transition: 'explorer_hard_cap_final_tool_choice_none',
+        request_tool_choice: 'none',
+      },
+    })),
+    {
+      ts: 9, sessionId, iteration: 9, kind: 'cache_break',
+      payload: { reason: 'response_output_mismatch:function_call' },
+    },
+    {
+      ts: 10, sessionId, iteration: 10, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'unknown_transition' },
+    },
+    {
+      ts: 11, sessionId, iteration: 11, kind: 'cache_break',
+      payload: {
+        reason: 'response_output_mismatch:function_call',
+        intentional_transition: 'automatic_compaction',
+      },
+    },
+    {
+      ts: 12, sessionId: `${sessionId}:compact`, iteration: 1, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch' },
+    },
+    {
+      ts: 13, sessionId, iteration: 13, kind: 'cache_break',
+      payload: {
+        reason: 'request_properties_changed',
+        intentional_transition: 'explorer_hard_cap_final_tool_choice_none',
+      },
+    },
+    ...Array.from({ length: 6 }, (_, index) => ({
+      ts: index + 14, sessionId, iteration: index + 14, kind: 'cache_break',
+      payload: { reason: 'response_output_mismatch:function_call' },
+    })),
+  ];
+  writeFileSync(trace, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`);
+  try {
+    const output = execFileSync(process.execPath, [
+      'scripts/session-bench.mjs', '--json', '--trace', trace, '--session', sessionId,
+    ], { cwd: process.cwd(), encoding: 'utf8' });
+    const report = JSON.parse(output);
+    assert.equal(report.cache.cache_breaks.length, 19, 'raw evidence is retained');
+    assert.equal(report.cache.intentional_cache_breaks.length, 8);
+    assert.equal(report.cache.actionable_cache_breaks.length, 11);
+    assert.deepEqual(
+      report.cache.intentional_cache_breaks.map((row) => row.phase),
+      [
+        ...Array(4).fill('intentional_automatic_compaction'),
+        ...Array(2).fill('intentional_transcript_rebuild'),
+        ...Array(2).fill('intentional_explorer_hard_cap_final_tool_choice_none'),
+      ],
+    );
+    assert.equal(report.cache.actionable_cache_breaks[0].reason, 'response_output_mismatch:function_call');
+    const actionableByTs = new Map(report.cache.actionable_cache_breaks.map((row) => [row.ts, row]));
+    assert.equal(actionableByTs.get(10).intentional_transition, 'unknown_transition');
+    assert.equal(actionableByTs.get(11).intentional_transition, 'automatic_compaction');
+    assert.equal(actionableByTs.get(12).session_id, `${sessionId}:compact`);
+    assert.equal(actionableByTs.get(13).intentional_transition, 'explorer_hard_cap_final_tool_choice_none');
+    const cacheBreakIssues = report.issues.filter((issue) => issue.type === 'cache_break');
+    assert.equal(cacheBreakIssues.length, 10, 'the cache-break issue cap remains bounded');
+    assert.equal(cacheBreakIssues.filter((issue) => issue.session_id === sessionId).length, 9);
+    assert.ok(
+      report.issues.some((issue) => issue.type === 'cache_break' && issue.session_id === `${sessionId}:compact`),
+      'the root report must surface a child compact mismatch as an issue',
+    );
+    assert.ok(
+      report.rankings.some((ranking) => ranking.type === 'cache_breaks' && ranking.message.includes('11 actionable cache break(s)')),
+      'the root report must rank child compact mismatches with other actionable breaks',
+    );
+    const text = execFileSync(process.execPath, [
+      'scripts/session-bench.mjs', '--trace', trace, '--session', sessionId,
+    ], { cwd: process.cwd(), encoding: 'utf8' });
+    assert.match(text, /compact cache breaks \(actionable\):/);
+    assert.doesNotMatch(text, /compact cache resets \(intentional\):/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});