universal-mcp 0.1.23rc2__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/servers/README.md

@@ -1,79 +0,0 @@
-# Servers
-
-This package provides server implementations for hosting and managing MCP (Model Control Protocol) applications.
-
-## Overview
-
-The server implementations provide different ways to host and expose MCP applications and their tools. The base `BaseServer` class provides common functionality that all server implementations inherit.
-
-## Supported Server Types
-
-### Local Server
-The `LocalServer` class provides a local development server implementation that:
-- Loads applications from local configuration
-- Manages a local store for data persistence
-- Supports integration with external services
-- Exposes application tools through the MCP protocol
-
-### AgentR Server
-The `AgentRServer` class provides a server implementation that:
-- Connects to the AgentR API
-- Dynamically fetches and loads available applications
-- Manages AgentR-specific integrations
-- Requires an API key for authentication
-
-### Single MCP Server
-The `SingleMCPServer` class provides a minimal server implementation that:
-- Hosts a single application instance
-- Ideal for development and testing
-- Does not manage integrations or stores internally
-- Exposes only the tools from the provided application
-
-## Core Features
-
-All server implementations provide:
-
-- Tool management and registration
-- Application loading and configuration
-- Error handling and logging
-- MCP protocol compliance
-- Integration support
-
-## Usage
-
-Each server implementation can be initialized with a `ServerConfig` object that specifies:
-- Server name and description
-- Port configuration
-- Application configurations
-- Store configuration (where applicable)
-
-Example:
-```python
-from universal_mcp.servers import LocalServer
-from universal_mcp.config import ServerConfig
-
-config = ServerConfig(
-    name="My Local Server",
-    description="Development server for testing applications",
-    port=8000,
-    # ... additional configuration
-)
-
-server = LocalServer(config)
-```
-
-## Tool Management
-
-Servers provide methods for:
-- Adding individual tools
-- Listing available tools
-- Calling tools with proper error handling
-- Formatting tool results
-
-## Error Handling
-
-All servers implement comprehensive error handling for:
-- Tool execution failures
-- Application loading errors
-- Integration setup issues
-- API communication problems

universal_mcp/stores/README.md

@@ -1,74 +0,0 @@
-# Universal MCP Stores
-
-The stores module provides a flexible and secure way to manage credentials and sensitive data across different storage backends. It implements a common interface for storing, retrieving, and deleting sensitive information.
-
-## Features
-
-- Abstract base class defining a consistent interface for credential stores
-- Multiple storage backend implementations:
-  - In-memory store (temporary storage)
-  - Environment variable store
-  - System keyring store (secure credential storage)
-- Exception handling for common error cases
-- Type hints and comprehensive documentation
-
-## Available Store Implementations
-
-### MemoryStore
-A simple in-memory store that persists data only for the duration of program execution. Useful for testing or temporary storage.
-
-```python
-from universal_mcp.stores import MemoryStore
-
-store = MemoryStore()
-store.set("api_key", "secret123")
-value = store.get("api_key")  # Returns "secret123"
-```
-
-### EnvironmentStore
-Uses environment variables to store and retrieve credentials. Useful for containerized environments or CI/CD pipelines.
-
-```python
-from universal_mcp.stores import EnvironmentStore
-
-store = EnvironmentStore()
-store.set("API_KEY", "secret123")
-value = store.get("API_KEY")  # Returns "secret123"
-```
-
-### KeyringStore
-Leverages the system's secure credential storage facility. Provides the most secure option for storing sensitive data.
-
-```python
-from universal_mcp.stores import KeyringStore
-
-store = KeyringStore(app_name="my_app")
-store.set("api_key", "secret123")
-value = store.get("api_key")  # Returns "secret123"
-```
-
-## Error Handling
-
-The module provides specific exception types for handling errors:
-
-- `StoreError`: Base exception for all store-related errors
-- `KeyNotFoundError`: Raised when a requested key is not found in the store
-
-## Best Practices
-
-1. Use `KeyringStore` for production environments where security is a priority
-2. Use `EnvironmentStore` for containerized or cloud environments
-3. Use `MemoryStore` for testing or temporary storage only
-4. Always handle `StoreError` and `KeyNotFoundError` exceptions appropriately
-
-## Dependencies
-
-- `keyring`: Required for the KeyringStore implementation
-- `loguru`: Used for logging operations in the KeyringStore
-
-## Contributing
-
-New store implementations should inherit from `BaseStore` and implement all required abstract methods:
-- `get(key: str) -> Any`
-- `set(key: str, value: str) -> None`
-- `delete(key: str) -> None`

