使用 OpenAI Agents SDK 构建智能体——环境配置与首个 Agent 开发

是时候上手了。我们将开始动手构建第一个 AI Agent。尽管 OpenAI Agents SDK 相对直观，在此之前仍需要先正确配置开发环境，并理解与 SDK 相关的一些基础 Python 概念。可用的开发环境是本书其余内容的发射台——从编写/运行 Agents，到测试工具（tools）、调试追踪（traces）、以及编排多 Agent 工作流，都依赖于此。

本章你将学习到：

• 环境搭建：安装 Python、创建虚拟环境、安装 openai-agents SDK，并安全配置你的 OpenAI API Key。我们还会通过运行测试脚本验证环境就绪。
• 开发预备知识：SDK 围绕一组关键 Python 概念构建：类型注解（type hints）、文档字符串（docstring）字面量、装饰器（decorators）、异步编程（async/await）、以及用于结构化数据校验的 Pydantic 库。它们在构建工具与在 Agents 之间传递数据时非常重要。
• 开发你的第一个 AI Agent：在完成搭建后，我们将创建一个客服助手机器人并逐步增强：为其添加一个查询订单状态的工具，再引入**交接（handoff）**到一个“客户挽留”专长的 Agent。本节会把之前讨论的控制逻辑框架真正跑起来。

从本章起，我们开始写代码。到本章末，你将拥有完整可用的 SDK 开发环境、对 SDK 依赖的 Python 概念有基本把握，并拥有一个可以接收输入、调用工具、并把控制权交接给其他 Agent 的真实可运行的 AI Agent。让我们开始吧。

技术要求

整本书的实践示例与每章完整代码可在配套 GitHub 仓库获取：
github.com/PacktPublis…

鼓励你克隆该仓库，复用/改造示例代码，并在学习各章时按需参考。

环境搭建

使用 OpenAI Agents SDK 的第一步是成功搭建环境，包括安装 SDK 并配置系统以便能够运行它。我们将覆盖先决条件、如何使用虚拟环境创建项目、以及在 Windows 与 macOS 上安装 SDK 的方法。还需要获取 OpenAI API Key 并确保安全存储与访问。遵循这些步骤可以避免常见安装问题，并确认你的环境已准备好用于开发。

注意
本章以本地运行 SDK 的环境搭建为主。如果你无法在本地运行（例如机器缺少前置依赖）或不希望本地运行，那么本书的大部分内容也可以在 Google Colab 上远程执行。若采用此方式，请跳至“替代方式：Google Colab”一节。

Python 版本与依赖

如前所述，OpenAI Agents SDK 基于 Python。这意味着你的机器上必须安装 Python 3.9 及以上版本。在 Windows 上，建议把你希望使用的 Python 加入 PATH，以便在 PowerShell/命令提示符 里可直接使用 python 命令。

要验证 Python 是否正确安装，请打开与你操作系统对应的控制台环境：

• Windows 10：PowerShell 或 命令提示符（CMD）
• Windows 11 或 macOS：Terminal（终端）

下文统称为控制台（console） 。

在控制台中输入以下命令查看 Python 版本，确认 ≥ 3.9。若版本不满足或命令报错，请前往 www.python.org/downloads/ 按操作系统说明安装。命令如下：

$ python – version
>>> Python 3.10.6

项目目录、虚拟环境与安装

干净有序的项目结构是构建可维护应用的第一步。书中每个示例会放在各自的项目文件夹内，按章节归类，统一置于一个根目录下。随着项目在本书中逐步升级，专用目录有助于管理 agents、tools 与配置文件。

在根目录下创建如下结构（从根到各章的层级）：

Root
└─ Chapter3
└─ Chapter4

你可以手动创建，也可在控制台里用 mkdir 命令创建。

由于我们将安装 openai-agents 库，需创建虚拟环境以将 SDK 与其他 Python 项目隔离。确保当前在 Root 目录下，在控制台输入：

