fix local codex review

[P1] Avoid duplicating session history — packages/agents-core/src/runImplementation.ts:1861-1872
When we compute sessionItems for a custom sessionInputCallback, we rely on reference equality (historySet.has(item)) to decide which entries came from prior history. That assumes the callback
returns the exact same object references for every preserved history item. A very common sanitization pattern is to clone history items (e.g. history.map(item => structuredClone(item))) before
returning them. In that case none of the clones are found in historySet or newInputSet, so every history entry is treated as “appended” and we persist the entire history again. After one or
two turns the session now contains duplicate copies of every message and will grow explosively on subsequent runs. Please adjust the change detection (e.g. track by index/length or require the
callback to return new items explicitly) so that cloning history entries does not cause the memory to balloon.

Author: seratch

packages/agents-core/src/runImplementation.ts

@@ -1858,22 +1858,35 @@ export async function prepareInputItemsWithSession(
     );
   }
 
-  const historySet = new Set(history);
-  const newInputSet = new Set(newInputItems);
+  const historyCounts = new Map<string, number>();
+  for (const item of history) {
+    const key = toSmartString(item);
+    historyCounts.set(key, (historyCounts.get(key) ?? 0) + 1);
+  }
+
+  const newInputCounts = new Map<string, number>();
+  for (const item of newInputItems) {
+    const key = toSmartString(item);
+    newInputCounts.set(key, (newInputCounts.get(key) ?? 0) + 1);
+  }
+
   const appended: AgentInputItem[] = [];
   for (const item of combined) {
-    if (historySet.has(item) || !newInputSet.has(item)) {
-      if (!historySet.has(item) && !newInputSet.has(item)) {
-        appended.push(item);
-      }
+    const key = toSmartString(item);
+    const historyRemaining = historyCounts.get(key) ?? 0;
+    if (historyRemaining > 0) {
+      historyCounts.set(key, historyRemaining - 1);
       continue;
     }
-    appended.push(item);
-  }
 
-  if (appended.length === 0 && combined.length > history.length) {
-    // When callbacks replace every new item with fresh objects, fall back to the tail slice.
-    appended.push(...combined.slice(history.length));
+    const newRemaining = newInputCounts.get(key) ?? 0;
+    if (newRemaining > 0) {
+      newInputCounts.set(key, newRemaining - 1);
+      appended.push(item);
+      continue;
+    }
+
+    appended.push(item);
   }
 
   return {

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

@@ -813,6 +813,41 @@ describe('Runner.run', () => {
         });
       });
 
+      it('does not duplicate history when callback clones entries', async () => {
+        const model = new RecordingModel([
+          {
+            ...TEST_MODEL_RESPONSE_BASIC,
+            output: [fakeModelMessage('clone response')],
+          },
+        ]);
+        const history = [user('Existing history item')];
+        const session = new MemorySession(history);
+        const agent = new Agent({ name: 'CloneSession', model });
+        const runner = new Runner();
+
+        await runner.run(agent, [user('Fresh input')], {
+          session,
+          sessionInputCallback: (incomingHistory, newItems) => {
+            const clonedHistory = incomingHistory.map((item) =>
+              structuredClone(item),
+            );
+            const clonedNewItems = newItems.map((item) =>
+              structuredClone(item),
+            );
+            return clonedHistory.concat(clonedNewItems);
+          },
+        });
+
+        expect(session.added).toHaveLength(1);
+        const [persistedItems] = session.added;
+        const persistedUsers = persistedItems.filter(
+          (item): item is protocol.UserMessageItem =>
+            item.type === 'message' && 'role' in item && item.role === 'user',
+        );
+        expect(persistedUsers).toHaveLength(1);
+        expect(getFirstTextContent(persistedUsers[0])).toBe('Fresh input');
+      });
+
       it('throws when session input callback returns invalid data', async () => {
         const model = new RecordingModel([
           {