fix: restore v0.7.0 constructor compatibility for RunResult types (#2414)

seratch · web-flow · commit 4b63ed7b5beb · 2026-02-04T21:49:06.000+09:00
diff --git a/src/agents/result.py b/src/agents/result.py
@@ -5,7 +5,7 @@
 import copy
 import weakref
 from collections.abc import AsyncIterator
-from dataclasses import dataclass, field
+from dataclasses import InitVar, dataclass, field
 from typing import Any, Literal, TypeVar, cast
 
 from .agent import Agent
@@ -76,8 +76,9 @@ def _populate_state_from_result(
     state._previous_response_id = previous_response_id
     state._auto_previous_response_id = auto_previous_response_id
 
-    if result.interruptions:
-        state._current_step = NextStepInterruption(interruptions=result.interruptions)
+    interruptions = list(getattr(result, "interruptions", []))
+    if interruptions:
+        state._current_step = NextStepInterruption(interruptions=interruptions)
 
     trace_state = getattr(result, "_trace_state", None)
     if trace_state is None:
@@ -120,9 +121,6 @@ class RunResultBase(abc.ABC):
     context_wrapper: RunContextWrapper[Any]
     """The context wrapper for the agent run."""
 
-    interruptions: list[ToolApprovalItem]
-    """Pending tool approval requests (interruptions) for this run."""
-
     _trace_state: TraceState | None = field(default=None, init=False, repr=False)
     """Serialized trace metadata captured during the run."""
 
@@ -228,6 +226,8 @@ class RunResult(RunResultBase):
     """Whether automatic previous response tracking was enabled."""
     max_turns: int = 10
     """The maximum number of turns allowed for this run."""
+    interruptions: list[ToolApprovalItem] = field(default_factory=list)
+    """Pending tool approval requests (interruptions) for this run."""
 
     def __post_init__(self) -> None:
         self._last_agent_ref = weakref.ref(self._last_agent)
@@ -337,8 +337,6 @@ class RunResultStreaming(RunResultBase):
         repr=False,
         default=None,
     )
-    _last_processed_response: ProcessedResponse | None = field(default=None, repr=False)
-    """The last processed model response. This is needed for resuming from interruptions."""
 
     _model_input_items: list[RunItem] = field(default_factory=list, repr=False)
     """Filtered items used to build model input between streaming turns."""
@@ -356,6 +354,11 @@ class RunResultStreaming(RunResultBase):
     _input_guardrails_task: asyncio.Task[Any] | None = field(default=None, repr=False)
     _output_guardrails_task: asyncio.Task[Any] | None = field(default=None, repr=False)
     _stored_exception: Exception | None = field(default=None, repr=False)
+    _cancel_mode: Literal["none", "immediate", "after_turn"] = field(default="none", repr=False)
+    _last_processed_response: ProcessedResponse | None = field(default=None, repr=False)
+    """The last processed model response. This is needed for resuming from interruptions."""
+    interruptions: list[ToolApprovalItem] = field(default_factory=list)
+    """Pending tool approval requests (interruptions) for this run."""
     _waiting_on_event_queue: bool = field(default=False, repr=False)
 
     _current_turn_persisted_item_count: int = 0
@@ -369,9 +372,6 @@ class RunResultStreaming(RunResultBase):
     """Original turn input before session history was merged, used for
     persistence (matches JS sessionInputOriginalSnapshot)."""
 
-    # Soft cancel state
-    _cancel_mode: Literal["none", "immediate", "after_turn"] = field(default="none", repr=False)
-
     _max_turns_handled: bool = field(default=False, repr=False)
 
     _original_input: str | list[TResponseInputItem] | None = field(default=None, repr=False)
@@ -386,12 +386,16 @@ class RunResultStreaming(RunResultBase):
     """Response identifier returned by the server for the last turn."""
     _auto_previous_response_id: bool = field(default=False, repr=False)
     """Whether automatic previous response tracking was enabled."""
+    _run_impl_task: InitVar[asyncio.Task[Any] | None] = None
 
-    def __post_init__(self) -> None:
+    def __post_init__(self, _run_impl_task: asyncio.Task[Any] | None) -> None:
         self._current_agent_ref = weakref.ref(self.current_agent)
         # Store the original input at creation time (it will be set via input field)
         if self._original_input is None:
             self._original_input = self.input
+        # Compatibility shim: accept legacy `_run_impl_task` constructor keyword.
+        if self.run_loop_task is None and _run_impl_task is not None:
+            self.run_loop_task = _run_impl_task
 
     @property
     def last_agent(self) -> Agent[Any]:
diff --git a/src/agents/tool_context.py b/src/agents/tool_context.py
@@ -1,9 +1,16 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, field, fields
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, cast
 
 from openai.types.responses import ResponseFunctionToolCall
 
 from .run_context import RunContextWrapper, TContext
+from .usage import Usage
+
+if TYPE_CHECKING:
+    from .items import TResponseInputItem
+    from .run_context import _ApprovalRecord
 
 
 def _assert_must_pass_tool_call_id() -> str:
@@ -18,6 +25,9 @@ def _assert_must_pass_tool_arguments() -> str:
     raise ValueError("tool_arguments must be passed to ToolContext")
 
 
+_MISSING = object()
+
+
 @dataclass
 class ToolContext(RunContextWrapper[TContext]):
     """The context of a tool call."""
@@ -31,16 +41,53 @@ class ToolContext(RunContextWrapper[TContext]):
     tool_arguments: str = field(default_factory=_assert_must_pass_tool_arguments)
     """The raw arguments string of the tool call."""
 
-    tool_call: Optional[ResponseFunctionToolCall] = None
+    tool_call: ResponseFunctionToolCall | None = None
     """The tool call object associated with this invocation."""
 
+    def __init__(
+        self,
+        context: TContext,
+        usage: Usage | object = _MISSING,
+        tool_name: str | object = _MISSING,
+        tool_call_id: str | object = _MISSING,
+        tool_arguments: str | object = _MISSING,
+        tool_call: ResponseFunctionToolCall | None = None,
+        *,
+        turn_input: list[TResponseInputItem] | None = None,
+        _approvals: dict[str, _ApprovalRecord] | None = None,
+        tool_input: Any | None = None,
+    ) -> None:
+        """Preserve the v0.7 positional constructor while accepting new context fields."""
+        resolved_usage = Usage() if usage is _MISSING else cast(Usage, usage)
+        super().__init__(
+            context=context,
+            usage=resolved_usage,
+            turn_input=list(turn_input or []),
+            _approvals={} if _approvals is None else _approvals,
+            tool_input=tool_input,
+        )
+        self.tool_name = (
+            _assert_must_pass_tool_name() if tool_name is _MISSING else cast(str, tool_name)
+        )
+        self.tool_arguments = (
+            _assert_must_pass_tool_arguments()
+            if tool_arguments is _MISSING
+            else cast(str, tool_arguments)
+        )
+        self.tool_call_id = (
+            _assert_must_pass_tool_call_id()
+            if tool_call_id is _MISSING
+            else cast(str, tool_call_id)
+        )
+        self.tool_call = tool_call
+
     @classmethod
     def from_agent_context(
         cls,
         context: RunContextWrapper[TContext],
         tool_call_id: str,
-        tool_call: Optional[ResponseFunctionToolCall] = None,
-    ) -> "ToolContext":
+        tool_call: ResponseFunctionToolCall | None = None,
+    ) -> ToolContext:
         """
         Create a ToolContext from a RunContextWrapper.
         """
