fix local codex review comment

  - [P1] Set message type when wrapping string input — packages/agents-core/src/runImplementation.ts:1713-1718
    When prepareInputItemsWithSession receives a string, this helper synthesizes the AgentInputItem that we hand to the model and also persist in session storage. Here we return { role: 'user',
  content: ... } without a type. The Responses API (and our own AgentInputItem contract) requires type: 'message', so as soon as session memory is enabled with a string input we start sending
  malformed payloads and will get a 400 from the model while also storing invalid history. Please set type: 'message' on the generated item before casting it to AgentInputItem.

Author: seratch

packages/agents-core/src/runImplementation.ts

@@ -39,12 +39,17 @@ import { getLastTextFromOutputMessage } from './utils/messages';
 import { withFunctionSpan, withHandoffSpan } from './tracing/createSpans';
 import { getSchemaAndParserFromInputType } from './utils/tools';
 import { encodeUint8ArrayToBase64 } from './utils/base64';
+import {
+  isArrayBufferView,
+  isNodeBuffer,
+  isSerializedBufferSnapshot,
+  toSmartString,
+} from './utils/smartString';
 import { safeExecute } from './utils/safeExecute';
 import { addErrorToCurrentSpan } from './tracing/context';
 import { RunItemStreamEvent, RunItemStreamEventName } from './events';
 import { RunResult, StreamedRunResult } from './result';
 import { z } from 'zod';
-import { toSmartString } from './utils/smartString';
 import * as protocol from './types/protocol';
 import { Computer } from './computer';
 import { RunState } from './runState';
@@ -1858,21 +1863,12 @@ export async function prepareInputItemsWithSession(
     );
   }
 
