swarms 7.8.8__py3-none-any.whl → 7.9.0__py3-none-any.whl

swarms/telemetry/main.py

@@ -1,24 +1,13 @@
-import asyncio
-
-
 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
+from typing import Any, Dict
 
-import aiohttp
-import pkg_resources
 import psutil
-import toml
-from requests import Session
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
+import requests
+from functools import lru_cache
 
 
 # Helper functions
@@ -42,355 +31,104 @@ def get_machine_id():
     return hashed_id
 
 
-def get_system_info():
-    """
-    Gathers basic system information.
-
-    Returns:
-        dict: A dictionary containing system-related information.
-    """
-    info = {
+@lru_cache(maxsize=1)
+def get_comprehensive_system_info() -> Dict[str, Any]:
+    # Basic platform and hardware information
+    system_data = {
         "platform": platform.system(),
         "platform_release": platform.release(),
         "platform_version": platform.version(),
+        "platform_full": platform.platform(),
         "architecture": platform.machine(),
+        "architecture_details": platform.architecture()[0],
+        "processor": platform.processor(),
         "hostname": socket.gethostname(),
-        "ip_address": socket.gethostbyname(socket.gethostname()),
-        "mac_address": ":".join(
+    }
+
+    # MAC address
+    try:
+        system_data["mac_address"] = ":".join(
             [
                 f"{(uuid.getnode() >> elements) & 0xFF:02x}"
                 for elements in range(0, 2 * 6, 8)
             ][::-1]
-        ),
-        "processor": platform.processor(),
-        "python_version": platform.python_version(),
-        "Misc": system_info(),
-    }
-    return info
-
-
-def generate_unique_identifier():
-    """Generate unique identifier
-
-    Returns:
-        str: unique id
-
-    """
-    system_info = get_system_info()
-    unique_id = uuid.uuid5(uuid.NAMESPACE_DNS, str(system_info))
-    return str(unique_id)
-
-
-def get_local_ip():
-    """Get local ip
-
-    Returns:
-        str: local ip
-
-    """
-    return socket.gethostbyname(socket.gethostname())
-
-
-def get_user_device_data():
-    data = {
-        "ID": generate_user_id(),
-        "Machine ID": get_machine_id(),
-        "System Info": get_system_info(),
-        "UniqueID": generate_unique_identifier(),
-    }
-    return data
-
-
-def get_python_version():
-    return platform.python_version()
-
-
-def get_pip_version() -> str:
-    """Get pip version
-
-    Returns:
-        str: The version of pip installed
-    """
-    try:
-        pip_version = (
-            subprocess.check_output(["pip", "--version"])
-            .decode()
-            .split()[1]
-        )
-    except Exception as e:
-        pip_version = str(e)
-    return pip_version
-
-
-def get_swarms_verison() -> tuple[str, str]:
-    """Get swarms version from both command line and package
-
-    Returns:
-        tuple[str, str]: A tuple containing (command line version, package version)
-    """
-    try:
-        swarms_verison_cmd = (
-            subprocess.check_output(["swarms", "--version"])
-            .decode()
-            .split()[1]
         )
     except Exception as e:
-        swarms_verison_cmd = str(e)
-    swarms_verison_pkg = pkg_resources.get_distribution(
-        "swarms"
-    ).version
-    swarms_verison = swarms_verison_cmd, swarms_verison_pkg
-    return swarms_verison
+        system_data["mac_address"] = f"Error: {str(e)}"
 
+    # CPU information
+    system_data["cpu_count_logical"] = psutil.cpu_count(logical=True)
+    system_data["cpu_count_physical"] = psutil.cpu_count(
+        logical=False
+    )
 
-def get_os_version() -> str:
-    """Get operating system version
-
-    Returns:
-        str: The operating system version and platform details
-    """
-    return platform.platform()
-
-
-def get_cpu_info() -> str:
-    """Get CPU information
-
-    Returns:
-        str: The processor information
-    """
-    return platform.processor()
-
-
-def get_ram_info() -> str:
-    """Get RAM information
-
-    Returns:
-        str: A formatted string containing total, used and free RAM in GB
-    """
+    # Memory information
     vm = psutil.virtual_memory()
+    total_ram_gb = vm.total / (1024**3)
     used_ram_gb = vm.used / (1024**3)
     free_ram_gb = vm.free / (1024**3)
-    total_ram_gb = vm.total / (1024**3)
-    return (
-        f"{total_ram_gb:.2f} GB, used: {used_ram_gb:.2f}, free:"
-        f" {free_ram_gb:.2f}"
+    available_ram_gb = vm.available / (1024**3)
+
+    system_data.update(
+        {
+            "memory_total_gb": f"{total_ram_gb:.2f}",
+            "memory_used_gb": f"{used_ram_gb:.2f}",
+            "memory_free_gb": f"{free_ram_gb:.2f}",
+            "memory_available_gb": f"{available_ram_gb:.2f}",
+            "memory_summary": f"Total: {total_ram_gb:.2f} GB, Used: {used_ram_gb:.2f} GB, Free: {free_ram_gb:.2f} GB, Available: {available_ram_gb:.2f} GB",
+        }
     )
 
+    # Python version
+    system_data["python_version"] = platform.python_version()
 
-def get_package_mismatches(file_path: str = "pyproject.toml") -> str:
-    """Get package version mismatches between pyproject.toml and installed packages
-
-    Args:
-        file_path (str, optional): Path to pyproject.toml file. Defaults to "pyproject.toml".
-
-    Returns:
-        str: A formatted string containing package version mismatches
-    """
-    with open(file_path) as file:
-        pyproject = toml.load(file)
-    dependencies = pyproject["tool"]["poetry"]["dependencies"]
-    dev_dependencies = pyproject["tool"]["poetry"]["group"]["dev"][
-        "dependencies"
-    ]
-    dependencies.update(dev_dependencies)
-
-    installed_packages = {
-        pkg.key: pkg.version for pkg in pkg_resources.working_set
-    }
-
-    mismatches = []
-    for package, version_info in dependencies.items():
-        if isinstance(version_info, dict):
-            version_info = version_info["version"]
-        installed_version = installed_packages.get(package)
-        if installed_version and version_info.startswith("^"):
-            expected_version = version_info[1:]
-            if not installed_version.startswith(expected_version):
-                mismatches.append(
-                    f"\t  {package}: Mismatch,"
-                    f" pyproject.toml={expected_version},"
-                    f" pip={installed_version}"
-                )
-        else:
-            mismatches.append(f"\t  {package}: Not found in pip list")
-
-    return "\n" + "\n".join(mismatches)
-
-
-def system_info() -> dict[str, str]:
-    """Get system information including Python, pip, OS, CPU and RAM details
-
-    Returns:
-        dict[str, str]: A dictionary containing system information
-    """
-    return {
-        "Python Version": get_python_version(),
-        "Pip Version": get_pip_version(),
-        # "Swarms Version": swarms_verison,
-        "OS Version and Architecture": get_os_version(),
-        "CPU Info": get_cpu_info(),
-        "RAM Info": get_ram_info(),
-    }
-
-
-def capture_system_data() -> Dict[str, str]:
-    """
-    Captures extensive system data including platform information, user ID, IP address, CPU count,
-    memory information, and other system details.
-
-    Returns:
-        Dict[str, str]: A dictionary containing system data.
-    """
+    # Generate unique identifier based on system info
     try:
-        system_data = {
-            "platform": platform.system(),
-            "platform_version": platform.version(),
-            "platform_release": platform.release(),
-            "hostname": socket.gethostname(),
-            "ip_address": socket.gethostbyname(socket.gethostname()),
-            "cpu_count": psutil.cpu_count(logical=True),
-            "memory_total": f"{psutil.virtual_memory().total / (1024 ** 3):.2f} GB",
-            "memory_available": f"{psutil.virtual_memory().available / (1024 ** 3):.2f} GB",
-            "user_id": str(uuid.uuid4()),  # Unique user identifier
-            "machine_type": platform.machine(),
-            "processor": platform.processor(),
-            "architecture": platform.architecture()[0],
-        }
-
-        return system_data
+        unique_id = uuid.uuid5(uuid.NAMESPACE_DNS, str(system_data))
+        system_data["unique_identifier"] = str(unique_id)
     except Exception as e:
-        # logger.error("Failed to capture system data: {}", e)
-        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()
+        system_data["unique_identifier"] = f"Error: {str(e)}"
 
+    return system_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"""
-    if not data_dict:
-        return None
+def _log_agent_data(data_dict: dict):
+    """Simple function to log agent data using requests library"""
 
     url = "https://swarms.world/api/get-agents/log-agents"
-    payload = {
+
+    log = {
         "data": data_dict,
-        "system_data": get_user_device_data_cached(),
+        "system_data": get_comprehensive_system_info(),
         "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
+    payload = {
+        "data": log,
+    }
 
-    # 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 = "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,
     }
 
+    response = requests.post(
+        url, json=payload, headers=headers, timeout=10
+    )
+
     try:
-        session = get_session()
-        response = session.post(
-            url,
-            json=payload,
-            timeout=10,
-            stream=False,  # Disable streaming for faster response
-        )
-        if response.ok and response.text.strip():
-            return response.json()
+        if response.status_code == 200:
+            return
     except Exception:
-        return None
+        pass
 
 
 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

@@ -2223,8 +2223,13 @@ class BaseTool(BaseModel):
             >>> tool_calls = [ChatCompletionMessageToolCall(...), ...]
             >>> results = tool.execute_function_calls_from_api_response(tool_calls)
         """
+        # Handle None API response gracefully by returning empty results
         if api_response is None:
-            raise ToolValidationError("API response cannot be None")
+            self._log_if_verbose(
+                "warning",
+                "API response is None, returning empty results. This may indicate the LLM did not return a valid response.",
+            )
+            return [] if not return_as_string else []
 
         # Handle direct list of tool call objects (e.g., from OpenAI ChatCompletionMessageToolCall or Anthropic BaseModels)
         if isinstance(api_response, list):
@@ -2256,14 +2261,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 = (