from agents import Agent

agent = Agent(
    name="Personal Assistant",
    instructions="You are a helpful personal assistant."
)

from pydantic import BaseModel
from enum import Enum

class Priority(str, Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class SupportTicket(BaseModel):
    customer_name: str
    priority: Priority
    issue_description: str

from agents import function_tool

@function_tool
def calculate_compound_interest(
    principal: float, 
    rate: float, 
    time: int
) -> float:
    """Calculate compound interest"""
    return principal * (1 + rate) ** time

agent = Agent(
    name="Calculator",
    tools=[calculate_compound_interest]
)

# Synchronous
result = Runner.run_sync(agent, "Hello")

# Asynchronous
result = await Runner.run(agent, "Hello")

# Streaming
async for event in Runner.run_streamed(agent, "Hello"):
    print(event.content)

# Pass context to agent
result = Runner.run_sync(
    agent,
    "Continue the story",
    context={"previous_chapter": chapter_1}
)

from agents import Agent

agent = Agent(
    name="Safe Agent",
    input_guardrails=[validate_user_input],
    output_guardrails=[filter_sensitive_data]
)

from agents import SQLiteSession

session = SQLiteSession("conversations.db")
result = Runner.run_sync(
    agent,
    "What did we discuss yesterday?",
    session=session
)

from agents import Agent, handoff

billing_agent = Agent(
    name="Billing Specialist",
    instructions="Handle billing inquiries"
)

support_agent = Agent(
    name="Tech Support",
    instructions="Handle technical issues"
)

triage_agent = Agent(
    name="Triage",
    instructions="Route customers to specialists",
    handoffs=[billing_agent, support_agent]
)

import asyncio

# Run multiple agents in parallel
results = await asyncio.gather(
    Runner.run(translator_agent, "Hello"),
    Runner.run(analyzer_agent, data),
    Runner.run(writer_agent, topic)
)

# Use specialized agents as tools
orchestrator = Agent(
    name="Orchestrator",
    tools=[
        translator.as_tool("translate"),
        analyzer.as_tool("analyze")
    ]
)

from agents import Agent, Runner, trace

# Default tracing
with trace():
    result = Runner.run_sync(agent, "Process this")

# Custom traces and spans
with trace(name="custom_workflow") as t:
    with t.span("research_phase"):
        research = await Runner.run(researcher, query)
    with t.span("analysis_phase"):
        analysis = await Runner.run(analyzer, research)

# Turn-based voice interaction
audio_input = record_audio()
result = Runner.run_sync(voice_agent, audio_input)
play_audio(result.audio_output)

# Real-time conversation with streaming
async for event in Runner.run_streamed(voice_agent, audio):
    if event.audio_chunk:
        play_audio_chunk(event.audio_chunk)

# WebSocket-based realtime conversation
async with RealtimeSession() as session:
    await session.connect(voice_agent)
    # Ultra-low latency voice conversation

# Get API key from:
# https://platform.openai.com/api-keys

pip install openai-agents

from agents import Agent, Runner

# Create agent
agent = Agent(
    name="Personal Assistant",
    instructions="You are a helpful assistant."
)

# Run agent
result = Runner.run_sync(agent, "Hello!")
print(result.final_output)