universal-mcp 0.1.18rc2__tar.gz → 0.1.18rc3__tar.gz

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.18rc2
+Version: 0.1.18rc3
 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

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.18-rc2"
+version = "0.1.18-rc3"
 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 = [

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/src/universal_mcp/applications/__init__.py

@@ -1,4 +1,5 @@
 import importlib
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -34,8 +35,12 @@ def _install_or_upgrade_package(package_name: str, repository_path: str):
     """
     Helper to install a package via pip from the universal-mcp GitHub repository.
     """
+
+    uv_path = os.getenv("UV_PATH")
+    uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
+    logger.info(f"Using uv executable: {uv_executable}")
     cmd = [
-        "uv",
+        uv_executable,
         "pip",
         "install",
         "--upgrade",

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/src/universal_mcp/applications/application.py

@@ -169,14 +169,28 @@ class APIApplication(BaseApplication):
         logger.debug(f"GET request successful with status code: {response.status_code}")
         return response
 
-    def _post(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
+    def _post(
+        self,
+        url: str,
+        data: Any,
+        params: dict[str, Any] | None = None,
+        content_type: str = "application/json",
+        files: dict[str, Any] | None = None,
+    ) -> httpx.Response:
         """
         Make a POST request to the specified URL.
 
         Args:
             url: The URL to send the request to
-            data: The data to send in the request body
+            data: The data to send. For 'application/json', this is JSON-serializable.
+                  For 'application/x-www-form-urlencoded' or 'multipart/form-data', this is a dict of form fields.
+                  For other content types, this is raw bytes or string.
             params: Optional query parameters
+            content_type: The Content-Type of the request body.
+                         Examples: 'application/json', 'application/x-www-form-urlencoded',
+                                   'multipart/form-data', 'application/octet-stream', 'text/plain'.
+            files: Optional dictionary of files to upload for 'multipart/form-data'.
+                   Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
             httpx.Response: The response from the server
@@ -184,25 +198,69 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(f"Making POST request to {url} with params: {params} and data: {data}")
-        response = httpx.post(
-            url,
-            headers=self._get_headers(),
-            json=data,
-            params=params,
+        logger.debug(
+            f"Making POST request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
         )
+        headers = self._get_headers().copy()
+
+        if content_type != "multipart/form-data":
+            headers["Content-Type"] = content_type
+
+        if content_type == "multipart/form-data":
+            response = self.client.post(
+                url,
+                headers=headers,
+                data=data,  # For regular form fields
+                files=files,  # For file parts
+                params=params,
+            )
+        elif content_type == "application/x-www-form-urlencoded":
+            response = self.client.post(
+                url,
+                headers=headers,
+                data=data,
+                params=params,
+            )
+        elif content_type == "application/json":
+            response = self.client.post(
+                url,
+                headers=headers,
+                json=data,
+                params=params,
+            )
+        else:  # Handles 'application/octet-stream', 'text/plain', 'image/jpeg', etc.
+            response = self.client.post(
+                url,
+                headers=headers,
+                content=data,  # Expect data to be bytes or str
+                params=params,
+            )
         response.raise_for_status()
         logger.debug(f"POST request successful with status code: {response.status_code}")
         return response
 
-    def _put(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
+    def _put(
+        self,
+        url: str,
+        data: Any,
+        params: dict[str, Any] | None = None,
+        content_type: str = "application/json",
+        files: dict[str, Any] | None = None,
+    ) -> httpx.Response:
         """
         Make a PUT request to the specified URL.
 
         Args:
             url: The URL to send the request to
-            data: The data to send in the request body
+            data: The data to send. For 'application/json', this is JSON-serializable.
+                  For 'application/x-www-form-urlencoded' or 'multipart/form-data', this is a dict of form fields.
+                  For other content types, this is raw bytes or string.
             params: Optional query parameters
+            content_type: The Content-Type of the request body.
+                         Examples: 'application/json', 'application/x-www-form-urlencoded',
+                                   'multipart/form-data', 'application/octet-stream', 'text/plain'.
+            files: Optional dictionary of files to upload for 'multipart/form-data'.
+                   Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
             httpx.Response: The response from the server
@@ -210,12 +268,44 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(f"Making PUT request to {url} with params: {params} and data: {data}")
-        response = self.client.put(
-            url,
-            json=data,
-            params=params,
+        logger.debug(
+            f"Making PUT request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
         )
+        headers = self._get_headers().copy()
+        # For multipart/form-data, httpx handles the Content-Type header (with boundary)
+        # For other content types, we set it explicitly.
+        if content_type != "multipart/form-data":
+            headers["Content-Type"] = content_type
+
+        if content_type == "multipart/form-data":
+            response = self.client.put(
+                url,
+                headers=headers,
+                data=data,  # For regular form fields
+                files=files,  # For file parts
+                params=params,
+            )
+        elif content_type == "application/x-www-form-urlencoded":
+            response = self.client.put(
+                url,
+                headers=headers,
+                data=data,
+                params=params,
+            )
+        elif content_type == "application/json":
+            response = self.client.put(
+                url,
+                headers=headers,
+                json=data,
+                params=params,
+            )
+        else:  # Handles 'application/octet-stream', 'text/plain', 'image/jpeg', etc.
+            response = self.client.put(
+                url,
+                headers=headers,
+                content=data,  # Expect data to be bytes or str
+                params=params,
+            )
         response.raise_for_status()
         logger.debug(f"PUT request successful with status code: {response.status_code}")
         return response

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/src/universal_mcp/cli.py

@@ -45,14 +45,26 @@ def generate(
         raise typer.Exit(1)
 
     try:
-        # Run the async function in the event loop
-        app_file = generate_api_from_schema(
+        app_file_data = generate_api_from_schema(
             schema_path=schema_path,
             output_path=output_path,
             class_name=class_name,
         )
-        console.print("[green]API client successfully generated and installed.[/green]")
-        console.print(f"[blue]Application file: {app_file}[/blue]")
+        if isinstance(app_file_data, dict) and "code" in app_file_data:
+            console.print("[yellow]No output path specified, printing generated code to console:[/yellow]")
+            console.print(app_file_data["code"])
+        elif isinstance(app_file_data, Path):
+            console.print("[green]API client successfully generated and installed.[/green]")
+            console.print(f"[blue]Application file: {app_file_data}[/blue]")
+        else:
+            # Handle the error case from api_generator if validation fails
+            if isinstance(app_file_data, dict) and "error" in app_file_data:
+                 console.print(f"[red]{app_file_data['error']}[/red]")
+                 raise typer.Exit(1)
+            else:
+                console.print("[red]Unexpected return value from API generator.[/red]")
+                raise typer.Exit(1)
+
     except Exception as e:
         console.print(f"[red]Error generating API client: {e}[/red]")
         raise typer.Exit(1) from e
@@ -255,5 +267,33 @@ def preprocess(
     run_preprocessing(schema_path, output_path)
 
 
+@app.command()
+def split_api(
+    input_app_file: Path = typer.Argument(..., help="Path to the generated app.py file to split"),
+    output_dir: Path = typer.Option(..., "--output-dir", "-o", help="Directory to save the split files"),
+):
+    """Splits a single generated API client file into multiple files based on path groups."""
+    from universal_mcp.utils.openapi.api_splitter import split_generated_app_file
+
+    if not input_app_file.exists() or not input_app_file.is_file():
+        console.print(f"[red]Error: Input file {input_app_file} does not exist or is not a file.[/red]")
+        raise typer.Exit(1)
+
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True, exist_ok=True)
+        console.print(f"[green]Created output directory: {output_dir}[/green]")
+    elif not output_dir.is_dir():
+        console.print(f"[red]Error: Output path {output_dir} is not a directory.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        split_generated_app_file(input_app_file, output_dir)
+        console.print(f"[green]Successfully split {input_app_file} into {output_dir}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error splitting API client: {e}[/red]")
+      
+        raise typer.Exit(1) from e
+
+
 if __name__ == "__main__":
     app()

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/src/universal_mcp/config.py

@@ -49,7 +49,9 @@ class ServerConfig(BaseSettings):
     description: str = Field(default="Universal MCP", description="Description of the MCP server")
     api_key: SecretStr | None = Field(default=None, description="API key for authentication")
     type: Literal["local", "agentr"] = Field(default="agentr", description="Type of server deployment")
-    transport: Literal["stdio", "sse", "http"] = Field(default="stdio", description="Transport protocol to use")
+    transport: Literal["stdio", "sse", "streamable-http"] = Field(
+        default="stdio", description="Transport protocol to use"
+    )
     port: int = Field(default=8005, description="Port to run the server on (if applicable)")
     host: str = Field(default="localhost", description="Host to bind the server to (if applicable)")
     apps: list[AppConfig] | None = Field(default=None, description="List of configured applications")

{universal_mcp-0.1.18rc2 → universal_mcp-0.1.18rc3}/src/universal_mcp/utils/installation.py

@@ -47,7 +47,7 @@ def _generate_mcp_config(api_key: str) -> None:
         "args": ["universal_mcp@latest", "run"],
         "env": {
             "AGENTR_API_KEY": api_key,
-            "PATH": str(uvx_path.parent),
+            "UV_PATH": str(uvx_path.parent),
         },
     }