universal-mcp-agents 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

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/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/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/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/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/codeact0/playbook_agent.py

@@ -2,18 +2,16 @@ import inspect
 import json
 import re
 from collections.abc import Callable
-from dataclasses import dataclass
-from pathlib import Path
 from typing import Literal, cast
 
-from langchain_core.messages import AIMessage, RemoveMessage, ToolMessage
+from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.tools import StructuredTool
 from langchain_core.tools import tool as create_tool
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
 from langgraph.types import Command, RetryPolicy
 from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat, ToolConfig
+from universal_mcp.types import ToolConfig, ToolFormat
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.codeact0.llm_tool import ai_classify, call_llm, data_extractor, smart_print
@@ -22,10 +20,14 @@ from universal_mcp.agents.codeact0.prompts import (
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell
 from universal_mcp.agents.codeact0.state import CodeActState
-from universal_mcp.agents.codeact0.tools import create_meta_tools, enter_playbook_mode, exit_playbook_mode, get_valid_tools
+from universal_mcp.agents.codeact0.tools import (
+    create_meta_tools,
+    enter_playbook_mode,
+    get_valid_tools,
+)
 from universal_mcp.agents.codeact0.utils import inject_context, smart_truncate
 from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.utils import filter_retry_on, get_message_text, convert_tool_ids_to_dict
+from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
 
 PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
 
@@ -48,7 +50,6 @@ Example:
 Now create a plan based on the conversation history. Enclose it between ``` and ```. Ask the user if the plan is okay."""
 
 
-
 PLAYBOOK_CONFIRMING_PROMPT = """Now, you are tasked with confirming the playbook plan. Return True if the user is happy with the plan, False otherwise. Do not say anything else in your response. The user response will be the last message in the chain.
 """
 
@@ -80,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
@@ -92,20 +93,19 @@ class CodeActPlaybookAgent(BaseAgent):
         meta_tools = create_meta_tools(self.registry)
         additional_tools = [smart_print, data_extractor, ai_classify, call_llm, meta_tools["web_search"]]
         self.additional_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in additional_tools]
+
         async def call_model(state: CodeActState) -> Command[Literal["sandbox", "execute_tools"]]:
             self.exported_tools = []
             if self.tools_config:
                 # Convert dict format to list format if needed
                 if isinstance(self.tools_config, dict):
                     self.tools_config = [
-                        f"{provider}__{tool}" 
-                        for provider, tools in self.tools_config.items() 
-                        for tool in tools
+                        f"{provider}__{tool}" for provider, tools in self.tools_config.items() for tool in tools
                     ]
                 if not self.registry:
                     raise ValueError("Tools are configured but no registry is provided")
                 # Langchain tools are fine
-            self.tools_config.extend(state.get('selected_tool_ids',[]))
+            self.tools_config.extend(state.get("selected_tool_ids", []))
             self.exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
             self.final_instructions, self.tools_context = create_default_prompt(
                 self.exported_tools, self.additional_tools, self.instructions
@@ -167,7 +167,7 @@ class CodeActPlaybookAgent(BaseAgent):
                         )
                         return Command(
                             goto="playbook",
-                            update={"playbook_mode": "planning", "messages": [tool_message]}, #Entered Playbook mode
+                            update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
                         )
                     elif tool_call["name"] == "execute_ipython_cell":
                         return Command(goto="sandbox")
@@ -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),
@@ -261,13 +266,12 @@ class CodeActPlaybookAgent(BaseAgent):
                 response = cast(AIMessage, response)
                 response_text = get_message_text(response)
                 # Extract plan from response text between triple backticks
-                plan_match = re.search(r'```(.*?)```', response_text, re.DOTALL)
+                plan_match = re.search(r"```(.*?)```", response_text, re.DOTALL)
                 if plan_match:
                     plan = plan_match.group(1).strip()
                 else:
                     plan = response_text.strip()
                 return Command(update={"messages": [response], "playbook_mode": "confirming", "plan": plan})
-                
 
             elif playbook_mode == "confirming":
                 confirmation_instructions = self.instructions + PLAYBOOK_CONFIRMING_PROMPT
@@ -279,8 +283,6 @@ class CodeActPlaybookAgent(BaseAgent):
                 else:
                     return Command(goto="playbook", update={"playbook_mode": "planning"})
 
-                    
-
             elif playbook_mode == "generating":
                 generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
@@ -327,25 +329,19 @@ class CodeActPlaybookAgent(BaseAgent):
                     saved_note = f"Failed to save generated playbook as Agent '{function_name}': {e}"
 
                 # Mock tool call for exit_playbook_mode (for testing/demonstration)
-                mock_exit_tool_call = {
-                    "name": "exit_playbook_mode",
-                    "args": {},
-                    "id": "mock_exit_playbook_123"
-                }
-                mock_assistant_message = AIMessage(
-                    content=saved_note, 
-                    tool_calls=[mock_exit_tool_call]
-                )
+                mock_exit_tool_call = {"name": "exit_playbook_mode", "args": {}, "id": "mock_exit_playbook_123"}
+                mock_assistant_message = AIMessage(content=saved_note, tool_calls=[mock_exit_tool_call])
 
-                
                 # Mock tool response for exit_playbook_mode
                 mock_exit_tool_response = ToolMessage(
                     content=json.dumps(f"Exited Playbook Mode.{saved_note}"),
                     name="exit_playbook_mode",
-                    tool_call_id="mock_exit_playbook_123"
+                    tool_call_id="mock_exit_playbook_123",
                 )
 
-                return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"})
+                return Command(
+                    update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"}
+                )
 
         def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
             """Route to either normal mode or playbook creation"""

universal_mcp/agents/codeact0/prompts.py

@@ -9,102 +9,41 @@ from universal_mcp.agents.codeact0.utils import schema_to_signature
 uneditable_prompt = """
 You are **Wingmen**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
 
-## Responsibilities
-
-- **Answer directly** if the task is simple (e.g. print, math, general knowledge).
-- For any task requiring logic, execution, or data handling, use `execute_ipython_cell`.
-- For writing or NLP tasks (summarizing, generating, extracting), always use AI functions via code — never respond directly.
-
-## Tool vs. Function: Required Separation
-
-You must clearly distinguish between tools (called via the tool calling API) and internal functions (used inside code blocks).
-
-### Tools — Must Be Called via Tool Calling API
-
-These must be called using **tool calling**, not from inside code blocks:
-
-- `execute_ipython_cell` — For running any Python code or logic.
-- `search_functions` — To discover available functions for a task.
-- `load_functions` — To load a specific function by full ID.
-
-**Do not attempt to call these inside `python` code.**
-Use tool calling syntax for these operations.
-
-### Functions — Must Be Used Inside Code Blocks
-
-All other functions, including LLM functions, must always be used within code executed by `execute_ipython_cell`. These include:
-
-- `smart_print()` — For inspecting unknown data structures before looping.
-- `asyncio.run()` — For wrapping and executing asynchronous logic. You must not use await outside an async function. And the async function must be called by `asyncio.run()`.
-- Any functions for applications loaded via `load_functions`.
-- Any logic, data handling, writing, NLP, generation, summarization, or extraction functionality of LLMs.
-
-These must be called **inside a Python code block**, and that block must be executed using `execute_ipython_cell`.
-
-## Tool/Function Usage Policy
-
-1. **Always Use Tools/Functions for Required Tasks**
-   Any searching, loading, or executing must be done using a tool/function call. Never answer manually if a tool/function is appropriate.
-
-2. **Use Existing Functions First**
-   Use existing functions if available. Otherwise, use `search_functions` with a concise query describing the task.
-
-3. **Load Only Relevant Tools**
-   When calling `load_functions`, include only relevant function IDs.
-   - Prefer connected applications over unconnected ones.
-   - If multiple functions match (i.e. if none are connected, or multiple are connected), ask the user to choose.
-   - After loading a tool, you do not need to import/declare it again. It can be called directly in further cells.
-
-4. **Follow First Turn Process Strictly**
-   On the **first turn**, do only **one** of the following:
-   - Handle directly (if trivial)
-   - Use a tool/function (`execute_ipython_cell`, `search_functions`, etc.)
-
-   **Do not extend the conversation on the first message.**
-
-## Coding Rules
-
-- Use `smart_print()` to inspect unknown structures, especially those received from function outputs, before looping or branching.
-- Validate logic with a single item before processing lists or large inputs.
-- Try to achieve as much as possible in a single code block.
-- Use only pre-installed Python libraries. Do import them once before using.
-- Outer level functions, variables, classes, and imports declared previously can be used in later cells.
-- For all functions, call using keyword arguments only. DO NOT use any positional arguments.
-
-### **Async Function Usage — Critical**
-
-When calling asynchronous functions:
-- You must define or use an **inner async function**.
-- Use `await` only **inside** that async function.
-- Run it using `asyncio.run(<function_name>())` **without** `await` at the outer level.
-
-**Wrong - Using `await` outside an async function**
-```
-result = await some_async_function()
-```
-**Wrong  - Attaching await before asyncio.run**.
-`await asyncio.run(main())`
-These will raise SyntaxError: 'await' outside async function
-The correct method is the following-
-```
-import asyncio
-async def some_async_function():
-    ...
-
-async def main():
-    result = await some_async_function()
-    print(result)
-
-asyncio.run(main())
-#or
-result = asyncio.run(some_async_function(arg1 = <arg1>))
-```
-## Output Formatting
-- All code results must be returned in **Markdown**.
-- The user cannot see raw output, so format results clearly:
-    - Use tables for structured data.
-    - Provide links for files or images.
-    - Be explicit in formatting to ensure readability.
+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.
+    - 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.
+- If needed, feel free to ask for more information from the user (without using the `execute_ipython_cell` tool) to clarify the task.
+
+GUIDELINES for writing code:
+- Variables defined at the top level of previous code snippets can be referenced in your code.
+- External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
+- When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
+- In a single code snippet, try to achieve as much as possible.
+- You can only import libraries that come pre-installed with Python. For external functions, use the search and load tools to access them in the code.
+- For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
+- Call all functions using keyword arguments only, never positional arguments.
+- Async Functions (Critical): Use them only as follows-
+Case 1: Top-level await without asyncio.run()
+    Wrap in async function and call with asyncio.run():
+    async def main():
+        result = await some_async_function()
+        return result
+    asyncio.run(main())
+Case 2: Using asyncio.run() directly
+If code already contains asyncio.run(), use as-is — do not wrap again:
+    asyncio.run(some_async_function())
+Rules:
+- Never use await outside an async function
+- Never use await asyncio.run()
+- Never nest asyncio.run() calls
 """
 
 

universal_mcp/agents/codeact0/tools.py

@@ -6,18 +6,19 @@ from langchain_core.tools import tool
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
 
-MAX_LENGHT=100
+MAX_LENGHT = 100
+
 
 def enter_playbook_mode():
     """Call this function to enter playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
     return
 
+
 def exit_playbook_mode():
     """Call this function to exit playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
     return
 
 
-
 def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
     """Create the meta tools for searching and loading tools"""
 
@@ -46,7 +47,7 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
                 for tool in tools_list:
                     app = tool["id"].split("__")[0]
                     tool_id = tool["id"]
-                    
+
                     # Check if within limit and add to set (automatically deduplicates)
                     if len(app_tools[app]) < MAX_LENGTH:
                         cleaned_desc = tool["description"].split("Context:")[0].strip()
@@ -54,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):")
@@ -62,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)
 
@@ -103,29 +114,30 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
         return f"Successfully loaded {len(tool_ids)} functions: {tool_ids}"
 
     @tool
-    async def web_search(query: str) -> list:
-        """Search the web for the given query and return structured search results.
+    async def web_search(query: str) -> dict:
+        """
+        Get an LLM answer to a question informed by Exa search results.
 
-        Do not use for app-specific searches (for example, reddit or linkedin searches
+        This tool performs an Exa `/answer` request, which:
+        1. Provides a **direct answer** for factual queries (e.g., "What is the capital of France?" → "Paris")
+        2. Generates a **summary with citations** for open-ended questions
+        (e.g., "What is the state of AI in healthcare?" → A detailed summary with source links)
 
+        Args:
+            query (str): The question or topic to answer.
         Returns:
-            list: A list of up to 10 search result dictionaries, each containing:
-                - id (str): Unique identifier, typically the URL
-                - title (str): The title/headline of the search result
-                - url (str): The web URL of the result
-                - publishedDate (str): ISO 8601 formatted date (e.g., "2025-01-01T00:00:00.000Z")
-                - author (str): Author name (may be empty string)
-                - summary (str): Text summary/snippet of the content
-                - image (str): URL to associated image (if available)
-
-        Example:
-            results = await web_search(query="python programming")
+            dict: A structured response containing only:
+                - answer (str): Generated answer
+                - citations (list[dict]): List of cited sources
         """
-        await tool_registry.export_tools(["exa__search_with_filters"], ToolFormat.LANGCHAIN)
-        response = await tool_registry.call_tool(
-            "exa__search_with_filters", {"query": query, "contents": {"summary": True}}
-        )
-        return response["results"]
+        await tool_registry.export_tools(["exa__answer"], ToolFormat.LANGCHAIN)
+        response = await tool_registry.call_tool("exa__answer", {"query": query, "text": True})
+
+        # Extract only desired fields
+        return {
+            "answer": response.get("answer"),
+            "citations": response.get("citations", []),
+        }
 
     return {"search_functions": search_functions, "load_functions": load_functions, "web_search": web_search}
 

universal_mcp/agents/codeact0/utils.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from langchain_core.messages import BaseMessage
 
-MAX_CHARS = 700
+MAX_CHARS = 5000
 
 
 def light_copy(data):

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/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/applications/llm/__init__.py

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

universal_mcp/applications/llm/app.py

@@ -2,10 +2,11 @@ import json
 from typing import Any, Literal, cast
 
 from langchain.chat_models import init_chat_model
-from langchain_openai import AzureChatOpenAI
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
+from universal_mcp.agents.llm import load_chat_model
+
 MAX_RETRIES = 3
 
 
@@ -28,7 +29,7 @@ def _get_context_as_string(source: Any | list[Any] | dict[str, Any]) -> str:
     return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
 
 
-class LLMApp(BaseApplication):
+class LlmApp(BaseApplication):
     """
     An application for leveraging Large Language Models (LLMs) for advanced text processing tasks.
     """
@@ -40,22 +41,34 @@ class LLMApp(BaseApplication):
     def generate_text(
         self,
         task: str,
-        context: Any | list[Any] | dict[str, Any],
+        context: str | list[str] | dict[str, str] = "",
         tone: str = "normal",
         output_format: Literal["markdown", "html", "plain"] = "markdown",
         length: Literal["very-short", "concise", "normal", "long"] = "concise",
     ) -> str:
         """
-        Generates well-written text for a high-level task using the provided context.
-
-        Use this function for creative writing, summarization, and other text generation tasks.
+        Given a high-level writing task and context, returns a well-written text
+        that achieves the task, given the context.
+
+        Example Call:
+            generate_text("Summarize this website with the goal of making it easy to understand.", web_content)
+            generate_text("Make a markdown table summarizing the key differences between doc_1 and doc_2.", {"doc_1": str(doc_1), "doc_2": str(doc_2)})
+            generate_text("Summarize all the provided documents.", [doc_1, doc_2, doc_3])
+
+        Important:
+        - Include specifics of the goal in the context verbatim.
+        - Be precise and direct in the task, and include as much context as possible.
+        - Include relevant high-level goals or intent in the task.
+        - You can provide multiple documents as input, and reference them in the task.
+        - You MUST provide the contents of any source documents to `generate_text`.
+        - NEVER use `generate_text` to produce JSON for a Pydantic model.
 
         Args:
             task: The main writing task or directive.
-            context: A single string, list of strings, or dictionary mapping labels to content.
-            tone: The desired tone of the output (e.g., "formal", "casual", "technical").
+            context: A single string, list of strings, or dict mapping labels to content.
+            tone: The desired tone of the output (e.g., "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.).
             output_format: The desired output format ('markdown', 'html', 'plain').
-            length: The desired length of the output ('very-short', 'concise', 'normal', 'long').
+            length: Desired length of the output ('very-short', 'concise', 'normal', 'long').
 
         Returns:
             The generated text as a string.
@@ -78,31 +91,63 @@ class LLMApp(BaseApplication):
 
         full_prompt = f"{prompt}\n\nContext:\n{context_str}\n\n"
 
-        model = AzureChatOpenAI(model="gpt-4o", temperature=0.7)
+        model = load_chat_model("azure/gpt-5-mini")
         response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt)
         return str(response.content)
 
     def classify_data(
         self,
-        task: str,
+        classification_task_and_requirements: str,
         context: Any | list[Any] | dict[str, Any],
         class_descriptions: dict[str, str],
     ) -> dict[str, Any]:
         """
-        Classifies data into one of several categories based on a given task and context.
+        Classifies and compares data based on given requirements.
+
+        Use `classify_data` for tasks which need to classify data into one of many categories.
+        If making multiple binary classifications, call `classify_data` for each.
+
+        Guidance:
+        - Prefer to use classify_data operations to compare strings, rather than string ops.
+        - Prefer to include an "Unsure" category for classification tasks.
+        - The `class_descriptions` dict argument MUST be a map from possible class names to a precise description.
+        - Use precise and specific class names and concise descriptions.
+        - Pass ALL relevant context, preferably as a dict mapping labels to content.
+        - Returned dict maps each possible class name to a probability.
+
+        Example Usage:
+            classification_task_and_requirements = "Does the document contain an address?"
+            class_descriptions = {
+                "Is_Address": "Valid addresses usually have street names, city, and zip codes.",
+                "Not_Address": "Not valid addresses."
+            }
+            classification = classify_data(
+                classification_task_and_requirements,
+                {"address": extracted_address},
+                class_descriptions
+            )
+            if classification["probabilities"]["Is_Address"] > 0.5:
+                ...
 
         Args:
-            task: The classification question and any specific rules or requirements.
-            context: The data to be classified, provided as a string, list, or dictionary.
-            class_descriptions: A dictionary mapping class names to their descriptions.
+            classification_task_and_requirements: The classification question and rules.
+            context: The data to classify (string, list, or dict).
+            class_descriptions: Mapping from class names to descriptions.
+
+        Tags:
+            important
 
         Returns:
-            A dictionary containing the classification probabilities, the reasoning, and the top class.
+            dict: {
+                "probabilities": dict[str, float],
+                "reason": str,
+                "top_class": str,
+            }
         """
         context_str = _get_context_as_string(context)
 
         prompt = (
-            f"{task}\n\n"
+            f"{classification_task_and_requirements}\n\n"
             f"This is a classification task.\nPossible classes and descriptions:\n"
             f"{json.dumps(class_descriptions, indent=2)}\n\n"
             f"Context:\n{context_str}\n\n"
@@ -125,25 +170,61 @@ class LLMApp(BaseApplication):
 
     def extract_data(
         self,
-        task: str,
+        extraction_task: str,
         source: Any | list[Any] | dict[str, Any],
         output_schema: dict[str, Any],
     ) -> dict[str, Any]:
         """
-        Extracts structured data from unstructured text based on a provided JSON schema.
+        Extracts structured data from unstructured data (documents, webpages, images, large bodies of text),
+        returning a dictionary matching the given output_schema.
+
+        You MUST anticipate Exception raised for unextractable data; skip this item if applicable.
+
+        Strongly prefer to:
+        - Be comprehensive, specific, and precise on the data you want to extract.
+        - Use optional fields everywhere.
+        - Extract multiple items from each source unless otherwise specified.
+        - The more specific your extraction task and output_schema are, the better the results.
 
         Args:
-            task: A description of the data to be extracted.
-            source: The unstructured data to extract from (e.g., document, webpage content).
-            output_schema: A valid JSON schema with a 'title' and 'description'.
+            extraction_task: The directive describing what to extract.
+            source: The unstructured data to extract from.
+            output_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
 
         Returns:
             A dictionary containing the extracted data, matching the provided schema.
+
+        Example:
+            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"]
+            }
+
+            news_articles = extract_data("Extract headlines and their corresponding URLs.", content, news_articles_schema)
         """
         context_str = _get_context_as_string(source)
 
         prompt = (
-            f"{task}\n\n"
+            f"{extraction_task}\n\n"
             f"Context:\n{context_str}\n\n"
             "Return ONLY a valid JSON object that conforms to the provided schema, with no extra text."
         )
@@ -156,3 +237,64 @@ class LLMApp(BaseApplication):
             .invoke(prompt)
         )
         return cast(dict[str, Any], response)
+
+    def call_llm(
+        self,
+        task_instructions: str,
+        context: Any | list[Any] | dict[str, Any],
+        output_schema: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Call a Large Language Model (LLM) with an instruction and contextual information,
+        returning a dictionary matching the given output_schema.
+        Can be used for tasks like creative writing, llm reasoning based content generation, etc.
+
+        You MUST anticipate Exceptions in reasoning based tasks which will lead to some empty fields
+        in the returned output; skip this item if applicable.
+
+        General Guidelines:
+        - Be comprehensive, specific, and precise on the task instructions.
+        - Include as much context as possible.
+        - You can provide multiple items in context, and reference them in the task.
+        - Include relevant high-level goals or intent in the task.
+        - In the output_schema, use required field wherever necessary.
+        - The more specific your task instructions and output_schema are, the better the results.
+
+        Guidelines for content generation tasks:
+        - Feel free to add instructions for tone, length, and format (markdown, html, plain-text, xml)
+        - Some examples of tone are: "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.
+        - Prefer length to be concise by default. Other examples are: "very-short", "concise", "normal", "long", "2-3 lines", etc.
+        - In format prefer plain-text but you can also use markdown and html wherever useful.
+
+        Args:
+            task_instructions: The main directive for the LLM (e.g., "Summarize the article" or "Extract key entities").
+            context:
+                A dictionary containing named text elements that provide additional
+                information for the LLM. Keys are labels (e.g., 'article', 'transcript'),
+                values are strings of content.
+            output_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
+
+        Returns:
+            dict: Parsed JSON object matching the desired output_schema.
+
+        """
+        context_str = _get_context_as_string(context)
+
+        prompt = f"{task_instructions}\n\nContext:\n{context_str}\n\nReturn ONLY a valid JSON object, no extra text."
+
+        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+
+        response = (
+            model.with_structured_output(schema=output_schema, method="json_mode")
+            .with_retry(stop_after_attempt=MAX_RETRIES)
+            .invoke(prompt)
+        )
+        return cast(dict[str, Any], response)
+
+    def list_tools(self):
+        return [
+            self.generate_text,
+            self.classify_data,
+            self.extract_data,
+            self.call_llm,
+        ]

