universal-mcp-agents 0.1.18__tar.gz → 0.1.19__tar.gz

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.18
+Version: 0.1.19
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

universal_mcp_agents-0.1.19/bech.py

@@ -0,0 +1,38 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents import get_agent
+from langgraph.checkpoint.memory import MemorySaver
+from universal_mcp.agents.utils import messages_to_list
+import time
+from loguru import logger
+
+
+async def main():
+    start_time = time.time()
+    memory = MemorySaver()
+    logger.info(f"Checkpointer: Time consumed: {time.time() - start_time}")
+    agent_cls = get_agent("codeact-repl")
+    logger.info(f"Get class: Time consumed: {time.time() - start_time}")
+    registry = AgentrRegistry()
+    logger.info(f"Init Registry: Time consumed: {time.time() - start_time}")
+    agent = agent_cls(
+        name="CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="anthropic:claude-4-sonnet-20250514",
+        tools={},
+        registry=registry,
+        memory=memory,
+    )
+    logger.info(f"Create agent: Time consumed: {time.time() - start_time}")
+    print("Init agent...")
+    await agent.ainit()
+    logger.info(f"Init Agent: Time consumed: {time.time() - start_time}")
+    print("Starting agent...")
+    async for e in agent.stream(user_input="hi"):
+        logger.info(f"First token: Time consumed: {time.time() - start_time}")
+        print(e)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.18"
+version = "0.1.19"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -70,7 +70,7 @@ lint.ignore = [
 
 [tool.ruff.lint.pylint]
 max-args = 10
-max-statements = 85
+max-statements = 118
 max-returns = 10
 max-branches = 37
 

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/__init__.py

@@ -9,7 +9,9 @@ from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
 
 
-def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"]):
+def get_agent(
+    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"],
+):
     if agent_name == "react":
         return ReactAgent
     elif agent_name == "simple":

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/base.py

@@ -49,8 +49,11 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
+            "recursion_limit": 25,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
+            "run_id": thread_id,
+            "run_name": self.name,
         }
 
         async for event, meta in self._graph.astream(

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/cli.py

@@ -28,9 +28,6 @@ def run(name: str = "react"):
         "model": "anthropic/claude-sonnet-4-20250514",
         "registry": AgentrRegistry(client=client),
         "memory": MemorySaver(),
-        "tools": {
-            "google_mail": ["send_email"],
-        },
     }
     agent_cls = get_agent(name)
     agent = agent_cls(name=name, **params)

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/codeact0/__main__.py

@@ -19,12 +19,6 @@ async def main():
         memory=memory,
     )
     print("Starting agent...")
-    # await agent.ainit()
-    # await agent.run_interactive()
-    # async for event in agent.stream(
-    #     user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
-    # ):
-    #     print(event.content, end="")
     result = await agent.invoke(
         user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
     )

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/codeact0/llm_tool.py

