mixdog 0.9.50 → 0.9.52

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/interrupted-turn-history-test.mjs

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+const DATA_DIR = mkdtempSync(join(tmpdir(), 'mixdog-interrupted-turn-'));
+process.env.MIXDOG_DATA_DIR = DATA_DIR;
+
+const PACKAGE_PATH = fileURLToPath(new URL('../package.json', import.meta.url));
+const USER_INTERRUPTION_MESSAGE = '[Request interrupted by user]';
+const TOOL_USE_INTERRUPTION_MESSAGE = '[Request interrupted by user for tool use]';
+const STREAMING_INTERRUPTED_TOOL_RESULT = 'Interrupted by user';
+const TOOL_USE_REJECT_RESULT = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+
+function deferred() {
+    let resolve;
+    const promise = new Promise((done) => { resolve = done; });
+    return { promise, resolve };
+}
+
+function waitForAbort(opts) {
+    return new Promise((_resolve, reject) => {
+        const signal = opts?.signal;
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+
+test('interrupted turns keep Claude Code-compatible model history boundaries', { concurrency: false }, async (t) => {
+    const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+    await initProviders({ gemini: { enabled: true, apiKey: 'test-only' } });
+    const provider = getProvider('gemini');
+    const {
+        abortSessionTurn,
+        askSession,
+        createSession,
+        getSession,
+    } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+    const { saveSessionAsync } = await import('../src/runtime/agent/orchestrator/session/store.mjs');
+
+    const createTestSession = (tools = []) => createSession({
+        provider: 'gemini',
+        model: 'gemini-test',
+        tools,
+        cwd: process.cwd(),
+        skipAgentRules: true,
+        skipSkills: true,
+        compaction: { auto: false },
+    });
+    const expectInterrupted = async (promise) => {
+        await assert.rejects(promise, (error) => error?.name === 'SessionClosedError');
+    };
+
+    await t.test('before response: rewinds the provisional user turn', async () => {
+        const session = createTestSession();
+        const baselineMessages = session.messages.slice();
+        const baselineSessionStart = session.sessionStartMetaInjected === true;
+        const entered = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            entered.resolve();
+            return waitForAbort(opts);
+        };
+
+        const asking = askSession(session.id, 'cancel before response', null, null, process.cwd());
+        await entered.promise;
+        assert.equal(abortSessionTurn(session.id, 'user-cancel'), true);
+        await expectInterrupted(asking);
+
+        const persisted = getSession(session.id);
+        assert.deepEqual(persisted.messages, baselineMessages);
+        assert.equal(persisted.sessionStartMetaInjected === true, baselineSessionStart);
+        assert.equal(persisted.liveTurnMessages, null);
+    });
+
+    await t.test('streaming: preserves a partial response without a newline', async () => {
+        const session = createTestSession();
+        const streamed = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            opts.onTextDelta?.('partial without newline');
+            streamed.resolve();
+            return waitForAbort(opts);
+        };
+
+        const asking = askSession(
+            session.id,
+            'stream a partial response',
+            null,
+            null,
+            process.cwd(),
+            null,
+            { onTextDelta: () => {} },
+        );
+        await streamed.promise;
+        abortSessionTurn(session.id, 'user-cancel');
+        await expectInterrupted(asking);
+
+        const persisted = getSession(session.id);
+        const partial = persisted.messages.find((message) => (
+            message.role === 'assistant' && message.content === 'partial without newline'
+        ));
+        assert.deepEqual(partial, {
+            role: 'assistant',
+            content: 'partial without newline',
+        });
+        assert.equal(persisted.messages.at(-1)?.content, USER_INTERRUPTION_MESSAGE);
+        assert.equal(persisted.liveTurnMessages, null);
+    });
+
+    await t.test('queued interrupt: preserves progress without a synthetic marker', async () => {
+        const session = createTestSession();
+        const streamed = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            opts.onTextDelta?.('partial before queued redirect');
+            streamed.resolve();
+            return waitForAbort(opts);
+        };
+
+        const asking = askSession(
+            session.id,
+            'active request',
+            null,
+            null,
+            process.cwd(),
+            null,
+            { onTextDelta: () => {} },
+        );
+        await streamed.promise;
+        abortSessionTurn(session.id, 'interrupt');
+        await expectInterrupted(asking);
+
+        const persisted = getSession(session.id);
+        assert.deepEqual(persisted.messages.at(-1), {
+            role: 'assistant',
+            content: 'partial before queued redirect',
+        });
+        assert.equal(persisted.messages.some((message) => (
+            message.content === USER_INTERRUPTION_MESSAGE
+            || message.content === TOOL_USE_INTERRUPTION_MESSAGE
+        )), false);
+    });
+
+    await t.test('streaming tool use: closes an unstarted call with an error result', async () => {
+        const session = createTestSession();
+        const observed = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            opts.onToolCall?.({
+                id: 'streaming_shell',
+                name: 'shell',
+                arguments: { command: 'echo not-started' },
+            });
+            observed.resolve();
+            return waitForAbort(opts);
+        };
+
+        const asking = askSession(session.id, 'prepare a shell call', null, null, process.cwd());
+        await observed.promise;
+        abortSessionTurn(session.id, 'user-cancel');
+        await expectInterrupted(asking);
+
+        const persisted = getSession(session.id);
+        assert.equal(persisted.messages.some((message) => (
+            message.role === 'assistant'
+            && message.toolCalls?.some((call) => call.id === 'streaming_shell')
+        )), true);
+        assert.deepEqual(
+            persisted.messages.find((message) => (
+                message.role === 'tool' && message.toolCallId === 'streaming_shell'
+            )),
+            {
+                role: 'tool',
+                content: STREAMING_INTERRUPTED_TOOL_RESULT,
+                toolCallId: 'streaming_shell',
+                toolKind: 'error',
+            },
+        );
+        assert.equal(persisted.messages.at(-1)?.content, USER_INTERRUPTION_MESSAGE);
+    });
+
+    await t.test('streamed eager tool: preserves a result completed before the provider response', async () => {
+        const session = createTestSession('readonly');
+        const eagerCompleted = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            opts.onToolCall?.({
+                id: 'eager_read',
+                name: 'read',
+                arguments: { path: PACKAGE_PATH, offset: 0, limit: 1 },
+            });
+            return waitForAbort(opts);
+        };
+        const asking = askSession(
+            session.id,
+            'run an eager read',
+            null,
+            null,
+            process.cwd(),
+            null,
+            {
+                onToolResult: (message) => {
+                    if (message?.__earlyNotify !== true) return;
+                    eagerCompleted.resolve();
+                    abortSessionTurn(session.id, 'user-cancel');
+                },
+            },
+        );
+        await eagerCompleted.promise;
+        await expectInterrupted(asking);
+
+        const persisted = getSession(session.id);
+        const assistant = persisted.messages.find((message) => (
+            message.role === 'assistant'
+            && message.toolCalls?.some((call) => call.id === 'eager_read')
+        ));
+        const result = persisted.messages.find((message) => (
+            message.role === 'tool' && message.toolCallId === 'eager_read'
+        ));
+        assert.ok(assistant, 'streamed tool_use is retained before send() returns');
+        assert.ok(result, 'completed eager result is retained');
+        assert.notEqual(result.content, STREAMING_INTERRUPTED_TOOL_RESULT);
+        assert.equal(persisted.messages.at(-1)?.content, USER_INTERRUPTION_MESSAGE);
+    });
+
+    let toolSession;
+    await t.test('tool execution: keeps completed results and closes unfinished calls', async () => {
+        toolSession = createTestSession();
+        provider.send = async () => ({
+            content: 'checking both slices',
+            toolCalls: [
+                { id: 'read_one', name: 'read', arguments: { path: PACKAGE_PATH, offset: 0, limit: 1 } },
+                { id: 'read_two', name: 'read', arguments: { path: PACKAGE_PATH, offset: 1, limit: 1 } },
+            ],
+            stopReason: 'tool_use',
+        });
+        let toolResults = 0;
+        const asking = askSession(
+            toolSession.id,
+            'read two slices',
+            null,
+            null,
+            process.cwd(),
+            null,
+            {
+                onToolResult: () => {
+                    toolResults += 1;
+                    if (toolResults === 1) abortSessionTurn(toolSession.id, 'user-cancel');
+                },
+            },
+        );
+        await expectInterrupted(asking);
+
+        const persisted = getSession(toolSession.id);
+        const results = persisted.messages.filter((message) => message.role === 'tool');
+        assert.equal(results.length, 2);
+        assert.equal(results[0].toolCallId, 'read_one');
+        assert.notEqual(results[0].content, TOOL_USE_REJECT_RESULT);
+        assert.deepEqual(
+            { id: results[1].toolCallId, content: results[1].content, kind: results[1].toolKind },
+            { id: 'read_two', content: TOOL_USE_REJECT_RESULT, kind: 'error' },
+        );
+        assert.equal(persisted.messages.at(-1)?.content, TOOL_USE_INTERRUPTION_MESSAGE);
+    });
+
+    await t.test('recovery: the next model request receives the closed tool trajectory', async () => {
+        let capturedMessages = null;
+        provider.send = async (messages, _model, _tools, opts) => {
+            capturedMessages = JSON.parse(JSON.stringify(messages));
+            opts.onTextDelta?.('recovered');
+            return { content: 'recovered', stopReason: 'STOP' };
+        };
+        const result = await askSession(toolSession.id, 'continue after interrupt', null, null, process.cwd());
+        assert.equal(result.content, 'recovered');
+        assert.equal(capturedMessages.some((message) => (
+            message.role === 'tool'
+            && message.toolCallId === 'read_two'
+            && message.content === TOOL_USE_REJECT_RESULT
+        )), true);
+        assert.equal(capturedMessages.some((message) => message.content === TOOL_USE_INTERRUPTION_MESSAGE), true);
+    });
+
+    let chainedSession;
+    await t.test('later iteration: preserves completed tool history, steering, and the current partial', async () => {
+        chainedSession = createTestSession();
+        let sendCount = 0;
+        const secondStream = deferred();
+        provider.send = async (_messages, _model, _tools, opts) => {
+            sendCount += 1;
+            if (sendCount === 1) {
+                opts.onTextDelta?.('first iteration preamble');
+                return {
+                    content: 'first iteration preamble',
+                    toolCalls: [
+                        { id: 'chain_read', name: 'read', arguments: { path: PACKAGE_PATH, offset: 0, limit: 1 } },
+                    ],
+                    stopReason: 'tool_use',
+                };
+            }
+            opts.onTextDelta?.('later partial');
+            secondStream.resolve();
+            return waitForAbort(opts);
+        };
+        let steeringDrained = false;
+        const asking = askSession(
+            chainedSession.id,
+            'run a chained turn',
+            null,
+            null,
+            process.cwd(),
+            null,
+            {
+                onTextDelta: () => {},
+                drainSteering: () => {
+                    if (steeringDrained) return [];
+                    steeringDrained = true;
+                    return [{ content: 'queued redirect', text: 'queued redirect', count: 1 }];
+                },
+            },
+        );
+        await secondStream.promise;
+        abortSessionTurn(chainedSession.id, 'user-cancel');
+        await expectInterrupted(asking);
+
+        const persisted = getSession(chainedSession.id);
+        assert.equal(persisted.messages.some((message) => (
+            message.role === 'tool' && message.toolCallId === 'chain_read'
+        )), true);
+        assert.equal(persisted.messages.some((message) => (
+            message.role === 'user'
+            && message.content === 'queued redirect'
+            && message.meta?.source === 'steering'
+        )), true);
+        assert.equal(persisted.messages.some((message) => (
+            message.role === 'assistant'
+            && message.content === 'later partial'
+        )), true);
+        assert.equal(persisted.messages.at(-1)?.content, USER_INTERRUPTION_MESSAGE);
+    });
+
+    await t.test('recovery and disk: partial/steering history survives the next send and storage flush', async () => {
+        let capturedMessages = null;
+        provider.send = async (messages) => {
+            capturedMessages = JSON.parse(JSON.stringify(messages));
+            return { content: 'chain recovered', stopReason: 'STOP' };
+        };
+        await askSession(chainedSession.id, 'finish the chain', null, null, process.cwd());
+        assert.equal(capturedMessages.some((message) => (
+            message.role === 'assistant'
+            && message.content === 'later partial'
+        )), true);
+        assert.equal(capturedMessages.some((message) => (
+            message.role === 'user' && message.content === 'queued redirect'
+        )), true);
+
+        const latestSession = getSession(chainedSession.id);
+        await saveSessionAsync(latestSession, { expectedGeneration: latestSession.generation });
+        const diskSession = JSON.parse(readFileSync(
+            join(DATA_DIR, 'sessions', `${chainedSession.id}.json`),
+            'utf8',
+        ));
+        assert.equal(diskSession.messages.some((message) => (
+            message.role === 'assistant' && message.content === 'later partial'
+        )), true);
+        assert.equal(diskSession.messages.some((message) => message.content === USER_INTERRUPTION_MESSAGE), true);
+        assert.equal(Object.hasOwn(diskSession, 'liveTurnMessages'), false);
+    });
+});

