fix local codex review comment

    - [P1] Prevent duplicating run items on approval resume — packages/agents-core/src/runImplementation.ts:460-462
    When we resume a turn after tool approval, originalPreStepItems already contains the assistant message/tool-call items that were generated before the interruption.
  Initializing newItems with processedResponse.newItems reuses those same instances, so SingleStepResult.generatedItems ends up concatenating [...preStepItems, ...newItems] where
  the message/tool-call appear twice. This causes duplicate entries to be persisted in session history and re-emitted to callers every time an approval is resolved. The previous
  implementation started from the tool results only (const newItems = functionResults.map(...)) to avoid this duplication. We should revert to building newItems from the newly
  produced tool results instead of cloning the prior processedResponse.newItems array.

Author: seratch

packages/agents-core/src/runImplementation.ts

@@ -457,7 +457,19 @@ export async function resolveTurnAfterModelResponse<TContext>(
   state: RunState<TContext, Agent<TContext, any>>,
 ): Promise<SingleStepResult> {
   const preStepItems = originalPreStepItems;
-  let newItems = processedResponse.newItems;
+  const seenItems = new Set<RunItem>(originalPreStepItems);
+  const newItems: RunItem[] = [];
+  const appendIfNew = (item: RunItem) => {
+    if (seenItems.has(item)) {
+      return;
+    }
+    newItems.push(item);
+    seenItems.add(item);
+  };
+
+  for (const item of processedResponse.newItems) {
+    appendIfNew(item);
+  }
 
   const [functionResults, computerResults] = await Promise.all([
     executeFunctionToolCalls(
@@ -474,8 +486,12 @@ export async function resolveTurnAfterModelResponse<TContext>(
     ),
   ]);
 
-  newItems = newItems.concat(functionResults.map((r) => r.runItem));
-  newItems = newItems.concat(computerResults);
+  for (const result of functionResults) {
+    appendIfNew(result.runItem);
+  }
+  for (const item of computerResults) {
+    appendIfNew(item);
+  }
 
   // run hosted MCP approval requests
   if (processedResponse.mcpApprovalRequests.length > 0) {

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

@@ -1744,6 +1744,55 @@ describe('resolveTurnAfterModelResponse', () => {
     expect(result.nextStep.type).toBe('next_step_run_again');
   });
 
+  it('does not duplicate previously persisted model items when resuming after approvals', async () => {
+    const toolCall = {
+      ...TEST_MODEL_FUNCTION_CALL,
+      id: 'call-resume',
+      callId: 'call-resume',
+    };
+    const message = fakeModelMessage('Tool approval pending');
+    message.id = 'message-resume';
+    const response: ModelResponse = {
+      output: [toolCall, message],
+      usage: new Usage(),
+    } as any;
+
+    const processedResponse = processModelResponse(
+      response,
+      TEST_AGENT,
+      [TEST_TOOL],
+      [],
+    );
+
+    const priorItems = [...processedResponse.newItems];
+    state._generatedItems = priorItems;
+
+    const result = await withTrace('test', () =>
+      resolveTurnAfterModelResponse(
+        TEST_AGENT,
+        'test input',
+        priorItems,
+        response,
+        processedResponse,
+        runner,
+        state,
+      ),
+    );
+
+    const persistedToolCalls = result.generatedItems.filter((item) => {
+      return item instanceof ToolCallItem && item.rawItem.id === 'call-resume';
+    });
+    expect(persistedToolCalls).toHaveLength(1);
+
+    const persistedMessages = result.generatedItems.filter((item) => {
+      return (
+        item instanceof MessageOutputItem &&
+        item.rawItem.id === 'message-resume'
+      );
+    });
+    expect(persistedMessages).toHaveLength(1);
+  });
+
   it('does not finalize when hosted MCP approval happens in the same turn; runs again', async () => {
     const approvalAgent = new Agent({ name: 'MCPAgent', outputType: 'text' });
     const mcpTool = hostedMcpTool({