universal-mcp 0.1.1rc1__tar.gz → 0.1.2__tar.gz

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.1rc1
+Version: 0.1.2
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 Requires-Python: >=3.11
@@ -27,6 +27,7 @@ Provides-Extra: playground
 Requires-Dist: fastapi[standard]>=0.115.12; extra == 'playground'
 Requires-Dist: langchain-anthropic>=0.3.10; extra == 'playground'
 Requires-Dist: langchain-mcp-adapters>=0.0.3; extra == 'playground'
+Requires-Dist: langchain-openai>=0.3.12; extra == 'playground'
 Requires-Dist: langgraph-checkpoint-sqlite>=2.0.6; extra == 'playground'
 Requires-Dist: langgraph>=0.3.24; extra == 'playground'
 Requires-Dist: python-dotenv>=1.0.1; extra == 'playground'

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "universal-mcp"
-version = "0.1.1rc1"
+version = "0.1.2"
 description = "Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more."
 readme = "README.md"
 authors = [
@@ -28,6 +28,7 @@ playground = [
     "langgraph-checkpoint-sqlite>=2.0.6",
     "streamlit>=1.44.1",
     "python-dotenv>=1.0.1",
+    "langchain-openai>=0.3.12",
 ]
 dev = [
     "ruff>=0.11.4",

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/src/playground/agents/react.py

@@ -1,9 +1,9 @@
 import asyncio
 from contextlib import asynccontextmanager
 
-from langchain_anthropic import ChatAnthropic
 from langchain_core.messages import HumanMessage
 from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_openai import ChatOpenAI
 from langgraph.prebuilt import create_react_agent
 
 
@@ -23,7 +23,7 @@ async def load_tools():
 
 @asynccontextmanager
 async def create_agent():
-    llm = ChatAnthropic(model="claude-3-5-sonnet-latest")
+    llm = ChatOpenAI(model="gpt-4o")
     async with load_tools() as tools:
         yield create_react_agent(
             model=llm,

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/src/tests/test_applications.py

@@ -20,6 +20,7 @@ from universal_mcp.applications import app_from_slug
         "e2b",
         "firecrawl",
         "serp",
+        "notion",
     ],
 )
 def test_application(app_name):

universal_mcp-0.1.2/src/universal_mcp/applications/notion/README.md

@@ -0,0 +1,32 @@
+# Notion Tool
+
+This is automatically generated from OpenAPI schema for the Notion API.
+
+## Supported Integrations
+
+This tool can be integrated with any service that supports HTTP requests.
+
+## Tool List
+
+| Tool | Description |
+|------|-------------|
+| notion_retrieve_auser | Retrieves user information from the Notion API by user ID. |
+| notion_list_all_users | Fetches and returns a list of all users from the Notion API. |
+| notion_retrieve_your_token_sbot_user | Retrieves the current user's token data from the Notion API. |
+| notion_retrieve_adatabase | Retrieves a Notion database by its unique identifier. |
+| notion_update_adatabase | Updates a Notion database with the given ID and request body data. |
+| notion_query_adatabase | Executes a query on a Notion database using the Notion API. |
+| notion_create_adatabase | Creates a new database in Notion using the provided request body. |
+| notion_create_apage | Creates a new page in Notion by sending a POST request with the specified request body. |
+| notion_retrieve_apage | Retrieves a page from the Notion API using a given page ID. |
+| notion_update_page_properties | Updates the properties of a Notion page identified by a given ID. |
+| notion_retrieve_apage_property_item | Retrieves a specific property item from a page in Notion using the page and property IDs. |
+| notion_retrieve_block_children | Retrieves the child blocks of a specified Notion block. |
+| notion_append_block_children | Appends child blocks to a block in Notion using its API. |
+| notion_retrieve_ablock | Retrieves a block from the Notion API using the specified block ID. |
+| notion_delete_ablock | Deletes a block from the Notion database using the specified block ID. |
+| notion_update_ablock | Updates a block in Notion with the given ID and request body. |
+| notion_search | Executes a search request to the Notion API and returns the response in JSON format. |
+| notion_retrieve_comments | Retrieves comments from a Notion block using the Notion API. |
+| notion_add_comment_to_page | Adds a comment to a specified Notion page using the provided request body. |
+

universal_mcp-0.1.2/src/universal_mcp/applications/notion/app.py

@@ -0,0 +1,415 @@
+from typing import Any
+
+from universal_mcp.applications import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class NotionApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        """
+        Initializes a new instance of the class with given integration and additional options.
+        
+        Args:
+            integration: An optional Integration instance to configure the connection. Defaults to None.
+            **kwargs: Additional keyword arguments for configuration.
+        
+        Returns:
+            None
+        """
+        super().__init__(name='notion', integration=integration, **kwargs)
+        self.base_url = "https://api.notion.com"
+
+    def _get_headers(self):
+        if not self.integration:
+            raise ValueError("Integration not configured for NotionApp")
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json",
+            "Notion-Version": "2022-06-28",
+        }    
+
+    def notion_retrieve_auser(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Retrieves user information from the Notion API by user ID.
+        
+        Args:
+            id: The unique identifier of the user whose information is to be retrieved.
+            request_body: A dictionary representing the request body, optional, default is None.
+        
+        Returns:
+            A dictionary containing the user's information from the Notion API.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/users/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_list_all_users(self, ) -> dict[str, Any]:
+        """
+        Fetches and returns a list of all users from the Notion API.
+        
+        Args:
+            None: This method does not take any parameters.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API, representing all users data.
+        """
+        url = f"{self.base_url}/v1/users"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_your_token_sbot_user(self, ) -> dict[str, Any]:
+        """
+        Retrieves the current user's token data from the Notion API.
+        
+        Args:
+            self: Instance of the class containing the necessary configuration and authentication details for accessing the Notion API.
+        
+        Returns:
+            A dictionary containing the current user's token information as retrieved from the Notion API.
+        """
+        url = f"{self.base_url}/v1/users/me"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_adatabase(self, id) -> dict[str, Any]:
+        """
+        Retrieves a Notion database by its unique identifier.
+        
+        Args:
+            id: A string representing the unique identifier of the Notion database to be retrieved.
+        
+        Returns:
+            A dictionary containing the details of the retrieved Notion database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_adatabase(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a Notion database with the given ID and request body data.
+        
+        Args:
+            self: An instance of the class containing configuration and methods for HTTP requests.
+            id: A string representing the unique identifier of the Notion database to be updated.
+            request_body: An optional dictionary containing the fields and values to update in the database.
+        
+        Returns:
+            A dictionary representing the JSON response from the Notion API after updating the database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_query_adatabase(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Executes a query on a Notion database using the Notion API.
+        
+        Args:
+            self: Instance of the class which should contain 'base_url' and '_post' method.
+            id: A string representing the unique identifier of the Notion database to query.
+            request_body: Optional. A dictionary representing the request body for the query. Defaults to None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after querying the specified database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}/query"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_create_adatabase(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new database in Notion using the provided request body.
+        
+        Args:
+            self: Reference to the current instance of the class.
+            request_body: Optional dictionary containing the specifications for creating the Notion database. If None, a default empty request body is used.
+        
+        Returns:
+            A dictionary representing the JSON response from the Notion API, containing data about the newly created database.
+        """
+        url = f"{self.base_url}/v1/databases/"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_create_apage(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new page in Notion by sending a POST request with the specified request body.
+        
+        Args:
+            request_body: Optional; A dictionary containing the data to create a new page in Notion. Defaults to None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API with the details of the newly created page.
+        """
+        url = f"{self.base_url}/v1/pages/"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_apage(self, id) -> dict[str, Any]:
+        """
+        Retrieves a page from the Notion API using a given page ID.
+        
+        Args:
+            id: The unique identifier of the Notion page to be retrieved.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API, representing the page data.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_page_properties(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates the properties of a Notion page identified by a given ID.
+        
+        Args:
+            self: Instance of the class containing the Notion API credentials and methods.
+            id: The unique identifier of the Notion page to update. Must not be None.
+            request_body: An optional dictionary representing the request body to be sent with the update request. Defaults to None, indicating no additional properties to update.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after the page update request.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_apage_property_item(self, page_id, property_id) -> dict[str, Any]:
+        """
+        Retrieves a specific property item from a page in Notion using the page and property IDs.
+        
+        Args:
+            page_id: The unique identifier for the Notion page from which the property item should be retrieved.
+            property_id: The unique identifier for the property item within the specified page that should be retrieved.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API representing the requested property item.
+        """
+        if page_id is None:
+            raise ValueError("Missing required parameter 'page_id'")
+        if property_id is None:
+            raise ValueError("Missing required parameter 'property_id'")
+        url = f"{self.base_url}/v1/pages/{page_id}/properties/{property_id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
+        """
+        Retrieves the child blocks of a specified Notion block.
+        
+        Args:
+            self: The instance of the class this method belongs to.
+            id: The unique identifier of the parent block whose children are to be retrieved.
+            page_size: Optional; the number of child blocks to retrieve per request.
+        
+        Returns:
+            A dictionary containing the JSON response with details about the child blocks.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {k: v for k, v in [('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_append_block_children(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Appends child blocks to a block in Notion using its API.
+        
+        Args:
+            self: Instance of the class containing Notion API credentials and configuration.
+            id: The unique identifier of the parent block to which child blocks are to be appended.
+            request_body: An optional dictionary containing the block data to append. Defaults to None.
+        
+        Returns:
+            A dictionary representing the response from the Notion API, containing the result of the append operation.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_ablock(self, id) -> dict[str, Any]:
+        """
+        Retrieves a block from the Notion API using the specified block ID.
+        
+        Args:
+            id: The unique identifier of the block to retrieve from the Notion API. Must be a non-null string.
+        
+        Returns:
+            A dictionary containing the block data in JSON format as retrieved from the Notion API.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_delete_ablock(self, id) -> dict[str, Any]:
+        """
+        Deletes a block from the Notion database using the specified block ID.
+        
+        Args:
+            id: The unique identifier of the block to be deleted. Must not be None.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after attempting to delete the block.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._delete(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_update_ablock(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a block in Notion with the given ID and request body.
+        
+        Args:
+            id: The unique identifier of the Notion block to update.
+            request_body: The request body containing the updates to be made to the block. Defaults to None if not provided.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API after the block has been updated.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._patch(url, data={}, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_search(self, request_body=None) -> dict[str, Any]:
+        """
+        Executes a search request to the Notion API and returns the response in JSON format.
+        
+        Args:
+            request_body: An optional dictionary containing the search parameters for the API request. Defaults to None if not provided.
+        
+        Returns:
+            A dictionary containing the response from the Notion API in JSON format.
+        """
+        url = f"{self.base_url}/v1/search"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
+        """
+        Retrieves comments from a Notion block using the Notion API.
+        
+        Args:
+            block_id: Optional; The ID of the block for which to retrieve comments. If None, it retrieves comments for all blocks available to the user.
+            page_size: Optional; The maximum number of comments to retrieve in one request. If None, the default page size will be used.
+            request_body: Optional; A dictionary to include additional parameters in the request body. If None, no extra parameters are added.
+        
+        Returns:
+            A dictionary containing the JSON response from the Notion API with the comments retrieved.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {k: v for k, v in [('block_id', block_id), ('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def notion_add_comment_to_page(self, request_body=None) -> dict[str, Any]:
+        """
+        Adds a comment to a specified Notion page using the provided request body.
+        
+        Args:
+            request_body: An optional dictionary containing the details of the comment to be added to the Notion page. If None, no data is sent in the request's body.
+        
+        Returns:
+            A dictionary containing the response data from the Notion API, parsed from JSON format.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {}
+        json_body = request_body if request_body is not None else None
+        response = self._post(url, data=json_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def list_tools(self):
+        """
+        Returns a list of functions that interact with Notion's API for various operations.
+        
+        Args:
+            None: This method does not take any parameters.
+        
+        Returns:
+            A list of functions that perform specific operations with Notion's API, such as retrieving or updating users, databases, pages, blocks, and comments.
+        """
+        return [
+            self.notion_retrieve_auser,
+            self.notion_list_all_users,
+            self.notion_retrieve_your_token_sbot_user,
+            self.notion_retrieve_adatabase,
+            self.notion_update_adatabase,
+            self.notion_query_adatabase,
+            self.notion_create_adatabase,
+            self.notion_create_apage,
+            self.notion_retrieve_apage,
+            self.notion_update_page_properties,
+            self.notion_retrieve_apage_property_item,
+            self.notion_retrieve_block_children,
+            self.notion_append_block_children,
+            self.notion_retrieve_ablock,
+            self.notion_delete_ablock,
+            self.notion_update_ablock,
+            self.notion_search,
+            self.notion_retrieve_comments,
+            self.notion_add_comment_to_page
+        ]

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/src/universal_mcp/cli.py

@@ -66,7 +66,7 @@ def generate(
 def docgen(
     file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
     model: str = typer.Option(
-        "anthropic/claude-3-sonnet-20240229",
+        "anthropic/claude-3-5-sonnet-20241022",
         "--model",
         "-m",
         help="Model to use for generating docstrings",

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/src/universal_mcp/utils/openapi.py

@@ -177,6 +177,9 @@ def generate_method_code(path, method, operation, tool_name=None):
     Returns:
         tuple: (method_code, func_name) - The Python code for the method and its name.
     """
+    # Extract path parameters from the URL path
+    path_params_in_url = re.findall(r'{([^}]+)}', path)
+    
     # Determine function name
     if "operationId" in operation:
         raw_name = operation["operationId"]
@@ -198,18 +201,28 @@ def generate_method_code(path, method, operation, tool_name=None):
         func_name = f"{tool_name}_{func_name}"
 
     # Get parameters and request body
-    parameters = operation.get("parameters", [])
+    # Filter out header parameters
+    parameters = [param for param in operation.get("parameters", []) if param.get("in") != "header"]
     has_body = "requestBody" in operation
     body_required = has_body and operation["requestBody"].get("required", False)
 
     # Build function arguments
     required_args = []
     optional_args = []
+    
+    
+    for param_name in path_params_in_url:
+        if param_name not in required_args:
+            required_args.append(param_name)
+
+    
     for param in parameters:
-        if param.get("required", False):
-            required_args.append(param["name"])
-        else:
-            optional_args.append(f"{param['name']}=None")
+        param_name = param["name"]
+        if param_name not in required_args:  
+            if param.get("required", False):
+                required_args.append(param_name)
+            else:
+                optional_args.append(f"{param_name}=None")
 
     # Add request body parameter
     if has_body:
@@ -229,12 +242,12 @@ def generate_method_code(path, method, operation, tool_name=None):
     # Build method body
     body_lines = []
 
-    # Validate required parameters
-    for param in parameters:
-        if param.get("required", False):
-            body_lines.append(f"        if {param['name']} is None:")
+    # Validate required parameters including path parameters
+    for param_name in required_args:
+        if param_name != "request_body":  # Skip validation for request body as it's handled separately
+            body_lines.append(f"        if {param_name} is None:")
             body_lines.append(
-                f"            raise ValueError(\"Missing required parameter '{param['name']}'\")"
+                f"            raise ValueError(\"Missing required parameter '{param_name}'\")"
             )
 
     # Validate required body
@@ -244,15 +257,9 @@ def generate_method_code(path, method, operation, tool_name=None):
             '            raise ValueError("Missing required request body")'
         )
 
-    # Path parameters
-    path_params = [p for p in parameters if p["in"] == "path"]
-    path_params_dict = ", ".join([f"'{p['name']}': {p['name']}" for p in path_params])
-    body_lines.append(f"        path_params = {{{path_params_dict}}}")
-
-    # Format URL
-    body_lines.append(
-        f'        url = f"{{self.base_url}}{path}".format_map(path_params)'
-    )
+    # Format URL directly with path parameters
+    url_line = f'        url = f"{{self.base_url}}{path}"'
+    body_lines.append(url_line)
 
     # Query parameters
     query_params = [p for p in parameters if p["in"] == "query"]

{universal_mcp-0.1.1rc1 → universal_mcp-0.1.2}/uv.lock

@@ -1092,6 +1092,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a6/32/b09799c5b6ce8c6842536116118664dd7ec5964e229b7cd449c8d598c68d/langchain_mcp_adapters-0.0.7-py3-none-any.whl", hash = "sha256:1e37ec79fc6afb58d1dea17733e08cc111ebc1992aed4b22c67de5e2bdcdb5c6", size = 8610 },
 ]
 
+[[package]]
+name = "langchain-openai"
+version = "0.3.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+    { name = "openai" },
+    { name = "tiktoken" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/32/01/94d861be321df40f104324d3c64115917c7e774bb5d6af45d4af967c863c/langchain_openai-0.3.12.tar.gz", hash = "sha256:c9dbff63551f6bd91913bca9f99a2d057fd95dc58d4778657d67e5baa1737f61", size = 269015 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/7e/0d8838972ffead497b40cd42a1676f9ad90427d422c92dff2fb5461c4308/langchain_openai-0.3.12-py3-none-any.whl", hash = "sha256:0fab64d58ec95e65ffbaf659470cd362e815685e15edbcb171641e90eca4eb86", size = 61320 },
+]
+
 [[package]]
 name = "langgraph"
 version = "0.3.25"
@@ -2834,7 +2848,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp"
-version = "0.1.0"
+version = "0.1.2rc1"
 source = { editable = "." }
 dependencies = [
     { name = "keyring" },
@@ -2866,6 +2880,7 @@ playground = [
     { name = "fastapi", extra = ["standard"] },
     { name = "langchain-anthropic" },
     { name = "langchain-mcp-adapters" },
+    { name = "langchain-openai" },
     { name = "langgraph" },
     { name = "langgraph-checkpoint-sqlite" },
     { name = "python-dotenv" },
@@ -2884,6 +2899,7 @@ requires-dist = [
     { name = "keyring", specifier = ">=25.6.0" },
     { name = "langchain-anthropic", marker = "extra == 'playground'", specifier = ">=0.3.10" },
     { name = "langchain-mcp-adapters", marker = "extra == 'playground'", specifier = ">=0.0.3" },
+    { name = "langchain-openai", marker = "extra == 'playground'", specifier = ">=0.3.12" },
     { name = "langgraph", marker = "extra == 'playground'", specifier = ">=0.3.24" },
     { name = "langgraph-checkpoint-sqlite", marker = "extra == 'playground'", specifier = ">=2.0.6" },
     { name = "litellm", specifier = ">=1.30.7" },