OpenAI Agents SDK — בניית סוכנים עם GPT

from agents import Agent, Runner

agent = Agent(
    name="assistant",
    instructions="You are a helpful assistant. Answer in Hebrew when asked in Hebrew.",
    model="gpt-5",
)

result = Runner.run_sync(agent, "מה זה סוכן AI? הסבר בקצרה.")
print(result.final_output)
# סוכן AI הוא תוכנת בינה מלאכותית שיכולה לקבל החלטות
# ולבצע פעולות באופן עצמאי כדי להשיג מטרה מוגדרת...

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

const agent = new Agent({
  name: 'assistant',
  instructions: 'You are a helpful assistant. Answer in Hebrew when asked in Hebrew.',
  model: 'gpt-5',
});

const result = await run(agent, 'מה זה סוכן AI? הסבר בקצרה.');
console.log(result.finalOutput);

from agents import Agent

agent = Agent(
    name="research_analyst",           # שם הסוכן
    instructions="You are a senior research analyst...",  # הוראות (system prompt)
    model="gpt-5",                     # מודל (ברירת מחדל: gpt-5)
    tools=[search_tool, calc_tool],    # כלים שהסוכן יכול לקרוא
    handoffs=[editor_agent],           # סוכנים שהוא יכול להעביר אליהם
    output_type=ResearchReport,        # Pydantic model לפלט מובנה
    handoff_description="Expert at deep research and analysis",  # תיאור להעברות
)

from agents import Agent, Runner

agent = Agent(
    name="storyteller",
    instructions="You tell short stories about Israeli tech culture. Be vivid and engaging.",
)

async def stream_example():
    result = Runner.run_streamed(agent, "ספר לי סיפור על סטארטאפ בתל אביב")

    async for event in result.stream_events():
        # כל event הוא חלק מהתשובה
        if event.type == "raw_response_event":
            # הדפסת טקסט בזמן אמת
            if hasattr(event.data, 'delta'):
                print(event.data.delta, end="", flush=True)

    # בסוף -- התוצאה המלאה
    final = await result.final_output
    print(f"\n\nTotal tokens: {result.usage.total_tokens}")

from dataclasses import dataclass
from agents import Agent, Runner, RunContextWrapper

@dataclass
class AppContext:
    user_id: str
    is_premium: bool
    language: str = "he"

# כלי שמשתמש ב-context
@function_tool
def get_user_orders(ctx: RunContextWrapper[AppContext]) -> str:
    """Get recent orders for the current user."""
    user_id = ctx.context.user_id
    is_premium = ctx.context.is_premium
    # בפרודקשן: query ל-database
    return f"User {user_id} has 3 recent orders (premium: {is_premium})"

agent = Agent(
    name="support",
    instructions="Help users with their orders. Check their order history first.",
    tools=[get_user_orders],
)

# context עובר לכל הכלים והסוכנים
ctx = AppContext(user_id="user_123", is_premium=True)
result = Runner.run_sync(agent, "מה הסטטוס של ההזמנה האחרונה שלי?", context=ctx)

from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str, unit: str = "celsius") -> str:
    """Get the current weather for a city.

    Args:
        city: The city name (e.g., "Tel Aviv", "Jerusalem")
        unit: Temperature unit - "celsius" or "fahrenheit"
    """
    # בפרודקשן: קריאת API אמיתית
    return f"The weather in {city} is 28 degrees {unit}, sunny."

@function_tool
def calculate_shipping(
    weight_kg: float,
    destination: str,
    express: bool = False
) -> str:
    """Calculate shipping cost for a package to Israel.

    Args:
        weight_kg: Package weight in kilograms
        destination: City in Israel
        express: Whether to use express shipping
    """
    base = weight_kg * 15  # ש"ח לק"ג
    if express:
        base *= 2
    return f"Shipping to {destination}: {base:.0f} ILS"

@function_tool
def search_products(query: str, max_results: int = 5) -> str:
    """Search for products in the catalog.

    Args:
        query: Search query string
        max_results: Maximum number of results to return
    """
    # סימולציה
    return f"Found {max_results} products matching '{query}'"

