Merge branch 'main' into feat/stt-event-name-alias

Author: dudududukim

examples/basic/sqlalchemy_session_example.py

@@ -0,0 +1,50 @@
+import asyncio
+
+from agents import Agent, Runner
+from agents.extensions.memory.sqlalchemy_session import SQLAlchemySession
+
+
+async def main():
+    # Create an agent
+    agent = Agent(
+        name="Assistant",
+        instructions="Reply very concisely.",
+    )
+
+    # Create a session instance with a session ID.
+    # This example uses an in-memory SQLite database.
+    # The `create_tables=True` flag is useful for development and testing.
+    session = SQLAlchemySession.from_url(
+        "conversation_123",
+        url="sqlite+aiosqlite:///:memory:",
+        create_tables=True,
+    )
+
+    print("=== SQLAlchemySession Example ===")
+    print("The agent will remember previous messages automatically.\n")
+
+    # First turn
+    print("User: What city is the Golden Gate Bridge in?")
+    result = await Runner.run(
+        agent,
+        "What city is the Golden Gate Bridge in?",
+        session=session,
+    )
+    print(f"Assistant: {result.final_output}\n")
+
+    # Second turn - the agent will remember the previous conversation
+    print("User: What state is it in?")
+    result = await Runner.run(
+        agent,
+        "What state is it in?",
+        session=session,
+    )
+    print(f"Assistant: {result.final_output}\n")
+
+    print("=== Conversation Complete ===")
+
+
+if __name__ == "__main__":
+    # To run this example, you need to install the sqlalchemy extras:
+    # pip install "agents[sqlalchemy]"
+    asyncio.run(main())

examples/financial_research_agent/agents/search_agent.py

@@ -12,6 +12,7 @@
 
 search_agent = Agent(
     name="FinancialSearchAgent",
+    model="gpt-4.1",
     instructions=INSTRUCTIONS,
     tools=[WebSearchTool()],
     model_settings=ModelSettings(tool_choice="required"),

examples/handoffs/message_filter.py

@@ -5,6 +5,7 @@
 
 from agents import Agent, HandoffInputData, Runner, function_tool, handoff, trace
 from agents.extensions import handoff_filters
+from agents.models import is_gpt_5_default
 
 
 @function_tool
@@ -14,6 +15,15 @@ def random_number_tool(max: int) -> int:
 
 
 def spanish_handoff_message_filter(handoff_message_data: HandoffInputData) -> HandoffInputData:
+    if is_gpt_5_default():
+        print("gpt-5 is enabled, so we're not filtering the input history")
+        # when using gpt-5, removing some of the items could break things, so we do this filtering only for other models
+        return HandoffInputData(
+            input_history=handoff_message_data.input_history,
+            pre_handoff_items=tuple(handoff_message_data.pre_handoff_items),
+            new_items=tuple(handoff_message_data.new_items),
+        )
+
     # First, we'll remove any tool-related messages from the message history
     handoff_message_data = handoff_filters.remove_all_tools(handoff_message_data)
 

examples/handoffs/message_filter_streaming.py

@@ -5,6 +5,7 @@
 
 from agents import Agent, HandoffInputData, Runner, function_tool, handoff, trace
 from agents.extensions import handoff_filters
+from agents.models import is_gpt_5_default
 
 
 @function_tool
@@ -14,6 +15,15 @@ def random_number_tool(max: int) -> int:
 
 
 def spanish_handoff_message_filter(handoff_message_data: HandoffInputData) -> HandoffInputData:
+    if is_gpt_5_default():
+        print("gpt-5 is enabled, so we're not filtering the input history")
+        # when using gpt-5, removing some of the items could break things, so we do this filtering only for other models
+        return HandoffInputData(
+            input_history=handoff_message_data.input_history,
+            pre_handoff_items=tuple(handoff_message_data.pre_handoff_items),
+            new_items=tuple(handoff_message_data.new_items),
+        )
+
     # First, we'll remove any tool-related messages from the message history
     handoff_message_data = handoff_filters.remove_all_tools(handoff_message_data)
 

examples/hosted_mcp/approvals.py

@@ -44,7 +44,10 @@ async def main(verbose: bool, stream: bool):
                 print(f"Got event of type {event.item.__class__.__name__}")
         print(f"Done streaming; final result: {result.final_output}")
     else:
-        res = await Runner.run(agent, "Which language is this repo written in?")
+        res = await Runner.run(
+            agent,
+            "Which language is this repo written in? Your MCP server should know what the repo is.",
+        )
         print(res.final_output)
 
     if verbose:

examples/hosted_mcp/simple.py

@@ -29,7 +29,10 @@ async def main(verbose: bool, stream: bool):
                 print(f"Got event of type {event.item.__class__.__name__}")
         print(f"Done streaming; final result: {result.final_output}")
     else:
-        res = await Runner.run(agent, "Which language is this repo written in?")
+        res = await Runner.run(
+            agent,
+            "Which language is this repo written in? Your MCP server should know what the repo is.",
+        )
         print(res.final_output)
         # The repository is primarily written in multiple languages, including Rust and TypeScript...
 

examples/realtime/app/server.py

@@ -4,11 +4,12 @@
 import logging
 import struct
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, assert_never
+from typing import TYPE_CHECKING, Any
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
+from typing_extensions import assert_never
 
 from agents.realtime import RealtimeRunner, RealtimeSession, RealtimeSessionEvent
 
@@ -111,6 +112,8 @@ async def _serialize_event(self, event: RealtimeSessionEvent) -> dict[str, Any]:
             }
         elif event.type == "error":
             base_event["error"] = str(event.error) if hasattr(event, "error") else "Unknown error"
