ToCode

agent = Agent(
    name="Assistant",
    tools=[read_shells_file],
    instructions="Answer questions about the file /etc/shells",
)

https://remote.mcpservers.org/fetch/mcp

result = await Runner.run(agent, "Summarize the top stories from ynet today. URL is: https://www.ynet.co.il/news/category/184")

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServer, MCPServerStreamableHttp
from agents.model_settings import ModelSettings


async def run(mcp_server: MCPServer):
    agent = Agent(
        name="Assistant",
        instructions="Use the tools to answer the questions.",
        mcp_servers=[mcp_server],
        model_settings=ModelSettings(tool_choice="required"),
    )

    result = await Runner.run(agent, "Summarize the top stories from ynet today. URL is: https://www.ynet.co.il/news/category/184")
    print(result.to_input_list())
    print(result.final_output)


async def main():
    async with MCPServerStreamableHttp(
        name="Streamable HTTP Python Server",
        params={
            "url": "https://remote.mcpservers.org/fetch/mcp",
        },
    ) as server:
        await run(server)


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

french_agent = Agent(
    name="French Translator",
    instructions="Translate everything to french"
)
spanish_agent = Agent(
    name="Spanish Translator",
    instructions="Translate everything to Spanish")

triage_agent = Agent(name="Triage agent", handoffs=[french_agent, spanish_agent])

async def main():
    session = SQLiteSession("handoffs", "handoffs.db")
    result = await Runner.run(triage_agent, "translate to French: 'hello world'", session=session)
    print(result.final_output)

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

1|handoffs|{"content": "translate to French: 'hello world'", "role": "user"}|2025-08-17 11:49:06
2|handoffs|{"arguments": "{}", "call_id": "call_Abq5WDOv6C1RZVKNsCg4WO0F", "name": "transfer_to_french_translator", "type": "function_call", "id": "fc_68a1c1b13b8081988a6174005b308dd20e79e771496ac495", "status": "completed"}|2025-08-17 11:49:06
3|handoffs|{"call_id": "call_Abq5WDOv6C1RZVKNsCg4WO0F", "output": "{\"assistant\": \"French Translator\"}", "type": "function_call_output"}|2025-08-17 11:49:06
4|handoffs|{"id": "msg_68a1c1b27324819892a9f00a9d0b95f50e79e771496ac495", "content": [{"annotations": [], "text": "'hello world' se traduit par 'bonjour le monde'.", "type": "output_text", "logprobs": []}], "role": "assistant", "status": "completed", "type": "message"}|2025-08-17 11:49:06

if result.tool.name == "open_box":
            return ToolsToFinalOutputResult(is_final_output=True, final_output=result.output)
    # Otherwise, continue
    return ToolsToFinalOutputResult(is_final_output=False)

on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x104dd1bc0>,
        strict_json_schema=True,
        is_enabled=True
    ),
    output='An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
    run_item=ToolCallOutputItem(
        agent=Agent(
            name='Assistant',
            handoff_description=None,
            tools=[
                FunctionTool(
                    name='open_box',
                    description='Open a box and search for the treasure inside. Returns True if found',
                    params_json_schema={
                        'properties': {
                            'id': {
                                'title': 'Id',
                                'type': 'string'
                            }
                        },
                        'required': ['id'],
                        'title': 'open_box_args',
                        'type': 'object',
                        'additionalProperties': False
                    },
                    on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x104dd1bc0>,
                    strict_json_schema=True,
                    is_enabled=True
                ),
                FunctionTool(
                    name='get_box_ids',
                    description='',
                    params_json_schema={
                        'properties': {},
                        'title': 'get_box_ids_args',
                        'type': 'object',
                        'additionalProperties': False,
                        'required': []
                    },
                    on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x110d2a200>,
                    strict_json_schema=True,
                    is_enabled=True
                )
            ],
            mcp_servers=[],
            mcp_config={},
            instructions=None,
            prompt=None,
            handoffs=[],
            model=<agents.extensions.models.litellm_model.LitellmModel object at 0x110aa7620>,
            model_settings=ModelSettings(
                temperature=None,
                top_p=None,
                frequency_penalty=None,
                presence_penalty=None,
                tool_choice=None,
                parallel_tool_calls=None,
                truncation=None,
                max_tokens=None,
                reasoning=None,
                metadata=None,
                store=None,
                include_usage=None,
                response_include=None,
                extra_query=None,
                extra_body=None,
                extra_headers=None,
                extra_args=None
            ),
            input_guardrails=[],
            output_guardrails=[],
            output_type=None,
            hooks=None,
            tool_use_behavior=<function custom_tool_use_behavior at 0x110d2a0c0>,
            reset_tool_choice=True
        ),
        raw_item={
            'call_id': 'call_4cPEq87qI3ccfPvCEQKZrelY',
            'output': 'An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
            'type': 'function_call_output'
        },
        output='An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
        type='tool_call_output_item'
    )
)
---