# סוכן עם 3 כלים
agent = Agent(
    name="shop_assistant",
    instructions="""You are a helpful shopping assistant for an Israeli e-commerce store.
    Use tools to help customers. Always respond in the customer's language.
    Prices are in ILS (שקלים).""",
    tools=[get_weather, calculate_shipping, search_products],
)

result = Runner.run_sync(agent, "כמה יעלה לשלוח חבילה של 3 קילו לחיפה?")
print(result.final_output)
# משלוח חבילה של 3 קילו לחיפה יעלה 45 ₪ (משלוח רגיל)
# או 90 ₪ (משלוח מהיר).

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

const getWeather = tool({
  name: 'get_weather',
  description: 'Get the current weather for a city',
  parameters: z.object({
    city: z.string().describe('The city name'),
    unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
  }),
  execute: async ({ city, unit }) => {
    return `The weather in ${city} is 28 degrees ${unit}, sunny.`;
  },
});

const agent = new Agent({
  name: 'assistant',
  instructions: 'You are a helpful assistant.',
  tools: [getWeather],
});

const result = await run(agent, "What's the weather in Tel Aviv?");
console.log(result.finalOutput);

from agents import Agent, Runner
from pydantic import BaseModel

class CompanyAnalysis(BaseModel):
    """Analysis result for an Israeli tech company."""
    company_name: str
    sector: str
    founded_year: int
    employee_count_estimate: int
    funding_total_usd: float
    strengths: list[str]
    risks: list[str]
    recommendation: str  # "invest", "watch", "pass"

agent = Agent(
    name="analyst",
    instructions="""You are a senior tech analyst specializing in Israeli startups.
    Analyze the given company and provide structured output.
    Be specific with numbers and cite sources when possible.""",
    output_type=CompanyAnalysis,  # הפלט חייב להיות CompanyAnalysis
)

result = Runner.run_sync(agent, "Analyze Wiz (Israeli cybersecurity company)")
analysis = result.final_output_as(CompanyAnalysis)

print(f"Company: {analysis.company_name}")
print(f"Sector: {analysis.sector}")
print(f"Recommendation: {analysis.recommendation}")
print(f"Strengths: {', '.join(analysis.strengths)}")

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

const CompanyAnalysisSchema = z.object({
  company_name: z.string(),
  sector: z.string(),
  founded_year: z.number(),
  strengths: z.array(z.string()),
  risks: z.array(z.string()),
  recommendation: z.enum(['invest', 'watch', 'pass']),
});

const agent = new Agent({
  name: 'analyst',
  instructions: 'Analyze Israeli tech companies. Be data-driven.',
  outputType: CompanyAnalysisSchema,
});

const result = await run(agent, 'Analyze Monday.com');
console.log(result.finalOutput.recommendation); // "invest"
console.log(result.finalOutput.strengths);       // ["Strong PLG motion", ...]

from pydantic import BaseModel
from enum import Enum

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

class ActionItem(BaseModel):
    description: str
    assignee: str
    priority: Priority
    due_date: str

class MeetingSummary(BaseModel):
    title: str
    date: str
    participants: list[str]
    key_decisions: list[str]
    action_items: list[ActionItem]  # מודל מקונן!
    next_meeting_date: str | None

meeting_agent = Agent(
    name="Meeting Summarizer",
    instructions="Summarize meeting transcripts into structured notes.",
    output_type=MeetingSummary,
)

result = Runner.run_sync(meeting_agent, """
Meeting transcript: Yossi and Dana discussed the Q2 roadmap.
Decided to launch the AI feature by June 15. Dana will prepare
the design specs by May 20. Yossi to set up the staging environment
by May 25. Next sync: May 18.
""")

summary = result.final_output_as(MeetingSummary)
for item in summary.action_items:
    print(f"[{item.priority.value}] {item.description} -> {item.assignee}")

from agents import Agent, Runner

# סוכנים מומחים
math_agent = Agent(
    name="Math Tutor",
    handoff_description="Specialist for math problems and calculations",
    instructions="""You are a math tutor. Explain step by step.
    Use examples with Israeli context (prices in ILS, distances in km).""",
)

history_agent = Agent(
    name="History Tutor",
    handoff_description="Specialist for historical questions",
    instructions="""You are a history tutor. Focus on context and cause-effect.
    Include Israeli and Middle Eastern history when relevant.""",
)

