[Bug]: Reused OpenAI tool-call IDs stop conversations with history-update errors (0.6.12; follow-up #490) #523

diff --git a/packages/local-runtime-v2/test/integration/compaction-openai-transport.integration.test.ts b/packages/local-runtime-v2/test/integration/compaction-openai-transport.integration.test.ts
index 14d0522..3761a48 100644
--- a/packages/local-runtime-v2/test/integration/compaction-openai-transport.integration.test.ts
+++ b/packages/local-runtime-v2/test/integration/compaction-openai-transport.integration.test.ts
@@ -11,6 +11,64 @@ import { createCheckpointSession } from "../../src/service/turn-system/compactio
 const summary =
   "The synthetic file was read. Continue with the pending user request.";
 
+describe('reused OpenAI tool identities', () => {
+  it.each(['history', 'parallel', 'late-id', 'repeated-delta', 'unchanged', 'reserved-suffix', 'encrypted', 'ambiguous'])('%s keeps distinct calls and stable streamed identities', async (scenario) => {
+    const model: Model<'openai-completions'> = {
+      id: 'fixture-model', name: 'fixture', api: 'openai-completions',
+      provider: 'custom_provider:fixture', baseUrl: 'https://example.invalid/v1',
+      reasoning: false, input: ['text'], contextWindow: 32768, maxTokens: 4096,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    };
+    const parallel = scenario === 'parallel' || scenario === 'ambiguous';
+    const messages = parallel || scenario === 'unchanged' ? [] : history(model);
+    if (scenario === 'reserved-suffix') {
+      const previous = structuredClone(history(model));
+      const assistant = previous[1];
+      const result = previous[2];
+      if (assistant.role === 'assistant' && assistant.content[0].type === 'toolCall') assistant.content[0].id = 'read-1_mcode_2';
+      if (result.role === 'toolResult') result.toolCallId = 'read-1_mcode_2';
+      messages.push(...previous);
+    }
+    const original = structuredClone(messages);
+    const deltas: Record<string, unknown>[] = scenario === 'late-id' || scenario === 'repeated-delta'
+      ? [{ tool_calls: [{ index: 0, ...(scenario === 'repeated-delta' ? { id: 'read-1' } : {}), function: { name: 'read', arguments: '{"path":' } }] },
+         { tool_calls: [{ index: 0, id: 'read-1', function: { arguments: '"next.txt"}' } }] }]
+      : [{ tool_calls: [{ index: 0, id: 'read-1', function: { name: 'read', arguments: '{"path":"next.txt"}' } },
+          ...(parallel ? [{ index: 1, id: 'read-1', function: { name: 'read', arguments: '{"path":"other.txt"}' } }] : [])] }];
+    if (scenario === 'encrypted') deltas.push({ reasoning_details: [{ type: 'reasoning.encrypted', id: 'read-1', data: 'opaque-synthetic-signature' }] });
+    if (scenario === 'ambiguous') deltas.push({ tool_calls: [{ id: 'read-1', function: { arguments: ' ' } }] });
+    const wire = [...deltas.map(delta => ({ choices: [{ index: 0, delta, finish_reason: null }] })),
+      { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }] }]
+      .map(chunk => `data: ${JSON.stringify({ id: 'synthetic-response', ...chunk })}\n\n`).join('') + 'data: [DONE]\n\n';
+    const response = streamSimple(model, { messages }, {
+      apiKey: 'synthetic', fetch: async () => new Response(wire, { headers: { 'content-type': 'text/event-stream' } }),
+    });
+    const ends: string[] = [];
+    for await (const event of response) {
+      if (event.type === 'toolcall_end') ends.push(event.toolCall.id);
+    }
+    const final = await response.result();
+    if (scenario === 'encrypted' || scenario === 'ambiguous') {
+      expect(final.stopReason).toBe('error');
+      expect(final.errorMessage).toContain(scenario === 'encrypted' ? 'cannot safely rebind' : 'ambiguous');
+      expect(messages).toEqual(original);
+      return;
+    }
+    expect(final.stopReason).toBe('toolUse');
+    const calls = final.content.filter(block => block.type === 'toolCall');
+    expect(calls).toHaveLength(scenario === 'parallel' ? 2 : 1);
+    const ids = calls.map(call => call.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ends).toEqual(ids);
+    expect(calls[0].arguments).toEqual({ path: 'next.txt' });
+    if (scenario === 'parallel') expect(calls[1].arguments).toEqual({ path: 'other.txt' });
+    if (messages.length) expect(ids).not.toContain('read-1');
+    else expect(ids[0]).toBe('read-1');
+    if (scenario === 'reserved-suffix') expect(ids).not.toContain('read-1_mcode_2');
+    expect(messages).toEqual(original);
+  });
+});
+
 function history(model: Model<"openai-completions">): Context["messages"] {
   return [
     { role: "user", content: "Read the synthetic file.", timestamp: 1 },
diff --git a/test/byok.test.mjs b/test/byok.test.mjs
index 7d429ae..998d315 100644
--- a/test/byok.test.mjs
+++ b/test/byok.test.mjs
@@ -1156,3 +1156,107 @@ function cancellationTest(cancellation) {
     );
   };
 }
