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

universal_mcp/applications/sample_tool_app.py

@@ -0,0 +1,80 @@
+import datetime
+
+from universal_mcp.applications.application import BaseApplication
+
+
+class SampleToolApp(BaseApplication):
+    """A sample application providing basic utility tools."""
+
+    def __init__(self):
+        """Initializes the SampleToolApp with the name 'sample_tool_app'."""
+        super().__init__("sample_tool_app")
+
+    def get_current_time(self):
+        """Get the current system time as a formatted string.
+
+        Returns:
+            str: The current time in the format 'YYYY-MM-DD HH:MM:SS'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def get_current_date(self):
+        """Get the current system date as a formatted string.
+
+        Returns:
+            str: The current date in the format 'YYYY-MM-DD'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d")
+
+    def calculate(self, expression: str):
+        """Safely evaluate a mathematical expression.
+
+        Args:
+            expression (str): The mathematical expression to evaluate.
+
+        Returns:
+            str: The result of the calculation, or an error message if evaluation fails.
+        """
+        try:
+            # Safe evaluation of mathematical expressions
+            result = eval(expression, {"__builtins__": {}}, {})
+            return f"Result: {result}"
+        except Exception as e:
+            return f"Error in calculation: {str(e)}"
+
+    def file_operations(self, operation: str, filename: str, content: str = ""):
+        """Perform file read or write operations.
+
+        Args:
+            operation (str): The operation to perform, either 'read' or 'write'.
+            filename (str): The name of the file to operate on.
+            content (str, optional): The content to write to the file (used only for 'write'). Defaults to "".
+
+        Returns:
+            str: The result of the file operation, or an error message if the operation fails.
+        """
+        try:
+            if operation == "read":
+                with open(filename) as f:
+                    return f"File content:\n{f.read()}"
+            elif operation == "write":
+                with open(filename, "w") as f:
+                    f.write(content)
+                return f"Successfully wrote to {filename}"
+            else:
+                return "Invalid operation. Use 'read' or 'write'"
+        except Exception as e:
+            return f"File operation error: {str(e)}"
+
+    def list_tools(self):
+        """List all available tool methods in this application.
+
+        Returns:
+            list: A list of callable tool methods.
+        """
+        return [
+            self.get_current_time,
+            self.get_current_date,
+            self.calculate,
+            self.file_operations,
+        ]

universal_mcp/cli.py

@@ -1,113 +1,22 @@
-import re
 from pathlib import Path
 
 import typer
 from rich.console import Console
 from rich.panel import Panel
 
+from universal_mcp.client.cli import app as client_app
 from universal_mcp.utils.installation import (
     get_supported_apps,
     install_app,
 )
+from universal_mcp.utils.openapi.cli import app as codegen_app
 
 # Setup rich console and logging
 console = Console()
 
-app = typer.Typer()
-
-
-@app.command()
-def generate(
-    schema_path: Path = typer.Option(..., "--schema", "-s"),
-    output_path: Path = typer.Option(
-        None,
-        "--output",
-        "-o",
-        help="Output file path - should match the API name (e.g., 'twitter.py' for Twitter API)",
-    ),
-    class_name: str = typer.Option(
-        None,
-        "--class-name",
-        "-c",
-        help="Class name to use for the API client",
-    ),
-):
-    """Generate API client from OpenAPI schema with optional docstring generation.
-
-    The output filename should match the name of the API in the schema (e.g., 'twitter.py' for Twitter API).
-    This name will be used for the folder in applications/.
-    """
-    # Import here to avoid circular imports
-    from universal_mcp.utils.openapi.api_generator import generate_api_from_schema
-
-    if not schema_path.exists():
-        console.print(f"[red]Error: Schema file {schema_path} does not exist[/red]")
-        raise typer.Exit(1)
-
-    try:
-        app_file_data = generate_api_from_schema(
-            schema_path=schema_path,
-            output_path=output_path,
-            class_name=class_name,
-        )
-        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
-
-
-@app.command()
-def readme(
-    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
-):
-    """Generate a README.md file for the API client."""
-    from universal_mcp.utils.openapi.readme import generate_readme
-
-    readme_file = generate_readme(file_path)
-    console.print(f"[green]README.md file generated at: {readme_file}[/green]")
-
-
-@app.command()
-def docgen(
-    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
-    model: str = typer.Option(
-        "perplexity/sonar",
-        "--model",
-        "-m",
-        help="Model to use for generating docstrings",
-    ),
-):
-    """Generate docstrings for Python files using LLMs.
-
-    This command uses litellm with structured output to generate high-quality
-    Google-style docstrings for all functions in the specified Python file.
-    """
-    from universal_mcp.utils.openapi.docgen import process_file
-
-    if not file_path.exists():
-        console.print(f"[red]Error: File not found: {file_path}[/red]")
-        raise typer.Exit(1)
-
-    try:
-        processed = process_file(str(file_path), model)
-        console.print(f"[green]Successfully processed {processed} functions[/green]")
-    except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
-        raise typer.Exit(1) from e
+app = typer.Typer(name="mcp")
+app.add_typer(codegen_app, name="codegen", help="Code generation and manipulation commands")
+app.add_typer(client_app, name="client", help="Client commands")
 
 
 @app.command()