$ python -m venv .venv

这会在 .venv 目录中创建新的虚拟环境。接下来激活虚拟环境，使之后的 Python 命令都使用该环境（及其已安装库）：

• macOS：

  source .venv/bin/activate
  

• Windows：

  .venv/Scripts/activate
  

激活后，提示符前通常会出现环境名（如 .venv）。这表示之后安装的包与运行的命令都会使用该隔离环境。注意：每次新开终端都需要重新激活虚拟环境。本书中若出现“激活虚拟环境”的提示，即指运行上述命令让终端进入该隔离环境。

接着使用 pip 安装 OpenAI Agents SDK：

$ pip install openai-agents

若控制台最后显示 Successfully installed openai-agents，则说明库安装成功。此时你已有 Python、虚拟环境与所需依赖，下一步是为 OpenAI API 访问做配置。

注册 OpenAI API 并设置 API Key

要使用 OpenAI 的大语言模型（LLM），你需要一个 OpenAI 平台账户（且余额为正）和一个 OpenAI API Key。该 Key 用于将 API 请求与账户关联。

生成 API Key 的步骤：

1. 访问 platform.openai.com/ ，注册或登录（需有效邮箱）。
2. 右上角进入 Settings，左侧选择 Billing。填入支付信息，然后选择 Add to credit balance，输入 **$10** 为账户充值$10。
3. 左侧选择 API keys，点击 Create new secret key。给密钥命名（如 OpenAIAgentsSDKKey），选择 Default project，再点击 Create secret key 生成私密的 API Key。
4. 此时会显示你的 API Key，并提示保存。这是你唯一一次能看到并复制该 Key 的机会。点击 Copy 复制到剪贴板，先临时粘贴到本机某处（如 .txt 文件）。

图 3.1：OpenAI 平台的 API Key 管理界面（示意）

生成 Key 后，下一步就是安全存放，以保护你的账户免遭未授权使用。

注意
该 API Key 相当于访问你 OpenAI 账户的认证层，务必像对待密码一样妥善保管。不要分享，也不要提交到任何公开仓库。任何拿到此 Key 的人都可以代表你调用 API 并消耗额度。因此我们总是通过环境变量传递，而非将 Key 明文写进代码。

在本地开发中也必须保护该 Key。最佳做法是在项目根目录创建一个 .env 文件用于存放 Key，内容如下（替换为你的真实 Key）：

OPENAI_API_KEY="sk-..."

然后安装 python-dotenv 将 .env 中的环境变量加载进应用。在根目录打开控制台，激活虚拟环境并执行：

$ pip install python-dotenv

此时根目录大致如下：

Root
└─ .venv
└─ .env
└─ Chapter3
└─ Chapter4
└─ ...

图 3.2：CLI 环境（示意）

注意
如怀疑 Key 泄露或想作废它，随时回到 OpenAI 平台 API keys 页面，找到目标 Key，点击 Revoke 即可失效处理。

验证环境搭建

现在把一切串起来，验证我们能否使用 SDK 初始化并运行一个 Agent。新建 Chapter3 文件夹，在其中创建 verify_environment_setup.py，写入：

import os
from dotenv import load_dotenv
from agents import Agent, Runner

# Load environment variables from the .env file
load_dotenv()

# Access the API key
api_key = os.getenv("OPENAI_API_KEY")

# Check to confirm API key is accessible:
if not api_key:
    print("Error: OPENAI_API_KEY not found. Please set it in your .env file.")
else:
    print("API Key loaded successfully.")

# Create an agent and run it
agent = Agent(name="Echo Agent", instructions="Return the words 'Setup successful'")
result = Runner.run_sync(agent, "Run setup")
print(result.final_output)

小贴士：在 Packt Reader（新一代阅读器） 中，可用 AI 代码讲解与一键复制功能。打开本书电子版，点击 Copy（1）快速复制代码到你的环境，或点击 Explain（2）获取对代码块的 AI 解释。购买本书可免费使用该阅读器。扫码或访问 packtpub.com/unlock，搜索本书书名并确认版本。