code_agent = Agent(
    name="Code Tutor",
    handoff_description="Specialist for programming questions",
    instructions="""You are a programming tutor. Show code examples.
    Support Python and TypeScript.""",
)

# סוכן מנתב
triage_agent = Agent(
    name="Triage Agent",
    instructions="""You are a study assistant router.
    Based on the student's question, hand off to the right specialist:
    - Math questions -> Math Tutor
    - History questions -> History Tutor
    - Programming questions -> Code Tutor
    For general questions, answer directly.""",
    handoffs=[math_agent, history_agent, code_agent],
)

# הרצה
result = Runner.run_sync(triage_agent, "איך כותבים לולאת for ב-Python?")
print(result.final_output)
# Code Tutor עונה על השאלה!

from agents import Agent, Runner

translator_es = Agent(
    name="Spanish Translator",
    instructions="Translate the user's message to Spanish.",
)

translator_fr = Agent(
    name="French Translator",
    instructions="Translate the user's message to French.",
)

orchestrator = Agent(
    name="Translation Orchestrator",
    instructions="You translate messages to multiple languages using your tools.",
    tools=[
        translator_es.as_tool(
            tool_name="translate_to_spanish",
            tool_description="Translate text to Spanish",
        ),
        translator_fr.as_tool(
            tool_name="translate_to_french",
            tool_description="Translate text to French",
        ),
    ],
)

result = Runner.run_sync(orchestrator, "Say 'Hello' in Spanish and French")
print(result.final_output)
# Spanish: "Hola"
# French: "Bonjour"

from agents import Agent, Runner

editor = Agent(
    name="Editor",
    instructions="""You are a senior editor. Polish the article you receive:
    - Fix grammar and clarity
    - Ensure engaging opening paragraph
    - Add a compelling headline
    - Keep the content accurate""",
)

writer = Agent(
    name="Writer",
    instructions="""You are a content writer. Take the research notes you receive and write
    a 500-word article. When done, hand off to the Editor for polishing.""",
    handoffs=[editor],
)

researcher = Agent(
    name="Researcher",
    instructions="""You are a research specialist. When given a topic:
    1. List 5 key facts
    2. Note 2-3 statistics
    3. Identify the main narrative angle
    Then hand off to the Writer with your findings.""",
    handoffs=[writer],
)

result = Runner.run_sync(researcher, "Write about AI adoption in Israeli startups")
print(result.final_output)  # מאמר ערוך ומלוטש

from agents import Agent, Runner

market_analyst = Agent(
    name="Market Analyst",
    instructions="Analyze the market size and trends for the given topic. Include Israeli market data.",
)

competitor_analyst = Agent(
    name="Competitor Analyst",
    instructions="Identify top 5 competitors and their strengths/weaknesses.",
)

financial_analyst = Agent(
    name="Financial Analyst",
    instructions="Estimate revenue potential, costs, and break-even timeline.",
)

ceo_agent = Agent(
    name="CEO Advisor",
    instructions="""You are a startup CEO advisor. Use your analyst tools to gather data,
    then synthesize into a clear go/no-go recommendation with supporting evidence.""",
    tools=[
        market_analyst.as_tool("analyze_market", "Get market analysis"),
        competitor_analyst.as_tool("analyze_competitors", "Get competitor analysis"),
        financial_analyst.as_tool("analyze_financials", "Get financial projections"),
    ],
)

result = Runner.run_sync(ceo_agent, "Should we launch an AI writing tool for Hebrew content?")
print(result.final_output)

from agents import (
    Agent, Runner,
    InputGuardrail, GuardrailFunctionOutput,
)
from agents.exceptions import InputGuardrailTripwireTriggered
from pydantic import BaseModel

# מודל פלט ל-guardrail
class RelevanceCheck(BaseModel):
    is_relevant: bool
    reasoning: str

# סוכן guardrail (יכול להשתמש במודל זול)
guardrail_agent = Agent(
    name="Relevance Checker",
    instructions="""Check if the user's message is about technology or business.
    If it's about something completely unrelated (recipes, sports scores, gossip),
    mark as not relevant.""",
    output_type=RelevanceCheck,
    model="gpt-5",  # מודל זול מספיק לבדיקה
)

