swarms 7.6.7__py3-none-any.whl → 7.7.0__py3-none-any.whl

swarms/__init__.py

@@ -7,6 +7,7 @@ from swarms.telemetry.bootup import bootup  # noqa: E402, F403
 bootup()
 
 from swarms.agents import *  # noqa: E402, F403
+
 from swarms.artifacts import *  # noqa: E402, F403
 from swarms.prompts import *  # noqa: E402, F403
 from swarms.schemas import *  # noqa: E402, F403

swarms/structs/agent.py

@@ -46,11 +46,12 @@ from swarms.structs.safe_loading import (
 )
 from swarms.telemetry.main import log_agent_data
 from swarms.tools.base_tool import BaseTool
-from swarms.tools.mcp_integration import (
-    MCPServerSseParams,
-    batch_mcp_flow,
-    mcp_flow_get_tool_schema,
-)
+
+# from swarms.tools.mcp_integration import (
+#     MCPServerSseParams,
+#     batch_mcp_flow,
+#     mcp_flow_get_tool_schema,
+# )
 from swarms.tools.tool_parse_exec import parse_and_execute_json
 from swarms.utils.any_to_str import any_to_str
 from swarms.utils.data_to_text import data_to_text
@@ -62,7 +63,6 @@ from swarms.utils.history_output_formatter import (
 from swarms.utils.litellm_tokenizer import count_tokens
 from swarms.utils.litellm_wrapper import LiteLLM
 from swarms.utils.pdf_to_text import pdf_to_text
-from swarms.utils.str_to_dict import str_to_dict
 
 
 # Utils
@@ -403,7 +403,7 @@ class Agent:
         role: agent_roles = "worker",
         no_print: bool = False,
         tools_list_dictionary: Optional[List[Dict[str, Any]]] = None,
-        mcp_servers: List[MCPServerSseParams] = [],
+        # mcp_servers: List[MCPServerSseParams] = [],
         *args,
         **kwargs,
     ):
@@ -523,7 +523,7 @@ class Agent:
         self.role = role
         self.no_print = no_print
         self.tools_list_dictionary = tools_list_dictionary
-        self.mcp_servers = mcp_servers
+        # self.mcp_servers = mcp_servers
         self._cached_llm = (
             None  # Add this line to cache the LLM instance
         )
@@ -643,11 +643,11 @@ class Agent:
         if self.llm is None:
             self.llm = self.llm_handling()
 
-        if (
-            self.tools_list_dictionary is None
-            and self.mcp_servers is not None
-        ):
-            self.tools_list_dictionary = self.mcp_tool_handling()
+        # if (
+        #     self.tools_list_dictionary is None
+        #     and self.mcp_servers is not None
+        # ):
+        #     self.tools_list_dictionary = self.mcp_tool_handling()
 
     def llm_handling(self):
         # Use cached instance if available
@@ -695,68 +695,68 @@ class Agent:
             )
             return None
 