该程序用于验证两大必需库（python-dotenv 与 openai-agents）已安装、你的 OPENAI_API_KEY 可被程序读取，并可用于创建一个基础 AI Agent。运行后若看到类似输出，说明环境配置成功：

PS C:\Users\hasyh\OneDrive\Documents\1_Projects\30. Packt Publishing\OpenAI Agents SDK\Root> python .\Chapter3\verify_environment_setup.py
API Key loaded successfully.
Setup successful

根据操作系统与 IDE 的不同，运行 Python 文件的方法也不同。比如在 VS Code 中，可用右上角的 运行/调试 按钮直接执行。

最基本的方式是通过控制台运行：激活虚拟环境后，输入 python 加上文件路径：

python Chapter3\verify_environment_setup.py

至此，你已完成构建 OpenAI Agents SDK 所需的关键步骤：安装依赖、安全管理 API Key、并验证一切可用。

下一节我们将探索远程环境的替代方案。

备选方案：Google Colab

如果你不想搭建本地开发环境，或正在使用无管理员权限的设备，Google Colab 是一个便捷的云端替代方案。它提供类 Jupyter Notebook 的运行环境，零本地配置即可运行 Python 代码。

要在 Colab 中使用 OpenAI Agents SDK，请按以下步骤操作：

1. 在 colab.research.google.com/ 注册并新建一个 Notebook：

图 3.3：Google Colab 界面

1. 虽然 Colab 已预装 Python，但你仍需安装 OpenAI Agents SDK。请在第一个代码单元格的顶部运行：

!pip install openai-agents

3. 通过环境变量设置你的 OpenAI API Key：

import os
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

4. 现在即可导入 SDK 并开始使用。按照本节说明导入所有所需库。 5. 如果你的 Notebook 涉及多个文件（例如从独立的 Python 模块中加载工具或 Agents），可使用 Colab 的 Files 面板上传这些文件。

在 Colab 中运行 SDK 基本支持本书覆盖的绝大多数工作流，并具备易分享、易复现实验的优势。对于极少数需要本地系统资源或自定义网络的高级场景，Colab 可能存在一定限制，但对大多数 Agent 开发场景来说已足够。

在下一节中，我们将深入支撑 SDK 的核心原语，讲解如何创建与组织你的第一个真实 Agent。

开发前置知识

要使用 OpenAI Agents SDK，不仅需要可用的安装与环境。该 SDK 以一组 Pythonic 的架构模式为设计前提；熟悉这些原则会让你用起来轻松许多。本节将快速介绍使用本 SDK 所需的 三项关键 Python 原则。

请注意，这不是一份完整的 Python 教程。Python 基础超出了本书范围。本节的目标是让你与本书示例中使用的技术保持一致。

Python 函数的架构

SDK 通过 Python 代码使用，因此你会编写自己的函数（甚至类）来扩展 Agent 能力。举例来说，Agents SDK 允许把工具（tool）定义为可被 Agent 调用的普通 Python 函数。因此你应了解如何创建并使用函数：

# 一个示例 Python 函数
def echo(message):
    return f"Message: {message}"

更重要的是，掌握围绕函数的三项“元”概念：类型注解（type hints） 、文档字符串（docstrings）与装饰器（decorators） ——OpenAI Agents SDK 大量使用它们：

• 类型注解（Type hints） ：Python 支持可选的类型注解，用于声明函数输入与输出的变量类型。Agents SDK 把类型注解作为框架功能的一部分使用。例如创建自定义工具时，SDK 会检查函数的类型注解并将其传递给 LLM，让模型准确理解你的工具期望哪些参数以及参数格式。下面的示例中，注解表明输入是 int，输出是 str。
• 文档字符串（Docstrings） ：紧随函数定义之后的字符串，用于记录函数的用途、入参与出参。在 Agents SDK 语境中，docstring 充当元数据，帮助 LLM 更好地理解函数/工具的作用。虽非强制，但有助于 Agent 的可解释性与正确使用。
• 装饰器（Decorators） ：包装并增强其它函数的高阶函数。在 Agents SDK 中，装饰器常用于标记某个函数为工具（如 @function_tool），并添加工具名、描述、参数模式等元数据。