{universal_mcp_agents-0.1.17.dist-info → universal_mcp_agents-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.17
+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.17.dist-info → universal_mcp_agents-0.1.19.dist-info}/RECORD

@@ -1,9 +1,10 @@
-universal_mcp/agents/__init__.py,sha256=5aE4zVgem6ehzfRrt5QqE6gLi7949vySZAn_uFuaU7Q,1252
-universal_mcp/agents/base.py,sha256=GmagwWFJdPpp_yLeAfsrr4fu-zzxh7CgIlBJbTgFgWM,7072
-universal_mcp/agents/cli.py,sha256=AG9e4iSX3GazT537573YrYT1wSaZYOr42rrYQ7xP3YA,1016
+universal_mcp/agents/__init__.py,sha256=NuS_JOKYeHfAkNA4xRyvxdGZP_tXKfvsmoc2fhkMrj8,1259
+universal_mcp/agents/base.py,sha256=hrlvSv0TLS-ShaKofpHD3kishciql7SSbTKCUHKGObc,7175
+universal_mcp/agents/cli.py,sha256=bXdpgxsOMjclm1STHJgx10ocX9EebQ11DrxH0p6KMZk,943
 universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
 universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
 universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
+universal_mcp/agents/sandbox.py,sha256=Int2O8JNFPlB8c7gb86KRxlNbuV0zdz5_NCo_GMcCds,2876
 universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
 universal_mcp/agents/utils.py,sha256=P6W9k6XAOBp6tdjC2VTP4tE0B2M4-b1EDmr-ylJ47Pw,7765
 universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
