Merge branch 'main' into hironow/chore-doc-type

# Conflicts:
#	tests/docs/config.md
#	tests/docs/guardrails.md
#	tests/docs/tracing.md

Author: hironow

.gitignore

@@ -3,6 +3,7 @@
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
+**/__pycache__/
 *.py[cod]
 *$py.class
 

README.md

@@ -118,7 +118,7 @@ When you call `Runner.run()`, we run a loop until we get a final output.
 2. The LLM returns a response, which may include tool calls.
 3. If the response has a final output (see below for the more on this), we return it and end the loop.
 4. If the response has a handoff, we set the agent to the new agent and go back to step 1.
-5. We process the tool calls (if any) and append the tool responses messsages. Then we go to step 1.
+5. We process the tool calls (if any) and append the tool responses messages. Then we go to step 1.
 
 There is a `max_turns` parameter that you can use to limit the number of times the loop executes.
 

docs/multi_agent.md

@@ -27,11 +27,11 @@ This pattern is great when the task is open-ended and you want to rely on the in
 
 ## Orchestrating via code
 
-While orchestrating via LLM is powerful, orchestrating via LLM makes tasks more deterministic and predictable, in terms of speed, cost and performance. Common patterns here are:
+While orchestrating via LLM is powerful, orchestrating via code makes tasks more deterministic and predictable, in terms of speed, cost and performance. Common patterns here are:
 
 -   Using [structured outputs](https://platform.openai.com/docs/guides/structured-outputs) to generate well formed data that you can inspect with your code. For example, you might ask an agent to classify the task into a few categories, and then pick the next agent based on the category.
 -   Chaining multiple agents by transforming the output of one into the input of the next. You can decompose a task like writing a blog post into a series of steps - do research, write an outline, write the blog post, critique it, and then improve it.
 -   Running the agent that performs the task in a `while` loop with an agent that evaluates and provides feedback, until the evaluator says the output passes certain criteria.
 -   Running multiple agents in parallel, e.g. via Python primitives like `asyncio.gather`. This is useful for speed when you have multiple tasks that don't depend on each other.
 
-We have a number of examples in [`examples/agent_patterns`](https://github.com/openai/openai-agents-python/examples/agent_patterns).
+We have a number of examples in [`examples/agent_patterns`](https://github.com/openai/openai-agents-python/tree/main/examples/agent_patterns).

docs/results.md

@@ -32,7 +32,7 @@ The [`new_items`][agents.result.RunResultBase.new_items] property contains the n
 
 -   [`MessageOutputItem`][agents.items.MessageOutputItem] indicates a message from the LLM. The raw item is the message generated.
 -   [`HandoffCallItem`][agents.items.HandoffCallItem] indicates that the LLM called the handoff tool. The raw item is the tool call item from the LLM.
--   [`HandoffOutputItem`][agents.items.HandoffOutputItem] indicates that a handoff occured. The raw item is the tool response to the handoff tool call. You can also access the source/target agents from the item.
+-   [`HandoffOutputItem`][agents.items.HandoffOutputItem] indicates that a handoff occurred. The raw item is the tool response to the handoff tool call. You can also access the source/target agents from the item.
 -   [`ToolCallItem`][agents.items.ToolCallItem] indicates that the LLM invoked a tool.
 -   [`ToolCallOutputItem`][agents.items.ToolCallOutputItem] indicates that a tool was called. The raw item is the tool response. You can also access the tool output from the item.
 -   [`ReasoningItem`][agents.items.ReasoningItem] indicates a reasoning item from the LLM. The raw item is the reasoning generated.

examples/agent_patterns/README.md

@@ -51,4 +51,4 @@ You can definitely do this without any special Agents SDK features by using para
 
 This is really useful for latency: for example, you might have a very fast model that runs the guardrail and a slow model that runs the actual agent. You wouldn't want to wait for the slow model to finish, so guardrails let you quickly reject invalid inputs.
 
-See the [`guardrails.py`](./guardrails.py) file for an example of this.
+See the [`input_guardrails.py`](./input_guardrails.py) and [`output_guardrails.py`](./output_guardrails.py) files for examples.

examples/research_bot/README.md

@@ -21,5 +21,5 @@ If you're building your own research bot, some ideas to add to this are:
 
 1. Retrieval: Add support for fetching relevant information from a vector store. You could use the File Search tool for this.
 2. Image and file upload: Allow users to attach PDFs or other files, as baseline context for the research.
-3. More planning and thinking: Models often produce better results given more time to think. Improve the planning process to come up with a better plan, and add an evaluation step so that the model can choose to improve it's results, search for more stuff, etc.
+3. More planning and thinking: Models often produce better results given more time to think. Improve the planning process to come up with a better plan, and add an evaluation step so that the model can choose to improve its results, search for more stuff, etc.
 4. Code execution: Allow running code, which is useful for data analysis.

examples/research_bot/agents/__pycache__/__init__.cpython-313.pyc

@@ -1,6 +1,5 @@
 import asyncio
 import base64
-import logging
 from typing import Literal, Union
 
 from playwright.async_api import Browser, Page, Playwright, async_playwright
@@ -16,8 +15,10 @@
     trace,
 )
 
-logging.getLogger("openai.agents").setLevel(logging.DEBUG)
-logging.getLogger("openai.agents").addHandler(logging.StreamHandler())
+# Uncomment to see very verbose logs
+# import logging
+# logging.getLogger("openai.agents").setLevel(logging.DEBUG)
+# logging.getLogger("openai.agents").addHandler(logging.StreamHandler())
 
 
 async def main():

examples/research_bot/agents/__pycache__/base_agent.cpython-313.pyc

@@ -1,6 +1,6 @@
 [project]
 name = "openai-agents"
-version = "0.0.2"
+version = "0.0.3"
 description = "OpenAI Agents SDK"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -9,7 +9,7 @@ authors = [
     { name = "OpenAI", email = "[email protected]" },
 ]
 dependencies = [
-    "openai>=1.66.0",
+    "openai>=1.66.2",
     "pydantic>=2.10, <3",
     "griffe>=1.5.6, <2",
     "typing-extensions>=4.12.2, <5",

examples/research_bot/agents/__pycache__/planner_agent.cpython-313.pyc

@@ -23,7 +23,7 @@
     ActionWait,
 )
 from openai.types.responses.response_input_param import ComputerCallOutput
-from openai.types.responses.response_output_item import Reasoning
+from openai.types.responses.response_reasoning_item import ResponseReasoningItem
 
 from . import _utils
 from .agent import Agent
@@ -288,7 +288,7 @@ def process_model_response(
                 items.append(ToolCallItem(raw_item=output, agent=agent))
             elif isinstance(output, ResponseFunctionWebSearch):
                 items.append(ToolCallItem(raw_item=output, agent=agent))
-            elif isinstance(output, Reasoning):
+            elif isinstance(output, ResponseReasoningItem):
                 items.append(ReasoningItem(raw_item=output, agent=agent))
             elif isinstance(output, ResponseComputerToolCall):
                 items.append(ToolCallItem(raw_item=output, agent=agent))

examples/research_bot/agents/__pycache__/research_manager_agent.cpython-313.pyc

@@ -138,7 +138,7 @@ def _type_to_str(t: type[Any]) -> str:
         # It's a simple type like `str`, `int`, etc.
         return t.__name__
     elif args:
-        args_str = ', '.join(_type_to_str(arg) for arg in args)
+        args_str = ", ".join(_type_to_str(arg) for arg in args)
         return f"{origin.__name__}[{args_str}]"
     else:
         return str(t)

examples/research_bot/agents/__pycache__/search_agent.cpython-313.pyc

@@ -19,7 +19,7 @@
     ResponseStreamEvent,
 )
 from openai.types.responses.response_input_item_param import ComputerCallOutput, FunctionCallOutput
-from openai.types.responses.response_output_item import Reasoning
+from openai.types.responses.response_reasoning_item import ResponseReasoningItem
 from pydantic import BaseModel
 from typing_extensions import TypeAlias
 
@@ -136,10 +136,10 @@ class ToolCallOutputItem(RunItemBase[Union[FunctionCallOutput, ComputerCallOutpu
 
 
 @dataclass
-class ReasoningItem(RunItemBase[Reasoning]):
+class ReasoningItem(RunItemBase[ResponseReasoningItem]):
     """Represents a reasoning item."""
 
-    raw_item: Reasoning
+    raw_item: ResponseReasoningItem
     """The raw reasoning item."""
 
     type: Literal["reasoning_item"] = "reasoning_item"

examples/research_bot/agents/__pycache__/summarization_agent.cpython-313.pyc

@@ -11,6 +11,7 @@ class ModelSettings:
     This class holds optional model configuration parameters (e.g. temperature,
     top_p, penalties, truncation, etc.).
     """
+
     temperature: float | None = None
     top_p: float | None = None
     frequency_penalty: float | None = None

examples/research_bot/agents/__pycache__/writer_agent.cpython-313.pyc

@@ -361,7 +361,7 @@ def _convert_tool(cls, tool: Tool) -> tuple[ToolParam, IncludeLiteral | None]:
             includes = "file_search_call.results" if tool.include_search_results else None
         elif isinstance(tool, ComputerTool):
             converted_tool = {
-                "type": "computer-preview",
+                "type": "computer_use_preview",
                 "environment": tool.computer.environment,
                 "display_width": tool.computer.dimensions[0],
                 "display_height": tool.computer.dimensions[1],

examples/tools/computer_use.py

@@ -284,3 +284,5 @@ def decorator(real_func: ToolFunction[...]) -> FunctionTool:
         return _create_function_tool(real_func)
 
     return decorator
+    return decorator
+    return decorator