Building AI Agents

from agents import Agent, Runner, function_tool
import requests

@function_tool
def get_weather(city: str) -> str:
    """Get the current weather for a city.
    
    Args:
        city: The name of the city to get weather for.
    """
    # In production, call a real weather API
    response = requests.get(f"https://api.weather.example.com/current?city={city}")
    data = response.json()
    return f"Weather in {city}: {data['condition']}, {data['temp_c']}°C"

@function_tool
def calculate(expression: str) -> str:
    """Safely evaluate a mathematical expression.
    
    Args:
        expression: A mathematical expression like '2 + 2 * 10'
    """
    import ast
    tree = ast.parse(expression, mode='eval')
    result = eval(compile(tree, '', 'eval'))
    return str(result)

agent = Agent(
    name="Utility Agent",
    model="glomaxgpt-pro",
    instructions="You help users with weather information and calculations.",
    tools=[get_weather, calculate]
)

result = await Runner.run(
    agent,
    "What's the weather in Tokyo? Also, what is 15% of 2,847?"
)
print(result.final_output)

from agents import Agent, Runner, handoff
from agents.tools import WebSearchTool

# Specialist agents
billing_agent = Agent(
    name="Billing Specialist",
    model="glomaxgpt-pro",
    instructions="""You handle billing inquiries. You can:
    - Look up invoices and payment history
    - Process refunds for eligible purchases
    - Explain pricing and subscription tiers
    Always be professional and empathetic."""
)

technical_agent = Agent(
    name="Technical Support",
    model="glomaxgpt-pro",
    instructions="""You handle technical issues. You can:
    - Diagnose API integration problems
    - Help with SDK installation and configuration
    - Explain error codes and troubleshooting steps
    Search documentation when needed.""",
    tools=[WebSearchTool()]
)

# Triage agent that routes to specialists
triage_agent = Agent(
    name="Customer Support Triage",
    model="glomaxgpt-pro",
    instructions="""You are the first point of contact. 
    Determine the nature of the user's request and route to the appropriate specialist.
    For billing issues → hand off to Billing Specialist.
    For technical issues → hand off to Technical Support.
    For general questions, answer directly.""",
    handoffs=[
        handoff(billing_agent),
        handoff(technical_agent)
    ]
)

result = await Runner.run(
    triage_agent,
    "I was charged twice for my subscription this month."
)
print(result.final_output)
print(f"Handled by: {result.last_agent.name}")

from agents import Agent, Runner
from agents.tracing import trace, set_tracing_export_api_key

# Enable tracing export to GlomaxGPT dashboard
set_tracing_export_api_key(api_key="your_GlomaxGPT_api_key")

agent = Agent(
    name="Traced Agent",
    model="glomaxgpt-pro",
    instructions="You are a helpful assistant."
)

# Wrap your run in a named trace for grouping
with trace("Customer Support Session"):
    result = await Runner.run(agent, "Help me understand my invoice.")

# Access trace data programmatically
for step in result.trace.steps:
    print(f"Step: {step.type} | Duration: {step.duration_ms}ms")
    if step.type == "model_call":
        print(f"  Tokens: {step.usage.total_tokens}")
    elif step.type == "tool_call":
        print(f"  Tool: {step.tool_name}")

from GlomaxGPT import GlomaxGPT
import json

client = GlomaxGPT()

tools = [
    {"type": "web_search_preview"},
    {
        "type": "function",
        "name": "send_email",
        "description": "Send an email to a recipient",
        "parameters": {
            "type": "object",
            "properties": {
                "to": {"type": "string"},
                "subject": {"type": "string"},
                "body": {"type": "string"}
            },
            "required": ["to", "subject", "body"]
        }
    }
]

def send_email(to, subject, body):
    # Your email sending implementation
    return {"status": "sent", "message_id": "msg_xyz123"}

def run_agent(user_message: str):
    input_messages = user_message
    
    while True:
        response = client.responses.create(
            model="glomaxgpt-pro",
            instructions="You are a helpful assistant that can search the web and send emails.",
            input=input_messages,
            tools=tools
        )
        
        # Check if we're done
        if response.status == "completed":
            return response.output_text
        
        # Process tool calls
        tool_results = []
        for item in response.output:
            if item.type == "function_call":
                args = json.loads(item.arguments)
                if item.name == "send_email":
                    result = send_email(**args)
                    tool_results.append({
                        "type": "function_call_output",
                        "call_id": item.call_id,
                        "output": json.dumps(result)
                    })
        
        # Continue the loop with tool results
        input_messages = response.output + tool_results

result = run_agent("Search for the latest GPT model pricing and send a summary email to team@example.com")
print(result)

from agents import Agent
from agents.voice import VoicePipeline, SingleAgentVoiceWorkflow

# Define your agent as usual
voice_agent = Agent(
    name="Voice Assistant",
    model="glomaxgpt-pro",
    instructions="""You are a real-time voice assistant. 
    Keep responses concise and conversational — remember the user is listening, not reading.
    Use natural speech patterns and avoid bullet points or markdown."""
)

# Wrap in a voice pipeline
pipeline = VoicePipeline(
    workflow=SingleAgentVoiceWorkflow(voice_agent),
    stt_settings={"language": "en"},
    tts_settings={"voice": "alloy", "speed": 1.0}
)

# Feed audio chunks and receive audio output
async with pipeline.run() as session:
    async for audio_chunk in mic_stream():
        await session.send_audio(audio_chunk)
    
    async for response_audio in session.audio_stream:
        await speaker.play(response_audio)