@@ -28,23 +29,25 @@ universal_mcp/agents/codeact/sandbox.py,sha256=NjN6ISj8psFtHf8V0w24ChJdUMUWkq7Or
 universal_mcp/agents/codeact/state.py,sha256=WTPfpxDlGRnlr5tZuXMg_KU7GS7TZbnrIKslOvZLbQI,565
 universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
 universal_mcp/agents/codeact0/__init__.py,sha256=ebKkpgg-0UnsvDtagEJ2tMer1VsfhmEE5KJcFzUk9fU,133
-universal_mcp/agents/codeact0/__main__.py,sha256=V2wLWW9ym3rtiSvPEs-N0Mki7G5dYHzV5dAsAoF-ygQ,1148
+universal_mcp/agents/codeact0/__main__.py,sha256=xeqNuawP9M8JVAnkhLesalnpI_TakC49ATJaSCzCsYs,880
 universal_mcp/agents/codeact0/agent.py,sha256=9BInAQr3csES-XHSscmeJlYJ3-wQUHPvLOf-6wFILUU,6695
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
 universal_mcp/agents/codeact0/langgraph_agent.py,sha256=ehjMV_Z1118pCFWB_Sa5H7XnUp0udsbUHjfjXjhIQM8,435
-universal_mcp/agents/codeact0/llm_tool.py,sha256=fydA4BbSnhG3OLMR_VEtJxTPTmRK_mMvXGsUCO-5Mig,13829
-universal_mcp/agents/codeact0/playbook_agent.py,sha256=YNuWQ_xK9KlOtb4kkHkxLl3CEJfmM3sUf8dwaSPyYcg,18089
-universal_mcp/agents/codeact0/prompts.py,sha256=j8HxA3Rp-EZsms9qMBcRmFrUjeySrG1IWjqrNFXZZn8,9457
+universal_mcp/agents/codeact0/llm_tool.py,sha256=q-hiqkKtjVmpyNceFoRgo7hvKh4HtQf_I1VudRUEPR0,11075
+universal_mcp/agents/codeact0/playbook_agent.py,sha256=6ePcpEOrHxoNoaAdKdg9i7Yi6hcJOxBAo1MavCn8J6A,18081
+universal_mcp/agents/codeact0/prompts.py,sha256=2MF0J371Ib7cDXqpW6Ei_CwBpRFmK95neLh9QM4emIY,8708
 universal_mcp/agents/codeact0/sandbox.py,sha256=zMgHrWnQYkSkJb2MzfXvT3euCc4hvqzBE_EbX2_iLxA,3142
 universal_mcp/agents/codeact0/state.py,sha256=Y-Rzn_S7--aXH18KPvyhqDqOOB-miu1lsAmLgmMlaAg,1259
