mixdog 0.9.36 → 0.9.37

package/scripts/output-style-smoke.mjs

@@ -13,7 +13,7 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-const DEFAULT_REPORT_LABELS = new Set(['바뀐 점', '확인한 것', '남은 리스크/다음 단계', '다음 단계']);
+const DEFAULT_REPORT_LABELS = new Set(['\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
 
 function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedLabels = new Set() } = {}) {
   const text = String(value || '').trim();
@@ -28,7 +28,7 @@ function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedL
   }
   assert(!/\b(?:tool trace|session metadata|model metadata|searched-path list)\b/i.test(text), `${name}: tool/meta trace found`);
   assert(!/\b(?:Mapped|Searched|Read|Called) for \d/i.test(text), `${name}: timing/tool status found`);
-  assert(!/^(?:네|예|맞아요|좋아요|알겠습니다|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
+  assert(!/^(?:\uB124|\uC608|\uB9DE\uC544\uC694|\uC88B\uC544\uC694|\uC54C\uACA0\uC2B5\uB2C8\uB2E4|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
   assert(!/(.+)(?:\n|\s{2,})\1/.test(text), `${name}: repeated conclusion found`);
 
   const lines = text.split(/\r?\n/).filter((line) => line.trim());
@@ -41,7 +41,7 @@ function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedL
   assert(lines.length <= maxLines, `${name}: too many lines`);
 
   const withoutCode = text.replace(/`[^`]*`/g, '');
-  const sentenceMarks = withoutCode.match(/[.!?。！？]|다\.|요\./g) || [];
+  const sentenceMarks = withoutCode.match(/[.!?。！？]|\uB2E4\.|\uC694\./g) || [];
   assert(sentenceMarks.length <= 2, `${name}: too many sentences`);
 }
 
@@ -52,7 +52,7 @@ for (const required of [
   'Mixdog default — the most detailed style',
   'State conclusions, not reasoning',
   'Use labels such as',
-  '`바뀐 점`, `확인한 것`,',
+  '`\uBC14\uB010 \uC810`, `\uD655\uC778\uD55C \uAC83`,',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
 ]) {
@@ -97,7 +97,7 @@ try {
 
   mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
   writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
-    agent: { profile: { title: '홍길동님', language: 'system' } },
+    agent: { profile: { title: '\uD64D\uAE38\uB3D9\uB2D8', language: 'system' } },
     outputStyle: 'custom-smoke',
   }));
   writeFileSync(join(dataDir, 'output-styles', 'custom-smoke.md'), '---\nname: custom-smoke\n---\n\n# Custom Output Style\n\ncustom smoke style\n');
@@ -105,7 +105,7 @@ try {
   assert(customRules.includes('# Custom Output Style'), 'configured outputStyle must select custom style');
   assert(!customRules.includes('Mixdog default — the most detailed of the three styles'), 'custom outputStyle should not append default style');
   const profileMeta = rulesBuilder.buildLeadMetaContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
-  assert(profileMeta.includes('Use "홍길동님" when directly addressing the user'), 'profile title must inject into Lead BP3 meta');
+  assert(profileMeta.includes('Use "\uD64D\uAE38\uB3D9\uB2D8" when directly addressing the user'), 'profile title must inject into Lead BP3 meta');
   assert(profileMeta.includes('do not repeat it in routine progress updates or pre-tool preambles'), 'profile title must not encourage title in preambles');
   assert(/Default user-facing response language from system locale/.test(profileMeta), 'system profile language must resolve from system locale');
   assert(profileMeta.includes('pre-tool preambles (even single-line)'), 'profile language must cover pre-tool preambles');
@@ -115,26 +115,26 @@ try {
 
 // assertCleanOutput encodes the Simple style compact contract (not Default, which may be longer).
 const goodOutputs = {
-  explanation: 'Simple 스타일은 결과 한 줄과 근거 한 가지로 끝내고, 최종 handoff만 짧은 bullet 라벨을 씁니다.',
-  implementation: '- 바뀐 점: `scripts/output-style-smoke.mjs`의 default/simple 문자열 검증을 현재 프리셋에 맞췄습니다.\n- 확인한 것: `node scripts/output-style-smoke.mjs`를 실행했습니다.',
-  crowded: '- 바뀐 점: compact guardrail은 Simple handoff용 controlled detail을 검증합니다.\n- 확인한 것: bad 샘플 거부 규칙은 그대로입니다.',
-  blocker: '`scripts/output-style-smoke.mjs`를 찾을 수 없어 변경이 막혔습니다.',
-  semicolon: '스모크 스크립트를 갱신했고; Simple 계약에 맞는 예시 응답만 통과합니다.',
+  explanation: 'Simple \uC2A4\uD0C0\uC77C\uC740 \uACB0\uACFC \uD55C \uC904\uACFC \uADFC\uAC70 \uD55C \uAC00\uC9C0\uB85C \uB05D\uB0B4\uACE0, \uCD5C\uC885 handoff\uB9CC \uC9E7\uC740 bullet \uB77C\uBCA8\uC744 \uC501\uB2C8\uB2E4.',
+  implementation: '- \uBC14\uB010 \uC810: `scripts/output-style-smoke.mjs`\uC758 default/simple \uBB38\uC790\uC5F4 \uAC80\uC99D\uC744 \uD604\uC7AC \uD504\uB9AC\uC14B\uC5D0 \uB9DE\uCDC4\uC2B5\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: `node scripts/output-style-smoke.mjs`\uB97C \uC2E4\uD589\uD588\uC2B5\uB2C8\uB2E4.',
+  crowded: '- \uBC14\uB010 \uC810: compact guardrail\uC740 Simple handoff\uC6A9 controlled detail\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: bad \uC0D8\uD50C \uAC70\uBD80 \uADDC\uCE59\uC740 \uADF8\uB300\uB85C\uC785\uB2C8\uB2E4.',
+  blocker: '`scripts/output-style-smoke.mjs`\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC5B4 \uBCC0\uACBD\uC774 \uB9C9\uD614\uC2B5\uB2C8\uB2E4.',
+  semicolon: '\uC2A4\uBAA8\uD06C \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uAC31\uC2E0\uD588\uACE0; Simple \uACC4\uC57D\uC5D0 \uB9DE\uB294 \uC608\uC2DC \uC751\uB2F5\uB9CC \uD1B5\uACFC\uD569\uB2C8\uB2E4.',
 };
 for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output, { allowedLabels: DEFAULT_REPORT_LABELS });
 
 const badOutputs = {
   heading: '## Summary\nDone.',
   label: 'Changed: updated default style.',
-  koreanLabel: '변경: default 스타일을 수정했습니다.\n검증: 스모크를 통과했습니다.',
+  koreanLabel: '\uBCC0\uACBD: default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n\uAC80\uC99D: \uC2A4\uBAA8\uD06C\uB97C \uD1B5\uACFC\uD588\uC2B5\uB2C8\uB2E4.',
   numbered: '1. Updated style\n2. Ran smoke',
   paragraphs: 'Done.\n\nDone again.',
   nested: '- Updated\n  - Nested detail',
-  ack: '네, default 스타일을 수정했습니다.',
-  timing: 'Mapped for 2m 32s\n\ndefault 스타일을 수정했습니다.',
-  tooManySentences: '수정했습니다. 검증했습니다. 보고했습니다.',
-  mixed: '수정했습니다.\n- 검증했습니다.',
-  tooManyBullets: '- 바뀐 점: A\n- 확인한 것: B\n- 다음 단계: C\n- 남은 리스크/다음 단계: D',
+  ack: '\uB124, default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
+  timing: 'Mapped for 2m 32s\n\ndefault \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
+  tooManySentences: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4. \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4. \uBCF4\uACE0\uD588\uC2B5\uB2C8\uB2E4.',
+  mixed: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n- \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4.',
+  tooManyBullets: '- \uBC14\uB010 \uC810: A\n- \uD655\uC778\uD55C \uAC83: B\n- \uB2E4\uC74C \uB2E8\uACC4: C\n- \uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4: D',
 };
 for (const [name, output] of Object.entries(badOutputs)) {
   let failed = false;

package/scripts/provider-toolcall-test.mjs

@@ -62,6 +62,8 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/anthropic-effort.mjs';
 import { buildAnthropicBetaHeaders } from '../src/runtime/agent/orchestrator/providers/anthropic-betas.mjs';
 import { PATCH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs';
+import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import { buildRequestBody as buildOpenAIOAuthRequestBody } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 
 // --- Helpers ---------------------------------------------------------------
 
@@ -100,6 +102,33 @@ function compatResponsesEventStream(events) {
     };
 }
 
+// Minimal 200-OK Response-like shape for the HTTP/SSE Responses path: frames
+// each event as `event:<type>\ndata:<json>\n\n`, delivered synchronously so the
+// semantic-idle watchdog never arms during the test.
+function httpSseResponse(events) {
+    const encoder = new TextEncoder();
+    const chunks = events.map((e) => encoder.encode(`event: ${e.type}\ndata: ${JSON.stringify(e)}\n\n`));
+    let i = 0;
+    return {
+        status: 200,
+        ok: true,
+        headers: new Map(),
+        body: {
+            getReader() {
+                return {
+                    read() {
+                        return i < chunks.length
+                            ? Promise.resolve({ done: false, value: chunks[i++] })
+                            : Promise.resolve({ done: true, value: undefined });
+                    },
+                    cancel() { return Promise.resolve(); },
+                    releaseLock() {},
+                };
+            },
+        },
+    };
+}
+
 // === 1. openai-compat ======================================================
 // Chat path:      parseToolCalls(choice, label)         openai-compat.mjs:957
 // Responses path: parseResponsesToolCalls(response,...) openai-compat.mjs:972
@@ -220,6 +249,126 @@ test('openai-compat/xai Responses stream: response.completed salvages deferred f
     assert.deepEqual(captured, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
 });
 
+// Missing-terminal + partial-tool gate (shared tool-stream-state.mjs tracker):
+// a Responses stream that streams a CUSTOM tool call's input then truncates
+// before response.output_item.done / response.completed. The call never lands
+// in pendingCalls or toolCalls, so the truncation error must be gated as
+// pendingToolUse via the shared active tool-item tracker (activeToolItems),
+// NOT accepted as a text-only partial-final that would drop the in-flight tool.
+test('openai-compat/xai Responses stream: mid custom-tool-input truncation is gated pendingToolUse via shared tracker', async () => {
+    const rejected = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_ct', model: 'grok' } },
+        { type: 'response.output_text.delta', delta: 'partial ' },
+        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_item_1' } },
+        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_item_1', delta: '{"x":' },
+        // stream truncates here: no output_item.done, no response.completed.
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+        onTextDelta: () => {},
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated stream to reject');
+    assert.equal(rejected.streamStalled, true);
+    // The in-flight custom tool must gate partial-final success even though it
+    // never reached pendingCalls/toolCalls — the active tracker carries it.
+    assert.equal(rejected.pendingToolUse, true);
+    assert.equal(rejected.partialContent, 'partial ');
+});
+
+// Precision half of the same tracker: once the tool call fully COMPLETES
+// (output_item.done clears the active item) and text keeps streaming, a later
+// truncation is a plain text-only partial — the tracker having been cleared is
+// what lets pendingToolUse fall back to the real emit/pending state.
+test('openai-compat/xai Responses stream: completed tool then trailing-text truncation clears active tracker', async () => {
+    let emitted = 0;
+    const rejected = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_done', model: 'grok' } },
+        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_done_1' } },
+        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_done_1', delta: '{"x":1}' },
+        { type: 'response.output_item.done', item: { type: 'custom_tool_call', id: 'ct_done_1', name: 'load_tool', input: '{"x":1}' } },
+        { type: 'response.output_text.delta', delta: 'after tool ' },
+        // truncates before response.completed.
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+        onTextDelta: () => {},
+        onToolCall: () => { emitted += 1; },
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated stream to reject');
+    assert.equal(rejected.streamStalled, true);
+    // A tool WAS emitted this turn, so the turn is still unsafe/tool-bearing —
+    // pendingToolUse stays true off the emit state, not a stale active latch.
+    assert.ok(emitted >= 1);
+    assert.equal(rejected.pendingToolUse, true);
+});
+
+// Reviewer fix: function output_item.done must delete the pendingCalls itemId
+// before recomputing toolInFlight — otherwise a fully-completed function call
+// keeps pendingCalls.size > 0 forever, and a later max-output cutoff on trailing
+// text is misclassified as a truncated tool-in-flight stall instead of a clean
+// length completion.
+test('openai-compat/xai Responses stream: completed function call clears pendingCalls so max-output cutoff is clean length', async () => {
+    const out = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_len', model: 'grok' } },
+        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_len', name: 'read', call_id: 'fc_len' } },
+        { type: 'response.function_call_arguments.done', item_id: 'fi_len', arguments: '{"path":"a"}' },
+        { type: 'response.output_item.done', item: { type: 'function_call', id: 'fi_len', call_id: 'fc_len', name: 'read', arguments: '{"path":"a"}' } },
+        { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+    });
+    // The completed call drained pendingCalls + the active tracker, so the
+    // max-output cutoff is a clean length truncation (no in-flight-tool stall).
+    assert.equal(out.stopReason, 'length');
+    assert.deepEqual(out.toolCalls, [{ id: 'fc_len', name: 'read', arguments: { path: 'a' } }]);
+});
+
+// Reviewer fix (HTTP/SSE): a max_output_tokens cutoff while a function call is
+// still in flight (added + partial args, no output_item.done) must NOT mark a
+// clean length completion — the tool arguments were truncated. Mirror compat:
+// throw a stream-stalled pendingToolUse error so the loop gates/retries.
+test('openai-oauth HTTP/SSE Responses: max-output cutoff with function call in flight → stream-stalled pendingToolUse', async () => {
+    const rejected = await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'k' },
+        body: { model: 'gpt', tools: [] },
+        useModel: 'gpt',
+        fetchFn: async () => httpSseResponse([
+            { type: 'response.created', response: { id: 'r', model: 'gpt' } },
+            { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_1', name: 'read', call_id: 'fc_1' } },
+            { type: 'response.function_call_arguments.delta', item_id: 'fi_1', delta: '{"path":' },
+            { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+        ]),
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated-tool cutoff to reject');
+    assert.equal(rejected.streamStalled, true);
+    assert.equal(rejected.pendingToolUse, true);
+});
+
+// Reviewer fix (HTTP/SSE): function output_item.done must delete pendingCalls[id]
+// before recomputing _toolInFlight — otherwise the completed call keeps
+// pendingCalls.size > 0 and a later max-output cutoff is misread as a truncated
+// tool. A fully-completed call before the cutoff must be a clean length result.
+test('openai-oauth HTTP/SSE Responses: completed function call clears pendingCalls so max-output cutoff is clean length', async () => {
+    const out = await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'k' },
+        body: { model: 'gpt', tools: [] },
+        useModel: 'gpt',
+        fetchFn: async () => httpSseResponse([
+            { type: 'response.created', response: { id: 'r', model: 'gpt' } },
+            { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_1', name: 'read', call_id: 'fc_1' } },
+            { type: 'response.function_call_arguments.done', item_id: 'fi_1', arguments: '{"path":"a"}' },
+            { type: 'response.output_item.done', item: { type: 'function_call', id: 'fi_1', call_id: 'fc_1', name: 'read', arguments: '{"path":"a"}' } },
+            { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+        ]),
+    });
+    assert.equal(out.stopReason, 'length');
+    assert.deepEqual(out.toolCalls, [{ 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');
@@ -229,6 +378,135 @@ test('openai-compat/xai Responses: freeform apply_patch downgrades to function s
     assert.deepEqual(patch.parameters?.required, ['patch']);
 });
 
+test('openai-compat/xai Responses: load_tool downgrades from tool_search to function schema', () => {
+    const loadTool = {
+        name: 'load_tool',
+        description: 'load tools',
+        inputSchema: {
+            type: 'object',
+            properties: { names: { type: 'array', items: { type: 'string' } } },
+        },
+    };
+    const [xaiTool] = _toResponsesToolsForTest([loadTool], { provider: 'xai' });
+    assert.equal(xaiTool.type, 'function');
+    assert.equal(xaiTool.name, 'load_tool');
+    assert.equal(xaiTool.execution, undefined);
+    assert.equal(xaiTool.parameters, loadTool.inputSchema);
+
+    const [openaiTool] = _toResponsesToolsForTest([loadTool], { provider: 'openai' });
+    assert.equal(openaiTool.type, 'tool_search');
+    assert.equal(openaiTool.execution, 'client');
+    assert.equal(openaiTool.name, undefined);
+});
+
+test('openai-compat/xai Responses: load_tool history replays as function_call', () => {
+    const { input } = _toXaiResponsesInputForTest([
+        { role: 'user', content: 'load a tool' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'load_tool', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'call_load_1',
+            content: '{}',
+            nativeToolSearch: { openaiTools: [{ name: 'read' }] },
+        },
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_same',
+            seenMessageCount: 0,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(input.some((item) => item.type === 'tool_search_call'), false);
+    assert.equal(input.some((item) => item.type === 'tool_search_output'), false);
+    const call = input.find((item) => item.type === 'function_call' && item.name === 'load_tool');
+    assert.equal(call.call_id, 'call_load_1');
+    assert.deepEqual(JSON.parse(call.arguments), { names: ['read'] });
+    assert.equal(input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
+});
+
+test('openai-compat/xai Responses: model switch drops prior tool transcript history', () => {
+    const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'before switch' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'load_tool', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'call_load_1', content: '{"loaded":["read"]}' },
+        { role: 'user', content: 'after switch' },
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_old',
+            seenMessageCount: 4,
+            model: 'grok-4.20',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(continuationResetReason, 'model_changed');
+    const serialized = JSON.stringify(input);
+    assert.equal(serialized.includes('tool_search'), false);
+    assert.equal(serialized.includes('function_call'), false);
+    assert.equal(serialized.includes('function_call_output'), false);
+    assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
+});
+
+test('openai-compat/xai Responses: first Grok request after provider switch drops prior tool transcript history', () => {
+    const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'before switch' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_patch_1', name: 'apply_patch', arguments: { patch: '*** Begin Patch\n*** End Patch\n' } }],
+        },
+        { role: 'tool', toolCallId: 'call_patch_1', content: 'OK' },
+        { role: 'user', content: 'after switch' },
+    ], {}, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(continuationResetReason, null);
+    const serialized = JSON.stringify(input);
+    assert.equal(serialized.includes('function_call'), false);
+    assert.equal(serialized.includes('function_call_output'), false);
+    assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
+});
+
+test('openai-oauth Responses: load_tool schema and history stay function_call', () => {
+    const loadTool = {
+        name: 'load_tool',
+        description: 'load tools',
+        inputSchema: {
+            type: 'object',
+            properties: { names: { type: 'array', items: { type: 'string' } } },
+        },
+    };
+    const body = buildOpenAIOAuthRequestBody([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'load a tool' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'tool_search', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'call_load_1', content: '{}' },
+    ], 'gpt-5.5', [loadTool], {});
+    assert.equal(JSON.stringify(body).includes('tool_search'), false);
+    assert.deepEqual(body.tools?.[0], {
+        type: 'function',
+        name: 'load_tool',
+        description: loadTool.description,
+        parameters: loadTool.inputSchema,
+    });
+    const call = body.input.find((item) => item.type === 'function_call' && item.name === 'load_tool');
+    assert.equal(call.call_id, 'call_load_1');
+    assert.deepEqual(JSON.parse(call.arguments), { names: ['read'] });
+    assert.equal(body.input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
+});
+
 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([
@@ -239,7 +517,13 @@ test('openai-compat/xai Responses: custom_tool_call history replays as function_
             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' });
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_same',
+            seenMessageCount: 0,
+            model: 'grok-composer-2.5-fast',
+        },
+    }, { 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');
@@ -1092,6 +1376,35 @@ test('anthropic effort: sonnet-4-6 uses output_config + effort beta, not thinkin
     assert.ok(beta.includes(EFFORT_BETA_HEADER));
 });
 
+test('anthropic-oauth: load_tool native references replay as ordinary tool_result after model switches', () => {
+    const body = _buildRequestBodyForCacheSmoke(
+        [
+            { role: 'user', content: 'load a tool' },
+            {
+                role: 'assistant',
+                content: '',
+                toolCalls: [{ id: 'toolu_load_1', name: 'load_tool', arguments: { names: ['read'] } }],
+            },
+            {
+                role: 'tool',
+                toolCallId: 'toolu_load_1',
+                content: '{"loaded":["read"]}',
+                nativeToolSearch: { toolReferences: ['read'] },
+            },
+        ],
+        'claude-opus-4-8',
+        [],
+        { effort: 'high' },
+    );
+    const serialized = JSON.stringify(body.messages);
+    assert.equal(serialized.includes('tool_reference'), false);
+    const toolResult = body.messages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block?.type === 'tool_result' && block.tool_use_id === 'toolu_load_1');
+    assert.ok(toolResult);
+    assert.equal(toolResult.content, '{"loaded":["read"]}');
+});
+
 test('anthropic effort: legacy sonnet-4-5 maps effort to thinking budget', () => {
     const model = 'claude-sonnet-4-5-20250514';
     const body = _buildRequestBodyForCacheSmoke(
@@ -1270,7 +1583,7 @@ test('canonical frame: full-frame builder leads with type and preserves codex bo
     assert.equal(frame.previous_response_id, undefined);
 });
 
-test('canonical frame: delta insert keeps key order, drops empty instructions, overrides input', () => {
+test('canonical frame: delta insert keeps key order, drops chained instructions, overrides input', () => {
     const body = {
         model: 'gpt-5.5',
         instructions: 'sys',
@@ -1279,10 +1592,11 @@ test('canonical frame: delta insert keeps key order, drops empty instructions, o
         text: { verbosity: 'low' },
     };
     const delta = _buildResponseCreateFrame(body, { previousResponseId: 'resp_prev', inputOverride: [{ b: 2 }] });
-    assert.deepEqual(Object.keys(delta), ['type', 'model', 'instructions', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.deepEqual(Object.keys(delta), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.equal(delta.instructions, undefined);
     assert.equal(delta.previous_response_id, 'resp_prev');
     assert.deepEqual(delta.input, [{ b: 2 }]);
-    // Empty instructions is dropped in delta mode (server resolves via prev id).
+    // Empty instructions is also dropped in delta mode (server resolves via prev id).
     const noInstr = _buildResponseCreateFrame({ ...body, instructions: '' }, { previousResponseId: 'resp_prev', inputOverride: [] });
     assert.deepEqual(Object.keys(noInstr), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
 });
@@ -1328,11 +1642,11 @@ import {
     FULL_RESPONSES_TRANSPORT_CAPS,
 } from '../src/runtime/agent/orchestrator/providers/openai-transport-policy.mjs';
 
-test('transport policy: default (no env) is ws-delta / refs continuation ON', () => {
+test('transport policy: default (no env) is auto WS-first / refs continuation ON / HTTP fallback ON', () => {
     const p = resolveOpenAiTransportPolicy({});
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
-    assert.equal(p.allowHttpFallback, false);
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
@@ -1364,10 +1678,11 @@ test('transport policy: http-sse forces the HTTP transport with delta OFF', () =
     assert.equal(p.delta.optIn, false);
 });
 
-test('transport policy: unknown MIXDOG_OAI_TRANSPORT falls back to default ws-delta', () => {
+test('transport policy: unknown MIXDOG_OAI_TRANSPORT falls back to default auto', () => {
     const p = resolveOpenAiTransportPolicy({ MIXDOG_OAI_TRANSPORT: 'quantum' });
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
+    assert.equal(p.allowHttpFallback, true);
 });
 
 test('response frame builder can omit transport-only stream/background for codex warmup parity', () => {
@@ -1383,7 +1698,7 @@ test('transport policy: mode token aliases normalize', () => {
     assert.equal(_normalizeTransportMode('  ws delta '), 'ws-delta');
     assert.equal(_normalizeTransportMode('http/sse'), 'http-sse');
     assert.equal(_normalizeTransportMode('sse'), 'http-sse');
-    assert.equal(_normalizeTransportMode('auto'), 'ws-delta');
+    assert.equal(_normalizeTransportMode('auto'), 'auto');
     assert.equal(_normalizeTransportMode('official'), null);
     assert.equal(_normalizeTransportMode(''), null);
     assert.equal(_normalizeTransportMode('bogus'), null);
@@ -1472,17 +1787,19 @@ test('responses transport policy: openai direct caps match oauth (both full)', (
     assert.deepEqual(direct.delta, { force: false, refs: true, optIn: true });
 });
 
-test('responses transport policy: xai auto defers (transport=auto, delta OFF, no http fallback)', () => {
+test('responses transport policy: xai auto is WS-first with HTTP fallback', () => {
     const p = resolveResponsesTransportPolicy({}, RESPONSES_TRANSPORT_CAPABILITIES.xai);
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
-    assert.equal(p.allowHttpFallback, false);
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
-test('responses transport policy: explicit auto is a ws-delta compatibility spelling', () => {
+test('responses transport policy: explicit auto is WS-first with HTTP fallback', () => {
     const p = resolveResponsesTransportPolicy({ MIXDOG_OAI_TRANSPORT: 'auto' }, RESPONSES_TRANSPORT_CAPABILITIES.xai);
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
@@ -1570,11 +1887,13 @@ test('grok-oauth: all Grok models inherit global transport; explicit setting is
 test('responses transport policy: _gateTransportMode down-shifts per capability', () => {
     // delta unsupported → ws-delta collapses to ws-full; others pass through.
     const noDelta = { ws: true, http: true, delta: false };
+    assert.equal(_gateTransportMode('auto', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('ws-delta', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('ws-full', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('http-sse', noDelta), 'http-sse');
     // WS unsupported → WS modes prefer HTTP.
     const httpOnly = { ws: false, http: true, delta: false };
+    assert.equal(_gateTransportMode('auto', httpOnly), 'http-sse');
     assert.equal(_gateTransportMode('ws-full', httpOnly), 'http-sse');
     assert.equal(_gateTransportMode('ws-delta', httpOnly), 'http-sse');
     // HTTP unsupported → http-sse prefers full-frame WS.

package/scripts/recall-bench-cases.json

@@ -4,8 +4,8 @@
   { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
   { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "limit": 10 }, "expect": "browse" },
   { "id": "scope-all", "label": "all-scope query", "args": { "query": "recall", "projectScope": "all", "limit": 10 }, "expect": "results" },
-  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "드라이런 델타 합산", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["드라이런"], "topN": 5 } },
-  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote 싱글톤 좌석", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["싱글톤"], "topN": 5 } },
-  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "오늘 진행한 작업", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
+  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "\uB4DC\uB77C\uC774\uB7F0 \uB378\uD0C0 \uD569\uC0B0", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uB4DC\uB77C\uC774\uB7F0"], "topN": 5 } },
+  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote \uC2F1\uAE00\uD1A4 \uC88C\uC11D", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uC2F1\uAE00\uD1A4"], "topN": 5 } },
+  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "\uC624\uB298 \uC9C4\uD589\uD55C \uC791\uC5C5", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
   { "id": "xlang-embedding-crash", "label": "cross-language: embedding worker crash (strict topN)", "args": { "query": "embedding worker crash", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["embedding"], "topN": 3 } }
 ]

package/scripts/recall-bench.mjs

@@ -31,7 +31,7 @@ function hasFlag(name) { return process.argv.includes(`--${name}`); }
 const WARN_LATENCY_MS = 3000;
 
 const DEFAULT_CASES = [
-  { id: 'kw-ko', label: 'keyword query (ko)', args: { query: '메모리 재현' }, expect: 'results' },
+  { id: 'kw-ko', label: 'keyword query (ko)', args: { query: '\uBA54\uBAA8\uB9AC \uC7AC\uD604' }, expect: 'results' },
   { id: 'kw-en', label: 'keyword query (en)', args: { query: 'memory recall pipeline' }, expect: 'results' },
   { id: 'short-1tok', label: 'short 1-token query', args: { query: 'recall' }, expect: 'results' },
   { id: 'short-2tok', label: 'short 2-token query', args: { query: 'cycle1 drain' }, expect: 'results' },

package/scripts/recall-quality-cases.json

@@ -1,11 +1,11 @@
 [
-  { "id": "q-kr-recall-phrase", "label": "Korean distinctive phrase: persistent memory", "args": { "query": "영속 메모리" }, "expect": { "kind": "results", "topNContains": ["영속 메모리"], "topN": 5 } },
+  { "id": "q-kr-recall-phrase", "label": "Korean distinctive phrase: persistent memory", "args": { "query": "\uC601\uC18D \uBA54\uBAA8\uB9AC" }, "expect": { "kind": "results", "topNContains": ["\uC601\uC18D \uBA54\uBAA8\uB9AC"], "topN": 5 } },
   { "id": "q-en-recall-pipeline", "label": "English distinctive phrase: recall fast-track builder", "args": { "query": "buildRecallFastTrackQuery" }, "expect": { "kind": "results", "topNContains": ["buildRecallFastTrackQuery"], "topN": 5 } },
   { "id": "q-cycle1-drain", "label": "cycle1 ECONNRESET topic", "args": { "query": "cycle1 ECONNRESET" }, "expect": { "kind": "results", "topNContains": ["cycle1", "ECONNRESET"], "topN": 5 } },
   { "id": "q-recall-general", "label": "bare recall keyword", "args": { "query": "recall" }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } },
-  { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "캐시 개선" }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["캐시 개선", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "recall"], "topN": 10 } },
+  { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last \uAC1C\uC120", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120"], "topN": 5 } },
+  { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "\uCE90\uC2DC \uAC1C\uC120" }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120"], "topN": 5 } },
+  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["\uCE90\uC2DC \uAC1C\uC120", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120", "recall"], "topN": 10 } },
   { "id": "q-short-2tok-cycle", "label": "short 2-token cycle1 query", "args": { "query": "cycle1 drain", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["cycle1"], "topN": 3 } },
   { "id": "q-recall-scope-project", "label": "project-scoped recall query", "args": { "query": "recall", "cwd": "C:\\Project\\mixdog" , "limit": 10 }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } }
 ]

package/scripts/recall-usecase-cases.json

@@ -8,10 +8,10 @@
   { "id": "uc3-tod-dated", "label": "UC3 dated time window 2026-07-03 09:00~12:00", "args": { "period": "2026-07-03 09:00~12:00", "limit": 10 }, "expect": "browse" },
   { "id": "uc3-date", "label": "UC3 specific date 2026-07-02", "args": { "period": "2026-07-02", "limit": 10 }, "expect": "browse" },
   { "id": "uc3-range", "label": "UC3 date range 2026-07-01~2026-07-03", "args": { "period": "2026-07-01~2026-07-03", "limit": 10 }, "expect": "browse" },
-  { "id": "uc4-topic", "label": "UC4 topic query", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": "results" },
+  { "id": "uc4-topic", "label": "UC4 topic query", "args": { "query": "recall period last \uAC1C\uC120", "limit": 8 }, "expect": "results" },
   { "id": "uc4-topic-time", "label": "UC4 topic + time window", "args": { "query": "recall", "period": "24h", "limit": 8 }, "expect": "results" },
   { "id": "uc4-topic-tod", "label": "UC4 topic + time-of-day", "args": { "query": "recall", "period": "12:00~15:00", "limit": 8 }, "expect": "results" },
-  { "id": "uc4-fanout", "label": "UC4 fan-out array query", "args": { "query": ["recall 개선", "battle balance"], "limit": 5 }, "expect": "results" },
+  { "id": "uc4-fanout", "label": "UC4 fan-out array query", "args": { "query": ["recall \uAC1C\uC120", "battle balance"], "limit": 5 }, "expect": "results" },
   { "id": "uc5-yesterday", "label": "UC5 calendar yesterday", "args": { "period": "yesterday", "limit": 10 }, "expect": "browse" },
   { "id": "uc5-thisweek", "label": "UC5 calendar this_week", "args": { "period": "this_week", "limit": 10 }, "expect": "browse" },
   { "id": "uc6-category", "label": "UC6 category decision 7d", "args": { "period": "7d", "category": "decision", "limit": 10 }, "expect": "browse" }