openai/openai-agents-python

This system is the OpenAI Agents SDK, a framework for building and orchestrating AI agents with support for multi-agent workflows, tool use, and human-in-the-loop interactions. It provides infrastructure for managing agent sessions, integrating with external services via the Model Context Protocol (MCP), and executing code in isolated sandbox environments with secure cloud storage mounts. The SDK also includes capabilities for real-time voice interactions, streaming responses, and comprehensive tracing for observability.

54 changes.

This period focused on expanding the SDK with new capabilities for voice interactions, Model Context Protocol (MCP) integration, and real-time agent sessions. It introduced the VoicePipeline and RealtimeAgent modules, added comprehensive session management with multiple storage backends, and significantly broadened the example suite to demonstrate these advanced orchestration patterns.

49 changes.

This period focused on establishing a comprehensive sandbox runtime architecture, introducing secure cloud storage mounting and structured capabilities like memory and compaction. It simultaneously expanded the ecosystem by adding backend support for multiple cloud providers (E2B, Modal, Daytona, etc.) and enriching the example suite with detailed workflows for MCP, sandboxing, and experimental extensions.

Users can now provision and manage sandboxes using the Daytona platform via the new \DaytonaSandboxClient\ and \DaytonaSandboxSession\ classes. This extension includes a \DaytonaCloudBucketMountStrategy\ that automatically provisions \rclone\ and FUSE support inside the sandbox to mount cloud storage buckets (S3, R2, GCS, Azure Blob), with credential-bearing mounts requiring explicit runtime acknowledgement on the trusted manifest. The implementation handles lazy SDK imports, transient error retry logic, and PTY output collection specific to the Daytona environment.

src/agents/extensions/sandbox/daytona · high confidence

A new example demonstrating how to use the Agents SDK with an MCP server over Server-Sent Events (SSE). The example includes a local server script that exposes tools (add, get\_weather, get\_secret\_word) and a main script that runs the server in a subprocess, connects via MCPServerSse, and executes agent workflows against it.

_examples/mcp/sse\example · high confidence

Added a new example demonstrating how to use the Model Context Protocol (MCP) to allow an agent to read local files. The example spins up a filesystem server via \npx\ and integrates it with an agent using \MCPServerStdio\. It includes sample data files (books, cities, songs) and demonstrates agent interactions such as listing files, reading specific content, and reasoning based on that data. The example also includes built-in tracing support to log agent execution to the OpenAI platform.

_examples/mcp/filesystem\example · high confidence

A new Python example has been added to demonstrate connecting to a remote MCP server (DeepWiki) via the Streamable HTTP transport. The example configures the client with specific timeouts and retry logic to handle remote tool responses, allowing an agent to utilize external tools through this protocol.

_examples/mcp/streamable\_http\_remote\example · high confidence

A new Python example has been added to demonstrate connecting to Model Context Protocol (MCP) servers via Server-Sent Events (SSE). The example, located in examples/mcp/sse\_remote\_example, allows users to run a bundled local SSE server by default or connect to a compatible remote SSE server by setting the MCP\_SSE\_REMOTE\_URL environment variable. It showcases how to initialize an agent with MCP tools and execute a simple task using the MCPServerSse client.

_examples/mcp/sse\_remote\example · high confidence

This change introduces a new Vercel-backed sandbox implementation, exposing \VercelSandboxClient\, \VercelSandboxSession\, and a \VercelCloudBucketMountStrategy\ for mounting S3 buckets. The module handles sandbox lifecycle management, including specific retry logic for transient provider errors and status checks, and implements secure credential handling for S3 mounts by redacting sensitive data in error messages.

src/agents/extensions/sandbox/vercel · high confidence

Introduces a new synthetic healthcare support workflow example in \examples/sandbox/healthcare\_support\ that demonstrates an orchestrator agent coordinating with a benefits subagent and a sandbox policy agent. The example includes a CLI entry point, synthetic patient and insurance fixture data, policy documents, and a sandbox skill for building prior-authorization packets, showcasing sandbox capabilities like shell execution, filesystem access, and lazy-loaded skills.

_examples/sandbox/healthcare\support · high confidence

The examples/hosted\_mcp directory now includes four Python scripts (simple.py, connectors.py, human\_in\_the\_loop.py, on\_approval.py) that demonstrate how to use the HostedMCPTool with the OpenAI Responses API. These examples cover basic usage with trusted servers, integration with Google Calendar via connectors, and human-in-the-loop approval workflows for tools like the DeepWiki MCP server.

_examples/hosted\mcp · high confidence

A new static voice demo has been added to the examples directory, allowing users to record audio directly from the terminal and process it through a voice pipeline. The example demonstrates a workflow where recorded speech is transcribed, passed to an agent (with tool use and handoff capabilities), and the response is streamed back as audio for playback. It includes utilities for terminal-based audio capture and playback, serving as a standalone example of the voice pipeline integration.

examples/voice/static · high confidence

Introduces a new interactive demo in examples/voice/streamed that allows users to have voice conversations with an AI agent. The example features a Textual-based terminal UI for real-time status and transcription display, integrates with the VoicePipeline for automatic turn detection, and demonstrates agent capabilities including tool usage (weather lookup) and handoffs (to a Spanish-speaking agent).

examples/voice/streamed · high confidence