diff --git a/tests/test_source_compat_constructors.py b/tests/test_source_compat_constructors.py
@@ -1,14 +1,19 @@
 from __future__ import annotations
 
-from typing import Any
+import asyncio
+from typing import Any, cast
 
 from agents import (
+    Agent,
     AgentHookContext,
     FunctionTool,
     HandoffInputData,
     ItemHelpers,
     MultiProvider,
     RunConfig,
+    RunContextWrapper,
+    RunResult,
+    RunResultStreaming,
     ToolGuardrailFunctionOutput,
     ToolInputGuardrailData,
     ToolOutputGuardrailData,
@@ -68,3 +73,156 @@ def test_agent_hook_context_third_positional_argument_is_turn_input() -> None:
 
     assert context.turn_input == turn_input
     assert isinstance(context._approvals, dict)
+
+
+def test_tool_context_v070_positional_constructor_still_works() -> None:
+    usage = Usage()
+    context = ToolContext(None, usage, "tool_name", "call_id", '{"x":1}', None)
+
+    assert context.usage is usage
+    assert context.tool_name == "tool_name"
+    assert context.tool_call_id == "call_id"
+    assert context.tool_arguments == '{"x":1}'
+
+
+def test_run_result_v070_positional_constructor_still_works() -> None:
+    result = RunResult(
+        "x",
+        [],
+        [],
+        "ok",
+        [],
+        [],
+        [],
+        [],
+        RunContextWrapper(context=None),
+        Agent(name="agent"),
+    )
+    assert result.final_output == "ok"
+    assert result.interruptions == []
+
+
+def test_run_result_streaming_v070_positional_constructor_still_works() -> None:
+    result = RunResultStreaming(
+        "x",
+        [],
+        [],
+        "ok",
+        [],
+        [],
+        [],
+        [],
+        RunContextWrapper(context=None),
+        Agent(name="agent"),
+        0,
+        1,
+        None,
+        None,
+    )
+    assert result.final_output == "ok"
+    assert result.interruptions == []
+
+
+def test_run_result_streaming_v070_optional_positional_constructor_still_works() -> None:
+    event_queue: asyncio.Queue[Any] = asyncio.Queue()
+    input_guardrail_queue: asyncio.Queue[Any] = asyncio.Queue()
+    result = RunResultStreaming(
+        "x",
+        [],
+        [],
+        "ok",
+        [],
+        [],
+        [],
+        [],
+        RunContextWrapper(context=None),
+        Agent(name="agent"),
+        0,
+        1,
+        None,
+        None,
+        True,
+        [],
+        event_queue,
+        input_guardrail_queue,
+        None,
+    )
+    assert result.is_complete is True
+    assert result.run_loop_task is None
+    assert result._event_queue is event_queue
+    assert result._input_guardrail_queue is input_guardrail_queue
+    assert result.interruptions == []
+
+
+def test_run_result_streaming_accepts_legacy_run_impl_task_keyword() -> None:
+    sentinel_task = cast(Any, object())
+    result = RunResultStreaming(
+        input="x",
+        new_items=[],
+        raw_responses=[],
+        final_output="ok",
+        input_guardrail_results=[],
+        output_guardrail_results=[],
+        tool_input_guardrail_results=[],
+        tool_output_guardrail_results=[],
+        context_wrapper=RunContextWrapper(context=None),
+        current_agent=Agent(name="agent"),
+        current_turn=0,
+        max_turns=1,
+        _current_agent_output_schema=None,
+        trace=None,
+        _run_impl_task=sentinel_task,
+    )
+    assert result.run_loop_task is sentinel_task
+
+
+def test_run_result_streaming_accepts_run_loop_task_keyword() -> None:
+    sentinel_task = cast(Any, object())
+    result = RunResultStreaming(
+        input="x",
+        new_items=[],
+        raw_responses=[],
+        final_output="ok",
+        input_guardrail_results=[],
+        output_guardrail_results=[],
+        tool_input_guardrail_results=[],
+        tool_output_guardrail_results=[],
+        context_wrapper=RunContextWrapper(context=None),
+        current_agent=Agent(name="agent"),
+        current_turn=0,
+        max_turns=1,
+        _current_agent_output_schema=None,
+        trace=None,
+        run_loop_task=sentinel_task,
+    )
+    assert result.run_loop_task is sentinel_task
+
+
+def test_run_result_streaming_v070_run_impl_task_positional_binding_is_preserved() -> None:
+    sentinel_task = cast(Any, object())
+    event_queue: asyncio.Queue[Any] = asyncio.Queue()
+    input_guardrail_queue: asyncio.Queue[Any] = asyncio.Queue()
+    result = RunResultStreaming(
+        "x",
+        [],
+        [],
+        "ok",
+        [],
+        [],
+        [],
+        [],
+        RunContextWrapper(context=None),
+        Agent(name="agent"),
+        0,
+        1,
+        None,
+        None,
+        False,
+        [],
+        event_queue,
+        input_guardrail_queue,
+        sentinel_task,
+    )
+    assert result._event_queue is event_queue
+    assert result._input_guardrail_queue is input_guardrail_queue
+    assert result.run_loop_task is sentinel_task