@@ -162,137 +71,5 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
         raise typer.Exit(1) from e
 
 
-@app.command()
-def init(
-    output_dir: Path | None = typer.Option(
-        None,
-        "--output-dir",
-        "-o",
-        help="Output directory for the project (must exist)",
-    ),
-    app_name: str | None = typer.Option(
-        None,
-        "--app-name",
-        "-a",
-        help="App name (letters, numbers, hyphens, underscores only)",
-    ),
-    integration_type: str | None = typer.Option(
-        None,
-        "--integration-type",
-        "-i",
-        help="Integration type (api_key, oauth, agentr, none)",
-        case_sensitive=False,
-        show_choices=True,
-    ),
-):
-    """Initialize a new MCP project using the cookiecutter template."""
-    from cookiecutter.main import cookiecutter
-
-    NAME_PATTERN = r"^[a-zA-Z0-9_-]+$"
-
-    def validate_pattern(value: str, field_name: str) -> None:
-        if not re.match(NAME_PATTERN, value):
-            console.print(
-                f"[red]❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.[/red]"
-            )
-            raise typer.Exit(code=1)
-
-    # App name
-    if not app_name:
-        app_name = typer.prompt(
-            "Enter the app name",
-            default="app_name",
-            prompt_suffix=" (e.g., reddit, youtube): ",
-        ).strip()
-    validate_pattern(app_name, "app name")
-    app_name = app_name.lower()
-    if not output_dir:
-        path_str = typer.prompt(
-            "Enter the output directory for the project",
-            default=str(Path.cwd()),
-            prompt_suffix=": ",
-        ).strip()
-        output_dir = Path(path_str)
-
-    if not output_dir.exists():
-        try:
-            output_dir.mkdir(parents=True, exist_ok=True)
-            console.print(f"[green]✅ Created output directory at '{output_dir}'[/green]")
-        except Exception as e:
-            console.print(f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]")
-            raise typer.Exit(code=1) from e
-    elif not output_dir.is_dir():
-        console.print(f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]")
-        raise typer.Exit(code=1)
-
-    # Integration type
-    if not integration_type:
-        integration_type = typer.prompt(
-            "Choose the integration type",
-            default="agentr",
-            prompt_suffix=" (api_key, oauth, agentr, none): ",
-        ).lower()
-    if integration_type not in ("api_key", "oauth", "agentr", "none"):
-        console.print("[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]")
-        raise typer.Exit(code=1)
-
-    console.print("[blue]🚀 Generating project using cookiecutter...[/blue]")
-    try:
-        cookiecutter(
-            "https://github.com/AgentrDev/universal-mcp-app-template.git",
-            output_dir=str(output_dir),
-            no_input=True,
-            extra_context={
-                "app_name": app_name,
-                "integration_type": integration_type,
-            },
-        )
-    except Exception as exc:
-        console.print(f"❌ Project generation failed: {exc}")
-        raise typer.Exit(code=1) from exc
-
-    project_dir = output_dir / f"{app_name}"
-    console.print(f"✅ Project created at {project_dir}")
-
-
-@app.command()
-def preprocess(
-    schema_path: Path = typer.Option(None, "--schema", "-s", help="Path to the OpenAPI schema file."),
-    output_path: Path = typer.Option(None, "--output", "-o", help="Path to save the processed schema."),
-):
-    from universal_mcp.utils.openapi.preprocessor import run_preprocessing
-
-    """Preprocess an OpenAPI schema using LLM to fill or enhance descriptions."""
-    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/client/agents/__init__.py

