fix local codex review comment:

    - [P0] Convert stored tool outputs back to function results — packages/agents-openai/src/memory/openaiConversationsSession.ts:99-110
    When we fetch history from an OpenAI conversation we run each item through convertToOutputItem here. Items that we previously added via session.addItems for tool results
  arrive from the Conversations API as type === "function_call_output", but convertToOutputItem only understands real response output types and falls back to returning an
  UnknownItem. On the very next turn the runner feeds these history items back through getInputItems, which throws UserError: Unsupported item { type: "unknown" }, so any tool
  usage breaks the session after the first turn. Please deserialize function_call_output into a proper FunctionCallResultItem before returning it from getItems.

Author: seratch

packages/agents-core/src/types/protocol.ts

@@ -606,6 +606,7 @@ export const OutputModelItem = z.discriminatedUnion('type', [
   HostedToolCallItem,
   FunctionCallItem,
   ComputerUseCallItem,
+  FunctionCallResultItem,
   ReasoningItem,
   UnknownItem,
 ]);

packages/agents-openai/src/openaiResponsesModel.ts

@@ -51,16 +51,16 @@ type ResponseFunctionCallOutputListItem =
     }
   | {
       type: 'input_image';
-      image_url?: string;
-      file_id?: string;
-      detail?: 'low' | 'high' | 'auto';
+      image_url?: string | null;
+      file_id?: string | null;
+      detail?: 'low' | 'high' | 'auto' | null;
     }
   | {
       type: 'input_file';
-      file_data?: string;
-      file_url?: string;
-      file_id?: string;
-      filename?: string;
+      file_data?: string | null;
+      file_url?: string | null;
+      file_id?: string | null;
+      filename?: string | null;
     };
 
 type ExtendedFunctionCallOutput = Omit<
@@ -70,6 +70,13 @@ type ExtendedFunctionCallOutput = Omit<
   output: string | ResponseFunctionCallOutputListItem[];
 };
 