A new shell script, find\_latest\_release\tag.sh, has been added to the final-release-review skill. This utility fetches tags from a specified Git remote and identifies the most recent tag matching a given pattern (defaulting to 'v\'), enabling automated release review processes to accurately target the latest version.

.agents/skills/final-release-review/scripts · high confidence

Introduced a new agent skill in \.agents/skills/sensitive-logging-audit\ to help identify and fix sensitive data exposure in Python SDK logging, telemetry, and exception handling. The skill provides a structured workflow and supporting scripts (\inventory\_logging.py\, \test\_inventory.py\) to audit logging calls, classify data types (model, tool, operational), and verify redaction policies. It includes a validation matrix to ensure that sensitive values are properly redacted in both diagnostic and redacted modes, preventing leaks through exception messages, arguments, tracebacks, and other diagnostic outputs.

.agents/skills/sensitive-logging-audit · high confidence

The Docker sandbox examples have been expanded to include a new mount-based workflow. A dedicated Dockerfile (Dockerfile.mount) now pre-installs and pins rclone (v1.74.4) alongside mount-s3, blobfuse2, and EFS utilities, ensuring the sandbox environment has the necessary tools for cloud storage integration. New example scripts demonstrate how to mount Azure Blob Storage, Google Cloud Storage (GCS), and AWS S3 buckets into the sandbox workspace using rclone as the underlying driver. These examples also include a smoke-test runner to verify that read/write operations work correctly within the mounted directories.

examples/sandbox/docker · high confidence

The examples/basic directory has been significantly expanded to demonstrate new SDK features. New examples include hello\_world\_gpt\_5.py and hello\_world\_gpt\_oss.py for GPT-5 and local OSS models, image\_tool\_output.py for image tool outputs, local\_file.py and local\_image.py for file/image inputs, and remote\_pdf.py for remote document handling. The SDK's retry policies are now demonstrated in retry.py and retry\_litellm.py. Input guardrails and tool guardrails are shown in tool\_guardrails.py. Streaming function call arguments are demonstrated in stream\_function\_call\_args.py, and a comprehensive websocket streaming example with HITL approval is provided in stream\_ws.py. The prompt\_template.py example shows dynamic prompt usage. Non-strict output types are covered in non\_strict\_output\_type.py, and previous\_response\_id.py shows conversation continuation. The lifecycle examples (agent\_lifecycle\_example.py and lifecycle\_example.py) have been updated to use the new AgentHookContext, the @tool decorator, and improved logging, while dynamic\_system\_prompt.py now uses dataclasses.

examples/basic · high confidence

New model providers are now available in the extensions package, allowing you to route agent model calls through the AnyLLM SDK or LiteLLM. This enables access to a wide range of third-party providers (such as Anthropic, Gemini, and Mistral) using a unified interface, with support for features like reasoning content replay, custom headers, and provider-specific tool call handling.

src/agents/extensions/models · high confidence

Adds the Blaxel sandbox provider implementation, enabling users to run agent workloads in Blaxel-hosted sandboxes. This includes the core client and session logic (sandbox.py), mount strategies for cloud storage buckets (S3, R2, GCS) via FUSE and persistent Blaxel Drives (mounts.py), and the public API exports (\_\init\\_.py).

src/agents/extensions/sandbox/blaxel · high confidence

Adds a new sandbox provider implementation for Cloudflare Workers, enabling users to run agent workloads in Cloudflare's serverless environment. This includes the \CloudflareSandboxClient\ and session management for executing commands and managing workspaces, as well as support for mounting cloud storage buckets (R2, S3, and GCS) into the sandbox environment.

src/agents/extensions/sandbox/cloudflare · high confidence

Added the E2B sandbox backend implementation, including the client, session management, and a mount strategy for E2B cloud bucket storage via rclone. This enables users to create and interact with sandboxes hosted on the E2B platform, supporting features like snapshot persistence, PTY output collection, and secure credential-bound mounts.

src/agents/extensions/sandbox/e2b · high confidence

This change adds the \src/agents/mcp\ package, providing the core infrastructure for integrating Model Context Protocol (MCP) servers into the Agents SDK. It introduces the \MCPServerManager\ to handle server connection, cleanup, and lifecycle timeouts, and exposes server types (\MCPServerStdio\, \MCPServerSse\, \MCPServerStreamableHttp\) for connecting to MCP endpoints. The implementation includes a compatibility layer (\\_compat\) to support both MCP SDK v1 and v2, along with utilities for tool filtering, metadata resolution, and secure logging that redacts sensitive URL credentials.

src/agents/mcp · high confidence

Added a new Modal-based sandbox implementation, including the core client and session logic, support for native cloud bucket mounts (S3, R2, GCS), and snapshot management. This enables users to run agent workloads in Modal's serverless sandbox environment with configurable timeouts, path grants, and secure credential handling.

src/agents/extensions/sandbox/modal · high confidence

This change adds the \src/agents/voice/models\ package, introducing \OpenAIVoiceModelProvider\ to manage OpenAI client configuration and connection pooling, alongside concrete \OpenAISTTModel\ and \OpenAITTSModel\ implementations. The STT model supports streamed transcription with specific handling for float32-to-PCM16 audio conversion, monotonic event deadlines, and trace redaction, while the TTS model streams audio using the OpenAI speech API with configurable speed and voice settings.

src/agents/voice/models · high confidence

The \src/agents/models\ package now includes dedicated modules to handle OpenAI API reliability and streaming behavior. \\_openai\_retry.py\ implements logic to determine whether errors (such as network issues, timeouts, or specific HTTP status codes) are safe to retry, respecting provider headers and stateful request context. \\_openai\_websocket.py\ manages WebSocket handshake preparation, including dynamic API key refresh and header merging for the OpenAI client. \\_response\_terminal.py\ standardizes error formatting for terminal stream events. Additionally, \\_retry\_runtime.py\ provides shared utilities for parsing retry-after headers and extracting error metadata, while \\_run\_context.py\ introduces context variables to track model run ownership for deterministic cleanup. These changes improve resilience and observability for OpenAI model interactions without altering the public API surface.

src/agents/models · high confidence

This release adds a new \src/agents/realtime\ module that enables building voice agents using the OpenAI Realtime API. It introduces the \RealtimeAgent\ class for defining voice-specific logic, a \RealtimeSession\ for managing the WebSocket connection, and a \RealtimeRunner\ to execute the agent. The module provides a comprehensive set of configuration options for audio input/output formats (PCM16, G.711), turn detection, and model settings, along with a rich event system (\RealtimeEventInfo\, \RealtimeAudio\, \RealtimeToolStart\, etc.) to handle streaming audio, tool calls, and handoffs. It also includes utilities for audio playback tracking, tool filtering, and validation to ensure a robust real-time experience.

src/agents/realtime · high confidence

This change adds a new Runloop sandbox implementation, exposing the RunloopSandboxClient and RunloopSandboxSession for managing sandbox lifecycles, along with a RunloopCloudBucketMountStrategy that enables mounting cloud storage via rclone and FUSE. The module handles lazy SDK imports, snapshot serialization, and credential validation for mount activations.

src/agents/extensions/sandbox/runloop · high confidence

Adds a new example in \examples/sandbox/extensions/temporal\ that runs a conversational SandboxAgent as a durable Temporal workflow. The example includes a Textual TUI for managing sessions, a session manager workflow for lifecycle operations (create, fork, switch, destroy), and a minimal local smoke test. It supports multiple sandbox backends (Daytona, Docker, E2B, local Unix) with runtime switching and forking, and provides configurable OpenAI Agents tracing modes via the \EXAMPLES\_TEMPORAL\_TRACE\ environment variable.

examples/sandbox/extensions/temporal · high confidence

Adds a new experimental \codex\ extension under \src/agents/extensions/experimental/codex\ that exposes a \Codex\ client and a \codex\_tool\ for use within the agents framework. The extension provides a structured API for managing Codex threads (start, resume, run, and streamed run), handling structured inputs (text and local images), and processing JSONL event streams from the Codex CLI. It includes configuration options for sandboxing, model selection, web search, and output schemas, along with type-safe data classes for thread items, events, and usage tracking.

src/agents/extensions/experimental/codex · high confidence

The handoff module now supports nesting conversation history by default, summarizing previous agent transcripts for the next agent to avoid duplication and context overflow. This includes filtering specific item types (like function calls and reasoning items) from the nested input, deduplicating inputs, and preserving user messages containing history wrappers. A new \HandoffInputData\ structure and \input\_filter\ capability allow agents to control which items are passed to the next agent while keeping full history for session logging. Additionally, strict Pydantic validation is enforced for handoff inputs when \strict\_json\_schema=True\, and JSON validation errors are now redacted for security.

src/agents/handoffs · high confidence

Added the \runtime-behavior-probe\ skill, which enables planning and executing controlled runtime probes to investigate real behavior, edge cases, and regressions. The skill enforces a strict manual-only workflow where invocation authorizes planning only; every probe requires explicit user approval via the \request\_user\_input\ tool (or a plain-text fallback) before execution, ensuring transparency around commands, capabilities, and environment variables. It includes a structured validation matrix for tracking test cases, a disposable Python probe scaffold for capturing runtime context and results, and reference guides for error cases, OpenAI runtime patterns, and reporting formats.

.agents/skills/runtime-behavior-probe · high confidence

Sandbox agents now automatically capture and consolidate session history into durable, file-based memory to help future runs work more efficiently. The system records run segments as JSONL rollouts, then runs a Phase 1 extraction to distill raw memories and rollout summaries, followed by a Phase 2 consolidation that merges these into a structured memory folder (MEMORY.md, memory\_summary.md, skills, and rollout summaries). This enables progressive disclosure of user preferences, proven workflows, and failure shields, reducing repetitive instructions and tool calls in subsequent sessions.

src/agents/sandbox/memory · high confidence

The \src/agents/sandbox/sandboxes\ package now provides concrete session and client implementations for executing agent workloads in isolated environments. It exposes \UnixLocalSandboxClient\ and \DockerSandboxClient\ (along with their respective options and session states) via the public API, with the UnixLocal backend restricted to non-Windows platforms and Docker treated as an optional extra. The UnixLocal backend introduces a hardened file I/O subsystem that operates on descriptor-relative paths to prevent symlink races and unauthorized host access, while the Docker backend adds support for disabling networking, applying container labels, and safely handling length-framed stdin writes to prevent silent data loss.

src/agents/sandbox/sandboxes · high confidence

The new \src/agents/sandbox/session\ module provides the core infrastructure for sandbox session management, featuring secure extraction of tar and zip archives that validates member paths and enforces resource limits to prevent unsafe extraction. It includes a dependency container for managing session-scoped resources and a comprehensive audit event system that delivers structured start/finish events to configurable sinks with granular payload policies to control sensitive data exposure.

src/agents/sandbox/session · high confidence

This change adds the core tool implementations for the sandbox agent environment, making three new capabilities available: applying file patches via a structured grammar-based \apply\_patch\ tool, executing shell commands with working directory and output truncation controls via \exec\_command\, and viewing images from the workspace or granted paths via \view\image\. The \\\init\\_.py\ module exposes these tools and their argument models, while the individual implementations handle sandbox-specific path normalization, security checks, and output formatting.

src/agents/sandbox/capabilities/tools · high confidence

Added the \src/agents/sandbox/util\ package, providing core utilities for the sandbox agent environment. This includes \tar\_utils\ for validating and safely extracting tar archives (preventing path traversal and external symlink attacks), \blocking\_io\ to run unbounded workspace I/O off the asyncio event loop, \retry\ for async transient error handling with configurable backoff strategies, and \token\_truncation\ for managing output size limits based on byte or token budgets. The module also exports helpers for GitHub repository cloning, deep merging dictionaries, parsing \ls -la\ output (including device nodes), and computing file checksums.

src/agents/sandbox/util · high confidence

The \src/agents/memory\ module now provides a complete session management system, allowing agents to maintain conversation history automatically. This includes a \Session\ protocol and \SessionABC\ base class for defining session stores, a \SessionSettings\ configuration class for managing history limits, and concrete implementations: \SQLiteSession\ for local persistent storage with file locking and thread safety, \OpenAIConversationsSession\ for server-side history via the OpenAI Conversations API, and \OpenAIResponsesCompactionSession\ which wraps other sessions to automatically compact long conversations using the OpenAI responses.compact API. A \SessionInputCallback\ utility is also provided to combine session history with new inputs.

src/agents/memory · high confidence

The sandbox now supports mounting cloud storage providers (Azure Blob, Box, GCS, Cloudflare R2, S3, and S3 Files) via a new modular mount system. This change introduces provider-specific mount classes that translate credentials into safe runtime configurations for in-container patterns (Rclone, Fuse, Mountpoint, S3 Files) and Docker volume drivers. It also adds a dedicated redaction layer to ensure sensitive mount credentials are never exposed in sandbox commands or error logs, and enforces strict validation for mount strategy types and credential pairs.

src/agents/sandbox/entries/mounts · high confidence

The sandbox now exposes a structured capabilities system (Filesystem, Shell, Memory, Compaction, and Skills) that bundles specific tools and behaviors for agent runs. The Filesystem capability provides image viewing and patch application, while the Shell capability exposes command execution and optional PTY-based stdin interaction. A new Compaction capability manages context window limits using either static thresholds or dynamic, model-aware policies (supporting GPT-5.x, o-series, and GPT-4o models). The Memory capability enables agents to read and generate persistent memory artifacts, and the Skills system allows for both static and lazy-loading of reusable instruction sets.

src/agents/sandbox/capabilities · high confidence

The sandbox now uses a structured entry system in \src/agents/sandbox/entries\ to define artifacts and mounts. This adds support for \Dir\, \File\, \LocalFile\, and \LocalDir\ artifacts, along with a registry for mount strategies including \BoxMount\, \S3Mount\, \GCSMount\, and \AzureBlobMount\. Path resolution is now strictly POSIX-based, preventing Windows-style absolute paths and directory traversal escapes, and local file sources are validated against path grants to prevent symlink attacks.

src/agents/sandbox/entries · high confidence

This change introduces the core \src/agents/sandbox\ module, establishing a new sandbox runtime architecture. It adds a comprehensive mount security system (\\_mount\_security.py\) that validates and redacts credentials for cloud storage providers (S3, GCS, Azure, Box, R2) to prevent data leakage. The module provides a structured error handling framework (\errors.py\) with stable error codes and retryability flags, and implements a POSIX-normalized file patching system (\apply\_patch.py\) that ensures cross-platform path consistency. Additionally, it integrates sandbox-backed memory generation capabilities (\config.py\, \runtime.py\) and defines the manifest and workspace path policies that govern how agents interact with the containerized filesystem.

src/agents/sandbox · high confidence

The \src/agents/voice\ module now provides a \VoicePipeline\ that orchestrates a three-step voice workflow: transcribing audio input via an STT model, processing the text through a configurable \VoiceWorkflowBase\ (including a ready-to-use \SingleAgentVoiceWorkflow\), and converting the resulting text into streaming audio output via a TTS model. The pipeline accepts both static \AudioInput\ buffers and live \StreamedAudioInput\ streams, returning a \StreamedAudioResult\ that emits typed events (audio chunks, lifecycle markers like turn/session start and end, and errors). Configuration is handled via \VoicePipelineConfig\, allowing customization of the model provider, STT/TTS settings, and tracing options (including sensitive data redaction). The module also exposes OpenAI-specific model implementations, a sentence-based text splitter for TTS chunking, and a \testing\ module with scripted STT/TTS models for deterministic unit testing.

src/agents/voice · high confidence

The \src/agents\ package now includes several new internal modules that underpin agent execution and tool handling. \\_config\_coercion.py\ adds logic to normalize SDK-owned dataclass and Pydantic configuration inputs at public boundaries. \\_function\_tool\_arguments.py\ introduces private, per-invocation preparation and conservative approval inspection for function tools. \\_httpx\_compat.py\ provides compatibility helpers for legacy httpx instances. \\_mcp\_tool\_metadata.py\ resolves display metadata (title and description) for MCP tools. \\_public\_agent.py\ and \\_run\_state\_agent\_identity.py\ manage stable agent graph identities and preserve user-visible agent identity during execution rewrites. \\_tool\_identity.py\ and \\_tool\_invocation.py\ define stable lookup keys and invocation identities for tools, including hosted MCP approvals. Finally, \agent\_tool\_input.py\ and \agent\_tool\_state.py\ handle structured input building and state management for agent-as-tool scenarios.

src/agents · high confidence

A new experimental package has been added to expose two beta capabilities: hosted multi-agent support and the Codex extension with its associated tool. These features are currently in beta and subject to change before general availability.

src/agents/extensions/experimental · high confidence

Added a new example demonstrating how to use the Git MCP server with the agents framework. The example shows how to spin up an MCP server via stdio, cache the tools list, and use it with an agent to inspect git repositories.

_examples/mcp/git\example · high confidence

This location introduces a new FastAPI-based example demonstrating the \MCPServerManager\ for managing MCP server lifecycles using the Streamable HTTP transport. The example app (\app.py\) shows how to initialize and use the manager to handle server connections, including support for reconnecting failed servers via a dedicated endpoint, and allows toggling the manager on or off via environment variables. It includes a companion MCP server implementation (\mcp\_server.py\) and a comprehensive smoke test (\smoke\_test.py\) that validates the integration by starting a local server, verifying health and tool endpoints, and testing tool execution without requiring an external model API key.

_examples/mcp/manager\example · high confidence

Added Python example scripts for \get\_all\_mcp\_tools\_example\ and \tool\_filter\_example\ that demonstrate how to prefetch MCP tools, apply static tool filters to restrict available capabilities, and handle human-in-the-loop interruptions by prompting for approval or auto-approving tool calls.

_examples/mcp/get\_all\_mcp\_tools\_example, examples/mcp/tool\_filter\example · high confidence

Added a new example in \examples/mcp/prompt\_server\ that demonstrates how to use MCP prompts to dynamically generate agent instructions. The example includes a local MCP server (\server.py\) exposing a \generate\_code\_review\_instructions\ prompt, and a client script (\main.py\) that discovers available prompts and uses user-selected parameters to configure an agent's behavior at runtime, rather than relying on hardcoded system instructions.

_examples/mcp/prompt\server · high confidence

Added a new interactive agent example that translates natural-language questions about NASA federal spending into SQL queries against a local SQLite database. The agent runs inside a Daytona sandbox and includes a custom SqlCapability with read-only guardrails (connection-level read-only mode, PRAGMA query\_only, statement validation, row limits, and timeouts). It supports multi-turn conversation with context compaction and memory capabilities to retain learnings across sessions. The example includes a setup script to download and build the database from USAspending.gov, schema documentation, and an audit log for debugging.

_examples/sandbox/extensions/daytona/usaspending\text2sql · high confidence

Added a new command-line demo (\examples/realtime/cli/demo.py\) that showcases the Realtime Agent SDK with full duplex audio capabilities. The demo implements a local audio loop using \sounddevice\ and \numpy\, featuring a jitter buffer for smooth playback, an energy-based threshold for detecting user speech (barge-in), and a fade-out mechanism to prevent audio clicks when interrupting the assistant. It also includes a sample \get\_weather\ tool to demonstrate function calling within the realtime session.

examples/realtime/cli · high confidence

Added a complete web-based realtime voice assistant demo application in the \examples/realtime/app\ directory. The demo features a FastAPI backend and a vanilla JavaScript frontend that connects via WebSocket to the OpenAI Realtime API. It showcases core patterns for building realtime voice applications, including audio capture and playback, session management, and event handling. Key capabilities include human-in-the-loop tool approvals (requiring user confirmation for seat updates), image input support (uploading images to the agent), and agent handoffs (transferring between triage, FAQ, and seat booking agents). The demo also includes detailed debug logging for usage and events.

examples/realtime · high confidence

Added a new example demonstrating how to use the Agents SDK with an MCP server over Streamable HTTP. The example includes a local server implementation (\server.py\) exposing tools like \add\, \get\_weather\, and \get\_secret\_word\, and a client script (\main.py\) that automatically selects a local port, starts the server in a subprocess, and runs agent interactions against it. The example targets MCP Python SDK v2 and uses the \MCPServerStreamableHttp\ class from \agents.mcp\.

_examples/mcp/streamablehttp\example · high confidence

The \src/agents/extensions\ module now includes a new \ToolOutputTrimmer\ class that acts as a \CallModelInputFilter\ to reduce token usage by replacing large tool outputs from older conversation turns with concise previews, while preserving recent turns at full fidelity. Additionally, the \remove\_all\_tools\ handoff filter has been updated to correctly handle a broader range of item types (including MCP, reasoning, and tool search items) and now preserves \input\_items\ to prevent data loss during chained handoff filters.

src/agents/extensions · high confidence

Added a new example demonstrating how to handle OpenAI Realtime SIP calls via Twilio Elastic SIP Trunking. The example includes a FastAPI server that accepts incoming calls, a triage agent that greets callers, and specialist agents (FAQ and Records) with handoff capabilities, allowing users to integrate voice-based AI agents into their telephony workflows.

_examples/realtime/twilio\sip · high confidence

A new example in the \examples/realtime/twilio\ directory demonstrates how to connect the OpenAI Realtime API to a phone call using Twilio's Media Streams. The provided FastAPI server handles incoming calls, streams audio between Twilio and the OpenAI Realtime API, and enables real-time voice conversations with an AI agent. The implementation includes a \TwilioHandler\ that manages the WebSocket connection, handles audio format conversion (G.711 μ-law), and supports tools like weather and time queries. It defaults to the \gpt-realtime-2.1\ model and includes configurable startup buffering to mitigate initial audio jitter.

examples/realtime/twilio · high confidence

The examples/agent\_patterns directory now includes several new demonstration scripts showcasing advanced agent orchestration capabilities. The agents-as-tools pattern is expanded with conditional tool enabling (agents\_as\_tools\_conditional.py), which dynamically enables or disables nested agent tools based on user context, and structured input support (agents\_as\_tools\_structured.py), which uses Pydantic models to define strict input schemas for agent tools. Streaming is supported via agents\_as\_tools\_streaming.py, which demonstrates tapping into nested agent events using on\_stream. Human-in-the-loop (HITL) capabilities are demonstrated through human\_in\_the\_loop.py (base approval flow with state serialization), human\_in\_the\_loop\_custom\_rejection.py (custom rejection messages and tool error formatting), and human\_in\_the\_loop\_stream.py (HITL with streaming). Additionally, hosted\_multi\_agent\_beta.py introduces an experimental pattern for coordinating server-hosted subagents, and forcing\_tool\_use.py shows how to enforce tool usage with custom tool use behaviors. Guardrails are also updated with streaming\_guardrails.py for real-time output checks, and existing examples have been updated to use the decorators module and auto-mode fallbacks.

_examples/agent\patterns · high confidence

The examples directory now includes a comprehensive runner script (run\_examples.py) and supporting utilities that allow executing the example suite via Make targets (e.g., make examples-run). This introduces an 'auto mode' (triggered by EXAMPLES\_INTERACTIVE\_MODE=auto) which provides deterministic inputs and confirmations, enabling examples to run without manual interaction. The runner handles discovery of example files, manages logging to .tmp/examples-start-logs, and allows filtering via environment variables and arguments. It also includes logic to skip examples that require external credentials, server dependencies, or are known to hang in automated runs.

examples · high confidence

Added a new example in \examples/mcp/streamablehttp\_custom\_client\_example\ that shows how to use the \httpx\_client\_factory\ parameter in \MCPServerStreamableHttp\ to configure custom HTTP client behavior, including SSL settings, custom headers, timeouts, and proxy support.

_examples/mcp/streamablehttp\_custom\_client\example · high confidence

Added a new \examples/reasoning\_content\ directory containing sample scripts (\main.py\, \runner\_example.py\, \gpt\_oss\_stream.py\) that demonstrate how to access and display reasoning summaries and deltas from models like gpt-5.6 and gpt-oss-20b. These examples show how to configure \ModelSettings\ with reasoning effort and summary options, and how to extract reasoning content from both streaming and non-streaming responses using the Runner API and lower-level model interfaces.

_examples/reasoning\content · high confidence

Added a new example demonstrating a multi-agent financial research workflow. The example orchestrates a planner, web search, specialized sub-agents (fundamentals and risk analysis), a writer, and a verifier to produce a long-form markdown report with an executive summary and follow-up questions. It includes the necessary entry point, manager logic, and a status printer for live updates.

_examples/financial\_research\agent · high confidence

Added a new example demonstrating a multi-agent financial research workflow. The example introduces specialized sub-agents for planning searches, conducting web research, analyzing financial fundamentals, assessing risks, verifying evidence consistency, and writing the final report. The search and writer agents are configured to use the gpt-5.6-sol model, while the planner agent uses o3-mini, showcasing how to orchestrate different models and tools (like WebSearchTool) within a single agent-based application.

_examples/financial\_research\agent/agents · high confidence

A new 'implementation-kickoff' skill has been added to guide the agent through an isolated implementation workflow. It enforces strict boundaries by creating a detached worktree from the current main branch, performing implementation without intermediate commits, and replaying changes onto the latest upstream. The skill includes a Python validation script and tests to ensure the final handoff is clean, verifying Git topology, ensuring exactly one commit is created, and validating that the shipped-path manifest matches the actual changes before generating a PR draft summary.

.agents/skills/implementation-kickoff · high confidence

Added a new agent skill located in .agents/skills/implementation-final-review/scripts that introduces a formal protocol for validating final-review packets, reviewer outputs, and verification receipts. The \review\_protocol.py\ script enforces strict schema validation on packet fields (such as task details, scope contracts, and repository evidence) and reviewer outputs, ensuring data integrity and completeness. The \review\_state.py\ module provides deterministic content and repository fingerprints, including robust handling of git submodules, unsafe index states, and atomic file writes. Comprehensive test suites (\test\_review\_protocol.py\ and \test\_review\_state.py\) verify these validation rules, fingerprint generation, and edge cases like special file types and concurrent changes.

.agents/skills/implementation-final-review/scripts · high confidence

Added a new \examples/sandbox/extensions\ directory containing standalone runner scripts and documentation for manually verifying cloud sandbox integrations. The package includes dedicated examples for E2B, Modal, Cloudflare, Blaxel, and Vercel sandboxes, each demonstrating core capabilities such as standard agent runs, streaming output, PTY interactive sessions, snapshot stop/resume round-trips, and native cloud bucket mounts. These examples are designed for local verification by contributors and require the corresponding optional repository extras (e.g., \uv sync --extra e2b\) and provider-specific credentials to run.

examples/sandbox/extensions · high confidence

Added comprehensive examples for new session storage backends and features: AdvancedSQLiteSession with conversation branching and usage tracking, OpenAIResponsesCompactionSession for automatic conversation compaction (including stateless mode), Dapr-backed distributed sessions, encrypted session storage, and human-in-the-loop (HITL) tool approval workflows with file-backed and in-memory sessions. Also added MongoDB and Redis session examples, and an OpenAI Conversations session example.

examples/memory · high confidence

Added a new \examples/model\_providers\ directory containing runnable scripts and documentation that demonstrate how to route model requests through adapter layers like LiteLLM and any-llm, as well as how to configure custom model providers. The examples show how to use the built-in any-llm and LiteLLM routing via OpenRouter, how to directly instantiate \AnyLLMModel\ and \LitellmModel\, and how to set up custom OpenAI clients for specific agents, globally, or via a custom \ModelProvider\.

_examples/model\providers · high confidence

The \src/agents/extensions/memory\ package now provides several optional, production-grade session implementations that conform to the \Session\ protocol and can be used as drop-in replacements for the default \SQLiteSession\. These include \AdvancedSQLiteSession\ (adds conversation branching and usage analytics), \AsyncSQLiteSession\ (async-native SQLite), \SQLAlchemySession\ (PostgreSQL, MySQL, etc.), \MongoDBSession\, \RedisSession\, \DaprSession\, and \EncryptedSession\ (transparent encryption wrapper). All backends use lazy imports to avoid requiring their specific third-party dependencies unless explicitly used, and they handle their own optional dependency installation via extras like \openai-agents\[redis\]\ or \openai-agents\[mongodb\]\.

src/agents/extensions/memory · high confidence

Added new example files in the sandbox misc directory to demonstrate sandbox agent patterns. This includes support code for building manifests and parsing tool calls, a reference MCP server for policy lookups, and two new sandbox capabilities: WorkspaceShellCapability for executing shell commands within the sandbox workspace, and WorkspaceApplyPatchCapability for applying text patches to files in the workspace.

examples/sandbox/misc · high confidence

The examples/sandbox directory now includes a comprehensive README and a suite of new example scripts demonstrating sandbox capabilities. These include basic Docker and Modal backend usage, agent handoffs, memory persistence (local and S3-backed), multi-agent multiturn scenarios, and extensions for Daytona and Runloop backends. The examples illustrate how to configure sandbox agents with workspace manifests, capabilities like shell and memory, and how to integrate with various sandbox runtimes.

examples/sandbox · high confidence

Added a suite of sandbox tutorial examples in \examples/sandbox/tutorials\ that demonstrate agent workflows within isolated environments. This includes a dataroom metric extraction demo that parses synthetic 10-K financial documents into structured CSV/JSONL artifacts, a dataroom Q&A demo for grounded financial question answering with source citations, a repo code review demo that inspects a git repository to produce line-level findings and patches, and a sandbox resume demo that serializes and restores sandbox session state to continue development tasks. The tutorials also provide a shared Dockerfile for the sandbox environment and a fixture generator for synthetic financial data.

examples/sandbox/tutorials · high confidence

The examples/tools directory now includes a comprehensive set of new demonstration scripts showcasing the latest agent tooling capabilities. Users can explore container-based and local shell execution with human-in-the-loop approval workflows (shell.py, shell\_human\_in\_the\_loop.py, container\_shell\_inline\_skill.py, container\_shell\_skill\_reference.py, local\_shell\_skill.py), automated code interpretation (code\_interpreter.py), and image generation with platform-specific file viewing (image\_generator.py). The collection also introduces programmatic tool calling for orchestrated multi-step operations (programmatic\_tool\_calling.py), experimental Codex CLI integration with thread reuse (codex.py, codex\_same\_thread.py), and advanced tool discovery via namespaces and search filters (tool\_search.py, web\_search\_filters.py). Additionally, a new apply\_patch example demonstrates safe, approval-gated file modifications, supported by reusable skill definitions in the skills/ directory.

examples/tools · high confidence

A new \src/agents/util\ package has been introduced to centralize runtime support logic. This includes strict JSON validation with redacted error reporting, approval policy evaluation for function tools, and safe async task coordination (including a \gather\_with\_cancel\ helper). It also adds pretty-printing for run results and error details, custom data extraction and normalization, and trace-safe error handling that respects sensitive data settings.

src/agents/util · high confidence

The tracing module has been restructured to support a pluggable TraceProvider (replacing the previous global singleton) and introduces new configurable span types for tasks and turns, alongside new span data for MCP tools, speech, and transcription. The backend exporter now uses httpx2, supports per-run API keys, and sanitizes payloads for the OpenAI ingest API. A public flush\_traces API is also added for immediate export control.

src/agents/tracing · high confidence

The generated egg-info files (PKG-INFO, SOURCES.txt, requires.txt, top\_level.txt) for the openai\_agents package have been deleted. These files, which previously contained package metadata and dependency specifications such as openai, pydantic, and griffe, are no longer present in the distribution.

(repo-wide) · high confidence

The agent run pipeline now uses a dedicated \src/agents/run\_internal\ package to host execution-time utilities, separating them from the public API surface. This location introduces internal helpers for agent identity binding, approval handling, guardrail execution, item normalization, error handling, and model retry logic, providing a cleaner separation between public-facing configuration and internal run mechanics.

_src/agents/run\internal · high confidence

A change to existing behaviour in examples/research\bot/agents/\\pycache\\_ — 2 commits, 7 files.

_examples/research\bot/\\pycache\\_, examples/research\bot/agents/\\pycache\\_ · medium confidence · unverified_

The verification scripts in \.agents/skills/code-change-verification/scripts\ have been updated to execute \make lint\, \make typecheck\, and \make tests\ concurrently rather than sequentially. The PowerShell script (\run.ps1\) now launches these three steps in parallel, monitors their progress with configurable heartbeats, and captures stdout/stderr logs for debugging, while the Bash script (\run.sh\) has been rewritten to use background jobs and process groups to achieve the same parallel execution. This change reduces the total time required for code-change verification by overlapping these independent checks.

.agents/skills/code-change-verification/scripts · high confidence

The customer service example now uses the \@tool\ decorator instead of \function\_tool\ for defining tools, and the FAQ lookup tool has been enhanced to recognize a broader set of keywords for baggage, seating, and connectivity queries. Agent handoffs have been updated to explicitly specify tool names (e.g., \transfer\_to\_faq\_agent\, \transfer\_to\_seat\_booking\_agent\, \transfer\_to\_triage\_agent\) for clearer routing. Additionally, the main loop now supports an auto-mode via \input\_with\_fallback\ and \is\_auto\_mode\, allowing the example to run automatically with a default input if not in interactive mode.

_examples/customer\service · high confidence

The handoff examples now use the new @tool decorator instead of the deprecated @function\_tool. Additionally, the message filtering logic has been updated to skip history filtering when GPT-5 is enabled, as removing items can break functionality for that model. The examples also correct a bug where the wrong agent was invoked for random number generation and fix minor typos in user prompts.

examples/handoffs · high confidence

A new local skill and supporting Python script have been introduced to prepare release candidates in an isolated worktree, replacing the previous GitHub Actions release-PR creator. This workflow creates a detached worktree from \origin/main\, runs readiness gates (including a prospective API contract check and a planning review), and materializes a candidate by updating only \pyproject.toml\, \uv.lock\, and \tests/fixtures/released\_api\_contract.json\. The process enforces strict boundaries: it never pushes, opens pull requests, or mutate GitHub, and it leaves the user's source checkout unchanged. A final-candidate review verifies the materialized branch and manifest before handing off a copy-ready PR description and the exact \git push\ command to the user.

.agents/skills/release-candidate-prep · high confidence

The example research bot agents now use newer model defaults: the PlannerAgent and SearchAgent have been switched to 'gpt-5.6-sol', while the WriterAgent now uses 'gpt-5-mini'. Additionally, the PlannerAgent and WriterAgent are configured with explicit ModelSettings enabling reasoning with medium effort, whereas the SearchAgent no longer enforces required tool choice. These changes update the underlying AI models and their configuration for the research workflow.

_examples/research\bot/agents · high confidence

The research bot example now supports auto-runs by importing and using \input\_with\_fallback\ to provide a default query if no input is given. The trace link in the manager has been corrected to point to the new OpenAI logs URL (\/logs/trace\) instead of the old \/traces\ path. Additionally, the web search progress reporting has been enhanced to show real-time success/failure counts during execution and a final summary of succeeded versus failed searches.

_examples/research\bot · high confidence

The sandbox extension module now exposes clients and mount strategies for multiple cloud providers (E2B, Modal, Daytona, Blaxel, Cloudflare, Runloop, and Vercel) via optional imports. Additionally, rclone is now pinned to version 1.74.4 and installed with SHA-256 checksum verification to ensure integrity, with automatic FUSE mount options configured for the current user.

src/agents/extensions/sandbox · high confidence

2 commits adding/updating tests in tests/\_\pycache\\_; Add RunState schema compatibility test fixtures; Added comprehensive test coverage for session memory and compaction logic; Added comprehensive test suite for MCP server functionality; Added comprehensive test suite for the voice pipeline and OpenAI model providers; Added comprehensive tests for tracing initialization, API key handling, and scope management; Added test coverage for sandbox capabilities and tools; Added test utilities for factories, HITL scenarios, and session implementations; Added tests for FastAPI streaming context handling; Added tests for ModelSettings serialization and configuration resolution; Added tests for hosted multi-agent beta support; Added tests for the ToolOutputTrimmer extension; Added tests for the experimental Codex extension; Expanded test coverage for memory session backends; Expanded test coverage for model provider configurations and reasoning content handling; Expanded test coverage for sandbox provider extensions; Expanded test coverage for sandbox subsystems; New deterministic test doubles for model and sandbox interactions; Packaged integration test suite for release validation; Realtime session tests reorganized into responsibility-based modules; Removal of example files from tests directory; Removed duplicated test source files.

The OpenAI Agents SDK has been upgraded to version 0.22.3, raising the minimum supported Python version from 3.9 to 3.10 and upgrading the core OpenAI client dependency from the 1.x series to 3.x. The package now includes a comprehensive set of optional dependency groups (extras) for features such as voice, visualization, LiteLLM integration, real-time support, and various session backends (Redis, MongoDB, Dapr, SQLAlchemy). Additionally, security-conscious transitive dependencies like httpx2, pyjwt, and starlette are now explicitly pinned with minimum version requirements in the main manifest, and the test suite has been expanded with new tools like pytest-xdist and inline-snapshot.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 75.

• Code Health 76
• Architecture 100
• Maturity 74
• Readiness 81
• Security 91
• Domain Modelling 70

• 300 commits — 116 feature/other, 184 fixes

• src/agents — 155 commits
• (root) — 28 commits
• .agents/skills — 27 commits
• .github/scripts — 11 commits
• docs/ja — 9 commits
• .github/workflows — 8 commits
• examples/realtime — 8 commits
• tests/sandbox — 6 commits
• integration_tests/_contract_support.py — 5 commits
• docs/sessions — 3 commits
• tests/fixtures — 3 commits
• tests/mcp — 3 commits
• tests/models — 3 commits
• .github/CODEOWNERS — 2 commits
• docs/sandbox — 2 commits
• docs/scripts — 2 commits
• docs/tracing.md — 2 commits
• examples/sandbox — 2 commits
• tests/realtime — 2 commits
• .agents/references — 1 commit

• fix: Fix falsy optional reference handling (#4305)
• fix: fix(apply-diff): apply stacked anchors sequentially (#4369)
• fix: fix(chat-completions): improve Chat Completions reasoning replay (#4432)
• fix: fix(chat-completions): merge a streamed turn's message into its pending tool-call message (#4728)
• fix: fix(chat-completions): omit parallel_tool_calls without tools on the Chat Completions path (#4359)
• fix: fix(chat-completions): raise ModelBehaviorError on truncated empty completions (#4513)
• fix: fix(chat-completions): raise on audio output in the streamed chat completions path (#4309)
• fix: fix(ci): consolidate Docker-backed integration tests (#4667)
• fix: fix(ci): deploy docs after dependency and workflow updates (#4976)
• fix: fix(ci): harden PyPI publishing and require manual release tags (#4726)
• fix: fix(codex): preserve resume argument ordering (#4400)
• fix: fix(core): accept JSON Schema type arrays of object for tool outputs (#4647)
• fix: fix(core): align conditional approvals with validated tool arguments (#5066)
• fix: fix(core): apply **kwargs value annotation to each keyword value (#4714)
• fix: fix(core): close all MultiProvider children after failures (#4438)
• fix: fix(core): close model providers created by Runner (#4785)
• fix: fix(core): count Responses requests without usage (#4453)
• fix: fix(core): deliver tool-not-found output on server-managed resume (#4947)
• fix: fix(core): detach aggregated request usage entries (#4519)
• fix: fix(core): fail closed on empty tool arguments (#4545)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

openai/openai-agents-python was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.