fix(agent-core): realign mid-history interrupted tool calls on resume

.changeset/fix-mid-history-interrupted-tool-call.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix resume not realigning a tool call that was interrupted mid-history. The synthetic interrupted result is now closed in place at the next step boundary, so later turns and deferred messages keep their recorded order instead of only the trailing exchange being repaired. The `/messages` wire transcript reducer mirrors the same closure so its folded length stays aligned with live history, preventing the later turn from being duplicated/reordered. Replay also drops a tool result whose call is no longer awaiting one, so a stale interrupted result left at the log tail by an older resume of a damaged session is not re-applied as a duplicate.

packages/agent-core/src/agent/context/index.ts

@@ -227,10 +227,20 @@ export class ContextMemory {
   }
 
   finishResume(): void {
-    const interruptedToolCallIds = [...this.pendingToolResultIds];
     this.openSteps.clear();
-    if (interruptedToolCallIds.length === 0) return;
+    this.closePendingToolResults();
+  }
 
+  // Synthesize interrupted tool results for any still-open tool calls, closing
+  // the exchange in place. Called at every replayed step boundary (see the
+  // `step.begin` case) so a tool call left unresolved mid-history is closed
+  // exactly where it occurred — otherwise it would keep `hasOpenToolExchange`
+  // true and strand every later message in `deferredMessages`, so only the
+  // trailing exchange ends up aligned. `finishResume` runs the same routine once
+  // more to close a genuine trailing interruption at end of resume.
+  private closePendingToolResults(): void {
+    if (this.pendingToolResultIds.size === 0) return;
+    const interruptedToolCallIds = [...this.pendingToolResultIds];
     for (const toolCallId of interruptedToolCallIds) {
       this.appendLoopEvent({
         type: 'tool.result',
@@ -251,6 +261,11 @@ export class ContextMemory {
     });
     switch (event.type) {
       case 'step.begin': {
+        // A new assistant step means any tool calls still pending from an
+        // earlier step were interrupted (the invariant guarantees this never
+        // happens live, so this is a no-op outside replay). Close them in place
+        // before opening the new step so mid-history gaps stay aligned.
+        this.closePendingToolResults();
         const message: ContextMessage = {
           role: 'assistant',
           content: [],
@@ -316,6 +331,10 @@ export class ContextMemory {
         return;
       }
       case 'tool.result': {
+        // Drop a result for an id that is not awaiting one: it was already
+        // closed in place at a step boundary (a stale duplicate from an older
+        // tail-only finishResume), or its call is gone.
+        if (!this.pendingToolResultIds.has(event.toolCallId)) return;
         const message = createToolMessage(event.toolCallId, toolResultOutputForModel(event.result));
         this.pushHistory({
           ...message,

packages/agent-core/src/services/message/transcript.ts

@@ -58,6 +58,8 @@ const TOOL_EMPTY_STATUS = '<system>Tool output is empty.</system>';
 const TOOL_EMPTY_ERROR_STATUS =
   '<system>ERROR: Tool execution failed. Tool output is empty.</system>';
 const TOOL_OUTPUT_EMPTY_TEXT = 'Tool output is empty.';
+const TOOL_INTERRUPTED_ON_RESUME_OUTPUT =
+  'Tool execution was interrupted before its result was recorded. Do not assume the tool completed successfully.';
 
 export interface TranscriptEntry {
   readonly message: ContextMessage;
@@ -116,6 +118,29 @@ export function reduceWireRecords(records: Iterable<AgentRecord>): {
     push(...deferred);
     deferred = [];
   };
+  // ContextMemory closes these during replay without persisting the synthetic
+  // result, so the reducer must reconstruct it to keep foldedLength aligned.
+  const closePendingToolResults = (time: number | undefined): void => {
+    if (pendingToolResultIds.size === 0) return;
+    const interruptedToolCallIds = [...pendingToolResultIds];
+    for (const toolCallId of interruptedToolCallIds) {
+      push({
+        message: {
+          role: 'tool',
+          content: toolResultContent({
+            output: TOOL_INTERRUPTED_ON_RESUME_OUTPUT,
+            isError: true,
+          }),
+          toolCalls: [],
+          toolCallId,
+          isError: true,
+        },
+        time,
+      });
+      pendingToolResultIds.delete(toolCallId);
+    }
+    flushDeferredIfToolExchangeClosed();
+  };
   const resetOpenState = (): void => {
     openSteps.clear();
     pendingToolResultIds.clear();
@@ -125,6 +150,7 @@ export function reduceWireRecords(records: Iterable<AgentRecord>): {
   const applyLoopEvent = (event: LoopRecordedEvent, time: number | undefined): void => {
     switch (event.type) {
       case 'step.begin': {
+        closePendingToolResults(time);
         const entry: MutableEntry = {
           message: { role: 'assistant', content: [], toolCalls: [] },
           time,
@@ -157,6 +183,9 @@ export function reduceWireRecords(records: Iterable<AgentRecord>): {
         return;
       }
       case 'tool.result': {
+        // Drop a result for an id not awaiting one (already closed in place, or
+        // its call is gone) — mirrors ContextMemory.
+        if (!pendingToolResultIds.has(event.toolCallId)) return;
         push({
           message: {
             role: 'tool',

packages/agent-core/test/agent/context.test.ts

@@ -18,6 +18,19 @@ describe('Agent context', () => {
       type: 'context.append_loop_event',
       event: { type: 'step.begin', uuid: 'origin-step', turnId: '', step: 1 },
     });
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: {
+        type: 'tool.call',
+        uuid: 'origin-tool',
+        turnId: '',
+        step: 1,
+        stepUuid: 'origin-step',
+        toolCallId: 'call_origin',
+        name: 'Run',
+        args: {},
+      },
+    });
     ctx.dispatch({
       type: 'context.append_loop_event',
       event: { type: 'step.end', uuid: 'origin-step', turnId: '', step: 1 },
@@ -45,6 +58,25 @@ describe('Agent context', () => {
     const ctx = testAgent();
     ctx.configure();
 
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: { type: 'step.begin', uuid: 's1', turnId: 't', step: 1 },
+    });
+    for (const toolCallId of ['call_error', 'call_empty']) {
+      ctx.dispatch({
+        type: 'context.append_loop_event',
+        event: {
+          type: 'tool.call',
+          uuid: toolCallId,
+          turnId: 't',
+          step: 1,
+          stepUuid: 's1',
+          toolCallId,
+          name: 'Run',
+          args: {},
+        },
+      });
+    }
     ctx.dispatch({
       type: 'context.append_loop_event',
       event: {
@@ -65,6 +97,7 @@ describe('Agent context', () => {
     });
 
     expect(ctx.agent.context.messages).toMatchObject([
+      { role: 'assistant', toolCalls: [{ id: 'call_error' }, { id: 'call_empty' }] },
       {
         role: 'tool',
         content: [