-    def mcp_execution_flow(self, response: any):
-        """
-        Executes the MCP (Model Context Protocol) flow based on the provided response.
-
-        This method takes a response, converts it from a string to a dictionary format,
-        and checks for the presence of a tool name or a name in the response. If either
-        is found, it retrieves the tool name and proceeds to call the batch_mcp_flow
-        function to execute the corresponding tool actions.
-
-        Args:
-            response (any): The response to be processed, which can be in string format
-            that represents a dictionary.
-
-        Returns:
-            The output from the batch_mcp_flow function, which contains the results of
-            the tool execution. If an error occurs during processing, it logs the error
-            and returns None.
-
-        Raises:
-            Exception: Logs any exceptions that occur during the execution flow.
-        """
-        try:
-            response = str_to_dict(response)
-
-            tool_output = batch_mcp_flow(
-                self.mcp_servers,
-                function_call=response,
-            )
-
-            return tool_output
-        except Exception as e:
-            logger.error(f"Error in mcp_execution_flow: {e}")
-            return None
-
-    def mcp_tool_handling(self):
-        """
-        Handles the retrieval of tool schemas from the MCP servers.
-
-        This method iterates over the list of MCP servers, retrieves the tool schema
-        for each server using the mcp_flow_get_tool_schema function, and compiles
-        these schemas into a list. The resulting list is stored in the
-        tools_list_dictionary attribute.
-
-        Returns:
-            list: A list of tool schemas retrieved from the MCP servers. If an error
-            occurs during the retrieval process, it logs the error and returns None.
-
-        Raises:
-            Exception: Logs any exceptions that occur during the tool handling process.
-        """
-        try:
-            self.tools_list_dictionary = []
-
-            for mcp_server in self.mcp_servers:
-                tool_schema = mcp_flow_get_tool_schema(mcp_server)
-                self.tools_list_dictionary.append(tool_schema)
-
-            print(self.tools_list_dictionary)
-            return self.tools_list_dictionary
-        except Exception as e:
-            logger.error(f"Error in mcp_tool_handling: {e}")
-            return None
+    # def mcp_execution_flow(self, response: any):
+    #     """
+    #     Executes the MCP (Model Context Protocol) flow based on the provided response.
+
+    #     This method takes a response, converts it from a string to a dictionary format,
+    #     and checks for the presence of a tool name or a name in the response. If either
+    #     is found, it retrieves the tool name and proceeds to call the batch_mcp_flow
+    #     function to execute the corresponding tool actions.
+
+    #     Args:
+    #         response (any): The response to be processed, which can be in string format
+    #         that represents a dictionary.
+
+    #     Returns:
+    #         The output from the batch_mcp_flow function, which contains the results of
+    #         the tool execution. If an error occurs during processing, it logs the error
+    #         and returns None.
+
+    #     Raises:
+    #         Exception: Logs any exceptions that occur during the execution flow.
+    #     """
+    #     try:
+    #         response = str_to_dict(response)
+
+    #         tool_output = batch_mcp_flow(
+    #             self.mcp_servers,
+    #             function_call=response,
+    #         )
+
+    #         return tool_output
+    #     except Exception as e:
+    #         logger.error(f"Error in mcp_execution_flow: {e}")
+    #         return None
+
+    # def mcp_tool_handling(self):
+    #     """
+    #     Handles the retrieval of tool schemas from the MCP servers.
+
+    #     This method iterates over the list of MCP servers, retrieves the tool schema
+    #     for each server using the mcp_flow_get_tool_schema function, and compiles
+    #     these schemas into a list. The resulting list is stored in the
+    #     tools_list_dictionary attribute.
+
+    #     Returns:
+    #         list: A list of tool schemas retrieved from the MCP servers. If an error
+    #         occurs during the retrieval process, it logs the error and returns None.
+
+    #     Raises:
+    #         Exception: Logs any exceptions that occur during the tool handling process.
+    #     """
+    #     try:
+    #         self.tools_list_dictionary = []
+
+    #         for mcp_server in self.mcp_servers:
+    #             tool_schema = mcp_flow_get_tool_schema(mcp_server)
+    #             self.tools_list_dictionary.append(tool_schema)
+
+    #         print(self.tools_list_dictionary)
+    #         return self.tools_list_dictionary
+    #     except Exception as e:
+    #         logger.error(f"Error in mcp_tool_handling: {e}")
+    #         return None
 
     def setup_config(self):
         # The max_loops will be set dynamically if the dynamic_loop
@@ -2490,10 +2490,12 @@ class Agent:
                 **kwargs,
             )
 
-            if self.tools_list_dictionary is not None:
-                return str_to_dict(output)
-            else:
-                return output
+            return output
+
+            # if self.tools_list_dictionary is not None:
+            #     return str_to_dict(output)
+            # else:
+            #     return output
 
         except ValueError as e:
             self._handle_run_error(e)

swarms/structs/deep_research_swarm.py

@@ -176,20 +176,20 @@ tools = [
         "type": "function",
         "function": {
             "name": "search_topic",
-            "description": "Conduct an in-depth search on a specified topic or subtopic, generating a comprehensive array of highly detailed search queries tailored to the input parameters.",
+            "description": "Conduct a thorough search on a specified topic or subtopic, generating a precise array of highly detailed search queries tailored to the input parameters.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "depth": {
                         "type": "integer",
-                        "description": "Indicates the level of thoroughness for the search. Values range from 1 to 3, where 1 represents a superficial search and 3 signifies an exploration of the topic.",
+                        "description": "Indicates the level of thoroughness for the search. Values range from 1 to 3, where 1 signifies a superficial search and 3 indicates an in-depth exploration of the topic.",
                     },
                     "detailed_queries": {
                         "type": "array",
-                        "description": "An array of highly specific search queries that are generated based on the input query and the specified depth. Each query should be designed to elicit detailed and relevant information from various sources.",
+                        "description": "An array of specific search queries generated based on the input query and the specified depth. Each query must be crafted to elicit detailed and relevant information from various sources.",
                         "items": {
                             "type": "string",
-                            "description": "Each item in this array should represent a unique search query that targets a specific aspect of the main topic, ensuring a comprehensive exploration of the subject matter.",
+                            "description": "Each item in this array must represent a unique search query targeting a specific aspect of the main topic, ensuring a comprehensive exploration of the subject matter.",
                         },
                     },
                 },