package/scripts/lifecycle-api-test.mjs

@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createLifecycleApi } from '../src/session-runtime/lifecycle-api.mjs';
+import {
+  _clearWebSocketPoolForTest,
+  _seedWebSocketEntryForTest,
+  closeOpenaiWsPoolForSession,
+} from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
+
+function socket() {
+  return {
+    closed: [],
+    close(_code, reason) {
+      this.closed.push(reason);
+    },
+  };
+}
+
+function lifecycleFor(session) {
+  let current = session;
+  return createLifecycleApi({
+    getSession: () => current,
+    setSession: (value) => { current = value; },
+    getRoute: () => ({}),
+    setRoute: () => {},
+    getConfig: () => ({}),
+    getMode: () => 'full',
+    getCurrentCwd: () => '/test',
+    setCloseRequested: () => {},
+    getMemoryModPromise: () => null,
+    setMemoryModPromise: () => {},
+    setSessionNeedsCwdRefresh: () => {},
+    hooks: { dispatch: () => {}, flushRules: () => {} },
+    hookCommonPayload: (payload) => payload,
+    mgr: {
+      closeSession: (id, reason) => {
+        closeOpenaiWsPoolForSession(id, `session-close:${reason}`);
+        return true;
+      },
+    },
+    statusRoutes: { clearGatewaySessionRoute: () => {} },
+    channels: { stop: () => null },
+    agentTool: { closeAll: () => {} },
+    mcpClient: { disconnectAll: () => null },
+    warmupTimers: {},
+    prewarmTimers: {},
+    flushConfigSave: () => {},
+    flushBackendSave: () => {},
+    flushOutputStyleSave: () => {},
+    withTeardownDeadline: (promise) => promise,
+    closePatchRuntimeIfLoaded: () => null,
+    invalidateContextStatusCache: () => {},
+    invalidatePreSessionToolSurface: () => {},
+    notificationListeners: { clear: () => {} },
+    remoteStateListeners: { clear: () => {} },
+  });
+}
+
+test('lifecycle drains the OpenAI WS pool only for process exit', async () => {
+  _clearWebSocketPoolForTest();
+  globalThis.__mixdogOpenaiWsRuntimeLoaded = true;
+  const replacementSocket = socket();
+  const retainedSocket = socket();
+  _seedWebSocketEntryForTest({ poolKey: 'replacement', auth: {}, cacheKey: '', entry: { socket: replacementSocket } });
+  _seedWebSocketEntryForTest({ poolKey: 'retained', auth: {}, cacheKey: '', entry: { socket: retainedSocket } });
+
+  await lifecycleFor({ id: 'replacement', messages: [], liveTurnMessages: [] }).close('engine-replace');
+
+  assert.deepEqual(replacementSocket.closed, ['session-close:engine-replace']);
+  assert.deepEqual(retainedSocket.closed, []);
+
+  await lifecycleFor({ id: 'exit-session', messages: [], liveTurnMessages: [] }).close('cli-exit');
+
+  assert.deepEqual(retainedSocket.closed, ['cli-exit']);
+});

