iflow-mcp_lroolle-agents-mcp-server 0.1.0__py3-none-any.whl

agents_mcp_server/__init__.py

@@ -0,0 +1,9 @@
+"""
+OpenAI Agents MCP Server.
+
+This package provides a Model Context Protocol (MCP) server for OpenAI Agents.
+"""
+
+from .__main__ import main
+
+__version__ = "0.1.0"

agents_mcp_server/__main__.py

@@ -0,0 +1,31 @@
+"""
+Main entry point for the agents-mcp-server.
+
+This module provides the main entry point for running the MCP server.
+"""
+
+import os
+import sys
+
+from .server import mcp
+
+
+def main() -> None:
+    """Run the MCP server."""
+    # Check if the OpenAI API key is set
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("Error: OPENAI_API_KEY environment variable is not set.")
+        print("Please set it before running the server.")
+        sys.exit(1)
+
+    # Get the transport from environment variables or use default
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
+    print(f"Starting OpenAI Agents MCP server with {transport} transport")
+
+    # Run the server using the FastMCP's run method
+    mcp.run(transport=transport)
+
+
+if __name__ == "__main__":
+    main()

agents_mcp_server/cli.py

@@ -0,0 +1,148 @@
+"""
+Command-line interface for the agentstool-mcp-server.
+
+This module provides a command-line interface for running and installing the MCP server.
+"""
+
+import getpass
+import json
+import os
+import platform
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import typer
+from openai import OpenAI
+from rich.console import Console
+
+app = typer.Typer(help="OpenAI Agents MCP Server CLI")
+console = Console()
+
+
+def which(cmd: str, path: Optional[str] = None) -> Optional[str]:
+    """Find the path to an executable."""
+    if path is None:
+        path = os.environ.get("PATH", "")
+
+    if platform.system() == "Windows":
+        cmd = cmd + ".exe"
+        paths = path.split(";")
+    else:
+        paths = path.split(":")
+
+    for p in paths:
+        cmd_path = os.path.join(p, cmd)
+        if os.path.isfile(cmd_path) and os.access(cmd_path, os.X_OK):
+            return cmd_path
+
+    return None
+
+
+def update_claude_config(
+    server_name: str, command: str, args: List[str], env_vars: Optional[Dict[str, str]] = None
+) -> bool:
+    """Update the Claude desktop app configuration to include this server."""
+    # Find the Claude config file
+    config_file = None
+    if platform.system() == "Darwin":  # macOS
+        config_file = Path(
+            Path.home(), "Library", "Application Support", "Claude", "servers_config.json"
+        )
+    elif platform.system() == "Windows":
+        config_file = Path(Path.home(), "AppData", "Roaming", "Claude", "servers_config.json")
+    elif platform.system() == "Linux":
+        config_file = Path(Path.home(), ".config", "Claude", "servers_config.json")
+
+    if not config_file:
+        console.print("[bold red]Error:[/] Could not determine Claude config file location.")
+        return False
+
+    # Create the config file if it doesn't exist
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    if not config_file.exists():
+        config_file.write_text("{}")
+
+    try:
+        config = json.loads(config_file.read_text())
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        # Always preserve existing env vars and merge with new ones
+        if server_name in config["mcpServers"] and "env" in config["mcpServers"][server_name]:
+            existing_env = config["mcpServers"][server_name]["env"]
+            if env_vars:
+                # New vars take precedence over existing ones
+                env_vars = {**existing_env, **env_vars}
+            else:
+                env_vars = existing_env
+
+        server_config = {"command": command, "args": args}
+
+        # Add environment variables if specified
+        if env_vars:
+            server_config["env"] = env_vars
+
+        config["mcpServers"][server_name] = server_config
+
+        config_file.write_text(json.dumps(config, indent=2))
+        console.print(f"[bold green]Success:[/] Added server '{server_name}' to Claude config")
+        return True
+    except Exception as e:
+        console.print(f"[bold red]Error:[/] Failed to update Claude config: {str(e)}")
+        return False
+
+
+@app.command()
+def run() -> None:
+    """Run the OpenAI Agents Tool MCP server."""
+    from . import main
+
+    main()
+
+
+@app.command()
+def install() -> None:
+    """Install the server in the Claude desktop app."""
+    name = "openai-agents-mcp"
+
+    env_dict = {}
+    local_bin = Path(Path.home(), ".local", "bin")
+    pyenv_shims = Path(Path.home(), ".pyenv", "shims")
+    path = os.environ["PATH"]
+    python_version = platform.python_version()
+    python_bin = Path(Path.home(), "Library", "Python", python_version, "bin")
+
+    if platform.system() == "Windows":
+        env_dict["PATH"] = f"{local_bin};{pyenv_shims};{python_bin};{path}"
+    else:
+        env_dict["PATH"] = f"{local_bin}:{pyenv_shims}:{python_bin}:{path}"
+
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    while not api_key:
+        api_key = getpass.getpass("Enter your OpenAI API key: ")
+        if api_key:
+            client = OpenAI(api_key=api_key)
+            try:
+                client.models.list()
+            except Exception as e:
+                console.print(
+                    f"[bold red]Error:[/] Failed to authenticate with OpenAI API: {str(e)}"
+                )
+                api_key = ""
+
+    env_dict["OPENAI_API_KEY"] = api_key
+
+    uv = which("uvx", path=env_dict["PATH"])
+    command = uv if uv else "uvx"
+    args = [name]
+
+    if update_claude_config(name, command, args, env_vars=env_dict):
+        console.print(f"[bold green]Success:[/] Successfully installed {name} in Claude app")
+    else:
+        console.print(f"[bold red]Error:[/] Failed to install {name} in Claude app")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    app()

