universal-mcp-agents 0.1.23rc8__py3-none-any.whl → 0.1.23rc10__py3-none-any.whl

universal_mcp/agents/codeact0/tools.py

@@ -1,6 +1,5 @@
 import asyncio
 import base64
-import json
 from collections import defaultdict
 from pathlib import Path
 from typing import Annotated, Any
@@ -26,181 +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 ---
+
+        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]
 
-        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,
-                }
+            initial_tool_results, app_search_results = await asyncio.gather(
+                asyncio.gather(*initial_tool_tasks), asyncio.gather(*app_search_tasks)
             )
 
-        else:
-            query_results = []
-            prioritized_app_id_list = []
+            # 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"
+            }
 
-            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.
+            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
 
-        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"
+        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
             )
-        return "\n".join(result_parts)
+            raw_results = await _handle_global_search(flat_queries)
+
+        # --- 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:

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

@@ -1,6 +1,7 @@
 import json
 from typing import Any, Literal, cast
 
+from langchain.agents import create_agent
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
@@ -37,7 +38,7 @@ class LlmApp(BaseApplication):
         """Initialize the LLMApp."""
         super().__init__(name="llm")
 
-    async def generate_text(
+    def generate_text(
         self,
         task: str,
         context: str | list[str] | dict[str, str] = "",
@@ -91,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 = await model.with_retry(stop_after_attempt=MAX_RETRIES).ainvoke(full_prompt)
+        response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt, stream=False)
         return str(response.content)
 
-    async def classify_data(
+    def classify_data(
         self,
         classification_task_and_requirements: str,
         context: Any | list[Any] | dict[str, Any],
@@ -150,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 = load_chat_model("azure/gpt-5-mini", 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 = (
-            await model.with_structured_output(schema=ClassificationResult)
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .ainvoke(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()
 
-    async def extract_data(
+        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
+        return result["structured_response"].model_dump()
+
+    def extract_data(
         self,
         extraction_task: str,
         source: Any | list[Any] | dict[str, Any],
@@ -230,14 +231,14 @@ class LlmApp(BaseApplication):
 
         model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = await (
+        response = (
             model.with_structured_output(schema=output_schema, method="json_mode")
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .ainvoke(prompt)
+            .invoke(prompt, stream=False)
         )
         return cast(dict[str, Any], response)
 
-    async def call_llm(
+    def call_llm(
         self,
         task_instructions: str,
         context: Any | list[Any] | dict[str, Any],
@@ -283,12 +284,13 @@ class LlmApp(BaseApplication):
 
         model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = await (
-            model.with_structured_output(schema=output_schema)
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .ainvoke(prompt)
+        agent = create_agent(
+            model=model,
+            tools=[],
+            response_format=output_schema,
         )
-        return response.model_dump()
+        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
+        return result["structured_response"]
 
     def list_tools(self):
         return [

{universal_mcp_agents-0.1.23rc8.dist-info → universal_mcp_agents-0.1.23rc10.dist-info}/METADATA

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

@@ -2,7 +2,7 @@ universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-
 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=YxTGp_zsajuN7FUn0Q4PFjuXczgLht7oKql_gyb2Gf4,5112
 universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
@@ -29,7 +29,7 @@ universal_mcp/agents/codeact0/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4
 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=kWFlEfJdbOPugPMbsP7I-vxFMGfZj3FUilMI-aT7-Xw,18753
+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
@@ -37,8 +37,8 @@ universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb
 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=zcMCcswJxvbk2jN_x4xpiv2IG2yoJ62jH1CQaNltmYs,12645
+universal_mcp/applications/llm/app.py,sha256=y84p2gIIsgTG5A1fxtZCPUAr3k4qacg8bp2jntBxy8A,12761
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc8.dist-info/METADATA,sha256=q1hNCeGDqDDTJ5TWkQkh8JuHoXyNgNZEbDOXViM-xM0,931
-universal_mcp_agents-0.1.23rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc8.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc10.dist-info/METADATA,sha256=J2tqsjN2LrLGdhyhjLGKwQHrXWenn2D4rH5Mqp20QWc,932
+universal_mcp_agents-0.1.23rc10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc10.dist-info/RECORD,,