@@ -27,7 +27,7 @@ def smart_print(data: Any) -> None:
     Args:
         data: Either a dictionary with string keys, or a list of such dictionaries
     """
-    print(light_copy(data))  # noqa
+    print(light_copy(data))  # noqa: T201
 
 
 def creative_writer(
@@ -275,105 +275,3 @@ def data_extractor(
         .invoke(prompt)
     )
     return cast(dict[str, Any], response)
-
-
-# news_articles_schema = {
-#     "type": "object",
-#     "properties": {
-#         "articles": {
-#             "type": "array",
-#             "title": "Articles",
-#             "description": "List of news articles",
-#             "items": {
-#                 "type": "object",
-#                 "properties": {
-#                     "headline": {
-#                         "type": "string",
-#                         "title": "Headline",
-#                         "description": "The headline of the news article"
-#                     },
-#                     "url": {
-#                         "type": "string",
-#                         "title": "URL",
-#                         "description": "The URL of the news article"
-#                     }
-#                 },
-#                 "required": ["headline", "url"],
-#             }
-#         }
-#     },
-#     "required": ["articles"],
-# }
-
-
-# news_articles_schema = {
-#   "title": "NewsArticleList",
-#   "description": "A list of news articles with headlines and URLs",
-#   "type": "object",
-#   "properties": {
-#     "articles": {
-#       "type": "array",
-#       "items": {
-#         "type": "object",
-#         "properties": {
-#           "headline": {
-#             "type": "string"
-#           },
-#           "url": {
-#             "type": "string"
-#           }
-#         },
-#         "required": ["headline", "url"]
-#       }
-#     }
-#   },
-#   "required": ["articles"]
-# }
-# model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-# structured_model = model.with_structured_output(news_articles_schema)
-
-
-# class TwitterComment(BaseModel):
-#     skip: bool
-#     reason: str
-#     comment: str
-
-# twitter_comment_schema = {
-#   "title": "TwitterComment",
-#   "description": "A twitter comment to engage with followers",
-#   "type": "object",
-#   "properties": {
-#     "skip": {
-#       "type": "boolean"
-#     },
-#     "reason": {
-#       "type": "string"
-#     },
-#     "comment": {
-#       "type": "string"
-#     },
-#     "tagged_profiles": {
-#       "type": "array",
-#       "items": {
-#         "type": "string"
-#       }
-#     }
-#   },
-#   "required": ["skip", "reason"]
-# }
-
-# comment = {
-#     "tweet_id": "08109402",
-#     "handle": "@iamnishant",
-#     "text": "Hey really loved this tweet! Well said 💯"
-# }
-
-# comment_instructions = (
-#     "Goal is to engage with my twitter followers who have commented on my tweets."
-#     "Please generate a single line, context-aware, conversational reply for the given comment."
-#     "- Use social media language (can use hinglish)."
-#     "- Skip the reply, if the comment is too generic."
-#     "- Also tag relevant people in the reply."
-# )
-
-# my_reply = call_llm(comment_instructions, comment, twitter_comment_schema)

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/codeact0/playbook_agent.py

@@ -81,7 +81,7 @@ class CodeActPlaybookAgent(BaseAgent):
             memory=memory,
             **kwargs,
         )
-        self.model_instance = load_chat_model(model, thinking=True)
+        self.model_instance = load_chat_model(model)
         self.tools_config = tools or []
         self.registry = registry
         self.playbook_registry = playbook_registry
@@ -184,8 +184,13 @@ class CodeActPlaybookAgent(BaseAgent):
                             ai_msg = f"Please login to the following app(s) using the following links and let me know in order to proceed:\n {links} "
                     elif tool_call["name"] == "search_functions":
                         tool_result = await meta_tools["search_functions"].ainvoke(tool_call["args"])
+                    else:
+                        raise Exception(
+                            f"Unexpected tool call: {tool_call['name']}. "
+                            "tool calls must be one of 'enter_playbook_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'"
+                        )
                 except Exception as e:
-                    tool_result = f"Error during {tool_call}: {e}"
+                    tool_result = str(e)
 
                 tool_message = ToolMessage(
                     content=json.dumps(tool_result),

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/codeact0/prompts.py

@@ -13,7 +13,10 @@ Your job is to answer the user's question or perform the task they ask for.
 - Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly.
 - For task requiring operations or access to external resources, you should achieve the task by executing Python code snippets.
 - You have access to `execute_ipython_cell` tool that allows you to execute Python code in an IPython notebook cell.
-- You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications. Prefer pre-loaded or functions already available when possible, and prioritize connected applications over unconnected ones. When this is not enough to break a tie between similar applications, ask the user.
+- You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications.
+    - Prefer pre-loaded or functions already available when possible.
+    - Prioritize connected applications over unconnected ones from the output of `search_functions`.
+    - When multiple apps are connected, or none of the apps are connected, ask the user to choose the application(s).
 - In writing or natural language processing tasks DO NOT answer directly. Instead use `execute_ipython_cell` tool with the AI functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc. Avoid hardcoded approaches to classification, data extraction.
 - The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code. variables, functions, imports are retained.
 - Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format.

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19}/src/universal_mcp/agents/codeact0/tools.py

@@ -55,6 +55,9 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
 
             # Build result string efficiently
             result_parts = []
+            apps_in_results = set(app_tools.keys())
+            connected_apps_in_results = apps_in_results.intersection(connected_apps)
+            
             for app, tools in app_tools.items():
                 app_status = "connected" if app in connected_apps else "NOT connected"
                 result_parts.append(f"Tools from {app} (status: {app_status} by user):")
@@ -63,6 +66,13 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
                     result_parts.append(f" - {tool}")
                 result_parts.append("")  # Empty line between apps
 
+            # Add connection status information
+            if len(connected_apps_in_results) == 0 and len(apps_in_results) > 0:
+                result_parts.append("Connection Status: None of the apps in the results are connected. You must ask the user to choose the application.")
+            elif len(connected_apps_in_results) > 1:
+                connected_list = ", ".join(connected_apps_in_results)
+                result_parts.append(f"Connection Status: Multiple apps are connected ({connected_list}). You must ask the user to select which application they want to use.")
+
             result_parts.append("Call load_functions to select the required functions only.")
             return "\n".join(result_parts)
 

universal_mcp_agents-0.1.19/src/universal_mcp/agents/sandbox.py

@@ -0,0 +1,90 @@
+import contextlib
+import inspect
+import io
+import queue
+import re
+import socket
+import threading
+import types
+from typing import Any
+
+from universal_mcp.agents.codeact0.utils import derive_context
+
+
+class Sandbox:
+    """
+    A class to execute code safely in a sandboxed environment with a timeout.
+    """
+
+    def __init__(self, timeout: int = 180):
+        """
+        Initializes the Sandbox.
+        Args:
+            timeout: The timeout for code execution in seconds.
+        """
+        self.timeout = timeout
+        self._locals: dict[str, Any] = {}
+        self.add_context: dict[str, Any] = {}
+
+    def run(self, code: str) -> tuple[str, dict[str, Any], dict[str, Any]]:
+        """
+        Execute code safely with a timeout.
+        - Returns (output_str, filtered_locals_dict, new_add_context)
+        - Errors or timeout are returned as output_str.
+        - Previous variables in _locals persist across calls.
+        """
+
+        EXCLUDE_TYPES = (
+            types.ModuleType,
+            type(re.match("", "")),
+            type(threading.Lock()),
+            type(threading.RLock()),
+            threading.Event,
+            threading.Condition,
+            threading.Semaphore,
+            queue.Queue,
+            socket.socket,
+            io.IOBase,
+        )
+
+        result_container = {"output": "<no output>"}
+
+        def target():
+            try:
+                with contextlib.redirect_stdout(io.StringIO()) as f:
+                    exec(code, self._locals, self._locals)
+                result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"
+            except Exception as e:
+                result_container["output"] = "Error during execution: " + str(e)
+
+        thread = threading.Thread(target=target)
+        thread.start()
+        thread.join(self.timeout)
+
+        if thread.is_alive():
+            result_container["output"] = f"Code timeout: code execution exceeded {self.timeout} seconds."
+
+        # Filter locals for picklable/storable variables
+        all_vars = {}
+        for key, value in self._locals.items():
+            if key == "__builtins__":
+                continue
+            if inspect.iscoroutine(value) or inspect.iscoroutinefunction(value):
+                continue
+            if inspect.isasyncgen(value) or inspect.isasyncgenfunction(value):
+                continue
+            if isinstance(value, EXCLUDE_TYPES):
+                continue
+            if not callable(value) or not hasattr(value, "__name__"):
+                all_vars[key] = value
+
+        self._locals = all_vars
+
+        # Safely derive context
+        try:
+            self.add_context = derive_context(code, self.add_context)
+        except Exception:
+            # Keep the old context if derivation fails
+            pass
+
+        return result_container["output"], self._locals, self.add_context

universal_mcp_agents-0.1.19/src/universal_mcp/applications/filesystem/app.py

@@ -0,0 +1,160 @@
+import fnmatch
+import os
+import pathlib
+import re
+import uuid
+
+from loguru import logger
+from universal_mcp.applications.application import BaseApplication
+
+
+class FileSystemApp(BaseApplication):
+    """
+    A class to safely interact with the filesystem within a specified working directory.
+    """
+
+    def __init__(self, working_dir: str | None = None, **kwargs):
+        """
+        Initializes the FileSystemApp with a working directory.
+
+        Args:
+            working_dir: The absolute path to the directory where all operations will be performed.
+        """
+        super().__init__(name="Filesystem")
+
+        self.set_working_dir(working_dir or f"/tmp/{uuid.uuid4()}")
+
+    def set_working_dir(self, working_dir: str):
+        self.working_dir = pathlib.Path(working_dir).absolute()
+        # Create dir if not exists
+        self.working_dir.mkdir(parents=True, exist_ok=True)
+
+    def _is_safe_path(self, path: str) -> bool:
+        """
+        Checks if the given path is within the working directory.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            True if the path is safe, False otherwise.
+        """
+        common_path = os.path.commonpath([self.working_dir, path])
+        return common_path == str(self.working_dir)
+
+    def create_file(self, path: str, content: str = "") -> None:
+        """
+        Creates a file with the given content.
+
+        Args:
+            path: The relative path to the file to create.
+            content: The content to write to the file.
+
+        Raises:
+            ValueError: If the path is outside the working directory.
+        """
+        if not self._is_safe_path(path):
+            error = f"Path is outside the working directory: {path} vs {self.working_dir}"
+            logger.error(error)
+            raise ValueError(error)
+
+        full_path = os.path.join(self.working_dir, path)
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        with open(full_path, "w") as f:
+            f.write(content)
+
+    def read_file(self, path: str) -> str:
+        """
+        Reads the content of a file.
+
+        Args:
+            path: The relative path to the file to read.
+
+        Returns:
+            The content of the file.
+
+        Raises:
+            ValueError: If the path is outside the working directory.
+            FileNotFoundError: If the file does not exist.
+        """
+        if not self._is_safe_path(path):
+            raise ValueError("Path is outside the working directory.")
+
+        full_path = os.path.join(self.working_dir, path)
+        if not os.path.exists(full_path):
+            raise FileNotFoundError(f"File not found: {full_path}")
+
+        with open(full_path) as f:
+            return f.read()
+
+    def list_files(self, path: str = ".", recursive: bool = False) -> list[str]:
+        """
+        Lists files in a directory.
+
+        Args:
+            path: The relative path to the directory to list.
+            recursive: Whether to list files recursively.
+
+        Returns:
+            A list of file paths.
+
+        Raises:
+            ValueError: If the path is outside the working directory.
+        """
+        if not self._is_safe_path(path):
+            raise ValueError("Path is outside the working directory.")
+
+        full_path = os.path.join(self.working_dir, path)
+        if not os.path.isdir(full_path):
+            raise ValueError(f"Path '{path}' is not a directory.")
+
+        files = []
+        if recursive:
+            for root, _, filenames in os.walk(full_path):
+                for filename in filenames:
+                    files.append(os.path.relpath(os.path.join(root, filename), self.working_dir))
+        else:
+            for item in os.listdir(full_path):
+                item_path = os.path.join(full_path, item)
+                if os.path.isfile(item_path):
+                    files.append(os.path.relpath(item_path, self.working_dir))
+        return files
+
+    def grep(self, pattern: str, path: str = ".", file_pattern: str = "*") -> list[str]:
+        """
+        Searches for a pattern in files.
+
+        Args:
+            pattern: The regex pattern to search for.
+            path: The relative path to the directory to search in.
+            file_pattern: A glob pattern to filter files to search.
+
+        Returns:
+            A list of strings with "file:line_number:line" for each match.
+
+        Raises:
+            ValueError: If the path is outside the working directory.
+        """
+        if not self._is_safe_path(path):
+            raise ValueError("Path is outside the working directory.")
+
+        full_path = os.path.join(self.working_dir, path)
+        if not os.path.isdir(full_path):
+            raise ValueError(f"Path '{path}' is not a directory.")
+
+        matches = []
+        for root, _, filenames in os.walk(full_path):
+            for filename in fnmatch.filter(filenames, file_pattern):
+                file_path = os.path.join(root, filename)
+                try:
+                    with open(file_path, errors="ignore") as f:
+                        for i, line in enumerate(f, 1):
+                            if re.search(pattern, line):
+                                relative_path = os.path.relpath(file_path, self.working_dir)
+                                matches.append(f"{relative_path}:{i}:{line.strip()}")
+                except OSError:
+                    continue  # Skip files that can't be opened
+        return matches
+
+    def list_tools(self):
+        return [self.create_file, self.grep, self.list_files, self.read_file]

universal_mcp_agents-0.1.19/src/universal_mcp/applications/llm/__init__.py

@@ -0,0 +1,3 @@
+from .app import LlmApp
+
+__all__ = ["LlmApp"]