将三者合而为一的完整工具示例：

@function_tool  # 装饰器
def get_order_status(orderID: int) -> str:  # 类型注解
    """ 
    Returns the order status given an order ID
    Args:
        orderID (int) - Order ID of the customer's order
    Returns:
        string - Status message of the customer's order
    """
    if orderID in (100, 101):
        return "Delivered"
    elif orderID in (200, 201):
        return "Delayed"
    elif orderID in (300, 301):
        return "Cancelled"

掌握如何用这三要素来组织函数，会让你的工具更可读、可维护，并与 SDK 的内建能力高度兼容。

Python 异步编程

大多数传统 Python 程序是同步的：逐步顺序执行，每一步完成后再进行下一步。与之相对的是异步编程，可并发处理操作；Python 通过 asyncio 与 async/await 提供了这类能力。

OpenAI Agents SDK 同时提供同步与异步两种运行方式。但在更复杂的场景（如并行运行多个 Agents 或工具）下，推荐异步。Agent 工作流天然偏异步：大量时间花在等待外部操作（API 调用、工具执行、LLM 响应等）。为高效管理并让 Agent 同时处理多件事，SDK 使用 Python 的异步特性，避免阻塞整个程序。

异步编程基础要点：

• 异步函数用 async def 定义（区别于传统 def）
• 调用异步函数时需在前面加 await
• 异步函数只能被其他异步函数或事件循环调用
• 事件循环可通过 asyncio.run() 创建

注意
书中很多示例用同步调用也没问题（尤其在开始阶段，我们不会同时处理多 Agent、多工具调用或流式输出）。但了解并优先使用 async 仍是好习惯，SDK 的设计也能充分发挥其优势。后续章节会同时出现同步与异步范式。熟悉 Python 的异步模型，有助于你理解 Agent 交互在幕后如何编排，并更高效地扩展工作流。

Python 的 Pydantic 数据校验

Pydantic 是一个用于数据校验的 Python 库。简而言之，它让开发者定义一种数据结构（模型） ，随后库会自动验证某个输入是否符合该结构。

OpenAI Agents SDK 使用 Pydantic 的方式主要有三类：

1. 工具的结构化输入：构建工具时，除了使用前面提到的类型注解，你还可以使用 Pydantic 模型定义期望的输入参数。这样 SDK 能在调用函数前先校验输入，并向 LLM 提供清晰的模式，便于其按正确格式调用工具。
2. Agent 的结构化输出：你可以用 Pydantic 定义一个数据结构，并将其设为 Agent 的期望输出。这样可确保 Agent 的任何输出始终符合你设定的 Pydantic 数据模型结构，便于下游处理或作为 API 响应的稳定格式。
3. Agent 执行过程中的 Guardrails：在工作流的某些步骤上，可能需要在继续决策前进行数据校验或护栏检查。在此使用 Pydantic 能通过触发护栏来及时捕获错误。

定义 Pydantic 模型并作为工具输入的示例：

from pydantic import BaseModel, Field
from openai import OpenAI
from openai.agent import tool

# Step 1: 使用 Pydantic 定义结构化输入
class PersonInput(BaseModel):
    name: str = Field(..., description="The full name of the person")
    age: int = Field(..., ge=0, le=150, description="The age of the person in years")
    email: str = Field(..., description="The email address of the person")

# Step 2: 用装饰器创建工具
@function_tool
def process_person(input: PersonInput) -> str:
    """Processes a person's information and returns a summary."""
    return f"{input.name} is {input.age} years old. Contact: {input.email}"