-universal_mcp/agents/codeact0/tools.py,sha256=Adh9Go87JnIk5U_rtBOHglFRPowk2JmRK9bumR4zJoo,7751
-universal_mcp/agents/codeact0/utils.py,sha256=ACncBI9-JJ4Qe_4VHWnSziY3P2nE6Vb9pj71NPeVZ0o,15943
+universal_mcp/agents/codeact0/tools.py,sha256=qVZLq1YlVKABZdpEqFAzLo04DTFd1ZJi18atfzmxEb8,8374
+universal_mcp/agents/codeact0/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0HKQ_jwvvSQ,15944
 universal_mcp/agents/shared/__main__.py,sha256=XxH5qGDpgFWfq7fwQfgKULXGiUgeTp_YKfcxftuVZq8,1452
 universal_mcp/agents/shared/prompts.py,sha256=yjP3zbbuKi87qCj21qwTTicz8TqtkKgnyGSeEjMu3ho,3761
 universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb5qP1qOoGgfs,9169
-universal_mcp/applications/llm/__init__.py,sha256=xnpxq4Wl_pevvwtSUtEwcty8_d61ywO1V2YnEXyCREY,46
-universal_mcp/applications/llm/app.py,sha256=iNLU6z2LRZc01GfSKvV0vNzT1LhKAjq_UrSJEmjthjw,6032
+universal_mcp/applications/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWlD1eEn8Jm0xBeigs,5561
+universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
+universal_mcp/applications/llm/app.py,sha256=oqX3byvlFRmeRo4jJJxUBGy-iTDGm2fplMEKA2pcMtw,12743
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.17.dist-info/METADATA,sha256=GFVLLOc3wPsDCvYnLV7w1klLJJIITEax5ipX_MScI98,878
-universal_mcp_agents-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.17.dist-info/RECORD,,
+universal_mcp_agents-0.1.19.dist-info/METADATA,sha256=imopF36ZWDrHP3tweT0GtvIlKdNg_CLa9yZrXvv3s9s,878
+universal_mcp_agents-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.19.dist-info/RECORD,,