universal_mcp/tools/README.md

@@ -1,86 +0,0 @@
-# Universal MCP Tools
-
-This directory contains the core tooling infrastructure for Universal MCP, providing a flexible and extensible framework for defining, managing, and converting tools across different formats.
-
-## Components
-
-### `tools.py`
-The main module containing the core tool management functionality:
-
-- `Tool` class: Represents a tool with metadata, validation, and execution capabilities
-- `ToolManager` class: Manages tool registration, lookup, and execution
-- Conversion utilities for different tool formats (OpenAI, LangChain, MCP)
-
-### `adapters.py`
-Contains adapters for converting tools between different formats:
-- `convert_tool_to_mcp_tool`: Converts a tool to MCP format
-- `convert_tool_to_langchain_tool`: Converts a tool to LangChain format
-
-### `func_metadata.py`
-Provides function metadata and argument validation:
-- `FuncMetadata` class: Handles function signature analysis and argument validation
-- `ArgModelBase` class: Base model for function arguments
-- Utilities for parsing and validating function signatures
-
-## Usage
-
-### Creating a Tool
-
-```python
-from universal_mcp.tools import Tool
-
-def my_tool(param1: str, param2: int) -> str:
-    """A simple tool that does something.
-    
-    Args:
-        param1: Description of param1
-        param2: Description of param2
-        
-    Returns:
-        Description of return value
-    """
-    return f"Result: {param1} {param2}"
-
-tool = Tool.from_function(my_tool)
-```
-
-### Managing Tools
-
-```python
-from universal_mcp.tools import ToolManager
-
-manager = ToolManager()
-manager.add_tool(my_tool)
-
-# Get a tool by name
-tool = manager.get_tool("my_tool")
-
-# List all tools in a specific format
-tools = manager.list_tools(format="openai")  # or "langchain" or "mcp"
-```
-
-### Converting Tools
-
-```python
-from universal_mcp.tools import convert_tool_to_langchain_tool
-
-langchain_tool = convert_tool_to_langchain_tool(tool)
-```
-
-## Features
-
-- Automatic docstring parsing for tool metadata
-- Type validation using Pydantic
-- Support for both sync and async tools
-- JSON schema generation for tool parameters
-- Error handling and analytics tracking
-- Tag-based tool organization
-- Multiple format support (OpenAI, LangChain, MCP)
-
-## Best Practices
-
-1. Always provide clear docstrings for your tools
-2. Use type hints for better validation
-3. Handle errors appropriately in your tool implementations
-4. Use tags to organize related tools
-5. Consider async implementations for I/O-bound operations

universal_mcp-0.1.23rc2.dist-info/METADATA

