universal-mcp-agents 0.1.23rc7__py3-none-any.whl → 0.1.23rc9__py3-none-any.whl

universal_mcp/agents/base.py

@@ -1,12 +1,13 @@
-from typing import Any, cast
-from uuid import uuid4
 import asyncio
+from typing import cast
+from uuid import uuid4
 
 from langchain_core.messages import AIMessageChunk
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import StateGraph
 from langgraph.types import Command
 from universal_mcp.logger import logger
+
 from .utils import RichCLI
 
 

universal_mcp/agents/codeact0/agent.py

@@ -3,10 +3,9 @@ import json
 import re
 import uuid
 from typing import Literal, cast
-from types import SimpleNamespace
 
 from langchain_anthropic import ChatAnthropic
-from langchain_core.messages import AIMessage, ToolMessage
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
 from langgraph.types import Command, RetryPolicy, StreamWriter
@@ -19,8 +18,8 @@ from universal_mcp.agents.codeact0.prompts import (
     AGENT_BUILDER_GENERATING_PROMPT,
     AGENT_BUILDER_META_PROMPT,
     AGENT_BUILDER_PLANNING_PROMPT,
+    build_tool_definitions,
     create_default_prompt,
-    build_tool_definitions
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
 from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
@@ -53,12 +52,11 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.agent_builder_model_instance = load_chat_model("anthropic:claude-sonnet-4-5-20250929", thinking = False)
+        self.agent_builder_model_instance = load_chat_model("anthropic:claude-sonnet-4-5-20250929")
         self.registry = registry
         self.agent_builder_registry = agent_builder_registry
         self.agent = agent_builder_registry.get_agent() if agent_builder_registry else None
 
-        
         self.tools_config = self.agent.tools if self.agent else {}
         self.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
@@ -67,21 +65,23 @@ class CodeActPlaybookAgent(BaseAgent):
         }
         self.final_instructions = ""
         self.tools_context = {}
+        self.eval_mode = kwargs.get("eval_mode", False)
 
     async def _build_graph(self):  # noqa: PLR0915
         """Build the graph for the CodeAct Playbook Agent."""
         meta_tools = create_meta_tools(self.registry)
-        self.additional_tools = [smart_print, meta_tools["web_search"]]
+        self.additional_tools = [
+            smart_print,
+            meta_tools["web_search"],
+            meta_tools["read_file"],
+            meta_tools["save_file"],
+            meta_tools["upload_file"],
+        ]
 
         if self.tools_config:
-            if isinstance(self.tools_config, dict):
-                self.tools_config = [
-                    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")
-            await self.registry.load_tools(self.tools_config)  # Load the default tools
-        await self.registry.load_tools(self.default_tools_config)  # Load more tools
+            await self.registry.load_tools(self.tools_config)  # Load provided tools
+        if self.default_tools_config:
+            await self.registry.load_tools(self.default_tools_config)  # Load default tools
 
         async def call_model(state: CodeActState) -> Command[Literal["execute_tools"]]:
             """This node now only ever binds the four meta-tools to the LLM."""
@@ -226,18 +226,29 @@ class CodeActPlaybookAgent(BaseAgent):
                 plan = cast(AgentBuilderPlan, response)
 
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
+                ai_msg = AIMessage(
+                    content=json.dumps(plan.model_dump()),
+                    additional_kwargs={
+                        "type": "planning",
+                        "plan": plan.steps,
+                        "update": bool(self.agent),
+                    },
+                )
+
+                if self.eval_mode:
+                    mock_user_message = HumanMessage(content="yes, this is great")
+                    return Command(
+                        goto="agent_builder",
+                        update={
+                            "messages": [ai_msg, mock_user_message],
+                            "agent_builder_mode": "generating",
+                            "plan": plan.steps,
+                        },
+                    )
+
                 return Command(
                     update={
-                        "messages": [
-                            AIMessage(
-                                content=json.dumps(plan.model_dump()),
-                                additional_kwargs={
-                                    "type": "planning",
-                                    "plan": plan.steps,
-                                    "update": bool(self.agent),
-                                },
-                            )
-                        ],
+                        "messages": [ai_msg],
                         "agent_builder_mode": "confirming",
                         "plan": plan.steps,
                     }
@@ -319,7 +330,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
             elif agent_builder_mode == "generating":
-                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT +  self.preloaded_defs
+                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT + self.preloaded_defs
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
                 model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
@@ -359,14 +370,10 @@ class CodeActPlaybookAgent(BaseAgent):
                         instructions=instructions_payload,
                         tools=tool_dict,
                     )
-                except Exception as e:
+                except Exception:
                     # In case of error, add the code to the exit message content
 
-                    mock_exit_tool_call = {
-                    "name": "exit_agent_builder_mode",
-                    "args": {},
-                    "id": "exit_builder_1"
-                    }
+                    mock_exit_tool_call = {"name": "exit_agent_builder_mode", "args": {}, "id": "exit_builder_1"}
 
                     # Create a minimal assistant message to maintain flow
                     mock_assistant_message = AIMessage(
@@ -385,9 +392,25 @@ class CodeActPlaybookAgent(BaseAgent):
                             f"An error occurred. Displaying the function code:\n\n{func_code}\nFinal Name: {final_name}\nDescription: {final_description}"
                         ),
                         name="exit_agent_builder_mode",
-                        tool_call_id="exit_builder_1"
+                        tool_call_id="exit_builder_1",
+                    )
+                    if self.eval_mode:
+                        human_msg = HumanMessage(
+                            content="Run the generated agent code and check whether it works as expected"
+                        )
+                        return Command(
+                            goto="call_model",
+                            update={
+                                "messages": [mock_assistant_message, mock_exit_tool_response, human_msg],
+                                "agent_builder_mode": "normal",
+                            },
+                        )
+                    return Command(
+                        update={
+                            "messages": [mock_assistant_message, mock_exit_tool_response],
+                            "agent_builder_mode": "normal",
+                        }
                     )
