browser

Instructions

Implementation Reference

• openai_tool2mcp/tools/browser.py:6-68 (handler)

  BrowserAdapter implements the core logic for the 'browser' tool: defines tool_id 'browser', maps to OpenAI 'web_browser', translates MCP requests (url, action) to OpenAI params and responses back to MCP format with markdown.

  class BrowserAdapter(ToolAdapter):
      """Adapter for OpenAI's web browser tool"""
  
      @property
      def tool_id(self) -> str:
          """Get the MCP tool ID"""
          return "browser"
  
      @property
      def openai_tool_type(self) -> str:
          """Get the OpenAI tool type"""
          return "web_browser"
  
      @property
      def description(self) -> str:
          """Get the tool description"""
          return "Browse websites and interact with web content"
  
      async def translate_request(self, request: MCPRequest) -> dict:
          """
          Translate MCP request to OpenAI parameters
  
          Args:
              request: The MCP request to translate
  
          Returns:
              Dictionary of OpenAI parameters
          """
          # Extract URL and action
          url = request.parameters.get("url", "")
          action = request.parameters.get("action", "browse")
  
          logger.debug(f"Translating browser request for URL: {url}, action: {action}")
  
          # Return OpenAI parameters
          return {"url": url, "action": action}
  
      async def translate_response(self, response: dict) -> MCPResponse:
          """
          Translate OpenAI response to MCP response
  
          Args:
              response: The OpenAI response to translate
  
          Returns:
              MCP response object
          """
          # Extract content
          content = response.get("content", "")
          title = response.get("title", "")
          url = response.get("url", "")
  
          logger.debug(f"Translating browser response for URL: {url}")
  
          # Format content as markdown
          formatted_content = f"# {title}\n\n{content}" if title else content
  
          # Check for errors
          error = response.get("error")
  
          # Return MCP response
          return MCPResponse(content=formatted_content, error=error, context={"url": url, "title": title})

• openai_tool2mcp/tools/registry.py:48-52 (registration)

  ToolRegistry._register_default_tools() registers 'browser' tool with mapping to OpenAI WEB_BROWSER, enabled status, and description.

  "browser": {
      "openai_tool": OpenAIBuiltInTools.WEB_BROWSER.value,
      "enabled": OpenAIBuiltInTools.WEB_BROWSER.value in self.enabled_tools,
      "description": "Browse websites and access web content",
  },

• openai_tool2mcp/server.py:53-59 (registration)

  MCPServer._build_tools_map() instantiates BrowserAdapter and adds it to self.tools_map[adapter.tool_id] ('browser') if enabled in config.

  adapters = [WebSearchAdapter(), CodeInterpreterAdapter(), BrowserAdapter(), FileManagerAdapter()]
  
  for adapter in adapters:
      # Only register if the tool is enabled
      if adapter.openai_tool_type in self.config.tools:
          tools_map[adapter.tool_id] = adapter

• openai_tool2mcp/server.py:67-113 (registration)

  MCPServer._register_mcp_tools() dynamically creates and registers the MCP tool handler for each adapter (including 'browser'), using @mcp.tool(name=tool_id), which invokes OpenAI via the adapter's translate methods.

  def create_tool_handler(tool_id=tool_id, adapter=adapter):
      @self.mcp.tool(name=tool_id, description=adapter.description)
      async def tool_handler(**parameters):
          """
          MCP tool handler for OpenAI tools.
          """
          # Create an MCP request from the parameters
          mcp_request = MCPRequest(parameters=parameters)
  
          # Translate the request parameters using the adapter
          translated_params = await adapter.translate_request(mcp_request)
  
          # Create an OpenAI tool request
          openai_request = mcp_to_openai.translate_request(mcp_request, tool_id)
  
          # Override the parameters with the adapter-specific ones
          openai_request.parameters = translated_params
  
          try:
              # Call OpenAI API to execute the tool
              openai_response = await self.openai_client.invoke_tool(openai_request)
  
              # Translate the OpenAI response to MCP format using the adapter
              if openai_response.tool_outputs:
                  # Use the adapter to translate the tool-specific response
                  mcp_response = await adapter.translate_response(openai_response.tool_outputs[0].output)
  
                  # Add thread_id to context for state management
                  if mcp_response.context is None:
                      mcp_response.context = {}
                  mcp_response.context["thread_id"] = openai_response.thread_id
  
                  # Return the response content which will be used by MCP SDK
                  return mcp_response.content
              else:
                  # Fallback to generic translation
                  mcp_response = openai_to_mcp.translate_response(openai_response)
                  return mcp_response.content
          except Exception as e:
              logger.error(f"Error invoking tool {tool_id}: {e!s}")
              # Using custom exception class to fix TRY003
              raise ToolInvocationError() from e
  
      return tool_handler
  
  # Create and register the tool handler
  create_tool_handler()

• openai_tool2mcp/tools/registry.py:16-17 (helper)

  Constants defining tool names: BROWSER='browser' and WEB_BROWSER='web_browser' used in registry.

  BROWSER = "browser"
  CODE = "code"