mixdog 0.9.40 → 0.9.43

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+process.env.MIXDOG_DATA_DIR = mkdtempSync(join(tmpdir(), 'mixdog-max-output-persist-'));
+
+test('askSession persists recovery history without duplicating the returned aggregate', async () => {
+    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 responses = [
+        {
+            content: 'persisted partial ',
+            stopReason: 'MAX_TOKENS',
+            truncated: true,
+            usage: { inputTokens: 4, outputTokens: 3, cachedTokens: 1, promptTokens: 4 },
+        },
+        {
+            content: 'terminal segment',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 2, outputTokens: 2, cachedTokens: 0, promptTokens: 2 },
+        },
+    ];
+    let sendIndex = 0;
+    const streamed = [];
+    provider.send = async (_messages, _model, _tools, opts = {}) => {
+        const response = responses[sendIndex++];
+        assert.ok(response, `unexpected provider send ${sendIndex}`);
+        opts.onTextDelta?.(response.content);
+        streamed.push(response.content);
+        return response;
+    };
+
+    const { createSession, askSession, getSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+    const session = createSession({
+        provider: 'gemini',
+        model: 'gemini-test',
+        tools: [],
+        cwd: process.cwd(),
+        skipAgentRules: true,
+        skipSkills: true,
+        compaction: { auto: false },
+    });
+
+    const result = await askSession(
+        session.id,
+        'produce a long answer',
+        null,
+        null,
+        process.cwd(),
+        null,
+        { onTextDelta: () => {} },
+    );
+    const persisted = getSession(session.id);
+    const partialRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'persisted partial ');
+    const terminalRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === 'terminal segment');
+    const aggregateRows = persisted.messages.filter((message) => message.role === 'assistant' && message.content === result.content);
+
+    assert.equal(result.content, 'persisted partial terminal segment');
+    assert.equal(streamed.join(''), result.content, 'streamed TUI text matches the aggregate without duplication');
+    assert.equal(partialRows.length, 1);
+    assert.equal(terminalRows.length, 1);
+    assert.equal(aggregateRows.length, 0, 'aggregate is returned but is not persisted over the recovery chain');
+    assert.equal(
+        persisted.messages.filter((message) => message?.meta?.source === 'max-output-recovery').length,
+        1,
+    );
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedTokens: result.usage.cachedTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 6, outputTokens: 5, cachedTokens: 1, promptTokens: 6 },
+    );
+});

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

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { agentLoop } from '../src/runtime/agent/orchestrator/session/agent-loop.mjs';
+import { HIDDEN_AGENT_NAMES } from '../src/runtime/agent/orchestrator/session/loop/hidden-agents.mjs';
+
+function queuedProvider(responses, streamed = []) {
+    const sent = [];
+    let index = 0;
+    return {
+        sent,
+        async send(messages, _model, _tools, opts = {}) {
+            sent.push(structuredClone(messages));
+            const response = responses[index++];
+            assert.ok(response, `unexpected provider send ${index}`);
+            if (response instanceof Error) {
+                if (typeof response.partialContent === 'string') {
+                    opts.onTextDelta?.(response.partialContent);
+                    streamed.push(response.partialContent);
+                }
+                throw response;
+            }
+            if (typeof response.content === 'string') {
+                opts.onTextDelta?.(response.content);
+                streamed.push(response.content);
+            }
+            return {
+                usage: { inputTokens: 1, outputTokens: 1 },
+                ...response,
+            };
+        },
+    };
+}
+
+async function run(provider, messages = [{ role: 'user', content: 'answer fully' }], options = {}) {
+    return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
+        onTextDelta: options.onTextDelta,
+        session: options.session,
+    });
+}
+
+function persistedAssistantText(messages, result) {
+    const terminal = typeof result.historyContent === 'string' ? result.historyContent : result.content;
+    return [
+        ...messages.filter((message) => message.role === 'assistant').map((message) => message.content),
+        terminal,
+    ].join('');
+}
+
+test('one max-output continuation resumes from preserved partial and returns one complete text', async () => {
+    const streamed = [];
+    const provider = queuedProvider([
+        { content: 'alpha ', stopReason: 'length', truncated: true },
+        { content: 'omega', stopReason: 'end_turn' },
+    ], streamed);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages, { onTextDelta: () => {} });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'alpha omega');
+    assert.equal(streamed.join(''), result.content);
+    assert.equal(result.historyContent, 'omega');
+    assert.equal(result.maxOutputRecoveryAttempts, 1);
+    assert.equal(result.terminationReason, undefined);
+    assert.deepEqual(provider.sent[1].map((message) => message.role), ['user', 'assistant', 'user']);
+    assert.equal(provider.sent[1][1].content, 'alpha ');
+    assert.match(provider.sent[1][2].content, /Resume directly/);
+    assert.match(provider.sent[1][2].content, /no apology, no recap/i);
+    assert.equal(persistedAssistantText(messages, result), result.content);
+    assert.equal(messages.some((message) => message.role === 'assistant' && message.content === result.content), false);
+});
+
+test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery and aggregates usage', async () => {
+    const streamed = [];
+    const geminiIncomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
+        name: 'ProviderIncompleteError',
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'MAX_TOKENS',
+        partialContent: 'gemini ',
+        partialToolCalls: undefined,
+        model: 'gemini-test',
+        rawUsage: {
+            promptTokenCount: 10,
+            candidatesTokenCount: 4,
+            thoughtsTokenCount: 1,
+            cachedContentTokenCount: 3,
+        },
+    });
+    const provider = queuedProvider([
+        geminiIncomplete,
+        {
+            content: 'complete',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 1, outputTokens: 2, cachedTokens: 1, promptTokens: 1 },
+        },
+    ], streamed);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages, { onTextDelta: () => {} });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'gemini complete');
+    assert.equal(streamed.join(''), result.content, 'TUI-facing deltas and final aggregate contain each segment once');
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedTokens: result.usage.cachedTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 11, outputTokens: 7, cachedTokens: 4, promptTokens: 11 },
+    );
+    assert.equal(result.lastTurnUsage.outputTokens, 2);
+    assert.equal(provider.sent[1][1].content, 'gemini ');
+});
+
+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 }]);
+        const result = await run(provider);
+        assert.equal(provider.sent.length, 1, stopReason);
+        assert.equal(result.content, `partial-${stopReason}`, stopReason);
+        assert.equal(result.terminationReason, undefined, stopReason);
+        assert.equal(Object.hasOwn(result, 'historyContent'), false, stopReason);
+    }
+});
+
+test('empty safety refusal gets one context-changing retry, then terminates as refusal', async () => {
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
+        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.terminationReason, 'refusal');
+    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
+    assert.match(provider.sent[1].at(-1).content, /safety classifier/);
+    assert.match(provider.sent[1].at(-1).content, /within policy/);
+});
+
+test('one refusal retry can recover to a normal answer', async () => {
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal' },
+        { content: 'compliant answer', stopReason: 'end_turn' },
+    ]);
+
+    const result = await run(provider);
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'compliant answer');
+    assert.equal(result.terminationReason, undefined);
+});
+
+test('hidden-agent empty refusal gets one retry, then terminates as refusal', async () => {
+    const hiddenAgent = HIDDEN_AGENT_NAMES.values().next().value;
+    assert.ok(hiddenAgent, 'expected at least one configured hidden agent');
+    const provider = queuedProvider([
+        { content: '', stopReason: 'refusal' },
+        { content: '', stopReason: 'refusal' },
+    ]);
+    const messages = [{ role: 'user', content: 'complete the assigned output' }];
+
+    const result = await run(provider, messages, { session: { agent: hiddenAgent } });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.terminationReason, 'refusal');
+    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
+    assert.match(provider.sent[1].at(-1).content, /assigned output within policy/);
+    assert.doesNotMatch(provider.sent[1].at(-1).content, /answer the user/i);
+});
+
+test('non-output ProviderIncompleteError remains an error', async () => {
+    const other = Object.assign(new Error('Gemini response incomplete: finishReason=OTHER'), {
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'OTHER',
+        partialContent: 'unsafe partial',
+        partialToolCalls: undefined,
+    });
+    await assert.rejects(run(queuedProvider([other])), (error) => error === other);
+});
+
+test('adaptive-thinking replay state is preserved on the partial assistant history turn', async () => {
+    const thinkingBlocks = [{ type: 'thinking', thinking: 'signed thought', signature: 'sig-123' }];
+    const reasoningItems = [{ type: 'reasoning', encrypted_content: 'enc-1' }];
+    const provider = queuedProvider([
+        {
+            content: 'first ',
+            stopReason: 'max_tokens',
+            truncated: true,
+            thinkingBlocks,
+            reasoningItems,
+            reasoningContent: 'display thought',
+        },
+        { content: 'second', stopReason: 'end_turn' },
+    ]);
+
+    const result = await run(provider);
+
+    assert.equal(result.content, 'first second');
+    assert.deepEqual(provider.sent[1][1].thinkingBlocks, thinkingBlocks);
+    assert.deepEqual(provider.sent[1][1].reasoningItems, reasoningItems);
+    assert.equal(provider.sent[1][1].reasoningContent, 'display thought');
+});
+
+test('max-output recovery stops after three continuations and surfaces explicit truncation', async () => {
+    const provider = queuedProvider([
+        { content: 'A', stopReason: 'max_tokens', truncated: true },
+        { content: 'B', stopReason: 'max_tokens', truncated: true },
+        { content: 'C', stopReason: 'max_tokens', truncated: true },
+        { content: 'D', stopReason: 'max_tokens', truncated: true },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 4);
+    assert.equal(result.maxOutputRecoveryAttempts, 3);
+    assert.equal(result.terminationReason, 'truncated');
+    assert.match(result.content, /^ABCD/);
+    assert.match(result.content, /remained truncated after 3 continuation attempts/);
+    assert.equal(messages.filter((message) => message?.meta?.source === 'max-output-recovery').length, 3);
+    assert.equal(messages.filter((message) => message.role === 'assistant').length, 3);
+    assert.equal(persistedAssistantText(messages, result), result.content);
+});
+
+test('clean end_turn is unchanged and does not enter recovery', async () => {
+    const provider = queuedProvider([
+        { content: 'clean answer', stopReason: 'end_turn' },
+    ]);
+    const messages = [{ role: 'user', content: 'answer fully' }];
+
+    const result = await run(provider, messages);
+
+    assert.equal(provider.sent.length, 1);
+    assert.equal(result.content, 'clean answer');
+    assert.equal(result.terminationReason, undefined);
+    assert.equal(Object.hasOwn(result, 'historyContent'), false);
+    assert.deepEqual(messages, [{ role: 'user', content: 'answer fully' }]);
+});
+
+test('tool-call turns keep the normal tool execution path', async () => {
+    const provider = queuedProvider([
+        {
+            content: '',
+            stopReason: 'tool_use',
+            toolCalls: [{ id: 'call-1', name: 'unknown_test_tool', arguments: {} }],
+        },
+        { content: 'done', stopReason: 'end_turn' },
+    ]);
+    const batches = [];
+    const messages = [{ role: 'user', content: 'use a tool' }];
+
+    const result = await run(provider, messages, {
+        onToolCall: (_iteration, calls) => batches.push(calls),
+    });
+
+    assert.equal(provider.sent.length, 2);
+    assert.equal(result.content, 'done');
+    assert.equal(result.toolCallsTotal, 1);
+    assert.equal(result.terminationReason, undefined);
+    assert.equal(Object.hasOwn(result, 'historyContent'), false);
+    assert.equal(batches.length, 1);
+    assert.deepEqual(messages.map((message) => message.role), ['user', 'assistant', 'tool']);
+});

package/scripts/mcp-client-normalization-test.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeMcpToolResult } from '../src/runtime/agent/orchestrator/mcp/client.mjs';
+import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+
+test('isError:true plain MCP text receives one canonical Error: prefix', () => {
+    const result = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'connection refused' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: connection refused');
+    assert.equal(classifyResultKind(result), 'error');
+});
+
+test('isError:true already-prefixed MCP text is unchanged', () => {
+    const result = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'Error: connection refused' }],
+        isError: true,
+    });
+    assert.equal(result, 'Error: connection refused');
+});
+
+test('absent or false isError leaves MCP text untouched', () => {
+    for (const isError of [undefined, false]) {
+        const result = normalizeMcpToolResult({
+            content: [{ type: 'text', text: 'search complete' }],
+            ...(isError === undefined ? {} : { isError }),
+        });
+        assert.equal(result, 'search complete');
+        assert.equal(classifyResultKind(result), 'normal');
+    }
+});
+
+test('isError:false Error:-leading MCP text stays untouched and normal', () => {
+    const returned = normalizeMcpToolResult({
+        content: [{ type: 'text', text: 'Error: quoted search result' }],
+        isError: false,
+    });
+    const normalized = normalizeToolEnvelope(returned);
+    assert.equal(normalized.result, 'Error: quoted search result');
+    assert.equal(normalized.explicitSuccess, true);
+    assert.equal(classifyResultKind(normalized.result, normalized.explicitSuccess), 'normal');
+});