def custom_tool_use_behavior(context, tool_results: list[FunctionToolResult]) -> ToolsToFinalOutputResult:
    print(context)
    for result in tool_results:

handoff_description=None,
            tools=[
                FunctionTool(
                    name='open_box',
                    description='Open a box and search for the treasure inside. Returns True if found',
                    params_json_schema={
                        'properties': {
                            'id': {
                                'title': 'Id',
                                'type': 'string'
                            }
                        },
                        'required': ['id'],
                        'title': 'open_box_args',
                        'type': 'object',
                        'additionalProperties': False
                    },
                    on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x104dd1bc0>,
                    strict_json_schema=True,
                    is_enabled=True
                ),
                FunctionTool(
                    name='get_box_ids',
                    description='',
                    params_json_schema={
                        'properties': {},
                        'title': 'get_box_ids_args',
                        'type': 'object',
                        'additionalProperties': False,
                        'required': []
                    },
                    on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x110d2a200>,
                    strict_json_schema=True,
                    is_enabled=True
                )
            ],
            mcp_servers=[],
            mcp_config={},
            instructions=None,
            prompt=None,
            handoffs=[],
            model=<agents.extensions.models.litellm_model.LitellmModel object at 0x110aa7620>,
            model_settings=ModelSettings(
                temperature=None,
                top_p=None,
                frequency_penalty=None,
                presence_penalty=None,
                tool_choice=None,
                parallel_tool_calls=None,
                truncation=None,
                max_tokens=None,
                reasoning=None,
                metadata=None,
                store=None,
                include_usage=None,
                response_include=None,
                extra_query=None,
                extra_body=None,
                extra_headers=None,
                extra_args=None
            ),
            input_guardrails=[],
            output_guardrails=[],
            output_type=None,
            hooks=None,
            tool_use_behavior=<function custom_tool_use_behavior at 0x110d2a0c0>,
            reset_tool_choice=True
        ),
        raw_item={
            'call_id': 'call_AakkVgr7fikDFcam0VADoa9z',
            'output': 'An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
            'type': 'function_call_output'
        },
        output='An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
        type='tool_call_output_item'
    )
)

