mixdog 0.9.46 → 0.9.49

package/scripts/patch-binary-cache-test.mjs

@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import {
+  mkdirSync, mkdtempSync, rmSync, writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  ensurePatchBinary,
+  findCachedPatchBinary,
+} from '../src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs';
+import {
+  ensureNativePatchBinaryAvailable,
+  nativePatchBinPath,
+} from '../src/runtime/agent/orchestrator/tools/patch/native-server.mjs';
+
+const pkey = `${process.platform === 'win32' ? 'win32' : process.platform}-${process.arch}`;
+const suffix = process.platform === 'win32' ? '.exe' : '';
+
+function sha256(body) {
+  return createHash('sha256').update(body).digest('hex');
+}
+
+function makeManifest(version, body, url = `https://github.com/tribgames/mixdog/releases/download/patch-v${version}/mixdog-patch-${pkey}${suffix}`) {
+  return {
+    version,
+    assets: { [pkey]: { url, sha256: sha256(body) } },
+  };
+}
+
+function fixture(t) {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-patch-cache-'));
+  const binDir = join(dataDir, 'patch-bin');
+  mkdirSync(binDir, { recursive: true });
+  t.after(() => rmSync(dataDir, { recursive: true, force: true }));
+  return {
+    dataDir,
+    binDir,
+    bin(version) {
+      return join(binDir, `mixdog-patch-${version}${suffix}`);
+    },
+    localBin: join(dataDir, 'local-build', `mixdog-patch${suffix}`),
+  };
+}
+
+function nativeOptions(f, bundledManifest, download) {
+  return {
+    dataDir: f.dataDir,
+    defaultBin: f.localBin,
+    fetcherOptions: { bundledManifest, download },
+  };
+}
+
+test('stale cached manifest and binary cannot bypass native resolution', async (t) => {
+  const f = fixture(t);
+  const oldBody = Buffer.from('old binary');
+  const bundledBody = Buffer.from('bundled binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(makeManifest('1.0.0', oldBody)));
+  writeFileSync(f.bin('1.0.0'), oldBody);
+  const options = nativeOptions(f, bundledManifest, async (_url, destination) => {
+    writeFileSync(destination, bundledBody);
+  });
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), null);
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  assert.equal(await ensureNativePatchBinaryAvailable(options), f.bin('2.0.0'));
+});
+
+test('wrong-hash binary cannot bypass native resolution', async (t) => {
+  const f = fixture(t);
+  const expectedBody = Buffer.from('expected binary');
+  const manifest = makeManifest('2.0.0', expectedBody);
+  writeFileSync(f.bin('2.0.0'), 'wrong binary');
+  const options = nativeOptions(f, manifest, async (_url, destination) => {
+    writeFileSync(destination, expectedBody);
+  });
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest: manifest }), null);
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  assert.equal(await ensureNativePatchBinaryAvailable(options), f.bin('2.0.0'));
+});
+
+test('exact bundled filename with the correct hash is selected', (t) => {
+  const f = fixture(t);
+  const body = Buffer.from('correct binary');
+  const manifest = makeManifest('2.0.0', body);
+  writeFileSync(f.bin('2.0.0'), body);
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest: manifest }), f.bin('2.0.0'));
+});
+
+test('upgrade downloads the bundled version through the network-free seam', async (t) => {
+  const f = fixture(t);
+  const oldBody = Buffer.from('old binary');
+  const newBody = Buffer.from('new binary');
+  const oldManifest = makeManifest('1.0.0', oldBody);
+  const bundledManifest = makeManifest('2.0.0', newBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(oldManifest));
+  writeFileSync(f.bin('1.0.0'), oldBody);
+  let downloads = 0;
+
+  const selected = await ensurePatchBinary(f.dataDir, {
+    bundledManifest,
+    download: async (url, destination) => {
+      downloads += 1;
+      assert.equal(url, bundledManifest.assets[pkey].url);
+      writeFileSync(destination, newBody);
+    },
+  });
+
+  assert.equal(downloads, 1);
+  assert.equal(selected, f.bin('2.0.0'));
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), selected);
+});
+
+test('only a trusted, strictly newer valid cached manifest may advance policy', (t) => {
+  const f = fixture(t);
+  const bundledBody = Buffer.from('bundled binary');
+  const newerBody = Buffer.from('newer binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  const newerManifest = makeManifest('2.1.0', newerBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+  writeFileSync(f.bin('2.1.0'), newerBody);
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.1.0'));
+
+  newerManifest.assets[pkey].url = 'https://example.com/untrusted';
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+  writeFileSync(f.bin('2.0.0'), bundledBody);
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+});
+
+test('equal-version cached manifest cannot replace bundled policy', (t) => {
+  const f = fixture(t);
+  const bundledBody = Buffer.from('bundled binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  const equalManifest = makeManifest('2.0.0', Buffer.from('different binary'));
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(equalManifest));
+  writeFileSync(f.bin('2.0.0'), bundledBody);
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+});
+
+for (const [label, badUrl] of [
+  ['wrong release tag', `https://github.com/tribgames/mixdog/releases/download/patch-v9.9.9/mixdog-patch-${pkey}${suffix}`],
+  ['wrong platform filename', `https://github.com/tribgames/mixdog/releases/download/patch-v2.1.0/mixdog-patch-wrong-platform${suffix}`],
+]) {
+  test(`newer cached manifest with ${label} cannot replace bundled policy`, (t) => {
+    const f = fixture(t);
+    const bundledBody = Buffer.from('bundled binary');
+    const newerBody = Buffer.from('newer binary');
+    const bundledManifest = makeManifest('2.0.0', bundledBody);
+    const newerManifest = makeManifest('2.1.0', newerBody, badUrl);
+    writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+    writeFileSync(f.bin('2.0.0'), bundledBody);
+    writeFileSync(f.bin('2.1.0'), newerBody);
+
+    assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+  });
+}
+
+test('explicit native override and local cargo path retain precedence', (t) => {
+  const f = fixture(t);
+  const body = Buffer.from('cached binary');
+  const bundledManifest = makeManifest('2.0.0', body);
+  writeFileSync(f.bin('2.0.0'), body);
+  mkdirSync(join(f.dataDir, 'local-build'), { recursive: true });
+  writeFileSync(f.localBin, 'local binary');
+  const options = nativeOptions(f, bundledManifest);
+
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  const previous = process.env.MIXDOG_PATCH_NATIVE_BIN;
+  process.env.MIXDOG_PATCH_NATIVE_BIN = join(f.dataDir, 'explicit-binary');
+  try {
+    assert.equal(nativePatchBinPath(options), process.env.MIXDOG_PATCH_NATIVE_BIN);
+  } finally {
+    if (previous === undefined) delete process.env.MIXDOG_PATCH_NATIVE_BIN;
+    else process.env.MIXDOG_PATCH_NATIVE_BIN = previous;
+  }
+});

package/scripts/prompt-immediate-render-test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  cancelPromptImmediateFlush,
+  schedulePromptImmediateFlush,
+} from '../src/tui/components/prompt-input/immediate-render.mjs';
+
+test('busy prompt input cancels a pending immediate render and schedules nothing', () => {
+  const throttle = { lastAt: 90, timer: 7 };
+  const cleared = [];
+  let queued = 0;
+  let flushed = 0;
+
+  const scheduled = schedulePromptImmediateFlush({
+    throttle,
+    isSuppressed: true,
+    flush: () => { flushed += 1; },
+    now: () => 100,
+    enqueue: () => { queued += 1; },
+    clearTimer: (timer) => cleared.push(timer),
+  });
+
+  assert.equal(scheduled, false);
+  assert.equal(throttle.timer, null);
+  assert.deepEqual(cleared, [7]);
+  assert.equal(queued, 0);
+  assert.equal(flushed, 0);
+});
+
+test('idle prompt input keeps one leading and one coalesced trailing immediate render', () => {
+  const throttle = { lastAt: 0, timer: null };
+  let current = 100;
+  const queued = [];
+  const timers = [];
+  let flushed = 0;
+  const options = {
+    throttle,
+    isSuppressed: false,
+    flush: () => { flushed += 1; },
+    now: () => current,
+    enqueue: (callback) => queued.push(callback),
+    setTimer: (callback, delay) => {
+      timers.push({ callback, delay });
+      return timers.length;
+    },
+  };
+
+  assert.equal(schedulePromptImmediateFlush(options), true);
+  assert.equal(queued.length, 1);
+  queued.shift()();
+  assert.equal(flushed, 1);
+
+  current = 105;
+  assert.equal(schedulePromptImmediateFlush(options), true);
+  current = 106;
+  assert.equal(schedulePromptImmediateFlush(options), false);
+  assert.equal(timers.length, 1);
+  assert.equal(timers[0].delay, 11);
+
+  current = 116;
+  timers[0].callback();
+  assert.equal(flushed, 2);
+  assert.equal(throttle.timer, null);
+});
+
+test('a trailing immediate render is dropped if the turn becomes busy', () => {
+  const throttle = { lastAt: 100, timer: null };
+  let busy = false;
+  let timerCallback;
+  let flushed = 0;
+
+  schedulePromptImmediateFlush({
+    throttle,
+    isSuppressed: () => busy,
+    flush: () => { flushed += 1; },
+    now: () => 105,
+    setTimer: (callback) => {
+      timerCallback = callback;
+      return 1;
+    },
+  });
+  busy = true;
+  timerCallback();
+
+  assert.equal(flushed, 0);
+  assert.equal(throttle.timer, null);
+  assert.equal(cancelPromptImmediateFlush(throttle), false);
+});

