fix(agent-core): handle incomplete tool_calls on session resume

When a session is killed mid-tool-call and later resumed, the history
contains an assistant message with tool_calls but no matching tool
results. This caused a 400 API error and silently deferred all new
user messages. Fixes #660.

Changes:
- project() now applies trimTrailingOpenToolExchange() to strip
  trailing assistant messages with unanswered tool_calls before
  sending to the LLM
- Added cleanupOrphanedToolCalls() to ContextMemory that clears
  stale pendingToolResultIds after resume, so new user messages
  are not silently deferred
- Fixed trimTrailingOpenToolExchange edge case where history with
  no assistant message returned [] instead of the full history

Tests:
- project() trims trailing assistant with unanswered tool_calls
- project() keeps assistant when all tool_calls are answered
- cleanupOrphanedToolCalls clears stale pendingToolResultIds

Author: LifeJiggy

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

@@ -298,6 +298,28 @@ export class ContextMemory {
     return this.pendingToolResultIds.size > 0;
   }
 
+  /**
+   * Remove stale entries from `pendingToolResultIds` that have no matching
+   * tool result in the history.  This happens when a session is killed
+   * mid-tool-call and later resumed — the tool.call events are replayed
+   * but the tool.result events never arrived.  Without this cleanup,
+   * `hasOpenToolExchange()` would remain true, silently deferring all
+   * new user messages.
+   */
+  cleanupOrphanedToolCalls(): void {
+    const answeredIds = new Set<string>();
+    for (const message of this._history) {
+      if (message.role === 'tool' && typeof message.toolCallId === 'string') {
+        answeredIds.add(message.toolCallId);
+      }
+    }
+    for (const id of this.pendingToolResultIds) {
+      if (!answeredIds.has(id)) {
+        this.pendingToolResultIds.delete(id);
+      }
+    }
+  }
+
   private pushHistory(...messages: ContextMessage[]): void {
     this._history.push(...messages);
     for (const message of messages) {

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

@@ -12,7 +12,11 @@ export function project(history: readonly ContextMessage[]): Message[] {
       !(message.role === 'assistant' && message.content.length === 0 && message.toolCalls.length === 0)
     );
   });
-  return mergeAdjacentUserMessages(usable);
+  // Trim any trailing assistant message whose tool_calls were never answered
+  // (e.g. the session was killed mid-tool-call).  Sending an assistant
+  // message with open tool_calls violates the API contract and causes a
+  // 400 error on resume.
+  return trimTrailingOpenToolExchange(mergeAdjacentUserMessages(usable));
 }
 
 function mergeAdjacentUserMessages(history: readonly ContextMessage[]): Message[] {
@@ -77,8 +81,11 @@ export function trimTrailingOpenToolExchange(history: readonly Message[]): Messa
     lastNonToolIndex -= 1;
   }
 
+  // No assistant message found — nothing to trim.
+  if (lastNonToolIndex < 0) return [...history];
+
   const assistant = history[lastNonToolIndex];
-  if (assistant === undefined) return [];
+  if (assistant === undefined) return [...history];
   if (assistant.role !== 'assistant' || assistant.toolCalls.length === 0) return [...history];
 
   const trailingToolCallIds = new Set(

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

@@ -300,6 +300,10 @@ export class Agent {
     await this.background.loadFromDisk();
     await this.background.reconcile();
     await this.cron?.loadFromDisk();
+    // Clean up any tool_call IDs that were never answered (session killed
+    // mid-tool-call).  Without this, new user messages would be silently
+    // deferred because `hasOpenToolExchange()` would remain true.
+    this.context.cleanupOrphanedToolCalls();
     this.turn.finishResume();
     return result;
   }

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

@@ -776,6 +776,84 @@ describe('Agent context notification projection', () => {
     expect(textOf(messages[1]!)).toBe('No origin prompt');
     expect(textOf(messages[2]!)).toBe('Third real prompt');
   });
+
+  it('project() trims trailing assistant message with unanswered tool_calls', () => {
+    const history: ContextMessage[] = [
+      userMessage('hello'),
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'I will run a tool' }],
+        toolCalls: [{ id: 'call_1', name: 'Bash', arguments: '{}' }],
+      },
+      // No tool result for call_1 — session was killed.
+    ];
+    const messages = project(history);
+    // The assistant message with open tool_calls should be trimmed.
+    expect(messages).toHaveLength(1);
+    expect(messages[0]!.role).toBe('user');
+  });
+
+  it('project() keeps assistant message when all tool_calls are answered', () => {
+    const history: ContextMessage[] = [
+      userMessage('hello'),
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'I will run a tool' }],
+        toolCalls: [{ id: 'call_1', name: 'Bash', arguments: '{}' }],
+      },
+      {
+        role: 'tool',
+        content: [{ type: 'text', text: 'tool output' }],
+        toolCalls: [],
+        toolCallId: 'call_1',
+      },
+    ];
+    const messages = project(history);
+    // All three messages should be present.
+    expect(messages).toHaveLength(3);
+    expect(messages[1]!.role).toBe('assistant');
+    expect(messages[2]!.role).toBe('tool');
+  });
+
+  it('cleanupOrphanedToolCalls clears stale pendingToolResultIds after resume', () => {
+    const ctx = testAgent();
+    ctx.configure();
+
+    // Simulate a tool.call event that never got a tool.result (session killed).
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: { type: 'step.begin', uuid: 'step-orphan', turnId: '', step: 1 },
+    });
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: {
+        type: 'tool.call',
+        parentUuid: 'step-orphan',
+        stepUuid: 'step-orphan',
+        toolCallId: 'orphan_call',
+        name: 'Bash',
+        arguments: '{}',
+      },
+    });
+
+    // The orphaned tool call should block new messages.
+    ctx.agent.context.appendUserMessage([{ type: 'text', text: 'follow up' }]);
+    // The message should be deferred, not in history.
+    const historyBefore = ctx.agent.context.history.filter(
+      (m) => m.role === 'user' && m.content.some((p) => p.type === 'text' && 'text' in p && p.text === 'follow up'),
+    );
+    expect(historyBefore).toHaveLength(0);
+
+    // Now cleanup the orphaned tool calls.
+    ctx.agent.context.cleanupOrphanedToolCalls();
+
+    // After cleanup, new messages should go through.
+    ctx.agent.context.appendUserMessage([{ type: 'text', text: 'after cleanup' }]);
+    const historyAfter = ctx.agent.context.history.filter(
+      (m) => m.role === 'user' && m.content.some((p) => p.type === 'text' && 'text' in p && p.text === 'after cleanup'),
+    );
+    expect(historyAfter).toHaveLength(1);
+  });
 });
 
 function userMessage(text: string, origin?: ContextMessage['origin']): ContextMessage {