swarms/structs/swarm_builder.py

@@ -177,11 +177,6 @@ class AutoSwarmBuilder:
             swarm_type=swarm_type,
         )
 
-        if not self.api_key:
-            raise ValueError(
-                "OpenAI API key must be provided either through initialization or environment variable"
-            )
-
         logger.info(
             "Initialized AutoSwarmBuilder",
             extra={

swarms/telemetry/main.py

@@ -1,18 +1,25 @@
+# Add these imports at the top
+import asyncio
+
+
 import datetime
 import hashlib
 import platform
 import socket
 import subprocess
-import threading
 import uuid
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
+from threading import Lock
 from typing import Dict
 
 import aiohttp
-import httpx
 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
@@ -251,92 +258,123 @@ 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}")
-        return {}
 
 
-def _log_agent_data(data_dict: dict) -> dict | None:
-    """
 
-    Args:
-        data_dict (dict): The dictionary containing the agent data to be logged.
+# 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
 
-    Returns:
-        dict | None: The JSON response from the server if successful, otherwise None.
-    """
+async def log_agent_data_async(data_dict: dict):
+    """Asynchronous version of log_agent_data"""
     if not data_dict:
         return None
 
     url = "https://swarms.world/api/get-agents/log-agents"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": "sk-xxx",  # replace with actual
-    }
-
     payload = {
         "data": data_dict,
-        "system_data": get_user_device_data(),
-        "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
+        "system_data": get_user_device_data_cached(),
+        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
     }
 
+    session = await get_aiohttp_session()
     try:
-        with httpx.Client(http2=True, timeout=3.0) as client:
-            response = client.post(url, json=payload, headers=headers)
-            if response.status_code == 200 and response.content:
-                return response.json()
+        async with session.post(url, json=payload) as response:
+            if response.status == 200:
+                return await response.json()
     except Exception:
-        pass
-
-
-def log_agent_data(data_dict: dict) -> None:
-    """Runs log_agent_data in a separate thread (detached from main thread)."""
-    threading.Thread(
-        target=_log_agent_data, args=(data_dict,), daemon=True
-    ).start()
-
+        return None
 
-async def async_log_agent_data(data_dict: dict) -> dict | None:
+def log_agent_data(data_dict: dict):
     """
-
-    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.
+    Enhanced log_agent_data with both sync and async capabilities
     """
     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": "sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
-    }
+    # 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
 
