swarms 7.6.9__py3-none-any.whl → 7.7.1__py3-none-any.whl

swarms/telemetry/main.py

@@ -1,15 +1,25 @@
+# Add these imports at the top
+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
 
+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
@@ -248,58 +258,135 @@ def capture_system_data() -> Dict[str, str]:
             "architecture": platform.architecture()[0],
         }
 
-        # Get external IP address
-        try:
-            system_data["external_ip"] = requests.get(
-                "https://api.ipify.org"
-            ).text
-        except Exception:
-            system_data["external_ip"] = "N/A"
-
         return system_data
     except Exception as e:
         # logger.error("Failed to capture system data: {}", e)
         print(f"Failed to capture system data: {e}")
 
 
-def log_agent_data(data_dict: dict):
-    """
-    Silently logs agent data to the Swarms database with retry logic.
+# 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
 
-    Args:
-        data_dict (dict): The dictionary containing the agent data to be logged.
 
-    Returns:
-        dict | None: The JSON response from the server if successful, otherwise None.
-    """
+@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"""
     if not data_dict:
-        return None  # Immediately exit if the input is empty
+        return None
 
     url = "https://swarms.world/api/get-agents/log-agents"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
+    payload = {
+        "data": data_dict,
+        "system_data": get_user_device_data_cached(),
+        "timestamp": datetime.datetime.now(
+            datetime.timezone.utc
+        ).isoformat(),
     }
 
-    system_data = get_user_device_data()
+    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
+
+    # Fallback to optimized sync version
+    url = "https://swarms.world/api/get-agents/log-agents"
     payload = {
         "data": data_dict,
-        "system_data": system_data,
-        "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
+        "system_data": get_user_device_data_cached(),
+        "timestamp": datetime.datetime.now(
+            datetime.timezone.utc
+        ).isoformat(),
     }
 
     try:
-        response = requests.post(
-            url, json=payload, headers=headers, timeout=10
+        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()
-        ):  # Check if response is valid and non-empty
-            return (
-                response.json()
-            )  # Parse and return the JSON response
-    except (
-        requests.exceptions.RequestException,
-        requests.exceptions.JSONDecodeError,
-    ):
-        return None  # Return None if anything goes wrong
+        if response.ok and response.text.strip():
+            return response.json()
+    except Exception:
+        return None

swarms/tools/mcp_client.py

@@ -0,0 +1,90 @@
+import asyncio
+from typing import Literal, Dict, Any, Union
+from fastmcp import Client
+from swarms.utils.any_to_str import any_to_str
+from swarms.utils.str_to_dict import str_to_dict
+
+
+def parse_agent_output(
+    dictionary: Union[str, Dict[Any, Any]]
+) -> tuple[str, Dict[Any, Any]]:
+    if isinstance(dictionary, str):
+        dictionary = str_to_dict(dictionary)
+
+    elif not isinstance(dictionary, dict):
+        raise ValueError("Invalid dictionary")
+
+    # Handle OpenAI function call format
+    if "function_call" in dictionary:
+        name = dictionary["function_call"]["name"]
+        # arguments is a JSON string, so we need to parse it
+        params = str_to_dict(dictionary["function_call"]["arguments"])
+        return name, params
+
+    # Handle OpenAI tool calls format
+    if "tool_calls" in dictionary:
+        # Get the first tool call (or you could handle multiple if needed)
+        tool_call = dictionary["tool_calls"][0]
+        name = tool_call["function"]["name"]
+        params = str_to_dict(tool_call["function"]["arguments"])
+        return name, params
+
+    # Handle regular dictionary format
+    if "name" in dictionary:
+        name = dictionary["name"]
+        params = dictionary.get("arguments", {})
+        return name, params
+
+    raise ValueError("Invalid function call format")
+
+
+async def _execute_mcp_tool(
+    url: str,
+    method: Literal["stdio", "sse"] = "sse",
+    parameters: Dict[Any, Any] = None,
+    output_type: Literal["str", "dict"] = "str",
+    *args,
+    **kwargs,
+) -> Dict[Any, Any]:
+
+    if "sse" or "stdio" not in url:
+        raise ValueError("Invalid URL")
+
+    url = f"{url}/{method}"
+
+    name, params = parse_agent_output(parameters)
+
+    if output_type == "str":
+        async with Client(url, *args, **kwargs) as client:
+            out = await client.call_tool(
+                name=name,
+                arguments=params,
+            )
+            return any_to_str(out)
+    elif output_type == "dict":
+        async with Client(url, *args, **kwargs) as client:
+            out = await client.call_tool(
+                name=name,
+                arguments=params,
+            )
+            return out
+    else:
+        raise ValueError(f"Invalid output type: {output_type}")
+
+
+def execute_mcp_tool(
+    url: str,
+    tool_name: str = None,
+    method: Literal["stdio", "sse"] = "sse",
+    parameters: Dict[Any, Any] = None,
+    output_type: Literal["str", "dict"] = "str",
+) -> Dict[Any, Any]:
+    return asyncio.run(
+        _execute_mcp_tool(
+            url=url,
+            tool_name=tool_name,
+            method=method,
+            parameters=parameters,
+            output_type=output_type,
+        )
+    )

swarms/utils/history_output_formatter.py

@@ -1,17 +1,35 @@
 import yaml
 from swarms.structs.conversation import Conversation
 
+from typing import Literal, Union, List, Dict, Any
+
+HistoryOutputType = Literal[
+    "list",
+    "dict",
+    "dictionary",
+    "string",
+    "str",
+    "final",
+    "last",
+    "json",
+    "all",
+    "yaml",
+    # "dict-final",
+    "dict-all-except-first",
+    "str-all-except-first",
+]
+
 
 def history_output_formatter(
-    conversation: Conversation, type: str = "list"
-):
+    conversation: Conversation, type: HistoryOutputType = "list"
+) -> Union[List[Dict[str, Any]], Dict[str, Any], str]:
     if type == "list":
         return conversation.return_messages_as_list()
-    elif type == "dict" or type == "dictionary":
+    elif type in ["dict", "dictionary"]:
         return conversation.to_dict()
-    elif type == "string" or type == "str":
+    elif type in ["string", "str"]:
         return conversation.get_str()
-    elif type == "final" or type == "last":
+    elif type in ["final", "last"]:
         return conversation.get_final_message_content()
     elif type == "json":
         return conversation.to_json()
@@ -19,5 +37,11 @@ def history_output_formatter(
         return conversation.get_str()
     elif type == "yaml":
         return yaml.safe_dump(conversation.to_dict(), sort_keys=False)
+    # elif type == "dict-final":
+    #     return conversation.to_dict()
+    elif type == "dict-all-except-first":
+        return conversation.return_all_except_first()
+    elif type == "str-all-except-first":
+        return conversation.return_all_except_first_string()
     else:
         raise ValueError(f"Invalid type: {type}")

swarms/utils/litellm_wrapper.py

@@ -254,16 +254,32 @@ class LiteLLM:
                     self.messages
                 )  # Use modality-processed messages
 
-            # Prepare common completion parameters
-            completion_params = {
-                "model": self.model_name,
-                "messages": messages,
-                "stream": self.stream,
-                "temperature": self.temperature,
-                "max_tokens": self.max_tokens,
-                "caching": self.caching,
-                **kwargs,
-            }
+            if (
+                self.model_name == "openai/o4-mini"
+                or self.model_name == "openai/o3-2025-04-16"
+            ):
+                # Prepare common completion parameters
+                completion_params = {
+                    "model": self.model_name,
+                    "messages": messages,
+                    "stream": self.stream,
+                    # "temperature": self.temperature,
+                    "max_completion_tokens": self.max_tokens,
+                    "caching": self.caching,
+                    **kwargs,
+                }
+
+            else:
+                # Prepare common completion parameters
+                completion_params = {
+                    "model": self.model_name,
+                    "messages": messages,
+                    "stream": self.stream,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "caching": self.caching,
+                    **kwargs,
+                }
 
             # Handle tool-based completion
             if self.tools_list_dictionary is not None:

{swarms-7.6.9.dist-info → swarms-7.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.6.9
+Version: 7.7.1
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT

{swarms-7.6.9.dist-info → swarms-7.7.1.dist-info}/RECORD

@@ -51,6 +51,7 @@ swarms/prompts/multi_modal_autonomous_instruction_prompt.py,sha256=SHfaKs5Hj9sV4
 swarms/prompts/multi_modal_prompts.py,sha256=yvE9_RAFTKU1QhN0rNOelrO7jn5fjDARpcKussbBc2c,3511
 swarms/prompts/multi_modal_visual_prompts.py,sha256=Apv5vqTzB7nBj7nnoMPO0fog3PL9KLrteEjYM_SjaEE,3225
 swarms/prompts/operations_agent_prompt.py,sha256=7ioHxH-xMVqo7vy-wuwHvs9OXQjx-sDQbHFgExZVobI,3454
+swarms/prompts/paper_idea_agent.py,sha256=I__fp0Rbpa5yr09C9UWPDZI7_jVRpejt9jrUSqcZHEw,1107
 swarms/prompts/personal_stylist.py,sha256=_14TSdWdHs6WCnBSK5--1QXcHv5qK466O6A781jif7c,2149
 swarms/prompts/product_agent_prompt.py,sha256=RN24ZeXA-QEVYWFoobJRtpXzQJ0shPhcUpCbNLkArTc,8333
 swarms/prompts/programming.py,sha256=Bg_PV5CexJFLqadJjjliU6t89q8IeQTEp2ZyEF9kO0g,10144
@@ -82,12 +83,13 @@ swarms/schemas/agent_input_schema.py,sha256=qhPyThMx2on91yG9mzNdP_08GpMh1IRDHDwF
 swarms/schemas/agent_step_schemas.py,sha256=a14gb58vR0xOwB_fwSJQbN6yb9HddEaT30E6hUrzEQA,2573
 swarms/schemas/base_schemas.py,sha256=UvBLVWg2qRen4tK5GJz50v42SiX95EQ5qK7hfyAHTEU,3267
 swarms/structs/__init__.py,sha256=gzD4B2KvKsS_WU7OOdJUlOwjAefTdhBPnBgsVz3RYCY,4247
-swarms/structs/agent.py,sha256=LcxNeZDzZ_Bbgv6ebkzfqAJ3J5yIf7dJP0_Tn-BW63o,96853
+swarms/structs/agent.py,sha256=Qzg2eWwJ5lHgYYGpjeBVV3E2EazTfAWH3Owbi-OHOHo,98868
 swarms/structs/agent_builder.py,sha256=tYNpfO4_8cgfMHfgA5DAOWffHnt70p6CLt59esqfVCY,12133
 swarms/structs/agent_registry.py,sha256=il507cO1NF-d4ChyANVLuWrN8bXsEAi8_7bLJ_sTU6A,12112
 swarms/structs/agent_roles.py,sha256=8XEw6RjOOZelaZaWt4gXaYQm5WMLEhSO7W6Z8sQjmFg,582
 swarms/structs/agent_router.py,sha256=YZw5AaK2yTvxkOA7ouED_4MoYgn0XZggvo1wrglp-4E,13017
 swarms/structs/agents_available.py,sha256=SedxDim-0IWgGsNwJZxRIUMfKyAFFXdvXSYeBNu0zGw,2804
+swarms/structs/aop.py,sha256=hmyxK0W_I1baW3EQ5U27uJjkDqNT4PHfIbWl8bvYW1I,17154
 swarms/structs/async_workflow.py,sha256=7YWsLPyGY-1-mMxoIXWQ0FnYH6F227nxsS9PFAJoF9Q,26214
 swarms/structs/auto_swarm_builder.py,sha256=vPM5Kq59D_FvuWJB8hxgHuEvTXsxDxovlBnHGVQsM4o,10938
 swarms/structs/base_structure.py,sha256=GDu4QJQQmhU7IyuFJHIh9UVThACCva-L7uoMbVD9l4s,15901
@@ -95,7 +97,7 @@ swarms/structs/base_swarm.py,sha256=LSGJDPJdyUCcK6698mNtjxoC1OU3s_J2NxC2k_ccGUs,
 swarms/structs/base_workflow.py,sha256=DTfFwX3AdFYxACDYwUDqhsbcDZnITlg5TeEYyxmJBCc,11414
 swarms/structs/concat.py,sha256=utezSxNyh1mIwXgdf8-dJ803NDPyEy79WE8zJHuooGk,732
 swarms/structs/concurrent_workflow.py,sha256=d1_slbALpxrdEGzZffUSAcEbONW0kc7fyTpVZTBmzi4,15517
-swarms/structs/conversation.py,sha256=h4A4l9Mcucw1v-N0mOA4keZ9vf-l3t-kBINZlk_CrOA,18392
+swarms/structs/conversation.py,sha256=696T1QHhaZozLleQFZyeAHEcecdJpNPRB0aCkUdh6OI,18995
 swarms/structs/csv_to_agent.py,sha256=ug9JqQFPguXeU9JQpSUXuVtOpHYdJhlpKJUJBovo694,9443
 swarms/structs/de_hallucination_swarm.py,sha256=9cC0rSSXGwYu6SRDwpeMbCcQ40C1WI1RE9SNapKRLOQ,10309
 swarms/structs/deep_research_swarm.py,sha256=axhzSK43-TViQJntt2Gz2AUhAc6zoBPzj9weRmQ8yE8,16733
@@ -141,7 +143,7 @@ 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/bootup.py,sha256=0leCNCy5rhzL19EsOsqHWSDI85KVcWO6_5hLDS0h4sY,1155
-swarms/telemetry/main.py,sha256=Uj4pZsEwukTdEQE_i8IWDOQAqY1YuMRpSGPwKP-2KQI,8454
+swarms/telemetry/main.py,sha256=ADJ1daQQKZpMwa9y1sAPFLrzwoY1raPgeb6p8-_3jFo,11205
 swarms/tools/__init__.py,sha256=pqIMcRQr4gtoNdbyI1N5k4upkYSBMxACJbxfB9yrV4c,1493
 swarms/tools/base_tool.py,sha256=BiBCFHin8AyZO3FYOGA-n3M2o-F36xUeIBUiybnZYjI,15179
 swarms/tools/cohere_func_call_schema.py,sha256=XJ6_yBMXCrV9KjN7v9Bk1iFj69TRlGIWYKsUTA1oGiQ,600
@@ -151,6 +153,7 @@ 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.py,sha256=tXlZsh0KKyYw0RIsazlxZ5XsloY569sgQZUlsUdx2bM,2683
 swarms/tools/mcp_integration.py,sha256=rUXxC9NvXQ3V4B7Lt1AoI4ZYiCl2-T4FW3_689HTRZk,12839
 swarms/tools/openai_func_calling_schema_pydantic.py,sha256=6BAH9kuaVTvJIbjgSSJ5XvHhWvWszPxgarkfUuE5Ads,978
 swarms/tools/openai_tool_creator_decorator.py,sha256=SYZjHnARjWvnH9cBdj7Kc_Yy1muvNxMT3RQz8KkA2SE,2578
@@ -169,9 +172,9 @@ swarms/utils/disable_logging.py,sha256=KKPKQVfQqLPFgj03uveOoyeHOTlfEJt-yfLc3SA53
 swarms/utils/file_processing.py,sha256=QjQCIPTcwicQlfy656BXBYpIzMR0s2343E7ftnok5Uo,4865
 swarms/utils/formatter.py,sha256=YykmcuWXkxvQ7a2Vq6OzWuqUDiIwro6VrtSt4ITbXcU,4194
 swarms/utils/function_caller_model.py,sha256=ZfgCMzOizNnuZipYLclTziECNHszH9p8RQcUq7VNr4Q,4156
-swarms/utils/history_output_formatter.py,sha256=WHcd0xhSNRDKakXtkCjv0nW1NF-GM9SYcey3RrN5gl8,778
+swarms/utils/history_output_formatter.py,sha256=5Gc-FLUDTkTYfzZVbfq4EL-wAZqPN0mD3K3h62CB71k,1379
 swarms/utils/litellm_tokenizer.py,sha256=0AAj4NffBe2eHii_3_5SpQAhSiBbunJR8MzaBTIm7hg,484
-swarms/utils/litellm_wrapper.py,sha256=mhlG52rffI-vNYbEnHsuYzraFbtsnx84-jb7WMZLReA,14507
+swarms/utils/litellm_wrapper.py,sha256=xdRRj2MvO-4RtfD1SHOCKoidX1UTKRj__I7CvWxQV3o,15145
 swarms/utils/loguru_logger.py,sha256=hIoSK3NHLpe7eAmjHRURrEYzNXYC2gbR7_Vv63Yaydk,685
 swarms/utils/markdown_message.py,sha256=RThHNnMf6ZLTlYK4vKn3yuewChaxWAYAWb0Xm_pTyIU,652
 swarms/utils/parse_code.py,sha256=XFOLymbdP3HzMZuqsj7pwUyisvUmTm0ev9iThR_ambI,1987
@@ -181,8 +184,8 @@ swarms/utils/try_except_wrapper.py,sha256=appEGu9Afy3TmdkNNXUgQ9yU9lj2j0uNkIoW0J
 swarms/utils/visualizer.py,sha256=0ylohEk62MAS6iPRaDOV03m9qo2k5J56tWlKJk_46p4,16927
 swarms/utils/vllm_wrapper.py,sha256=OIGnU9Vf81vE_hul1FK-xEhChFK8fxqZX6-fhQeW22c,4987
 swarms/utils/wrapper_clusterop.py,sha256=PMSCVM7ZT1vgj1D_MYAe835RR3SMLYxA-si2JS02yNQ,4220
-swarms-7.6.9.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.6.9.dist-info/METADATA,sha256=iTHHfwETykHYl3yWPpH3QtNOuur9YrksWFmYzP5VV8I,104909
-swarms-7.6.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-swarms-7.6.9.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.6.9.dist-info/RECORD,,
+swarms-7.7.1.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.7.1.dist-info/METADATA,sha256=_rVOKIek6LO--J4jqcewJ0aRKD2t63raUHk8C9v9GXk,104909
+swarms-7.7.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+swarms-7.7.1.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.7.1.dist-info/RECORD,,