@@ -0,0 +1,4 @@
+from .base import AgentType, BaseAgent
+from .react import ReActAgent
+
+__all__ = ["AgentType", "BaseAgent", "ReActAgent"]

universal_mcp/client/agents/base.py

@@ -0,0 +1,38 @@
+# agents/base.py
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+from universal_mcp.tools.manager import ToolManager
+
+
+class AgentType(Enum):
+    REACT = "react"
+    CODEACT = "codeact"
+    SIMPLE = "simple"
+
+
+class AgentResponse(BaseModel):
+    thought: str | None = None
+    action: str | None = None
+    action_input: dict[str, Any] | None = None
+    observation: str | None = None
+    answer: str | None = None
+    finished: bool = False
+
+
+class BaseAgent(ABC):
+    def __init__(self, name: str, instructions: str, model: str, debug: bool = False):
+        self.name = name
+        self.instructions = instructions
+        self.model = model
+        self.conversation_history: list[dict[str, Any]] = []
+
+    @abstractmethod
+    def process_step(self, user_input: str, tool_manager: ToolManager):
+        pass
+
+    def reset_conversation(self):
+        self.conversation_history = []

universal_mcp/client/agents/llm.py

@@ -0,0 +1,115 @@
+import json
+from typing import Any
+
+from loguru import logger
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionToolParam,
+)
+
+from universal_mcp.tools.adapters import ToolFormat
+from universal_mcp.tools.manager import ToolManager
+
+
+class LLMClient:
+    def __init__(self, model: str):
+        self.model = model
+        self.client = OpenAI()
+        logger.info(f"LLMClient initialized with model: {self.model}")
+
+    async def generate_response(
+        self,
+        messages: list[dict[str, str]],
+        tools: list[ChatCompletionToolParam] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1000,
+    ) -> ChatCompletionMessage:
+        """Generate response using OpenAI with native tool calling"""
+        try:
+            logger.debug(f"Generating response with messages: {messages}")
+            kwargs = {"model": self.model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
+            if tools:
+                kwargs["tools"] = tools
+                kwargs["tool_choice"] = "auto"
+                logger.debug(f"Using tools: {tools}")
+            response: ChatCompletion = self.client.chat.completions.create(**kwargs)
+            logger.debug(f"OpenAI response: {response}")
+            choice = response.choices[0]
+            message: ChatCompletionMessage = choice.message
+            logger.info(f"Generated message: {message}")
+            return message
+        except Exception as e:
+            logger.error(f"Error in generate_response: {e}")
+            raise e
+
+    async def handle_tool_calls(
+        self, tool_calls: list[ChatCompletionToolParam], tool_manager: ToolManager
+    ) -> list[dict[str, Any]]:
+        """Handle tool calls"""
+        messages: list[dict[str, Any]] = []
+        for tool_call in tool_calls:
+            tool_name = tool_call.function.name
+            tool_args = tool_call.function.arguments
+            logger.info(f"Handling tool call: {tool_name} with args: {tool_args}")
+            tool_result = await tool_manager.call_tool(tool_name, tool_args)
+            logger.debug(f"Tool result for {tool_name}: {tool_result}")
+            messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(tool_result)})
+        return messages
+
+    async def generate_response_with_tool_results(
+        self, messages: list[dict[str, str]], tool_manager: ToolManager, max_iterations: int = 5
+    ) -> ChatCompletionMessage:
+        """Handle complete tool calling conversation loop using OpenAI"""
+        conversation = messages.copy()
+        iteration = 0
+        tools = tool_manager.list_tools(format=ToolFormat.OPENAI)
+        logger.info(f"Starting tool calling loop with max_iterations={max_iterations}")
+
+        while iteration < max_iterations:
+            iteration += 1
+            logger.info(f"Iteration {iteration}: Generating response with conversation: {conversation}")
+
+            # Generate response with tools
+            response = await self.generate_response(conversation, tools)
+
+            # If no tool calls, return the response
+            tool_calls = response.tool_calls
+            if not tool_calls:
+                logger.info("No tool calls detected, returning response.")
+                return response
+
+            logger.info(f"Tool calls detected: {tool_calls}")
+
+            # Add assistant message with tool calls
+            assistant_msg = {"role": "assistant", "content": response.content}
+            if tool_calls:
+                assistant_msg["tool_calls"] = tool_calls
+            conversation.append(assistant_msg)
+
+            # Execute tool calls and add results
+            for tool_call in tool_calls:
+                function = tool_call.function
+                tool_name = function.name
+                arguments = function.arguments
+                logger.info(f"Executing tool: {tool_name} with arguments: {arguments}")
+                try:
+                    tool_args = json.loads(arguments)
+                except Exception as e:
+                    logger.warning(f"Failed to parse tool arguments as JSON: {arguments}. Error: {e}")
+                    tool_args = {"query": arguments}
+                # Execute the tool
+                try:
+                    tool_result = await tool_manager.call_tool(tool_name, tool_args)
+                    logger.debug(f"Tool result for {tool_name}: {tool_result}")
+                except Exception as e:
+                    logger.error(f"Error executing tool {tool_name}: {e}")
+                    tool_result = f"Error executing tool {tool_name}: {e}"
+                # Add tool result to conversation
+                conversation.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(tool_result)})
+            # Continue the conversation loop
+
+        logger.info("Max iterations reached or tool loop complete. Generating final response.")
+        # Final response after tool execution
+        return await self.generate_response(conversation)

