mcp-openapi-proxy 0.1.1741476231__tar.gz → 0.1.1741477332__tar.gz

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mcp-openapi-proxy
-Version: 0.1.1741476231
+Version: 0.1.1741477332
 Summary: MCP server for exposing OpenAPI specifications as MCP tools.
 Author-email: Matthew Hand <matthewhandau@gmail.com>
 Description-Content-Type: text/markdown
@@ -107,8 +107,8 @@ Refer to the **Examples** section below for practical configurations tailored to
 - `TOOL_WHITELIST`: (Optional) A comma-separated list of endpoint paths to expose as tools.
 - `TOOL_NAME_PREFIX`: (Optional) A prefix to prepend to all tool names.
 - `API_KEY`: (Optional) Authentication token for the API, sent as `Bearer <API_KEY>` in the Authorization header by default.
-- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `query.token` for Slack).
-- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for Fly.io).
+- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `token` for Slack).
+- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for GetZep).
 
 ## Examples
 
@@ -172,8 +172,6 @@ OPENAPI_SPEC_URL="https://raw.githubusercontent.com/abhiaagarwal/peristera/refs/
 
 ### Slack Example
 
-![image](https://github.com/user-attachments/assets/6ae7f708-9494-41a1-9075-e685f2cd8873)
-
 Slack’s API showcases payload-based authentication with JMESPath. Obtain a bot token from [Slack API documentation](https://api.slack.com/authentication/token-types#bot).
 
 #### 1. Verify the OpenAPI Specification
@@ -276,7 +274,6 @@ Update your configuration:
 - **TOOL_WHITELIST**: Limits to `/sessions` endpoints.
 - **API_KEY**: Your GetZep API key.
 - **API_AUTH_TYPE**: Uses `Api-Key` for header-based authentication (overrides default `Bearer`).
-- **SERVER_URL_OVERRIDE**: GetZep’s API base URL.
 - **TOOL_NAME_PREFIX**: Prepends `getzep_` to tools.
 
 #### 3. Resulting Tools

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/README.md

@@ -91,8 +91,8 @@ Refer to the **Examples** section below for practical configurations tailored to
 - `TOOL_WHITELIST`: (Optional) A comma-separated list of endpoint paths to expose as tools.
 - `TOOL_NAME_PREFIX`: (Optional) A prefix to prepend to all tool names.
 - `API_KEY`: (Optional) Authentication token for the API, sent as `Bearer <API_KEY>` in the Authorization header by default.
-- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `query.token` for Slack).
-- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for Fly.io).
+- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `token` for Slack).
+- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for GetZep).
 
 ## Examples
 
@@ -156,8 +156,6 @@ OPENAPI_SPEC_URL="https://raw.githubusercontent.com/abhiaagarwal/peristera/refs/
 
 ### Slack Example
 
