fix: typing updates to pass make old_version_tests

Author: mjschock

src/agents/run.py

@@ -1945,7 +1945,7 @@ def run_streamed(
         else:
             # input is already str | list[TResponseInputItem] when not RunState
             # Reuse input_for_result variable from outer scope
-            input_for_result = cast(str | list[TResponseInputItem], input)
+            input_for_result = cast(Union[str, list[TResponseInputItem]], input)
             context_wrapper = RunContextWrapper(context=context)  # type: ignore
             # input_for_state is the same as input_for_result here
             input_for_state = input_for_result
@@ -3600,59 +3600,6 @@ async def _get_single_step_result_from_response(
             run_config=run_config,
         )
 
-    @classmethod
-    async def _get_single_step_result_from_streamed_response(
-        cls,
-        *,
-        agent: Agent[TContext],
-        all_tools: list[Tool],
-        streamed_result: RunResultStreaming,
-        new_response: ModelResponse,
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        run_config: RunConfig,
-        tool_use_tracker: AgentToolUseTracker,
-    ) -> SingleStepResult:
-        original_input = streamed_result.input
-        # When resuming from a RunState, items from streamed_result.new_items were already saved
-        # to the session, so we should start with empty pre_step_items to avoid duplicates.
-        # pre_step_items should only include items from the current run.
-        pre_step_items: list[RunItem] = []
-        event_queue = streamed_result._event_queue
-
-        processed_response = RunImpl.process_model_response(
-            agent=agent,
-            all_tools=all_tools,
-            response=new_response,
-            output_schema=output_schema,
-            handoffs=handoffs,
-        )
-        new_items_processed_response = processed_response.new_items
-        tool_use_tracker.add_tool_use(agent, processed_response.tools_used)
-        RunImpl.stream_step_items_to_queue(new_items_processed_response, event_queue)
-
-        single_step_result = await RunImpl.execute_tools_and_side_effects(
-            agent=agent,
-            original_input=original_input,
-            pre_step_items=pre_step_items,
-            new_response=new_response,
-            processed_response=processed_response,
-            output_schema=output_schema,
-            hooks=hooks,
-            context_wrapper=context_wrapper,
-            run_config=run_config,
-        )
-        new_step_items = [
-            item
-            for item in single_step_result.new_step_items
-            if item not in new_items_processed_response
-        ]
-        RunImpl.stream_step_items_to_queue(new_step_items, event_queue)
-
-        return single_step_result
-
     @classmethod
     async def _run_input_guardrails(
         cls,

src/agents/run_state.py

@@ -6,7 +6,7 @@
 import json
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generic, cast
+from typing import TYPE_CHECKING, Any, Generic, Optional, cast
 
 from openai.types.responses import (
     ResponseComputerToolCall,
@@ -741,7 +741,7 @@ def _serialize_item(self, item: RunItem) -> dict[str, Any]:
     def _convert_output_item_to_protocol(self, raw_item_dict: dict[str, Any]) -> dict[str, Any]:
         """Convert API-format tool output items to protocol format."""
         converted = dict(raw_item_dict)
-        call_id = cast(str | None, converted.get("call_id") or converted.get("callId"))
+        call_id = cast(Optional[str], converted.get("call_id") or converted.get("callId"))
 
         converted["type"] = "function_call_result"
 
@@ -761,13 +761,13 @@ def _lookup_function_name(self, call_id: str) -> str:
         def _extract_name(raw: Any) -> str | None:
             candidate_call_id: str | None = None
             if isinstance(raw, dict):
-                candidate_call_id = cast(str | None, raw.get("call_id") or raw.get("callId"))
+                candidate_call_id = cast(Optional[str], raw.get("call_id") or raw.get("callId"))
                 if candidate_call_id == call_id:
                     name_value = raw.get("name", "")
                     return str(name_value) if name_value else ""
             else:
                 candidate_call_id = cast(
-                    str | None,
+                    Optional[str],
                     getattr(raw, "call_id", None) or getattr(raw, "callId", None),
                 )
                 if candidate_call_id == call_id:
@@ -800,7 +800,7 @@ def _extract_name(raw: Any) -> str | None:
                 if input_item.get("type") != "function_call":
                     continue
                 item_call_id = cast(
-                    str | None, input_item.get("call_id") or input_item.get("callId")
+                    Optional[str], input_item.get("call_id") or input_item.get("callId")
                 )
                 if item_call_id == call_id:
                     name_value = input_item.get("name", "")

tests/fake_model.py

@@ -9,6 +9,7 @@
     ResponseContentPartAddedEvent,
     ResponseContentPartDoneEvent,
     ResponseCreatedEvent,
+    ResponseCustomToolCall,
     ResponseFunctionCallArgumentsDeltaEvent,
     ResponseFunctionCallArgumentsDoneEvent,
     ResponseFunctionToolCall,
@@ -121,8 +122,26 @@ async def get_response(
                 )
                 raise output
 
+            # Convert apply_patch_call dicts to ResponseCustomToolCall
+            # to avoid Pydantic validation errors
+            converted_output = []
+            for item in output:
+                if isinstance(item, dict) and item.get("type") == "apply_patch_call":
+                    import json
+                    operation = item.get("operation", {})
+                    operation_json = json.dumps(operation) if isinstance(operation, dict) else str(operation)
+                    converted_item = ResponseCustomToolCall(
+                        type="custom_tool_call",
+                        name="apply_patch",
+                        call_id=item.get("call_id") or item.get("callId", ""),
+                        input=operation_json,
+                    )
+                    converted_output.append(converted_item)
+                else:
+                    converted_output.append(item)
+
             return ModelResponse(
-                output=output,
+                output=converted_output,
                 usage=self.hardcoded_usage or Usage(),
                 response_id="resp-789",
             )