了解 Pydantic 有助于理解 SDK 如何保障数据可靠性。虽然使用 Agents SDK 并不要求你成为 Pydantic 专家，但知道何时用 Pydantic 模型替代普通类型注解很有帮助；当复杂 Agents 之间需要交换结构化数据时，Pydantic 往往能提供更稳定的定义与约束。

开发你的第一个 AI Agent

在我们已完成环境配置并理解核心 Python 开发概念之后，终于到了最激动人心的环节：构建并运行你的第一个 AI Agent。我们将先运行一个 Agent，然后逐步拆解其输出与内部执行阶段。随后再为 Agent 逐步增加复杂度（如集成工具、使用多 Agent 等），让它更智能、更实用。整体结构如下：

图 3.4：Agent 组件

一个简单的客服 Agent

假设我们要构建一个客服 Agent，供公司处理客户请求使用。请在 Chapter3 文件夹下新建 customer_service_agent.py，写入定义 Agent、提供输入并运行 Agent 所需的代码。

下面的示例展示了如何使用 OpenAI Agents SDK 创建并执行一个基础的客服 Agent：

# Required imports
import os
from dotenv import load_dotenv
from agents import Agent, Runner

# Load environment variables from the .env file
load_dotenv()

# Access the API key
api_key = os.getenv("OPENAI_API_KEY")

# Define an agent
agent = Agent(name="Customer service agent",
              instructions="You are an AI Agent that helps respond to customer queries for a local paper company",
              model="gpt-4o")

# Run the Control Logic Framework
result = Runner.run_sync(agent, "How do I cancel my order?")

# Print the result
print(result.final_output)

激活虚拟环境并运行该文件，你可能看到类似输出：

To cancel your order, please contact our customer service team directly. You can reach us by phone at [Your Phone Number] or email us at [Your Email Address]. Be sure to have your order number handy so we can assist you quickly.

注意
由于 LLM 具有概率性，你看到的具体回答可能与示例不同。

逐步解析：

1. 加载依赖与环境变量：与前文一致，我们导入运行 Agent 所需的库并读取 .env。

2. 实例化 Agent：创建 agent 对象并传入 name、instructions、model 三个参数。它们共同构成 Agent 的系统提示（system prompt），用于规定 Agent 的角色与行为。在此示例中，它把 Agent 设定为一家本地纸业公司的客服助手。

3. 运行 Runner.run_sync：传入新建的 agent 与 input_context（这里是用户问题）。在内部，Runner 实现了我们在第 1 章讨论过的控制逻辑框架：调用 agent 指定的 LLM 处理输入、接收响应，并进入循环/生命周期：

   • 若 LLM 返回符合指令与输入的最终输出（final_output） ，则直接返回结果并结束循环；
   • 若 LLM 返回的是要执行的动作（调用一个或多个工具、或进行交接 handoff），Runner 会执行这些动作、拼接结果并再次进入循环，直至完成目标（或达到最大循环次数上限）。

4. 解析结果：Runner.run_sync 返回一个 RunResult 对象，可从中读取 final_output 展示给用户。

在该示例中，Agent 的复杂度很低：只是用系统提示与输入提示直接调用 GPT-4o 并返回结果。因此这次循环只执行了一次：

• 以系统提示 “You are an AI Agent that helps respond to customer queries for a local paper company” 与输入 “How do I cancel my order?” 调用了 LLM；
• LLM 返回了一个 final_output（无需交接或调用工具）；
• 循环结束，输出展示给用户。

理解这套循环机制非常重要。无论 Agent 以后多复杂，Runner 都在每一步根据 LLM 的输出持续驱动这个循环。SDK 的价值在于为我们屏蔽了大量底层流程。

现在，让我们从**工具（tool）**开始，逐步增强这个系统的 agentic 能力。

添加一个工具（Tool）