package/scripts/provider-toolcall-test.mjs

@@ -52,6 +52,7 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/gemini-cache.mjs';
 import { parseSSEStream as anthropicParseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
 import { _buildRequestBodyForCacheSmoke } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { _toAnthropicMessagesForTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
 import {
     EFFORT_BETA_HEADER,
     LEGACY_EFFORT_BUDGET,
@@ -94,6 +95,29 @@ function anthropicSseResponse(events) {
     };
 }
 
+test('anthropic SSE exposes refusal stop details and category metadata', async () => {
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse([
+            { type: 'message_start', message: { model: 'claude-fable-5', usage: { input_tokens: 1 } } },
+            {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: 'refusal',
+                    stop_details: { classifier: 'safety' },
+                    category: 'policy',
+                },
+                usage: { output_tokens: 0 },
+            },
+            { type: 'message_stop' },
+        ]),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+
+    assert.equal(result.stopReason, 'refusal');
+    assert.deepEqual(result.stopDetails, { classifier: 'safety', category: 'policy' });
+    assert.equal(result.content, '');
+});
+
 function compatResponsesEventStream(events) {
     return {
         async *[Symbol.asyncIterator]() {
@@ -773,6 +797,37 @@ test('anthropic(-oauth): redacted_thinking round-trips exactly as {type,data} (n
     ]);
 });
 
+test('anthropic API-key and OAuth lower plain signed thinkingBlocks before text without tool calls', () => {
+    const thinkingBlocks = [
+        { type: 'thinking', thinking: 'resume state', signature: 'sig-recovery-1' },
+        { type: 'redacted_thinking', data: 'ENCRYPTED_RECOVERY_STATE' },
+    ];
+    const history = [
+        { role: 'user', content: 'write the answer' },
+        { role: 'assistant', content: 'partial answer', thinkingBlocks },
+        { role: 'user', content: 'resume directly' },
+    ];
+    const expectedAssistantContent = [
+        ...thinkingBlocks,
+        { type: 'text', text: 'partial answer' },
+    ];
+
+    const apiKeyMessages = _toAnthropicMessagesForTest(history);
+    const oauthMessages = _buildRequestBodyForCacheSmoke(
+        history,
+        'claude-sonnet-4-6',
+        [],
+        {},
+    ).messages;
+
+    for (const lowered of [apiKeyMessages, oauthMessages]) {
+        const assistant = lowered.find((message) => message.role === 'assistant');
+        assert.ok(assistant, 'plain recovery assistant turn must survive lowering');
+        assert.deepEqual(assistant.content, expectedAssistantContent);
+        assert.equal(assistant.content.some((block) => block.type === 'tool_use'), false);
+    }
+});
+
 test('anthropic effort: legacy claude-3-7-sonnet gets NO adaptive thinking / effort beta', () => {
     const model = 'claude-3-7-sonnet-20250219';
     assert.equal(modelSupportsEffort(model), false);

package/scripts/result-classification-test.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    executeInternalTool,
+    setInternalToolsProvider,
+} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
+import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
+
+async function classifyHandlerResult(handlerResult) {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => handlerResult,
+    });
+    const returned = await executeInternalTool('result_classification_test', {});
+    const normalized = normalizeToolEnvelope(returned);
+    return classifyResultKind(normalized.result, normalized.explicitSuccess);
+}
+
+test('explicit success suppresses Error: text-prefix classification', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: quoted log output' }],
+        isError: false,
+    }), 'normal');
+});
+
+test('explicit isError:true remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'handler failed' }],
+        isError: true,
+    }), 'error');
+});
+
+test('flag-less Error: text remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: prefix-only failure' }],
+    }), 'error');
+});
+
+test('flag-less normal text remains normal', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'ordinary output' }],
+    }), 'normal');
+});
+
+test('afterToolHook receives unwrapped explicit-success text', async () => {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => ({
+            content: [{ type: 'text', text: 'Error: quoted hook payload' }],
+            isError: false,
+        }),
+    });
+    let hookResult;
+    const returned = await executeTool(
+        'result_classification_test',
+        {},
+        process.cwd(),
+        'result-classification-test-session',
+        {
+            afterToolHook: async (input) => {
+                hookResult = input.result;
+            },
+        },
+        { toolCallId: 'result-classification-hook-call' },
+    );
+    assert.equal(hookResult, 'Error: quoted hook payload');
+    assert.equal(typeof hookResult, 'string');
+
+    const normalized = normalizeToolEnvelope(returned);
+    assert.equal(normalized.result, hookResult);
+    assert.equal(normalized.explicitSuccess, true);
+});

package/scripts/smoke.mjs

@@ -95,7 +95,7 @@ runNode(['--input-type=module', '-e', `
     stats: { currentContextTokens: 0 },
     agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
   });
-  if (!line.includes('Running') || !line.includes('bench-agent')) throw new Error('statusline must render live agent task state: ' + JSON.stringify(line));
+  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
 `], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
 
 runNode(['--input-type=module', '-e', `