swarms 7.8.7__py3-none-any.whl → 7.8.9__py3-none-any.whl

swarms/structs/agent.py

@@ -72,8 +72,10 @@ from swarms.prompts.max_loop_prompt import generate_reasoning_prompt
 from swarms.prompts.safety_prompt import SAFETY_PROMPT
 from swarms.structs.ma_utils import set_random_models_for_agents
 from swarms.tools.mcp_client_call import (
+    execute_multiple_tools_on_multiple_mcp_servers_sync,
     execute_tool_call_simple,
     get_mcp_tools_sync,
+    get_tools_for_multiple_mcp_servers,
 )
 from swarms.schemas.mcp_schemas import (
     MCPConnection,
@@ -81,7 +83,6 @@ from swarms.schemas.mcp_schemas import (
 from swarms.utils.index import (
     exists,
     format_data_structure,
-    format_dict_to_string,
 )
 from swarms.schemas.conversation_schema import ConversationSchema
 from swarms.utils.output_types import OutputType
@@ -417,7 +418,8 @@ class Agent:
         llm_base_url: Optional[str] = None,
         llm_api_key: Optional[str] = None,
         rag_config: Optional[RAGConfig] = None,
-        no_tool_call_summary: bool = False,
+        tool_call_summary: bool = True,
+        output_raw_json_from_tool_call: bool = False,
         *args,
         **kwargs,
     ):
@@ -446,7 +448,10 @@ class Agent:
         self.system_prompt = system_prompt
         self.agent_name = agent_name
         self.agent_description = agent_description
-        self.saved_state_path = f"{self.agent_name}_{generate_api_key(prefix='agent-')}_state.json"
+        # self.saved_state_path = f"{self.agent_name}_{generate_api_key(prefix='agent-')}_state.json"
+        self.saved_state_path = (
+            f"{generate_api_key(prefix='agent-')}_state.json"
+        )
         self.autosave = autosave
         self.response_filters = []
         self.self_healing_enabled = self_healing_enabled
@@ -549,7 +554,10 @@ class Agent:
         self.llm_base_url = llm_base_url
         self.llm_api_key = llm_api_key
         self.rag_config = rag_config
-        self.no_tool_call_summary = no_tool_call_summary
+        self.tool_call_summary = tool_call_summary
+        self.output_raw_json_from_tool_call = (
+            output_raw_json_from_tool_call
+        )
 
         # self.short_memory = self.short_memory_init()
 
@@ -623,7 +631,7 @@ class Agent:
 
         self.short_memory.add(
             role=f"{self.agent_name}",
-            content=f"Tools available: {format_data_structure(self.tools_list_dictionary)}",
+            content=self.tools_list_dictionary,
         )
 
     def short_memory_init(self):
@@ -692,6 +700,10 @@ class Agent:
 
         if exists(self.tools) and len(self.tools) >= 2:
             parallel_tool_calls = True
+        elif exists(self.mcp_url) or exists(self.mcp_urls):
+            parallel_tool_calls = True
+        elif exists(self.mcp_config):
+            parallel_tool_calls = True
         else:
             parallel_tool_calls = False
 
@@ -714,7 +726,7 @@ class Agent:
                     parallel_tool_calls=parallel_tool_calls,
                 )
 
-            elif self.mcp_url is not None:
+            elif exists(self.mcp_url) or exists(self.mcp_urls):
                 self.llm = LiteLLM(
                     **common_args,
                     tools_list_dictionary=self.add_mcp_tools_to_memory(),
@@ -752,15 +764,27 @@ class Agent:
                 tools = get_mcp_tools_sync(server_path=self.mcp_url)
             elif exists(self.mcp_config):
                 tools = get_mcp_tools_sync(connection=self.mcp_config)
-                logger.info(f"Tools: {tools}")
+                # logger.info(f"Tools: {tools}")
+            elif exists(self.mcp_urls):
+                tools = get_tools_for_multiple_mcp_servers(
+                    urls=self.mcp_urls,
+                    output_type="str",
+                )
+                # print(f"Tools: {tools} for {self.mcp_urls}")
             else:
                 raise AgentMCPConnectionError(
                     "mcp_url must be either a string URL or MCPConnection object"
                 )
-            self.pretty_print(
-                f"✨ [SYSTEM] Successfully integrated {len(tools)} MCP tools into agent: {self.agent_name} | Status: ONLINE | Time: {time.strftime('%H:%M:%S')} ✨",
-                loop_count=0,
-            )
+
+            if (
+                exists(self.mcp_url)
+                or exists(self.mcp_urls)
+                or exists(self.mcp_config)
+            ):
+                self.pretty_print(
+                    f"✨ [SYSTEM] Successfully integrated {len(tools)} MCP tools into agent: {self.agent_name} | Status: ONLINE | Time: {time.strftime('%H:%M:%S')} ✨",
+                    loop_count=0,
+                )
 
             return tools
         except AgentMCPConnectionError as e:
@@ -939,7 +963,7 @@ class Agent:
 
             self.short_memory.add(role=self.user_name, content=task)
 
-            if self.plan_enabled:
+            if self.plan_enabled or self.planning_prompt is not None:
                 self.plan(task)
 
             # Set the loop count
@@ -1006,55 +1030,51 @@ class Agent:
                             )
                             self.memory_query(task_prompt)
 
-                        # # Generate response using LLM
-                        # response_args = (
-                        #     (task_prompt, *args)
-                        #     if img is None
-                        #     else (task_prompt, img, *args)
-                        # )
-
-                        # # Call the LLM
-                        # response = self.call_llm(
-                        #     *response_args, **kwargs
-                        # )
-
                         response = self.call_llm(
                             task=task_prompt, img=img, *args, **kwargs
                         )
 
+                        print(f"Response: {response}")
+
                         if exists(self.tools_list_dictionary):
                             if isinstance(response, BaseModel):
                                 response = response.model_dump()
 
-                        # # Convert to a str if the response is not a str
-                        # if self.mcp_url is None or self.tools is None:
+                        # Parse the response from the agent with the output type
                         response = self.parse_llm_output(response)
 
                         self.short_memory.add(
                             role=self.agent_name,
-                            content=format_dict_to_string(response),
+                            content=response,
                         )
 
                         # Print
                         self.pretty_print(response, loop_count)
 