+
+test("BYOK reused tool IDs survive repeated execution and canonical persistence", { timeout: 60000 }, async (t) => {
+  const fixtureDir = mkdtempSync(path.join(tmpdir(), "minimax-code-tool-id-"));
+  const dataDir = path.join(fixtureDir, "data");
+  const workspaceDir = path.join(fixtureDir, "workspace");
+  const homeDir = path.join(fixtureDir, "home");
+  for (const directory of [dataDir, workspaceDir, homeDir]) mkdirSync(directory);
+  const readPath = path.join(workspaceDir, "completed-tool.txt");
+  writeFileSync(readPath, "COMPLETED_TOOL_RESULT");
+  const networkAudit = path.join(fixtureDir, "network-audit.log");
+  let streamRequests = 0;
+  const server = createServer(async (req, res) => {
+    let raw = "";
+    for await (const chunk of req) raw += chunk;
+    const body = JSON.parse(raw);
+    if (req.url?.endsWith("/responses/input_tokens")) {
+      res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ input_tokens: 1 }));
+      return;
+    }
+    if (!body.stream) {
+      res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
+        id: "fixture", object: "chat.completion", model: "fixture",
+        choices: [{ index: 0, message: { role: "assistant", content: "synthetic title" }, finish_reason: "stop" }],
+      }));
+      return;
+    }
+    streamRequests += 1;
+    res.writeHead(200, { "content-type": "text/event-stream" });
+    const send = (delta, finishReason = null) => res.write(`data: ${JSON.stringify({
+      id: "fixture", object: "chat.completion.chunk", created: 1, model: "fixture",
+      choices: [{ index: 0, delta, finish_reason: finishReason }],
+    })}\n\n`);
+    const results = body.messages.filter(message => message.role === "tool");
+    assert.equal(results.length, streamRequests - 1);
+    const calls = body.messages.flatMap(message => message.tool_calls ?? []);
+    assert.equal(new Set(calls.map(call => call.id)).size, calls.length);
+    assert.deepEqual(results.map(result => result.tool_call_id), calls.map(call => call.id));
+    for (const result of results) assert.match(JSON.stringify(result), /COMPLETED_TOOL_RESULT/u);
+    if (streamRequests <= 3) {
+      send({ role: "assistant", tool_calls: [{
+        index: 0, id: "reused-call", type: "function",
+        function: { name: "read", arguments: JSON.stringify({ path: readPath }) },
+      }] });
+      send({}, "tool_calls");
+      res.end("data: [DONE]\n\n");
+      return;
+    }
+    send({ role: "assistant", content: "RECONNECTED_OK" });
+    send({}, "stop");
+    res.end("data: [DONE]\n\n");
+  });
+  let child;
+  t.after(async () => {
+    if (child && child.exitCode === null) child.kill("SIGKILL");
+    server.closeAllConnections();
+    await new Promise(resolve => server.close(resolve));
+    rmSync(fixtureDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  });
+  await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
+  const origin = `http://127.0.0.1:${server.address().port}`;
+  writeFileSync(path.join(dataDir, "config.yaml"), stringifyYaml({
+    defaultModel: "custom_provider:fixture/fixture",
+    custom_provider: {
+      fixture: {
+        name: "fixture", kind: "custom", enabled: true, api: "openai-completions",
+        options: { apiKey: "synthetic-key", baseURL: `${origin}/v1`, authMode: "api-key" },
+        models: { fixture: { limit: { context: 32768, output: 4096 } } },
+      },
+    },
+  }));
+  child = spawn(process.execPath, [
+    cli, "exec", "Reply RECONNECTED_OK only.", "--mode", "standard",
+    "--permission", "off", "--cwd", workspaceDir, "--timeout", "45s", "--max-steps", "5",
+  ], {
+    cwd: workspaceDir,
+    env: {
+      ...withoutProxyEnvironment(process.env), HOME: homeDir,
+      XDG_CONFIG_HOME: path.join(homeDir, "config"), XDG_DATA_HOME: path.join(homeDir, "data"),
+      MINIMAX_DATA_DIR: dataDir, MAVIS_DATA_DIR: dataDir,
+      MCODE_TEST_ALLOWED_ORIGIN: origin, MCODE_TEST_NETWORK_AUDIT: networkAudit,
+      MCODE_TEST_MANAGED_OFFLINE: "1",
+      NODE_OPTIONS: `--import=${new URL("./network-deny.mjs", import.meta.url).href}`,
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", chunk => { stdout += chunk; });
+  child.stderr.on("data", chunk => { stderr += chunk; });
+  const [code] = await once(child, "close");
+  assert.equal(code, 0, `${stdout}\n${stderr}`);
+  assert.equal(streamRequests, 4, "Three intentional reads must complete, with no history failure or retry");
+  assert.equal(stdout.split("RECONNECTED_OK").length - 1, 1, "Only the successful answer is published");
+  assert.doesNotMatch(stdout, /DISCARD_PARTIAL_RESPONSE/u);
+  assert.equal(existsSync(networkAudit), false, "No external requests are allowed");
+  const records = readdirSync(path.join(dataDir, "v2", "sessions"), { recursive: true })
+    .filter(name => name.endsWith("messages.jsonl"))
+    .flatMap(name => readFileSync(path.join(dataDir, "v2", "sessions", name), "utf8").trim().split("\n").filter(Boolean).map(JSON.parse));
+  const calls = records.flatMap(record => record.message?.role === "assistant" ? record.message.content.filter(block => block.type === "toolCall") : []);
+  const results = records.filter(record => record.message?.role === "toolResult");
+  assert.equal(calls.length, 3);
+  assert.equal(new Set(calls.map(call => call.id)).size, 3);
+  assert.deepEqual(results.map(record => record.message.toolCallId), calls.map(call => call.id));
+});
diff --git a/third_party/pi-mono/packages/ai/src/providers/openai-completions.ts b/third_party/pi-mono/packages/ai/src/providers/openai-completions.ts
index 2f52683..97fb28f 100644
--- a/third_party/pi-mono/packages/ai/src/providers/openai-completions.ts
+++ b/third_party/pi-mono/packages/ai/src/providers/openai-completions.ts
@@ -153,6 +153,26 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 			let hasFinishReason = false;
 			const toolCallBlocksByIndex = new Map<number, StreamingToolCallBlock>();
 			const toolCallBlocksById = new Map<string, StreamingToolCallBlock>();
+			const ambiguousToolCallIds = new Set<string>();
+			// Chat-compatible endpoints may reuse a call ID in later responses.
+			// Assign the incoming call a free identity before any event reaches the
+			// agent, so execution, tool results and durable history all agree.
+			const usedToolCallIds = new Set<string>();
+			for (const message of context.messages) {
+				if (message.role === "assistant") {
+					for (const block of message.content) {
+						if (block.type === "toolCall") usedToolCallIds.add(block.id);
+					}
+				} else if (message.role === "toolResult") usedToolCallIds.add(message.toolCallId);
+			}
+			const allocateToolCallId = (rawId: string): string => {
+				if (!rawId) return rawId;
+				let id = rawId;
+				let suffix = 2;
+				while (usedToolCallIds.has(id)) id = `${rawId.slice(0, 48)}_mcode_${suffix++}`;
+				usedToolCallIds.add(id);
+				return id;
+			};
 			const blocks = output.content as StreamingBlock[];
 			const getContentIndex = (block: StreamingBlock) => blocks.indexOf(block);
 			const finishBlock = (block: StreamingBlock) => {
@@ -210,14 +230,20 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 			};
 			const ensureToolCallBlock = (toolCall: StreamingToolCallDelta) => {
 				const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
+				if (streamIndex === undefined && toolCall.id && ambiguousToolCallIds.has(toolCall.id)) {
+					throw new Error("Provider omitted the index for an ambiguous reused tool call ID");
+				}
 				let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
 				if (!block && toolCall.id) {
-					block = toolCallBlocksById.get(toolCall.id);
+					const byId = toolCallBlocksById.get(toolCall.id);
+					// An explicit index identifies a separate parallel call even when
+					// the provider mistakenly gives both calls the same raw ID.
+					if (streamIndex === undefined || byId?.streamIndex === undefined) block = byId;
 				}
 				if (!block) {
 					block = {
 						type: "toolCall",
-						id: toolCall.id || "",
+						id: allocateToolCallId(toolCall.id || ""),
 						name: toolCall.function?.name || "",
 						arguments: {},
 						partialArgs: "",
@@ -227,6 +253,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 						toolCallBlocksByIndex.set(streamIndex, block);
 					}
 					if (toolCall.id) {
+						if (toolCallBlocksById.has(toolCall.id)) ambiguousToolCallIds.add(toolCall.id);
 						toolCallBlocksById.set(toolCall.id, block);
 					}
 					blocks.push(block);
@@ -331,7 +358,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 						for (const toolCall of choice.delta.tool_calls) {
 							const block = ensureToolCallBlock(toolCall);
 							if (!block.id && toolCall.id) {
-								block.id = toolCall.id;
+								block.id = allocateToolCallId(toolCall.id);
 								toolCallBlocksById.set(toolCall.id, block);
 							}
 							if (!block.name && toolCall.function?.name) {
@@ -357,10 +384,12 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 					if (reasoningDetails && Array.isArray(reasoningDetails)) {
 						for (const detail of reasoningDetails) {
 							if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
-								const matchingToolCall = output.content.find(
-									(b) => b.type === "toolCall" && b.id === detail.id,
-								) as ToolCall | undefined;
+								const matchingToolCall = toolCallBlocksById.get(detail.id);
 								if (matchingToolCall) {
+									// Do not rewrite an opaque signature's bound identity.
+									if (matchingToolCall.id !== detail.id) {
+										throw new Error("Provider reused a tool call ID with encrypted reasoning; cannot safely rebind it");
+									}
 									matchingToolCall.thoughtSignature = JSON.stringify(detail);
 								}
 							}