universal_mcp/client/agents/react.py

@@ -0,0 +1,67 @@
+from loguru import logger
+
+from universal_mcp.tools.manager import ToolManager
+
+from .base import BaseAgent
+from .llm import LLMClient
+
+
+class ReActAgent(BaseAgent):
+    def __init__(self, name: str, instructions: str, model: str):
+        super().__init__(name, instructions, model)
+        self.llm_client = LLMClient(model)
+        self.max_iterations = 10
+        logger.debug(f"Initialized ReActAgent: name={name}, model={model}")
+
+    def _build_system_message(self) -> str:
+        system_message = f"""You are {self.name}. {self.instructions}
+
+You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
+
+1. Think about what information you need
+2. Call the appropriate tool with the right parameters
+3. Use the tool results to provide a comprehensive answer
+
+Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so."""
+        logger.debug(f"System message built: {system_message}")
+        return system_message
+
+    def _build_messages(self, user_input: str) -> list[dict[str, str]]:
+        """Build message history for the conversation"""
+        messages = [{"role": "system", "content": self._build_system_message()}]
+
+        # Add conversation history
+        for entry in self.conversation_history:
+            messages.append({"role": "user", "content": entry["human"]})
+            messages.append({"role": "assistant", "content": entry["assistant"]})
+
+        # Add current user input
+        messages.append({"role": "user", "content": user_input})
+
+        logger.debug(f"Built messages for user_input='{user_input}': {messages}")
+        return messages
+
+    async def process_step(self, user_input: str, tool_manager: ToolManager) -> str:
+        """Process user input using native tool calling"""
+
+        logger.info(f"Processing user input: {user_input}")
+
+        # Build conversation messages
+        messages = self._build_messages(user_input)
+
+        # Use native tool calling with conversation loop
+        try:
+            response = await self.llm_client.generate_response_with_tool_results(
+                messages, tool_manager, self.max_iterations
+            )
+            final_answer = response.content
+            logger.info(f"LLM response received: {final_answer}")
+        except Exception as e:
+            logger.error(f"Error during LLM response generation: {e}")
+            raise
+
+        # Store in conversation history
+        self.conversation_history.append({"human": user_input, "assistant": final_answer})
+        logger.debug(f"Updated conversation history: {self.conversation_history[-1]}")
+
+        return final_answer