package/scripts/provider-toolcall-test.mjs

@@ -53,7 +53,9 @@ 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 { _test as _anthropicApiKeyTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
 import { _toAnthropicMessagesForTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
+import { _test as _anthropicOAuthTest } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
 import {
     EFFORT_BETA_HEADER,
     LEGACY_EFFORT_BUDGET,
@@ -66,9 +68,191 @@ import { buildAnthropicBetaHeaders } from '../src/runtime/agent/orchestrator/pro
 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';
+import { _convertMessagesToResponsesInputForTest } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 
 // --- Helpers ---------------------------------------------------------------
 
+test('native deferred history normalizes per provider without leaking OpenAI variants to xAI', () => {
+    const nativePayload = {
+        provider: 'openai-oauth',
+        toolReferences: ['mcp__demo__ping'],
+        openaiTools: [{
+            type: 'function',
+            name: 'mcp__demo__ping',
+            defer_loading: true,
+            parameters: { type: 'object', properties: {} },
+        }],
+    };
+    const history = [
+        { role: 'user', content: 'load it' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'load-1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'load-1', content: 'Loaded', nativeToolSearch: nativePayload },
+    ];
+    const openai = _convertMessagesToResponsesInputForTest(history);
+    assert.equal(openai[1].type, 'tool_search_call');
+    assert.equal(openai[2].type, 'tool_search_output');
+    assert.equal(openai[2].tools[0].name, 'mcp__demo__ping');
+
+    const xai = _toXaiResponsesInputForTest(history, {
+        xaiResponses: { previousResponseId: 'resp-1', seenMessageCount: 0, model: 'grok-4' },
+    }, { model: 'grok-4' }).input;
+    assert.equal(xai.some((item) => item.type === 'tool_search_call' || item.type === 'tool_search_output'), false);
+    assert.equal(xai[1].type, 'function_call');
+    assert.equal(xai[2].type, 'function_call_output');
+});
+
+test('Anthropic native deferred result retains tool_reference history and defer_loading declarations', () => {
+    const base = [{ name: 'load_tool', description: 'loader', inputSchema: { type: 'object', properties: {} } }];
+    const deferred = { name: 'mcp__demo__ping', description: 'ping', inputSchema: { type: 'object', properties: {} } };
+    const session = {
+        deferredNativeTools: true,
+        deferredToolCatalog: [...base, deferred],
+    };
+    const firstBody = _buildRequestBodyForCacheSmoke(
+        [{ role: 'user', content: 'find ping' }],
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    assert.equal(firstBody.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+    assert.deepEqual(_anthropicApiKeyTest.deferredAnthropicTools(base, [], { session }), []);
+    const history = [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'load-a1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'load-a1',
+            content: 'Loaded',
+            nativeToolSearch: {
+                provider: 'anthropic-oauth',
+                toolReferences: ['mcp__demo__ping'],
+                openaiTools: [],
+            },
+        },
+    ];
+    const body = _buildRequestBodyForCacheSmoke(history, 'claude-sonnet-4-6', base, { session });
+    const result = body.messages.flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(result.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    assert.equal(body.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+    const apiKeyHistory = history.map((message) => (
+        message.nativeToolSearch
+            ? { ...message, nativeToolSearch: { ...message.nativeToolSearch, provider: 'anthropic' } }
+            : message
+    ));
+    const apiKeyDiscovered = _anthropicApiKeyTest.deferredAnthropicTools(base, apiKeyHistory, { session });
+    assert.equal(apiKeyDiscovered.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+    session.deferredDiscoveredTools = ['mcp__demo__ping'];
+    const compacted = _buildRequestBodyForCacheSmoke(
+        [{ role: 'user', content: 'continue after compact' }],
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    assert.equal(compacted.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+    const apiKeyCompacted = _anthropicApiKeyTest.deferredAnthropicTools(base, [], { session });
+    assert.equal(apiKeyCompacted.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+});
+
+test('Anthropic API-key and OAuth preserve root properties across compound schemas', () => {
+    const properties = {
+        pattern: { type: 'string' },
+        path: { type: 'string' },
+    };
+    const branches = [
+            { required: ['pattern'] },
+            { required: ['path'] },
+    ];
+    for (const compoundKey of ['oneOf', 'anyOf', 'allOf']) {
+        const schema = { type: 'object', properties, [compoundKey]: branches };
+        const expected = { type: 'object', properties };
+        const apiKey = _anthropicApiKeyTest.sanitizeInputSchema(schema, 'grep');
+        const oauth = _anthropicOAuthTest.sanitizeInputSchema(schema, 'grep');
+
+        assert.deepEqual(apiKey, expected, `API-key ${compoundKey}`);
+        assert.deepEqual(oauth, expected, `OAuth ${compoundKey}`);
+        assert.deepEqual(apiKey, oauth, `${compoundKey} parity`);
+    }
+});
+
+test('OpenAI native provider-tag switches keep tool_search call/output paired', () => {
+    const history = [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'native-pair', name: 'load_tool', arguments: {}, nativeType: 'tool_search_call' }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'native-pair',
+            content: 'Loaded',
+            nativeToolSearch: {
+                provider: 'openai',
+                toolReferences: ['read'],
+                openaiTools: [{ type: 'function', name: 'read', parameters: { type: 'object', properties: {} } }],
+            },
+        },
+    ];
+    const oauth = _convertMessagesToResponsesInputForTest(history, { nativeToolSearchProvider: 'openai-oauth' });
+    assert.deepEqual(oauth.map((item) => item.type), ['tool_search_call', 'tool_search_output']);
+    history[1].nativeToolSearch.provider = 'openai-oauth';
+    const direct = _convertMessagesToResponsesInputForTest(history, { nativeToolSearchProvider: 'openai' });
+    assert.deepEqual(direct.map((item) => item.type), ['tool_search_call', 'tool_search_output']);
+});
+
+test('Anthropic native provider-tag switches preserve tool_reference and loaded schema bidirectionally', () => {
+    const base = [{ name: 'load_tool', description: 'loader', inputSchema: { type: 'object', properties: {} } }];
+    const deferred = { name: 'mcp__demo__ping', description: 'ping', inputSchema: { type: 'object', properties: {} } };
+    const session = {
+        deferredNativeTools: true,
+        deferredToolCatalog: [...base, deferred],
+    };
+    const history = (provider) => [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'anthropic-family-pair', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'anthropic-family-pair',
+            content: 'Loaded deferred tools: mcp__demo__ping',
+            nativeToolSearch: {
+                provider,
+                toolReferences: ['mcp__demo__ping'],
+                openaiTools: [],
+            },
+        },
+    ];
+    const apiKeyToOauth = _buildRequestBodyForCacheSmoke(
+        history('anthropic'),
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    const oauthResult = apiKeyToOauth.messages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(oauthResult.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    assert.equal(apiKeyToOauth.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+
+    const oauthHistory = history('anthropic-oauth');
+    const oauthToApiKeyMessages = _toAnthropicMessagesForTest(oauthHistory);
+    const apiKeyResult = oauthToApiKeyMessages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(apiKeyResult.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    const apiKeyTools = _anthropicApiKeyTest.deferredAnthropicTools(base, oauthHistory, { session });
+    assert.equal(apiKeyTools.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+});
+
 // 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.
@@ -500,7 +684,7 @@ test('openai-compat/xai Responses: first Grok request after provider switch drop
     assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
 });
 
-test('openai-oauth Responses: load_tool schema and history stay function_call', () => {
+test('openai-oauth Responses: load_tool uses native tool_search history', () => {
     const loadTool = {
         name: 'load_tool',
         description: 'load tools',
@@ -517,19 +701,51 @@ test('openai-oauth Responses: load_tool schema and history stay function_call',
             content: '',
             toolCalls: [{ id: 'call_load_1', name: 'tool_search', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
         },
-        { role: 'tool', toolCallId: 'call_load_1', content: '{}' },
+        {
+            role: 'tool',
+            toolCallId: 'call_load_1',
+            content: 'Loaded deferred tools: read',
+            nativeToolSearch: {
+                provider: 'openai-oauth',
+                toolReferences: ['read'],
+                openaiTools: [{
+                    type: 'function',
+                    name: 'read',
+                    description: 'read',
+                    defer_loading: true,
+                    parameters: { type: 'object', properties: {} },
+                }],
+            },
+        },
     ], 'gpt-5.5', [loadTool], {});
-    assert.equal(JSON.stringify(body).includes('tool_search'), false);
-    assert.deepEqual(body.tools?.[0], {
-        type: 'function',
-        name: 'load_tool',
+    assert.equal(JSON.stringify(body).includes('tool_search'), true);
+    assert.deepEqual(body.tools, [{
+        type: 'tool_search',
+        execution: 'client',
         description: loadTool.description,
         parameters: loadTool.inputSchema,
+    }]);
+    const call = body.input.find((item) => item.type === 'tool_search_call');
+    assert.deepEqual(call, {
+        type: 'tool_search_call',
+        call_id: 'call_load_1',
+        execution: 'client',
+        arguments: { names: ['read'] },
+    });
+    const output = body.input.find((item) => item.type === 'tool_search_output' && item.call_id === 'call_load_1');
+    assert.deepEqual(output, {
+        type: 'tool_search_output',
+        call_id: 'call_load_1',
+        status: 'completed',
+        execution: 'client',
+        tools: [{
+            type: 'function',
+            name: 'read',
+            description: 'read',
+            defer_loading: true,
+            parameters: { type: 'object', properties: {} },
+        }],
     });
-    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', () => {
@@ -1432,7 +1648,7 @@ 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', () => {
+test('anthropic-oauth: foreign native references normalize to ordinary tool_result after provider switches', () => {
     const body = _buildRequestBodyForCacheSmoke(
         [
             { role: 'user', content: 'load a tool' },
@@ -1445,7 +1661,7 @@ test('anthropic-oauth: load_tool native references replay as ordinary tool_resul
                 role: 'tool',
                 toolCallId: 'toolu_load_1',
                 content: '{"loaded":["read"]}',
-                nativeToolSearch: { toolReferences: ['read'] },
+                nativeToolSearch: { provider: 'openai-oauth', toolReferences: ['read'] },
             },
         ],
         'claude-opus-4-8',
@@ -1617,6 +1833,55 @@ test('openai oauth ws delta: warmup generate:false does not force request_proper
     }
 });
 
+test('openai oauth ws delta: native tool_search output replays with canonical fields', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const baseTools = [{
+            type: 'tool_search',
+            execution: 'client',
+            description: 'load tools',
+            parameters: { type: 'object', properties: {} },
+        }];
+        const output = {
+            type: 'tool_search_output',
+            call_id: 'call_load_1',
+            status: 'completed',
+            execution: 'client',
+            tools: [{ type: 'function', name: 'read', parameters: { type: 'object', properties: {} } }],
+        };
+        const body = {
+            model: 'gpt-5.5',
+            instructions: 'sys',
+            tools: baseTools,
+            prompt_cache_key: 'cache-key',
+            input: [
+                { type: 'message', role: 'user', content: 'load read' },
+                { type: 'tool_search_call', call_id: 'call_load_1', execution: 'client', arguments: { names: ['read'] } },
+                output,
+                { type: 'message', role: 'user', content: 'use read' },
+            ],
+        };
+        const delta = _computeDelta({
+            entry: {
+                lastRequestSansInput: _stableStringify(_sansInput(body)),
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [body.input[0]],
+                lastResponseItems: [body.input[1]],
+            },
+            body,
+        });
+        assert.equal(delta.mode, 'delta');
+        assert.equal(delta.frame.prompt_cache_key, 'cache-key');
+        assert.deepEqual(delta.frame.tools, baseTools);
+        assert.equal(delta.frame.instructions, 'sys');
+        assert.deepEqual(delta.frame.input, [output, body.input[3]]);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
 test('canonical frame: full-frame builder leads with type and preserves codex body key order', () => {
     const body = {
         model: 'gpt-5.5',
@@ -1639,7 +1904,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 chained instructions, overrides input', () => {
+test('canonical frame: delta insert keeps key order and chained instructions, overrides input', () => {
     const body = {
         model: 'gpt-5.5',
         instructions: 'sys',
@@ -1648,8 +1913,8 @@ test('canonical frame: delta insert keeps key order, drops chained instructions,
         text: { verbosity: 'low' },
     };
     const delta = _buildResponseCreateFrame(body, { previousResponseId: 'resp_prev', inputOverride: [{ b: 2 }] });
-    assert.deepEqual(Object.keys(delta), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
-    assert.equal(delta.instructions, undefined);
+    assert.deepEqual(Object.keys(delta), ['type', 'model', 'instructions', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.equal(delta.instructions, 'sys');
     assert.equal(delta.previous_response_id, 'resp_prev');
     assert.deepEqual(delta.input, [{ b: 2 }]);
     // Empty instructions is also dropped in delta mode (server resolves via prev id).