+        elif event.type == "input_audio_timeout_triggered":
+            pass
         else:
             assert_never(event)
 

examples/realtime/cli/demo.py

@@ -52,7 +52,7 @@ def __init__(self) -> None:
         # Audio output state for callback system
         self.output_queue: queue.Queue[Any] = queue.Queue(maxsize=10)  # Buffer more chunks
         self.interrupt_event = threading.Event()
-        self.current_audio_chunk: np.ndarray | None = None  # type: ignore
+        self.current_audio_chunk: np.ndarray[Any, np.dtype[Any]] | None = None
         self.chunk_position = 0
 
     def _output_callback(self, outdata, frames: int, time, status) -> None:

examples/reasoning_content/main.py

@@ -1,25 +1,26 @@
 """
 Example demonstrating how to use the reasoning content feature with models that support it.
 
-Some models, like deepseek-reasoner, provide a reasoning_content field in addition to the regular content.
+Some models, like gpt-5, provide a reasoning_content field in addition to the regular content.
 This example shows how to access and use this reasoning content from both streaming and non-streaming responses.
 
 To run this example, you need to:
 1. Set your OPENAI_API_KEY environment variable
-2. Use a model that supports reasoning content (e.g., deepseek-reasoner)
+2. Use a model that supports reasoning content (e.g., gpt-5)
 """
 
 import asyncio
 import os
 from typing import Any, cast
 
 from openai.types.responses import ResponseOutputRefusal, ResponseOutputText
+from openai.types.shared.reasoning import Reasoning
 
 from agents import ModelSettings
 from agents.models.interface import ModelTracing
 from agents.models.openai_provider import OpenAIProvider
 
-MODEL_NAME = os.getenv("EXAMPLE_MODEL_NAME") or "deepseek-reasoner"
+MODEL_NAME = os.getenv("EXAMPLE_MODEL_NAME") or "gpt-5"
 
 
 async def stream_with_reasoning_content():
@@ -36,10 +37,11 @@ async def stream_with_reasoning_content():
     reasoning_content = ""
     regular_content = ""
 
+    output_text_already_started = False
     async for event in model.stream_response(
         system_instructions="You are a helpful assistant that writes creative content.",
         input="Write a haiku about recursion in programming",
-        model_settings=ModelSettings(),
+        model_settings=ModelSettings(reasoning=Reasoning(effort="medium", summary="detailed")),
         tools=[],
         output_schema=None,
         handoffs=[],
@@ -48,18 +50,16 @@ async def stream_with_reasoning_content():
         prompt=None,
     ):
         if event.type == "response.reasoning_summary_text.delta":
-            print(
-                f"\033[33m{event.delta}\033[0m", end="", flush=True
-            )  # Yellow for reasoning content
+            # Yellow for reasoning content
+            print(f"\033[33m{event.delta}\033[0m", end="", flush=True)
             reasoning_content += event.delta
         elif event.type == "response.output_text.delta":
-            print(f"\033[32m{event.delta}\033[0m", end="", flush=True)  # Green for regular content
+            if not output_text_already_started:
+                print("\n")
+                output_text_already_started = True
+            # Green for regular content
+            print(f"\033[32m{event.delta}\033[0m", end="", flush=True)
             regular_content += event.delta
-
-    print("\n\nReasoning Content:")
-    print(reasoning_content)
-    print("\nRegular Content:")
-    print(regular_content)
     print("\n")
 
 
