openai-agents 0.0.6__tar.gz → 0.0.7__tar.gz

{openai_agents-0.0.6 → openai_agents-0.0.7}/.github/workflows/issues.yml

@@ -17,7 +17,10 @@ jobs:
           stale-issue-label: "stale"
           stale-issue-message: "This issue is stale because it has been open for 7 days with no activity."
           close-issue-message: "This issue was closed because it has been inactive for 3 days since being marked as stale."
-          days-before-pr-stale: -1
-          days-before-pr-close: -1
-          any-of-labels: 'question,needs-more-info'
+          any-of-issue-labels: 'question,needs-more-info'
+          days-before-pr-stale: 10
+          days-before-pr-close: 7
+          stale-pr-label: "stale"
+          stale-pr-message: "This PR is stale because it has been open for 10 days with no activity."
+          close-pr-message: "This PR was closed because it has been inactive for 7 days since being marked as stale."
           repo-token: ${{ secrets.GITHUB_TOKEN }}

{openai_agents-0.0.6 → openai_agents-0.0.7}/.github/workflows/tests.yml

@@ -8,6 +8,9 @@ on:
     branches:
       - main
 
+env:
+  UV_FROZEN: "1"
+
 jobs:
   lint:
     runs-on: ubuntu-latest

{openai_agents-0.0.6 → openai_agents-0.0.7}/.gitignore

@@ -135,10 +135,10 @@ dmypy.json
 cython_debug/
 
 # PyCharm
-#.idea/
+.idea/
 
 # Ruff stuff:
 .ruff_cache/
 
 # PyPI configuration file
-.pypirc
+.pypirc

{openai_agents-0.0.6 → openai_agents-0.0.7}/Makefile

@@ -5,6 +5,7 @@ sync:
 .PHONY: format
 format: 
 	uv run ruff format
+	uv run ruff check --fix
 
 .PHONY: lint
 lint: 
@@ -36,7 +37,6 @@ snapshots-create:
 .PHONY: old_version_tests
 old_version_tests: 
 	UV_PROJECT_ENVIRONMENT=.venv_39 uv run --python 3.9 -m pytest
-	UV_PROJECT_ENVIRONMENT=.venv_39 uv run --python 3.9 -m mypy .
 
 .PHONY: build-docs
 build-docs:

{openai_agents-0.0.6 → openai_agents-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openai-agents
-Version: 0.0.6
+Version: 0.0.7
 Summary: OpenAI Agents SDK
 Project-URL: Homepage, https://github.com/openai/openai-agents-python
 Project-URL: Repository, https://github.com/openai/openai-agents-python
@@ -19,11 +19,14 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Requires-Dist: griffe<2,>=1.5.6
+Requires-Dist: mcp; python_version >= '3.10'
 Requires-Dist: openai>=1.66.5
 Requires-Dist: pydantic<3,>=2.10
 Requires-Dist: requests<3,>=2.0
 Requires-Dist: types-requests<3,>=2.0
 Requires-Dist: typing-extensions<5,>=4.12.2
+Provides-Extra: viz
+Requires-Dist: graphviz>=0.17; extra == 'viz'
 Provides-Extra: voice
 Requires-Dist: numpy<3,>=2.2.0; (python_version >= '3.10') and extra == 'voice'
 Requires-Dist: websockets<16,>=15.0; extra == 'voice'
@@ -61,7 +64,7 @@ source env/bin/activate
 pip install openai-agents
 ```
 
-For voice support, install with the optional `voice` group: `pip install openai-agents[voice]`.
+For voice support, install with the optional `voice` group: `pip install 'openai-agents[voice]'`.
 
 ## Hello world example
 

{openai_agents-0.0.6 → openai_agents-0.0.7}/README.md

@@ -30,7 +30,7 @@ source env/bin/activate
 pip install openai-agents
 ```
 
-For voice support, install with the optional `voice` group: `pip install openai-agents[voice]`.
+For voice support, install with the optional `voice` group: `pip install 'openai-agents[voice]'`.
 
 ## Hello world example
 

{openai_agents-0.0.6 → openai_agents-0.0.7}/docs/agents.md

@@ -142,4 +142,6 @@ Supplying a list of tools doesn't always mean the LLM will use a tool. You can f
 
 !!! note
 
-    If requiring tool use, you should consider setting [`Agent.tool_use_behavior`] to stop the Agent from running when a tool output is produced. Otherwise, the Agent might run in an infinite loop, where the LLM produces a tool call , and the tool result is sent to the LLM, and this infinite loops because the LLM is always forced to use a tool.
+    To prevent infinite loops, the framework automatically resets `tool_choice` to "auto" after a tool call. This behavior is configurable via [`agent.reset_tool_choice`][agents.agent.Agent.reset_tool_choice]. The infinite loop is because tool results are sent to the LLM, which then generates another tool call because of `tool_choice`, ad infinitum.
+
+    If you want the Agent to completely stop after a tool call (rather than continuing with auto mode), you can set [`Agent.tool_use_behavior="stop_on_first_tool"`] which will directly use the tool output as the final response without further LLM processing.

{openai_agents-0.0.6 → openai_agents-0.0.7}/docs/context.md

@@ -41,14 +41,14 @@ async def fetch_user_age(wrapper: RunContextWrapper[UserInfo]) -> str:  # (2)!
     return f"User {wrapper.context.name} is 47 years old"
 
 async def main():
-    user_info = UserInfo(name="John", uid=123)  # (3)!
+    user_info = UserInfo(name="John", uid=123)
 
-    agent = Agent[UserInfo](  # (4)!
+    agent = Agent[UserInfo](  # (3)!
         name="Assistant",
         tools=[fetch_user_age],
     )
 
-    result = await Runner.run(
+    result = await Runner.run(  # (4)!
         starting_agent=agent,
         input="What is the age of the user?",
         context=user_info,

{openai_agents-0.0.6 → openai_agents-0.0.7}/docs/guardrails.md

@@ -29,7 +29,7 @@ Output guardrails run in 3 steps:
 
 !!! Note
 
-    Output guardrails are intended to run on the final agent input, so an agent's guardrails only run if the agent is the *last* agent. Similar to the input guardrails, we do this because guardrails tend to be related to the actual Agent - you'd run different guardrails for different agents, so colocating the code is useful for readability.
+    Output guardrails are intended to run on the final agent output, so an agent's guardrails only run if the agent is the *last* agent. Similar to the input guardrails, we do this because guardrails tend to be related to the actual Agent - you'd run different guardrails for different agents, so colocating the code is useful for readability.
 
 ## Tripwires
 

openai_agents-0.0.7/docs/mcp.md

@@ -0,0 +1,51 @@
+# Model context protocol
+
+The [Model context protocol](https://modelcontextprotocol.io/introduction) (aka MCP) is a way to provide tools and context to the LLM. From the MCP docs:
+
+> MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.
+
+The Agents SDK has support for MCP. This enables you to use a wide range of MCP servers to provide tools to your Agents.
+
+## MCP servers
+
+Currently, the MCP spec defines two kinds of servers, based on the transport mechanism they use:
+
+1. **stdio** servers run as a subprocess of your application. You can think of them as running "locally".
+2. **HTTP over SSE** servers run remotely. You connect to them via a URL.
+
+You can use the [`MCPServerStdio`][agents.mcp.server.MCPServerStdio] and [`MCPServerSse`][agents.mcp.server.MCPServerSse] classes to connect to these servers.
+
+For example, this is how you'd use the [official MCP filesystem server](https://www.npmjs.com/package/@modelcontextprotocol/server-filesystem).
+
+```python
+async with MCPServerStdio(
+    params={
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-filesystem", samples_dir],
+    }
+) as server:
+    tools = await server.list_tools()
+```
+
+## Using MCP servers
+
+MCP servers can be added to Agents. The Agents SDK will call `list_tools()` on the MCP servers each time the Agent is run. This makes the LLM aware of the MCP server's tools. When the LLM calls a tool from an MCP server, the SDK calls `call_tool()` on that server.
+
+```python
+
+agent=Agent(
+    name="Assistant",
+    instructions="Use the tools to achieve the task",
+    mcp_servers=[mcp_server_1, mcp_server_2]
+)
+```
+
+## Caching
+
+Every time an Agent runs, it calls `list_tools()` on the MCP server. This can be a latency hit, especially if the server is a remote server. To automatically cache the list of tools, you can pass `cache_tools_list=True` to both [`MCPServerStdio`][agents.mcp.server.MCPServerStdio] and [`MCPServerSse`][agents.mcp.server.MCPServerSse]. You should only do this if you're certain the tool list will not change.
+
+If you want to invalidate the cache, you can call `invalidate_tools_cache()` on the servers.
+
+## End-to-end example
+
+View complete working examples at [examples/mcp](https://github.com/openai/openai-agents-python/tree/main/examples/mcp).

openai_agents-0.0.7/docs/ref/mcp/server.md

@@ -0,0 +1,3 @@
+# `MCP Servers`
+
+::: agents.mcp.server

openai_agents-0.0.7/docs/ref/mcp/util.md

@@ -0,0 +1,3 @@
+# `MCP Util`
+
+::: agents.mcp.util

{openai_agents-0.0.6 → openai_agents-0.0.7}/docs/tracing.md

@@ -35,6 +35,9 @@ By default, the SDK traces the following:
 -   Function tool calls are each wrapped in `function_span()`
 -   Guardrails are wrapped in `guardrail_span()`
 -   Handoffs are wrapped in `handoff_span()`
+-   Audio inputs (speech-to-text) are wrapped in a `transcription_span()`
+-   Audio outputs (text-to-speech) are wrapped in a `speech_span()`
+-   Related audio spans may be parented under a `speech_group_span()`
 
 By default, the trace is named "Agent trace". You can set this name if you use `trace`, or you can can configure the name and other properties with the [`RunConfig`][agents.run.RunConfig].
 
@@ -76,7 +79,11 @@ Spans are automatically part of the current trace, and are nested under the near
 
 ## Sensitive data
 
-Some spans track potentially sensitive data. For example, the `generation_span()` stores the inputs/outputs of the LLM generation, and `function_span()` stores the inputs/outputs of function calls. These may contain sensitive data, so you can disable capturing that data via [`RunConfig.trace_include_sensitive_data`][agents.run.RunConfig.trace_include_sensitive_data].
+Certain spans may capture potentially sensitive data.
+
+The `generation_span()` stores the inputs/outputs of the LLM generation, and `function_span()` stores the inputs/outputs of function calls. These may contain sensitive data, so you can disable capturing that data via [`RunConfig.trace_include_sensitive_data`][agents.run.RunConfig.trace_include_sensitive_data].
+
+Similarly, Audio spans include base64-encoded PCM data for input and output audio by default. You can disable capturing this audio data by configuring [`VoicePipelineConfig.trace_include_sensitive_audio_data`][agents.voice.pipeline_config.VoicePipelineConfig.trace_include_sensitive_audio_data].
 
 ## Custom tracing processors
 
@@ -92,6 +99,7 @@ To customize this default setup, to send traces to alternative or additional bac
 
 ## External tracing processors list
 
+-   [Weights & Biases](https://weave-docs.wandb.ai/guides/integrations/openai_agents)
 -   [Arize-Phoenix](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai-agents-sdk)
 -   [MLflow](https://mlflow.org/docs/latest/tracing/integrations/openai-agent)
 -   [Braintrust](https://braintrust.dev/docs/guides/traces/integrations#openai-agents-sdk)
@@ -102,3 +110,4 @@ To customize this default setup, to send traces to alternative or additional bac
 -   [LangSmith](https://docs.smith.langchain.com/observability/how_to_guides/trace_with_openai_agents_sdk)
 -   [Maxim AI](https://www.getmaxim.ai/docs/observe/integrations/openai-agents-sdk)
 -   [Comet Opik](https://www.comet.com/docs/opik/tracing/integrations/openai_agents)
+-   [Langfuse](https://langfuse.com/docs/integrations/openaiagentssdk/openai-agents)

openai_agents-0.0.7/docs/visualization.md

@@ -0,0 +1,86 @@
+# Agent Visualization
+
+Agent visualization allows you to generate a structured graphical representation of agents and their relationships using **Graphviz**. This is useful for understanding how agents, tools, and handoffs interact within an application.
+
+## Installation
+
+Install the optional `viz` dependency group:
+
+```bash
+pip install "openai-agents[viz]"
+```
+
+## Generating a Graph
+
+You can generate an agent visualization using the `draw_graph` function. This function creates a directed graph where:
+
+- **Agents** are represented as yellow boxes.
+- **Tools** are represented as green ellipses.
+- **Handoffs** are directed edges from one agent to another.
+
+### Example Usage
+
+```python
+from agents import Agent, function_tool
+from agents.extensions.visualization import draw_graph
+
+@function_tool
+def get_weather(city: str) -> str:
+    return f"The weather in {city} is sunny."
+
+spanish_agent = Agent(
+    name="Spanish agent",
+    instructions="You only speak Spanish.",
+)
+
+english_agent = Agent(
+    name="English agent",
+    instructions="You only speak English",
+)
+
+triage_agent = Agent(
+    name="Triage agent",
+    instructions="Handoff to the appropriate agent based on the language of the request.",
+    handoffs=[spanish_agent, english_agent],
+    tools=[get_weather],
+)
+
+draw_graph(triage_agent)
+```
+
+![Agent Graph](./assets/images/graph.png)
+
+This generates a graph that visually represents the structure of the **triage agent** and its connections to sub-agents and tools.
+
+
+## Understanding the Visualization
+
+The generated graph includes:
+
+- A **start node** (`__start__`) indicating the entry point.
+- Agents represented as **rectangles** with yellow fill.
+- Tools represented as **ellipses** with green fill.
+- Directed edges indicating interactions:
+  - **Solid arrows** for agent-to-agent handoffs.
+  - **Dotted arrows** for tool invocations.
+- An **end node** (`__end__`) indicating where execution terminates.
+
+## Customizing the Graph
+
+### Showing the Graph
+By default, `draw_graph` displays the graph inline. To show the graph in a separate window, write the following:
+
+```python
+draw_graph(triage_agent).view()
+```
+
+### Saving the Graph
+By default, `draw_graph` displays the graph inline. To save it as a file, specify a filename:
+
+```python
+draw_graph(triage_agent, filename="agent_graph.png")
+```
+
+This will generate `agent_graph.png` in the working directory.
+
+

{openai_agents-0.0.6 → openai_agents-0.0.7}/docs/voice/quickstart.md

@@ -5,7 +5,7 @@
 Make sure you've followed the base [quickstart instructions](../quickstart.md) for the Agents SDK, and set up a virtual environment. Then, install the optional voice dependencies from the SDK:
 
 ```bash
-pip install openai-agents[voice]
+pip install 'openai-agents[voice]'
 ```
 
 ## Concepts
@@ -91,7 +91,7 @@ agent = Agent(
 We'll set up a simple voice pipeline, using [`SingleAgentVoiceWorkflow`][agents.voice.workflow.SingleAgentVoiceWorkflow] as the workflow.
 
 ```python
-from agents import SingleAgentVoiceWorkflow, VoicePipeline,
+from agents.voice import SingleAgentVoiceWorkflow, VoicePipeline
 pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
 ```
 
@@ -100,10 +100,13 @@ pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
 ```python
 import numpy as np
 import sounddevice as sd
+from agents.voice import AudioInput
 
 # For simplicity, we'll just create 3 seconds of silence
 # In reality, you'd get microphone data
-audio = np.zeros(24000 * 3, dtype=np.int16)
+buffer = np.zeros(24000 * 3, dtype=np.int16)
+audio_input = AudioInput(buffer=buffer)
+
 result = await pipeline.run(audio_input)
 
 # Create an audio player using `sounddevice`
@@ -128,11 +131,13 @@ import sounddevice as sd
 
 from agents import (
     Agent,
+    function_tool,
+    set_tracing_disabled,
+)
+from agents.voice import (
     AudioInput,
     SingleAgentVoiceWorkflow,
     VoicePipeline,
-    function_tool,
-    set_tracing_disabled,
 )
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
 

{openai_agents-0.0.6 → openai_agents-0.0.7}/examples/basic/lifecycle_example.py

@@ -79,7 +79,7 @@ multiply_agent = Agent(
 
 start_agent = Agent(
     name="Start Agent",
-    instructions="Generate a random number. If it's even, stop. If it's odd, hand off to the multipler agent.",
+    instructions="Generate a random number. If it's even, stop. If it's odd, hand off to the multiplier agent.",
     tools=[random_number],
     output_type=FinalResult,
     handoffs=[multiply_agent],

openai_agents-0.0.7/examples/mcp/filesystem_example/README.md

@@ -0,0 +1,26 @@
+# MCP Filesystem Example
+
+This example uses the [filesystem MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem), running locally via `npx`.
+
+Run it via:
+
+```
+uv run python  python examples/mcp/filesystem_example/main.py
+```
+
+## Details
+
+The example uses the `MCPServerStdio` class from `agents`, with the command:
+
+```bash
+npx -y "@modelcontextprotocol/server-filesystem" <samples_directory>
+```
+
+It's only given access to the `sample_files` directory adjacent to the example, which contains some sample data.
+
+Under the hood:
+
+1. The server is spun up in a subprocess, and exposes a bunch of tools like `list_directory()`, `read_file()`, etc.
+2. We add the server instance to the Agent via `mcp_agents`.
+3. Each time the agent runs, we call out to the MCP server to fetch the list of tools via `server.list_tools()`.
+4. If the LLM chooses to use an MCP tool, we call the MCP server to run the tool via `server.run_tool()`.

openai_agents-0.0.7/examples/mcp/filesystem_example/main.py

@@ -0,0 +1,57 @@
+import asyncio
+import os
+import shutil
+
+from agents import Agent, Runner, gen_trace_id, trace
+from agents.mcp import MCPServer, MCPServerStdio
+
+
+async def run(mcp_server: MCPServer):
+    agent = Agent(
+        name="Assistant",
+        instructions="Use the tools to read the filesystem and answer questions based on those files.",
+        mcp_servers=[mcp_server],
+    )
+
+    # List the files it can read
+    message = "Read the files and list them."
+    print(f"Running: {message}")
+    result = await Runner.run(starting_agent=agent, input=message)
+    print(result.final_output)
+
+    # Ask about books
+    message = "What is my #1 favorite book?"
+    print(f"\n\nRunning: {message}")
+    result = await Runner.run(starting_agent=agent, input=message)
+    print(result.final_output)
+
+    # Ask a question that reads then reasons.
+    message = "Look at my favorite songs. Suggest one new song that I might like."
+    print(f"\n\nRunning: {message}")
+    result = await Runner.run(starting_agent=agent, input=message)
+    print(result.final_output)
+
+
+async def main():
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    samples_dir = os.path.join(current_dir, "sample_files")
+
+    async with MCPServerStdio(
+        name="Filesystem Server, via npx",
+        params={
+            "command": "npx",
+            "args": ["-y", "@modelcontextprotocol/server-filesystem", samples_dir],
+        },
+    ) as server:
+        trace_id = gen_trace_id()
+        with trace(workflow_name="MCP Filesystem Example", trace_id=trace_id):
+            print(f"View trace: https://platform.openai.com/traces/{trace_id}\n")
+            await run(server)
+
+
+if __name__ == "__main__":
+    # Let's make sure the user has npx installed
+    if not shutil.which("npx"):
+        raise RuntimeError("npx is not installed. Please install it with `npm install -g npx`.")
+
+    asyncio.run(main())

openai_agents-0.0.7/examples/mcp/filesystem_example/sample_files/favorite_books.txt

@@ -0,0 +1,20 @@
+1. To Kill a Mockingbird – Harper Lee
+2. Pride and Prejudice – Jane Austen
+3. 1984 – George Orwell
+4. The Hobbit – J.R.R. Tolkien
+5. Harry Potter and the Sorcerer’s Stone – J.K. Rowling
+6. The Great Gatsby – F. Scott Fitzgerald
+7. Charlotte’s Web – E.B. White
+8. Anne of Green Gables – Lucy Maud Montgomery
+9. The Alchemist – Paulo Coelho
+10. Little Women – Louisa May Alcott
+11. The Catcher in the Rye – J.D. Salinger
+12. Animal Farm – George Orwell
+13. The Chronicles of Narnia: The Lion, the Witch, and the Wardrobe – C.S. Lewis
+14. The Book Thief – Markus Zusak
+15. A Wrinkle in Time – Madeleine L’Engle
+16. The Secret Garden – Frances Hodgson Burnett
+17. Moby-Dick – Herman Melville
+18. Fahrenheit 451 – Ray Bradbury
+19. Jane Eyre – Charlotte Brontë
+20. The Little Prince – Antoine de Saint-Exupéry

openai_agents-0.0.7/examples/mcp/filesystem_example/sample_files/favorite_cities.txt

@@ -0,0 +1,4 @@
+- In the summer, I love visiting London.
+- In the winter, Tokyo is great.
+- In the spring, San Francisco.
+- In the fall, New York is the best.

openai_agents-0.0.7/examples/mcp/filesystem_example/sample_files/favorite_songs.txt

@@ -0,0 +1,10 @@
+1. "Here Comes the Sun" – The Beatles
+2. "Imagine" – John Lennon
+3. "Bohemian Rhapsody" – Queen
+4. "Shake It Off" – Taylor Swift
+5. "Billie Jean" – Michael Jackson
+6. "Uptown Funk" – Mark Ronson ft.  Bruno Mars
+7. "Don’t Stop Believin’" – Journey
+8. "Dancing Queen" – ABBA
+9. "Happy" – Pharrell Williams
+10. "Wonderwall" – Oasis

openai_agents-0.0.7/examples/mcp/git_example/README.md

@@ -0,0 +1,25 @@
+# MCP Git Example
+
+This example uses the [git MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/git), running locally via `uvx`.
+
+Run it via:
+
+```
+uv run python examples/mcp/git_example/main.py
+```
+
+## Details
+
+The example uses the `MCPServerStdio` class from `agents`, with the command:
+
+```bash
+uvx mcp-server-git
+```
+Prior to running the agent, the user is prompted to provide a local directory path to their git repo. Using that, the Agent can invoke Git MCP tools like `git_log` to inspect the git commit log.
+
+Under the hood:
+
+1. The server is spun up in a subprocess, and exposes a bunch of tools like `git_log()`
+2. We add the server instance to the Agent via `mcp_agents`.
+3. Each time the agent runs, we call out to the MCP server to fetch the list of tools via `server.list_tools()`. The result is cached. 
+4. If the LLM chooses to use an MCP tool, we call the MCP server to run the tool via `server.run_tool()`.

openai_agents-0.0.7/examples/mcp/git_example/main.py

@@ -0,0 +1,48 @@
+import asyncio
+import shutil
+
+from agents import Agent, Runner, trace
+from agents.mcp import MCPServer, MCPServerStdio
+
+
+async def run(mcp_server: MCPServer, directory_path: str):
+    agent = Agent(
+        name="Assistant",
+        instructions=f"Answer questions about the git repository at {directory_path}, use that for repo_path",
+        mcp_servers=[mcp_server],
+    )
+
+    message = "Who's the most frequent contributor?"
+    print("\n" + "-" * 40)
+    print(f"Running: {message}")
+    result = await Runner.run(starting_agent=agent, input=message)
+    print(result.final_output)
+
+    message = "Summarize the last change in the repository."
+    print("\n" + "-" * 40)
+    print(f"Running: {message}")
+    result = await Runner.run(starting_agent=agent, input=message)
+    print(result.final_output)
+
+
+async def main():
+    # Ask the user for the directory path
+    directory_path = input("Please enter the path to the git repository: ")
+
+    async with MCPServerStdio(
+        params={
+            "command": "uvx",
+            "args": [
+                "mcp-server-git"
+            ]
+        }
+    ) as server:
+        with trace(workflow_name="MCP Git Example"):
+            await run(server, directory_path)
+
+
+if __name__ == "__main__":
+    if not shutil.which("uvx"):
+        raise RuntimeError("uvx is not installed. Please install it with `pip install uvx`.")
+
+    asyncio.run(main())

{openai_agents-0.0.6 → openai_agents-0.0.7}/examples/research_bot/agents/search_agent.py

@@ -4,7 +4,7 @@ from agents.model_settings import ModelSettings
 INSTRUCTIONS = (
     "You are a research assistant. Given a search term, you search the web for that term and"
     "produce a concise summary of the results. The summary must 2-3 paragraphs and less than 300"
-    "words. Capture the main points. Write succintly, no need to have complete sentences or good"
+    "words. Capture the main points. Write succinctly, no need to have complete sentences or good"
     "grammar. This will be consumed by someone synthesizing a report, so its vital you capture the"
     "essence and ignore any fluff. Do not include any additional commentary other than the summary"
     "itself."

{openai_agents-0.0.6 → openai_agents-0.0.7}/examples/voice/static/main.py

@@ -1,6 +1,8 @@
 import asyncio
 import random
 
+import numpy as np
+
 from agents import Agent, function_tool
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
 from agents.voice import (
@@ -78,6 +80,9 @@ async def main():
             elif event.type == "voice_stream_event_lifecycle":
                 print(f"Received lifecycle event: {event.event}")
 
+        # Add 1 second of silence to the end of the stream to avoid cutting off the last audio.
+        player.add_audio(np.zeros(24000 * 1, dtype=np.int16))
+
 
 if __name__ == "__main__":
     asyncio.run(main())

{openai_agents-0.0.6 → openai_agents-0.0.7}/examples/voice/static/util.py

@@ -62,6 +62,7 @@ class AudioPlayer:
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
+        self.stream.stop()  # wait for the stream to finish
         self.stream.close()
 
     def add_audio(self, audio_data: npt.NDArray[np.int16]):

{openai_agents-0.0.6 → openai_agents-0.0.7}/examples/voice/streamed/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sounddevice as sd
@@ -13,7 +14,18 @@ from typing_extensions import override
 
 from agents.voice import StreamedAudioInput, VoicePipeline
 
-from .agents import MyWorkflow
+# Import MyWorkflow class - handle both module and package use cases
+if TYPE_CHECKING:
+    # For type checking, use the relative import
+    from .my_workflow import MyWorkflow
+else:
+    # At runtime, try both import styles
+    try:
+        # Try relative import first (when used as a package)
+        from .my_workflow import MyWorkflow
+    except ImportError:
+        # Fall back to direct import (when run as a script)
+        from my_workflow import MyWorkflow
 
 CHUNK_LENGTH_S = 0.05  # 100ms
 SAMPLE_RATE = 24000