-                    return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
 
                 writer(
                     {
@@ -402,11 +425,7 @@ class CodeActPlaybookAgent(BaseAgent):
                         },
                     }
                 )
-                mock_exit_tool_call = {
-                    "name": "exit_agent_builder_mode",
-                    "args": {},
-                    "id": "exit_builder_1"
-                }
+                mock_exit_tool_call = {"name": "exit_agent_builder_mode", "args": {}, "id": "exit_builder_1"}
                 mock_assistant_message = AIMessage(
                     content=json.dumps(response.model_dump()),
                     tool_calls=[mock_exit_tool_call],
@@ -418,14 +437,21 @@ class CodeActPlaybookAgent(BaseAgent):
                         "description": final_description,
                     },
                 )
-                
+
                 mock_exit_tool_response = ToolMessage(
-                    content=json.dumps("Exited Agent Builder Mode. Enter this mode again if you need to modify the saved agent."),
+                    content=json.dumps(
+                        "Exited Agent Builder Mode. Enter this mode again if you need to modify the saved agent."
+                    ),
                     name="exit_agent_builder_mode",
-                    tool_call_id="exit_builder_1"
+                    tool_call_id="exit_builder_1",
                 )
 
-                return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
+                return Command(
+                    update={
+                        "messages": [mock_assistant_message, mock_exit_tool_response],
+                        "agent_builder_mode": "normal",
+                    }
+                )
 
         async def route_entry(state: CodeActState) -> Command[Literal["call_model", "agent_builder", "execute_tools"]]:
             """Route to either normal mode or agent builder creation"""
@@ -441,16 +467,20 @@ class CodeActPlaybookAgent(BaseAgent):
                 is_initial_prompt=True,
             )
             self.preloaded_defs, _ = build_tool_definitions(pre_tools)
-            self.preloaded_defs = '\n'.join(self.preloaded_defs)
+            self.preloaded_defs = "\n".join(self.preloaded_defs)
             await self.registry.load_tools(state["selected_tool_ids"])
-            exported_tools = await self.registry.export_tools(state["selected_tool_ids"],ToolFormat.NATIVE)  # Get definition for only the new tools
+            exported_tools = await self.registry.export_tools(
+                state["selected_tool_ids"], ToolFormat.NATIVE
+            )  # Get definition for only the new tools
             _, loaded_tools_context = build_tool_definitions(exported_tools)
             self.tools_context.update(loaded_tools_context)
-            
-            if len(state['messages']) == 1 and self.agent: # Inject the agent's script function into add_context for execution
-                script = self.agent.instructions.get('script')
-                add_context = {"functions":[script]}
-                return Command(goto="call_model", update = {"add_context": add_context})
+
+            if (
+                len(state["messages"]) == 1 and self.agent
+            ):  # Inject the agent's script function into add_context for execution
+                script = self.agent.instructions.get("script")
+                add_context = {"functions": [script]}
+                return Command(goto="call_model", update={"add_context": add_context})
 
             if state.get("agent_builder_mode") in ["planning", "confirming", "generating"]:
                 return Command(goto="agent_builder")

universal_mcp/agents/codeact0/prompts.py

@@ -2,8 +2,6 @@ import inspect
 import re
 from collections.abc import Callable
 