package/scripts/max-output-recovery-test.mjs

@@ -37,6 +37,7 @@ async function run(provider, messages = [{ role: 'user', content: 'answer fully'
     return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
         onTextDelta: options.onTextDelta,
         session: options.session,
+        providerState: options.providerState,
     });
 }
 
@@ -117,6 +118,45 @@ test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery
     assert.equal(provider.sent[1][1].content, 'gemini ');
 });
 
+test('Gemini MAX_TOKENS continuation preserves provider-scoped replay metadata', async () => {
+    const providerMetadata = {
+        gemini: { thoughtParts: [{ text: 'signed thought', thoughtSignature: 'sig-gemini' }] },
+    };
+    const incomplete = Object.assign(new Error('MAX_TOKENS'), {
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'MAX_TOKENS',
+        partialContent: 'first ',
+        providerMetadata,
+    });
+    const provider = queuedProvider([
+        incomplete,
+        { content: 'second', stopReason: 'end_turn' },
+    ]);
+    await run(provider);
+    assert.deepEqual(provider.sent[1][1].providerMetadata, providerMetadata);
+});
+
+test('Gemini partial-final stall commits signed provider metadata with partial text', async () => {
+    const providerMetadata = {
+        gemini: {
+            thoughtParts: [{ text: 'private', thoughtSignature: 'sig-private' }],
+            textParts: [{ text: 'partial answer', thoughtSignature: 'sig-text' }],
+        },
+    };
+    const stalled = Object.assign(new Error('stalled'), {
+        streamStalled: true,
+        pendingToolUse: false,
+        emittedToolCall: false,
+        partialContent: 'partial answer',
+        providerMetadata,
+    });
+    const messages = [{ role: 'user', content: 'answer' }];
+    const result = await run(queuedProvider([stalled]), messages);
+    assert.equal(result.content, 'partial answer');
+    assert.deepEqual(result.providerMetadata, providerMetadata);
+});
+
 test('pause_turn and Gemini OTHER preserve prior non-empty semantics and do not recover', async () => {
     for (const stopReason of ['pause_turn', 'OTHER']) {
         const provider = queuedProvider([{ content: `partial-${stopReason}`, stopReason }]);
@@ -245,6 +285,21 @@ test('clean end_turn is unchanged and does not enter recovery', async () => {
     assert.deepEqual(messages, [{ role: 'user', content: 'answer fully' }]);
 });
 
+test('providerState distinguishes no update from an explicit clear for other providers', async () => {
+    const initial = { otherProvider: { continuation: 'keep' } };
+    const noUpdate = await run(queuedProvider([
+        { content: 'done', stopReason: 'end_turn' },
+    ]), undefined, { providerState: initial });
+    assert.deepEqual(noUpdate.providerState, initial);
+    assert.equal(noUpdate.providerStateUpdated, false);
+
+    const cleared = await run(queuedProvider([
+        { content: 'done', stopReason: 'end_turn', providerState: null },
+    ]), undefined, { providerState: initial });
+    assert.equal(cleared.providerState, null);
+    assert.equal(cleared.providerStateUpdated, true);
+});
+
 test('tool-call turns keep the normal tool execution path', async () => {
     const provider = queuedProvider([
         {