File: README.md
OpenAI Agents SDK [](https://pypi.org/project/openai-agents/)
The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows. It is provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs.
[!NOTE]
Looking for the JavaScript/TypeScript version? Check out Agents SDK JS/TS.
Core concepts:
- Agents: LLMs configured with instructions, tools, guardrails, and handoffs
- Sandbox agents: Agents preconfigured to work with a container to perform work over long time horizons.
- Realtime agents: Build powerful voice agents with
gpt-realtime-2.1and full agent features - Voice agents: Build voice pipelines that combine speech-to-text, an agent workflow, and text-to-speech
- Agents as tools / Handoffs: Delegating to other agents for specific tasks
- Tools: Various Tools let agents take actions (functions, MCP, hosted tools)
- Guardrails: Configurable safety checks for input and output validation
- Human in the loop: Built-in mechanisms for involving humans across agent runs
- Sessions: Automatic conversation history management across agent runs
- Tracing: Built-in tracking of agent runs, allowing you to view, debug and optimize your workflows
Explore the examples directory to see the SDK in action, and read our documentation for more details.
Get started
To get started, set up your Python environment (Python 3.10 or newer required), and then install OpenAI Agents SDK package.
venv
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
pip install openai-agentsFor voice support, install with the optional voice group: pip install 'openai-agents[voice]'. For Redis session support, install with the optional redis group: pip install 'openai-agents[redis]'.
uv
If you're familiar with uv, installing the package would be even easier:
uv init
uv add openai-agentsFor voice support, install with the optional voice group: uv add 'openai-agents[voice]'. For Redis session support, install with the optional redis group: uv add 'openai-agents[redis]'.
Run your first agents
The SDK supports four primary ways to run agents. Set the OPENAI_API_KEY environment variable before running any of these examples.
Run a text agent
Use a text Agent for workflows that do not need a persistent realtime connection or a sandbox workspace.
from agents import Agent, Runner
agent = Agent(name="Assistant", instructions="You are a helpful assistant")
result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)
# Code within the code,
# Functions calling themselves,
# Infinite loop's dance.(For Jupyter notebook users, see hello_world_jupyter.ipynb)
Run a sandbox agent
Use a SandboxAgent when the agent needs to inspect files, run commands, apply patches, or preserve workspace state across longer tasks.
This example uses UnixLocalSandboxClient, which is supported on macOS and Linux. On Windows, use DockerSandboxClient with the openai-agents[docker] extra or a hosted sandbox client instead; see Sandbox clients for setup details.
from agents import Runner
from agents.run import RunConfig
from agents.sandbox import Manifest, SandboxAgent, SandboxRunConfig
from agents.sandbox.entries import GitRepo
from agents.sandbox.sandboxes import UnixLocalSandboxClient
agent = SandboxAgent(
name="Workspace Assistant",
instructions="Inspect the sandbox workspace before answering.",
default_manifest=Manifest(entries={"repo": GitRepo(repo="openai/openai-agents-python", ref="main")}),
)
result = Runner.run_sync(
agent,
"Inspect the repo README and summarize what this project does.",
run_config=RunConfig(sandbox=SandboxRunConfig(client=UnixLocalSandboxClient())),
)
print(result.final_output)Run a realtime agent
Use a RealtimeAgent for low-latency, server-side voice and multimodal experiences over WebSocket.
import asyncio
from agents.realtime import RealtimeAgent, RealtimeRunner
async def main() -> None:
agent = RealtimeAgent(name="Assistant", instructions="You are a helpful voice assistant. Keep responses short.")
runner = RealtimeRunner(starting_agent=agent)
session = await runner.run()
async with session:
await session.send_message("Say hello in one short sentence.")
async for event in session:
if event.type == "audio":
# Forward or play event.audio.data.
pass
elif event.type == "history_added":
print(event.item)
elif event.type == "agent_end":
break
if __name__ == "__main__":
asyncio.run(main())Run a voice agent
Use a VoicePipeline to turn audio into text, run an agent workflow, and stream generated speech.
import asyncio
import numpy as np
from agents import Agent
from agents.voice import AudioInput, SingleAgentVoiceWorkflow, VoicePipeline
async def main() -> None:
agent = Agent(name="Assistant", instructions="You are a helpful voice assistant.")
pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
audio_input = AudioInput(buffer=np.zeros(24000 * 3, dtype=np.int16))
result = await pipeline.run(audio_input)
async for event in result.stream():
if event.type == "voice_stream_event_audio":
# Forward or play event.data.
pass
if __name__ == "__main__":
asyncio.run(main())Explore the examples directory to see the SDK in action, and read our documentation for more details.
Acknowledgements
We'd like to acknowledge the excellent work of the open-source community, especially:
This library has these optional dependencies:
We also rely on the following tools to manage the project:
We're committed to continuing to build the Agents SDK as an open source framework so others in the community can expand on our approach.
File: docs/ja/models/index.md
search: exclude: true
モデル
Agents SDK は、すぐに利用できる OpenAI モデルを 2 種類サポートしています。
- 推奨: 新しい Responses API を使用して OpenAI API を呼び出す [
OpenAIResponsesModel][agents.models.openai_responses.OpenAIResponsesModel]。 - Chat Completions API を使用して OpenAI API を呼び出す [
OpenAIChatCompletionsModel][agents.models.openai_chatcompletions.OpenAIChatCompletionsModel]。
モデル設定の選択
設定に適した最もシンプルな方法から始めてください。
| 目的 | 推奨される方法 | 詳細 |
|---|---|---|
| OpenAI モデルのみを使用する | デフォルトの OpenAI プロバイダーと Responses モデルのパスを使用する | OpenAI モデル |
| WebSocket トランスポート経由で OpenAI Responses API を使用する | Responses モデルのパスを維持し、WebSocket トランスポートを有効にする | Responses WebSocket トランスポート |
| OpenAI がホストするサブエージェントを使用する | 実験的なホステッド・マルチエージェントモデルを使用する | ホステッド・マルチエージェント |
| OpenAI 以外のプロバイダーを 1 つ使用する | 組み込みのプロバイダー統合ポイントから始める | OpenAI 以外のモデル |
| エージェント間でモデルまたはプロバイダーを組み合わせる | 実行単位またはエージェント単位でプロバイダーを選択し、機能の違いを確認する | 1 つのワークフローでのモデルの組み合わせおよびプロバイダー間でのモデルの組み合わせ |
| OpenAI Responses の高度なリクエスト設定を調整する | OpenAI Responses のパスで ModelSettings を使用する |
OpenAI Responses の高度な設定 |
| OpenAI 以外または複数プロバイダーのルーティングにサードパーティ製アダプターを使用する | サポートされているベータ版アダプターを比較し、提供予定のプロバイダーパスを検証する | サードパーティ製アダプター |
OpenAI モデル
OpenAI のみを使用するほとんどのアプリでは、デフォルトの OpenAI プロバイダーで文字列のモデル名を使用し、Responses モデルのパスを維持する方法を推奨します。
[Agent][agents.agent.Agent] でモデルを指定しない場合、Agents SDK は、コスト重視で大量処理を行うエージェントワークフロー向けに、デフォルトで gpt-5.6-luna を reasoning.effort="none" および verbosity="low" とともに使用します。最先端の性能が必要なアプリケーションでは、model="gpt-5.6-sol" を明示的に設定し、ワークロードに適した model_settings を選択できます。
gpt-5.6-sol などの別のモデルに切り替える場合、エージェントを設定する方法は 2 つあります。
デフォルトモデル
まず、カスタムモデルを設定していないすべてのエージェントで特定のモデルを一貫して使用するには、エージェントを実行する前に環境変数 OPENAI_DEFAULT_MODEL を設定します。
export OPENAI_DEFAULT_MODEL=gpt-5.6-sol
python3 my_awesome_agent.py次に、RunConfig を使用して、実行のデフォルトモデルを設定できます。エージェントにモデルを設定しなかった場合は、この実行のモデルが使用されます。
from agents import Agent, RunConfig, Runner
agent = Agent(
name="Assistant",
instructions="You're a helpful agent.",
)
result = await Runner.run(
agent,
"Hello",
run_config=RunConfig(model="gpt-5.6-sol"),
)GPT-5 モデル
この方法で gpt-5.6-sol などの GPT-5 モデルを使用すると、SDK はデフォルトの ModelSettings を適用します。ほとんどのユースケースで最適に機能する設定が適用されます。デフォルトモデルの推論エフォートを調整するには、独自の ModelSettings を渡します。
from openai.types.shared import Reasoning
from agents import Agent, ModelSettings
my_agent = Agent(
name="My Agent",
instructions="You're a helpful agent.",
# If OPENAI_DEFAULT_MODEL=gpt-5.6-sol is set, passing only model_settings works.
# It's also fine to pass a GPT-5 model name explicitly:
model="gpt-5.6-sol",
model_settings=ModelSettings(reasoning=Reasoning(effort="high"), verbosity="low")
)レイテンシーを低減するには、GPT-5 モデルで reasoning.effort="none" を使用することを推奨します。
GPT-5.6 は、既存の reasoning 設定を通じて、推論モード、会話ターン間で保持される推論コンテキスト、および "max" エフォートレベルもサポートします。これらの制御は Responses API のパスで利用できます。
from openai.types.shared import Reasoning
from agents import Agent, ModelSettings
agent = Agent(
name="Deep research agent",
model="gpt-5.6-sol",
model_settings=ModelSettings(
reasoning=Reasoning(
mode="pro",
effort="max",
context="all_turns",
),
),
)reasoning.mode と reasoning.context は、Responses 専用の設定です。Chat Completions では reasoning.effort のみが使用され、サポートされるエフォートレベルはモデルおよび API サーフェスによって異なります。GPT-5.6 の "max" エフォートには Responses API を使用してください。Chat Completions アダプターは警告を出してモードとコンテキストを無視します。この警告をエラーにするには、OpenAI プロバイダーで strict_feature_validation=True を設定します。
context="all_turns" を使用する場合は、previous_response_id、サーバー側の Responses API 会話、または次のリクエストに以前の推論項目を含めることで、会話を維持してください。ステートレスな store=False 呼び出しでは、レスポンスで reasoning.encrypted_content をリクエストし、その推論項目を次のリクエストの入力に含めます。
ComputerTool のモデル選択
エージェントに [ComputerTool][agents.tool.ComputerTool] が含まれる場合、実際の Responses リクエストで有効なモデルによって、SDK が送信するコンピューターツールのペイロードが決まります。明示的な gpt-5.5 リクエストでは、GA 版の組み込み computer ツールが使用されます。一方、明示的な computer-use-preview リクエストでは、従来の computer_use_preview ペイロードが維持されます。
主な例外は、プロンプトで管理される呼び出しです。プロンプトテンプレートでモデルを指定し、SDK がリクエストから model を省略する場合、SDK はプロンプトが固定するモデルを推測しないよう、プレビュー互換のコンピューターペイロードをデフォルトで使用します。このフローで GA のパスを維持するには、リクエストで model="gpt-5.5" を明示するか、ModelSettings(tool_choice="computer") または ModelSettings(tool_choice="computer_use") で GA セレクターを強制します。
[ComputerTool][agents.tool.ComputerTool] が登録されている場合、tool_choice="computer"、"computer_use"、および "computer_use_preview" は、有効なリクエストモデルに一致する組み込みセレクターへ正規化されます。ComputerTool が登録されていない場合、これらの文字列は通常の関数名として動作し続けます。
プレビュー互換のリクエストでは、environment と画面サイズを事前にシリアライズする必要があります。そのため、[ComputerProvider][agents.tool.ComputerProvider] ファクトリーを使用するプロンプト管理フローでは、具体的な Computer または AsyncComputer インスタンスを渡すか、リクエスト送信前に GA セレクターを強制する必要があります。移行の詳細については、ツールを参照してください。
GPT-5 以外のモデル
カスタムの model_settings を指定せずに GPT-5 以外のモデル名を渡すと、SDK はどのモデルとも互換性がある汎用の ModelSettings に戻ります。
Responses 専用のツール機能
次のツール機能は、OpenAI Responses モデルでのみサポートされます。
- [
ToolSearchTool][agents.tool.ToolSearchTool] - [
tool_namespace()][agents.tool.tool_namespace] @function_tool(defer_loading=True)およびその他の遅延読み込み対応の Responses ツールサーフェス- [
ProgrammaticToolCallingTool][agents.tool.ProgrammaticToolCallingTool]、allowed_callers、およびtool_choice="programmatic_tool_calling"
これらの機能は、Chat Completions モデルおよび Responses 以外のバックエンドでは拒否されます。遅延読み込みツールを使用する場合は、エージェントに ToolSearchTool() を追加し、名前空間名のみ、または遅延読み込み専用の関数名を強制する代わりに、auto または required のツール選択を通じてモデルにツールを読み込ませます。設定の詳細と現在の制約については、ホステッドツール検索およびプログラムによるツール呼び出しを参照してください。
Responses WebSocket トランスポート
デフォルトでは、OpenAI Responses API リクエストは HTTP トランスポートを使用します。OpenAI Responses プロバイダーのパスを使用する場合は、WebSocket トランスポートを有効にできます。
基本設定
from agents import set_default_openai_responses_transport
set_default_openai_responses_transport("websocket")これは、デフォルトの OpenAI プロバイダーがモデル名を解決した結果として得られる OpenAI Responses モデルに影響します。これには、"gpt-5.6-sol" などの文字列のモデル名も含まれます。
トランスポートの選択は、SDK がモデル名をモデルインスタンスへ解決するときに行われます。具体的な [Model][agents.models.interface.Model] オブジェクトを渡した場合、そのトランスポートはすでに固定されています。[OpenAIResponsesWSModel][agents.models.openai_responses.OpenAIResponsesWSModel] は WebSocket、[OpenAIResponsesModel][agents.models.openai_responses.OpenAIResponsesModel] は HTTP を使用し、[OpenAIChatCompletionsModel][agents.models.openai_chatcompletions.OpenAIChatCompletionsModel] は Chat Completions のままです。RunConfig(model_provider=...) を渡した場合は、グローバルなデフォルトではなく、そのプロバイダーがトランスポートの選択を制御します。
プロバイダー単位または実行単位の設定
WebSocket トランスポートは、プロバイダー単位または実行単位でも設定できます。
from agents import Agent, OpenAIProvider, RunConfig, Runner
provider = OpenAIProvider(
use_responses_websocket=True,
# Optional; if omitted, OPENAI_WEBSOCKET_BASE_URL is used when set.
websocket_base_url="wss://your-proxy.example/v1",
# Optional low-level websocket keepalive settings.
responses_websocket_options={"ping_interval": 20.0, "ping_timeout": 60.0},
)
agent = Agent(name="Assistant")
result = await Runner.run(
agent,
"Hello",
run_config=RunConfig(model_provider=provider),
)SDK の OpenAI 統合を介してルーティングするプロバイダーは、オプションのエージェント登録設定も受け付けます。これは、OpenAI の設定でハーネス ID などのプロバイダー単位の登録メタデータが必要な場合に使用する高度なオプションです。
from agents import (
Agent,
OpenAIAgentRegistrationConfig,
OpenAIProvider,
RunConfig,
Runner,
)
provider = OpenAIProvider(
use_responses_websocket=True,
agent_registration=OpenAIAgentRegistrationConfig(harness_id="your-harness-id"),
)
agent = Agent(name="Assistant")
result = await Runner.run(
agent,
"Hello",
run_config=RunConfig(model_provider=provider),
)`MultiProvider` を使用した高度なルーティング
プレフィックスに基づくモデルルーティングが必要な場合、たとえば 1 回の実行で openai/... と any-llm/... のモデル名を混在させる場合は、[MultiProvider][agents.MultiProvider] を使用し、そこで openai_use_responses_websocket=True を設定します。
MultiProvider には、次の 2 つの従来のデフォルトがあります。
openai/...は OpenAI プロバイダーのエイリアスとして扱われるため、openai/gpt-4.1はモデルgpt-4.1としてルーティングされます。- 不明なプレフィックスは、そのまま渡されるのではなく
UserErrorを発生させます。
OpenAI プロバイダーを、名前空間付きのモデル ID をそのまま受け取ることを想定した OpenAI 互換エンドポイントに向ける場合は、パススルー動作を明示的に有効にしてください。WebSocket が有効な設定では、MultiProvider にも openai_use_responses_websocket=True を設定します。
from agents import Agent, MultiProvider, RunConfig, Runner
provider = MultiProvider(
openai_base_url="https://openrouter.ai/api/v1",
openai_api_key="...",
openai_use_responses_websocket=True,
openai_prefix_mode="model_id",
unknown_prefix_mode="model_id",
)
agent = Agent(
name="Assistant",
instructions="Be concise.",
model="openai/gpt-4.1",
)
result = await Runner.run(
agent,
"Hello",
run_config=RunConfig(model_provider=provider),
)バックエンドがリテラルの openai/... 文字列を想定する場合は、openai_prefix_mode="model_id" を使用します。バックエンドが openrouter/openai/gpt-4.1-mini など、その他の名前空間付きモデル ID を想定する場合は、unknown_prefix_mode="model_id" を使用します。これらのオプションは、WebSocket トランスポート以外の MultiProvider でも動作します。この例では、このセクションで説明するトランスポート設定の一部であるため、WebSocket を有効なままにしています。同じオプションは [responses_websocket_session()][agents.responses_websocket_session] でも利用できます。
MultiProvider を通じてルーティングしながら、同じプロバイダー単位の登録メタデータが必要な場合は、openai_agent_registration=OpenAIAgentRegistrationConfig(...) を渡してください。基盤となる OpenAI プロバイダーへ転送されます。
カスタムの OpenAI 互換エンドポイントまたはプロキシを使用する場合、WebSocket トランスポートには互換性のある WebSocket の /responses エンドポイントも必要です。このような設定では、websocket_base_url を明示的に設定する必要がある場合があります。
注記
- これは WebSocket トランスポート経由の Responses API であり、Realtime API ではありません。Chat Completions には適用されません。OpenAI 以外のプロバイダーには、Responses WebSocket の
/responsesエンドポイントをサポートしている場合にのみ適用されます。 - 環境にまだ存在しない場合は、
websocketsパッケージをインストールしてください。 - WebSocket トランスポートを有効にした後は、[
Runner.run_streamed()][agents.run.Runner.run_streamed] を直接使用できます。複数ターンのワークフローで、ターン間およびネストされたエージェントをツールとして使用する呼び出し間で同じ WebSocket 接続を再利用する場合は、[responses_websocket_session()][agents.responses_websocket_session] ヘルパーを推奨します。エージェントの実行ガイドおよびexamples/basic/stream_ws.pyを参照してください。 - 長時間の推論ターンやレイテンシーが急増するネットワークでは、
responses_websocket_optionsを使用して WebSocket のキープアライブ動作をカスタマイズしてください。遅延した pong フレームを許容するにはping_timeoutを増やします。ping を有効なままハートビートのタイムアウトを無効にするには、ping_timeout=Noneを設定します。WebSocket のレイテンシーより信頼性が重要な場合は、HTTP/SSE トランスポートを優先してください。 - デフォルトでは、SDK は受信メッセージのサイズ制限を無効にします（
max_size=None）。プロキシの背後で長期間稼働するエージェントプロセスや、メモリに制約のあるコンテナでは、メッセージごとのメモリ使用量を制限するためにresponses_websocket_options={"max_size": 8 * 1024 * 1024}を設定してください。 - Responses API WebSocket サービスは、各接続で一度に 1 つのレスポンスを処理し、各接続を 60 分に制限します。この上限に達したら新しい接続を開いてください。並列実行が必要な場合は複数の接続を使用します。
- サービスは、接続ローカルのメモリに最新のレスポンスのみを保持します。失敗した
4xxまたは5xxのターンでは、previous_response_idが参照するレスポンスがそのメモリから削除されます。再接続後も、保存済みのレスポンスが利用可能であれば継続できますが、store=Falseと ZDR のフローには永続化されたフォールバックがありません。previous_response_id=Noneで新しいチェーンを開始して完全な入力コンテキストを送信するか、ローカルで管理されるセッション状態からそのコンテキストを再構築してください。
ホステッド・マルチエージェント（実験的）
OpenAI Responses API のホステッド・マルチエージェントベータでは、GPT-5.6 のルートモデルが、サーバーでホストされるサブエージェントを作成および調整できます。Agents SDK は通常の Runner を引き続き使用できます。ホステッドオーケストレーションはサービス上で行われ、開発者が定義した関数ツールはアプリケーション内で実行されます。
この統合は実験的なもので、ローカル関数の出力を response.inject によってアクティブなホステッドエージェントへ返せるよう、Responses WebSocket トランスポートを使用します。client.beta.responses.connect を公開しているバージョン 2.45.0 以降の openai[realtime] のビルドが必要です。インターフェースとベータ版の項目スキーマは、一般提供前に変更される可能性があります。
モデルの設定
実験的モジュールからモデルをインポートし、SDK の Agent に割り当てます。
from agents import Agent
from agents.extensions.experimental.hosted_multi_agent import OpenAIHostedMultiAgentModel
agent = Agent(
name="Research coordinator",
instructions="Delegate independent research tasks, then synthesize the findings.",
model=OpenAIHostedMultiAgentModel(model="gpt-5.6-sol", config={"max_concurrent_subagents": 3}),
)OpenAIHostedMultiAgentModel を構築すると multi_agent.enabled が有効になり、OpenAI-Beta: responses_multi_agent=v1 WebSocket ヘッダーが送信されます。openai_client を指定しない場合、モデルはデフォルトの OpenAI クライアントを使用します。max_concurrent_subagents を省略した場合は、サービスのデフォルトが使用されます。
ローカル関数ツール
すべてのホステッドエージェントは、リクエストに設定されたモデルとツールを共有します。どのホステッドエージェントが関数を呼び出すかは、Responses API が決定します。通常の SDK Runner は関数をローカルで実行し、同じ呼び出し ID を持つ function_call_output をアクティブな WebSocket レスポンスへ注入します。これにより、サービスは元のホステッド呼び出し元を再開できます。関数の実行には、引き続き Runner の通常のガードレール、フック、および失敗時の変換が適用されます。SDK のツール承認による中断はサポートされません。needs_approval 設定が False ではない関数ツールは、リクエストの送信前に拒否されます。
ツールで呼び出し元を考慮したログ記録または認可が必要な場合は、get_hosted_agent_metadata() を使用します。
from typing import Any
from agents.decorators import tool
from agents.extensions.experimental.hosted_multi_agent import get_hosted_agent_metadata
from agents.tool_context import ToolContext
@tool
def lookup_document(ctx: ToolContext[Any], section: str) -> str:
metadata = get_hosted_agent_metadata(ctx)
caller = metadata.agent_name if metadata else "unknown"
print(f"tool caller: {caller}; call ID: {ctx.tool_call_id}")
return f"Contents for {section}"ホステッドエージェント名は観測用のメタデータであり、ローカルのルーティング機構ではありません。SDK が提供する呼び出し ID を使用して出力をルーティングしてください。副作用を伴うツールでは、その呼び出し ID を冪等性キーとして使用し、ツール実行前または実行中に、必要な認可をアプリケーションコードで適用してください。このモデルでは needs_approval を使用しないでください。ツールの引数と出力は Responses API の境界を越えます。
出力とストリーミングの動作
フェーズが final_answer で、/root に属するメッセージだけが、通常の最終メッセージになります。実験的アダプターは、上位レベルの RunResult からサブエージェントのメッセージとホステッドオーケストレーションのレコードを除外します。SDK がそれらのレコードをローカル関数として実行することはありません。
raw ストリーミングでは、ホステッド出力項目や response.inject.created の確認応答を含む、Responses のベータイベントが引き続き公開されます。アダプターは、関数呼び出しの準備が整ったときに 1 つのアクティブなプロバイダーレスポンスを SDK から見える論理的なモデルターンに分割し、Runner が出力を生成した後に同じプロバイダーレスポンスを再開します。raw のホステッド項目または ToolContext とともに get_hosted_agent_metadata() を使用すると、その項目またはツール呼び出しがどのホステッドエージェントに属するかを識別できます。
SDK オーケストレーションとの関係
ホステッド・マルチエージェントは、SDK のハンドオフおよび Agents-as-tools とは別のものです。
- ホステッド・マルチエージェントは、OpenAI サービス上にサブエージェントを作成します。アプリケーションがそれらのサブエージェントを作成またはスケジュールすることはありません。
- SDK のハンドオフは、アクティブなローカル SDK の
Agentを変更します。この実験的モデルを使用している場合、すべてのホステッドエージェントが同じハンドオフツールを受け取って所有権の競合が発生するため、ハンドオフは拒否されます。 - Agents-as-tools は引き続き利用できますが、使用するとクライアント側とサーバー側のオーケストレーションがネストされます。追加のレイテンシー、コスト、およびツールの公開範囲を慎重に評価してください。
現在の制限事項
実験的モデルは、reasoning.summary、max_tool_calls、および呼び出し元が指定する multi_agent または betas のオーバーライドを拒否します。Responses の /compact エンドポイントはベータ版ではサポートされません。ただし、サービスが各ホステッドエージェントのコンテキストを個別に自動圧縮するため、明示的な context_management.compact_threshold は使用できます。
1 つの OpenAIHostedMultiAgentModel インスタンスが同時に所有できるアクティブなホステッドレスポンスは、最大 1 つです。ローカル関数の出力を待っている間に実行を放棄した場合は、await model.close() を呼び出して WebSocket を解放してください。進行中のホステッドレスポンスを別のプロセスまたはイベントループで復元することは、現在サポートされていません。
基盤となる Responses API ベータ版の動作については、OpenAI マルチエージェントガイドを参照してください。ストリーミングおよび非ストリーミングでの SDK の使用方法については、examples/agent_patterns/hosted_multi_agent_beta.py を参照してください。
OpenAI 以外のモデル
OpenAI 以外のプロバイダーが必要な場合は、SDK に組み込まれたプロバイダー統合ポイントから始めてください。多くの設定では、サードパーティ製アダプターを追加しなくてもこれで十分です。各パターンのコード例は、examples/model_providers にあります。
OpenAI 以外のプロバイダーの統合方法
| 方法 | 使用する状況 | 適用範囲 |
|---|---|---|
[set_default_openai_client][agents.set_default_openai_client] |
1 つの OpenAI 互換エンドポイントを、ほとんどまたはすべてのエージェントのデフォルトにする場合 | グローバルデフォルト |
[ModelProvider][agents.models.interface.ModelProvider] |
1 つのカスタムプロバイダーを 1 回の実行に適用する場合 | 実行単位 |
[Agent.model][agents.agent.Agent.model] |
エージェントごとに異なるプロバイダーまたは具体的なモデルオブジェクトが必要な場合 | エージェント単位 |
| サードパーティ製アダプター | 組み込みのパスでは提供されないプロバイダー対応範囲またはルーティングが必要な場合 | サードパーティ製アダプターを参照 |
次の組み込みの方法で、他の LLM プロバイダーを統合できます。
- [
set_default_openai_client][agents.set_default_openai_client] は、AsyncOpenAIのインスタンスを LLM クライアントとしてグローバルに使用する場合に便利です。これは、LLM プロバイダーが OpenAI 互換 API エンドポイントを備え、base_urlとapi_keyを設定できる場合に使用します。設定可能なコード例については、examples/model_providers/custom_example_global.py を参照してください。 - [
ModelProvider][agents.models.interface.ModelProvider] はRunner.runレベルで機能します。これにより、「この実行のすべてのエージェントでカスタムモデルプロバイダーを使用する」と指定できます。設定可能なコード例については、examples/model_providers/custom_example_provider.py を参照してください。 - [
Agent.model][agents.agent.Agent.model] を使用すると、特定の Agent インスタンスにモデルを指定できます。これにより、エージェントごとに異なるプロバイダーを組み合わせて使用できます。設定可能なコード例については、examples/model_providers/custom_example_agent.py を参照してください。
platform.openai.com の API キーがない場合は、set_tracing_disabled() でトレーシングを無効にするか、別のトレーシングプロセッサーを設定することを推奨します。
from agents import Agent, AsyncOpenAI, OpenAIChatCompletionsModel, set_tracing_disabled
set_tracing_disabled(disabled=True)
client = AsyncOpenAI(api_key="Api_Key", base_url="Base URL of Provider")
model = OpenAIChatCompletionsModel(model="Model_Name", openai_client=client)
agent= Agent(name="Helping Agent", instructions="You are a Helping Agent", model=model)!!! note
これらのコード例では、依然として多くの LLM プロバイダーが Responses API をサポートしていないため、Chat Completions API/モデルを使用しています。LLM プロバイダーが Responses をサポートしている場合は、Responses の使用を推奨します。1 つのワークフローでのモデルの組み合わせ
1 つのワークフロー内で、エージェントごとに異なるモデルを使用したい場合があります。たとえば、トリアージには小型で高速なモデルを使用し、複雑なタスクには大型で高性能なモデルを使用できます。[Agent][agents.Agent] を設定する際は、次のいずれかの方法で特定のモデルを選択できます。
- モデル名を渡します。
- 任意のモデル名と、その名前を Model インスタンスへマッピングできる [
ModelProvider][agents.models.interface.ModelProvider] を渡します。 - [
Model][agents.models.interface.Model] の実装を直接指定します。
!!! note
SDK は [`OpenAIResponsesModel`][agents.models.openai_responses.OpenAIResponsesModel] と [`OpenAIChatCompletionsModel`][agents.models.openai_chatcompletions.OpenAIChatCompletionsModel] の両方の形式をサポートしていますが、2 つの形式でサポートされる機能とツールが異なるため、ワークフローごとに 1 つのモデル形式を使用することを推奨します。ワークフローでモデル形式を組み合わせる必要がある場合は、使用するすべての機能が両方で利用できることを確認してください。import asyncio
from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel
spanish_agent = Agent(
name="Spanish agent",
instructions="You only speak Spanish.",
model="gpt-5-mini", # (1)!
)
english_agent = Agent(
name="English agent",
instructions="You only speak English",
model=OpenAIChatCompletionsModel( # (2)!
model="gpt-5-nano",
openai_client=AsyncOpenAI()
),
)
triage_agent = Agent(
name="Triage agent",
instructions="Handoff to the appropriate agent based on the language of the request.",
handoffs=[spanish_agent, english_agent],
model="gpt-5.6-sol",
)
async def main():
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())- OpenAI モデルの名前を直接設定します。
- [
Model][agents.models.interface.Model] の実装を指定します。
エージェントで使用するモデルをさらに設定する場合は、temperature などのオプションのモデル設定パラメーターを提供する [ModelSettings][agents.model_settings.ModelSettings] を渡せます。
from agents import Agent, ModelSettings
english_agent = Agent(
name="English agent",
instructions="You only speak English",
model="gpt-4.1",
model_settings=ModelSettings(temperature=0.1),
)OpenAI Responses の高度な設定
OpenAI Responses のパスでより細かい制御が必要な場合は、ModelSettings から始めてください。
一般的な高度な `ModelSettings` オプション
OpenAI Responses API を使用する場合、複数のリクエストフィールドには対応する ModelSettings フィールドがすでに直接用意されているため、それらに extra_args を使用する必要はありません。
parallel_tool_calls: 同じターンで複数のツール呼び出しを許可または禁止します。truncation: コンテキストが上限を超える場合に失敗させる代わりに、Responses API が最も古い会話項目を削除できるよう、"auto"を設定します。store: 生成されたレスポンスを後で取得できるよう、サーバー側に保存するかどうかを制御します。これはレスポンス ID に依存する後続ワークフローや、store=Falseの場合にローカル入力へのフォールバックが必要になる可能性があるセッション圧縮フローに関係します。context_management:compact_thresholdを使用した Responses の圧縮など、サーバー側のコンテキスト処理を設定します。prompt_cache_retention: 以前のモデルファミリー向けに、たとえば"24h"を使用して保持期間の延長を設定します。prompt_cache_options: 暗黙的または明示的なプロンプトキャッシュを選択し、GPT-5.6 では"30m"のキャッシュ TTL を設定します。response_include:web_search_call.action.sources、file_search_call.results、またはreasoning.encrypted_contentなど、より詳細なレスポンスペイロードをリクエストします。top_logprobs: 出力テキストの上位トークンの logprobs をリクエストします。SDK はmessage.output_text.logprobsも自動的に追加します。retry: Runner が管理するモデル呼び出しの再試行設定を有効にします。Runner 管理の再試行を参照してください。
from agents import Agent, ModelSettings
research_agent = Agent(
name="Research agent",
model="gpt-5.6-sol",
model_settings=ModelSettings(
parallel_tool_calls=False,
truncation="auto",
store=True,
context_management=[{"type": "compaction", "compact_threshold": 200000}],
prompt_cache_options={"mode": "explicit", "ttl": "30m"},
response_include=["web_search_call.action.sources"],
top_logprobs=5,
),
)明示的なプロンプトキャッシュでは、再利用可能なプレフィックスの末尾となるコンテンツ部分にブレークポイントを追加します。同じ ModelSettings.prompt_cache_options フィールドが Responses と Chat Completions のリクエストでそのまま渡され、Chat Completions コンバーターはテキスト、画像、音声、およびファイルのコンテンツ部分にあるブレークポイントを維持します。
from agents import Runner
result = await Runner.run(
research_agent,
[
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "Reusable background material...",
"prompt_cache_breakpoint": {"mode": "explicit"},
},
{
"type": "input_text",
"text": "Analyze the latest question.",
},
],
}
],
)従来の保持制御を使用する以前のモデルファミリーでは、prompt_cache_retention を引き続き利用できます。ModelSettings の直接フィールドと、extra_args 内の同じキーを併用しないでください。
store=False を設定すると、Responses API はそのレスポンスを後でサーバー側から取得できる状態で保持しません。これはステートレスまたはゼロデータ保持形式のフローに便利ですが、通常はレスポンス ID を再利用する機能で、代わりにローカル管理の状態を使用する必要があることも意味します。たとえば、最後のレスポンスが保存されていない場合、[OpenAIResponsesCompactionSession][agents.memory.openai_responses_compaction_session.OpenAIResponsesCompactionSession] はデフォルトの "auto" 圧縮パスを入力ベースの圧縮へ切り替えます。セッションガイドを参照してください。
サーバー側の圧縮は、[OpenAIResponsesCompactionSession][agents.memory.openai_responses_compaction_session.OpenAIResponsesCompactionSession] とは異なります。context_management=[{"type": "compaction", "compact_threshold": ...}] は Responses API リクエストごとに送信され、レンダリングされたコンテキストがしきい値を超えると、API はレスポンスの一部として圧縮項目を出力できます。OpenAIResponsesCompactionSession はターン間で独立した responses.compact エンドポイントを呼び出し、ローカルのセッション履歴を書き換えます。
`extra_args` の受け渡し
SDK がまだトップレベルで直接公開していない、プロバイダー固有または新しいリクエストフィールドが必要な場合は、extra_args を使用します。
OpenAI モデルを使用する場合、extra_args を使用すると、Responses API と Chat Completions API の両方にオプションのパラメーターを渡せます（例: user および service_tier）。サポート対象モデルで Fast モードを使用するには、extra_args={"service_tier": "fast"} を設定します。"priority" も同等です。同じリクエストフィールドを ModelSettings の直接フィールドでも設定しないでください。
from agents import Agent, ModelSettings
english_agent = Agent(
name="English agent",
instructions="You only speak English",
model="gpt-4.1",
model_settings=ModelSettings(
temperature=0.1,
extra_args={"service_tier": "flex", "user": "user_12345"},
),
)モデル呼び出しのタイムアウト
モデル呼び出しの各試行を制限するには、[ModelSettings.timeout][agents.model_settings.ModelSettings.timeout] に正の秒数を設定します。タイムアウトはストリーミングと非ストリーミングの呼び出しに適用され、トランスポートの待機時間を含む試行全体を対象とします。エージェント実行全体、関数ツールの実行、または再試行のバックオフは制限しません。
from agents import Agent, ModelSettings
agent = Agent(
name="Assistant",
model_settings=ModelSettings(timeout=30.0),
)試行が上限を超えると、SDK はその試行をキャンセルし、クリーンアップの完了を待ってから [ModelTimeoutError][agents.exceptions.ModelTimeoutError] を発生させます。Runner 管理の再試行が有効な場合、SDK は context.normalized.is_timeout を True に設定して、タイムアウトによる失敗を再試行ポリシーへ渡します。たとえば、retry_policies.network_error() はこの分類に一致します。許可された各再試行には、試行ごとに新しいタイムアウトが適用されます。SDK は再試行前に通常のリプレイ安全性ルールも適用します。
Runner 管理の再試行
再試行はランタイム専用で、明示的な有効化が必要です。ModelSettings(retry=...) を設定し、再試行ポリシーが再試行を選択しない限り、SDK は一般的なモデルリクエストを再試行しません。
Responses WebSocket トランスポートでは、retry_policies.provider_suggested() が、レスポンス前の過負荷フレームとコードのない server_error フレームを再試行の提案として認識します。これだけで再試行が有効になるわけではありません。引き続き ModelRetrySettings が必要で、通常のリプレイ安全性チェックも適用されます。レスポンスイベントが 1 つでもすでに到着している場合、SDK はリクエストを再実行しません。
from agents import Agent, ModelRetrySettings, ModelSettings, retry_policies
agent = Agent(
name="Assistant",
model="gpt-5.6-sol",
model_settings=ModelSettings(
retry=ModelRetrySettings(
max_retries=4,
backoff={
"initial_delay": 0.5,
"max_delay": 5.0,
"multiplier": 2.0,
"jitter": True,
},
policy=retry_policies.any(
retry_policies.provider_suggested(),
retry_policies.retry_after(),
retry_policies.network_error(),
retry_policies.http_status([408, 409, 429, 500, 502, 503, 504]),
),
)
),
)ModelRetrySettings には 3 つのフィールドがあります。
| フィールド | 型 | 注記 |
|---|---|---|
max_retries |
`int | None` |
backoff |
`ModelRetryBackoffSettings | dict |
policy |
`RetryPolicy | None` |
再試行ポリシーは、次の情報を持つ [RetryPolicyContext][agents.retry.RetryPolicyContext] を受け取ります。
- 試行回数を考慮した判断を行うための
attemptおよびmax_retries。 - ストリーミングと非ストリーミングの動作を分岐するための
stream。 - raw の内容を確認するための
error。 status_code、retry_after、error_code、is_network_error、is_timeout、およびis_abortなどのnormalized情報。- 基盤となるモデルアダプターが再試行の指針を提供できる場合の
provider_advice。 - ポリシー実行前に取得される、安定したリプレイ安全性情報としての
response_started、replay_safety、およびstateful_request。replay_safetyは"safe"、"unsafe"、または"unknown"です。リクエストがprevious_response_idまたはconversation_idを使用する場合、stateful_requestは true になります。
ポリシーは、次のいずれかを返せます。
- 単純な再試行の判断を示す
True/False。 - 遅延をオーバーライドする、診断理由を付加する、または限定された範囲で安全でないリプレイを明示的に承認する場合の [
RetryDecision][agents.retry.RetryDecision]。
SDK は、retry_policies で既成のヘルパーを公開しています。
| ヘルパー | 動作 |
|---|---|
retry_policies.never() |
常に再試行しません。 |
retry_policies.provider_suggested() |
利用可能な場合、プロバイダーの再試行に関する推奨に従います。 |
retry_policies.network_error() |
一時的なトランスポート障害およびタイムアウトに一致します。 |
retry_policies.http_status([...]) |
選択された HTTP ステータスコードに一致します。 |
retry_policies.retry_after() |
retry-after ヒントが利用可能な場合にのみ、その遅延を使用して再試行します。このヘルパーは retry-after の値を明示的なポリシー遅延として扱うため、backoff.max_delay では制限されません。 |
retry_policies.any(...) |
ネストされたポリシーのいずれかが再試行を選択した場合に再試行します。 |
retry_policies.all(...) |
ネストされたすべてのポリシーが再試行を選択した場合にのみ再試行します。 |
ポリシーを組み合わせる場合、provider_suggested() は最初の構成要素として最も安全です。これは、プロバイダーがそれらを区別できる場合に、プロバイダーによる拒否とリプレイ安全性の承認を維持するためです。
安全性の境界
一部の失敗は再試行されません。
- 中断エラー。
- リプレイが安全でなくなる形ですでに出力が開始されたストリーミング実行。
- プロバイダーが独自にリプレイを安全とマークしていない限り、Programmatic Tool Calling リクエストを含む、ローカルでの副作用を理由とした別個のリプレイ拒否があるリクエスト。
プロバイダーによって安全でないとマークされた失敗も、デフォルトではブロックされます。ローカルでの副作用を理由とした別個の拒否がない非ストリーミングリクエストでは、アプリケーションは RetryDecision(retry=True, approve_unsafe_replay=True) を返すことで、プロバイダー側のリプレイリスクを受け入れられます。この承認を与える前に、context.response_started、context.replay_safety、および context.stateful_request を確認し、プロバイダー側の処理を繰り返しても許容できる場合にのみ承認してください。通常の RetryDecision(retry=True) がリプレイ保護を回避することはなく、approve_unsafe_replay=True はストリーミングの再試行やローカルの副作用を承認できません。
previous_response_id または conversation_id を使用するステートフルな後続リクエストは、リプレイの安全性が不明な場合、安全側に倒して失敗します。このようなリクエストでは、network_error() や http_status([500]) など、プロバイダーに基づかない述語だけでは不十分です。通常は retry_policies.provider_suggested() を通じて、プロバイダーからリプレイ安全性の承認を含めるか、前述のとおり、プロバイダーが安全でないとマークした非ストリーミングの失敗を明示的に承認してください。
Runner とエージェントのマージ動作
retry は、Runner レベルとエージェントレベルの ModelSettings の間でディープマージされます。
- エージェントは
retry.max_retriesのみをオーバーライドし、Runner のpolicyを引き続き継承できます。 - エージェントは
retry.backoffの一部のみをオーバーライドし、Runner の同階層にある他のバックオフフィールドを維持できます。 policyはランタイム専用であるため、シリアライズされたModelSettingsはmax_retriesとbackoffを保持しますが、コールバック自体は省略します。
より詳細なコード例については、examples/basic/retry.py およびアダプターを使用した再試行のコード例を参照してください。
OpenAI 以外のプロバイダーのトラブルシューティング
トレーシングクライアントのエラー 401
トレーシング関連のエラーが発生する場合、トレースが OpenAI サーバーへアップロードされる一方で、OpenAI API キーが設定されていないことが原因です。解決方法は 3 つあります。
- トレーシングを完全に無効にします: [
set_tracing_disabled(True)][agents.set_tracing_disabled]。 - トレーシング用の OpenAI キーを設定します: [
set_tracing_export_api_key(...)][agents.set_tracing_export_api_key]。この API キーはトレースのアップロードにのみ使用され、platform.openai.com で発行されたものである必要があります。 - OpenAI 以外のトレースプロセッサーを使用します。トレーシングのドキュメントを参照してください。
Responses API のサポート
SDK はデフォルトで Responses API を使用しますが、依然として多くの他の LLM プロバイダーはこれをサポートしていません。その結果、404 などの問題が発生する場合があります。解決方法は 2 つあります。
- [
set_default_openai_api("chat_completions")][agents.set_default_openai_api] を呼び出します。これは、環境変数でOPENAI_API_KEYとOPENAI_BASE_URLを設定している場合に機能します。 - [
OpenAIChatCompletionsModel][agents.models.openai_chatcompletions.OpenAIChatCompletionsModel] を使用します。コード例はこちらにあります。
Chat Completions の互換性オプション
Chat Completions を通じてルーティングする場合、SDK は、previous_response_id、conversation_id、Responses API の prompt フィールド、またはテキストのみではないツール出力など、Chat Completions では送信できない Responses 専用フィールドを暗黙的に破棄して互換性を維持します。開発中にこのような不一致を即座に失敗させるには、OpenAI プロバイダーで厳格な機能検証を有効にします。
from agents import Agent, OpenAIProvider, RunConfig, Runner
provider = OpenAIProvider(
use_responses=False,
strict_feature_validation=True,
)
agent = Agent(name="Assistant")
result = await Runner.run(
agent,
"Hello",
run_config=RunConfig(model_provider=provider),
)[MultiProvider][agents.MultiProvider] を使用する場合は、代わりに openai_strict_feature_validation=True を渡します。
OpenAI Chat Completions API は音声出力を返せますが、[OpenAIChatCompletionsModel][agents.models.openai_chatcompletions.OpenAIChatCompletionsModel] は現在、音声出力を Agents SDK の実行項目へ変換しません。非ストリーミングメッセージまたはストリーミングの差分に音声出力が含まれる場合、アダプターは不完全または空の実行結果を返す代わりに、AgentsException("Audio is not currently supported") を発生させます。SDK が管理する音声ワークフローには、Realtime エージェントまたは音声エージェントを使用してください。
一部の OpenAI 互換 Chat Completions プロバイダーは、SDK が増分処理するには十分な信頼性がないチャンクで、ツール呼び出しの差分をストリーミングします。その場合は、ストリーミングされるツール呼び出しのバッファリングを有効にし、プロバイダーのストリームが終了した後にのみ SDK がツール呼び出しを出力するようにします。
from agents import OpenAIProvider
provider = OpenAIProvider(
use_responses=False,
buffer_streamed_tool_calls=True,
)[MultiProvider][agents.MultiProvider] では、openai_buffer_streamed_tool_calls=True を使用します。
structured outputs のサポート
一部のモデルプロバイダーは、structured outputs をサポートしていません。その結果、次のようなエラーが発生することがあります。
BadRequestError: Error code: 400 - {'error': {'message': "'response_format.type' : value is not one of the allowed values ['text','json_object']", 'type': 'invalid_request_error'}}これは一部のモデルプロバイダーの制約です。JSON 出力には対応していますが、出力に使用する json_schema は指定できません。この問題の修正に取り組んでいますが、JSON スキーマ出力をサポートするプロバイダーを使用することを推奨します。そうしない場合、不正な形式の JSON が原因でアプリが頻繁に動作しなくなる可能性があります。
プロバイダー間でのモデルの組み合わせ
モデルプロバイダー間の機能差を把握しておく必要があります。そうしないと、エラーが発生する可能性があります。たとえば、OpenAI は structured outputs、マルチモーダル入力、ホステッドファイル検索、および Web 検索をサポートしていますが、他の多くのプロバイダーはこれらの機能をサポートしていません。次の制限に注意してください。
- サポートされていない
toolsを、それを解釈できないプロバイダーへ送信しないでください - テキスト専用モデルを呼び出す前に、マルチモーダル入力を除外してください
- 構造化 JSON 出力をサポートしないプロバイダーでは、無効な JSON が生成されることがある点に注意してください。
サードパーティ製アダプター
サードパーティ製アダプターは、SDK に組み込まれたプロバイダー統合ポイントだけでは不十分な場合にのみ使用してください。この SDK で OpenAI モデルのみを使用する場合は、Any-LLM や LiteLLM ではなく、組み込みの [OpenAIResponsesModel][agents.models.openai_responses.OpenAIResponsesModel] のパスを優先してください。サードパーティ製アダプターは、OpenAI モデルと OpenAI 以外のプロバイダーを組み合わせる必要がある場合や、アダプターのみが提供するプロバイダー対応範囲またはルーティングが必要な場合のためのものです。アダプターは SDK と上流のモデルプロバイダーの間に別の互換性レイヤーを追加するため、機能のサポート状況とリクエストのセマンティクスはプロバイダーによって異なる場合があります。SDK には現在、ベストエフォートのベータ版アダプター統合として Any-LLM と LiteLLM が含まれています。
Any-LLM
Any-LLM のサポートは、Any-LLM が管理するプロバイダー対応範囲またはルーティングが必要な場合に向けて、ベストエフォートのベータ版として提供されています。
上流のプロバイダーパスに応じて、Any-LLM は Responses API、Chat Completions 互換 API、またはプロバイダー固有の互換性レイヤーを使用する場合があります。
Any-LLM が必要な場合は、openai-agents[any-llm] をインストールし、examples/model_providers/any_llm_auto.py または examples/model_providers/any_llm_provider.py から始めてください。[MultiProvider][agents.MultiProvider] で any-llm/... のモデル名を使用するか、AnyLLMModel を直接インスタンス化するか、実行スコープで AnyLLMProvider を使用できます。モデルサーフェスを明示的に固定する必要がある場合は、AnyLLMModel の構築時に api="responses" または api="chat_completions" を渡します。
Any-LLM はサードパーティ製アダプターレイヤーであるため、プロバイダーの依存関係と機能上の不足は SDK ではなく、上流の Any-LLM によって定義されます。使用量メトリクスは上流のプロバイダーが返す場合に自動的に伝播されますが、ストリーミング Chat Completions のバックエンドでは、使用量のチャンクを出力する前に ModelSettings(include_usage=True) が必要になる場合があります。structured outputs、ツール呼び出し、使用量レポート、または Responses 固有の動作に依存する場合は、デプロイ予定の正確なプロバイダーバックエンドを検証してください。
LiteLLM
LiteLLM のサポートは、LiteLLM 固有のプロバイダー対応範囲またはルーティングが必要な場合に向けて、ベストエフォートのベータ版として提供されています。
LiteLLM が必要な場合は、openai-agents[litellm] をインストールし、examples/model_providers/litellm_auto.py または examples/model_providers/litellm_provider.py から始めてください。litellm/... のモデル名を使用するか、[LitellmModel][agents.extensions.models.litellm_model.LitellmModel] を直接インスタンス化できます。
LiteLLM アダプターを通じてアクセスする一部のプロバイダーは、デフォルトでは SDK の使用量メトリクスを設定しません。使用量レポートが必要な場合は、ModelSettings(include_usage=True) を渡してください。また、structured outputs、ツール呼び出し、使用量レポート、またはアダプター固有のルーティング動作に依存する場合は、デプロイ予定の正確なプロバイダーバックエンドを検証してください。
LiteLLM がレスポンスオブジェクトについて Pydantic シリアライザーの警告を出す場合、LiteLLM アダプターをインポートする前に、SDK の互換性パッチを有効にできます。
export OPENAI_AGENTS_ENABLE_LITELLM_SERIALIZER_PATCH=trueこのパッチはデフォルトでは無効で、1 または true の値でのみ有効になります。プライベートな LiteLLM のログ記録ヘルパーをラップすることで、特定の種類の LiteLLM レスポンスシリアライズ警告を抑制するため、一般的なシリアライズ設定ではなく、対象を限定した回避策として扱ってください。プライベートな LiteLLM API に依存しているため、LiteLLM のアップグレード時には再度検証し、上流で警告が発生しなくなったら環境変数を削除してください。
File: docs/ja/models/litellm.md
search: exclude: true
LiteLLM
このページは Models のサードパーティアダプターセクション に移動しました。
自動的にリダイレクトされない場合は、上記のリンクを使用してください。
File: docs/ja/voice/pipeline.md
search: exclude: true
パイプラインとワークフロー
[VoicePipeline][agents.voice.pipeline.VoicePipeline] は、エージェント型ワークフローを音声アプリに簡単に変換できるクラスです。実行するワークフローを渡すと、パイプラインが入力音声の文字起こし、音声終了の検出、適切なタイミングでのワークフローの呼び出し、ワークフロー出力の音声への変換を行います。
graph LR
%% Input
A["🎤 Audio Input"]
%% Voice Pipeline
subgraph Voice_Pipeline [Voice Pipeline]
direction TB
B["Transcribe (speech-to-text)"]
C["Your Code"]:::highlight
D["Text-to-speech"]
B --> C --> D
end
%% Output
E["🎧 Audio Output"]
%% Flow
A --> Voice_Pipeline
Voice_Pipeline --> E
%% Custom styling
classDef highlight fill:#ffcc66,stroke:#333,stroke-width:1px,font-weight:700;パイプラインの設定
パイプラインを作成するとき、次の項目を設定できます。
- [
workflow][agents.voice.workflow.VoiceWorkflowBase]。新しい音声が文字起こしされるたびに実行されるコードです。 - 使用する [
speech-to-text][agents.voice.model.STTModel] モデルと [text-to-speech][agents.voice.model.TTSModel] モデル - [
config][agents.voice.pipeline_config.VoicePipelineConfig]。次のような項目を設定できます。- モデル名をモデルにマッピングできるモデルプロバイダー
- トレーシングを無効にするかどうか、音声ファイルをアップロードするかどうか、ワークフロー名、トレース ID などのトレーシング設定
- プロンプト、言語、使用するデータ型など、TTS モデルと STT モデルの設定
パイプラインの実行
[run()][agents.voice.pipeline.VoicePipeline.run] メソッドを使用してパイプラインを実行できます。このメソッドには、次の 2 つの形式で音声入力を渡せます。
- [
AudioInput][agents.voice.input.AudioInput] は、完全な音声入力があり、その結果を生成するだけの場合に使用します。これは、話者が話し終えたタイミングを検出する必要がない場合に便利です。たとえば、事前に録音された音声がある場合や、ユーザーが話し終えたタイミングが明確なプッシュ・トゥ・トークアプリの場合です。 - [
StreamedAudioInput][agents.voice.input.StreamedAudioInput] は、ユーザーが話し終えたタイミングを検出する必要がある場合に使用します。検出された音声チャンクを順次プッシュでき、音声パイプラインは「アクティビティ検出」と呼ばれる処理を通じて、適切なタイミングでエージェントのワークフローを自動的に実行します。
結果
音声パイプラインの実行結果は [StreamedAudioResult][agents.voice.result.StreamedAudioResult] です。これは、イベントの発生に応じてストリーミングできるオブジェクトです。[VoiceStreamEvent][agents.voice.events.VoiceStreamEvent] には、次のようないくつかの種類があります。
- [
VoiceStreamEventAudio][agents.voice.events.VoiceStreamEventAudio]。音声チャンクを含みます。 - [
VoiceStreamEventLifecycle][agents.voice.events.VoiceStreamEventLifecycle]。ターンの開始や終了などのライフサイクルイベントを通知します。 - [
VoiceStreamEventError][agents.voice.events.VoiceStreamEventError]。エラーイベントです。
アプリケーションが [StreamedAudioResult.stream()][agents.voice.result.StreamedAudioResult.stream] を処理している間に、パイプラインの終端エラーが送出されます。それ以外は正常に実行されたにもかかわらず、音声テキスト変換の文字起こしセッションを閉じられなかった場合、ストリームは無期限に待機する代わりに、そのクローズエラーを送出します。ターンがすでに失敗しており、文字起こしセッションのクローズも失敗した場合、ストリームは元のターンエラーを主要なエラーとして保持します。
result = await pipeline.run(input)
async for event in result.stream():
if event.type == "voice_stream_event_audio":
# play audio
pass
elif event.type == "voice_stream_event_lifecycle":
# lifecycle
pass
elif event.type == "voice_stream_event_error":
# error
passベストプラクティス
割り込み
現在、Agents SDK は [StreamedAudioInput][agents.voice.input.StreamedAudioInput] に対する組み込みの割り込み処理を提供していません。代わりに、検出されたターンごとにワークフローが個別に実行されます。アプリケーション内で割り込みを処理する場合は、[VoiceStreamEventLifecycle][agents.voice.events.VoiceStreamEventLifecycle] イベントをリッスンできます。turn_started は、新しいターンが文字起こしされ、処理が開始されたことを示します。turn_ended は、該当するターンのすべての音声が送信された後にトリガーされます。これらのイベントを使用して、モデルがターンを開始したときに話者のマイクをミュートし、アプリケーションがそのターンに関連するすべての音声の再生を終えた後にミュートを解除できます。
File: docs/ja/voice/quickstart.md
search: exclude: true
クイックスタート
前提条件
Agents SDKの基本的なクイックスタート手順に従い、仮想環境をセットアップしていることを確認してください。次に、SDK からオプションの音声依存関係をインストールします。
pip install 'openai-agents[voice]'以下のデモコードでは、マイクとスピーカーの I/O に sounddevice も使用します。これは voice extra には含まれていません。
pip install sounddevice概念
理解しておくべき主な概念は [VoicePipeline][agents.voice.pipeline.VoicePipeline] です。これは次の 3 ステップのプロセスです。
- 音声テキスト変換モデルを実行して、音声をテキストに変換します。
- 通常はエージェントワークフローであるコードを実行して、結果を生成します。
- テキスト音声変換モデルを実行して、結果のテキストを音声に戻します。
graph LR
%% Input
A["🎤 Audio Input"]
%% Voice Pipeline
subgraph Voice_Pipeline [Voice Pipeline]
direction TB
B["Transcribe (speech-to-text)"]
C["Your Code"]:::highlight
D["Text-to-speech"]
B --> C --> D
end
%% Output
E["🎧 Audio Output"]
%% Flow
A --> Voice_Pipeline
Voice_Pipeline --> E
%% Custom styling
classDef highlight fill:#ffcc66,stroke:#333,stroke-width:1px,font-weight:700;エージェント
まず、複数のエージェントをセットアップします。この SDK でエージェントを構築したことがあれば、見慣れた内容です。2 つのエージェント、設定済みのハンドオフ、ツールを 1 つ用意します。
import random
from agents import Agent
from agents.decorators import tool
from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
@tool
def get_weather(city: str) -> str:
"""Get the weather for a given city."""
print(f"[debug] get_weather called with city: {city}")
choices = ["sunny", "cloudy", "rainy", "snowy"]
return f"The weather in {city} is {random.choice(choices)}."
spanish_agent = Agent(
name="Spanish",
handoff_description="A Spanish-speaking agent.",
instructions=prompt_with_handoff_instructions(
"You're speaking to a human, so be polite and concise. Speak in Spanish.",
),
model="gpt-5.6-sol",
)
agent = Agent(
name="Assistant",
instructions=prompt_with_handoff_instructions(
"You're speaking to a human, so be polite and concise. If the user speaks in Spanish, hand off to the Spanish agent.",
),
model="gpt-5.6-sol",
handoffs=[spanish_agent],
tools=[get_weather],
)音声パイプライン
ワークフローに [SingleAgentVoiceWorkflow][agents.voice.workflow.SingleAgentVoiceWorkflow] を使用して、シンプルな音声パイプラインをセットアップします。
from agents.voice import SingleAgentVoiceWorkflow, VoicePipeline
pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))パイプラインの実行
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
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`
player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
player.start()
# Play the audio stream as it comes in
async for event in result.stream():
if event.type == "voice_stream_event_audio":
player.write(event.data)全体の統合
import asyncio
import random
import numpy as np
import sounddevice as sd
from agents import Agent
from agents.decorators import tool
from agents.voice import (
AudioInput,
SingleAgentVoiceWorkflow,
VoicePipeline,
)
from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
@tool
def get_weather(city: str) -> str:
"""Get the weather for a given city."""
print(f"[debug] get_weather called with city: {city}")
choices = ["sunny", "cloudy", "rainy", "snowy"]
return f"The weather in {city} is {random.choice(choices)}."
spanish_agent = Agent(
name="Spanish",
handoff_description="A Spanish-speaking agent.",
instructions=prompt_with_handoff_instructions(
"You're speaking to a human, so be polite and concise. Speak in Spanish.",
),
model="gpt-5.6-sol",
)
agent = Agent(
name="Assistant",
instructions=prompt_with_handoff_instructions(
"You're speaking to a human, so be polite and concise. If the user speaks in Spanish, hand off to the Spanish agent.",
),
model="gpt-5.6-sol",
handoffs=[spanish_agent],
tools=[get_weather],
)
async def main():
pipeline = VoicePipeline(workflow=SingleAgentVoiceWorkflow(agent))
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`
player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
player.start()
# Play the audio stream as it comes in
async for event in result.stream():
if event.type == "voice_stream_event_audio":
player.write(event.data)
if __name__ == "__main__":
asyncio.run(main())このコード例を実行すると、エージェントが音声を生成し、実際に聞くことができます。自分でエージェントに話しかけられるデモについては、examples/voice/static のコード例をご覧ください。
File: docs/ja/voice/tracing.md
search: exclude: true
トレーシング
エージェントのトレーシングと同様に、音声パイプラインも自動的にトレーシングされます。
基本的なトレーシング情報については上記のトレーシングドキュメントを参照できますが、さらに [VoicePipelineConfig][agents.voice.pipeline_config.VoicePipelineConfig] を通じてパイプラインのトレーシングを設定できます。
トレーシングに関連する主なフィールドは次のとおりです。
- [
tracing_disabled][agents.voice.pipeline_config.VoicePipelineConfig.tracing_disabled]: トレーシングを無効にするかどうかを制御します。デフォルトでは、トレーシングは有効です。 - [
trace_include_sensitive_data][agents.voice.pipeline_config.VoicePipelineConfig.trace_include_sensitive_data]: トレースに音声文字起こしなど、潜在的に機微なデータを含めるかどうかを制御します。これは音声パイプライン専用であり、Workflow 内で行われる処理には適用されません。 - [
trace_include_sensitive_audio_data][agents.voice.pipeline_config.VoicePipelineConfig.trace_include_sensitive_audio_data]: トレースに音声データを含めるかどうかを制御します。 - [
workflow_name][agents.voice.pipeline_config.VoicePipelineConfig.workflow_name]: トレースワークフローの名前です。 - [
group_id][agents.voice.pipeline_config.VoicePipelineConfig.group_id]: トレースのgroup_idで、複数のトレースを関連付けることができます。 - [
trace_metadata][agents.voice.pipeline_config.VoicePipelineConfig.trace_metadata]: トレースに含める追加のメタデータです。
File: docs/ja/agents.md
search: exclude: true
エージェント
エージェントは、アプリの中核となる構成要素です。エージェントとは、指示、ツール、およびハンドオフ、ガードレール、structured outputs などの任意の実行時動作を設定した大規模言語モデル（LLM）です。
SandboxAgent ではなく、単一の基本 Agent を定義またはカスタマイズする場合は、このページを使用してください。複数のエージェントをどのように連携させるかを決定する場合は、エージェントオーケストレーションを参照してください。マニフェストで定義されたファイルとサンドボックスネイティブの機能を備えた分離ワークスペース内でエージェントを実行する場合は、サンドボックスエージェントの概念を参照してください。
SDK は、OpenAIモデルに対してデフォルトで Responses API を使用しますが、ここで重要なのはオーケストレーションです。Agent と Runner を組み合わせることで、SDK がターン、ツール、ガードレール、ハンドオフ、セッションを管理できます。このループを自身で管理する場合は、代わりに Responses API を直接使用してください。
次のガイドの選択
このページは、エージェント定義のハブとして使用してください。次に決定する必要がある内容に応じて、関連するガイドに進んでください。
| 目的 | 次に読むガイド |
|---|---|
| モデルまたはプロバイダーの設定を選択する | モデル |
| エージェントに機能を追加する | ツール |
| 実際のリポジトリ、ドキュメント一式、または分離ワークスペースを対象にエージェントを実行する | サンドボックスエージェントのクイックスタート |
| マネージャー方式のオーケストレーションとハンドオフのどちらを使用するか決定する | エージェントオーケストレーション |
| ハンドオフの動作を設定する | ハンドオフ |
| ターンの実行、イベントのストリーミング、または会話状態の管理を行う | エージェントの実行 |
| 最終出力、実行項目、または再開可能な状態を確認する | 実行結果 |
| ローカルの依存関係と実行時状態を共有する | コンテキスト管理 |
基本設定
エージェントで最も一般的なプロパティは次のとおりです。
| プロパティ | 必須 | 説明 |
|---|---|---|
name |
はい | 人が読める形式のエージェント名です。 |
instructions |
いいえ | システムプロンプトまたは動的な指示のコールバックです。使用を強く推奨します。動的な指示を参照してください。 |
prompt |
いいえ | OpenAIの Responses API 用プロンプト設定です。静的なプロンプトオブジェクトまたは関数を受け取ります。プロンプトテンプレートを参照してください。 |
handoff_description |
いいえ | このエージェントがハンドオフ先として提示される際に公開される短い説明です。 |
handoffs |
いいえ | 会話を専門エージェントに委譲します。ハンドオフを参照してください。 |
model |
いいえ | 使用するLLMです。モデルを参照してください。 |
model_settings |
いいえ | temperature、top_p、tool_choice などのモデル調整パラメーターです。 |
tools |
いいえ | エージェントが呼び出せるツールです。ツールを参照してください。 |
mcp_servers |
いいえ | MCP対応ツールをエージェントに提供するMCPサーバーです。MCPガイドを参照してください。 |
mcp_config |
いいえ | スキーマの strict モードへの変換やMCPエラーの形式調整など、MCPツールの準備方法を詳細に調整します。MCPガイドを参照してください。 |
input_guardrails |
いいえ | このエージェントチェーンへの最初のユーザー入力に対して実行されるガードレールです。ガードレールを参照してください。 |
output_guardrails |
いいえ | このエージェントの最終出力に対して実行されるガードレールです。ガードレールを参照してください。 |
output_type |
いいえ | プレーンテキストの代わりに使用する構造化された出力型です。出力型を参照してください。 |
hooks |
いいえ | エージェント単位のライフサイクルコールバックです。ライフサイクルイベント（フック）を参照してください。 |
tool_use_behavior |
いいえ | ツールの実行結果をモデルに戻してループを継続するか、実行を終了するかを制御します。ツール使用時の動作を参照してください。 |
reset_tool_choice |
いいえ | ツール使用ループを回避するため、ツール呼び出し後に tool_choice をリセットします（デフォルト：True）。ツール使用の強制を参照してください。 |
from agents import Agent
from agents.decorators import tool
@tool
def get_weather(city: str) -> str:
"""returns weather info for the specified city."""
return f"The weather in {city} is sunny"
agent = Agent(
name="Haiku agent",
instructions="Always respond in haiku form",
model="gpt-5-nano",
tools=[get_weather],
)このセクションの内容はすべて Agent に適用されます。SandboxAgent は同じ考え方を基盤とし、ワークスペース単位の実行向けに default_manifest、base_instructions、capabilities、run_as を追加します。サンドボックスエージェントの概念を参照してください。
プロンプトテンプレート
prompt を設定することで、OpenAIプラットフォームで作成したプロンプトテンプレートを参照できます。これは、Responses API 経由でOpenAIモデルにアクセスする場合に機能します。
使用手順は次のとおりです。
新しいプロンプト変数
poem_styleを作成します。次の内容でシステムプロンプトを作成します。
textWrite a poem in {{poem_style}}--prompt-idフラグを指定してコード例を実行します。
from agents import Agent
agent = Agent(
name="Prompted assistant",
prompt={
"id": "pmpt_123",
"version": "1",
"variables": {"poem_style": "haiku"},
},
)実行時にプロンプトを動的に生成することもできます。
from dataclasses import dataclass
from agents import Agent, GenerateDynamicPromptData, Runner
@dataclass
class PromptContext:
prompt_id: str
poem_style: str
async def build_prompt(data: GenerateDynamicPromptData):
ctx: PromptContext = data.context.context
return {
"id": ctx.prompt_id,
"version": "1",
"variables": {"poem_style": ctx.poem_style},
}
agent = Agent(name="Prompted assistant", prompt=build_prompt)
result = await Runner.run(
agent,
"Say hello",
context=PromptContext(prompt_id="pmpt_123", poem_style="limerick"),
)コンテキスト
エージェントは、その context 型に関してジェネリックです。コンテキストは依存性注入の仕組みです。自身で作成して Runner.run() に渡すオブジェクトであり、すべてのエージェント、ツール、ハンドオフなどに渡されます。また、エージェント実行に必要な依存関係と状態をまとめる柔軟なコンテナとして機能します。コンテキストには任意の Python オブジェクトを指定できます。
RunContextWrapper の全機能、共有の使用量追跡、ネストされた tool_input、シリアライズに関する注意事項については、コンテキストガイドを参照してください。
from dataclasses import dataclass
@dataclass
class Purchase:
id: str
@dataclass
class UserContext:
name: str
uid: str
is_pro_user: bool
async def fetch_purchases(self) -> list[Purchase]:
# implement your logic here
return []
agent = Agent[UserContext](
...,
)出力型
デフォルトでは、エージェントはプレーンテキスト（つまり str）形式の出力を生成します。エージェントに特定の型の出力を生成させる場合は、output_type パラメーターを使用できます。一般的には Pydantic オブジェクトを使用しますが、Pydantic の TypeAdapter でラップできる任意の型をサポートしています。これには、dataclass、リスト、TypedDict などが含まれます。
from pydantic import BaseModel
from agents import Agent
class CalendarEvent(BaseModel):
name: str
date: str
participants: list[str]
agent = Agent(
name="Calendar extractor",
instructions="Extract calendar events from text",
output_type=CalendarEvent,
)!!! note
`output_type` を渡すと、通常のプレーンテキストレスポンスではなく、[structured outputs](https://platform.openai.com/docs/guides/structured-outputs)を使用するようモデルに指示します。マルチエージェントシステムの設計パターン
マルチエージェントシステムには多くの設計方法がありますが、一般的には広く適用できる次の 2 つのパターンが使用されます。
- マネージャー（agents as tools）：中央のマネージャー／オーケストレーターが専門サブエージェントをツールとして呼び出し、会話の制御を維持します。
- ハンドオフ：対等なエージェントが、会話を引き継ぐ専門エージェントに制御をハンドオフします。これは分散型のパターンです。
詳細については、エージェント構築の実践ガイドを参照してください。
マネージャー（agents as tools）
customer_facing_agent はすべてのユーザー操作を処理し、ツールとして公開された専門サブエージェントを呼び出します。詳細については、ツールのドキュメントを参照してください。
from agents import Agent
booking_agent = Agent(...)
refund_agent = Agent(...)
customer_facing_agent = Agent(
name="Customer-facing agent",
instructions=(
"Handle all direct user communication. "
"Call the relevant tools when specialized expertise is needed."
),
tools=[
booking_agent.as_tool(
tool_name="booking_expert",
tool_description="Handles booking questions and requests.",
),
refund_agent.as_tool(
tool_name="refund_expert",
tool_description="Handles refund questions and requests.",
)
],
)ハンドオフ
設定されたハンドオフ先は、エージェントが処理を委譲できるサブエージェントです。ハンドオフが発生すると、委譲先のエージェントが会話履歴を受け取り、会話を引き継ぎます。このパターンにより、単一のタスクに特化したモジュール式の専門エージェントを構築できます。詳細については、ハンドオフのドキュメントを参照してください。
from agents import Agent
booking_agent = Agent(...)
refund_agent = Agent(...)
triage_agent = Agent(
name="Triage agent",
instructions=(
"Help the user with their questions. "
"If they ask about booking, hand off to the booking agent. "
"If they ask about refunds, hand off to the refund agent."
),
handoffs=[booking_agent, refund_agent],
)動的な指示
ほとんどの場合、エージェントの作成時に指示を指定できます。ただし、関数を使用して動的な指示を指定することもできます。この関数はエージェントとコンテキストを受け取り、プロンプトを返す必要があります。通常の関数と async 関数の両方を使用できます。
from agents import Agent, RunContextWrapper
def dynamic_instructions(
context: RunContextWrapper[UserContext], agent: Agent[UserContext]
) -> str:
return f"The user's name is {context.context.name}. Help them with their questions."
agent = Agent[UserContext](
name="Triage agent",
instructions=dynamic_instructions,
)ライフサイクルイベント（フック）
エージェントのライフサイクルを監視したい場合があります。たとえば、特定のイベントが発生したときに、イベントのログ記録、データの事前取得、使用量の記録を行う場合です。
フックには次の 2 つのスコープがあります。
- [
RunHooks][agents.lifecycle.RunHooks] は、他のエージェントへのハンドオフを含むRunner.run(...)呼び出し全体を監視します。 - [
AgentHooks][agents.lifecycle.AgentHooks] は、agent.hooksを介して特定のエージェントインスタンスにアタッチされます。
コールバックのコンテキストも、イベントに応じて変わります。
- エージェントの開始／終了フックは、元のコンテキストをラップし、共有の実行使用量状態を保持する [
AgentHookContext][agents.run_context.AgentHookContext] を受け取ります。 - LLM、ツール、ハンドオフの各フックは、[
RunContextWrapper][agents.run_context.RunContextWrapper] を受け取ります。
一般的なフックのタイミングは次のとおりです。
on_agent_start：特定のエージェントが実行を開始したとき。on_agent_end：そのエージェントが最終出力の生成を完了したとき。on_llm_start/on_llm_end：各モデル呼び出しの直前と直後。on_tool_start/on_tool_end：各ローカルツール呼び出しの前後。関数ツールの場合、フックのcontextは通常ToolContextであるため、tool_call_idなどのツール呼び出しメタデータを確認できます。on_handoff：制御があるエージェントから別のエージェントに移ったとき。
ワークフロー全体を単一のオブザーバーで監視する場合は RunHooks を使用し、特定のエージェントに限定されたライフサイクルコールバックが必要な場合は AgentHooks を使用してください。
from agents import Agent, RunHooks, Runner
class LoggingHooks(RunHooks):
async def on_agent_start(self, context, agent):
print(f"Starting {agent.name}")
async def on_llm_end(self, context, agent, response):
print(f"{agent.name} produced {len(response.output)} output items")
async def on_agent_end(self, context, agent, output):
print(f"{agent.name} finished with usage: {context.usage}")
agent = Agent(name="Assistant", instructions="Be concise.")
result = await Runner.run(agent, "Explain quines", hooks=LoggingHooks())
print(result.final_output)コールバックの全機能については、ライフサイクル API リファレンスを参照してください。
ガードレール
ガードレールを使用すると、エージェントの実行と並行してユーザー入力に対するチェック／検証を実行し、生成後のエージェント出力に対してもチェック／検証を実行できます。たとえば、ユーザー入力とエージェント出力の関連性を確認できます。詳細については、ガードレールのドキュメントを参照してください。
エージェントのクローン／コピー
エージェントの clone() メソッドを使用すると、エージェントを複製し、必要に応じて任意のプロパティを変更できます。
pirate_agent = Agent(
name="Pirate",
instructions="Write like a pirate",
model="gpt-5.6-sol",
)
robot_agent = pirate_agent.clone(
name="Robot",
instructions="Write like a robot",
)ツール使用の強制
ツールのリストを指定しても、LLMが必ずツールを使用するとは限りません。[ModelSettings.tool_choice][agents.model_settings.ModelSettings.tool_choice] を設定することで、ツールの使用を強制できます。有効な値は次のとおりです。
auto：ツールを使用するかどうかをLLMが判断できます。required：LLMにツールの使用を要求しますが、どのツールを使用するかはLLMが適切に判断できます。none：LLMにツールを 使用させない ことを要求します。my_toolなどの特定の文字列を設定すると、LLMにその特定のツールの使用を要求します。
OpenAI Responses のツール検索を使用する場合、名前付きツールの選択にはさらに制約があります。tool_choice では、修飾なしの名前空間名や遅延のみのツールを指定できず、tool_choice="tool_search" では [ToolSearchTool][agents.tool.ToolSearchTool] を指定できません。このような場合は、auto または required を使用してください。Responses 固有の制約については、ホスト型ツール検索を参照してください。
from agents import Agent, ModelSettings
from agents.decorators import tool
@tool
def get_weather(city: str) -> str:
"""Returns weather info for the specified city."""
return f"The weather in {city} is sunny"
agent = Agent(
name="Weather Agent",
instructions="Retrieve weather details.",
tools=[get_weather],
model_settings=ModelSettings(tool_choice="get_weather")
)ツール使用時の動作
Agent 設定の tool_use_behavior パラメーターは、ツール出力の処理方法を制御します。
"run_llm_again"：デフォルトです。ツールが実行され、その結果をLLMが処理して最終レスポンスを生成します。"stop_on_first_tool"：最初のツール呼び出しの出力を、LLMによる追加処理なしで最終レスポンスとして使用します。
from agents import Agent
from agents.decorators import tool
@tool
def get_weather(city: str) -> str:
"""Returns weather info for the specified city."""
return f"The weather in {city} is sunny"
agent = Agent(
name="Weather Agent",
instructions="Retrieve weather details.",
tools=[get_weather],
tool_use_behavior="stop_on_first_tool"
)StopAtTools(stop_at_tool_names=[...])：指定されたツールのいずれかが呼び出されると停止し、その出力を最終レスポンスとして使用します。
from agents import Agent
from agents.agent import StopAtTools
from agents.decorators import tool
@tool
def get_weather(city: str) -> str:
"""Returns weather info for the specified city."""
return f"The weather in {city} is sunny"
@tool
def sum_numbers(a: int, b: int) -> int:
"""Adds two numbers."""
return a + b
agent = Agent(
name="Stop At Stock Agent",
instructions="Get weather or sum numbers.",
tools=[get_weather, sum_numbers],
tool_use_behavior=StopAtTools(stop_at_tool_names=["get_weather"])
)ToolsToFinalOutputFunction：ツールの実行結果を処理し、最終出力で実行を終了するか、LLMによる処理を続行するかを決定するカスタム関数です。
from agents import Agent, FunctionToolResult, RunContextWrapper
from agents.agent import ToolsToFinalOutputResult
from agents.decorators import tool
from typing import List, Any
@tool
def get_weather(city: str) -> str:
"""Returns weather info for the specified city."""
return f"The weather in {city} is sunny"
def custom_tool_handler(
context: RunContextWrapper[Any],
tool_results: List[FunctionToolResult]
) -> ToolsToFinalOutputResult:
"""Processes tool results to decide final output."""
for result in tool_results:
if result.output and "sunny" in result.output:
return ToolsToFinalOutputResult(
is_final_output=True,
final_output=f"Final weather: {result.output}"
)
return ToolsToFinalOutputResult(
is_final_output=False,
final_output=None
)
agent = Agent(
name="Weather Agent",
instructions="Retrieve weather details.",
tools=[get_weather],
tool_use_behavior=custom_tool_handler
)!!! note
無限ループを防ぐため、フレームワークはツール呼び出し後に `tool_choice` を自動的に「auto」にリセットします。この動作は、[`agent.reset_tool_choice`][agents.agent.Agent.reset_tool_choice] で設定できます。無限ループが発生する理由は、ツールの実行結果がLLMに送信された後、`tool_choice` によってLLMがさらに別のツール呼び出しを生成し続けるためです。File: docs/ja/config.md
search: exclude: true
設定
このページでは、デフォルトの OpenAI キーやクライアント、デフォルトの OpenAI API 形式、トレーシングのエクスポートに関するデフォルト設定、ログ動作など、通常はアプリケーションの起動時に一度だけ設定する SDK 全体のデフォルトについて説明します。
これらのデフォルトはサンドボックスベースのワークフローにも適用されますが、サンドボックスワークスペース、サンドボックスクライアント、セッションの再利用は個別に設定します。
特定のエージェントまたは実行を設定する必要がある場合は、以下を参照してください。
- 通常の
Agentにおける instructions、ツール、出力型、ハンドオフ、ガードレールについては、エージェントを参照してください。 RunConfig、セッション、会話状態のオプションについては、エージェントの実行を参照してください。SandboxRunConfig、マニフェスト、ケイパビリティ、サンドボックスクライアント固有のワークスペース設定については、サンドボックスエージェントを参照してください。- モデルの選択とプロバイダー設定については、モデルを参照してください。
- 実行ごとのトレーシングメタデータとカスタムトレースプロセッサーについては、トレーシングを参照してください。
設定オブジェクトと辞書
SDK で定義される設定パラメーターは通常、型付きの設定オブジェクト、または同じフィールドを含む辞書のいずれかを受け入れます。これは、型アノテーションに辞書が含まれる、エージェント、実行、モデル、セッション、サンドボックス、音声の各設定境界に適用されます。SDK で定義されたネストされた設定型でも、辞書を使用できます。
from agents import Agent
agent = Agent(
name="Assistant",
model="gpt-5.6-sol",
model_settings={
"reasoning": {"effort": "high"},
"verbosity": "low",
},
)SDK は、これらの辞書を対応する設定オブジェクトに正規化します。SDK で定義されたデータクラス設定型に不明なフィールドがあると TypeError が発生するため、オプション名のスペルミスを早期に検出できます。特定の境界が辞書を受け入れるかどうかを確認するには、そのパラメーターの型アノテーションまたは API リファレンスを確認してください。
API キーとクライアント
デフォルトでは、SDK は LLM リクエストとトレーシングに OPENAI_API_KEY 環境変数を使用します。キーは、SDK が初めて OpenAI クライアントを作成するときに解決されるため（遅延初期化）、最初のモデル呼び出しより前に環境変数を設定してください。アプリの起動前にその環境変数を設定できない場合は、[set_default_openai_key()][agents.set_default_openai_key] 関数を使用してキーを設定できます。
from agents import set_default_openai_key
set_default_openai_key("sk-...")別の方法として、使用する OpenAI クライアントを設定することもできます。デフォルトでは、SDK は環境変数の API キー、または上記で設定したデフォルトキーを使用して AsyncOpenAI インスタンスを作成します。[set_default_openai_client()][agents.set_default_openai_client] 関数を使用すると、これを変更できます。
from openai import AsyncOpenAI
from agents import set_default_openai_client
custom_client = AsyncOpenAI(base_url="...", api_key="...")
set_default_openai_client(custom_client)`openai` v3 のカスタム HTTP クライアント
バージョン 0.21.0 では openai>=3.0.0,<4 が必要です。デフォルトの OpenAI プロバイダーは HTTPX2 を使用するため、ほとんどのアプリケーションでは HTTP クライアントを直接設定する必要はありません。アプリケーションから AsyncOpenAI に http_client= を渡す場合は、カスタムクライアントとそのトランスポート向けオプションに HTTPX2 の型を使用してください。
import httpx2
from openai import AsyncOpenAI, DefaultAsyncHttpx2Client
from agents import set_default_openai_client
http_client = DefaultAsyncHttpx2Client(
timeout=httpx2.Timeout(30.0, connect=5.0),
)
custom_client = AsyncOpenAI(
api_key="...",
http_client=http_client,
)
set_default_openai_client(custom_client)同じ移行が、カスタムトランスポート、認証、イベントフック、モックトランスポート、URL、リクエスト、レスポンス、トランスポート例外処理にも適用されます。それぞれに対応する httpx2 を使用してください。Agents SDK は、任意の従来の httpx オブジェクトを HTTPX2 に変換しません。アプリケーションで httpx を明示的にインストールすると、OpenAI Python SDK による従来のクライアント向けの一時的な互換性対応を利用できますが、新規コードおよび移行済みコードでは HTTPX2 を使用してください。
この OpenAI クライアント境界は、ローカル MCP トランスポートのカスタマイズとは別です。MCP Python SDK v1 は独自の従来の httpx 依存関係を使用し、MCP Python SDK v2 は httpx2 を使用します。詳細については、MCP Python SDK v1 および v2を参照してください。
環境変数に基づくエンドポイント設定を使用する場合、デフォルトの OpenAI プロバイダーは OPENAI_BASE_URL も読み取ります。Responses の WebSocket トランスポートを有効にすると、WebSocket の /responses エンドポイント用に OPENAI_WEBSOCKET_BASE_URL も読み取ります。
export OPENAI_BASE_URL="https://your-openai-compatible-endpoint.example/v1"
export OPENAI_WEBSOCKET_BASE_URL="wss://your-openai-compatible-endpoint.example/v1"最後に、使用する OpenAI API をカスタマイズすることもできます。デフォルトでは、OpenAI Responses API を使用します。[set_default_openai_api()][agents.set_default_openai_api] 関数を使用すると、これをオーバーライドして Chat Completions API を使用できます。
from agents import set_default_openai_api
set_default_openai_api("chat_completions")OpenAI プロバイダーのデフォルト
SDK の OpenAI バックエンドを使用するプロバイダーも、モデル名の文字列をモデルにマッピングするときに SDK 全体のデフォルトを読み取ります。OpenAI Responses モデルでデフォルトとして WebSocket トランスポートを使用するには、[set_default_openai_responses_transport()][agents.set_default_openai_responses_transport] を使用します。
from agents import set_default_openai_responses_transport
set_default_openai_responses_transport("websocket")これは、デフォルトの OpenAI プロバイダーがモデル名を解決した結果として得られる OpenAI Responses モデルに影響します。プロバイダーレベルの設定、接続の再利用、キープアライブオプション、カスタム WebSocket エンドポイントについては、Responses WebSocket トランスポートを参照してください。
OpenAI の設定でプロバイダーレベルのエージェント登録メタデータが必要な場合は、起動時にデフォルトのハーネス ID を一度設定します。
from agents import set_default_openai_harness
set_default_openai_harness("your-harness-id")完全な登録オブジェクトを渡すこともできます。
from agents import OpenAIAgentRegistrationConfig, set_default_openai_agent_registration
set_default_openai_agent_registration(
OpenAIAgentRegistrationConfig(harness_id="your-harness-id")
)SDK のデフォルトが設定されていない場合、SDK の OpenAI バックエンドを使用するプロバイダーは OPENAI_AGENT_HARNESS_ID 環境変数にフォールバックします。ハーネス ID が設定されている場合、RunConfig.trace_metadata にそのキーがすでに存在しない限り、SDK はその ID を agent_harness_id としてトレースメタデータに追加します。
トレーシング
トレーシングはデフォルトで有効です。デフォルトでは、上記のセクションで説明したモデルリクエストと同じ OpenAI API キー、つまり環境変数または設定したデフォルトキーを使用します。[set_tracing_export_api_key][agents.set_tracing_export_api_key] 関数を使用すると、トレーシングに使用する API キーを明示的に設定できます。
from agents import set_tracing_export_api_key
set_tracing_export_api_key("sk-...")モデルのトラフィックで使用するキーまたはクライアントとは異なる OpenAI キーをトレーシングで使用する場合は、デフォルトのキーまたはクライアントを設定するときに use_for_tracing=False を渡してから、トレーシングを個別に設定してください。カスタムクライアントを使用しない場合は、[set_default_openai_key()][agents.set_default_openai_key] でも同じパターンを使用できます。
from openai import AsyncOpenAI
from agents import (
set_default_openai_client,
set_tracing_export_api_key,
)
custom_client = AsyncOpenAI(base_url="https://your-openai-compatible-endpoint.example/v1", api_key="provider-key")
set_default_openai_client(custom_client, use_for_tracing=False)
set_tracing_export_api_key("sk-tracing")デフォルトのエクスポーターを使用するときに、トレースを特定の組織またはプロジェクトに関連付ける必要がある場合は、アプリの起動前に以下の環境変数を設定します。
export OPENAI_ORG_ID="org_..."
export OPENAI_PROJECT_ID="proj_..."グローバルエクスポーターを変更せずに、実行ごとにトレーシング API キーを設定することもできます。
from agents import Runner, RunConfig
await Runner.run(
agent,
input="Hello",
run_config=RunConfig(tracing={"api_key": "sk-tracing-123"}),
)[set_tracing_disabled()][agents.set_tracing_disabled] 関数を使用して、トレーシングを完全に無効にすることもできます。
from agents import set_tracing_disabled
set_tracing_disabled(True)トレーシングを有効にしたまま、機密情報が含まれる可能性のある入力や出力をトレースペイロードから除外する場合は、[RunConfig.trace_include_sensitive_data][agents.run.RunConfig.trace_include_sensitive_data] を False に設定します。
from agents import Runner, RunConfig
await Runner.run(
agent,
input="Hello",
run_config=RunConfig(trace_include_sensitive_data=False),
)アプリの起動前に以下の環境変数を設定することで、コードを変更せずにデフォルトを変更することもできます。
export OPENAI_AGENTS_TRACE_INCLUDE_SENSITIVE_DATA=0トレーシングのすべての制御方法については、トレーシングガイドを参照してください。
デバッグログ
SDK は 2 つの Python ロガー（openai.agents と openai.agents.tracing）を定義しますが、デフォルトではハンドラーをアタッチしません。ログは、アプリケーションの Python ロギング設定に従います。
詳細なログを有効にするには、[enable_verbose_stdout_logging()][agents.enable_verbose_stdout_logging] 関数を使用します。
from agents import enable_verbose_stdout_logging
enable_verbose_stdout_logging()別の方法として、ハンドラー、フィルター、フォーマッターなどを追加してログをカスタマイズできます。詳細については、Python ロギングガイドを参照してください。
import logging
logger = logging.getLogger("openai.agents") # or openai.agents.tracing for the Tracing logger
# To make all logs show up
logger.setLevel(logging.DEBUG)
# To make info and above show up
logger.setLevel(logging.INFO)
# To make warning and above show up
logger.setLevel(logging.WARNING)
# etc
# You can customize this as needed, but this will output to `stderr` by default
logger.addHandler(logging.StreamHandler())ログと診断に含まれる機密データ
一部のログや診断用例外には、機密データ（モデルまたはツールの入力と出力など）が含まれる場合があります。
デフォルトでは、SDK は LLM の入力と出力、またはツールの入力と出力を ログに記録しません 。これらの保護は以下によって制御されます。
OPENAI_AGENTS_DONT_LOG_MODEL_DATA=1
OPENAI_AGENTS_DONT_LOG_TOOL_DATA=1デバッグのためにこのデータを一時的に含める必要がある場合は、アプリの起動前に、いずれかの変数を 0（または false）に設定します。
export OPENAI_AGENTS_DONT_LOG_MODEL_DATA=0
export OPENAI_AGENTS_DONT_LOG_TOOL_DATA=0これらのフラグは、影響を受ける失敗時に、ペイロードを含む診断の詳細を保持するかどうかも制御します。たとえば、ツールデータの秘匿化が有効な場合、FunctionTool に無効な引数を渡すと、基礎となる検証エラーを例外チェーンに含めず、汎用的な ModelBehaviorError が発生します。いずれかの変数を 0 に設定すると、未加工のモデルデータやツールデータが、ログ、例外メッセージ、例外チェーン、その他の診断コンテキストに露出する可能性があるため、管理された開発環境でのみ有効にしてください。
File: docs/ja/examples.md
search: exclude: true
コード例
SDK を使用したさまざまなサンプル実装は、リポジトリの examples セクションで確認できます。コード例は、さまざまなパターンや機能を示す複数のカテゴリーに分かれています。
カテゴリー
agent_patterns: このカテゴリーのコード例では、次のような一般的なエージェント設計パターンを示します。
- 決定論的ワークフロー
- Agents as tools
- ストリーミングイベントを使用する Agents as tools (
examples/agent_patterns/agents_as_tools_streaming.py) - 構造化された入力パラメーターを使用する Agents as tools (
examples/agent_patterns/agents_as_tools_structured.py) - エージェントの並列実行
- 条件に応じたツールの使用
- さまざまなツール使用動作を示しながらツールの使用を強制 (
examples/agent_patterns/forcing_tool_use.py) - 入出力ガードレール
- 判定者としての LLM
- ルーティング
- ストリーミングガードレール
- ツールの承認と状態のシリアル化を伴うヒューマン・イン・ザ・ループ (
examples/agent_patterns/human_in_the_loop.py) - ストリーミングを伴うヒューマン・イン・ザ・ループ (
examples/agent_patterns/human_in_the_loop_stream.py) - 承認フロー向けのカスタム拒否メッセージ (
examples/agent_patterns/human_in_the_loop_custom_rejection.py)
basic: これらのコード例では、次のような SDK の基本機能を紹介します。
- Hello world のコード例（デフォルトモデル、GPT-5、オープンウェイトモデル）
- エージェントのライフサイクル管理
RunHooksとAgentHooksを使用したエージェントおよび実行のライフサイクルのコード例 (examples/basic/lifecycle_example.py)- 動的なシステムプロンプト
- 基本的なツールの使用 (
examples/basic/tools.py) - ツールの入出力ガードレール (
examples/basic/tool_guardrails.py) - ツール出力としての画像の返却 (
examples/basic/image_tool_output.py) - 出力のストリーミング（テキスト、項目、関数呼び出し引数）
- ターン間で共有セッションヘルパーを使用する Responses の WebSocket トランスポート (
examples/basic/stream_ws.py) - プロンプトテンプレート
- ファイル処理（ローカルとリモート、画像と PDF）
- 使用量の追跡
- Runner が管理する再試行設定 (
examples/basic/retry.py) - サードパーティアダプターを介して Runner が管理する再試行 (
examples/basic/retry_litellm.py) - 非厳密な出力型
- 以前のレスポンス ID の使用
customer_service: 航空会社向けカスタマーサービスシステムのコード例です。
financial_research_agent: エージェントとツールを使用して、財務データ分析のための構造化された調査ワークフローを示す財務調査エージェントです。
handoffs: メッセージフィルタリングを伴うエージェントのハンドオフの実践的なコード例です。次の内容が含まれます。
- メッセージフィルターのコード例 (
examples/handoffs/message_filter.py) - ストリーミングを伴うメッセージフィルター (
examples/handoffs/message_filter_streaming.py)
- メッセージフィルターのコード例 (
hosted_mcp: OpenAI Responses API でホスト型 MCP（Model Context Protocol）を使用する方法を示すコード例です。次の内容が含まれます。
- 承認なしのシンプルなホスト型 MCP (
examples/hosted_mcp/simple.py) - Google カレンダーなどの MCP コネクター (
examples/hosted_mcp/connectors.py) - 割り込みベースの承認を伴うヒューマン・イン・ザ・ループ (
examples/hosted_mcp/human_in_the_loop.py) - MCP ツール承認リクエスト用のコールバック (
examples/hosted_mcp/on_approval.py)
- 承認なしのシンプルなホスト型 MCP (
mcp: MCP（Model Context Protocol）を使用してエージェントを構築する方法を学習できます。次の内容が含まれます。
- ファイルシステムのコード例
- Git のコード例
- MCP プロンプトサーバーのコード例
- SSE（Server-Sent Events）のコード例
- SSE リモートサーバー接続 (
examples/mcp/sse_remote_example) - Streamable HTTP のコード例
- Streamable HTTP リモート接続 (
examples/mcp/streamable_http_remote_example) - Streamable HTTP 向けのカスタム HTTP クライアントファクトリー (
examples/mcp/streamablehttp_custom_client_example) MCPUtil.get_all_function_toolsを使用したすべての MCP ツールのプリフェッチ (examples/mcp/get_all_mcp_tools_example)- FastAPI アプリケーションでの
MCPServerManagerの使用 (examples/mcp/manager_example) - MCP ツールのフィルタリング (
examples/mcp/tool_filter_example)
memory: エージェント向けのさまざまなメモリ実装のコード例です。次の内容が含まれます。
- SQLite セッションストレージ
- 高度な SQLite セッションストレージ
- Redis セッションストレージ
- SQLAlchemy セッションストレージ
- Dapr 状態ストアのセッションストレージ
- 暗号化されたセッションストレージ
- OpenAI Conversations セッションストレージ
- Responses 圧縮セッションストレージ
ModelSettings(store=False)を使用したステートレスな Responses 圧縮 (examples/memory/compaction_session_stateless_example.py)- ファイルベースのセッションストレージ (
examples/memory/file_session.py) - ヒューマン・イン・ザ・ループを伴うファイルベースのセッション (
examples/memory/file_hitl_example.py) - ヒューマン・イン・ザ・ループを伴う SQLite インメモリセッション (
examples/memory/memory_session_hitl_example.py) - ヒューマン・イン・ザ・ループを伴う OpenAI Conversations セッション (
examples/memory/openai_session_hitl_example.py) - セッションをまたぐ HITL の承認／拒否シナリオ (
examples/memory/hitl_session_scenario.py)
model_providers: カスタムプロバイダーやサードパーティアダプターなど、OpenAI 以外のモデルを SDK で使用する方法を確認できます。
realtime: SDK を使用してリアルタイム体験を構築する方法を示すコード例です。次の内容が含まれます。
- 構造化されたテキストおよび画像メッセージを使用する Web アプリケーションパターン
- コマンドラインの音声ループと再生処理
- WebSocket 経由の Twilio Media Streams 連携
- Realtime Calls API の
attachフローを使用した Twilio SIP 連携
reasoning_content: 推論コンテンツの扱い方を示すコード例です。次の内容が含まれます。
- Runner API での推論コンテンツ（ストリーミングおよび非ストリーミング） (
examples/reasoning_content/runner_example.py) - OpenRouter 経由の OSS モデルを使用した推論コンテンツ (
examples/reasoning_content/gpt_oss_stream.py) - 基本的な推論コンテンツのコード例 (
examples/reasoning_content/main.py)
- Runner API での推論コンテンツ（ストリーミングおよび非ストリーミング） (
research_bot: 複雑なマルチエージェント調査ワークフローを示す、シンプルなディープリサーチのクローンです。
sandbox: 分離されたワークスペースでエージェントを実行するためのコード例です。次の内容が含まれます。
- 基本的なサンドボックスエージェントのセットアップ (
examples/sandbox/basic.py) - Unix ローカルおよび Docker サンドボックスのライフサイクルのコード例
- サンドボックスを基盤とするハンドオフ (
examples/sandbox/handoffs.py) - サンドボックスのメモリとスナップショットからの再開 (
examples/sandbox/memory.py) - ツールとして公開されるサンドボックスエージェント (
examples/sandbox/sandbox_agents_as_tools.py)
- 基本的なサンドボックスエージェントのセットアップ (
tools: OpenAI がホストするツールと実験的な Codex ツール機能の実装方法を学習できます。コード例には次の内容が含まれます。
- Web 検索とフィルター付き Web 検索
- ファイル検索
- Code interpreter
- ファイル編集と承認を伴う Apply patch ツール (
examples/tools/apply_patch.py) - 承認コールバックを伴う Shell ツールの実行 (
examples/tools/shell.py) - ヒューマン・イン・ザ・ループによる割り込みベースの承認を伴う Shell ツール (
examples/tools/shell_human_in_the_loop.py) - インラインスキルを使用するホスト型コンテナー Shell (
examples/tools/container_shell_inline_skill.py) - スキル参照を使用するホスト型コンテナー Shell (
examples/tools/container_shell_skill_reference.py) - ローカルスキルを使用するローカル Shell (
examples/tools/local_shell_skill.py) - 名前空間と遅延読み込みを使用するツールを備えたツール検索 (
examples/tools/tool_search.py) - 構造化されたツール呼び出しを並行実行するプログラムによるツール呼び出し (
examples/tools/programmatic_tool_calling.py) - コンピュータ操作
- 画像生成
- 実験的な Codex ツールワークフロー (
examples/tools/codex.py) - 同じ Codex 会話スレッドを再利用する実験的な Codex ワークフロー (
examples/tools/codex_same_thread.py)
voice: TTS および STT モデルを使用する音声エージェントのコード例を確認できます。音声をストリーミングするコード例も含まれます。