flowchart TB
    subgraph "用户应用层"
        APP[应用入口]
        DEMO[run_demo_loop]
    end
    
    subgraph "API 接口层"
        AGENT[Agent]
        RUNNER[Runner]
        STREAM[Stream Events]
    end
    
    subgraph "执行引擎层"
        RUNIMPL[_run_impl 执行引擎]
        LIFECYCLE[生命周期钩子]
        CONTEXT[运行上下文]
    end
    
    subgraph "工具系统"
        TOOLS[Tools 工具基类]
        FUNC[Function Tools]
        HOSTED[Hosted Tools]
        MCP[MCP Tools]
        COMPUTER[Computer Tools]
    end
    
    subgraph "模型抽象层"
        MODELINT[Model Interface]
        OPENAIMODEL[OpenAI Models]
        MULTIPROV[Multi Provider]
        LITELLM[LiteLLM Provider]
    end
    
    subgraph "记忆系统"
        SESSION[Session ABC]
        SQLITE[SQLite Session]
        OPENAIMEM[OpenAI Memory]
        REDIS[Redis Session]
    end
    
    subgraph "安全与治理"
        GUARDRAIL[Guardrails]
        EXCEPTIONS[异常处理]
    end
    
    subgraph "多代理协作"
        HANDOFF[Handoffs]
        MULTIAGENT[Multi-Agent]
    end
    
    subgraph "实时语音"
        VOICE[Voice Pipeline]
        STT[Speech-to-Text]
        TTS[Text-to-Speech]
        REALTIME[Realtime Agent]
    end
    
    subgraph "可观测性"
        TRACING[Tracing]
        USAGE[Usage Tracking]
        LOGGER[Logging]
    end
    
    APP --> AGENT
    APP --> RUNNER
    DEMO --> RUNNER
    
    AGENT --> RUNIMPL
    RUNNER --> RUNIMPL
    RUNIMPL --> LIFECYCLE
    RUNIMPL --> CONTEXT
    
    RUNIMPL --> TOOLS
    TOOLS --> FUNC
    TOOLS --> HOSTED
    TOOLS --> MCP
    TOOLS --> COMPUTER
    
    RUNIMPL --> MODELINT
    MODELINT --> OPENAIMODEL
    MODELINT --> MULTIPROV
    MODELINT --> LITELLM
    
    RUNIMPL --> SESSION
    SESSION --> SQLITE
    SESSION --> OPENAIMEM
    SESSION --> REDIS
    
    RUNIMPL --> GUARDRAIL
    RUNIMPL --> EXCEPTIONS
    
    RUNIMPL --> HANDOFF
    HANDOFF --> MULTIAGENT
    
    REALTIME --> VOICE
    VOICE --> STT
    VOICE --> TTS
    
    RUNIMPL --> TRACING
    RUNIMPL --> USAGE
    RUNIMPL --> LOGGER
    
    RUNNER --> STREAM

sequenceDiagram
    autonumber
    participant U as 用户应用
    participant R as Runner
    participant RI as RunImpl
    participant M as Model
    participant T as Tools
    participant S as Session
    participant G as Guardrails
    
    U->>R: Runner.run(agent, input)
    R->>S: 加载会话历史
    S-->>R: 历史消息
    R->>G: 输入安全检查
    G-->>R: 检查通过
    R->>RI: 开始执行循环
    
    loop 直到达到最终输出
        RI->>M: 调用模型
        M-->>RI: 模型响应
        
        alt 模型要求工具调用
            RI->>T: 执行工具调用
            T-->>RI: 工具执行结果
            RI->>S: 保存工具调用记录
        else 模型输出最终结果
            RI->>G: 输出安全检查
            G-->>RI: 检查通过
        end
    end
    
    RI->>S: 保存最终会话状态
    RI-->>R: 执行结果
    R-->>U: RunResult

import asyncio
from agents import Agent, Runner

async def main():
    # 创建最简单的代理
    agent = Agent(
        name="Assistant",
        instructions="你是一个有用的AI助手，请简洁回答用户问题。"
    )
    
    # 执行单次对话
    result = await Runner.run(agent, "今天天气怎么样？")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    """获取指定城市的天气信息"""
    # 模拟天气API调用
    return f"{city}今天天气晴朗，温度25°C"

@function_tool
def calculate(expression: str) -> str:
    """计算数学表达式"""
    try:
        result = eval(expression)
        return f"计算结果：{result}"
    except Exception as e:
        return f"计算错误：{e}"

async def main():
    agent = Agent(
        name="WeatherBot",
        instructions="你是一个能够查询天气和进行计算的助手。",
        tools=[get_weather, calculate]
    )
    
    result = await Runner.run(
        agent,
        "北京天气如何？顺便帮我算一下 15 * 24 是多少。"
    )
    print(f"最终回答：{result.final_output}")
    
    # 查看工具调用历史
    for item in result.all_items:
        if hasattr(item, 'tool_name'):
            print(f"工具调用：{item.tool_name}({item.input}) -> {item.output}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from agents import Agent, Runner, handoff

# 创建专门的代理
research_agent = Agent(
    name="ResearchAgent",
    instructions="你是一个专业的研究助手，专门收集和分析信息。",
    handoff_description="负责信息搜集和研究分析"
)

summary_agent = Agent(
    name="SummaryAgent",
    instructions="你是一个专业的总结助手，将复杂信息简化为易懂的摘要。",
    handoff_description="负责信息总结和简化"
)

# 创建主代理，可以切换到其他代理
main_agent = Agent(
    name="MainAgent",
    instructions="你是一个协调助手，根据用户需求选择合适的专业助手处理任务。",
    handoffs=[research_agent, summary_agent]
)

async def main():
    result = await Runner.run(
        main_agent,
        "请研究一下人工智能的发展历程，并给我一个简洁的总结"
    )
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())