我们先添加一个工具，让 Agent 能根据订单号查看订单配送状态。真实系统中通常会查数据库，这里为简化直接硬编码逻辑。工具本身的复杂度不是关键，关键在于 SDK 帮我们完成的事：决定是否调用工具、构造工具入参、执行工具并解释其输出。

先补充一个导入：

from agents import Agent, Runner, function_tool

在 Agent 定义上方加入如下代码，创建工具：

# Create a tool
@function_tool
def get_order_status(orderID: int) -> str:
    """
    Returns the order status given an order ID
    """
    if orderID in (100, 101):
        return "Delivered"
    elif orderID in (200, 201):
        return "Delayed"
    elif orderID in (300, 301):
        return "Cancelled"

然后在 Agent 定义中添加 tools 参数：

# Define an agent
agent = Agent(name="Customer service agent",
              instructions="You are an AI Agent that helps respond to customer queries for a local paper company",
              model="gpt-4o",
              tools=[get_order_status])

最后，修改输入，使其与新工具相关：

result = Runner.run_sync(agent, "What's the status of my order? My Order ID is 200")

运行后，可能看到如下输出：

Your order with ID 200 is currently delayed. If you have any further questions or need assistance, feel free to let me know!

在该示例中，我们把 get_order_status 工具加入到客服 Agent。为此需要两步：

1. 给自定义函数加上 @function_tool 装饰器。装饰器会利用函数的类型注解与 docstring，把工具名、参数、用途、返回类型告知 SDK——任何 Python 函数一旦加上该装饰器，都可以被 Agent 调用。
2. 将该函数名放入列表，作为 tools 参数传给 Agent 构造函数。

之后，Agent 会根据目标与任务上下文自行决定是否使用工具。本例中，用户显式询问订单状态并提供了 ID。

在控制逻辑循环中，LLM 首先没有返回最终输出，而是看到可用工具 get_order_status（及其元信息），判断下一步应执行工具，并传入 orderID=200。Runner 执行该函数并把返回值 "Delayed" 加入到 Agent 的输入上下文，开始下一次循环。此时 LLM 既能看到原始用户输入（“订单状态是什么，ID=200？”），也能看到函数输出（“订单为延迟”），于是构造出最终回复并返回给用户。

这串步骤可能有点抽象，但可以可视化。OpenAI 会为每次 Agent 运行记录详细日志，展示每一次 LLM 调用、工具执行与交接，这称为 trace（追踪） 。查看最近一次运行的 trace：

1. 访问 platform.openai.com/ 并登录；
2. 右上选择 Dashboard，左侧点 Traces；
3. 选择 Created 时间最近的那条 trace，你会看到类似如下的分步信息（图 3.5）。

在我的记录里，Runner 首先使用我们设定的系统提示与输入提示调用了 LLM，得到的结果是执行函数调用，入参为 "orderID": 200（图 3.6）。

随后调用了 get_order_status，返回 "Delayed"（图 3.7）。

最后又进行了一次 LLM 调用，输入包含原始问题与函数返回，模型给出最终回复（图 3.8）。

追踪（Tracing）会在后续章节详细讲解，但现在先通过它理解控制逻辑框架中的“思考过程”非常有帮助。

注意
工具可用 ≠ 一定会被用。这是 Agentic AI 的关键特征之一：工具选择与决策不是确定性的，而是依据请求上下文做出。如果用户问的是 “How do I change my password?”，则没必要调用 get_order_status。

添加交接（Handoff）

OpenAI Agents SDK 的一项强大能力是允许 Agent 将任务交接给另一个 Agent。这在多 Agent 编排或专业化分工时十分有用：把问题拆解为子任务，由不同专长的 Agents 处理。在我们的例子里，如果用户想取消订单，我们可能希望把任务交给客户挽留专长的 Agent（它可能被指示采用挽留策略，或有权限调用能为客户提供折扣的工具）。当不同 Agent 各自擅长不同知识域时，交接尤其有价值。

