OpenAI Agents SDK Skill

Quick Start

Installation

bun add @openai/agents zod@3
bun add @openai/agents-realtime  # For voice agents

export OPENAI_API_KEY="your-api-key"

Basic Text Agent

import { Agent, run, tool } from '@openai/agents';
import { z } from 'zod';

const agent = new Agent({
  name: 'Assistant',
  instructions: 'You are helpful.',
  tools: [tool({
    name: 'get_weather',
    parameters: z.object({ city: z.string() }),
    execute: async ({ city }) => `Weather in ${city}: sunny`,
  })],
  model: 'gpt-4o-mini',
});

const result = await run(agent, 'What is the weather in SF?');

Voice Agent & Multi-Agent

// Voice agent
const voiceAgent = new RealtimeAgent({
  voice: 'alloy',
  model: 'gpt-4o-realtime-preview',
});

// Browser session
const session = new RealtimeSession(voiceAgent, {
  apiKey: sessionApiKey, // From backend!
  transport: 'webrtc',
});

// Multi-agent handoffs
const triageAgent = Agent.create({
  handoffs: [billingAgent, techAgent],
});

templates/

Top 3 Critical Errors

1. Zod Schema Type Errors

// ❌ Can cause type errors
parameters: mySchema

// ✅ Works reliably
parameters: z.object({ field: z.string() })

2. MCP Tracing Errors

import { initializeTracing } from '@openai/agents/tracing';
await initializeTracing();

3. MaxTurnsExceededError

const result = await run(agent, input, {
  maxTurns: 20,
});

// Or improve instructions
instructions: `After using tools, provide a final answer.
Do not loop endlessly.`

references/common-errors.md

When to Load References

Agent Patterns (

references/agent-patterns.md

)

• Designing multi-agent orchestration strategies
• Choosing between LLM-based vs code-based orchestration
• Implementing parallel agent execution
• Creating agents-as-tools patterns
• Need to understand when to use which orchestration pattern

Common Errors (

references/common-errors.md

)

• Debugging agent issues beyond the top 3 errors above
• Implementing comprehensive error handling
• Encountering: GuardrailExecutionError, ToolCallError, Schema Mismatch, Ollama integration, webSearchTool failures, Agent Builder export bugs
• Building production error recovery patterns

Realtime Transports (

references/realtime-transports.md

)

• Choosing between WebRTC vs WebSocket for voice agents
• Optimizing voice agent latency
• Debugging voice connection issues
• Understanding network/firewall requirements for voice
• Implementing custom audio sources/sinks

Cloudflare Integration (

references/cloudflare-integration.md

)

• Deploying agents to Cloudflare Workers
• Understanding Workers limitations (CPU, memory, no voice)
• Implementing streaming in Workers
• Debugging Workers-specific issues
• Optimizing for Workers performance and costs

Official Links (

references/official-links.md

)

• Need official documentation links
• Looking for examples or community resources
• Checking latest SDK versions
• Finding pricing information
• Need migration guides

Core Concepts Summary

requiresApproval: true

templates/text-agents/

templates/realtime-agents/

Text Agents Quick Reference

// Basic
const result = await run(agent, 'Your question');

// Streaming
const stream = await run(agent, input, { stream: true });

// Structured output
const agent = new Agent({
  outputType: z.object({ sentiment: z.enum([...]), confidence: z.number() }),
});

templates/text-agents/

Realtime Voice Agents Quick Reference

const voiceAgent = new RealtimeAgent({
  voice: 'alloy', // alloy, echo, fable, onyx, nova, shimmer
  model: 'gpt-4o-realtime-preview',
});

const session = new RealtimeSession(voiceAgent, {
  apiKey: sessionApiKey,
  transport: 'webrtc', // or 'websocket'
});

templates/realtime-agents/

references/realtime-transports.md

Framework Integration Quick Reference

Cloudflare Workers (Experimental)