-  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 historyCounts = buildItemFrequencyMap(history);
+  const newInputCounts = buildItemFrequencyMap(newInputItems);
 
   const appended: AgentInputItem[] = [];
   for (const item of combined) {
-    const key = toSmartString(item);
+    const key = sessionItemKey(item);
     const historyRemaining = historyCounts.get(key) ?? 0;
     if (historyRemaining > 0) {
       historyCounts.set(key, historyRemaining - 1);
@@ -1894,3 +1890,54 @@ export async function prepareInputItemsWithSession(
     sessionItems: appended.length > 0 ? appended : [],
   };
 }
+
+function buildItemFrequencyMap(items: AgentInputItem[]): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const item of items) {
+    const key = sessionItemKey(item);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function sessionItemKey(item: AgentInputItem): string {
+  return JSON.stringify(item, sessionSerializationReplacer);
+}
+
+function sessionSerializationReplacer(_key: string, value: unknown): unknown {
+  if (value instanceof ArrayBuffer) {
+    return {
+      __type: 'ArrayBuffer',
+      data: encodeUint8ArrayToBase64(new Uint8Array(value)),
+    };
+  }
+
+  if (isArrayBufferView(value)) {
+    const view = value as ArrayBufferView;
+    return {
+      __type: view.constructor.name,
+      data: encodeUint8ArrayToBase64(
+        new Uint8Array(view.buffer, view.byteOffset, view.byteLength),
+      ),
+    };
+  }
+
+  if (isNodeBuffer(value)) {
+    const view = value as Uint8Array;
+    return {
+      __type: 'Buffer',
+      data: encodeUint8ArrayToBase64(
+        new Uint8Array(view.buffer, view.byteOffset, view.byteLength),
+      ),
+    };
+  }
+
+  if (isSerializedBufferSnapshot(value)) {
+    return {
+      __type: 'Buffer',
+      data: encodeUint8ArrayToBase64(Uint8Array.from(value.data)),
+    };
+  }
+
+  return value;
+}

packages/agents-core/src/utils/smartString.ts

@@ -1,6 +1,7 @@
 const BYTE_PREVIEW_LIMIT = 20;
 
 export function toSmartString(value: unknown): string {
+  // Produce a human-friendly string representation while preserving enough detail for debugging workflows.
   if (value === null || value === undefined) {
     return String(value);
   }
@@ -31,7 +32,8 @@ export function toSmartString(value: unknown): string {
   return String(value);
 }
 
-function isArrayBufferLike(value: unknown): value is ArrayBufferLike {
+export function isArrayBufferLike(value: unknown): value is ArrayBufferLike {
+  // Detect raw ArrayBuffer-backed payloads so callers can generate full previews rather than truncated hashes.
   if (value instanceof ArrayBuffer) {
     return true;
   }
@@ -47,13 +49,15 @@ function isArrayBufferLike(value: unknown): value is ArrayBufferLike {
   );
 }
 
-function isArrayBufferView(value: unknown): value is ArrayBufferView {
+export function isArrayBufferView(value: unknown): value is ArrayBufferView {
+  // Treat typed array views as binary data for consistent serialization.
   return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(value);
 }
 
-function isSerializedBufferSnapshot(
+export function isSerializedBufferSnapshot(
   value: unknown,
 ): value is { type: 'Buffer'; data: number[] } {
+  // Support serialized Buffer snapshots (e.g., from JSON.parse) emitted by some tool outputs.
   return (
     typeof value === 'object' &&
     value !== null &&
@@ -62,6 +66,22 @@ function isSerializedBufferSnapshot(
   );
 }
 
+export function isNodeBuffer(
+  value: unknown,
+): value is Uint8Array & { toString(encoding: string): string } {
+  // Detect runtime Buffers without importing node-specific shims, handling browser builds gracefully.
+  const bufferCtor = (
+    globalThis as {
+      Buffer?: { isBuffer(input: unknown): boolean };
+    }
+  ).Buffer;
+  return Boolean(
+    bufferCtor &&
+      typeof bufferCtor.isBuffer === 'function' &&
+      bufferCtor.isBuffer(value),
+  );
+}
+
 function formatByteArray(bytes: Uint8Array): string {
   if (bytes.length === 0) {
     return '[byte array (0 bytes)]';

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

@@ -848,6 +848,61 @@ describe('Runner.run', () => {
         expect(getFirstTextContent(persistedUsers[0])).toBe('Fresh input');
       });
 
+      it('persists binary payloads that share prefixes with history', async () => {
+        const model = new RecordingModel([
+          {
+            ...TEST_MODEL_RESPONSE_BASIC,
+            output: [fakeModelMessage('binary response')],
+          },
+        ]);
+        const historyPayload = new Uint8Array(32);
+        const newPayload = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+          const value = i < 20 ? 0xaa : i;
+          historyPayload[i] = value;
+          newPayload[i] = value;
+        }
+        historyPayload[31] = 0xbb;
+        newPayload[31] = 0xcc;
+
+        const session = new MemorySession([
+          user('History with binary', { payload: historyPayload }),
+        ]);
+        const agent = new Agent({ name: 'BinarySession', model });
+        const runner = new Runner();
+
+        await runner.run(agent, [user('Binary input')], {
+          session,
+          sessionInputCallback: (history, newItems) => {
+            const clonedHistory = history.map((item) => structuredClone(item));
+            const updatedNewItems = newItems.map((item) => {
+              const cloned = structuredClone(item);
+              cloned.providerData = { payload: newPayload };
+              return cloned;
+            });
+            return clonedHistory.concat(updatedNewItems);
+          },
+        });
+
+        expect(session.added).toHaveLength(1);
+        const [persistedItems] = session.added;
+        const persistedPayloads = persistedItems
+          .filter(
+            (item): item is protocol.UserMessageItem =>
+              item.type === 'message' &&
+              'role' in item &&
+              item.role === 'user' &&
+              item.providerData?.payload,
+          )
+          .map((item) =>
+            Array.from(item.providerData?.payload as Uint8Array | number[]),
+          );
+        expect(persistedPayloads).toContainEqual(Array.from(newPayload));
+        expect(persistedPayloads).not.toContainEqual(
+          Array.from(historyPayload),
+        );
+      });
+
       it('throws when session input callback returns invalid data', async () => {
         const model = new RecordingModel([
           {