@@ -77,7 +77,7 @@ async def get_response_with_reasoning_content():
     response = await model.get_response(
         system_instructions="You are a helpful assistant that explains technical concepts clearly.",
         input="Explain the concept of recursion in programming",
-        model_settings=ModelSettings(),
+        model_settings=ModelSettings(reasoning=Reasoning(effort="medium", summary="detailed")),
         tools=[],
         output_schema=None,
         handoffs=[],
@@ -102,12 +102,10 @@ async def get_response_with_reasoning_content():
                     refusal_item = cast(Any, content_item)
                     regular_content = refusal_item.refusal
 
-    print("\nReasoning Content:")
+    print("\n\n### Reasoning Content:")
     print(reasoning_content or "No reasoning content provided")
-
-    print("\nRegular Content:")
+    print("\n\n### Regular Content:")
     print(regular_content or "No regular content provided")
-
     print("\n")
 
 
@@ -118,7 +116,7 @@ async def main():
     except Exception as e:
         print(f"Error: {e}")
         print("\nNote: This example requires a model that supports reasoning content.")
-        print("You may need to use a specific model like deepseek-reasoner or similar.")
+        print("You may need to use a specific model like gpt-5 or similar.")
 
 
 if __name__ == "__main__":

examples/reasoning_content/runner_example.py

@@ -6,17 +6,18 @@
 
 To run this example, you need to:
 1. Set your OPENAI_API_KEY environment variable
-2. Use a model that supports reasoning content (e.g., deepseek-reasoner)
+2. Use a model that supports reasoning content (e.g., gpt-5)
 """
 
 import asyncio
 import os
-from typing import Any
 
-from agents import Agent, Runner, trace
+from openai.types.shared.reasoning import Reasoning
+
+from agents import Agent, ModelSettings, Runner, trace
 from agents.items import ReasoningItem
 
-MODEL_NAME = os.getenv("EXAMPLE_MODEL_NAME") or "deepseek-reasoner"
+MODEL_NAME = os.getenv("EXAMPLE_MODEL_NAME") or "gpt-5"
 
 
 async def main():
@@ -27,6 +28,7 @@ async def main():
         name="Reasoning Agent",
         instructions="You are a helpful assistant that explains your reasoning step by step.",
         model=MODEL_NAME,
+        model_settings=ModelSettings(reasoning=Reasoning(effort="medium", summary="detailed")),
     )
 
     # Example 1: Non-streaming response
@@ -35,53 +37,34 @@ async def main():
         result = await Runner.run(
             agent, "What is the square root of 841? Please explain your reasoning."
         )
-
         # Extract reasoning content from the result items
         reasoning_content = None
-        # RunResult has 'response' attribute which has 'output' attribute
-        for item in result.response.output:  # type: ignore
-            if isinstance(item, ReasoningItem):
-                reasoning_content = item.summary[0].text  # type: ignore
+        for item in result.new_items:
+            if isinstance(item, ReasoningItem) and len(item.raw_item.summary) > 0:
+                reasoning_content = item.raw_item.summary[0].text
                 break
 
-        print("\nReasoning Content:")
+        print("\n### Reasoning Content:")
         print(reasoning_content or "No reasoning content provided")
-
-        print("\nFinal Output:")
+        print("\n### Final Output:")
         print(result.final_output)
 
     # Example 2: Streaming response
     with trace("Reasoning Content - Streaming"):
         print("\n=== Example 2: Streaming response ===")
-        print("\nStreaming response:")
-
-        # Buffers to collect reasoning and regular content
-        reasoning_buffer = ""
-        content_buffer = ""
-
-        # RunResultStreaming is async iterable
         stream = Runner.run_streamed(agent, "What is 15 x 27? Please explain your reasoning.")
-
-        async for event in stream:  # type: ignore
-            if isinstance(event, ReasoningItem):
-                # This is reasoning content
-                reasoning_item: Any = event
-                reasoning_buffer += reasoning_item.summary[0].text
-                print(
-                    f"\033[33m{reasoning_item.summary[0].text}\033[0m", end="", flush=True
-                )  # Yellow for reasoning
-            elif hasattr(event, "text"):
-                # This is regular content
-                content_buffer += event.text
-                print(
-                    f"\033[32m{event.text}\033[0m", end="", flush=True
-                )  # Green for regular content
-
-        print("\n\nCollected Reasoning Content:")
-        print(reasoning_buffer)
-
-        print("\nCollected Final Answer:")
-        print(content_buffer)
+        output_text_already_started = False
+        async for event in stream.stream_events():
+            if event.type == "raw_response_event":
+                if event.data.type == "response.reasoning_summary_text.delta":
+                    print(f"\033[33m{event.data.delta}\033[0m", end="", flush=True)
+                elif event.data.type == "response.output_text.delta":
+                    if not output_text_already_started:
+                        print("\n")
+                        output_text_already_started = True
+                    print(f"\033[32m{event.data.delta}\033[0m", end="", flush=True)
+
+        print("\n")
 
 
 if __name__ == "__main__":