mixdog 0.8.1 → 0.9.0

package/scripts/provider-toolcall-test.mjs

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+// Regression tests pinning the cross-provider "native tool_call extraction"
+// contract: when a provider's native parser is fed a well-formed tool_call
+// payload, it MUST surface the call in our canonical toolCalls shape
+// ({ id, name, arguments }). Synthetic inputs fed directly to the exported parser, asserting the
+// resulting outcome. No network, no model. Each provider also gets one
+// negative case (no native tool_call → undefined / empty).
+//
+// Parser entry points (file:line at authoring time) and sharing notes are
+// documented inline per provider block below.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+    _toResponsesToolsForTest,
+    _toXaiResponsesInputForTest,
+    parseToolCalls as compatParseToolCalls,
+    parseResponsesToolCalls as compatParseResponsesToolCalls,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat.mjs';
+import {
+    consumeCompatResponsesStream,
+    isInvalidToolArgsMarker,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import { parseToolCalls as geminiParseToolCalls } from '../src/runtime/agent/orchestrator/providers/gemini.mjs';
+import { parseSSEStream as anthropicParseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { PATCH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs';
+
+// --- Helpers ---------------------------------------------------------------
+
+// Wraps an array of Anthropic SSE event objects in a minimal Response-like
+// shape exposing the single `body.getReader()` API that parseSSEStream uses.
+// Each event becomes a `data: <json>` SSE frame, preceded by its `event:` line.
+function anthropicSseResponse(events) {
+    const encoder = new TextEncoder();
+    const frames = events.map((e) => {
+        const type = e.type || 'message';
+        return `event: ${type}\ndata: ${JSON.stringify(e)}\n\n`;
+    });
+    const chunks = frames.map((f) => encoder.encode(f));
+    let i = 0;
+    return {
+        body: {
+            getReader() {
+                return {
+                    read() {
+                        if (i < chunks.length) return Promise.resolve({ done: false, value: chunks[i++] });
+                        return Promise.resolve({ done: true, value: undefined });
+                    },
+                    cancel() { return Promise.resolve(); },
+                    releaseLock() {},
+                };
+            },
+        },
+    };
+}
+
+function compatResponsesEventStream(events) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            for (const event of events) yield event;
+        },
+    };
+}
+
+// === 1. openai-compat ======================================================
+// Chat path:      parseToolCalls(choice, label)         openai-compat.mjs:957
+// Responses path: parseResponsesToolCalls(response,...) openai-compat.mjs:972
+// Both exported (added `export` keyword only).
+
+test('openai-compat (chat): native tool_calls → canonical toolCalls', () => {
+    const choice = {
+        message: {
+            tool_calls: [{
+                id: 'call_1',
+                type: 'function',
+                function: { name: 'grep', arguments: '{"pattern":"x"}' },
+            }],
+        },
+        finish_reason: 'tool_calls',
+    };
+    const out = compatParseToolCalls(choice, 'test');
+    assert.deepEqual(out, [{ id: 'call_1', name: 'grep', arguments: { pattern: 'x' } }]);
+});
+
+test('openai-compat (chat): no tool_calls → undefined', () => {
+    assert.equal(compatParseToolCalls({ message: { content: 'hi' }, finish_reason: 'stop' }, 'test'), undefined);
+    assert.equal(compatParseToolCalls({ message: { tool_calls: [] } }, 'test'), undefined);
+});
+
+test('openai-compat (responses): native function_call → canonical toolCalls', () => {
+    const response = {
+        status: 'completed',
+        output: [{
+            type: 'function_call',
+            call_id: 'fc_1',
+            name: 'read',
+            arguments: '{"path":"a"}',
+        }],
+    };
+    const out = compatParseResponsesToolCalls(response, 'test');
+    assert.deepEqual(out, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
+});
+
+test('openai-compat (responses): no function_call → undefined', () => {
+    assert.equal(compatParseResponsesToolCalls({ status: 'completed', output: [] }, 'test'), undefined);
+    assert.equal(compatParseResponsesToolCalls({ output: [{ type: 'message', content: [] }] }, 'test'), undefined);
+});
+
+// Native convergence: a completed function tool_call whose arguments JSON is
+// malformed must NOT make the provider layer throw or swallow to {}. The parse
+// failure rides through on the call's `arguments` slot as an invalid-args
+// marker so the dispatch loop can return an is_error tool_result and let the
+// model self-correct in the same turn.
+test('openai-compat (chat): malformed tool_calls args → invalid-args marker (provider does not throw)', () => {
+    const choice = {
+        message: {
+            tool_calls: [{
+                id: 'call_bad',
+                type: 'function',
+                function: { name: 'grep', arguments: '{"pattern": dispatchAiWrapped}' },
+            }],
+        },
+        finish_reason: 'tool_calls',
+    };
+    const out = compatParseToolCalls(choice, 'test');
+    assert.equal(Array.isArray(out), true);
+    assert.equal(out.length, 1);
+    assert.equal(out[0].id, 'call_bad');
+    assert.equal(out[0].name, 'grep');
+    assert.equal(isInvalidToolArgsMarker(out[0].arguments), true);
+});
+
+test('openai-compat (responses): malformed function_call args → invalid-args marker (no throw)', () => {
+    const response = {
+        status: 'completed',
+        output: [{
+            type: 'function_call',
+            call_id: 'fc_bad',
+            name: 'read',
+            arguments: '{path:}',
+        }],
+    };
+    const out = compatParseResponsesToolCalls(response, 'test');
+    assert.equal(Array.isArray(out), true);
+    assert.equal(out.length, 1);
+    assert.equal(out[0].id, 'fc_bad');
+    assert.equal(out[0].name, 'read');
+    assert.equal(isInvalidToolArgsMarker(out[0].arguments), true);
+});
+
+test('openai-compat/xai Responses stream: response.completed salvages deferred function_call id/name', async () => {
+    const captured = [];
+    const out = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_1', model: 'grok' } },
+        {
+            type: 'response.function_call_arguments.done',
+            item_id: 'fc_item_1',
+            arguments: '{"path":"a"}',
+        },
+        {
+            type: 'response.completed',
+            response: {
+                id: 'resp_1',
+                model: 'grok',
+                status: 'completed',
+                output: [{
+                    type: 'function_call',
+                    id: 'fc_item_1',
+                    call_id: 'fc_1',
+                    name: 'read',
+                    arguments: '{"path":"a"}',
+                }],
+            },
+        },
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+        onToolCall: (call) => captured.push(call),
+    });
+    assert.deepEqual(out.toolCalls, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
+    assert.deepEqual(captured, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
+});
+
+test('openai-compat/xai Responses: freeform apply_patch downgrades to function schema', () => {
+    const tools = _toResponsesToolsForTest(PATCH_TOOL_DEFS);
+    const patch = tools.find((tool) => tool.name === 'apply_patch');
+    assert.equal(patch.type, 'function');
+    assert.equal(patch.format, undefined);
+    assert.equal(patch.parameters?.properties?.patch?.type, 'string');
+    assert.deepEqual(patch.parameters?.required, ['patch']);
+});
+
+test('openai-compat/xai Responses: custom_tool_call history replays as function_call', () => {
+    const rawPatch = '*** Begin Patch\n*** Add File: xai-history.txt\n+ok\n*** End Patch\n';
+    const { input } = _toXaiResponsesInputForTest([
+        { role: 'user', content: 'patch please' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_patch_1', name: 'apply_patch', arguments: { patch: rawPatch }, nativeType: 'custom_tool_call' }],
+        },
+        { role: 'tool', toolCallId: 'call_patch_1', content: 'OK' },
+    ], null, { model: 'grok-composer-2.5-fast' });
+    assert.equal(input.some((item) => item.type === 'custom_tool_call'), false);
+    assert.equal(input.some((item) => item.type === 'custom_tool_call_output'), false);
+    const call = input.find((item) => item.type === 'function_call' && item.name === 'apply_patch');
+    assert.equal(call.call_id, 'call_patch_1');
+    assert.deepEqual(JSON.parse(call.arguments), { patch: rawPatch });
+    const output = input.find((item) => item.type === 'function_call_output');
+    assert.equal(output.call_id, 'call_patch_1');
+    assert.equal(output.output, 'OK');
+});
+
+// === 2. gemini =============================================================
+// parseToolCalls(parts)   gemini.mjs:946  (exported — `export` keyword only).
+// id is a content hash → assert the `gemini_` prefix, not the exact value.
+
+test('gemini: native functionCall parts → canonical toolCalls (hashed id)', () => {
+    const parts = [{ functionCall: { name: 'read', args: { path: 'a' } } }];
+    const out = geminiParseToolCalls(parts);
+    assert.equal(Array.isArray(out), true);
+    assert.equal(out.length, 1);
+    assert.equal(out[0].name, 'read');
+    assert.deepEqual(out[0].arguments, { path: 'a' });
+    assert.match(out[0].id, /^gemini_/);
+});
+
+test('gemini: no functionCall parts → undefined', () => {
+    assert.equal(geminiParseToolCalls([{ text: 'hello' }]), undefined);
+    assert.equal(geminiParseToolCalls([]), undefined);
+});
+
+// === 3. anthropic / anthropic-oauth ========================================
+// tool_use block parser lives in anthropic-oauth.mjs:936 parseSSEStream
+// (content_block_start/delta/stop → toolCalls.push). anthropic.mjs has NO
+// independent tool_use parser: it imports and reuses the SAME parseSSEStream
+// from anthropic-oauth.mjs (anthropic.mjs:12). So a single test covers both
+// providers — shared parser, no duplicate test needed.
+
+test('anthropic(-oauth): streamed tool_use block → canonical toolCalls', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id: 'toolu_1', name: 'shell' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: '{"command":"ls"}' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const captured = [];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null,            // signal
+        () => {},        // abortStream
+        () => {},        // onStreamDelta
+        (call) => captured.push(call), // onToolCall
+        {},              // state
+        null,            // onTextDelta
+    );
+    assert.deepEqual(result.toolCalls, [{ id: 'toolu_1', name: 'shell', arguments: { command: 'ls' } }]);
+    // Eager dispatch fired the same call exactly once.
+    assert.deepEqual(captured, [{ id: 'toolu_1', name: 'shell', arguments: { command: 'ls' } }]);
+});
+
+test('anthropic(-oauth): malformed streamed tool_use args → invalid-args marker, not {} dispatch', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id: 'toolu_bad', name: 'shell' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: '{"command": dispatchAiWrapped}' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const captured = [];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null,
+        () => {},
+        () => {},
+        (call) => captured.push(call),
+        {},
+        null,
+    );
+    assert.equal(isInvalidToolArgsMarker(result.toolCalls[0].arguments), true);
+    assert.equal(result.toolCalls[0].arguments.__rawArguments, '{"command": dispatchAiWrapped}');
+    assert.equal(isInvalidToolArgsMarker(captured[0].arguments), true);
+});
+
+test('anthropic(-oauth): text-only stream → no toolCalls', async () => {
+    const events = [
+        { type: 'message_start', message: { model: 'claude', usage: { input_tokens: 1 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'text' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'hello' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
+        { type: 'message_stop' },
+    ];
+    const result = await anthropicParseSSEStream(
+        anthropicSseResponse(events),
+        null, () => {}, () => {}, () => {}, {}, null,
+    );
+    assert.equal(result.toolCalls, undefined);
+    assert.equal(result.content, 'hello');
+});
+
+// === 4. openai-oauth / openai-oauth-ws =====================================
+// openai-oauth (HTTP/SSE) and openai-oauth-ws (WebSocket) both consume the
+// Responses event stream inside large stateful stream loops, NOT a standalone
+// parser. The HTTP path's handleEvent is a private closure inside
+// sendViaHttpSse (openai-oauth.mjs:1038) and cannot be exported without
+// extracting it (forbidden: no logic change). The WS path's _streamResponse
+// (openai-oauth-ws.mjs:1190) IS exported but requires a live `entry.socket`
+// EventEmitter and resolves only on response.completed — driving it needs a
+// full fake-socket test rig, well beyond "inject synthetic input to a parser".
+//
+// Their canonical Responses function_call shape (call_id/name/arguments) and
+// custom_tool_call handling are the SAME wire contract already asserted via
+// openai-compat's parseResponsesToolCalls above, and the shared
+// customToolCallFromResponseItem helper (custom-tool-wire.mjs) is imported by
+// all three. We add a focused unit test for that shared custom-tool helper so
+// the OAuth custom_tool_call extraction path has explicit coverage; the
+// function_call path is covered by the openai-compat Responses test.
+
+import { customToolCallFromResponseItem } from '../src/runtime/agent/orchestrator/providers/custom-tool-wire.mjs';
+import { parseToolSearchArgs } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+
+test('openai-oauth (shared custom-tool-wire): custom_tool_call item → canonical call', () => {
+    const item = { type: 'custom_tool_call', call_id: 'ctc_1', name: 'apply_patch', input: '*** patch ***' };
+    const call = customToolCallFromResponseItem(item);
+    assert.equal(call.id, 'ctc_1');
+    assert.equal(call.name, 'apply_patch');
+    assert.deepEqual(call.arguments, { patch: '*** patch ***' });
+    assert.equal(call.nativeType, 'custom_tool_call');
+});
+
+test('openai-oauth (shared custom-tool-wire): non custom_tool_call → null', () => {
+    assert.equal(customToolCallFromResponseItem({ type: 'function_call' }), null);
+    assert.equal(customToolCallFromResponseItem(null), null);
+});
+
+// WS tool_search_call.arguments parse policy (parseToolSearchArgs, module-scope
+// export of openai-oauth-ws.mjs). Native convergence: malformed non-empty JSON
+// becomes an invalid-args marker so the dispatch loop blocks execution and
+// returns an is_error tool_result — NOT a silent {} that would dispatch
+// tool_search with empty arguments. Empty/whitespace/object inputs keep their
+// prior, correct behavior.
+test('openai-oauth-ws (tool_search): malformed args string → invalid-args marker (not {})', () => {
+    const out = parseToolSearchArgs('{"query": dispatchAiWrapped}');
+    assert.equal(isInvalidToolArgsMarker(out), true);
+    assert.equal(out.__invalidToolArgs, true);
+    assert.equal(out.__rawArguments, '{"query": dispatchAiWrapped}');
+    assert.equal(typeof out.__parseError, 'string');
+    assert.ok(out.__parseError.length > 0);
+});
+
+test('openai-oauth-ws (tool_search): valid args / object / empty preserved', () => {
+    // valid JSON string → parsed object
+    assert.deepEqual(parseToolSearchArgs('{"query":"x"}'), { query: 'x' });
+    // already an object → passthrough
+    const obj = { query: 'y' };
+    assert.equal(parseToolSearchArgs(obj), obj);
+    // empty / whitespace / null / non-string → {} (no args, not a marker)
+    assert.deepEqual(parseToolSearchArgs(''), {});
+    assert.deepEqual(parseToolSearchArgs('   '), {});
+    assert.deepEqual(parseToolSearchArgs(null), {});
+    assert.deepEqual(parseToolSearchArgs(undefined), {});
+    assert.equal(isInvalidToolArgsMarker(parseToolSearchArgs('')), false);
+});
+
+// === 5. grok-oauth =========================================================
+// grok-oauth has NO independent tool_call parser. GrokOAuthProvider delegates
+// all request shaping AND response parsing to an inner OpenAICompatProvider
+// constructed as `new OpenAICompatProvider('xai', ...)` (grok-oauth.mjs:668).
+// Its tool_call extraction therefore goes through the exact
+// parseToolCalls / parseResponsesToolCalls already asserted in block 1 — no
+// duplicate test. (Documented as shared in the report.)

package/scripts/reactive-compact-persist-smoke.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { estimateMessagesTokens } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import { SUMMARY_PREFIX } from '../src/runtime/agent/orchestrator/session/compact.mjs';
+
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+process.env.MIXDOG_DATA_DIR = mkdtempSync(join(tmpdir(), 'mixdog-reactive-compact-persist-'));
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+const { saveSessionAsync, loadSession } = await import('../src/runtime/agent/orchestrator/session/store.mjs');
+
+await initProviders({ 'openai-oauth': { enabled: true } });
+const provider = getProvider('openai-oauth');
+if (!provider || typeof provider.send !== 'function') {
+  process.stdout.write('reactive-compact-persist smoke skipped (openai-oauth unavailable)\n');
+  process.exit(0);
+}
+
+let mainSendCount = 0;
+let compactSendCount = 0;
+provider.send = async (_sentMessages, _model, _tools, opts = {}) => {
+  if (String(opts?.sessionId || '').endsWith(':compact')) {
+    compactSendCount += 1;
+    return {
+      content: [
+        '## Goal',
+        '- continue reactive persist smoke',
+        '',
+        '## Constraints & Preferences',
+        '- (none)',
+        '',
+        '## Progress',
+        '### Done',
+        '- older turn summarized',
+        '',
+        '### In Progress',
+        '- (none)',
+        '',
+        '### Blocked',
+        '- (none)',
+        '',
+        '## Key Decisions',
+        '- (none)',
+        '',
+        '## Next Steps',
+        '- continue',
+        '',
+        '## Critical Context',
+        '- manager.mjs',
+        '',
+        '## Relevant Files',
+        '- src/runtime/agent/orchestrator/session/manager.mjs: askSession overflow persist',
+      ].join('\n'),
+    };
+  }
+  mainSendCount += 1;
+  throw new Error('input tokens exceeds the context window');
+};
+
+const messages = [{ role: 'system', content: 'system rules stay mandatory' }];
+let overflowIndex = 0;
+while (estimateMessagesTokens(messages) + 512 < 8_800) {
+  messages.push({ role: 'user', content: `older overflow request ${overflowIndex}: ${'important detail '.repeat(90)}` });
+  messages.push({ role: 'assistant', content: `older overflow answer ${overflowIndex}: ${'implementation note '.repeat(90)}` });
+  overflowIndex += 1;
+}
+
+const sessionId = `sess_reactive_compact_persist_${process.pid}_${Date.now()}`;
+const session = {
+  id: sessionId,
+  provider: 'openai-oauth',
+  model: 'reactive-compact-persist-smoke',
+  messages,
+  tools: [],
+  generation: 0,
+  closed: false,
+  contextWindow: 12_000,
+  rawContextWindow: 12_000,
+  compactBoundaryTokens: 12_000,
+  compaction: { auto: true, semantic: true, type: 1, compactType: 1, lastStage: 'compacting' },
+  cwd: process.cwd(),
+  sessionStartMetaInjected: true,
+  providerState: { xaiResponses: { previousResponseId: 'stale-after-compact' } },
+};
+await saveSessionAsync(session, { expectedGeneration: 0 });
+const beforeCount = messages.length;
+
+const { askSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+
+let threw = false;
+let thrownCode = null;
+try {
+  await askSession(sessionId, 'current overflow task must stay verbatim', null, null, process.cwd());
+} catch (err) {
+  threw = true;
+  thrownCode = err?.code || null;
+}
+
+assert(threw, 'askSession should surface overflow error');
+assert(thrownCode === 'AGENT_CONTEXT_OVERFLOW', `expected AGENT_CONTEXT_OVERFLOW, got ${thrownCode}`);
+assert(mainSendCount === 2, `expected 2 main sends after reactive retry, got ${mainSendCount}`);
+assert(compactSendCount === 1, `expected 1 compact send, got ${compactSendCount}`);
+
+const reloaded = loadSession(sessionId);
+assert(reloaded, 'session should reload from store after overflow');
+assert((reloaded.messages || []).length < beforeCount + 1, 'persisted transcript should reflect compaction shrink');
+const summary = (reloaded.messages || []).find(
+  (m) => m?.role === 'user' && typeof m.content === 'string' && m.content.startsWith(SUMMARY_PREFIX),
+);
+assert(summary, 'compacted transcript with SUMMARY_PREFIX should persist after overflow error');
+assert(
+  (reloaded.messages || []).some((m) => m?.role === 'user' && String(m.content).includes('current overflow task must stay verbatim')),
+  'current user turn should remain in persisted transcript',
+);
+assert(reloaded.compaction?.lastStage !== 'compacting', 'compaction lastStage should not remain stuck on compacting');
+assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact persist');
+
+process.stdout.write('reactive-compact-persist smoke passed ✓\n');