-from loguru import logger
-
 uneditable_prompt = """
 You are **Ruzo**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
 
@@ -45,6 +43,7 @@ Your job is to answer the user's question or perform the task they ask for.
 - Always respond in github flavoured markdown format.
 - For charts and diagrams, use mermaid chart in markdown directly.
 - Your final response should contain the complete answer to the user's request in a clear, well-formatted manner that directly addresses what they asked for.
+- For file types like images, audio, documents, etc., you must use the `upload_file` tool to upload the file to the server and render the link in the markdown response.
 """
 
 AGENT_BUILDER_PLANNING_PROMPT = """TASK: Analyze the conversation history and code execution to create a step-by-step non-technical plan for a reusable function.
@@ -100,7 +99,7 @@ Rules-
 - Do not include any text, explanations, or Markdown.
 - The response must start with `def` or `async def` and define a single, complete, executable function.
 - The function parameters **must exactly match the external variables** in the agent plan. External variables are marked using backticks `` `variable_name` ``.  Any variables in italics (i.e. enclosed in *...*) are to be used internally, but not as the main function paramters.
-- Any imports, variables, helper or child functions required must be defined **inside the main top-level function**.  
+- Any imports, variables, helper or child functions required must be defined **inside the main top-level function**.
 - Ensure that the outer function is self-contained and can run independently, based on previously validated code snippets.
 
 Example:
@@ -162,38 +161,39 @@ def make_safe_function_name(name: str) -> str:
 
 
 # Compile regex once for better performance
-_RAISES_PATTERN = re.compile(r'\n\s*[Rr]aises\s*:.*$', re.DOTALL)
+_RAISES_PATTERN = re.compile(r"\n\s*[Rr]aises\s*:.*$", re.DOTALL)
+
 
 def _clean_docstring(docstring: str | None) -> str:
     """Remove the 'Raises:' section and everything after it from a docstring."""
     if not docstring:
         return ""
-    
+
     # Use pre-compiled regex for better performance
-    cleaned = _RAISES_PATTERN.sub('', docstring)
+    cleaned = _RAISES_PATTERN.sub("", docstring)
     return cleaned.strip()
 
 
 def build_tool_definitions(tools: list[Callable]) -> tuple[list[str], dict[str, Callable]]:
     tool_definitions = []
     context = {}
-    
+
     # Pre-allocate lists for better performance
     tool_definitions = [None] * len(tools)
-    
+
     for i, tool in enumerate(tools):
         tool_name = tool.__name__
         cleaned_docstring = _clean_docstring(tool.__doc__)
-        
+
         # Pre-compute string parts to avoid repeated string operations
         async_prefix = "async " if inspect.iscoroutinefunction(tool) else ""
         signature = str(inspect.signature(tool))
-        
+
         tool_definitions[i] = f'''{async_prefix}def {tool_name} {signature}:
     """{cleaned_docstring}"""
     ...'''
         context[tool_name] = tool
-    
+
     return tool_definitions, context
 
 
@@ -231,7 +231,9 @@ def create_default_prompt(
                 plan = pb.get("plan")
                 code = pb.get("script")
                 if plan or code:
-                    system_prompt += "\n\nYou have been provided an existing agent plan and code for performing a task.:\n"
+                    system_prompt += (
+                        "\n\nYou have been provided an existing agent plan and code for performing a task.:\n"
+                    )
                     if plan:
                         if isinstance(plan, list):
                             plan_block = "\n".join(f"- {str(s)}" for s in plan)

universal_mcp/agents/codeact0/sandbox.py

@@ -1,14 +1,14 @@
+import ast
 import contextlib
 import inspect
 import io
+import pickle
 import queue
 import re
 import socket
 import threading
 import types
 from typing import Any
-import pickle
-import ast
 
 from langchain_core.tools import tool
 
@@ -40,12 +40,12 @@ async def eval_unsafe(
     )
 
     result_container = {"output": "<no output>"}
-    
+
     try:
         compiled_code = compile(code, "<string>", "exec", flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
         with contextlib.redirect_stdout(io.StringIO()) as f:
             coroutine = eval(compiled_code, _locals, _locals)
-             # Await the coroutine to run the code if it's async
+            # Await the coroutine to run the code if it's async
             if coroutine:
                 await coroutine
         result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"

universal_mcp/agents/codeact0/tools.py

@@ -1,11 +1,14 @@
 import asyncio
-import json
+import base64
 from collections import defaultdict
+from pathlib import Path
 from typing import Annotated, Any
 
 from langchain_core.tools import tool
 from pydantic import Field
+from universal_mcp.agentr.client import AgentrClient
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.applications.markitdown.app import MarkitdownApp
 from universal_mcp.types import ToolFormat
 
 from universal_mcp.agents.codeact0.prompts import build_tool_definitions
@@ -22,179 +25,279 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
     @tool
     async def search_functions(
         queries: Annotated[
-            list[str] | str | None,
-            Field(description="A single query or a list of queries to search for relevant functions"),
+            list[list[str]] | None,
+            Field(
+                description="A list of query lists. Each inner list contains one or more search terms that will be used together to find relevant tools."
+            ),
         ] = None,
-        app_id: Annotated[
-            str | None,
-            Field(description="The ID or common name of a specific application to search within"),
+        app_ids: Annotated[
+            list[str] | None,
+            Field(description="The ID or list of IDs (common names) of specific applications to search within."),
         ] = None,
     ) -> str:
         """