export default {
  async fetch(request: Request, env: Env) {
    const { message } = await request.json();
    process.env.OPENAI_API_KEY = env.OPENAI_API_KEY;

    const agent = new Agent({
      name: 'Assistant',
      instructions: 'Be helpful and concise',
      model: 'gpt-4o-mini',
    });

    const result = await run(agent, message, { maxTurns: 5 });

    return new Response(JSON.stringify({
      response: result.finalOutput,
      tokens: result.usage.totalTokens,
    }));
  },
};

templates/cloudflare-workers/

references/cloudflare-integration.md

Next.js App Router

// app/api/agent/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { Agent, run } from '@openai/agents';

export async function POST(request: NextRequest) {
  const { message } = await request.json();
  const agent = new Agent({ /* ... */ });
  const result = await run(agent, message);
  return NextResponse.json({ response: result.finalOutput });
}

templates/nextjs/

Guardrails & Human-in-the-Loop

// Input/output guardrails
const agent = new Agent({
  inputGuardrails: [homeworkDetectorGuardrail],
  outputGuardrails: [piiFilterGuardrail],
});

// Human approval
const tool = tool({
  requiresApproval: true,
  execute: async ({ amount }) => `Refunded $${amount}`,
});

// Handle approval loop
while (result.interruption?.type === 'tool_approval') {
  result = (await promptUser(result.interruption))
    ? await result.state.approve(result.interruption)
    : await result.state.reject(result.interruption);
}

templates/text-agents/agent-guardrails-*.ts

agent-human-approval.ts

Orchestration Patterns Summary

references/agent-patterns.md

templates/text-agents/agent-parallel.ts

Debugging & Tracing

process.env.DEBUG = '@openai/agents:*';

const result = await run(agent, input);
console.log('Tokens:', result.usage.totalTokens, 'Turns:', result.history.length);

templates/shared/tracing-setup.ts

Production Checklist

• Set

  OPENAI_API_KEY

  as environment secret
• Implement error handling for all agent calls
• Add guardrails for safety-critical applications
• Set reasonable

  maxTurns

  to prevent runaway costs
• Use

  gpt-4o-mini

  where possible for cost efficiency
• Implement rate limiting
• Log token usage for cost monitoring
• Test handoff flows thoroughly
• Never expose API keys to browsers (use session tokens)
• Enable tracing/observability for debugging

When to Use This Skill

• Building multi-agent workflows
• Creating voice AI applications
• Implementing tool-calling patterns
• Requiring input/output validation (guardrails)
• Needing human approval gates
• Orchestrating complex AI tasks
• Deploying to Cloudflare Workers or Next.js

• Simple OpenAI API calls (use

  openai-api

  skill instead)
• Non-OpenAI models exclusively
• Production voice at massive scale (consider LiveKit Agents)

Token Efficiency

Templates Index

1. agent-basic.ts

   - Simple agent with tools

2. agent-handoffs.ts

   - Multi-agent triage

3. agent-structured-output.ts

   - Zod schemas

4. agent-streaming.ts

   - Real-time events

5. agent-guardrails-input.ts

   - Input validation

6. agent-guardrails-output.ts

   - Output filtering

7. agent-human-approval.ts

   - HITL pattern

8. agent-parallel.ts

   - Concurrent execution

realtime-agent-basic.ts

realtime-session-browser.tsx

realtime-handoffs.ts

worker-text-agent.ts

worker-agent-hono.ts

api-agent-route.ts

api-realtime-route.ts

error-handling.ts

tracing-setup.ts

References

1. agent-patterns.md

   - Orchestration strategies (LLM vs code, parallel, agents-as-tools)

2. common-errors.md

   - All 9 errors with workarounds and sources

3. realtime-transports.md

   - WebRTC vs WebSocket comparison, latency, debugging

4. cloudflare-integration.md

   - Workers setup, limitations, performance, costs

5. official-links.md

   - Documentation, GitHub, npm, community resources

Official Resources

• Docs: https://openai.github.io/openai-agents-js/
• GitHub: https://github.com/openai/openai-agents-js
• npm: https://www.npmjs.com/package/@openai/agents
• Issues: https://github.com/openai/openai-agents-js/issues