fix local codex review comment

  - [P0] Preserve pending MCP approvals when resuming — packages/agents-core/src/runImplementation.ts:414-418
    When we resume an interrupted turn, this block removes every RunToolApprovalItem from originalPreStepItems, but we only re-add the ones tied to function tools. For
  hosted MCP approvals without an on_approval handler, if the user has not yet approved, approved stays undefined, so nothing gets pushed back into newItems. As a result
  maybeCompleteTurnFromToolResults sees no interruptions, returns next_step_run_again, and the runner keeps looping until it hits the max-turns guard. In practice you can
  reproduce this with any HostedMCPTool HITL flow: run once, do not call state.approve, resume the run, and the approval request disappears so the user can no longer respond. We
  need to keep outstanding hosted approval items in preStepItems (or push them back into newItems) whenever they are still waiting on human input; otherwise HITL with hosted MCP
  tools is broken.

Author: seratch

packages/agents-core/src/runImplementation.ts

@@ -370,8 +370,21 @@ export async function resolveInterruptedTurn<TContext>(
     state,
   );
 
-  // Create the initial set of the output items
-  const newItems: RunItem[] = functionResults.map((r) => r.runItem);
+  // When resuming we receive the original RunItem references; suppress duplicates so history and streaming do not double-emit the same items.
+  const originalPreStepItemSet = new Set(originalPreStepItems);
+  const newItems: RunItem[] = [];
+  const newItemsSet = new Set<RunItem>();
+  const appendIfNew = (item: RunItem) => {
+    if (originalPreStepItemSet.has(item) || newItemsSet.has(item)) {
+      return;
+    }
+    newItems.push(item);
+    newItemsSet.add(item);
+  };
+
+  for (const result of functionResults) {
+    appendIfNew(result.runItem);
+  }
 
   // Run MCP tools that require approval after they get their approval results
   const mcpApprovalRuns = processedResponse.mcpApprovalRequests.filter(
@@ -383,6 +396,9 @@ export async function resolveInterruptedTurn<TContext>(
       );
     },
   );
+  // Hosted MCP approvals may still be waiting on a human decision when the turn resumes.
+  const pendingHostedMCPApprovals = new Set<RunToolApprovalItem>();
+  const pendingHostedMCPApprovalIds = new Set<string>();
   for (const run of mcpApprovalRuns) {
     // the approval_request_id "mcpr_123..."
     const approvalRequestId = run.requestItem.rawItem.id!;
@@ -398,23 +414,49 @@ export async function resolveInterruptedTurn<TContext>(
         reason: undefined,
       };
       // Tell Responses API server the approval result in the next turn
-      newItems.push(
-        new RunToolCallItem(
-          {
-            type: 'hosted_tool_call',
-            name: 'mcp_approval_response',
-            providerData,
-          },
-          agent as Agent<unknown, 'text'>,
-        ),
+      const responseItem = new RunToolCallItem(
+        {
+          type: 'hosted_tool_call',
+          name: 'mcp_approval_response',
+          providerData,
+        },
+        agent as Agent<unknown, 'text'>,
       );
+      appendIfNew(responseItem);
+    } else {
+      pendingHostedMCPApprovals.add(run.requestItem);
+      pendingHostedMCPApprovalIds.add(approvalRequestId);
+      functionResults.push({
+        type: 'hosted_mcp_tool_approval',
+        tool: run.mcpTool,
+        runItem: run.requestItem,
+      });
+      appendIfNew(run.requestItem);
     }
   }
 