+type ResponseOutputItemWithFunctionResult =
+  | OpenAI.Responses.ResponseOutputItem
+  | (OpenAI.Responses.ResponseFunctionToolCallOutputItem & {
+      name?: string;
+      function_name?: string;
+    });
+
 const HostedToolChoice = z.enum([
   'file_search',
   'web_search',
@@ -394,6 +401,73 @@ function convertStructuredOutputToRequestItem(
   );
 }
 
+function convertResponseFunctionCallOutputItemToStructured(
+  item: ResponseFunctionCallOutputListItem,
+): protocol.ToolCallStructuredOutput {
+  if (item.type === 'input_text') {
+    return {
+      type: 'input_text',
+      text: item.text,
+    };
+  }
+
+  if (item.type === 'input_image') {
+    const structured: protocol.InputImage = { type: 'input_image' };
+
+    if (typeof item.image_url === 'string' && item.image_url.length > 0) {
+      structured.image = item.image_url;
+    } else if (typeof item.file_id === 'string' && item.file_id.length > 0) {
+      structured.image = { id: item.file_id };
+    }
+
+    if (item.detail) {
+      structured.detail = item.detail;
+    }
+
+    return structured;
+  }
+
+  if (item.type === 'input_file') {
+    const structured: protocol.InputFile = { type: 'input_file' };
+
+    if (typeof item.file_id === 'string' && item.file_id.length > 0) {
+      structured.file = { id: item.file_id };
+    } else if (typeof item.file_url === 'string' && item.file_url.length > 0) {
+      structured.file = { url: item.file_url };
+    } else if (
+      typeof item.file_data === 'string' &&
+      item.file_data.length > 0
+    ) {
+      structured.file = item.file_data;
+    }
+
+    if (item.filename) {
+      structured.filename = item.filename;
+    }
+
+    return structured;
+  }
+
+  const exhaustive: never = item;
+  throw new UserError(
+    `Unsupported structured tool output: ${JSON.stringify(exhaustive)}`,
+  );
+}
+
+function convertFunctionCallOutputToProtocol(
+  output: OpenAI.Responses.ResponseFunctionToolCallOutputItem['output'],
+): protocol.FunctionCallResultItem['output'] {
+  if (typeof output === 'string') {
+    return output;
+  }
+
+  if (Array.isArray(output)) {
+    return output.map(convertResponseFunctionCallOutputItemToStructured);
+  }
+
+  return '';
+}
+
 function normalizeLegacyFileFromOutput(value: Record<string, any>): {
   file?: protocol.InputFile['file'];
   filename?: string;
@@ -1090,7 +1164,7 @@ function convertToMessageContentItem(
 }
 
 function convertToOutputItem(
-  items: OpenAI.Responses.ResponseOutputItem[],
+  items: ResponseOutputItemWithFunctionResult[],
 ): protocol.OutputModelItem[] {
   return items.map((item) => {
     if (item.type === 'message') {
@@ -1137,6 +1211,28 @@ function convertToOutputItem(
         providerData,
       };
       return output;
+    } else if (item.type === 'function_call_output') {
+      const {
+        call_id,
+        status,
+        output: rawOutput,
+        name: toolName,
+        function_name: functionName,
+        ...providerData
+      } = item as OpenAI.Responses.ResponseFunctionToolCallOutputItem & {
+        name?: string;
+        function_name?: string;
+      };
+      const output: protocol.FunctionCallResultItem = {
+        type: 'function_call_result',
+        id: item.id,
+        callId: call_id,
+        name: toolName ?? functionName ?? call_id,
+        status: status ?? 'completed',
+        output: convertFunctionCallOutputToProtocol(rawOutput),
+        providerData,
+      };
+      return output;
     } else if (item.type === 'computer_call') {
       const { call_id, status, action, ...providerData } = item;
       const output: protocol.ComputerUseCallItem = {
@@ -1204,6 +1300,7 @@ function convertToOutputItem(
 
     return {
       type: 'unknown',
+      id: item.id,
       providerData: item,
     };
   });

packages/agents-openai/test/openaiResponsesModel.helpers.test.ts

@@ -512,4 +512,70 @@ describe('convertToOutputItem', () => {
       ] as any),
     ).toThrow();
   });
+
+  it('converts function_call_output items into function_call_result entries', () => {
+    const out = convertToOutputItem([
+      {
+        type: 'function_call_output',
+        id: 'out-1',
+        call_id: 'call-1',
+        name: 'lookup',
+        output: 'done',
+      } as any,
+    ]);
+
+    expect(out[0]).toMatchObject({
+      type: 'function_call_result',
+      id: 'out-1',
+      callId: 'call-1',
+      name: 'lookup',
+      output: 'done',
+      status: 'completed',
+    });
+  });
+
+  it('converts structured function_call_output payloads into structured outputs', () => {
+    const out = convertToOutputItem([
+      {
+        type: 'function_call_output',
+        id: 'out-2',
+        call_id: 'call-2',
+        function_name: 'search',
+        status: 'in_progress',
+        output: [
+          { type: 'input_text', text: 'hello' },
+          {
+            type: 'input_image',
+            image_url: 'https://example.com/img.png',
+            detail: 'high',
+          },
+          {
+            type: 'input_file',
+            file_url: 'https://example.com/file.txt',
+            filename: 'file.txt',
+          },
+        ],
+      } as any,
+    ]);
+
+    expect(out[0]).toMatchObject({
+      type: 'function_call_result',
+      callId: 'call-2',
+      name: 'search',
+      status: 'in_progress',
+      output: [
+        { type: 'input_text', text: 'hello' },
+        {
+          type: 'input_image',
+          image: 'https://example.com/img.png',
+          detail: 'high',
+        },
+        {
+          type: 'input_file',
+          file: { url: 'https://example.com/file.txt' },
+          filename: 'file.txt',
+        },
+      ],
+    });
+  });
 });