下面创建一个专长于客户挽留的 Agent，并把它作为可交接对象加入现有结构。

首先，定义客户挽留 Agent：

# Define the customer retention agent
customer_retention_agent = Agent(
    name="Customer Retention Agent",
    instructions="You are an AI agent that responds to customers that want to close their accounts and retains their business. Be very courteous, relatable, and kind. Offer discounts up to 10% if it helps",
    model="gpt-4.1"
)

然后，把它加到原客服 Agent 的 handoffs 列表中：

# Define an agent
agent = Agent(name="Customer service agent",
              instructions="You are an AI Agent that helps respond to customer queries for a local paper company",
              model="gpt-4o",
              tools=[get_order_status],
              handoffs=[customer_retention_agent])

最后，修改输入，使其符合交接场景：

result = Runner.run_sync(agent, "I want to cancel my order and account. You delayed my order for the 3rd time!")

可能出现如下输出：

I sincerely apologize for the repeated delays with your order. I understand how frustrating and disappointing this experience has been, and I want to make things right.
While I know you're considering canceling, I'd love the opportunity to make it up to you. As a thank you for your patience, I can offer you a 10% discount on your order, and I will personally monitor your order to ensure there are no further issues.
If you still prefer to cancel, I will completely respect your decision and assist with that right away. Please let me know how you'd like to proceed—your satisfaction is very important to us!

在这个案例中，我们有两个 Agent：之前的客服管理 Agent，以及新的 customer_retention_agent。客服管理 Agent 负责接收客户请求，然后要么直接回复、要么调用 get_order_status 工具、要么交接给客户挽留 Agent。

该流程的控制逻辑循环中，LLM 再次没有直接返回最终输出，而是决定交接任务与上下文给另一 Agent。SDK 的 Runner 发现后会把上下文切换给对方（并带上同样的用户问题）。此时由被交接的 Agent “接管”对话，处理请求并生成最终回答。

这串步骤也可以在本次工作流的 trace 中看到（图 3.9）。

这种多 Agent 设置可扩展到更多 Agent 和更复杂的路由逻辑。其威力在于：每个 Agent 都能有独立人设与能力，而你可以让模型通过 handoff 机制来决定由哪个 Agent 处理。SDK 的职责是无缝传递控制权与会话历史（如有）给下一个 Agent，并遵循模型的输出指令进行编排。

总结

本章我们完成了使用 OpenAI Agents SDK 所需的开发环境搭建：在隔离的 Python 虚拟环境中安装了 SDK，配置了 OpenAI API Key，并通过运行一个最小化的 Agent 验证了环境是否就绪。

同时，我们回顾了 SDK 大量依赖的关键 Python 构造：说明了 类型注解（type hints） 与 文档字符串（docstrings） 如何为 LLM 提供解释你工具所需的元数据，以及 装饰器（decorators） 如何将函数标记为可调用的工具；随后学习了 Python 的异步执行（async/await） ，以及它为何与 Agent 场景密切相关；最后展示了 Pydantic 模型如何对结构化输入/输出进行校验。

随后我们构建了第一个真正的 Agent——一个简单的客服助手，并通过添加工具与**交接（handoff）**扩展了它的能力。我们新增了一个工具，供 Agent 在用户查询订单状态时调用：通过编写一个类型明确、文档完善的自定义函数 get_order_status，并为其添加 @function_tool 装饰器实现。

接着，我们演示了多 Agent 编排的工作方式：创建多个 Agent 并允许它们相互交接。在示例中，我们新增了一个专注“客户挽留”的 Agent，必要时主 Agent 可以将对话交接给它。

每一步增强中，我们都讨论了 SDK 的控制逻辑框架如何在幕后处理推理、工具执行与Agent 切换，从而让你用极少的代码构建出复杂而自适应的系统。

本章只是对 AI Agent 与该 SDK 的入门。在下一章，我们将深入构建与集成 AI Agent 工具。