@@ -1,283 +0,0 @@
-Metadata-Version: 2.4
-Name: universal-mcp
-Version: 0.1.23rc2
-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>
-License: MIT
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: black>=25.1.0
-Requires-Dist: cookiecutter>=2.6.0
-Requires-Dist: gql[all]>=3.5.2
-Requires-Dist: jinja2>=3.1.3
-Requires-Dist: jsonref>=1.1.0
-Requires-Dist: keyring>=25.6.0
-Requires-Dist: langchain-mcp-adapters>=0.0.3
-Requires-Dist: litellm>=1.30.7
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp>=1.9.3
-Requires-Dist: posthog>=3.24.0
-Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: pydantic>=2.11.1
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: rich>=14.0.0
-Requires-Dist: typer>=0.15.2
-Provides-Extra: dev
-Requires-Dist: litellm>=1.30.7; extra == 'dev'
-Requires-Dist: pre-commit>=4.2.0; extra == 'dev'
-Requires-Dist: pyright>=1.1.398; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
-Requires-Dist: pytest>=8.3.5; extra == 'dev'
-Requires-Dist: ruff>=0.11.4; extra == 'dev'
-Provides-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: litellm>=1.30.7; extra == 'playground'
-Requires-Dist: python-dotenv>=1.0.1; extra == 'playground'
-Requires-Dist: streamlit>=1.44.1; extra == 'playground'
-Requires-Dist: watchdog>=6.0.0; extra == 'playground'
-Description-Content-Type: text/markdown
-
-# Universal MCP
-
-Universal MCP acts as a middleware layer for your API applications, enabling seamless integration with various services through the Model Control Protocol (MCP). It simplifies credential management, authorization, dynamic app enablement, and provides a robust framework for building and managing AI-powered tools.
-
-## 🌟 Features
-
-- **MCP (Model Control Protocol) Integration**: Seamlessly works with MCP server architecture for standardized agent-tool communication.
-- **Simplified API Integration**: Connect to services like GitHub, Google Calendar, Gmail, Reddit, Tavily, and more with minimal code. See [AgentR](https://agentr.dev) for a list of available applications.
-- **Managed Authentication**: Built-in support for API keys and OAuth-based authentication flows, often managed via the AgentR platform.
-- **Extensible Architecture**: Easily build and add new app integrations with minimal boilerplate using provided base classes and generation tools.
-- **Credential Management**: Flexible and secure storage options for API credentials (memory, environment variables, system keyring).
-- **Comprehensive Tool Management**: Robust tool registration, Pydantic-based validation, automatic docstring parsing, and execution capabilities. Supports conversion between MCP, LangChain, and OpenAI tool formats.
-- **Multiple Server Types**: Configurations for local development, AgentR-connected dynamic app loading, and single-application servers.
-- **Playground Environment**: Includes an interactive Streamlit-based playground for testing agents and tools.
-
-## 🔧 Installation
-
-Install Universal MCP using pip:
-
-```bash
-pip install universal-mcp
-```
-
-## 🚀 Quick Start
-
-**Important Prerequisite: AgentR API Key (If Using AgentR Integration)**
-
-If you plan to use integrations with `type: "agentr"` (for services like GitHub, Gmail, Notion via the AgentR platform), or if you run the MCP server itself with `type: "agentr"`, you first need an AgentR API key:
-
-1.  Visit [https://agentr.dev](https://agentr.dev) to create an account and generate an API key from your dashboard.
-2.  Set it as an environment variable _before_ running the MCP server:
-    ```bash
-    export AGENTR_API_KEY="your_api_key_here"
-    ```
-
-**1. Create a Configuration File (e.g., `config.json`)**
-
-This file defines the server settings, credential stores, and the applications to load with their respective integrations.
-
-```json
-{
-  "name": "My Local MCP Server",
-  "description": "A server for testing applications locally",
-  "type": "local", // "local" or "agentr"
-  "transport": "sse", // "sse", "stdio", or "http"
-  "port": 8005, // Relevant for "sse" or "http"
-  "store": {
-    // Default store for integrations
-    "name": "my_mcp_store",
-    "type": "keyring" // "keyring", "environment", or "memory"
-  },
-  "apps": [
-    {
-      "name": "zenquotes", // App slug (e.g., from agentr.dev)
-      "integration": null // No authentication needed for this app
-    },
-    {
-      "name": "tavily",
-      "integration": {
-        "name": "TAVILY_API_KEY", // Unique name for this credential if type is "api_key"
-        "type": "api_key",
-        "store": {
-          // Override default store for this specific app
-          "type": "environment" // Looks for TAVILY_API_KEY env var
-        }
-      }
-    },
-    {
-      "name": "github",
-      "integration": {
-        "name": "github", // Matches the service name in AgentR
-        "type": "agentr" // Uses AgentR platform for auth/creds
-      }
-    }
-  ]
-}
-```
-
-_Notes on `config.json`:_
-
-- `type: "local"`: Runs applications defined directly in the config's `apps` list.
-- `type: "agentr"`: Connects to the AgentR platform to dynamically load user-enabled apps (ignores the `apps` list in the config) and handle credentials. Requires `AGENTR_API_KEY` environment variable.
-- `store`: Defines credential storage.
-  - `environment`: Looks for an environment variable named `<INTEGRATION_NAME_UPPERCASE>` (e.g., `TAVILY_API_KEY` for the example above).
-  - `keyring`: Uses the system's secure credential storage.
-  - `memory`: Transient storage, lost when the server stops.
-- `integration`: Configures authentication for each app.
-  - `type: "agentr"`: Uses the AgentR platform for OAuth/credential management.
-  - `type: "api_key"`: Uses the specified `store` to retrieve the key.
-
-**2. Run the Server via CLI**
-
-Ensure any required environment variables (like `TAVILY_API_KEY` for the Tavily example, or `AGENTR_API_KEY` if using `"agentr"` type server/integrations) are set.
-
-```bash
-universal_mcp run -c config.json
-```
-
-The server will start, load the configured applications (or connect to AgentR if `type: "agentr"`), and listen for connections based on the `transport` type.
-
-## 🛠️ Using the Playground
-
-The `playground` directory provides a runnable Streamlit application for interacting with agents that can use tools from an MCP server.
-
-**Prerequisites:**
-
-- **`local_config.json`**: This file must exist in the **project root directory** (the same directory as this `README.md`). It configures the _local_ MCP server that the playground's agent can connect to if you choose to run one. For an example, see the `local_config.json` structure in the [Playground README](playground/README.md).
-- **Dependencies**: Install playground-specific dependencies. If you have the project cloned, you might install them via:
-  ```bash
-  pip install -e .[playground]
-  # or manually install fastapi, streamlit, uvicorn, langchain-openai, etc.
-  ```
-
-**Running the Playground:**
-
-The easiest way is to use the automated startup script from the **project root directory**:
-
-```bash
-python playground
-```
-
-This script will:
-
-1. Optionally start a local MCP server (based on your `local_config.json`) if you confirm.
-2. Launch the Streamlit application.
-
-For more detailed setup, manual startup instructions, and an explanation of the `local_config.json` for the playground, please refer to the [Playground README](playground/README.md).
-
-## 🧩 Available Applications
-
-Universal MCP can integrate with a wide variety of applications. For a list of publicly available applications and their slugs (e.g., "github", "google-calendar"), please visit [AgentR Applications](https://agentr.dev).
-Applications are typically installed dynamically by Universal MCP from their respective repositories when first referenced by slug.
-
-_Authentication Type Notes:_
-
-- _OAuth (via AgentR)_: Usually requires configuring the app's integration with `type: "agentr"` in your `ServerConfig`. This leverages the AgentR platform for the OAuth flow and requires the `AGENTR_API_KEY` to be set.
-- _API Key (via Integration)_: Requires configuring `type: "api_key"` for the app's integration in your `ServerConfig`, along with a `store` (like `environment` or `keyring`) to specify where the API key is located.
-
-## 🔐 Integration Types
-
-Universal MCP supports different ways to handle authentication for applications:
-
-### 1. API Key Integration (`type: "api_key"`)
-
-For services that authenticate via simple API keys.
-
-```json
-// In your ServerConfig apps array:
-{
-  "name": "tavily",
-  "integration": {
-    "name": "TAVILY_API_KEY", // Used by the store (e.g., as env var name)
-    "type": "api_key",
-    "store": {
-      "type": "environment" // Or "keyring", "memory"
-    }
-  }
-}
-```
-
-### 2. AgentR Integration (`type: "agentr"`)
-
-Recommended for services integrated with the AgentR platform, which typically handles OAuth flows or centrally managed credentials. Requires the `AGENTR_API_KEY` environment variable to be set for the MCP server process.
-
-```json
-// In your ServerConfig apps array:
-{
-  "name": "github",
-  "integration": {
-    "name": "github", // Matches the service name configured in AgentR
-    "type": "agentr"
-  }
-}
-```
-
-When an action requiring authorization is called, the `AgentRIntegration` will prompt the user (via the MCP client) to visit a URL to complete the OAuth flow managed by AgentR. This is also the default integration type for apps if the main server config is `type: "agentr"`.
-
-### 3. Direct OAuth Integration (`type: "oauth"`)
-
-While `AgentRIntegration` is generally preferred for OAuth, a direct `OAuthIntegration` class exists. However, it requires manual configuration of client IDs, secrets, and callback handling, which is more complex to set up outside the AgentR platform.
-
-## 🤖 CLI Usage
-
-Universal MCP includes a powerful command-line interface:
-
-```bash
-# Run the MCP server using a configuration file
-universal_mcp run -c config.json
-
-# Initialize a new MCP application project structure
-universal_mcp init --app-name my-cool-app --o ./my-apps --integration-type api_key
-
-# Generate API client code and application structure from an OpenAPI schema
-universal_mcp generate -s <path_to_schema.json_or_yaml> -o <path/to/app_output_directory> --c CustomAppClassName
-# Example: universal_mcp generate -s notion_api.yaml -o ./custom_apps/notion --c MyNotionApp
-
-# Preprocess an OpenAPI schema using an LLM to fill/enhance descriptions
-universal_mcp preprocess -s <path_to_input_schema.json_or_yaml> -o <path_to_processed_schema.json_or_yaml>
-
-# Generate Google-style docstrings for functions in a Python file using an LLM
-universal_mcp docgen <path/to/app_file.py>
-
-# Generate a README.md for a generated application file
-universal_mcp readme <path/to/app_file.py>
-
-# Install MCP configuration for supported desktop apps (e.g., Claude, Cursor)
-# Requires an AgentR API key for configuration.
-universal_mcp install claude
-universal_mcp install cursor
-
-# Check installed version (standard typer command)
-universal_mcp --version
-```
-
-## 📋 Requirements
-
-- Python 3.10+
-- Key Dependencies (installed automatically via pip, see `pyproject.toml` for full list):
-  - `mcp-server`
-  - `loguru`
-  - `typer`
-  - `httpx`
-  - `pydantic`
-  - `pyyaml`
-  - `keyring` (for `KeyringStore`)
-  - `litellm` (for `docgen` and `preprocess` commands)
-  - `uv` (used internally for dynamic package installation)
-
-## 📚 Documentation
-
-For more detailed information about specific components:
-
-- [Applications Framework](src/universal_mcp/applications/README.md)
-- [Tool Management](src/universal_mcp/tools/README.md)
-- [Server Implementations](src/universal_mcp/servers/README.md)
-- [Credential Stores](src/universal_mcp/stores/README.md)
-- [Integration & Authentication](src/universal_mcp/integrations/README.md)
-- [Playground Usage](playground/README.md)
-
-## 📝 License
-
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

universal_mcp-0.1.23rc2.dist-info/RECORD

@@ -1,51 +0,0 @@
-universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/analytics.py,sha256=Dkv8mkc_2T2t5NxLSZzcr3BlmOispj1RKtbB86V1i4M,2306
-universal_mcp/cli.py,sha256=Ndc1I4BtmvDCM6xNtXaO6roUvNabRlclI3tLDeSHKAw,10453
-universal_mcp/config.py,sha256=9yofM9MCyBiriojFVcMqRwc9njce6lgwX5r_EfvG0NE,5185
-universal_mcp/exceptions.py,sha256=-pbeZhpNieJfnSd2-WM80pU8W8mK8VHXcSjky0BHwdk,665
-universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
-universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/applications/README.md,sha256=eqbizxaTxKH2O1tyIJR2yI0Db5TQxtgPd_vbpWyCa2Y,3527
-universal_mcp/applications/__init__.py,sha256=l19_sMs5766VFWU_7O2niamvvvfQOteysqylbqvjjGQ,3500
-universal_mcp/applications/application.py,sha256=_fcnfAeT5Lm2PJpHjK5ax8pCsxlDGJIKyRqnlCdEg_w,18758
-universal_mcp/client/__main__.py,sha256=72e4WyJRiLoCtHlpIuvMZcDV98LvZclVaUGJmuCvpIE,886
-universal_mcp/client/agent.py,sha256=20N0aZ55ge9PBg-R9gHxit2NSY1ppSz2ez8ZXTiO5kc,3803
-universal_mcp/client/client.py,sha256=rx-meuWZuurjaTbjumpf5NO9zIh4wH9nMYUAp2uAejU,8393
-universal_mcp/client/oauth.py,sha256=H7goK8FcVuITiwdXR30Am-qAWcgNylsrvt9EJHZMayA,4144
-universal_mcp/client/token_store.py,sha256=eoZJbVcmkR-mAGhwk1tmDXXZnDKvjoqOVZG3nXfI8f8,1234
-universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMIdw-nmwEA,996
-universal_mcp/integrations/__init__.py,sha256=X8iEzs02IlXfeafp6GMm-cOkg70QdjnlTRuFo24KEfo,916
-universal_mcp/integrations/integration.py,sha256=WtW92Awr111Vb_i_vKBvyyYvsNton3N2cX7wQ3ZXy2Y,13105
-universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
-universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=FqAdAAXh23_ZL7ghZvXR5quAidXxQ6m-vDQrim40tag,12429
-universal_mcp/stores/README.md,sha256=jrPh_ow4ESH4BDGaSafilhOVaN8oQ9IFlFW-j5Z5hLA,2465
-universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
-universal_mcp/stores/store.py,sha256=mxnmOVlDNrr8OKhENWDtCIfK7YeCBQcGdS6I2ogRCsU,6756
-universal_mcp/tools/README.md,sha256=RuxliOFqV1ZEyeBdj3m8UKfkxAsfrxXh-b6V4ZGAk8I,2468
-universal_mcp/tools/__init__.py,sha256=Fatza_R0qYWmNF1WQSfUZZKQFu5qf-16JhZzdmyx3KY,333
-universal_mcp/tools/adapters.py,sha256=rnicV_WBgNe0WqVG60ms0o92BoRTRqd_C9jMMndx47c,3461
-universal_mcp/tools/func_metadata.py,sha256=7kUWArtUDa2Orr7VGzpwPVfyf2LM3UFA_9arMpl7Zn8,10838
-universal_mcp/tools/manager.py,sha256=ao_ovTyca8HR4uwHdL_lTWNdquxcqRx6FaLA4U1lZvQ,11242
-universal_mcp/tools/tools.py,sha256=8S_KzARYbG9xbyqhZcI4Wk46tXiZcWlcAMgjChXNEI4,3698
-universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
-universal_mcp/utils/agentr.py,sha256=-brwvgCZgPjvF7wPXw0QfpEsl1ekXQxmcF07-1AQMR4,3663
-universal_mcp/utils/common.py,sha256=HEZC2Mhilb8DrGXQG2tboAIw1r4veGilGWjfnPF1lyA,888
-universal_mcp/utils/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
-universal_mcp/utils/installation.py,sha256=ItOfBFhKOh4DLz237jgAz_Fn0uOMdrKXw0n5BaUZZNs,7286
-universal_mcp/utils/singleton.py,sha256=kolHnbS9yd5C7z-tzaUAD16GgI-thqJXysNi3sZM4No,733
-universal_mcp/utils/testing.py,sha256=0znYkuFi8-WjOdbwrTbNC-UpMqG3EXcGOE0wxlERh_A,1464
-universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/utils/openapi/api_generator.py,sha256=FjtvbnWuI1P8W8wXuKLCirUtsqQ4HI_TuQrhpA4SqTs,4749
-universal_mcp/utils/openapi/api_splitter.py,sha256=0hoq6KMcDVA5NynDBrFjjqjDugZvaWGBdfLzvyLkFAM,20968
-universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=8TV7L1Wm9_mi_1iy0ccf_4H39XLuZjIinBnJ56H-ggw,51197
-universal_mcp/utils/openapi/preprocessor.py,sha256=PPIM3Uu8DYi3dRKdqi9thr9ufeUgkr2K08ri1BwKpoQ,60835
-universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
-universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
-universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.23rc2.dist-info/METADATA,sha256=oRusZjRll0c923kS-RTc64lZw_XTVk8NSuv1gKis1Lk,12154
-universal_mcp-0.1.23rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.23rc2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.23rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.23rc2.dist-info/RECORD,,