-        Searches for relevant functions across applications based on queries and/or a specific app.
-        This function operates in three modes:
-
-        1.  **Global Search (provide `queries` only):**
-            - Use when the user wants to perform an action without specifying an application.
-            - The system will search across all available functions.
-            - Example: For "how can I create a presentation?", call with queries=["create presentation"].
-
-        2.  **App Discovery (provide `app_id` only):**
-            - Use when the user asks about the capabilities of a specific application.
-            - The `app_id` can be the common name of the app (e.g., "Gmail", "Google Drive").
-            - This will return all available functions for that application, up to a limit.
-            - Example: For "what can you do with Gmail?", call with app_id="Gmail".
-
-        3.  **Scoped Search (provide `queries` AND `app_id`):**
-            - Use when the user wants to perform an action within a specific application.
-            - This performs a targeted search only within the specified app's functions.
-            - Example: For "how do I find an email in Gmail?", call with queries=["find email"], app_id="Gmail".
+        Searches for relevant functions based on queries and/or applications. This function
+        operates in three powerful modes with support for multi-query searches:
+
+        1.  **Global Search** (`queries` only as List[List[str]]):
+            - Searches all functions across all applications.
+            - Supports multiple independent searches in parallel.
+            - Each inner list represents a separate search query.
+
+            Examples:
+            - Single global search:
+              `search_functions(queries=[["create presentation"]])`
+
+            - Multiple independent global searches:
+              `search_functions(queries=[["send email"], ["schedule meeting"]])`
+
+            - Multi-term search for comprehensive results:
+              `search_functions(queries=[["send email", "draft email", "compose email"]])`
+
+        2.  **App Discovery** (`app_ids` only as List[str]):
+            - Returns ALL available functions for one or more specific applications.
+            - Use this to explore the complete capability set of an application.
+
+            Examples:
+            - Single app discovery:
+              `search_functions(app_ids=["Gmail"])`
+
+            - Multiple app discovery:
+              `search_functions(app_ids=["Gmail", "Google Calendar", "Slack"])`
+
+        3.  **Scoped Search** (`queries` as List[List[str]] and `app_ids` as List[str]):
+            - Performs targeted searches within specific applications in parallel.
+            - The number of app_ids must match the number of inner query lists.
+            - Each query list is searched within its corresponding app_id.
+            - Supports multiple search terms per app for comprehensive discovery.
+
+            Examples:
+            - Basic scoped search (one query per app):
+              `search_functions(queries=[["find email"], ["share file"]], app_ids=["Gmail", "Google_Drive"])`
+
+            - Multi-term scoped search (multiple queries per app):
+              `search_functions(
+                  queries=[
+                      ["send email", "draft email", "compose email", "reply to email"],
+                      ["create event", "schedule meeting", "find free time"],
+                      ["upload file", "share file", "create folder", "search files"]
+                  ],
+                  app_ids=["Gmail", "Google Calendar", "Google_Drive"]
+              )`
+
+            - Mixed complexity (some apps with single query, others with multiple):
+              `search_functions(
+                  queries=[
+                      ["list messages"],
+                      ["create event", "delete event", "update event"]
+                  ],
+                  app_ids=["Gmail", "Google Calendar"]
+              )`
+
+        **Pro Tips:**
+        - Use multiple search terms in a single query list to cast a wider net and discover related functionality
+        - Multi-term searches are more efficient than separate calls
+        - Scoped searches return more focused results than global searches
+        - The function returns connection status for each app (connected vs NOT connected)
+        - All searches within a single call execute in parallel for maximum efficiency
+
+        **Parameters:**
+        - `queries` (List[List[str]], optional): A list of query lists. Each inner list contains one or more
+          search terms that will be used together to find relevant tools.
+        - `app_ids` (List[str], optional): A list of application IDs to search within or discover.
+
+        **Returns:**
+        - A structured response containing:
+          - Matched tools with their descriptions
+          - Connection status for each app
+          - Recommendations for which tools to load next
         """
-        if isinstance(queries, str):  # Handle JSON string input
-            try:
-                queries = json.loads(queries)
-            except json.JSONDecodeError:
-                # If it's a single query as a string, convert to list
-                queries = [queries] if queries else None
+        registry = tool_registry
 
-        if not queries and not app_id:
-            raise ValueError("You must provide 'queries', an 'app_id', or both.")
+        TOOL_THRESHOLD = 0.75
+        APP_THRESHOLD = 0.7
 
-        registry = tool_registry
-        connections = await registry.list_connected_apps()
-        connected_app_ids = {connection["app_id"] for connection in connections}
+        # --- Helper Functions for Different Search Modes ---
 
-        canonical_app_id = None
-        found_tools_result = []
-        THRESHOLD = 0.8
-
-        if app_id:
-            relevant_apps = await registry.search_apps(query=app_id, distance_threshold=THRESHOLD)
-            if not relevant_apps:
-                return {
-                    "found_tools": [],
-                    "message": f"Search failed. Application '{app_id}' was not found.",
-                }
-            canonical_app_id = relevant_apps[0]["id"]
-
-        if canonical_app_id and not queries:
-            all_app_tools = await registry.search_tools(query="", app_id=canonical_app_id, limit=20)
-
-            tool_list = []
-            for tool in all_app_tools:
-                cleaned_description = tool.get("description", "").split("Context:")[0].strip()
-                tool_list.append({"id": tool["id"], "description": cleaned_description})
-
-            found_tools_result.append(
-                {
-                    "app_id": canonical_app_id,
-                    "connection_status": "connected" if canonical_app_id in connected_app_ids else "not_connected",
-                    "tools": tool_list,
-                }
-            )
+        async def _handle_global_search(queries: list[str]) -> list[list[dict[str, Any]]]:
+            """Performs a broad search across all apps to find relevant tools and apps."""
+            # 1. Perform initial broad searches for tools and apps concurrently.
+            initial_tool_tasks = [registry.search_tools(query=q, distance_threshold=TOOL_THRESHOLD) for q in queries]
+            app_search_tasks = [registry.search_apps(query=q, distance_threshold=APP_THRESHOLD) for q in queries]
 
-        else:
-            query_results = []
-            prioritized_app_id_list = []
+            initial_tool_results, app_search_results = await asyncio.gather(
+                asyncio.gather(*initial_tool_tasks), asyncio.gather(*app_search_tasks)
+            )
 
-            if canonical_app_id:
-                prioritized_app_id_list = [canonical_app_id]
-            else:
-                # 1. Perform an initial broad search for tools.
-                initial_tool_search_tasks = [
-                    registry.search_tools(query=q, distance_threshold=THRESHOLD) for q in queries
-                ]
-                initial_tool_results = await asyncio.gather(*initial_tool_search_tasks)
-
-                # 2. Search for relevant apps.
-                app_search_tasks = [registry.search_apps(query=q, distance_threshold=THRESHOLD) for q in queries]
-                app_search_results = await asyncio.gather(*app_search_tasks)
-
-                # 3. Create a prioritized list of app IDs for the final search.
-                # Apps found via search_apps are considered higher priority and come first.
-                app_ids_from_apps = {app["id"] for result_list in app_search_results for app in result_list}
-                # Use a list to maintain order.
-                prioritized_app_id_list.extend(list(app_ids_from_apps))
-
-                # Add app_ids from the initial tool search, ensuring no duplicates.
-                app_ids_from_tools = {tool["app_id"] for result_list in initial_tool_results for tool in result_list}
-
-                for tool_app_id in app_ids_from_tools:
-                    if tool_app_id not in app_ids_from_apps:
-                        prioritized_app_id_list.append(tool_app_id)
-
-            # 4. Perform the final, comprehensive tool search across the prioritized list of apps.
-            if prioritized_app_id_list:
-                # print(f"Prioritized app IDs for final search: {prioritized_app_id_list}")
-                final_tool_search_tasks = []
-                for app_id_to_search in prioritized_app_id_list:
-                    for query in queries:
-                        final_tool_search_tasks.append(
-                            registry.search_tools(query=query, app_id=app_id_to_search, distance_threshold=THRESHOLD)
-                        )
-                query_results = await asyncio.gather(*final_tool_search_tasks)
-
-            # 5. Aggregate all found tools for easy lookup.
+            # 2. Create a prioritized list of app IDs for the final search.
+            app_ids_from_apps = {app["id"] for result_list in app_search_results for app in result_list}
+            prioritized_app_id_list = list(app_ids_from_apps)
+
+            app_ids_from_tools = {tool["app_id"] for result_list in initial_tool_results for tool in result_list}
+            for tool_app_id in app_ids_from_tools:
+                if tool_app_id not in app_ids_from_apps:
+                    prioritized_app_id_list.append(tool_app_id)
+
+            if not prioritized_app_id_list:
+                return []
+
+            # 3. Perform the final, comprehensive tool search across the prioritized apps.
+            final_tool_search_tasks = [
+                registry.search_tools(query=query, app_id=app_id_to_search, distance_threshold=TOOL_THRESHOLD)
+                for app_id_to_search in prioritized_app_id_list
+                for query in queries
+            ]
+            return await asyncio.gather(*final_tool_search_tasks)
+
+        async def _handle_scoped_search(app_ids: list[str], queries: list[list[str]]) -> list[list[dict[str, Any]]]:
+            """Performs targeted searches for specific queries within specific applications."""
+            if len(app_ids) != len(queries):
+                raise ValueError("The number of app_ids must match the number of query lists.")
+
+            tasks = []
+            for app_id, query_list in zip(app_ids, queries):
+                for query in query_list:
+                    # Create a search task for each query in the list for the corresponding app
+                    tasks.append(registry.search_tools(query=query, app_id=app_id, distance_threshold=TOOL_THRESHOLD))
+
+            return await asyncio.gather(*tasks)
+
+        async def _handle_app_discovery(app_ids: list[str]) -> list[list[dict[str, Any]]]:
+            """Fetches all tools for a list of applications."""
+            tasks = [registry.search_tools(query="", app_id=app_id, limit=20) for app_id in app_ids]
+            return await asyncio.gather(*tasks)
+
+        # --- Helper Functions for Structuring and Formatting Results ---
+
+        def _format_response(structured_results: list[dict[str, Any]]) -> str:
+            """Builds the final, user-facing formatted string response from structured data."""
+            if not structured_results:
+                return "No relevant functions were found."
+
+            result_parts = []
+            apps_in_results = {app["app_id"] for app in structured_results}
+            connected_apps_in_results = {
+                app["app_id"] for app in structured_results if app["connection_status"] == "connected"
+            }
+
+            for app in structured_results:
+                app_id = app["app_id"]
+                app_status = "connected" if app["connection_status"] == "connected" else "NOT connected"
+                result_parts.append(f"Tools from {app_id} (status: {app_status} by user):")
+
+                for tool in app["tools"]:
+                    result_parts.append(f" - {tool['id']}: {tool['description']}")
+                result_parts.append("")  # Empty line for readability
+
+            # Add summary connection status messages
+            if not connected_apps_in_results and len(apps_in_results) > 1:
+                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(sorted(list(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.")
+            if 0 < len(connected_apps_in_results) < len(apps_in_results):
+                result_parts.append(
+                    "Unconnected app functions can also be loaded if required by the user, "
+                    "but prefer connected ones. Ask the user to choose if none of the "
+                    "relevant apps are connected."
+                )
+
+            return "\n".join(result_parts)
+
+        def _structure_tool_results(
+            raw_tool_lists: list[list[dict[str, Any]]], connected_app_ids: set[str]
+        ) -> list[dict[str, Any]]:
+            """
+            Converts raw search results into a structured format, handling duplicates,
+            cleaning descriptions, and adding connection status.
+            """
             aggregated_tools = defaultdict(dict)
-            for tool_list in query_results:
+            # Use a list to maintain the order of apps as they are found.
+            ordered_app_ids = []
+
+            for tool_list in raw_tool_lists:
                 for tool in tool_list:
-                    app_id_from_tool = tool.get("app_id", "unknown")
+                    app_id = tool.get("app_id", "unknown")
                     tool_id = tool.get("id")
-                    if not tool_id or tool_id in aggregated_tools[app_id_from_tool]:
+
+                    if not tool_id:
                         continue
-                    cleaned_description = tool.get("description", "").split("Context:")[0].strip()
-                    aggregated_tools[app_id_from_tool][tool_id] = {
-                        "id": tool_id,
-                        "description": cleaned_description,
-                    }
-
-            # 6. Build the final results list, respecting the prioritized app order.
-            for app_id_from_list in prioritized_app_id_list:
-                if app_id_from_list in aggregated_tools and aggregated_tools[app_id_from_list]:
+
+                    if app_id not in aggregated_tools:
+                        ordered_app_ids.append(app_id)
+
+                    if tool_id not in aggregated_tools[app_id]:
+                        aggregated_tools[app_id][tool_id] = {
+                            "id": tool_id,
+                            "description": _clean_tool_description(tool.get("description", "")),
+                        }
+
+            # Build the final results list respecting the discovery order.
+            found_tools_result = []
+            for app_id in ordered_app_ids:
+                if app_id in aggregated_tools and aggregated_tools[app_id]:
                     found_tools_result.append(
                         {
-                            "app_id": app_id_from_list,
-                            "connection_status": "connected"
-                            if app_id_from_list in connected_app_ids
-                            else "not_connected",
-                            "tools": list(aggregated_tools[app_id_from_list].values()),
+                            "app_id": app_id,
+                            "connection_status": "connected" if app_id in connected_app_ids else "not_connected",
+                            "tools": list(aggregated_tools[app_id].values()),
                         }
                     )
+            return found_tools_result
 
-        # Build result string efficiently
-        result_parts = []
-        apps_in_results = {app["app_id"] for app in found_tools_result}
-        connected_apps_in_results = apps_in_results.intersection(connected_app_ids)
-
-        for app in found_tools_result:
-            app_id = app["app_id"]
-            connection_status = app["connection_status"]
-            tools = app["tools"]
-
-            app_status = "connected" if connection_status == "connected" else "NOT connected"
-            result_parts.append(f"Tools from {app_id} (status: {app_status} by user):")
-
-            for tool in tools:
-                tool_id = tool["id"]
-                description = tool["description"]
-                result_parts.append(f" - {tool_id}: {description}")
-            result_parts.append("")  # Empty line between apps
-
-        # Add connection status information
-        if len(connected_apps_in_results) == 0 and len(apps_in_results) > 1:
-            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."
+        def _clean_tool_description(description: str) -> str:
+            """Consistently formats tool descriptions by removing implementation details."""
+            return description.split("Context:")[0].strip()
+
+        # Main Function Logic
+
+        if not queries and not app_ids:
+            raise ValueError("You must provide 'queries', 'app_ids', or both.")
+
+        # --- Initialization and Input Normalization ---
+        connections = await registry.list_connected_apps()
+        connected_app_ids = {connection["app_id"] for connection in connections}
+
+        canonical_app_ids = []
+        if app_ids:
+            # Concurrently search for all provided app names
+            app_search_tasks = [
+                registry.search_apps(query=app_name, distance_threshold=APP_THRESHOLD) for app_name in app_ids
+            ]
+            app_search_results = await asyncio.gather(*app_search_tasks)
+
+            # Process results and build the list of canonical IDs, handling not found errors
+            for app_name, result_list in zip(app_ids, app_search_results):
+                if not result_list:
+                    raise ValueError(f"Application '{app_name}' could not be found.")
+                # Assume the first result is the correct one
+                canonical_app_ids.append(result_list[0]["id"])
+
+        # --- Mode Dispatching ---
+        raw_results = []
+
+        if canonical_app_ids and queries:
+            raw_results = await _handle_scoped_search(canonical_app_ids, queries)
+        elif canonical_app_ids:
+            raw_results = await _handle_app_discovery(canonical_app_ids)
+        elif queries:
+            # Flatten list of lists to list of strings for global search
+            flat_queries = (
+                [q for sublist in queries for q in sublist] if queries and not isinstance(queries[0], str) else queries
             )
+            raw_results = await _handle_global_search(flat_queries)
 
-        result_parts.append("Call load_functions to select the required functions only.")
-        if len(connected_apps_in_results)<len(apps_in_results) and len(connected_apps_in_results)>0:
-            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones. And do ask the user to choose if none of the relevant apps are connected")
-        return "\n".join(result_parts)
+        # --- Structuring and Formatting ---
+        structured_data = _structure_tool_results(raw_results, connected_app_ids)
+        return _format_response(structured_data)
 
     @tool
     async def load_functions(tool_ids: list[str]) -> str:
@@ -263,7 +366,95 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             "citations": response.get("citations", []),
         }
 
-    return {"search_functions": search_functions, "load_functions": load_functions, "web_search": web_search}
+    async def read_file(uri: str) -> str:
+        """
+        Asynchronously reads a local file or uri and returns the content as a markdown string.
+
+        This tool aims to extract the main text content from various sources.
+        It automatically prepends 'file://' to the input string if it appears
+        to be a local path without a specified scheme (like http, https, data, file).
+
+        Args:
+            uri (str): The URI pointing to the resource or a local file path.
+                       Supported schemes:
+                       - http:// or https:// (Web pages, feeds, APIs)
+                       - file:// (Local or accessible network files)
+                       - data: (Embedded data)
+
+        Returns:
+            A string containing the markdown representation of the content at the specified URI
+
+        Raises:
+            ValueError: If the URI is invalid, empty, or uses an unsupported scheme
+                        after automatic prefixing.
+
+        Tags:
+            convert, markdown, async, uri, transform, document, important
+        """
+        markitdown = MarkitdownApp()
+        response = await markitdown.convert_to_markdown(uri)
+        return response
+
+    async def save_file(file_name: str, content: str) -> dict:
+        """
+        Saves a file to the local filesystem.
+
+        Args:
+            file_name (str): The name of the file to save.
+            content (str): The content to save to the file.
+
+        Returns:
+            dict: A dictionary containing the result of the save operation with the following fields:
+                - status (str): "success" if the save succeeded, "error" otherwise.
+                - message (str): A message returned by the server, typically indicating success or providing error details.
+        """
+        with Path(file_name).open("w") as f:
+            f.write(content)
+
+        return {
+            "status": "success",
+            "message": f"File {file_name} saved successfully",
+            "file_path": Path(file_name).absolute(),
+        }
+
+    async def upload_file(file_name: str, mime_type: str, base64_data: str) -> dict:
+        """
+        Uploads a file to the server via the AgentrClient.
+
+        Args:
+            file_name (str): The name of the file to upload.
+            mime_type (str): The MIME type of the file.
+            base64_data (str): The file content encoded as a base64 string.
+
+        Returns:
+            dict: A dictionary containing the result of the upload operation with the following fields:
+                - status (str): "success" if the upload succeeded, "error" otherwise.
+                - message (str): A message returned by the server, typically indicating success or providing error details.
+                - signed_url (str or None): The signed URL to access the uploaded file if successful, None otherwise.
+        """
+        client: AgentrClient = tool_registry.client
+        bytes_data = base64.b64decode(base64_data)
+        response = client._upload_file(file_name, mime_type, bytes_data)
+        if response.get("status") != "success":
+            return {
+                "status": "error",
+                "message": response.get("message"),
+                "signed_url": None,
+            }
+        return {
+            "status": "success",
+            "message": response.get("message"),
+            "signed_url": response.get("signed_url"),
+        }
+
+    return {
+        "search_functions": search_functions,
+        "load_functions": load_functions,
+        "web_search": web_search,
+        "read_file": read_file,
+        "upload_file": upload_file,
+        "save_file": save_file,
+    }
 
 
 async def get_valid_tools(tool_ids: list[str], registry: AgentrRegistry) -> tuple[list[str], list[str]]:

universal_mcp/agents/codeact0/utils.py

@@ -4,7 +4,7 @@ import re
 from collections.abc import Sequence
 from typing import Any
 
-from langchain_core.messages import AIMessage, ToolMessage, BaseMessage
+from langchain_core.messages import BaseMessage
 from universal_mcp.types import ToolConfig
 
 MAX_CHARS = 5000

universal_mcp/agents/llm.py

@@ -4,6 +4,7 @@ from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models import BaseChatModel
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_openai import AzureChatOpenAI
+from loguru import logger
 
 
 @lru_cache(maxsize=8)
@@ -41,8 +42,6 @@ def load_chat_model(
 
 
 if __name__ == "__main__":
-    from loguru import logger
-
     models_to_test = [
         "azure/gpt-5-chat",
         "anthropic/claude-4-sonnet-20250514",

universal_mcp/agents/sandbox.py

@@ -5,6 +5,7 @@ import io
 import traceback
 
 import cloudpickle as pickle
+from loguru import logger
 
 
 class Sandbox:
@@ -26,17 +27,37 @@ class Sandbox:
     def save_context(self) -> str:
         """
         Saves the context to a base64 string.