---
RunContextWrapper(
    context=None,
    usage=Usage(
        requests=2,
        input_tokens=939,
        input_tokens_details=InputTokensDetails(
            cached_tokens=0
        ),
        output_tokens=78,
        output_tokens_details=OutputTokensDetails(
            reasoning_tokens=0
        ),
        total_tokens=1017
    )
)
FunctionToolResult(
    tool=FunctionTool(
        name='open_box',
        description='Open a box and search for the treasure inside. Returns True if found',
        params_json_schema={
            'properties': {
                'id': {
                    'title': 'Id',
                    'type': 'string'
                }
            },
            'required': ['id'],
            'title': 'open_box_args',
            'type': 'object',
            'additionalProperties': False
        },

7|boxes|{"call_id": "call_0ukIo397uSCrgRHDNwJugFuC", "output": "True", "type": "function_call_output"}|2025-08-14 10:13:28
8|boxes|{"id": "__fake_id__", "content": [{"annotations": [], "text": "I opened the first box, but didn't find the treasure. Then I opened the second box and found the treasure inside! \n\nI found the treasure by opening only 2 boxes.", "type": "output_text"}], "role": "assistant", "status": "completed", "type": "message"}|2025-08-14 10:13:28

async def main():
    session = SQLiteSession("boxes", "boxes.db")
    result = await Runner.run(agent, """
    Let's play a game. You are given 3 boxes and you need to find the treasure hidden in one of them. You can open any box you want
    to look inside.
    Use open_box tool to open boxes and find the treasure. 
    Try to find it by opening the miniumum number of boxes.
    """, session=session, max_turns=3)
    print(result.final_output)

agents.exceptions.MaxTurnsExceeded: Max turns (3) exceeded

agent = Agent(
    name="Assistant",
    model=LitellmModel(model="github/gpt-4.1", api_key=os.environ["GITHUB_TOKEN"]),
    tools=[open_box, get_box_ids],
    tool_use_behavior=custom_tool_use_behavior
)

def custom_tool_use_behavior(context, tool_results: list[FunctionToolResult]) -> ToolsToFinalOutputResult:
    print(context)
    for result in tool_results:
        print(result)
        print("---")
    # Otherwise, continue
    return ToolsToFinalOutputResult(is_final_output=False)

RunContextWrapper(
    context=None,
    usage=Usage(
        requests=1,
        input_tokens=437,
        input_tokens_details=InputTokensDetails(
            cached_tokens=0
        ),
        output_tokens=40,
        output_tokens_details=OutputTokensDetails(
            reasoning_tokens=0
        ),
        total_tokens=477
    )
)
FunctionToolResult(
    tool=FunctionTool(
        name='open_box',
        description='Open a box and search for the treasure inside. Returns True if found',
        params_json_schema={
            'properties': {
                'id': {
                    'title': 'Id',
                    'type': 'string'
                }
            },
            'required': ['id'],
            'title': 'open_box_args',
            'type': 'object',
            'additionalProperties': False
        },
        on_invoke_tool=<function function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool at 0x104dd1bc0>,
        strict_json_schema=True,
        is_enabled=True
    ),
    output='An error occurred while running the tool. Please try again. Error: coroutine raised StopIteration',
    run_item=ToolCallOutputItem(
        agent=Agent(
            name='Assistant',

14|weather|{"id": "__fake_id__", "content": [{"annotations": [], "text": "Here is today's weather in major Israeli cities:\n\n- Tel Aviv: Clear sky, 36.9\u00b0C (feels like 40.23\u00b0C), 38% humidity\n- Jerusalem: Clear sky, 38.34\u00b0C (feels like 42.39\u00b0C), 36% humidity\n- Haifa: Clear sky, 33.39\u00b0C (feels like 34.41\u00b0C), 40% humidity\n- Eilat: Clear sky, 42.91\u00b0C (feels like 45.23\u00b0C), 23% humidity\n\nIt\u2019s a very hot and sunny day across the country\u2014plan accordingly!", "type": "output_text"}], "role": "assistant", "status": "completed", "type": "message"}|2025-08-14 09:59:42

from typing_extensions import TypedDict
from agents import Agent, function_tool, Runner, SQLiteSession
from agents.extensions.models.litellm_model import LitellmModel
from uuid import uuid4
import requests
import os
import asyncio

boxes = [
    {
        "id": str(uuid4()),
        "has_treasure": False
    },
    {
        "id": str(uuid4()),
        "has_treasure": True
    },
    {
        "id": str(uuid4()),
        "has_treasure": False
    }
]

@function_tool
async def open_box(id: str) -> bool:
    """Open a box and search for the treasure inside. Returns True if found"""
    return next(b['has_treasure'] for b in boxes if b['id'] == id)

@function_tool
async def get_box_ids() -> list[str]:
    return [b['id'] for b in boxes]

agent = Agent(
    name="Assistant",
    model=LitellmModel(model="github/gpt-4.1", api_key=os.environ["GITHUB_TOKEN"]),
    tools=[open_box, get_box_ids],
)

async def main():
    session = SQLiteSession("boxes", "boxes.db")
    result = await Runner.run(agent, """
    Let's play a game. You are given 3 boxes and you need to find the treasure hidden in one of them. You can open any box you want
    to look inside.
    Use open_box tool to open boxes and find the treasure. 
    Try to find it by opening the miniumum number of boxes.
    """, session=session)
    print(result.final_output)

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

sqlite> select * from agent_messages ;
1|boxes|{"content": "\n    Let's play a game. You are given 3 boxes and you need to find the treasure hidden in one of them. You can open any box you want\n    to look inside.\n    Use open_box tool to open boxes and find the treasure. \n    Try to find it by opening the miniumum number of boxes.\n    ", "role": "user"}|2025-08-14 10:13:28
2|boxes|{"arguments": "{}", "call_id": "call_Rjqjj5dQyxCISwpPMR3hrrai", "name": "get_box_ids", "type": "function_call", "id": "__fake_id__"}|2025-08-14 10:13:28
3|boxes|{"call_id": "call_Rjqjj5dQyxCISwpPMR3hrrai", "output": "['c77fa56d-0375-4e8d-9470-3f494b16706c', '1e499625-705d-40f7-bae4-df71bf97c523', 'd3f99c22-33fd-4cce-b7c2-9f7de13c122e']", "type": "function_call_output"}|2025-08-14 10:13:28
4|boxes|{"arguments": "{\"id\":\"c77fa56d-0375-4e8d-9470-3f494b16706c\"}", "call_id": "call_MU2FdBwcGn9ayc0f04UyS1ea", "name": "open_box", "type": "function_call", "id": "__fake_id__"}|2025-08-14 10:13:28
5|boxes|{"call_id": "call_MU2FdBwcGn9ayc0f04UyS1ea", "output": "False", "type": "function_call_output"}|2025-08-14 10:13:28
6|boxes|{"arguments": "{\"id\":\"1e499625-705d-40f7-bae4-df71bf97c523\"}", "call_id": "call_0ukIo397uSCrgRHDNwJugFuC", "name": "open_box", "type": "function_call", "id": "__fake_id__"}|2025-08-14 10:13:28

2|weather|{"arguments": "{\"location\":{\"lat\":32.0853,\"long\":34.7818}}", "call_id": "call_obLi5Lbz93fzOIDRvC195udg", "name": "fetch_weather", "type": "function_call", "id": "__fake_id__"}|2025-08-14 09:54:56
3|weather|{"call_id": "call_obLi5Lbz93fzOIDRvC195udg", "output": "Weather: Clear Sky, Temperature: 36.9\u00b0C (feels like 40.23\u00b0C), Humidity: 38%", "type": "function_call_output"}|2025-08-14 09:54:56
4|weather|{"id": "__fake_id__", "content": [{"annotations": [], "text": "The weather in Tel Aviv is currently clear sky with a temperature of 36.9\u00b0C (feels like 40.23\u00b0C) and humidity at 38%. It's quite hot today!", "type": "output_text"}], "role": "assistant", "status": "completed", "type": "message"}|2025-08-14 09:54:56

result = await Runner.run(agent, "What is the weather in Tel Aviv?", session=session)

async def main():
    session = SQLiteSession("weather", "weather.db")
    result = await Runner.run(agent, "I'm planning a trip to Israel, what is the weather in Tel Aviv, Jerusalem, Haifa and Eilat today?", session=session)
    print(result.final_output)

5|weather|{"content": "I'm planning a trip to Israel, what is the weather in Tel Aviv, Jerusalem, Haifa and Eilat today?", "role": "user"}|2025-08-14 09:59:42
6|weather|{"arguments": "{\"location\": {\"lat\": 32.0853, \"long\": 34.7818}}", "call_id": "call_la2QHswRUH0Xa80wZNLQ6dOv", "name": "fetch_weather", "type": "function_call", "id": "__fake_id__"}|2025-08-14 09:59:42
7|weather|{"arguments": "{\"location\": {\"lat\": 31.7683, \"long\": 35.2137}}", "call_id": "call_AEGdktcxYfR2MzGS7BzhA9AY", "name": "fetch_weather", "type": "function_call", "id": "__fake_id__"}|2025-08-14 09:59:42
8|weather|{"arguments": "{\"location\": {\"lat\": 32.794, \"long\": 34.9896}}", "call_id": "call_CFb2TkCz6M6eL19aT7c69Zae", "name": "fetch_weather", "type": "function_call", "id": "__fake_id__"}|2025-08-14 09:59:42
9|weather|{"arguments": "{\"location\": {\"lat\": 29.5577, \"long\": 34.9519}}", "call_id": "call_DWgN1qFAru8ScClVHj1jgqIz", "name": "fetch_weather", "type": "function_call", "id": "__fake_id__"}|2025-08-14 09:59:42
10|weather|{"call_id": "call_la2QHswRUH0Xa80wZNLQ6dOv", "output": "Weather: Clear Sky, Temperature: 36.9\u00b0C (feels like 40.23\u00b0C), Humidity: 38%", "type": "function_call_output"}|2025-08-14 09:59:42
11|weather|{"call_id": "call_AEGdktcxYfR2MzGS7BzhA9AY", "output": "Weather: Clear Sky, Temperature: 38.34\u00b0C (feels like 42.39\u00b0C), Humidity: 36%", "type": "function_call_output"}|2025-08-14 09:59:42
12|weather|{"call_id": "call_CFb2TkCz6M6eL19aT7c69Zae", "output": "Weather: Clear Sky, Temperature: 33.39\u00b0C (feels like 34.41\u00b0C), Humidity: 40%", "type": "function_call_output"}|2025-08-14 09:59:42
13|weather|{"call_id": "call_DWgN1qFAru8ScClVHj1jgqIz", "output": "Weather: Clear Sky, Temperature: 42.91\u00b0C (feels like 45.23\u00b0C), Humidity: 23%", "type": "function_call_output"}|2025-08-14 09:59:42

from typing_extensions import TypedDict
from agents import Agent, function_tool, Runner
from agents.extensions.models.litellm_model import LitellmModel

import requests
import os
import asyncio

weather_api_key = os.getenv("OPENWEATHER_API_KEY")
if not weather_api_key:
    raise "Error: OpenWeather API key not found in environment variables"

class Location(TypedDict):
    lat: float
    long: float

@function_tool
async def fetch_weather(location: Location) -> str:
    base_url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "lat": location["lat"],
        "lon": location["long"],
        "appid": weather_api_key,
        "units": "metric"
    }

    # Run the synchronous requests call in a thread pool
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, requests.get, base_url, params)
    response.raise_for_status()

    data = response.json()
    weather_desc = data["weather"][0]["description"]
    temp = data["main"]["temp"]
    feels_like = data["main"]["feels_like"]
    humidity = data["main"]["humidity"]

    return f"Weather: {weather_desc.title()}, Temperature: {temp}°C (feels like {feels_like}°C), Humidity: {humidity}%"

agent = Agent(
    name="Assistant",
    model=LitellmModel(model="github/gpt-4.1", api_key=os.environ["GITHUB_TOKEN"]),
    tools=[fetch_weather],
)

async def main():
    result = await Runner.run(agent, "What is the weather in Tel Aviv?")
    print(result.final_output)

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

The weather in Tel Aviv is currently clear with a temperature of 37.05°C (feels like 40.16°C) and humidity at 37%. It's quite hot outside!

async def main():
    session = SQLiteSession("weather", "weather.db")
    result = await Runner.run(agent, "What is the weather in Tel Aviv?", session=session)
    print(result.final_output)

sqlite> select * from agent_messages ;
1|weather|{"content": "What is the weather in Tel Aviv?", "role": "user"}|2025-08-14 09:54:56

name="Assistant",
    tools=[
        WebSearchTool(),
    ],
)

async def main():
    result = await Runner.run(agent, "Which coffee shop should I go to, taking into account the weather today in SF?")
    print(result.final_output)


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

from tavily import TavilyClient
tavily_client = TavilyClient(api_key="tvly-YOUR_API_KEY")
response = tavily_client.search("Who is Leo Messi?")
print(response)

import asyncio

from agents import Agent, Runner

import json

from typing_extensions import TypedDict, Any
import os
from agents import Agent, FunctionTool, RunContextWrapper, function_tool
from agents.extensions.models.litellm_model import LitellmModel

@function_tool
async def run_python(code: str) -> str:
    """Run provided python code and return the value of "result" global variable as string.

    Args:
        code: python code to execute

    Example input to return the value of 5 + 7:
        x = 5
        y = 7
        result = x + y
    """
    print(f"Running Code: \n\n{code}")
    ns = {}
    exec(code, ns)
    print(f"Result = {ns['result']}")
    return str(ns['result'])

agent = Agent(
    name="Assistant",
    model=LitellmModel(model="github/gpt-4.1", api_key=os.environ["GITHUB_TOKEN"]),
    tools=[run_python],
)

async def main():
    result = await Runner.run(agent, "What is the current os.name ? use Python to find out")
    print(result.final_output)

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

import os
result = os.name

import asyncio
from agents import Agent, Runner, CodeInterpreterTool

agent = Agent(
    name="Assistant",
    tools=[CodeInterpreterTool(
        tool_config={
            "type": "code_interpreter",
            "container": { "type": "auto" }
        }
    )],
)

async def main():
    result = await Runner.run(agent, "What is the current os.name ? use Python to find out")
    print(result.final_output)

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

import asyncio

from agents import Agent, Runner, WebSearchTool

agent = Agent(

from telegram import ForceReply, Update
from telegram.ext import Application, CommandHandler, ContextTypes, MessageHandler, filters

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Send a message when the command /start is issued."""
    user = update.effective_user
    await update.message.reply_html(
        rf"Hi {user.mention_html()}!",
        reply_markup=ForceReply(selective=True),
    )


async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Echo the user message."""
    await update.message.reply_text(update.message.text)


def main() -> None:
    token = os.environ["TELEGRAM_BOT_TOKEN"]
    application = Application.builder().token(token).build()

    application.add_handler(CommandHandler("start", start))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

    application.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == "__main__":
    main()

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Echo the user message."""
    chat_id = update.effective_chat.id
    session_id = f"chat_{chat_id}"
    session = SQLiteSession(session_id, "bot.sql")

    await update.message.reply_chat_action(ChatAction.TYPING)

    result = await Runner.run(
        agent,
        update.message.text,
        session=session
    )
    await update.message.reply_text(result.final_output)

await update.message.reply_chat_action(ChatAction.TYPING)

content: prev.at(-1)!.content + decoder.decode(value),
          role: prev.at(-1)!.role,
        }));
      }
    } catch (error) {
      console.error('Streaming error:', error);
    }
  }

  return (
    <div >
      <main >
        <ul>
          {messages.map(msg => (
            <li>{msg.role}: {msg.content}</li>
          ))}
        </ul>
        <form onSubmit={sendMessage}>
          <input type="text" name="message" />
          <input type="submit" value="Send" />
        </form>
      </main>
    </div>
  );
}

const { done, value } = await reader.read();
if (done) break;
setMessages(prev => prev.with(-1, {
  content: prev.at(-1)!.content + decoder.decode(value),
  role: prev.at(-1)!.role,
}));

{ role: 'user', content: 'hello' }

{ role: 'user', content: [
    { type: 'input_text', text: 'hello' }
] }

const messages = await request.json();

const messagesForAgent = messages.map((m: any) => 
  (m.role === 'user' ? user(m.content) : assistant(m.content)))

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

const agent = new Agent({
  name: 'Assistant',
  instructions: 'You are a helpful assistant',
});

export async function POST(request: Request) {
  const messages = await request.json();

  const messagesForAgent = messages.map((m: any) => 
    (m.role === 'user' ? user(m.content) : assistant(m.content)))

  console.log(messagesForAgent);

  const result = await run(agent, messagesForAgent, {
    stream: true,
  });

  // Convert the result to a standard ReadableStream
  const stream = new ReadableStream({
    async start(controller) {
      const encoder = new TextEncoder();
      
      try {
        for await (const event of result) {
          if (event.type === 'raw_model_stream_event') {
            if (event.data.type === "output_text_delta") {
              controller.enqueue(encoder.encode(event.data.delta));
            }                        
          }          
        }
      } catch (error) {
        controller.error(error);
      } finally {
        controller.close();
      }
    },
  });

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/plain; charset=utf-8',
      'Transfer-Encoding': 'chunked',
    },
  });
}