-                        # # Output Cleaner
-                        # self.output_cleaner_op(response)
-
-                        # Check and execute tools
+                        # Check and execute callable tools
                         if exists(self.tools):
 
-                            self.execute_tools(
-                                response=response,
-                                loop_count=loop_count,
-                            )
+                            if (
+                                self.output_raw_json_from_tool_call
+                                is True
+                            ):
+                                print(type(response))
+                                response = response
+                            else:
+                                self.execute_tools(
+                                    response=response,
+                                    loop_count=loop_count,
+                                )
 
                         # Handle MCP tools
-                        if exists(self.mcp_url) or exists(
-                            self.mcp_config
+                        if (
+                            exists(self.mcp_url)
+                            or exists(self.mcp_config)
+                            or exists(self.mcp_urls)
                         ):
                             self.mcp_tool_handling(
-                                response, loop_count
+                                response=response,
+                                current_loop=loop_count,
                             )
 
                         self.sentiment_and_evaluator(response)
@@ -1298,26 +1318,47 @@ class Agent:
 
     def plan(self, task: str, *args, **kwargs) -> None:
         """
-        Plan the task
+        Create a strategic plan for executing the given task.
+
+        This method generates a step-by-step plan by combining the conversation
+        history, planning prompt, and current task. The plan is then added to
+        the agent's short-term memory for reference during execution.
 
         Args:
-            task (str): The task to plan
+            task (str): The task to create a plan for
+            *args: Additional positional arguments passed to the LLM
+            **kwargs: Additional keyword arguments passed to the LLM
+
+        Returns:
+            None: The plan is stored in memory rather than returned
+
+        Raises:
+            Exception: If planning fails, the original exception is re-raised
         """
         try:
-            if exists(self.planning_prompt):
-                # Join the plan and the task
-                planning_prompt = f"{self.planning_prompt} {task}"
-                plan = self.llm(planning_prompt, *args, **kwargs)
-                logger.info(f"Plan: {plan}")
+            # Get the current conversation history
+            history = self.short_memory.get_str()
 
-            # Add the plan to the memory
-            self.short_memory.add(
-                role=self.agent_name, content=str(plan)
+            # Construct the planning prompt by combining history, planning prompt, and task
+            planning_prompt = (
+                f"{history}\n\n{self.planning_prompt}\n\nTask: {task}"
             )
 
+            # Generate the plan using the LLM
+            plan = self.llm.run(task=planning_prompt, *args, **kwargs)
+
+            # Store the generated plan in short-term memory
+            self.short_memory.add(role=self.agent_name, content=plan)
+
+            logger.info(
+                f"Successfully created plan for task: {task[:50]}..."
+            )
             return None
+
         except Exception as error:
-            logger.error(f"Error planning task: {error}")
+            logger.error(
+                f"Failed to create plan for task '{task}': {error}"
+            )
             raise error
 
     async def run_concurrent(self, task: str, *args, **kwargs):
@@ -1440,7 +1481,6 @@ class Agent:
             raise AgentInitializationError(
                 f"Max tokens is set to {self.max_tokens}, but the model '{self.model_name}' only supports {get_max_tokens(self.model_name)} tokens. Please set max tokens to {get_max_tokens(self.model_name)} or less."
             )
-            
 
         if self.model_name not in model_list:
             logger.warning(
@@ -2664,7 +2704,7 @@ class Agent:
                 )  # Convert other dicts to string
 
             elif isinstance(response, BaseModel):
-                out = response.model_dump()
+                response = response.model_dump()
 
             # Handle List[BaseModel] responses
             elif (
@@ -2674,14 +2714,9 @@ class Agent:
             ):
                 return [item.model_dump() for item in response]
 
-            elif isinstance(response, list):
-                out = format_data_structure(response)
-            else:
-                out = str(response)
+            return response
 
-            return out
-
-        except Exception as e:
+        except AgentChatCompletionResponse as e:
             logger.error(f"Error parsing LLM output: {e}")
             raise ValueError(
                 f"Failed to parse LLM output: {type(response)}"
@@ -2738,6 +2773,15 @@ class Agent:
                         connection=self.mcp_config,
                     )
                 )
+            elif exists(self.mcp_urls):
+                tool_response = execute_multiple_tools_on_multiple_mcp_servers_sync(
+                    responses=response,
+                    urls=self.mcp_urls,
+                    output_type="json",
+                )
+                # tool_response = format_data_structure(tool_response)
+
+                print(f"Multiple MCP Tool Response: {tool_response}")
             else:
                 raise AgentMCPConnectionError(
                     "mcp_url must be either a string URL or MCPConnection object"
@@ -2745,7 +2789,7 @@ class Agent:
 
             # Get the text content from the tool response
             # execute_tool_call_simple returns a string directly, not an object with content attribute
-            text_content = f"MCP Tool Response: \n{json.dumps(tool_response, indent=2)}"
+            text_content = f"MCP Tool Response: \n\n {json.dumps(tool_response, indent=2)}"
 
             if self.no_print is False:
                 formatter.print_panel(
@@ -2818,7 +2862,7 @@ class Agent:
         # Now run the LLM again without tools - create a temporary LLM instance
         # instead of modifying the cached one
         # Create a temporary LLM instance without tools for the follow-up call
-        if self.no_tool_call_summary is False:
+        if self.tool_call_summary is True:
             temp_llm = self.temp_llm_instance_for_tool_summary()
 
             tool_response = temp_llm.run(

swarms/structs/conversation.py

@@ -1326,6 +1326,12 @@ class Conversation(BaseStructure):
             self.conversation_history[-1]["content"],
         )
 
+    def return_list_final(self):
+        """Return the final message as a list."""
+        return [
+            self.conversation_history[-1]["content"],
+        ]
+
     @classmethod
     def list_conversations(
         cls, conversations_dir: Optional[str] = None

swarms/structs/csv_to_agent.py

@@ -104,9 +104,7 @@ class AgentValidator:
                 model_name in model["model_name"]
                 for model in model_list
             ):
-                valid_models = [
-                    model["model_name"] for model in model_list
-                ]
+                [model["model_name"] for model in model_list]
                 raise AgentValidationError(
                     "Invalid model name. Must be one of the supported litellm models",
                     "model_name",

swarms/telemetry/__init__.py

@@ -4,11 +4,9 @@ from swarms.telemetry.main import (
     get_cpu_info,
     get_machine_id,
     get_os_version,
-    get_package_mismatches,
     get_pip_version,
     get_python_version,
     get_ram_info,
-    get_swarms_verison,
     get_system_info,
     get_user_device_data,
     system_info,
@@ -21,11 +19,9 @@ __all__ = [
     "generate_unique_identifier",
     "get_python_version",
     "get_pip_version",
-    "get_swarms_verison",
     "get_os_version",
     "get_cpu_info",
     "get_ram_info",
-    "get_package_mismatches",
     "system_info",
     "get_user_device_data",
 ]

swarms/telemetry/main.py

@@ -1,24 +1,16 @@
-import asyncio
-
-
+import os
 import datetime
 import hashlib
 import platform
 import socket
 import subprocess
 import uuid
-from concurrent.futures import ThreadPoolExecutor
-from functools import lru_cache
-from threading import Lock
 from typing import Dict
 
-import aiohttp
 import pkg_resources
 import psutil
+import requests
 import toml
-from requests import Session
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
 
 
 # Helper functions
@@ -263,134 +255,44 @@ def capture_system_data() -> Dict[str, str]:
         print(f"Failed to capture system data: {e}")
 
 
-# Global variables
-_session = None
-_session_lock = Lock()
-_executor = ThreadPoolExecutor(max_workers=10)
-_aiohttp_session = None
-
-
-def get_session() -> Session:
-    """Thread-safe session getter with optimized connection pooling"""
-    global _session
-    if _session is None:
-        with _session_lock:
-            if _session is None:  # Double-check pattern
-                _session = Session()
-                adapter = HTTPAdapter(
-                    pool_connections=1000,  # Increased pool size
-                    pool_maxsize=1000,  # Increased max size
-                    max_retries=Retry(
-                        total=3,
-                        backoff_factor=0.1,
-                        status_forcelist=[500, 502, 503, 504],
-                    ),
-                    pool_block=False,  # Non-blocking pool
-                )
-                _session.mount("http://", adapter)
-                _session.mount("https://", adapter)
-                _session.headers.update(
-                    {
-                        "Content-Type": "application/json",
-                        "Authorization": "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
-                        "Connection": "keep-alive",  # Enable keep-alive
-                    }
-                )
-    return _session
-
-
-@lru_cache(maxsize=2048, typed=True)
-def get_user_device_data_cached():
-    """Cached version with increased cache size"""
-    return get_user_device_data()
-
-
-async def get_aiohttp_session():
-    """Get or create aiohttp session for async requests"""
-    global _aiohttp_session
-    if _aiohttp_session is None or _aiohttp_session.closed:
-        timeout = aiohttp.ClientTimeout(total=10)
-        connector = aiohttp.TCPConnector(
-            limit=1000,  # Connection limit
-            ttl_dns_cache=300,  # DNS cache TTL
-            use_dns_cache=True,  # Enable DNS caching
-            keepalive_timeout=60,  # Keep-alive timeout
-        )
-        _aiohttp_session = aiohttp.ClientSession(
-            timeout=timeout,
-            connector=connector,
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
-            },
-        )
-    return _aiohttp_session
-
-
-async def log_agent_data_async(data_dict: dict):
-    """Asynchronous version of log_agent_data"""
+def _log_agent_data(data_dict: dict):
+    """Simple function to log agent data using requests library"""
     if not data_dict:
-        return None
+        return
 
     url = "https://swarms.world/api/get-agents/log-agents"
     payload = {
         "data": data_dict,
-        "system_data": get_user_device_data_cached(),
+        "system_data": get_user_device_data(),
         "timestamp": datetime.datetime.now(
             datetime.timezone.utc
         ).isoformat(),
     }
 
-    session = await get_aiohttp_session()
-    try:
-        async with session.post(url, json=payload) as response:
-            if response.status == 200:
-                return await response.json()
-    except Exception:
-        return None
-
-
-def _log_agent_data(data_dict: dict):
-    """
-    Enhanced log_agent_data with both sync and async capabilities
-    """
-    if not data_dict:
-        return None
-
-    # If running in an event loop, use async version
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            return asyncio.create_task(
-                log_agent_data_async(data_dict)
-            )
-    except RuntimeError:
-        pass
+    key = (
+        os.getenv("SWARMS_API_KEY")
+        or "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24"
+    )
 
-    # Fallback to optimized sync version
-    url = "https://swarms.world/api/get-agents/log-agents"
-    payload = {
-        "data": data_dict,
-        "system_data": get_user_device_data_cached(),
-        "timestamp": datetime.datetime.now(
-            datetime.timezone.utc
-        ).isoformat(),
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": key,
     }
 
     try:
-        session = get_session()
-        response = session.post(
-            url,
-            json=payload,
-            timeout=10,
-            stream=False,  # Disable streaming for faster response
+        response = requests.post(
+            url, json=payload, headers=headers, timeout=10
         )
-        if response.ok and response.text.strip():
-            return response.json()
+        if response.status_code == 200:
+            return
     except Exception:
-        return None
+        return
+
+    return
 
 
 def log_agent_data(data_dict: dict):
-    """Log agent data"""
-    pass
+    try:
+        _log_agent_data(data_dict)
+    except Exception:
+        pass

swarms/tools/__init__.py

@@ -33,6 +33,11 @@ from swarms.tools.mcp_client_call import (
     get_tools_for_multiple_mcp_servers,
     get_mcp_tools_sync,
     aget_mcp_tools,
+    execute_multiple_tools_on_multiple_mcp_servers,
+    execute_multiple_tools_on_multiple_mcp_servers_sync,
+    _create_server_tool_mapping,
+    _create_server_tool_mapping_async,
+    _execute_tool_on_server,
 )
 
 
@@ -62,4 +67,9 @@ __all__ = [
     "get_tools_for_multiple_mcp_servers",
     "get_mcp_tools_sync",
     "aget_mcp_tools",
+    "execute_multiple_tools_on_multiple_mcp_servers",
+    "execute_multiple_tools_on_multiple_mcp_servers_sync",
+    "_create_server_tool_mapping",
+    "_create_server_tool_mapping_async",
+    "_execute_tool_on_server",
 ]

swarms/tools/base_tool.py

@@ -2256,14 +2256,18 @@ class BaseTool(BaseModel):
                 try:
                     api_response = json.loads(api_response)
                 except json.JSONDecodeError as e:
-                    raise ToolValidationError(
-                        f"Invalid JSON in API response: {e}"
-                    ) from e
+                    self._log_if_verbose(
+                        "error",
+                        f"Failed to parse JSON from API response: {e}. Response: '{api_response[:100]}...'"
+                    )
+                    return []
 
             if not isinstance(api_response, dict):
-                raise ToolValidationError(
-                    "API response must be a dictionary, JSON string, BaseModel, or list of tool calls"
+                self._log_if_verbose(
+                    "warning",
+                    f"API response is not a dictionary (type: {type(api_response)}), returning empty list"
                 )
+                return []
 
             # Extract function calls from dictionary response
             function_calls = (

swarms/tools/mcp_client_call.py

@@ -505,3 +505,511 @@ async def execute_tool_call_simple(
         *args,
         **kwargs,
     )
+
+
+def _create_server_tool_mapping(
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    format: str = "openai",
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Create a mapping of function names to server information for all MCP servers.
+
+    Args:
+        urls: List of server URLs
+        connections: Optional list of MCPConnection objects
+        format: Format to fetch tools in
+
+    Returns:
+        Dict mapping function names to server info (url, connection, tool)
+    """
+    server_tool_mapping = {}
+
+    for i, url in enumerate(urls):
+        connection = (
+            connections[i]
+            if connections and i < len(connections)
+            else None
+        )
+
+        try:
+            # Get tools for this server
+            tools = get_mcp_tools_sync(
+                server_path=url,
+                connection=connection,
+                format=format,
+            )
+
+            # Create mapping for each tool
+            for tool in tools:
+                if isinstance(tool, dict) and "function" in tool:
+                    function_name = tool["function"]["name"]
+                    server_tool_mapping[function_name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+                elif hasattr(tool, "name"):
+                    # Handle MCPTool objects
+                    server_tool_mapping[tool.name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to fetch tools from server {url}: {str(e)}"
+            )
+            continue
+
+    return server_tool_mapping
+
+
+async def _create_server_tool_mapping_async(
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    format: str = "openai",
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Async version: Create a mapping of function names to server information for all MCP servers.
+
+    Args:
+        urls: List of server URLs
+        connections: Optional list of MCPConnection objects
+        format: Format to fetch tools in
+
+    Returns:
+        Dict mapping function names to server info (url, connection, tool)
+    """
+    server_tool_mapping = {}
+
+    for i, url in enumerate(urls):
+        connection = (
+            connections[i]
+            if connections and i < len(connections)
+            else None
+        )
+
+        try:
+            # Get tools for this server using async function
+            tools = await aget_mcp_tools(
+                server_path=url,
+                connection=connection,
+                format=format,
+            )
+
+            # Create mapping for each tool
+            for tool in tools:
+                if isinstance(tool, dict) and "function" in tool:
+                    function_name = tool["function"]["name"]
+                    server_tool_mapping[function_name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+                elif hasattr(tool, "name"):
+                    # Handle MCPTool objects
+                    server_tool_mapping[tool.name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to fetch tools from server {url}: {str(e)}"
+            )
+            continue
+
+    return server_tool_mapping
+
+
+async def _execute_tool_on_server(
+    tool_call: Dict[str, Any],
+    server_info: Dict[str, Any],
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+) -> Dict[str, Any]:
+    """
+    Execute a single tool call on a specific server.
+
+    Args:
+        tool_call: The tool call to execute
+        server_info: Server information from the mapping
+        output_type: Output format type
+
+    Returns:
+        Execution result with server metadata
+    """
+    try:
+        result = await _execute_tool_call_simple(
+            response=tool_call,
+            server_path=server_info["url"],
+            connection=server_info["connection"],
+            output_type=output_type,
+        )
+
+        return {
+            "server_url": server_info["url"],
+            "server_index": server_info["server_index"],
+            "function_name": tool_call.get("function", {}).get(
+                "name", "unknown"
+            ),
+            "result": result,
+            "status": "success",
+        }
+
+    except Exception as e:
+        logger.error(
+            f"Failed to execute tool on server {server_info['url']}: {str(e)}"
+        )
+        return {
+            "server_url": server_info["url"],
+            "server_index": server_info["server_index"],
+            "function_name": tool_call.get("function", {}).get(
+                "name", "unknown"
+            ),
+            "result": None,
+            "error": str(e),
+            "status": "error",
+        }
+
+
+async def execute_multiple_tools_on_multiple_mcp_servers(
+    responses: List[Dict[str, Any]],
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+    max_concurrent: Optional[int] = None,
+    *args,
+    **kwargs,
+) -> List[Dict[str, Any]]:
+    """
+    Execute multiple tool calls across multiple MCP servers.
+
+    This function creates a mapping of function names to servers, then for each response
+    that contains tool calls, it finds the appropriate server for each function and
+    executes the calls concurrently.
+
+    Args:
+        responses: List of responses containing tool calls (OpenAI format)
+        urls: List of MCP server URLs
+        connections: Optional list of MCPConnection objects corresponding to each URL
+        output_type: Output format type for results
+        max_concurrent: Maximum number of concurrent executions (default: len(responses))
+
+    Returns:
+        List of execution results with server metadata
+
+    Example:
+        # Example responses format:
+        responses = [
+            {
+                "function": {
+                    "name": "search_web",
+                    "arguments": {"query": "python programming"}
+                }
+            },
+            {
+                "function": {
+                    "name": "search_database",
+                    "arguments": {"table": "users", "id": 123}
+                }
+            }
+        ]
+
+        urls = ["http://server1:8000", "http://server2:8000"]
+
+        results = await execute_multiple_tools_on_multiple_mcp_servers(
+            responses=responses,
+            urls=urls
+        )
+    """
+    if not responses:
+        logger.warning("No responses provided for execution")
+        return []
+
+    if not urls:
+        raise MCPValidationError("No server URLs provided")
+
+    # Create mapping of function names to servers using async version
+    logger.info(f"Creating tool mapping for {len(urls)} servers")
+    server_tool_mapping = await _create_server_tool_mapping_async(
+        urls=urls, connections=connections, format="openai"
+    )
+
+    if not server_tool_mapping:
+        raise MCPExecutionError(
+            "No tools found on any of the provided servers"
+        )
+
+    logger.info(
+        f"Found {len(server_tool_mapping)} unique functions across all servers"
+    )
+
+    # Extract all tool calls from responses
+    all_tool_calls = []
+    logger.info(
+        f"Processing {len(responses)} responses for tool call extraction"
+    )
+
+    # Check if responses are individual characters that need to be reconstructed
+    if len(responses) > 10 and all(
+        isinstance(r, str) and len(r) == 1 for r in responses
+    ):
+        logger.info(
+            "Detected character-by-character response, reconstructing JSON string"
+        )
+        try:
+            reconstructed_response = "".join(responses)
+            logger.info(
+                f"Reconstructed response length: {len(reconstructed_response)}"
+            )
+            logger.debug(
+                f"Reconstructed response: {reconstructed_response}"
+            )
+
+            # Try to parse the reconstructed response to validate it
+            try:
+                json.loads(reconstructed_response)
+                logger.info(
+                    "Successfully validated reconstructed JSON response"
+                )
+            except json.JSONDecodeError as e:
+                logger.warning(
+                    f"Reconstructed response is not valid JSON: {str(e)}"
+                )
+                logger.debug(
+                    f"First 100 chars: {reconstructed_response[:100]}"
+                )
+                logger.debug(
+                    f"Last 100 chars: {reconstructed_response[-100:]}"
+                )
+
+            responses = [reconstructed_response]
+        except Exception as e:
+            logger.warning(
+                f"Failed to reconstruct response from characters: {str(e)}"
+            )
+
+    for i, response in enumerate(responses):
+        logger.debug(
+            f"Processing response {i}: {type(response)} - {response}"
+        )
+
+        # Handle JSON string responses
+        if isinstance(response, str):
+            try:
+                response = json.loads(response)
+                logger.debug(
+                    f"Parsed JSON string response {i}: {response}"
+                )
+            except json.JSONDecodeError:
+                logger.warning(
+                    f"Failed to parse JSON response at index {i}: {response}"
+                )
+                continue
+
+        if isinstance(response, dict):
+            # Single tool call
+            if "function" in response:
+                logger.debug(
+                    f"Found single tool call in response {i}: {response['function']}"
+                )
+                # Parse arguments if they're a JSON string
+                if isinstance(
+                    response["function"].get("arguments"), str
+                ):
+                    try:
+                        response["function"]["arguments"] = (
+                            json.loads(
+                                response["function"]["arguments"]
+                            )
+                        )
+                        logger.debug(
+                            f"Parsed function arguments: {response['function']['arguments']}"
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            f"Failed to parse function arguments: {response['function']['arguments']}"
+                        )
+
+                all_tool_calls.append((i, response))
+            # Multiple tool calls
+            elif "tool_calls" in response:
+                logger.debug(
+                    f"Found multiple tool calls in response {i}: {len(response['tool_calls'])} calls"
+                )
+                for tool_call in response["tool_calls"]:
+                    # Parse arguments if they're a JSON string
+                    if isinstance(
+                        tool_call.get("function", {}).get(
+                            "arguments"
+                        ),
+                        str,
+                    ):
+                        try:
+                            tool_call["function"]["arguments"] = (
+                                json.loads(
+                                    tool_call["function"]["arguments"]
+                                )
+                            )
+                            logger.debug(
+                                f"Parsed tool call arguments: {tool_call['function']['arguments']}"
+                            )
+                        except json.JSONDecodeError:
+                            logger.warning(
+                                f"Failed to parse tool call arguments: {tool_call['function']['arguments']}"
+                            )
+
+                    all_tool_calls.append((i, tool_call))
+            # Direct tool call
+            elif "name" in response and "arguments" in response:
+                logger.debug(
+                    f"Found direct tool call in response {i}: {response}"
+                )
+                # Parse arguments if they're a JSON string
+                if isinstance(response.get("arguments"), str):
+                    try:
+                        response["arguments"] = json.loads(
+                            response["arguments"]
+                        )
+                        logger.debug(
+                            f"Parsed direct tool call arguments: {response['arguments']}"
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            f"Failed to parse direct tool call arguments: {response['arguments']}"
+                        )
+
+                all_tool_calls.append((i, {"function": response}))
+            else:
+                logger.debug(
+                    f"Response {i} is a dict but doesn't match expected tool call formats: {list(response.keys())}"
+                )
+        else:
+            logger.warning(
+                f"Unsupported response type at index {i}: {type(response)}"
+            )
+            continue
+
+    if not all_tool_calls:
+        logger.warning("No tool calls found in responses")
+        return []
+
+    logger.info(f"Found {len(all_tool_calls)} tool calls to execute")
+
+    # Execute tool calls concurrently
+    max_concurrent = max_concurrent or len(all_tool_calls)
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def execute_with_semaphore(tool_call_info):
+        async with semaphore:
+            response_index, tool_call = tool_call_info
+            function_name = tool_call.get("function", {}).get(
+                "name", "unknown"
+            )
+
+            if function_name not in server_tool_mapping:
+                logger.warning(
+                    f"Function '{function_name}' not found on any server"
+                )
+                return {
+                    "response_index": response_index,
+                    "function_name": function_name,
+                    "result": None,
+                    "error": f"Function '{function_name}' not available on any server",
+                    "status": "not_found",
+                }
+
+            server_info = server_tool_mapping[function_name]
+            result = await _execute_tool_on_server(
+                tool_call=tool_call,
+                server_info=server_info,
+                output_type=output_type,
+            )
+            result["response_index"] = response_index
+            return result
+
+    # Execute all tool calls concurrently
+    tasks = [
+        execute_with_semaphore(tool_call_info)
+        for tool_call_info in all_tool_calls
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Process results and handle exceptions
+    processed_results = []
+    for i, result in enumerate(results):
+        if isinstance(result, Exception):
+            logger.error(
+                f"Task {i} failed with exception: {str(result)}"
+            )
+            processed_results.append(
+                {
+                    "response_index": (
+                        all_tool_calls[i][0]
+                        if i < len(all_tool_calls)
+                        else -1
+                    ),
+                    "function_name": "unknown",
+                    "result": None,
+                    "error": str(result),
+                    "status": "exception",
+                }
+            )
+        else:
+            processed_results.append(result)
+
+    logger.info(
+        f"Completed execution of {len(processed_results)} tool calls"
+    )
+    return processed_results
+
+
+def execute_multiple_tools_on_multiple_mcp_servers_sync(
+    responses: List[Dict[str, Any]],
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+    max_concurrent: Optional[int] = None,
+    *args,
+    **kwargs,
+) -> List[Dict[str, Any]]:
+    """
+    Synchronous version of execute_multiple_tools_on_multiple_mcp_servers.
+
+    Args:
+        responses: List of responses containing tool calls (OpenAI format)
+        urls: List of MCP server URLs
+        connections: Optional list of MCPConnection objects corresponding to each URL
+        output_type: Output format type for results
+        max_concurrent: Maximum number of concurrent executions
+
+    Returns:
+        List of execution results with server metadata
+    """
+    with get_or_create_event_loop() as loop:
+        try:
+            return loop.run_until_complete(
+                execute_multiple_tools_on_multiple_mcp_servers(
+                    responses=responses,
+                    urls=urls,
+                    connections=connections,
+                    output_type=output_type,
+                    max_concurrent=max_concurrent,
+                    *args,
+                    **kwargs,
+                )
+            )
+        except Exception as e:
+            logger.error(
+                f"Error in execute_multiple_tools_on_multiple_mcp_servers_sync: {str(e)}"
+            )
+            raise MCPExecutionError(
+                f"Failed to execute multiple tools sync: {str(e)}"
+            )

swarms/tools/py_func_to_openai_func_str.py

@@ -492,7 +492,6 @@ def convert_multiple_functions_to_openai_function_schema(
     # ]
     # Use 40% of cpu cores
     max_workers = int(os.cpu_count() * 0.8)
-    print(f"max_workers: {max_workers}")
 
     with concurrent.futures.ThreadPoolExecutor(
         max_workers=max_workers

swarms/utils/auto_download_check_packages.py

@@ -8,9 +8,10 @@ import subprocess
 import sys
 from typing import Literal, Optional, Union
 from swarms.utils.loguru_logger import initialize_logger
-import pkg_resources
 
 
+from importlib.metadata import distribution, PackageNotFoundError
+
 logger = initialize_logger("autocheckpackages")
 
 
@@ -39,13 +40,13 @@ def check_and_install_package(
         # Check if package exists
         if package_manager == "pip":
             try:
-                pkg_resources.get_distribution(package_name)
+                distribution(package_name)
                 if not upgrade:
                     logger.info(
                         f"Package {package_name} is already installed"
                     )
                     return True
-            except pkg_resources.DistributionNotFound:
+            except PackageNotFoundError:
                 pass
 
             # Construct installation command

swarms/utils/history_output_formatter.py

@@ -23,6 +23,8 @@ def history_output_formatter(
         return yaml.safe_dump(conversation.to_dict(), sort_keys=False)
     elif type == "dict-all-except-first":
         return conversation.return_all_except_first()
+    elif type == "list-final":
+        return conversation.return_list_final()
     elif type == "str-all-except-first":
         return conversation.return_all_except_first_string()
     elif type == "dict-final":

swarms/utils/output_types.py

@@ -12,11 +12,11 @@ HistoryOutputType = Literal[
     "all",
     "yaml",
     "xml",
-    # "dict-final",
     "dict-all-except-first",
     "str-all-except-first",
     "basemodel",
     "dict-final",
+    "list-final",
 ]
 
 OutputType = HistoryOutputType

{swarms-7.8.7.dist-info → swarms-7.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: swarms
-Version: 7.8.7
+Version: 7.8.9
 Summary: Swarms - TGSC
 License: MIT
 Keywords: artificial intelligence,deep learning,optimizers,Prompt Engineering,swarms,agents,llms,transformers,multi-agent,swarms of agents,Enterprise-Grade Agents,Production-Grade Agents,Agents,Multi-Grade-Agents,Swarms,Transformers,LLMs,Prompt Engineering,Agents,Generative Agents,Generative AI,Agent Marketplace,Agent Store,quant,finance,algorithmic trading,portfolio optimization,risk management,financial modeling,machine learning for finance,natural language processing for finance

{swarms-7.8.7.dist-info → swarms-7.8.9.dist-info}/RECORD

@@ -105,7 +105,7 @@ swarms/schemas/mcp_schemas.py,sha256=XZJ4HyiY_cv8Gvj-53ddjzXuqT9hBU2f0cHbhIKs_jY
 swarms/schemas/swarms_api_schemas.py,sha256=uKqleW_7hNpqHi06yoba9jS2i9yzZp-SBV944MnkN68,6233
 swarms/schemas/tool_schema_base_model.py,sha256=0biTGIoibsPPP3fOrkC6WvNU5vXaalyccVKC1fpO_eg,1409
 swarms/structs/__init__.py,sha256=XbUK6MSivL9qHNFlcoGcAVRYPupQssD3dG_-yAqrycw,4345
-swarms/structs/agent.py,sha256=dwCuxBLpPEvJCREfsMbp_Imiz_VtFiZTuXZMrWduIAE,102867
+swarms/structs/agent.py,sha256=azNp6iejRn9GnRcWxkPy3hO38TWPvJTYlZysgfV056Q,104857
 swarms/structs/agent_builder.py,sha256=tYNpfO4_8cgfMHfgA5DAOWffHnt70p6CLt59esqfVCY,12133
 swarms/structs/agent_rag_handler.py,sha256=g17YRrNmf16TLvyFCCcsitVk3d-QNZmck_XYmjSN_YM,21372
 swarms/structs/agent_registry.py,sha256=il507cO1NF-d4ChyANVLuWrN8bXsEAi8_7bLJ_sTU6A,12112
@@ -119,9 +119,9 @@ swarms/structs/base_workflow.py,sha256=DTfFwX3AdFYxACDYwUDqhsbcDZnITlg5TeEYyxmJB
 swarms/structs/batch_agent_execution.py,sha256=d85DzeCq4uTbbPqLhAXFqFx_cxXUS5yRnJ1-gJkwU5w,1871
 swarms/structs/concat.py,sha256=utezSxNyh1mIwXgdf8-dJ803NDPyEy79WE8zJHuooGk,732
 swarms/structs/concurrent_workflow.py,sha256=OqXI-X-9a0hG2a7aLzobwd7CVF2ez0rgLj3ZHqri5bg,12952
-swarms/structs/conversation.py,sha256=EagQYlcLoa4Kukb5oQnLDQqpM7-HnIeLNepubIk8ono,49225
+swarms/structs/conversation.py,sha256=06CY2vHXbKr9egwPsQMxZbanxEvuMnuLI-8MXz7v5Bo,49390
 swarms/structs/council_judge.py,sha256=siYDKiHMvFmShUTXxdo4R6vXiQhKt7bEBI205oC3kU4,19639
-swarms/structs/csv_to_agent.py,sha256=PVSbLdWqt6VnnekwqcnWQ8-Am3bhNFsIkUK5GliZV18,11178
+swarms/structs/csv_to_agent.py,sha256=Zv41sjeWA50msq-paGHESzlxZyMU78DYDLNNKZtNfoI,11125
 swarms/structs/de_hallucination_swarm.py,sha256=9cC0rSSXGwYu6SRDwpeMbCcQ40C1WI1RE9SNapKRLOQ,10309
 swarms/structs/deep_research_swarm.py,sha256=cNLDI7_lT47q4bCRlMJO4IAO3Fu_iF3nPi3jgtg6CJQ,17026
 swarms/structs/dynamic_conversational_swarm.py,sha256=xm8x_0OCI4ijatgVt8dzHhLNUyMzqG2U_XQL14kcIS8,8354
@@ -160,11 +160,11 @@ swarms/structs/swarming_architectures.py,sha256=guNQU2N7Ofuk01fZbU3tmBJymnZ9zdGU
 swarms/structs/tree_swarm.py,sha256=AnIxrt0KhWxAQN8uGjfCcOq-XCmsuTJiH8Ex4mXy8V8,12500
 swarms/structs/utils.py,sha256=Mo6wHQYOB8baWZUKnAJN5Dsgubpo81umNwJIEDitb2A,1873
 swarms/structs/various_alt_swarms.py,sha256=qdBuOF31UjatlKRu-9bxwyRQzIjohRhTv_63YoUeYEY,27866
-swarms/telemetry/__init__.py,sha256=yibtkHEbQRPUv6ir1FhDHlAO_3nwKJPQH4LjzBC2AuQ,661
+swarms/telemetry/__init__.py,sha256=NfKiXtyEtQJuQ74qiFFy2MxMX5KdgUbU7c3cpnHvhmQ,553
 swarms/telemetry/bootup.py,sha256=0leCNCy5rhzL19EsOsqHWSDI85KVcWO6_5hLDS0h4sY,1155
-swarms/telemetry/main.py,sha256=8FxivorvclSvhgfU03cHFktaRgRNV1UXCMi0VV8-U60,11248
-swarms/tools/__init__.py,sha256=tyGQpcfrosMx06fdV9h_8_9WB-1vfT-aAjZufiTXyPQ,1838
-swarms/tools/base_tool.py,sha256=kyCteIJxk38jE0upttSQA1iJ1k6GEjebYwhl8WmUxGw,107020
+swarms/telemetry/main.py,sha256=Yvc12fUErOdQgUl4B7blBLALLMnvQ4qGh-vgRZDBewQ,7877
+swarms/tools/__init__.py,sha256=6j4tc28dxLrlHG88Yot90PHuNZxhJFb27xqJ8GjwN-0,2268
+swarms/tools/base_tool.py,sha256=gxGqsXNjxmBxLQ4zX3jsGsXYPtWS6autaahAOAvJrfY,107174
 swarms/tools/cohere_func_call_schema.py,sha256=XJ6_yBMXCrV9KjN7v9Bk1iFj69TRlGIWYKsUTA1oGiQ,600
 swarms/tools/create_agent_tool.py,sha256=YsiBgrR9gkn2Jenu_mIFXOMJCWb_Hdw4gBYPQN5HEQk,3467
 swarms/tools/func_calling_utils.py,sha256=PhHHZRHN-vRHA_h21ELRjXIhSRIrsT4UhU5-1Bhy-iU,3542
@@ -173,10 +173,10 @@ swarms/tools/function_util.py,sha256=DAnAPO0Ik__TAqL7IJzFmkukHnhpsW_QtALl3yj837g
 swarms/tools/json_former.py,sha256=4ugLQ_EZpghhuhFsVKsy-ehin9K64pqVE2gLU7BTO_M,14376
 swarms/tools/json_utils.py,sha256=WKMZjcJ0Vt6lgIjiTBenslcfjgRSLX4UWs4uDkKFMQI,1316
 swarms/tools/logits_processor.py,sha256=NifZZ5w9yemWGJAJ5nHFrphtZVX1XlyesgvYZTxK1GM,2965
-swarms/tools/mcp_client_call.py,sha256=8cLwtOAYSRGdCRYq_RujuyLHcApQXmNp6K9vYtv1N6U,15362
+swarms/tools/mcp_client_call.py,sha256=DKivM3OVLeoOjx0hiorSyj3m3Z4MWWwqe4LT6KNi8HU,33007
 swarms/tools/openai_func_calling_schema_pydantic.py,sha256=6BAH9kuaVTvJIbjgSSJ5XvHhWvWszPxgarkfUuE5Ads,978
 swarms/tools/openai_tool_creator_decorator.py,sha256=SYZjHnARjWvnH9cBdj7Kc_Yy1muvNxMT3RQz8KkA2SE,2578
-swarms/tools/py_func_to_openai_func_str.py,sha256=sjoNutRZ11-0kYFDalUTxZxQ0TEDyn5R8EXMdS4gsgw,17091
+swarms/tools/py_func_to_openai_func_str.py,sha256=MoNVYMiLN_aeexEmzwEktCLEouSmjU8j4XMNcSwU_LU,17050
 swarms/tools/pydantic_to_json.py,sha256=sd5uWwjSHsu7M8wCBrPv0uje05-K4xcfbvKQ_zOaww8,3399
 swarms/tools/tool_parse_exec.py,sha256=FW5XzkuNEs2YrroybjKChbCzDvaCs7ypknSDpYhfkd4,8717
 swarms/tools/tool_registry.py,sha256=ULZmIKBTx9XRCJRD9hwXfY3iQw9v94arw-VV6jcuftY,7992
@@ -184,7 +184,7 @@ swarms/tools/tool_utils.py,sha256=yXzzqG7Ytd8ybB8bsjNUNLaXIuIp9JbbpUKCiHxQqo8,28
 swarms/utils/__init__.py,sha256=tpbhE-BTISDMXemSRSRJz-Rz7m_C05Q5Pre3d9H9SN4,1195
 swarms/utils/any_to_str.py,sha256=Qi4N9ed6LYnCs2AeFYo1zwEfYhOKUesGVFUmVUz54KI,2936
 swarms/utils/audio_processing.py,sha256=Y3KaWG9WJrgquWCeaty20HWPIXfeuPAhcJFzoSBIQjE,9893
-swarms/utils/auto_download_check_packages.py,sha256=mqx3jCetfkTuxTdeGLx-gGMB1xWOU5vata8lTKXLatk,4580
+swarms/utils/auto_download_check_packages.py,sha256=nnEPfUr2zy_Y6vPZF56zyWLamz0e2gskS4ecKSw30ww,4594
 swarms/utils/calculate_func_metrics.py,sha256=Nb5r7rWf809m5F7mWIYXZ0H_WeyGr78A2UZD2GHtJkM,5007
 swarms/utils/check_all_model_max_tokens.py,sha256=ZHIKlrU-L-OM2IJAbYkCoVyBKe2d0JrGhDC9QNppGIs,1519
 swarms/utils/data_to_text.py,sha256=1PUoWokylp7MOrGNk1cmO3cJlfskdAIiImGk9ECwsKU,3427
@@ -193,20 +193,20 @@ swarms/utils/file_processing.py,sha256=QjQCIPTcwicQlfy656BXBYpIzMR0s2343E7ftnok5
 swarms/utils/formatter.py,sha256=e15FsyTIIkyRreMUApkkZCzJC1Sm67w5Zd6EQcUkMwA,4533
 swarms/utils/function_caller_model.py,sha256=ZfgCMzOizNnuZipYLclTziECNHszH9p8RQcUq7VNr4Q,4156
 swarms/utils/generate_keys.py,sha256=o5zp_8rwu5sgQnItWS1xAuIIRIkahwm02qy1vsV6DSQ,997
-swarms/utils/history_output_formatter.py,sha256=hxRVeusMxcwIPcbPpsmWgxd7PGxBv2eJzUDITbyFvKE,1309
+swarms/utils/history_output_formatter.py,sha256=whjfk4N5SjMo3mtrafNny_alNiAhQcGza3l1dCyg7Nw,1388
 swarms/utils/index.py,sha256=iYVlMiuSpBuKHF34uSrxDUuSYmS26bbYoAqyz_VIyvY,6902
 swarms/utils/litellm_tokenizer.py,sha256=PqzAY4C5lJ3P-K9SL-dCNtxmHHlZvAw1UohT-ob9lxY,3389
 swarms/utils/litellm_wrapper.py,sha256=moSaVYIViCSib2r1kS2h1BqltQKcysVJCeI6cAXp2bU,19566
 swarms/utils/loguru_logger.py,sha256=hIoSK3NHLpe7eAmjHRURrEYzNXYC2gbR7_Vv63Yaydk,685
-swarms/utils/output_types.py,sha256=yEggBESV8D-gOh7NR6OpOT0WUmA97oz514f27B9NV1Y,406
+swarms/utils/output_types.py,sha256=jPOiRr2s114Dw2ngG8DTtxHIWZikMfNtXkyLtgghj9w,404
 swarms/utils/parse_code.py,sha256=XFOLymbdP3HzMZuqsj7pwUyisvUmTm0ev9iThR_ambI,1987
 swarms/utils/pdf_to_text.py,sha256=nkySOS_sJ4Jf4RP5SoDpMB5WfjJ_GGc5z8gJfn2cxOM,1311
 swarms/utils/str_to_dict.py,sha256=T3Jsdjz87WIlkSo7jAW6BB80sv0Ns49WT1qXlOrdEoE,874
 swarms/utils/try_except_wrapper.py,sha256=uvDZDZJcH986EF0Ej6zZBLcqHJ58NHizPsAH5olrE7Q,3919
 swarms/utils/vllm_wrapper.py,sha256=sNkm4EbeMrqqmHidnvq5zTnofQAaARy3HIrNBu11lKs,5072
 swarms/utils/xml_utils.py,sha256=D4nEdo1nkHqSoTKrWylXBXjcHFhGaOYvvfGNQQoYV5o,2514
-swarms-7.8.7.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.8.7.dist-info/METADATA,sha256=ysQ9oCgqZ8C76O62Z3g0L_RSZOq-4iyw_yjVdUYrAhk,94363
-swarms-7.8.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-swarms-7.8.7.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.8.7.dist-info/RECORD,,
+swarms-7.8.9.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.8.9.dist-info/METADATA,sha256=-jF_6uuBLf4o-NOrosFWpsPN84oaSLBHa7hw_loIipo,94363
+swarms-7.8.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+swarms-7.8.9.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.8.9.dist-info/RECORD,,