+        files, IO, threads, etc. are not pickable. So we only pickle the context that is pickable.
         """
-        pickled_data = pickle.dumps(self.context)
+        pickable_context = {}
+        for key, value in self.context.items():
+            try:
+                pickle.dumps(value)
+                pickable_context[key] = value
+            except Exception as e:
+                logger.error(f"Error picking {key}: {e}")
+        pickled_data = pickle.dumps(pickable_context)
         base64_encoded = base64.b64encode(pickled_data).decode("utf-8")
         return base64_encoded
 
-    def load_context(self, context: str):
+    def load_context(self, context: str, add_context: list[str] = []):
         """
         Loads the context from a base64 string.
+        Also executes the add_context code strings to add to the context.
         """
-        pickled_data = base64.b64decode(context)
-        self.context = pickle.loads(pickled_data)
+        if context:
+            pickled_data = base64.b64decode(context)
+            new_context = pickle.loads(pickled_data)
+            self.context.update(new_context)
+        for code in add_context:
+            self.run(code)
+        return self.context
+
+    def _filter_context(self, context: dict[str, any]) -> dict[str, any]:
+        """
+        Filters the context to only include pickable variables.
+        """
+        return {k: v for k, v in context.items() if not k.startswith("__")}
 
     def run(self, code: str) -> dict[str, any]:
         """