-  // Exclude the tool approval items, which should not be sent to Responses API,
-  // from the SingleStepResult's preStepItems
+  // Server-managed conversations rely on preStepItems to re-surface pending approvals.
+  // Keep unresolved hosted MCP approvals in place so HITL flows still have something to approve next turn.
   const preStepItems = originalPreStepItems.filter((item) => {
-    return !(item instanceof RunToolApprovalItem);
+    if (!(item instanceof RunToolApprovalItem)) {
+      return true;
+    }
+
+    if (
+      item.rawItem.type === 'hosted_tool_call' &&
+      item.rawItem.providerData?.type === 'mcp_approval_request'
+    ) {
+      if (pendingHostedMCPApprovals.has(item)) {
+        return true;
+      }
+      const approvalRequestId = item.rawItem.id;
+      if (approvalRequestId) {
+        return pendingHostedMCPApprovalIds.has(approvalRequestId);
+      }
+      return false;
+    }
+
+    return false;
   });
 
   const completedStep = await maybeCompleteTurnFromToolResults({

packages/agents-core/test/run.test.ts

@@ -31,6 +31,7 @@ import { handoff } from '../src/handoff';
 import {
   RunMessageOutputItem as MessageOutputItem,
   RunToolApprovalItem as ToolApprovalItem,
+  RunToolCallOutputItem as ToolCallOutputItem,
 } from '../src/items';
 import { getTurnInput, selectModel } from '../src/run';
 import { RunContext } from '../src/runContext';
@@ -2389,14 +2390,23 @@ describe('Runner.run', () => {
         conversationId: 'conv-mixed',
       });
 
-      expect(model.requests).toHaveLength(2);
-      const secondItems = model.requests[1].input as AgentInputItem[];
-      expect(secondItems).toHaveLength(1);
-      expect(secondItems[0]).toMatchObject({
-        type: 'function_call_result',
-        callId: 'call-mixed',
+      expect(model.requests).toHaveLength(1);
+
+      const toolOutputs = secondResult.newItems.filter(
+        (item) =>
+          item instanceof ToolCallOutputItem &&
+          item.rawItem.type === 'function_call_result' &&
+          item.rawItem.callId === 'call-mixed',
+      );
+      expect(toolOutputs).toHaveLength(1);
+
+      expect(secondResult.interruptions).toHaveLength(1);
+      expect(secondResult.interruptions[0].rawItem).toMatchObject({
+        providerData: { id: 'approval-id', type: 'mcp_approval_request' },
       });
-      expect(secondResult.finalOutput).toBe('still waiting');
+      expect(secondResult.state._currentStep?.type).toBe(
+        'next_step_interruption',
+      );
     });
 
     it('sends full history when no server-managed state is provided', async () => {

packages/agents-core/test/runImplementation.test.ts

@@ -1915,4 +1915,80 @@ describe('resolveTurnAfterModelResponse', () => {
       });
     }
   });
+
+  it('preserves pending hosted MCP approvals when resuming an interrupted turn', async () => {
+    const approvalAgent = new Agent({ name: 'MCPAgent', outputType: 'text' });
+    const mcpTool = hostedMcpTool({
+      serverLabel: 'demo_server',
+      serverUrl: 'https://example.com',
+      requireApproval: {
+        always: { toolNames: ['demo_tool'] },
+      },
+    });
+
+    const approvalRequest: protocol.HostedToolCallItem = {
+      type: 'hosted_tool_call',
+      id: 'approval1',
+      name: 'demo_tool',
+      status: 'in_progress',
+      providerData: {
+        type: 'mcp_approval_request',
+        server_label: 'demo_server',
+        name: 'demo_tool',
+        id: 'approval1',
+        arguments: '{}',
+      },
+    } as protocol.HostedToolCallItem;
+
+    const approvalItem = new ToolApprovalItem(approvalRequest, approvalAgent);
+    const originalPreStepItems = [approvalItem];
+
+    const processedResponse: ProcessedResponse = {
+      newItems: [],
+      handoffs: [],
+      functions: [],
+      computerActions: [],
+      mcpApprovalRequests: [
+        {
+          requestItem: approvalItem,
+          mcpTool,
+        },
+      ],
+      toolsUsed: [],
+      hasToolsOrApprovalsToRun() {
+        return true;
+      },
+    };
+
+    const resumedResponse: ModelResponse = {
+      output: [],
+      usage: new Usage(),
+    } as any;
+
+    const resumedState = new RunState(
+      new RunContext(),
+      'test input',
+      approvalAgent,
+      1,
+    );
+
+    const runner = new Runner();
+
+    const result = await resolveInterruptedTurn(
+      approvalAgent,
+      'test input',
+      originalPreStepItems,
+      resumedResponse,
+      processedResponse,
+      runner,
+      resumedState,
+    );
+
+    expect(result.nextStep.type).toBe('next_step_interruption');
+    if (result.nextStep.type === 'next_step_interruption') {
+      expect(result.nextStep.data.interruptions).toContain(approvalItem);
+    }
+    expect(result.preStepItems).toContain(approvalItem);
+    expect(result.newStepItems).not.toContain(approvalItem);
+  });
 });