-    data_input = {
+    # Fallback to optimized sync version
+    url = "https://swarms.world/api/get-agents/log-agents"
+    payload = {
         "data": data_dict,
-        "system_data": get_user_device_data(),
-        "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
+        "system_data": get_user_device_data_cached(),
+        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
     }
 
-    async with aiohttp.ClientSession() as session:
-        try:
-            async with session.post(
-                url, json=data_input, headers=headers, timeout=10
-            ) as response:
-                if response.ok and await response.text():
-                    out = await response.json()
-                    return out
-        except Exception:
-            pass
+    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()
+    except Exception:
+        return None

swarms/utils/litellm_wrapper.py

@@ -27,6 +27,12 @@ except ImportError:
     litellm.ssl_verify = False
 
 
+class LiteLLMException(Exception):
+    """
+    Exception for LiteLLM.
+    """
+
+
 def get_audio_base64(audio_source: str) -> str:
     """
     Convert audio from a given source to a base64 encoded string.
@@ -79,6 +85,7 @@ class LiteLLM:
         audio: str = None,
         retries: int = 3,
         verbose: bool = False,
+        caching: bool = False,
         *args,
         **kwargs,
     ):
@@ -102,6 +109,7 @@ class LiteLLM:
         self.tools_list_dictionary = tools_list_dictionary
         self.tool_choice = tool_choice
         self.parallel_tool_calls = parallel_tool_calls
+        self.caching = caching
         self.modalities = []
         self._cached_messages = {}  # Cache for prepared messages
         self.messages = []  # Initialize messages list
@@ -253,6 +261,7 @@ class LiteLLM:
                 "stream": self.stream,
                 "temperature": self.temperature,
                 "max_tokens": self.max_tokens,
+                "caching": self.caching,
                 **kwargs,
             }
 
@@ -283,10 +292,13 @@ class LiteLLM:
                 return response.choices[0].message.content
 
             # Standard completion
-            response = completion(**completion_params)
-            return response.choices[0].message.content
+            if self.stream:
+                return completion(**completion_params)
+            else:
+                response = completion(**completion_params)
+                return response.choices[0].message.content
 
-        except Exception as error:
+        except LiteLLMException as error:
             logger.error(f"Error in LiteLLM run: {str(error)}")
             if "rate_limit" in str(error).lower():
                 logger.warning(
@@ -355,16 +367,18 @@ class LiteLLM:
 
             # Standard completion
             response = await acompletion(**completion_params)
-            return response.choices[0].message.content
+
+            print(response)
+            return response
 
         except Exception as error:
             logger.error(f"Error in LiteLLM arun: {str(error)}")
-            if "rate_limit" in str(error).lower():
-                logger.warning(
-                    "Rate limit hit, retrying with exponential backoff..."
-                )
-                await asyncio.sleep(2)  # Use async sleep
-                return await self.arun(task, *args, **kwargs)
+            # if "rate_limit" in str(error).lower():
+            #     logger.warning(
+            #         "Rate limit hit, retrying with exponential backoff..."
+            #     )
+            #     await asyncio.sleep(2)  # Use async sleep
+            #     return await self.arun(task, *args, **kwargs)
             raise error
 
     async def _process_batch(

{swarms-7.6.7.dist-info → swarms-7.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.6.7
+Version: 7.7.0
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT
@@ -23,7 +23,6 @@ Requires-Dist: docstring_parser (==0.16)
 Requires-Dist: httpx
 Requires-Dist: litellm
 Requires-Dist: loguru
-Requires-Dist: mcp
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: psutil

{swarms-7.6.7.dist-info → swarms-7.7.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-swarms/__init__.py,sha256=bc-57terLt5Uxlawsdq-ER6ukbVrxxWy8PEoG7VB5Ug,560
+swarms/__init__.py,sha256=YxGdUrWHekSiNneyQUM7Yrdf6pCIy2-xgIzhocZY0Ek,561
 swarms/agents/__init__.py,sha256=ebUrX9rMccQokq5XthgnzGDMISn8EyQyOIOwVAlLs1E,1190
 swarms/agents/agent_judge.py,sha256=xT242CX5mV64cq2B-3RGkuEHiV5aD04P_Zq8_s64iMQ,3967
 swarms/agents/agent_print.py,sha256=SXqWA2ZzXwRFdv8hkuYwOPMTasvaGTG6U29413qRCAA,918
@@ -82,7 +82,7 @@ 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=L8ZnvSNrmvK6z0n6RwHZ7MfZtRbwtQ5t6pQPcL2OLfA,96742
+swarms/structs/agent.py,sha256=LcxNeZDzZ_Bbgv6ebkzfqAJ3J5yIf7dJP0_Tn-BW63o,96853
 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
@@ -98,7 +98,7 @@ swarms/structs/concurrent_workflow.py,sha256=d1_slbALpxrdEGzZffUSAcEbONW0kc7fyTp
 swarms/structs/conversation.py,sha256=h4A4l9Mcucw1v-N0mOA4keZ9vf-l3t-kBINZlk_CrOA,18392
 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=h4jtrcuiAKMWMYo8I7oaq6eFn8cJpqHhml58EveNbZ4,16756
+swarms/structs/deep_research_swarm.py,sha256=axhzSK43-TViQJntt2Gz2AUhAc6zoBPzj9weRmQ8yE8,16733
 swarms/structs/dynamic_conversational_swarm.py,sha256=n_d1jDCzBwiGb0QjJpW_MlXxqEkhGEhC1ttaebH7f3Q,8098
 swarms/structs/graph_swarm.py,sha256=HPHlLWwdSPSe4o-I06ZOIgtBg72a06llEnv8-aglf3Q,20962
 swarms/structs/graph_workflow.py,sha256=TAaUG_J3898hhghPOp0WEAV3Zf0in6s48ZSVbSTX-vQ,8629
@@ -126,7 +126,7 @@ swarms/structs/sequential_workflow.py,sha256=5jxHP-a2CzdclSXIrVWkQKXBr01VzrgOBIe
 swarms/structs/spreadsheet_swarm.py,sha256=ToX56QJjlm_nnC3MYppvKC_NTr9Zy_orkBzfxNLdwbA,14845
 swarms/structs/stopping_conditions.py,sha256=Z0Jx0U2feAfQfuVV_IJGgal62DoVsGPN8K6HkkqB_bM,484
 swarms/structs/swarm_arange.py,sha256=6fexCPsXRgdLbpY0p9rp_REipeXzsbv1_GOtD9B4HaI,15179
-swarms/structs/swarm_builder.py,sha256=moO9jqvCM3EYInYsGshlESov_7DTyK_PgXiLj58eqB8,13232
+swarms/structs/swarm_builder.py,sha256=TqxD4bIE11gPZBqi_awXem5-svnQ-IJVAhRquX0ErQg,13054
 swarms/structs/swarm_eval.py,sha256=148E2R2zaCmt_LZYx15nmdFjybXHiQ2CZbl6pk77jNs,11635
 swarms/structs/swarm_id_generator.py,sha256=Wly7AtGM9e6VgzhYmfg8_gSOdxAdsOvWHJFK81cpQNQ,68
 swarms/structs/swarm_load_balancer.py,sha256=pUCc5FEBcuJ_GmOFeTWBPfXlUdiTOjYcJqVq_ymGHlM,11374
@@ -139,10 +139,9 @@ swarms/structs/talk_hier.py,sha256=npyEuL52SCgQmMynIvGjfatNqOz4toq0EyhEtSNmQhQ,2
 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/structs/workspace_manager.py,sha256=t0OgUP9dDU7xS6N3mAT2PbXvjHTsUK3nf2mxppcfZ70,5473
 swarms/telemetry/__init__.py,sha256=yibtkHEbQRPUv6ir1FhDHlAO_3nwKJPQH4LjzBC2AuQ,661
 swarms/telemetry/bootup.py,sha256=0leCNCy5rhzL19EsOsqHWSDI85KVcWO6_5hLDS0h4sY,1155
-swarms/telemetry/main.py,sha256=QBQyO4JgIeMLGbdVPFaipIBasCMwuADB5wDNKQBEYDQ,9474
+swarms/telemetry/main.py,sha256=w_6ud1onZpBgqIF-173GEesXLLj4iyvzTTjhz7pFUqc,11096
 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
@@ -172,19 +171,18 @@ swarms/utils/formatter.py,sha256=YykmcuWXkxvQ7a2Vq6OzWuqUDiIwro6VrtSt4ITbXcU,419
 swarms/utils/function_caller_model.py,sha256=ZfgCMzOizNnuZipYLclTziECNHszH9p8RQcUq7VNr4Q,4156
 swarms/utils/history_output_formatter.py,sha256=WHcd0xhSNRDKakXtkCjv0nW1NF-GM9SYcey3RrN5gl8,778
 swarms/utils/litellm_tokenizer.py,sha256=0AAj4NffBe2eHii_3_5SpQAhSiBbunJR8MzaBTIm7hg,484
-swarms/utils/litellm_wrapper.py,sha256=wmWFD_TJI1_puVJTm9w3ZZYN6R0vQ6IRxAoEULHcysg,14194
+swarms/utils/litellm_wrapper.py,sha256=mhlG52rffI-vNYbEnHsuYzraFbtsnx84-jb7WMZLReA,14507
 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
 swarms/utils/pdf_to_text.py,sha256=nkySOS_sJ4Jf4RP5SoDpMB5WfjJ_GGc5z8gJfn2cxOM,1311
 swarms/utils/str_to_dict.py,sha256=T3Jsdjz87WIlkSo7jAW6BB80sv0Ns49WT1qXlOrdEoE,874
-swarms/utils/swarm_reliability_checks.py,sha256=MsgUULt3HYg72D0HifZNmtCyJYpLA2UDA2wQixI-NbA,2562
 swarms/utils/try_except_wrapper.py,sha256=appEGu9Afy3TmdkNNXUgQ9yU9lj2j0uNkIoW0JhVzzY,3917
 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.7.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.6.7.dist-info/METADATA,sha256=PqWXBFtGfiGKlv29sgmOP2QN7VRWBVgeVZ18hGtlXgs,104928
-swarms-7.6.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-swarms-7.6.7.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.6.7.dist-info/RECORD,,
+swarms-7.7.0.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.7.0.dist-info/METADATA,sha256=AjkFhCgUgocVqF_3D_HR8IA30JnY2ckwUg3ywrBbvE0,104909
+swarms-7.7.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+swarms-7.7.0.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.7.0.dist-info/RECORD,,

swarms/structs/workspace_manager.py

@@ -1,178 +0,0 @@
-import os
-from pathlib import Path
-from typing import Optional
-from swarms.utils.loguru_logger import initialize_logger
-
-
-logger = initialize_logger("workspace-manager")
-
-
-class WorkspaceManager:
-    """
-    Manages the workspace directory and settings for the application.
-    This class is responsible for setting up the workspace directory, logging configuration,
-    and retrieving environment variables for telemetry and API key.
-    """
-
-    def __init__(
-        self,
-        workspace_dir: Optional[str] = "agent_workspace",
-        use_telemetry: Optional[bool] = True,
-        api_key: Optional[str] = None,
-    ):
-        """
-        Initializes the WorkspaceManager with optional parameters for workspace directory,
-        telemetry usage, and API key.
-
-        Args:
-            workspace_dir (Optional[str]): The path to the workspace directory.
-            use_telemetry (Optional[bool]): A flag indicating whether to use telemetry.
-            api_key (Optional[str]): The API key for the application.
-        """
-        self.workspace_dir = workspace_dir
-        self.use_telemetry = use_telemetry
-        self.api_key = api_key
-
-    def _create_env_file(self, env_file_path: Path) -> None:
-        """
-        Create a new .env file with default WORKSPACE_DIR.
-
-        Args:
-            env_file_path (Path): The path to the .env file.
-        """
-        with env_file_path.open("w") as file:
-            file.write(f"WORKSPACE_DIR={self.workspace_dir}\n")
-        logger.info(
-            "Created a new .env file with default WORKSPACE_DIR."
-        )
-
-    def _append_to_env_file(self, env_file_path: Path) -> None:
-        """
-        Append WORKSPACE_DIR to .env if it doesn't exist.
-
-        Args:
-            env_file_path (Path): The path to the .env file.
-        """
-        with env_file_path.open("r+") as file:
-            content = file.read()
-            if "WORKSPACE_DIR" not in content:
-                file.seek(0, os.SEEK_END)
-                file.write(f"WORKSPACE_DIR={self.workspace_dir}\n")
-                logger.info("Appended WORKSPACE_DIR to .env file.")
-
-    def _get_workspace_dir(
-        self, workspace_dir: Optional[str] = None
-    ) -> str:
-        """
-        Get the workspace directory from environment variable or default.
-
-        Args:
-            workspace_dir (Optional[str]): The path to the workspace directory.
-
-        Returns:
-            str: The path to the workspace directory.
-        """
-        return workspace_dir or os.getenv(
-            "WORKSPACE_DIR", "agent_workspace"
-        )
-
-    def _get_telemetry_status(
-        self, use_telemetry: Optional[bool] = None
-    ) -> bool:
-        """
-        Get telemetry status from environment variable or default.
-
-        Args:
-            use_telemetry (Optional[bool]): A flag indicating whether to use telemetry.
-
-        Returns:
-            bool: The status of telemetry usage.
-        """
-        return (
-            use_telemetry
-            if use_telemetry is not None
-            else os.getenv("USE_TELEMETRY", "true").lower() == "true"
-        )
-
-    def _get_api_key(
-        self, api_key: Optional[str] = None
-    ) -> Optional[str]:
-        """
-        Get API key from environment variable or default.
-
-        Args:
-            api_key (Optional[str]): The API key for the application.
-
-        Returns:
-            Optional[str]: The API key or None if not set.
-        """
-        return api_key or os.getenv("SWARMS_API_KEY")
-
-    def _init_workspace(self) -> None:
-        """
-        Initialize the workspace directory if it doesn't exist.
-        """
-        if not self.workspace_path.exists():
-            self.workspace_path.mkdir(parents=True, exist_ok=True)
-        logger.info("Workspace directory initialized.")
-
-    @property
-    def get_workspace_path(self) -> Path:
-        """
-        Get the workspace path.
-
-        Returns:
-            Path: The path to the workspace directory.
-        """
-        return self.workspace_path
-
-    @property
-    def get_telemetry_status(self) -> bool:
-        """
-        Get telemetry status.
-
-        Returns:
-            bool: The status of telemetry usage.
-        """
-        return self.use_telemetry
-
-    @property
-    def get_api_key(self) -> Optional[str]:
-        """
-        Get API key.
-
-        Returns:
-            Optional[str]: The API key or None if not set.
-        """
-        return self.api_key
-
-    def run(self) -> None:
-        try:
-            # Check if .env file exists and create it if it doesn't
-            env_file_path = Path(".env")
-
-            # If the .env file doesn't exist, create it
-            if not env_file_path.exists():
-                self._create_env_file(env_file_path)
-            else:
-                # Append WORKSPACE_DIR to .env if it doesn't exist
-                self._append_to_env_file(env_file_path)
-
-            # Set workspace directory
-            self.workspace_dir = self._get_workspace_dir(
-                self.workspace_dir
-            )
-            self.workspace_path = Path(self.workspace_dir)
-
-            # Set telemetry preference
-            self.use_telemetry = self._get_telemetry_status(
-                self.use_telemetry
-            )
-
-            # Set API key
-            self.api_key = self._get_api_key(self.api_key)
-
-            # Initialize workspace
-            self._init_workspace()
-        except Exception as e:
-            logger.error(f"Error initializing WorkspaceManager: {e}")

swarms/utils/swarm_reliability_checks.py

@@ -1,81 +0,0 @@
-from typing import Callable, List, Optional, Union
-
-from swarms.structs.agent import Agent
-from swarms.utils.loguru_logger import initialize_logger
-
-logger = initialize_logger(log_folder="swarm_reliability_checks")
-
-
-def reliability_check(
-    agents: List[Union[Agent, Callable]],
-    max_loops: int,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    flow: Optional[str] = None,
-) -> None:
-    """
-    Performs reliability checks on swarm configuration parameters.
-
-    Args:
-        agents: List of Agent objects or callables that will be executed
-        max_loops: Maximum number of execution loops
-        name: Name identifier for the swarm
-        description: Description of the swarm's purpose
-
-    Raises:
-        ValueError: If any parameters fail validation checks
-        TypeError: If parameters are of incorrect type
-    """
-    logger.info("Initializing swarm reliability checks")
-
-    # Type checking
-    if not isinstance(agents, list):
-        raise TypeError("agents parameter must be a list")
-
-    if not isinstance(max_loops, int):
-        raise TypeError("max_loops must be an integer")
-
-    # Validate agents
-    if not agents:
-        raise ValueError("Agents list cannot be empty")
-
-    for i, agent in enumerate(agents):
-        if not isinstance(agent, (Agent, Callable)):
-            raise TypeError(
-                f"Agent at index {i} must be an Agent instance or Callable"
-            )
-
-    # Validate max_loops
-    if max_loops <= 0:
-        raise ValueError("max_loops must be greater than 0")
-
-    if max_loops > 1000:
-        logger.warning(
-            "Large max_loops value detected. This may impact performance."
-        )
-
-    # Validate name
-    if name is None:
-        raise ValueError("name parameter is required")
-    if not isinstance(name, str):
-        raise TypeError("name must be a string")
-    if len(name.strip()) == 0:
-        raise ValueError("name cannot be empty or just whitespace")
-
-    # Validate description
-    if description is None:
-        raise ValueError("description parameter is required")
-    if not isinstance(description, str):
-        raise TypeError("description must be a string")
-    if len(description.strip()) == 0:
-        raise ValueError(
-            "description cannot be empty or just whitespace"
-        )
-
-    # Validate flow
-    if flow is None:
-        raise ValueError("flow parameter is required")
-    if not isinstance(flow, str):
-        raise TypeError("flow must be a string")
-
-    logger.info("All reliability checks passed successfully")