@@ -64,7 +85,7 @@ class Sandbox:
 
             # Update the context with any new/modified variables
             # Filter out dunder methods/system keys that might be introduced by exec
-            new_context = {k: v for k, v in exec_scope.items() if not k.startswith("__")}
+            new_context = self._filter_context(exec_scope)
             self.context.update(new_context)
 
         except Exception:
@@ -114,8 +135,9 @@ class Sandbox:
                     await coroutine
 
             # Update the context with any new/modified variables
-            new_context = {k: v for k, v in exec_scope.items() if not k.startswith("__")}
-            self.context.update(new_context)
+            new_context = self._filter_context(exec_scope)
+            if new_context:
+                self.context.update(new_context)
 
         except Exception:
             stderr_output = traceback.format_exc()

universal_mcp/applications/llm/app.py

@@ -1,7 +1,7 @@
 import json
 from typing import Any, Literal, cast
 
-from langchain.chat_models import init_chat_model
+from langchain.agents import create_agent
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
@@ -38,7 +38,7 @@ class LlmApp(BaseApplication):
         """Initialize the LLMApp."""
         super().__init__(name="llm")
 
-    def generate_text(
+    async def generate_text(
         self,
         task: str,
         context: str | list[str] | dict[str, str] = "",
@@ -92,10 +92,10 @@ class LlmApp(BaseApplication):
         full_prompt = f"{prompt}\n\nContext:\n{context_str}\n\n"
 
         model = load_chat_model("azure/gpt-5-mini")
-        response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt)
+        response = await model.with_retry(stop_after_attempt=MAX_RETRIES).ainvoke(full_prompt)
         return str(response.content)
 
-    def classify_data(
+    async def classify_data(
         self,
         classification_task_and_requirements: str,
         context: Any | list[Any] | dict[str, Any],
@@ -151,24 +151,24 @@ class LlmApp(BaseApplication):
             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"
-            "Return ONLY a valid JSON object, no extra text."
         )
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-
         class ClassificationResult(BaseModel):
             probabilities: dict[str, float] = Field(..., description="The probabilities for each class.")
             reason: str = Field(..., description="The reasoning behind the classification.")
             top_class: str = Field(..., description="The class with the highest probability.")
 
-        response = (
-            model.with_structured_output(schema=ClassificationResult)
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
+        agent = create_agent(
+            model=model,
+            tools=[],
+            response_format=ClassificationResult,  # Auto-selects ProviderStrategy
         )
-        return response.model_dump()
 
-    def extract_data(
+        result = await agent.ainvoke({"messages": [{"role": "user", "content": prompt}]})
+        return result["structured_response"].model_dump()
+
+    async def extract_data(
         self,
         extraction_task: str,
         source: Any | list[Any] | dict[str, Any],
@@ -229,16 +229,16 @@ class LlmApp(BaseApplication):
             "Return ONLY a valid JSON object that conforms to the provided schema, with no extra text."
         )
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = (
+        response = await (
             model.with_structured_output(schema=output_schema, method="json_mode")
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+            .ainvoke(prompt)
         )
         return cast(dict[str, Any], response)
 
-    def call_llm(
+    async def call_llm(
         self,
         task_instructions: str,
         context: Any | list[Any] | dict[str, Any],
@@ -282,14 +282,15 @@ class LlmApp(BaseApplication):
 
         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)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = (
-            model.with_structured_output(schema=output_schema, method="json_mode")
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+        agent = create_agent(
+            model=model,
+            tools=[],
+            response_format=output_schema,
         )
-        return cast(dict[str, Any], response)
+        result = await agent.ainvoke({"messages": [{"role": "user", "content": prompt}]})
+        return result["structured_response"]
 
     def list_tools(self):
         return [

{universal_mcp_agents-0.1.23rc7.dist-info → universal_mcp_agents-0.1.23rc9.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
 universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-ww4,914
-universal_mcp/agents/base.py,sha256=pnPf5EgVVoycg_mrgdIwqEiENny1Dcx6GDZWmOVw2NU,7837
+universal_mcp/agents/base.py,sha256=IyU1HUmB8rjHuCxv-c29RV-dWXfdiQiPq5rGkcCiSbU,7833
 universal_mcp/agents/cli.py,sha256=9CG7majpWUz7C6t0d8xr-Sg2ZPKBuQdykTbYS6KIZ3A,922
 universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
-universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
+universal_mcp/agents/llm.py,sha256=S6dI3xaeVS8rKa2ttXToOYf_mI-6rm0E9XwE5nm3uko,1782
 universal_mcp/agents/react.py,sha256=ocYm94HOiJVI2zwTjO1K2PNfVY7EILLJ6cd__jnGHPs,3327
-universal_mcp/agents/sandbox.py,sha256=LL4OfavEzxbmTDcc_NxizRRpQnw5hc3G2bxvFY63scY,4241
+universal_mcp/agents/sandbox.py,sha256=YxTGp_zsajuN7FUn0Q4PFjuXczgLht7oKql_gyb2Gf4,5112
 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
@@ -22,23 +22,23 @@ universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQ
 universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
 universal_mcp/agents/codeact0/__init__.py,sha256=8-fvUo1Sm6dURGI-lW-X3Kd78LqySYbb5NMkNJ4NDwg,76
 universal_mcp/agents/codeact0/__main__.py,sha256=YyIoecUcKVUhTcCACzLlSmYrayMDsdwzDEqaV4VV4CE,766
-universal_mcp/agents/codeact0/agent.py,sha256=lixuPcFLEaWl3IgJ7pY9JSLz9UxH5t9F9FJVEIELydA,22507
+universal_mcp/agents/codeact0/agent.py,sha256=CRgbKCBHSbMOpiNp_Sgdb-Wml7o9Uy72aA9_DaPNiJA,23449
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
 universal_mcp/agents/codeact0/langgraph_agent.py,sha256=8nz2wq-LexImx-l1y9_f81fK72IQetnCeljwgnduNGY,420
 universal_mcp/agents/codeact0/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4EbU0tiuF_UNU,798
-universal_mcp/agents/codeact0/prompts.py,sha256=re1DHkfC6kyy1Y2pgmPLMZ_TceKZHZk-0-csCPHnQjw,15344
-universal_mcp/agents/codeact0/sandbox.py,sha256=FcJgJ64upa8NMcFDLXkT7FT69AQvUvPBiXyqW937AUo,4701
+universal_mcp/agents/codeact0/prompts.py,sha256=RiC_43GSeE4LDoiFhmJIOsKkoijOK9_7skwAH6ZqSWk,15501
+universal_mcp/agents/codeact0/sandbox.py,sha256=Zcr7fvYtcGbwNWd7RPV7-Btl2HtycPIPofEGVmzxSmE,4696
 universal_mcp/agents/codeact0/state.py,sha256=cf-94hfVub-HSQJk6b7_SzqBS-oxMABjFa8jqyjdDK0,1925
-universal_mcp/agents/codeact0/tools.py,sha256=e-ucTRkXuHEagEAWo2OPWh28UGeYlKzeNhi5cM7lqPc,15007
-universal_mcp/agents/codeact0/utils.py,sha256=a0ux1icTSB6ETIZ_X2azZxlP44LBx95bi7wchQWpnuY,18188
+universal_mcp/agents/codeact0/tools.py,sha256=oaGBzto6yaysPPEwV0bpAHH8QASjEaTIey_zJHxmNyY,23182
+universal_mcp/agents/codeact0/utils.py,sha256=Gvft0W0Sg1qlFWm8ciX14yssCa8y3x037lql92yGsBQ,18164
 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/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=4aMDlbBFCJIe_yzSq3Jphtk5ctvjWhHkHfSfnh3_Mso,12714
+universal_mcp/applications/llm/app.py,sha256=D3j5f5BUD2ZL2CXfc9z2KD5_PCbeqo7-GcWA0rEhAw0,12757
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc7.dist-info/METADATA,sha256=Up-hGsxUw2JH3vSa9FipSTF45ROWOMiySV0DItN4Cx8,931
-universal_mcp_agents-0.1.23rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc7.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc9.dist-info/METADATA,sha256=WmURY6Ks9IBtLdL4gKfyife2jQ1IVQjjCI4yPW1xUw8,931
+universal_mcp_agents-0.1.23rc9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc9.dist-info/RECORD,,