# פונקציית guardrail
async def check_relevance(ctx, agent, input_data):
    result = await Runner.run(guardrail_agent, input_data, context=ctx.context)
    check = result.final_output_as(RelevanceCheck)
    return GuardrailFunctionOutput(
        output_info=check,
        tripwire_triggered=not check.is_relevant,
    )

# הסוכן הראשי עם guardrail
main_agent = Agent(
    name="Tech Advisor",
    instructions="You are a tech advisor for Israeli businesses.",
    input_guardrails=[
        InputGuardrail(guardrail_function=check_relevance),
    ],
)

# שימוש
import asyncio

async def main():
    # שאלה רלוונטית -- עוברת
    try:
        result = await Runner.run(main_agent, "What cloud provider should I use?")
        print(result.final_output)
    except InputGuardrailTripwireTriggered:
        print("Blocked: not relevant!")

    # שאלה לא רלוונטית -- נחסמת
    try:
        result = await Runner.run(main_agent, "What's the best hummus in Tel Aviv?")
        print(result.final_output)
    except InputGuardrailTripwireTriggered:
        print("Blocked: not relevant!")  # זה מה שיודפס

asyncio.run(main())

from agents import Agent, Runner, OutputGuardrail, GuardrailFunctionOutput
from agents.exceptions import OutputGuardrailTripwireTriggered
from pydantic import BaseModel

class SensitivityCheck(BaseModel):
    contains_pii: bool
    pii_types: list[str]

sensitivity_agent = Agent(
    name="PII Detector",
    instructions="""Check if the text contains PII (Personally Identifiable Information):
    - Israeli ID numbers (teudat zehut)
    - Credit card numbers
    - Phone numbers
    - Full addresses
    List any PII types found.""",
    output_type=SensitivityCheck,
)

async def check_pii(ctx, agent, output):
    result = await Runner.run(sensitivity_agent, output, context=ctx.context)
    check = result.final_output_as(SensitivityCheck)
    return GuardrailFunctionOutput(
        output_info=check,
        tripwire_triggered=check.contains_pii,
    )

safe_agent = Agent(
    name="Customer Agent",
    instructions="Help customers with their accounts.",
    output_guardrails=[
        OutputGuardrail(guardrail_function=check_pii),
    ],
)

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

const RelevanceSchema = z.object({
  is_relevant: z.boolean(),
  reasoning: z.string(),
});

const guardrailAgent = new Agent({
  name: 'Relevance Check',
  instructions: 'Check if the input is about technology. Return is_relevant: false if off-topic.',
  outputType: RelevanceSchema,
});

const mainAgent = new Agent({
  name: 'Tech Advisor',
  instructions: 'You advise on tech topics.',
  inputGuardrails: [
    {
      name: 'relevance_check',
      execute: async (ctx, input) => {
        const result = await run(guardrailAgent, input);
        const check = result.finalOutput;
        return {
          tripwireTriggered: !check.is_relevant,
          outputInfo: check,
        };
      },
    },
  ],
});

from agents import set_trace_processors
from agents.tracing.processors import LangfuseTraceProcessor

# שולח traces גם ל-OpenAI Dashboard וגם ל-Langfuse
set_trace_processors([
    LangfuseTraceProcessor(),  # מעקב חיצוני
])

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

# עוטפים את הריצה ב-trace מותאם
with trace("customer_support_flow", metadata={"user_id": "user_123", "channel": "web"}):
    result = await Runner.run(
        triage_agent,
        "I want to cancel my subscription",
    )

# ב-Dashboard: Trace שם "customer_support_flow" עם metadata
# מאפשר חיפוש לפי user_id, channel, וכו'

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# חיבור ל-MCP Server (filesystem server כדוגמה)
async with MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp/data"],
) as mcp_server:

    agent = Agent(
        name="File Assistant",
        instructions="You help users manage files. Use the filesystem tools.",
        mcp_servers=[mcp_server],  # הכלים נטענים אוטומטית
    )

    result = await Runner.run(agent, "List all files in the data directory")
    print(result.final_output)

from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio

@function_tool
def calculate_vat(amount: float, rate: float = 17.0) -> str:
    """Calculate VAT (מע"מ) for Israeli transactions.

    Args:
        amount: The base amount in ILS
        rate: VAT rate (default 17% for Israel)
    """
    vat = amount * (rate / 100)
    total = amount + vat
    return f"Base: {amount:.2f} ILS, VAT ({rate}%): {vat:.2f} ILS, Total: {total:.2f} ILS"

async with MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp/invoices"],
) as fs_server:

    # סוכן עם כלים מ-2 מקורות: custom + MCP
    accountant = Agent(
        name="Accountant",
        instructions="""You are an Israeli accountant assistant.
        Use filesystem tools to read invoice files.
        Use calculate_vat to compute VAT on amounts.""",
        tools=[calculate_vat],           # כלי custom
        mcp_servers=[fs_server],         # כלים מ-MCP
    )

    result = await Runner.run(accountant, "Read invoice.txt and calculate VAT on the total")
    print(result.final_output)

from agents.mcp import MCPServerSse

async with MCPServerSse(
    url="https://my-mcp-server.example.com/sse",
    headers={"Authorization": "Bearer my-token"},
) as remote_server:

    agent = Agent(
        name="Remote Tool User",
        instructions="Use the remote tools to complete tasks.",
        mcp_servers=[remote_server],
    )

from agents import Agent, Runner
from agents.tools import CodeInterpreterTool, WebSearchTool, FileSearchTool

# סוכן עם Code Interpreter -- יכול לכתוב ולהריץ Python
data_agent = Agent(
    name="Data Analyst",
    instructions="""You are a data analyst. When asked to analyze data:
    1. Write Python code to process the data
    2. Execute it with Code Interpreter
    3. Present findings clearly""",
    tools=[CodeInterpreterTool()],
)

# סוכן עם Web Search -- יכול לחפש באינטרנט
research_agent = Agent(
    name="Researcher",
    instructions="You research topics using web search. Cite sources.",
    tools=[WebSearchTool()],
)

# סוכן עם File Search -- יכול לחפש במסמכים
knowledge_agent = Agent(
    name="Knowledge Base",
    instructions="You answer questions based on uploaded documents.",
    tools=[FileSearchTool(vector_store_ids=["vs_abc123"])],
)

from agents import Agent, Runner

agent = Agent(
    name="advisor",
    instructions="You are a financial advisor. Remember previous context.",
)

# שיחה ראשונה
result1 = Runner.run_sync(agent, "I have 500K ILS to invest.")
# ה-SDK מחזיר previous_response_id

# שיחה שנייה -- ממשיכה את ההקשר!
result2 = Runner.run_sync(
    agent,
    "What about real estate in Tel Aviv?",
    previous_response_id=result1.last_response_id,
)
# הסוכן זוכר שיש 500K ILS

from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    """Get weather for a city."""
    return f"Sunny, 28C in {city}"

agent = Agent(name="assistant", instructions="Help with weather.", tools=[get_weather])
result = Runner.run_sync(agent, "Weather in Tel Aviv?")
print(result.final_output)

import { ToolLoopAgent, tool } from 'ai';
import { z } from 'zod';

const getWeather = tool({
  description: 'Get weather for a city',
  inputSchema: z.object({ city: z.string() }),
  execute: async ({ city }) => `Sunny, 28C in ${city}`,
});

const agent = new ToolLoopAgent({
  model: 'openai/gpt-5',
  tools: { getWeather },
  instructions: 'Help with weather.',
});

const { text } = await agent.generate('Weather in Tel Aviv?');
console.log(text);

from agents.realtime import RealtimeAgent, RealtimeSession

# הגדרת סוכן קולי
voice_agent = RealtimeAgent(
    name="Phone Support",
    instructions="""You are a phone support agent for an Israeli tech company.
    Speak naturally in Hebrew. Be concise -- phone conversations should be short.
    If you can't help, offer to transfer to a human agent.""",
    tools=[check_order_status, create_ticket],
    handoffs=[human_agent],
)

# הפעלת session (WebSocket)
async with RealtimeSession(agent=voice_agent) as session:
    # session מטפל ב-audio input/output אוטומטית
    await session.run()