agents_mcp_server/server.py

@@ -0,0 +1,389 @@
+"""
+MCP server for OpenAI agents tools.
+
+This module provides a FastMCP server that exposes OpenAI agents through the Model Context Protocol.
+"""
+
+import asyncio
+import base64
+from typing import Any, Dict, List, Literal, Optional
+
+from agents import Agent, AsyncComputer, ComputerTool, FileSearchTool, Runner, WebSearchTool, trace
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field
+
+
+class SimpleAsyncComputer(AsyncComputer):
+    """
+    A simple implementation of the AsyncComputer interface that simulates computer actions.
+
+    In a real implementation, you would use a browser automation library like Playwright
+    or a system automation tool to actually perform these actions on the computer.
+    """
+
+    def __init__(self):
+        """Initialize the SimpleAsyncComputer."""
+        self._screen_width = 1024
+        self._screen_height = 768
+        self._cursor_x = 0
+        self._cursor_y = 0
+        self._current_page = "https://bing.com"
+
+    @property
+    def environment(self) -> Literal["browser", "desktop"]:
+        """Return the environment type of this computer."""
+        return "browser"
+
+    @property
+    def dimensions(self) -> tuple[int, int]:
+        """Return the dimensions of the screen."""
+        return (self._screen_width, self._screen_height)
+
+    async def screenshot(self) -> str:
+        """
+        Capture a screenshot and return it as a base64-encoded string.
+
+        In a real implementation, this would capture an actual screenshot.
+        """
+        placeholder_png = base64.b64decode(
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
+        )
+        return base64.b64encode(placeholder_png).decode("utf-8")
+
+    async def click(
+        self, x: int, y: int, button: Literal["left", "middle", "right"] = "left"
+    ) -> None:
+        """Simulate clicking at the specified coordinates."""
+        self._cursor_x = x
+        self._cursor_y = y
+        print(f"Simulated {button} click at ({x}, {y})")
+
+    async def double_click(self, x: int, y: int) -> None:
+        """Simulate double-clicking at the specified coordinates."""
+        self._cursor_x = x
+        self._cursor_y = y
+        print(f"Simulated double click at ({x}, {y})")
+
+    async def scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
+        """Simulate scrolling from the specified position."""
+        self._cursor_x = x
+        self._cursor_y = y
+        print(f"Simulated scroll at ({x}, {y}) by ({scroll_x}, {scroll_y})")
+
+    async def type(self, text: str) -> None:
+        """Simulate typing the specified text."""
+        print(f"Simulated typing: {text}")
+
+    async def wait(self) -> None:
+        """Simulate waiting for a short period."""
+        await asyncio.sleep(1)
+        print("Waited for 1 second")
+
+    async def move(self, x: int, y: int) -> None:
+        """Simulate moving the cursor to the specified coordinates."""
+        self._cursor_x = x
+        self._cursor_y = y
+        print(f"Moved cursor to ({x}, {y})")
+
+    async def keypress(self, keys: list[str]) -> None:
+        """Simulate pressing the specified keys."""
+        print(f"Simulated keypress: {', '.join(keys)}")
+
+    async def drag(self, path: list[tuple[int, int]]) -> None:
+        """Simulate dragging the cursor along the specified path."""
+        if not path:
+            return
+
+        self._cursor_x = path[0][0]
+        self._cursor_y = path[0][1]
+        print(f"Started drag at ({self._cursor_x}, {self._cursor_y})")
+
+        for x, y in path[1:]:
+            self._cursor_x = x
+            self._cursor_y = y
+
+        print(f"Ended drag at ({self._cursor_x}, {self._cursor_y})")
+
+    async def run_command(self, command: str) -> str:
+        """
+        Simulate running a command and return the output.
+
+        In a real implementation, this could execute shell commands
+        or perform actions based on high-level instructions.
+        """
+        print(f"Simulating command: {command}")
+
+        if command.startswith("open "):
+            app = command[5:].strip()
+            return f"Opened {app}"
+        elif command.startswith("search "):
+            query = command[7:].strip()
+            self._current_page = f"https://bing.com/search?q={query}"
+            return f"Searched for '{query}'"
+        elif command.startswith("navigate "):
+            url = command[9:].strip()
+            self._current_page = url
+            return f"Navigated to {url}"
+        else:
+            return f"Executed: {command}"
+
+    async def get_screenshot(self) -> bytes:
+        """Get a screenshot of the current screen as raw bytes."""
+        return base64.b64decode(
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
+        )
+
+
+mcp = FastMCP(
+    name="OpenAI Agents",
+    instructions="This MCP server provides access to OpenAI agents through the Model Context Protocol.",
+)
+
+
+class AgentResponse(BaseModel):
+    """Response from an OpenAI agent."""
+
+    response: str = Field(..., description="The response from the agent")
+    raw_response: Optional[Dict[str, Any]] = Field(
+        None, description="The raw response data from the agent, if available"
+    )
+
+
+web_search_agent = Agent(
+    name="Web Search Assistant",
+    instructions="""You are a web search assistant. Your primary goal is to search the web for accurate,
+    up-to-date information based on the user's query.
+
+    Guidelines:
+    1. Always use the web search tool to find information
+    2. Cite your sources when providing information
+    3. If information seems outdated or contradictory, acknowledge this
+    4. Summarize information in a clear, concise manner
+    5. For complex topics, break down information into digestible parts
+    """,
+    tools=[WebSearchTool()],
+)
+
+file_search_instructions = """You are a file search assistant. Your primary goal is to search through files and documents
+to find relevant information based on the user's query.
+
+Guidelines:
+1. Always use the file search tool to find documents
+2. Quote relevant sections from documents when appropriate
+3. Summarize document content clearly
+4. If multiple documents are found, compare and contrast their information
+5. If no relevant documents are found, clearly state this
+"""
+
+computer_action_instructions = """You are a computer action assistant. Your primary goal is to help users perform
+actions on their computer safely and effectively.
+
+Guidelines:
+1. Always use the computer tool to perform actions
+2. Prioritize safety and security in all actions
+3. Verify user intentions before performing potentially destructive actions
+4. Provide clear feedback about actions taken
+5. If an action cannot be performed, explain why and suggest alternatives
+"""
+
+
+@mcp.tool(
+    name="web_search_agent",
+    description="Use an AI agent specialized in web searching to find accurate, up-to-date information from the internet.",
+)
+async def web_search(
+    query: str = Field(
+        ..., description="The search query or question you want to find information about online."
+    ),
+    location: Optional[str] = Field(
+        None,
+        description="Optional location context for location-specific searches (e.g., 'New York').",
+    ),
+) -> AgentResponse:
+    """Use a specialized web search agent powered by OpenAI to find information on the internet."""
+    try:
+        agent = web_search_agent
+        if location:
+            agent = Agent(
+                name="Web Search Assistant",
+                instructions=web_search_agent.instructions,
+                tools=[WebSearchTool(user_location={"type": "approximate", "city": location})],
+            )
+
+        with trace("Web search agent execution"):
+            result = await Runner.run(agent, query)
+
+        return AgentResponse(
+            response=result.final_output,
+            raw_response={"items": [str(item) for item in result.new_items]},
+        )
+
+    except Exception as e:
+        print(f"Error running web search agent: {e}")
+        return AgentResponse(
+            response=f"An error occurred while searching the web: {str(e)}", raw_response=None
+        )
+
+
+@mcp.tool(
+    name="file_search_agent",
+    description="Use an AI agent specialized in searching through files and documents to find relevant information.",
+)
+async def file_search(
+    query: str = Field(..., description="The search query or question to find in the documents."),
+    vector_store_ids: List[str] = Field(
+        ...,
+        description="The IDs of the vector stores to search in. This is required for file search to work.",
+    ),
+    max_results: int = Field(5, description="The maximum number of document results to return."),
+) -> AgentResponse:
+    """Use a specialized file search agent powered by OpenAI to find information in documents."""
+    try:
+        agent = Agent(
+            name="File Search Assistant",
+            instructions=file_search_instructions,
+            tools=[FileSearchTool(max_num_results=max_results, vector_store_ids=vector_store_ids)],
+        )
+
+        with trace("File search agent execution"):
+            result = await Runner.run(agent, query)
+
+        return AgentResponse(
+            response=result.final_output,
+            raw_response={"items": [str(item) for item in result.new_items]},
+        )
+
+    except Exception as e:
+        print(f"Error running file search agent: {e}")
+        return AgentResponse(
+            response=f"An error occurred while searching files: {str(e)}", raw_response=None
+        )
+
+
+@mcp.tool(
+    name="computer_action_agent",
+    description="Use an AI agent specialized in performing computer actions safely and effectively.",
+)
+async def computer_action(
+    action: str = Field(..., description="The action or task you want to perform on the computer.")
+) -> AgentResponse:
+    """Use a specialized computer action agent powered by OpenAI to perform actions on the computer."""
+    try:
+        computer = SimpleAsyncComputer()
+
+        agent = Agent(
+            name="Computer Action Assistant",
+            instructions=computer_action_instructions,
+            tools=[ComputerTool(computer=computer)],
+        )
+
+        with trace("Computer action agent execution"):
+            result = await Runner.run(agent, action)
+
+        return AgentResponse(
+            response=result.final_output,
+            raw_response={"items": [str(item) for item in result.new_items]},
+        )
+
+    except Exception as e:
+        print(f"Error running computer action agent: {e}")
+        return AgentResponse(
+            response=f"An error occurred while performing the computer action: {str(e)}",
+            raw_response=None,
+        )
+
+
+@mcp.tool(
+    name="multi_tool_agent",
+    description="Use an AI agent that can orchestrate between web search, file search, and computer actions based on your query.",
+)
+async def orchestrator_agent(
+    query: str = Field(..., description="The query or task you want help with."),
+    enable_web_search: bool = Field(True, description="Whether to enable web search capabilities."),
+    enable_file_search: bool = Field(
+        False, description="Whether to enable file search capabilities."
+    ),
+    enable_computer_actions: bool = Field(
+        True, description="Whether to enable computer action capabilities."
+    ),
+    vector_store_ids: Optional[List[str]] = Field(
+        None,
+        description="Required if enable_file_search is True. The IDs of the vector stores to search in.",
+    ),
+) -> AgentResponse:
+    """Use a specialized orchestrator agent that can delegate to the most appropriate specialized agent."""
+    try:
+        tools = []
+
+        if enable_web_search:
+            tools.append(
+                web_search_agent.as_tool(
+                    tool_name="search_web", tool_description="Search the web for information"
+                )
+            )
+
+        if enable_file_search:
+            if not vector_store_ids:
+                return AgentResponse(
+                    response="Error: vector_store_ids is required when file search is enabled.",
+                    raw_response=None,
+                )
+
+            file_search_agent = Agent(
+                name="File Search Assistant",
+                instructions=file_search_instructions,
+                tools=[FileSearchTool(max_num_results=5, vector_store_ids=vector_store_ids)],
+            )
+
+            tools.append(
+                file_search_agent.as_tool(
+                    tool_name="search_files",
+                    tool_description="Search for information in files and documents",
+                )
+            )
+
+        if enable_computer_actions:
+            computer = SimpleAsyncComputer()
+
+            computer_action_agent = Agent(
+                name="Computer Action Assistant",
+                instructions=computer_action_instructions,
+                tools=[ComputerTool(computer=computer)],
+            )
+
+            tools.append(
+                computer_action_agent.as_tool(
+                    tool_name="perform_computer_action",
+                    tool_description="Perform an action on the computer",
+                )
+            )
+
+        orchestrator = Agent(
+            name="Multi-Tool Orchestrator",
+            instructions="""You are an intelligent orchestrator with access to specialized agents.
+            Based on the user's query, determine which specialized agent(s) can best help and
+            delegate the task to them.
+
+            Guidelines:
+            1. For queries about current events or facts, use the web search agent
+            2. For queries about documents or specific files, use the file search agent
+            3. For requests to perform actions on the computer, use the computer action agent
+            4. For complex requests, you can use multiple agents in sequence
+            5. Always explain your reasoning and which agent(s) you're using
+            """,
+            tools=tools,
+        )
+
+        with trace("Orchestrator agent execution"):
+            result = await Runner.run(orchestrator, query)
+
+        return AgentResponse(
+            response=result.final_output,
+            raw_response={"items": [str(item) for item in result.new_items]},
+        )
+
+    except Exception as e:
+        print(f"Error running orchestrator agent: {e}")
+        return AgentResponse(
+            response=f"An error occurred while processing your request: {str(e)}", raw_response=None
+        )

iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_lroolle-agents-mcp-server
+Version: 0.1.0
+Summary: MCP server for OpenAI agents and agents tools.
+Author-email: Eric Wang <wrqatw@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: mcp
+Requires-Dist: openai
+Requires-Dist: openai-agents
+Requires-Dist: pydantic
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: typer
+Requires-Dist: uvicorn
+Description-Content-Type: text/markdown
+
+# OpenAI Agents MCP Server
+[![smithery badge](https://smithery.ai/badge/@lroolle/openai-agents-mcp-server)](https://smithery.ai/server/@lroolle/openai-agents-mcp-server)
+
+A Model Context Protocol (MCP) server that exposes OpenAI agents through the MCP protocol.
+
+## Features
+
+This server exposes both individual agents and a multi-agent orchestrator using the OpenAI Agents SDK:
+
+### Individual Specialized Agents
+
+- **Web Search Agent**: A specialized agent for searching the web for real-time information
+- **File Search Agent**: A specialized agent for searching and analyzing files in OpenAI's vector store
+- **Computer Action Agent**: A specialized agent for performing actions on your computer safely
+
+### Multi-Agent Orchestrator
+
+- **Orchestrator Agent**: A powerful agent that can coordinate between the specialized agents, choosing the right one(s) for each task
+
+Each agent is accessed through the MCP protocol, making them available to any MCP client, including the Claude desktop app.
+
+## Installation
+
+### Prerequisites
+
+- Python 3.11 or higher
+- [uv](https://github.com/astral-sh/uv) package manager (recommended)
+- OpenAI API key
+
+
+### Installing via Smithery
+
+To install openai-agents-mcp-server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@lroolle/openai-agents-mcp-server):
+
+```bash
+npx -y @smithery/cli install @lroolle/openai-agents-mcp-server --client claude
+```
+
+### Claude Desktop
+
+```
+"mcpServers": {
+  "openai-agents-mcp-server": {
+    "command": "uvx",
+    "args": ["openai-agents-mcp-server"],
+    "env": {
+        "OPENAI_API_KEY": "your-api-key-here"
+    }
+  }
+}
+
+```
+
+
+## Implementation Details
+
+### Tool Requirements
+
+- **WebSearchTool**: No required parameters, but can accept optional location context
+- **FileSearchTool**: Requires vector_store_ids (IDs from your OpenAI vector stores)
+- **ComputerTool**: Requires an AsyncComputer implementation (currently simulated)
+
+### Customization
+
+You can customize this server by:
+
+1. Implementing a full AsyncComputer interface to enable real computer interactions
+2. Adding additional specialized agents for other OpenAI tools
+3. Enhancing the orchestrator agent to handle more complex workflows
+
+## Configuration
+
+You can configure the server using environment variables:
+
+- `OPENAI_API_KEY`: Your OpenAI API key (required)
+- `MCP_TRANSPORT`: Transport protocol to use (default: "stdio", can be "sse")
+
+## Development
+
+### Setup development environment
+
+```bash
+# Clone the repository
+git clone https://github.com/lroolle/openai-agents-mcp-server.git
+cd openai-agents-mcp-server
+
+# Create a virtual environment
+uv venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install dependencies
+uv sync --dev
+```
+
+### Testing with MCP Inspector
+
+You can test the server using the MCP Inspector:
+
+```bash
+# In one terminal, run the server with SSE transport
+export OPENAI_API_KEY=your-api-key
+export MCP_TRANSPORT=sse
+
+uv run mcp dev src/agents_mcp_server/server.py
+```
+
+Then open a web browser and navigate to http://localhost:5173.
+
+## License
+
+MIT

iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+agents_mcp_server/__init__.py,sha256=fxxEeKaLlkvWLFrVEKGw6MAlTOJQjw4DdQpJFHXt9tM,165
+agents_mcp_server/__main__.py,sha256=OcRp9ey2fSsVoXgkGYqBj_CFhfstJI3kfI6L1zoFf0k,784
+agents_mcp_server/cli.py,sha256=lH-ER6sZ-V9dtsm11rTdmTFxVnwsX76ZWYUBGHZrpsk,4715
+agents_mcp_server/server.py,sha256=cpbtiDCDpOnx-6k3LilHcZpcWu-C0_v5G-bPrGHT_z4,14503
+iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/METADATA,sha256=V_PXmoAdNhSqK6tLGPl3_juQ0mOyC0NwPpVejqQq3kg,3498
+iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=u8TGPJRsmT0z9CL3PCxEYCcjEvFtLET9gOqxZ5jifWg,122
+iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/RECORD,,

iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_lroolle_agents_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+openai-agents-mcp-install = agents_mcp_server.cli:app
+openai-agents-mcp-server = agents_mcp_server:main