-![image](https://github.com/user-attachments/assets/6ae7f708-9494-41a1-9075-e685f2cd8873)
-
 Slack’s API showcases payload-based authentication with JMESPath. Obtain a bot token from [Slack API documentation](https://api.slack.com/authentication/token-types#bot).
 
 #### 1. Verify the OpenAPI Specification
@@ -260,7 +258,6 @@ Update your configuration:
 - **TOOL_WHITELIST**: Limits to `/sessions` endpoints.
 - **API_KEY**: Your GetZep API key.
 - **API_AUTH_TYPE**: Uses `Api-Key` for header-based authentication (overrides default `Bearer`).
-- **SERVER_URL_OVERRIDE**: GetZep’s API base URL.
 - **TOOL_NAME_PREFIX**: Prepends `getzep_` to tools.
 
 #### 3. Resulting Tools

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/mcp_openapi_proxy/server_fastmcp.py

@@ -16,7 +16,8 @@ import os
 import sys
 import json
 import requests
-
+from typing import Dict, Any
+from mcp import types
 from mcp.server.fastmcp import FastMCP
 from mcp_openapi_proxy.utils import setup_logging, is_tool_whitelisted, fetch_openapi_spec, get_auth_headers, build_base_url, normalize_tool_name, handle_custom_auth, get_tool_prefix
 
@@ -49,7 +50,7 @@ def list_functions(*, env_key: str = "OPENAPI_SPEC_URL") -> str:
         logger.debug("No paths found in spec.")
         return json.dumps([])
     functions = {}
-    prefix = get_tool_prefix()  # Grab the prefix here
+    prefix = get_tool_prefix()
     for path, path_item in paths.items():
         logger.debug(f"Processing path: {path}")
         if not path_item:
@@ -71,19 +72,37 @@ def list_functions(*, env_key: str = "OPENAPI_SPEC_URL") -> str:
             raw_name = f"{method.upper()} {path}"
             function_name = normalize_tool_name(raw_name)
             if prefix:
-                function_name = f"{prefix}{function_name}"  # Apply prefix here
+                function_name = f"{prefix}{function_name}"
             if function_name in functions:
                 logger.debug(f"Skipping duplicate tool name: {function_name}")
                 continue
             function_description = operation.get("summary", operation.get("description", "No description provided."))
             logger.debug(f"Registering function: {function_name} - {function_description}")
+            input_schema = {
+                "type": "object",
+                "properties": {},
+                "required": [],
+                "additionalProperties": False
+            }
+            for param in operation.get("parameters", []):
+                param_name = param.get("name")
+                param_type = param.get("type", "string")
+                if param_type not in ["string", "integer", "boolean", "number"]:
+                    param_type = "string"
+                input_schema["properties"][param_name] = {
+                    "type": param_type,
+                    "description": param.get("description", f"{param.get('in', 'unknown')} parameter {param_name}")
+                }
+                if param.get("required", False):
+                    input_schema["required"].append(param_name)
             functions[function_name] = {
                 "name": function_name,
                 "description": function_description,
                 "path": path,
                 "method": method.upper(),
                 "operationId": operation.get("operationId"),
-                "original_name": raw_name
+                "original_name": raw_name,
+                "inputSchema": input_schema
             }
     logger.info(f"Discovered {len(functions)} functions from the OpenAPI specification.")
     logger.debug(f"Functions list: {list(functions.values())}")
@@ -110,7 +129,7 @@ def call_function(*, function_name: str, parameters: dict = None, env_key: str =
     function_def = None
     paths = spec.get("paths", {})
     logger.debug(f"Paths for function lookup: {list(paths.keys())}")
-    prefix = get_tool_prefix()  # Ensure prefix is considered here too
+    prefix = get_tool_prefix()
     for path, path_item in paths.items():
         logger.debug(f"Checking path: {path}")
         for method, operation in path_item.items():
@@ -138,8 +157,10 @@ def call_function(*, function_name: str, parameters: dict = None, env_key: str =
         return json.dumps({"error": f"Function '{function_name}' not found"})
     logger.debug(f"Function def found: {function_def}")
 
-    # Apply custom auth mapping if API_KEY_JMESPATH is set
-    parameters = handle_custom_auth(function_def["operation"], parameters)
+    operation = function_def["operation"]
+    operation["method"] = function_def["method"]
+    parameters = handle_custom_auth(operation, parameters)
+    logger.debug(f"Parameters after auth handling: {parameters}")
 
     if not is_tool_whitelisted(function_def["path"]):
         logger.error(f"Access to function '{function_name}' is not allowed.")
@@ -151,26 +172,40 @@ def call_function(*, function_name: str, parameters: dict = None, env_key: str =
         return json.dumps({"error": "No base URL defined in spec or SERVER_URL_OVERRIDE"})
 
     path = function_def["path"]
-    path = "/" + path.lstrip("/")
-    logger.debug(f"Normalized path: {path}")
-    api_url = base_url + path
-    logger.debug(f"Final API URL: {api_url}")
-    request_params = {}
-    request_body = None
+    api_url = f"{base_url.rstrip('/')}/{path.lstrip('/')}"
     headers = {}
     if function_def["method"] != "GET":
         headers["Content-Type"] = "application/json"
     headers.update(get_auth_headers(spec))
-    if parameters is None:
-        parameters = {}
-    logger.debug(f"Parameters after auth handling: {parameters}")
-    if parameters:
+    request_params = {}
+    request_body = None
+
+    # Map all path parameters dynamically from the spec
+    if isinstance(parameters, dict):
+        path_params_in_openapi = [
+            param["name"] for param in operation.get("parameters", []) if param.get("in") == "path"
+        ]
+        if path_params_in_openapi:
+            missing_required = [
+                param["name"] for param in operation.get("parameters", [])
+                if param.get("in") == "path" and param.get("required", False) and param["name"] not in parameters
+            ]
+            if missing_required:
+                logger.error(f"Missing required path parameters: {missing_required}")
+                return json.dumps({"error": f"Missing required path parameters: {missing_required}"})
+            for param_name in path_params_in_openapi:
+                if param_name in parameters:
+                    api_url = api_url.replace(f"{{{param_name}}}", str(parameters.pop(param_name)))
+                    logger.debug(f"Replaced path param {param_name} in URL: {api_url}")
+        # Remaining parameters go to query (GET) or body (non-GET)
         if function_def["method"] == "GET":
             request_params = parameters
-            logger.debug(f"Set request_params for GET: {request_params}")
         else:
             request_body = parameters
-            logger.debug(f"Set request_body: {request_body}")
+    else:
+        parameters = {}
+        logger.debug("No valid parameters provided, proceeding without params/body")
+
     logger.debug(f"Sending request - Method: {function_def['method']}, URL: {api_url}, Headers: {headers}, Params: {request_params}, Body: {request_body}")
     try:
         response = requests.request(
@@ -178,7 +213,7 @@ def call_function(*, function_name: str, parameters: dict = None, env_key: str =
             url=api_url,
             headers=headers,
             params=request_params if function_def["method"] == "GET" else None,
-            json=None if function_def["method"] == "GET" else request_body
+            json=request_body if function_def["method"] != "GET" else None
         )
         response.raise_for_status()
         logger.debug(f"API response received: {response.text}")

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/mcp_openapi_proxy/server_lowlevel.py

@@ -78,33 +78,28 @@ async def dispatcher_handler(request: types.CallToolRequest) -> types.ServerResu
         request_params = {}
         request_body = None
 
-        # Handle all path parameters, not just required ones
-        path_params_in_openapi = [
-            param['name'] for param in operation.get('parameters', []) if param.get('in') == 'path'
-        ]
-        if path_params_in_openapi:
-            if not isinstance(parameters, dict):
-                logger.error(f"Path parameters {path_params_in_openapi} missing: parameters is not a dict")
-                return types.ServerResult(
-                    root=types.CallToolResult(
-                        content=[types.TextContent(type="text", text=f"Missing path parameters: {path_params_in_openapi}")]
-                    )
-                )
-            missing_params = [p for p in path_params_in_openapi if p not in parameters]
-            if missing_params:
-                logger.error(f"Required path parameters missing: {missing_params}")
-                return types.ServerResult(
-                    root=types.CallToolResult(
-                        content=[types.TextContent(type="text", text=f"Missing required path parameters: {missing_params}")]
-                    )
-                )
-            for param_name in path_params_in_openapi:
-                if param_name in parameters:
-                    api_url = api_url.replace(f"{{{param_name}}}", str(parameters.pop(param_name)))
-                    logger.debug(f"Replaced path param {param_name} in URL: {api_url}")
-
-        # Remaining parameters go to query (GET) or body (non-GET)
+        # Map all path parameters dynamically from the spec
         if isinstance(parameters, dict):
+            path_params_in_openapi = [
+                param['name'] for param in operation.get('parameters', []) if param.get('in') == 'path'
+            ]
+            if path_params_in_openapi:
+                missing_required = [
+                    param['name'] for param in operation.get('parameters', [])
+                    if param.get('in') == 'path' and param.get('required', False) and param['name'] not in parameters
+                ]
+                if missing_required:
+                    logger.error(f"Missing required path parameters: {missing_required}")
+                    return types.ServerResult(
+                        root=types.CallToolResult(
+                            content=[types.TextContent(type="text", text=f"Missing required path parameters: {missing_required}")]
+                        )
+                    )
+                for param_name in path_params_in_openapi:
+                    if param_name in parameters:
+                        api_url = api_url.replace(f"{{{param_name}}}", str(parameters.pop(param_name)))
+                        logger.debug(f"Replaced path param {param_name} in URL: {api_url}")
+            # Remaining parameters go to query (GET) or body (non-GET)
             if method == "GET":
                 request_params = parameters
             else:

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/mcp_openapi_proxy/utils.py

@@ -21,15 +21,6 @@ load_dotenv()
 OPENAPI_SPEC_URL = os.getenv("OPENAPI_SPEC_URL")
 
 def setup_logging(debug: bool = False) -> logging.Logger:
-    """
-    Configures logging for the application, directing all output to stderr.
-
-    Args:
-        debug (bool): If True, sets log level to DEBUG; otherwise, INFO.
-
-    Returns:
-        logging.Logger: Configured logger instance.
-    """
     logger = logging.getLogger(__name__)
     logger.setLevel(logging.DEBUG if debug else logging.INFO)
     logger.propagate = False
@@ -53,21 +44,11 @@ logger.debug(f"OpenAPI Spec URL: {OPENAPI_SPEC_URL}")
 logger.debug("utils.py initialized")
 
 def redact_api_key(key: str) -> str:
-    """Redacts an API key for secure logging."""
     if not key or len(key) <= 4:
         return "<not set>"
     return f"{key[:2]}{'*' * (len(key) - 4)}{key[-2:]}"
 
 def normalize_tool_name(name: str) -> str:
-    """
-    Normalizes tool names into a clean function name without parameters.
-
-    Args:
-        name (str): Raw method and path, e.g., 'GET /sessions/{sessionId}/messages/{messageUUID}'.
-
-    Returns:
-        str: Normalized tool name without special characters.
-    """
     if not name or not isinstance(name, str):
         logger.warning(f"Invalid tool name input: {name}. Defaulting to 'unknown_tool'.")
         return "unknown_tool"
@@ -99,22 +80,12 @@ def normalize_tool_name(name: str) -> str:
     return func_name or "unknown_tool"
 
 def get_tool_prefix() -> str:
-    """Retrieves tool name prefix from environment, ensuring it ends with an underscore."""
     prefix = os.getenv("TOOL_NAME_PREFIX", "")
     if prefix and not prefix.endswith("_"):
         prefix += "_"
     return prefix
 
 def is_tool_whitelisted(endpoint: str) -> bool:
-    """
-    Checks if an endpoint matches any partial path in TOOL_WHITELIST.
-
-    Args:
-        endpoint (str): The endpoint path from the OpenAPI spec.
-
-    Returns:
-        bool: True if the endpoint matches any whitelist item, False otherwise.
-    """
     whitelist = os.getenv("TOOL_WHITELIST", "")
     logger.debug(f"Checking whitelist - endpoint: {endpoint}, TOOL_WHITELIST: {whitelist}")
     if not whitelist:
@@ -152,7 +123,6 @@ def is_tool_whitelisted(endpoint: str) -> bool:
     return False
 
 def fetch_openapi_spec(spec_url: str) -> dict:
-    """Fetches and parses OpenAPI specification from a URL or file, assuming JSON if no suffix."""
     try:
         if spec_url.startswith("file://"):
             spec_path = spec_url.replace("file://", "")
@@ -160,12 +130,13 @@ def fetch_openapi_spec(spec_url: str) -> dict:
                 content = f.read()
             logger.debug(f"Read local OpenAPI spec from {spec_path}")
         else:
-            response = requests.get(spec_url)
+            response = requests.get(spec_url, timeout=10)
+            if response.status_code in [401, 403]:
+                logger.debug(f"Spec {spec_url} requires auth (status {response.status_code})—skipping")
+                return None
             response.raise_for_status()
             content = response.text
             logger.debug(f"Fetched OpenAPI spec from {spec_url}")
-        
-        # Check suffix, default to JSON if none
         if spec_url.endswith(('.yaml', '.yml')):
             spec = yaml.safe_load(content)
             logger.debug(f"Parsed YAML OpenAPI spec from {spec_url}")
@@ -181,16 +152,6 @@ def fetch_openapi_spec(spec_url: str) -> dict:
         return None
 
 def get_auth_headers(spec: dict, api_key_env: str = "API_KEY") -> dict:
-    """
-    Constructs authorization headers based on spec and environment variables.
-
-    Args:
-        spec (dict): OpenAPI specification.
-        api_key_env (str): Environment variable name for the API key (default: "API_KEY").
-
-    Returns:
-        dict: Headers dictionary with Authorization set appropriately.
-    """
     headers = {}
     auth_token = os.getenv(api_key_env)
     if not auth_token:
@@ -223,75 +184,54 @@ def get_auth_headers(spec: dict, api_key_env: str = "API_KEY") -> dict:
     return headers
 
 def handle_custom_auth(operation: dict, parameters: dict = None) -> dict:
-    """
-    Applies custom authentication mapping using API_KEY_JMESPATH if provided, overwriting existing keys.
-
-    Args:
-        operation (dict): The OpenAPI operation object for the endpoint.
-        parameters (dict, optional): Existing parameters or arguments to modify.
-
-    Returns:
-        dict: Updated parameters with API_KEY mapped according to API_KEY_JMESPATH, overwriting conflicts.
-    """
     if parameters is None:
         parameters = {}
-
     logger.debug(f"Raw parameters before auth handling: {parameters}")
     api_key = os.getenv("API_KEY")
     jmespath_expr = os.getenv("API_KEY_JMESPATH")
-
     if not api_key or not jmespath_expr:
         logger.debug("No API_KEY or API_KEY_JMESPATH set, skipping custom auth handling.")
         return parameters
 
-    # Structure to apply JMESPath: separate query params and body
+    method = operation.get("method", "GET").upper()
     request_data = {"query": {}, "body": {}}
+    # Preserve original params, split by method
     if parameters:
-        # Assume GET params go to query, others to body (simplified heuristic)
         for key, value in parameters.items():
-            if operation.get("method", "GET").upper() == "GET":
+            param_in = next((p.get("in") for p in operation.get("parameters", []) if p.get("name") == key), None)
+            if param_in == "query" or (method == "GET" and param_in not in ["path", "header"]):
                 request_data["query"][key] = value
-            else:
+            elif param_in == "header":
+                request_data["body"][key] = value
+            elif param_in != "path":  # Path params handled elsewhere
                 request_data["body"][key] = value
 
+    # Apply API_KEY via JMESPath
     try:
-        # Compile JMESPath expression and set the API key, overwriting existing
-        expr = jmespath.compile(jmespath_expr)
-        updated_data = expr.search(request_data, options=jmespath.Options(dict_cls=dict))
-        if updated_data is None:
-            # If path doesn't exist, create it
-            parts = jmespath_expr.split('.')
-            current = request_data
-            for i, part in enumerate(parts):
-                if i == len(parts) - 1:
-                    current[part] = api_key  # Overwrite here
-                else:
-                    current.setdefault(part, {})
-                    current = current[part]
-        else:
-            # Overwrite existing value at the JMESPath location
-            parts = jmespath_expr.split('.')
-            current = request_data
-            for i, part in enumerate(parts):
+        if jmespath_expr:
+            parts = jmespath_expr.split(".")
+            target = request_data[parts[0]] if parts[0] in request_data else {}
+            current = target
+            for i, part in enumerate(parts[1:], 1):
                 if i == len(parts) - 1:
-                    current[part] = api_key  # Force overwrite
+                    current[part] = api_key  # Overwrite at final key
                 else:
                     current = current.setdefault(part, {})
-        logger.debug(f"Applied API_KEY to {jmespath_expr}, overwriting any existing: {redact_api_key(api_key)}")
+            if parts[0] in request_data:
+                request_data[parts[0]] = target
+            logger.debug(f"Applied API_KEY to {jmespath_expr}: {redact_api_key(api_key)}")
     except Exception as e:
-        logger.error(f"Failed to apply API_KEY_JMESPATH '{jmespath_expr}': {e}")
-        return parameters
+        logger.error(f"Error applying JMESPath expression {jmespath_expr}: {e}")
 
-    # Flatten back to parameters, overwriting original params
-    if operation.get("method", "GET").upper() == "GET":
+    # Merge back, overwriting original params
+    if method == "GET":
         parameters = {**parameters, **request_data["query"]}
     else:
         parameters = {**parameters, **request_data["body"]}
-
+    logger.debug(f"Parameters after custom auth merge: {parameters}")
     return parameters
 
 def map_schema_to_tools(schema: dict) -> list:
-    """Maps a schema to a list of MCP tools."""
     tools = []
     classes = schema.get("classes", [])
     for entry in classes:
@@ -308,15 +248,6 @@ def map_schema_to_tools(schema: dict) -> list:
     return tools
 
 def detect_response_type(response_text: str) -> tuple[types.TextContent, str]:
-    """
-    Detects the response type (JSON or text) and returns the appropriate MCP content object.
-
-    Args:
-        response_text (str): The raw response text from the HTTP request.
-
-    Returns:
-        Tuple: (content object, log message)
-    """
     try:
         json_data = json.loads(response_text)
         structured_text = {"text": response_text}
@@ -328,15 +259,6 @@ def detect_response_type(response_text: str) -> tuple[types.TextContent, str]:
     return content, log_message
 
 def build_base_url(spec: dict) -> str:
-    """
-    Constructs the base URL for API requests, prioritizing SERVER_URL_OVERRIDE.
-
-    Args:
-        spec (dict): OpenAPI specification containing servers or host information.
-
-    Returns:
-        str: The constructed base URL, or empty string if not determinable.
-    """
     override = os.getenv("SERVER_URL_OVERRIDE", "").strip()
     if override:
         urls = override.split()

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/mcp_openapi_proxy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mcp-openapi-proxy
-Version: 0.1.1741476231
+Version: 0.1.1741477332
 Summary: MCP server for exposing OpenAPI specifications as MCP tools.
 Author-email: Matthew Hand <matthewhandau@gmail.com>
 Description-Content-Type: text/markdown
@@ -107,8 +107,8 @@ Refer to the **Examples** section below for practical configurations tailored to
 - `TOOL_WHITELIST`: (Optional) A comma-separated list of endpoint paths to expose as tools.
 - `TOOL_NAME_PREFIX`: (Optional) A prefix to prepend to all tool names.
 - `API_KEY`: (Optional) Authentication token for the API, sent as `Bearer <API_KEY>` in the Authorization header by default.
-- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `query.token` for Slack).
-- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for Fly.io).
+- `API_KEY_JMESPATH`: (Optional) JMESPath expression to map `API_KEY` into request parameters (e.g., `token` for Slack).
+- `API_AUTH_TYPE`: (Optional) Overrides the default `Bearer` Authorization header type (e.g., `Api-Key` for GetZep).
 
 ## Examples
 
@@ -172,8 +172,6 @@ OPENAPI_SPEC_URL="https://raw.githubusercontent.com/abhiaagarwal/peristera/refs/
 
 ### Slack Example
 
-![image](https://github.com/user-attachments/assets/6ae7f708-9494-41a1-9075-e685f2cd8873)
-
 Slack’s API showcases payload-based authentication with JMESPath. Obtain a bot token from [Slack API documentation](https://api.slack.com/authentication/token-types#bot).
 
 #### 1. Verify the OpenAPI Specification
@@ -276,7 +274,6 @@ Update your configuration:
 - **TOOL_WHITELIST**: Limits to `/sessions` endpoints.
 - **API_KEY**: Your GetZep API key.
 - **API_AUTH_TYPE**: Uses `Api-Key` for header-based authentication (overrides default `Bearer`).
-- **SERVER_URL_OVERRIDE**: GetZep’s API base URL.
 - **TOOL_NAME_PREFIX**: Prepends `getzep_` to tools.
 
 #### 3. Resulting Tools

{mcp_openapi_proxy-0.1.1741476231 → mcp_openapi_proxy-0.1.1741477332}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-openapi-proxy"
-version = "0.1.1741476231"
+version = "0.1.1741477332"
 description = "MCP server for exposing OpenAPI specifications as MCP tools."
 readme = "README.md"
 authors = [