fix: cleanup

Author: mjschock

src/agents/_run_impl.py

@@ -359,8 +359,6 @@ async def execute_tools_and_side_effects(
         # Add all tool results to new_step_items first, including approval items.
         # This ensures ToolCallItem items from processed_response.new_items are preserved
         # in the conversation history when resuming after an interruption.
-        from .items import ToolApprovalItem
-
         # Add all function results (including approval items) to new_step_items
         for result in function_results:
             new_step_items.append(result.run_item)
@@ -991,8 +989,6 @@ async def run_single_tool(
                     needs_approval_result = func_tool.needs_approval
                     if callable(needs_approval_result):
                         # Parse arguments for dynamic approval check
-                        import json
-
                         try:
                             parsed_args = (
                                 json.loads(tool_call.arguments) if tool_call.arguments else {}
@@ -1011,8 +1007,6 @@ async def run_single_tool(
 
                         if approval_status is None:
                             # Not yet decided - need to interrupt for approval
-                            from .items import ToolApprovalItem
-
                             approval_item = ToolApprovalItem(
                                 agent=agent, raw_item=tool_call, tool_name=func_tool.name
                             )
@@ -2396,8 +2390,6 @@ def _is_apply_patch_name(name: str | None, tool: ApplyPatchTool | None) -> bool:
 def _build_litellm_json_tool_call(output: ResponseFunctionToolCall) -> FunctionTool:
     async def on_invoke_tool(_ctx: ToolContext[Any], value: Any) -> Any:
         if isinstance(value, str):
-            import json
-
             return json.loads(value)
         return value
 

src/agents/handoffs/history.py

@@ -127,7 +127,7 @@ def _build_summary_message(transcript: list[TResponseInputItem]) -> TResponseInp
     ]
     content = "\n".join(content_lines)
     summary_message: dict[str, Any] = {
-        "role": "system",
+        "role": "assistant",
         "content": content,
     }
     return cast(TResponseInputItem, summary_message)

src/agents/result.py

@@ -9,7 +9,7 @@
 
 from typing_extensions import TypeVar
 
-from ._run_impl import QueueCompleteSentinel
+from ._run_impl import NextStepInterruption, ProcessedResponse, QueueCompleteSentinel
 from .agent import Agent
 from .agent_output import AgentOutputSchemaBase
 from .exceptions import (
@@ -22,7 +22,9 @@
 from .items import ItemHelpers, ModelResponse, RunItem, TResponseInputItem
 from .logger import logger
 from .run_context import RunContextWrapper
+from .run_state import RunState
 from .stream_events import StreamEvent
+from .tool_guardrails import ToolInputGuardrailResult, ToolOutputGuardrailResult
 from .tracing import Trace
 from .util._pretty_print import (
     pretty_print_result,
@@ -201,9 +203,6 @@ def to_state(self) -> Any:
                 result = await Runner.run(agent, state)
             ```
         """
-        from ._run_impl import NextStepInterruption
-        from .run_state import RunState
-
         # Create a RunState from the current result
         state = RunState(
             context=self.context_wrapper,
@@ -508,9 +507,6 @@ def to_state(self) -> Any:
                     pass
             ```
         """
-        from ._run_impl import NextStepInterruption
-        from .run_state import RunState
-
         # Create a RunState from the current result
         state = RunState(
             context=self.context_wrapper,

src/agents/run.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import contextlib
+import dataclasses as _dc
 import inspect
 import os
 import warnings
@@ -56,8 +57,10 @@
     ModelResponse,
     ReasoningItem,
     RunItem,
+    ToolApprovalItem,
     ToolCallItem,
     ToolCallItemTypes,
+    ToolCallOutputItem,
     TResponseInputItem,
     normalize_function_call_output_payload,
 )
@@ -76,7 +79,7 @@
     RunItemStreamEvent,
     StreamEvent,
 )
-from .tool import Tool
+from .tool import FunctionTool, Tool
 from .tool_guardrails import ToolInputGuardrailResult, ToolOutputGuardrailResult
 from .tracing import Span, SpanError, agent_span, get_current_trace, trace
 from .tracing.span_data import AgentSpanData
@@ -1923,8 +1926,6 @@ async def _run_single_turn_streamed(
             event_queue=streamed_result._event_queue,
         )
 
-        import dataclasses as _dc
-
         # Filter out items that have already been sent to avoid duplicates
         items_to_filter = single_step_result.new_step_items
 
@@ -2001,8 +2002,6 @@ async def _execute_approved_tools_static(
         hooks: RunHooks[TContext],
     ) -> None:
         """Execute tools that have been approved after an interruption (classmethod version)."""
-        from .items import ToolApprovalItem, ToolCallOutputItem
-
         tool_runs: list[ToolRunFunction] = []
 
         # Find all tools from the agent
@@ -2116,8 +2115,6 @@ async def _execute_approved_tools_static(
                 continue
 
             # Only function tools can be executed via ToolRunFunction
-            from .tool import FunctionTool
-
             if not isinstance(tool, FunctionTool):
                 # Only function tools can create proper tool_call_output_item
                 error_tool_call = (
@@ -2641,7 +2638,6 @@ def _normalize_input_items(items: list[TResponseInputItem]) -> list[TResponseInp
         Returns:
             Normalized list of input items
         """
-        from .run_state import _normalize_field_names
 
         def _coerce_to_dict(value: TResponseInputItem) -> dict[str, Any] | None:
             if isinstance(value, dict):

src/agents/run_state.py

@@ -6,13 +6,54 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generic, cast
 
+from openai.types.responses import (
+    ResponseComputerToolCall,
+    ResponseFunctionToolCall,
+    ResponseOutputMessage,
+    ResponseReasoningItem,
+)
+from openai.types.responses.response_input_param import (
+    ComputerCallOutput,
+    FunctionCallOutput,
+    LocalShellCallOutput,
+    McpApprovalResponse,
+)
+from openai.types.responses.response_output_item import (
+    McpApprovalRequest,
+    McpListTools,
+)
+from pydantic import TypeAdapter, ValidationError
 from typing_extensions import TypeVar
 
-from ._run_impl import NextStepInterruption
+from ._run_impl import (
+    NextStepInterruption,
+    ProcessedResponse,
+    ToolRunComputerAction,
+    ToolRunFunction,
+    ToolRunHandoff,
+    ToolRunMCPApprovalRequest,
+)
 from .exceptions import UserError
-from .items import ToolApprovalItem, normalize_function_call_output_payload
+from .handoffs import Handoff
+from .items import (
+    HandoffCallItem,
+    HandoffOutputItem,
+    MCPApprovalRequestItem,
+    MCPApprovalResponseItem,
+    MCPListToolsItem,
+    MessageOutputItem,
+    ModelResponse,
+    ReasoningItem,
+    RunItem,
+    ToolApprovalItem,
+    ToolCallItem,
+    ToolCallOutputItem,
+    TResponseInputItem,
+    normalize_function_call_output_payload,
+)
 from .logger import logger
 from .run_context import RunContextWrapper
+from .tool import ComputerTool, FunctionTool, HostedMCPTool
 from .usage import Usage
 
 if TYPE_CHECKING:
@@ -285,6 +326,17 @@ def to_json(self) -> dict[str, Any]:
                         # Look it up from the corresponding function_call if missing
                         if "name" not in normalized_item and call_id:
                             normalized_item["name"] = call_id_to_name.get(call_id, "")
+                    # Convert assistant messages with string content to array format
+                    # TypeScript SDK requires content to be an array for assistant messages
+                    role = normalized_item.get("role")
+                    if role == "assistant":
+                        content = normalized_item.get("content")
+                        if isinstance(content, str):
+                            # Convert string content to array format with output_text
+                            normalized_item["content"] = [{"type": "output_text", "text": content}]
+                        # Ensure status field is present (required by TypeScript schema)
+                        if "status" not in normalized_item:
+                            normalized_item["status"] = "completed"
                     # Normalize field names to camelCase for JSON (call_id -> callId)
                     normalized_item = self._camelize_field_names(normalized_item)
                     normalized_items.append(normalized_item)
@@ -745,8 +797,6 @@ async def from_string(
         # Reconstruct current step if it's an interruption
         current_step_data = state_json.get("currentStep")
         if current_step_data and current_step_data.get("type") == "next_step_interruption":
-            from openai.types.responses import ResponseFunctionToolCall
-
             interruptions: list[RunItem] = []
             # Handle both old format (interruptions directly) and new format (wrapped in data)
             interruptions_data = current_step_data.get("data", {}).get(
@@ -880,8 +930,6 @@ async def from_json(
         # Reconstruct current step if it's an interruption
         current_step_data = state_json.get("currentStep")
         if current_step_data and current_step_data.get("type") == "next_step_interruption":
-            from openai.types.responses import ResponseFunctionToolCall
-
             interruptions: list[RunItem] = []
             # Handle both old format (interruptions directly) and new format (wrapped in data)
             interruptions_data = current_step_data.get("data", {}).get(
@@ -920,15 +968,6 @@ async def _deserialize_processed_response(
     Returns:
         A reconstructed ProcessedResponse instance.
     """
-    from ._run_impl import (
-        ProcessedResponse,
-        ToolRunComputerAction,
-        ToolRunFunction,
-        ToolRunHandoff,
-        ToolRunMCPApprovalRequest,
-    )
-    from .tool import FunctionTool
-
     # Deserialize new items
     new_items = _deserialize_items(processed_response_data.get("newItems", []), agent_map)
 
@@ -944,13 +983,9 @@ async def _deserialize_processed_response(
         tool.name: tool for tool in all_tools if hasattr(tool, "type") and tool.type == "computer"
     }
     # Build MCP tools map
-    from .tool import HostedMCPTool
-
     mcp_tools_map = {tool.name: tool for tool in all_tools if isinstance(tool, HostedMCPTool)}
 
     # Get handoffs from the agent
-    from .handoffs import Handoff
-
     handoffs_map: dict[str, Handoff[Any, Agent[Any]]] = {}
     if hasattr(current_agent, "handoffs"):
         for handoff in current_agent.handoffs:
@@ -969,8 +1004,6 @@ async def _deserialize_processed_response(
             "handoff", {}
         ).get("tool_name")
         if handoff_name and handoff_name in handoffs_map:
-            from openai.types.responses import ResponseFunctionToolCall
-
             tool_call = ResponseFunctionToolCall(**tool_call_data)
             handoff = handoffs_map[handoff_name]
             handoffs.append(ToolRunHandoff(tool_call=tool_call, handoff=handoff))
@@ -981,22 +1014,16 @@ async def _deserialize_processed_response(
         tool_call_data = _normalize_field_names(func_data.get("toolCall", {}))
         tool_name = func_data.get("tool", {}).get("name")
         if tool_name and tool_name in tools_map:
-            from openai.types.responses import ResponseFunctionToolCall
-
             tool_call = ResponseFunctionToolCall(**tool_call_data)
             function_tool = tools_map[tool_name]
             functions.append(ToolRunFunction(tool_call=tool_call, function_tool=function_tool))
 
     # Deserialize computer actions
-    from .tool import ComputerTool
-
     computer_actions = []
     for action_data in processed_response_data.get("computerActions", []):
         tool_call_data = _normalize_field_names(action_data.get("toolCall", {}))
         computer_name = action_data.get("computer", {}).get("name")
         if computer_name and computer_name in computer_tools_map:
-            from openai.types.responses import ResponseComputerToolCall
-
             computer_tool_call = ResponseComputerToolCall(**tool_call_data)
             computer_tool = computer_tools_map[computer_name]
             # Only include ComputerTool instances
@@ -1011,9 +1038,6 @@ async def _deserialize_processed_response(
         request_item_data = request_data.get("requestItem", {})
         raw_item_data = _normalize_field_names(request_item_data.get("rawItem", {}))
         # Create a McpApprovalRequest from the raw item data
-        from openai.types.responses.response_output_item import McpApprovalRequest
-        from pydantic import TypeAdapter
-
         request_item_adapter: TypeAdapter[McpApprovalRequest] = TypeAdapter(McpApprovalRequest)
         request_item = request_item_adapter.validate_python(raw_item_data)
 
@@ -1135,8 +1159,6 @@ def _deserialize_model_responses(responses_data: list[dict[str, Any]]) -> list[M
         List of ModelResponse instances.
     """
 
-    from .items import ModelResponse
-
     result = []
     for resp_data in responses_data:
         usage = Usage()
@@ -1145,8 +1167,6 @@ def _deserialize_model_responses(responses_data: list[dict[str, Any]]) -> list[M
         usage.output_tokens = resp_data["usage"]["outputTokens"]
         usage.total_tokens = resp_data["usage"]["totalTokens"]
 
-        from pydantic import TypeAdapter
-
         # Normalize output items from JSON format (camelCase) to Python format (snake_case)
         normalized_output = [
             _normalize_field_names(item) if isinstance(item, dict) else item
@@ -1182,28 +1202,6 @@ def _deserialize_items(
     Returns:
         List of RunItem instances.
     """
-    from openai.types.responses import (
-        ResponseFunctionToolCall,
-        ResponseOutputMessage,
-        ResponseReasoningItem,
-    )
-    from openai.types.responses.response_output_item import (
-        McpApprovalRequest,
-        McpListTools,
-    )
-
-    from .items import (
-        HandoffCallItem,
-        HandoffOutputItem,
-        MCPApprovalRequestItem,
-        MCPApprovalResponseItem,
-        MCPListToolsItem,
-        MessageOutputItem,
-        ReasoningItem,
-        ToolApprovalItem,
-        ToolCallItem,
-        ToolCallOutputItem,
-    )
 
     result: list[RunItem] = []
 
@@ -1264,13 +1262,6 @@ def _deserialize_items(
 
             elif item_type == "tool_call_output_item":
                 # For tool call outputs, validate and convert the raw dict
-                from openai.types.responses.response_input_param import (
-                    ComputerCallOutput,
-                    FunctionCallOutput,
-                    LocalShellCallOutput,
-                )
-                from pydantic import TypeAdapter
-
                 # Try to determine the type based on the dict structure
                 normalized_raw_item = _convert_protocol_result_to_api(normalized_raw_item)
                 output_type = normalized_raw_item.get("type")
@@ -1320,10 +1311,6 @@ def _deserialize_items(
                     # For handoff output items, we need to validate the raw_item
                     # as a TResponseInputItem (which is a union type)
                     # If validation fails, use the raw dict as-is (for test compatibility)
-                    from pydantic import TypeAdapter, ValidationError
-
-                    from .items import TResponseInputItem
-
                     try:
                         input_item_adapter: TypeAdapter[TResponseInputItem] = TypeAdapter(
                             TResponseInputItem
@@ -1355,9 +1342,6 @@ def _deserialize_items(
 
             elif item_type == "mcp_approval_response_item":
                 # Validate and convert the raw dict to McpApprovalResponse
-                from openai.types.responses.response_input_param import McpApprovalResponse
-                from pydantic import TypeAdapter
-
                 approval_response_adapter: TypeAdapter[McpApprovalResponse] = TypeAdapter(
                     McpApprovalResponse
                 )