OpenAI Agents SDK + MCP Tools Integration: The Missing Bridge

import requests
import os

TOOLROUTE_KEY = os.environ["TOOLROUTE_KEY"]
BASE = "https://toolroute.ai/api/v1"

# Fetch all MCP tools formatted as OpenAI function definitions
tools = requests.get(f"{BASE}/tools?format=openai").json()

print(f"Loaded {len(tools)} tools as OpenAI function definitions")
# Loaded 87 tools as OpenAI function definitions

# Each tool is already in the right shape:
# { "type": "function", "function": { "name": "...", "parameters": {...} } }
print(tools[0]["function"]["name"])
# e.g. "tavily_search"

# Only fetch security tools
security_tools = requests.get(
    f"{BASE}/tools?format=openai&category=security"
).json()

# Only fetch research and communication tools
research_tools = requests.get(
    f"{BASE}/tools?format=openai&category=research,communication"
).json()

from openai import OpenAI
import json

client = OpenAI()

# Fetch MCP tools in OpenAI format
tools = requests.get(f"{BASE}/tools?format=openai").json()

# Create the initial completion with MCP tools available
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "You are a research assistant with access to web search, "
                       "code scanning, email, DNS management, and 80+ other tools."
        },
        {
            "role": "user",
            "content": "Search for the latest MCP protocol updates and email "
                       "me a summary at team@example.com"
        }
    ],
    tools=tools,
    tool_choice="auto"
)

# The model will generate tool_calls for the tools it wants to use
message = response.choices[0].message
print(f"Model wants to call: {[tc.function.name for tc in message.tool_calls]}")
# Model wants to call: ['tavily_search']

HEADERS = {
    "Authorization": f"Bearer {TOOLROUTE_KEY}",
    "Content-Type": "application/json"
}

def execute_tool_call(tool_call) -> str:
    """Route an OpenAI tool call through the ToolRoute gateway."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    # Every MCP tool executes through the same endpoint
    resp = requests.post(f"{BASE}/execute", headers=HEADERS, json={
        "tool": name,
        "input": args
    })
    resp.raise_for_status()
    return json.dumps(resp.json())

# Execute each tool call the model requested
tool_results = []
for tc in message.tool_calls:
    result = execute_tool_call(tc)
    tool_results.append({
        "role": "tool",
        "tool_call_id": tc.id,
        "content": result
    })

print(f"Executed {len(tool_results)} tool calls through the gateway")

from openai import OpenAI
import requests, json, os

client = OpenAI()
TOOLROUTE_KEY = os.environ["TOOLROUTE_KEY"]
BASE = "https://toolroute.ai/api/v1"
HEADERS = {
    "Authorization": f"Bearer {TOOLROUTE_KEY}",
    "Content-Type": "application/json"
}

def execute_tool_call(tool_call) -> str:
    """Route any tool call through the ToolRoute gateway."""
    resp = requests.post(f"{BASE}/execute", headers=HEADERS, json={
        "tool": tool_call.function.name,
        "input": json.loads(tool_call.function.arguments)
    })
    resp.raise_for_status()
    return json.dumps(resp.json())

def run_agent(user_message: str, max_turns: int = 5) -> str:
    """Run a full agent loop with MCP tools via OpenAI Agents SDK."""

    # 1. Fetch MCP tools as OpenAI function definitions
    tools = requests.get(f"{BASE}/tools?format=openai").json()

    messages = [
        {"role": "system", "content": (
            "You are an assistant with access to web search, code scanning, "
            "email, DNS management, database queries, and 80+ other tools. "
            "Use them to complete the user's request."
        )},
        {"role": "user", "content": user_message}
    ]

    for turn in range(max_turns):
        # 2. Call the model with MCP tools available
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        message = response.choices[0].message
        messages.append(message)

        # 3. If no tool calls, we have our final answer
        if not message.tool_calls:
            return message.content

        # 4. Execute each tool call through the gateway
        for tc in message.tool_calls:
            result = execute_tool_call(tc)
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": result
            })

        print(f"Turn {turn + 1}: executed "
              f"{len(message.tool_calls)} tool calls")

    return messages[-1].content if messages[-1].role == "assistant" \
        else "Max turns reached"

# Run it
answer = run_agent(
    "Search for the latest OpenAI Agents SDK release notes, "
    "then check if toolroute.ai has valid DNS records"
)
print(answer)

# Security auditor — only gets security + code analysis tools
security_agent_tools = requests.get(
    f"{BASE}/tools?format=openai&category=security"
).json()

# Research assistant — search + documentation tools
research_agent_tools = requests.get(
    f"{BASE}/tools?format=openai&category=research,documentation"
).json()

# DevOps agent — infrastructure + monitoring tools
devops_agent_tools = requests.get(
    f"{BASE}/tools?format=openai&category=infrastructure,monitoring"
).json()

# Each agent gets a focused toolset
print(f"Security agent: {len(security_agent_tools)} tools")
print(f"Research agent: {len(research_agent_tools)} tools")
print(f"DevOps agent: {len(devops_agent_tools)} tools")

import time

def execute_tool_call_safe(tool_call, retries: int = 1) -> str:
    """Execute with retry logic and standardized error handling."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    for attempt in range(retries + 1):
        try:
            resp = requests.post(f"{BASE}/execute", headers=HEADERS, json={
                "tool": name,
                "input": args
            })
            resp.raise_for_status()
            return json.dumps(resp.json())

        except requests.HTTPError as e:
            error = e.response.json().get("error", {})

            # Gateway returns uniform error shape across all 47 adapters:
            # { "error": { "code": "rate_limited", "message": "...", "retry_after": 30 } }
            if error.get("code") == "rate_limited" and attempt < retries:
                wait = error.get("retry_after", 10)
                time.sleep(wait)
                continue

            # Return error as tool result — let the model adapt
            return json.dumps({
                "error": True,
                "code": error.get("code", "unknown"),
                "message": error.get("message", str(e))
            })

    return json.dumps({"error": True, "message": "Max retries exceeded"})

// .mcp.json — MCP-native clients connect directly
{
  "toolroute": {
    "type": "http",
    "url": "https://toolroute.ai/mcp",
    "headers": {
      "Authorization": "Bearer tr_live_abc123..."
    }
  }
}