swarms 7.6.5__py3-none-any.whl → 7.6.6__py3-none-any.whl

swarms/structs/agent.py

@@ -46,6 +46,11 @@ 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.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
@@ -55,15 +60,10 @@ from swarms.utils.history_output_formatter import (
     history_output_formatter,
 )
 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
 
-from swarms.tools.mcp_integration import (
-    batch_mcp_flow,
-    mcp_flow_get_tool_schema,
-    MCPServerSseParams,
-)
-
 
 # Utils
 # Custom stopping condition
@@ -104,6 +104,51 @@ agent_output_type = Literal[
 ToolUsageType = Union[BaseModel, Dict[str, Any]]
 
 
+# Agent Exceptions
+
+
+class AgentError(Exception):
+    """Base class for all agent-related exceptions."""
+
+    pass
+
+
+class AgentInitializationError(AgentError):
+    """Exception raised when the agent fails to initialize properly. Please check the configuration and parameters."""
+
+    pass
+
+
+class AgentRunError(AgentError):
+    """Exception raised when the agent encounters an error during execution. Ensure that the task and environment are set up correctly."""
+
+    pass
+
+
+class AgentLLMError(AgentError):
+    """Exception raised when there is an issue with the language model (LLM). Verify the model's availability and compatibility."""
+
+    pass
+
+
+class AgentToolError(AgentError):
+    """Exception raised when the agent fails to utilize a tool. Check the tool's configuration and availability."""
+
+    pass
+
+
+class AgentMemoryError(AgentError):
+    """Exception raised when the agent encounters a memory-related issue. Ensure that memory resources are properly allocated and accessible."""
+
+    pass
+
+
+class AgentLLMInitializationError(AgentError):
+    """Exception raised when the LLM fails to initialize properly. Please check the configuration and parameters."""
+
+    pass
+
+
 # [FEAT][AGENT]
 class Agent:
     """
@@ -479,6 +524,12 @@ class Agent:
         self.no_print = no_print
         self.tools_list_dictionary = tools_list_dictionary
         self.mcp_servers = mcp_servers
+        self._cached_llm = (
+            None  # Add this line to cache the LLM instance
+        )
+        self._default_model = (
+            "gpt-4o-mini"  # Move default model name here
+        )
 
         if (
             self.agent_name is not None
@@ -599,50 +650,49 @@ class Agent:
             self.tools_list_dictionary = self.mcp_tool_handling()
 
     def llm_handling(self):
-        from swarms.utils.litellm_wrapper import LiteLLM
+        # Use cached instance if available
+        if self._cached_llm is not None:
+            return self._cached_llm
 
         if self.model_name is None:
-            # raise ValueError("Model name cannot be None")
             logger.warning(
-                "Model name is not provided, using gpt-4o-mini. You can configure any model from litellm if desired."
+                f"Model name is not provided, using {self._default_model}. You can configure any model from litellm if desired."
             )
-            self.model_name = "gpt-4o-mini"
+            self.model_name = self._default_model
 
         try:
+            # Simplify initialization logic
+            common_args = {
+                "model_name": self.model_name,
+                "temperature": self.temperature,
+                "max_tokens": self.max_tokens,
+                "system_prompt": self.system_prompt,
+            }
+
             if self.llm_args is not None:
-                llm = LiteLLM(
-                    model_name=self.model_name, **self.llm_args
+                self._cached_llm = LiteLLM(
+                    **{**common_args, **self.llm_args}
                 )
             elif self.tools_list_dictionary is not None:
-
-                length_of_tools_list_dictionary = len(
-                    self.tools_list_dictionary
-                )
-
-                if length_of_tools_list_dictionary > 0:
-
-                    parallel_tool_calls = True
-
-                llm = LiteLLM(
-                    model_name=self.model_name,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    system_prompt=self.system_prompt,
+                self._cached_llm = LiteLLM(
+                    **common_args,
                     tools_list_dictionary=self.tools_list_dictionary,
                     tool_choice="auto",
-                    parallel_tool_calls=parallel_tool_calls,
+                    parallel_tool_calls=len(
+                        self.tools_list_dictionary
+                    )
+                    > 1,
                 )
             else:
-                llm = LiteLLM(
-                    model_name=self.model_name,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    system_prompt=self.system_prompt,
-                    stream=self.streaming_on,
+                self._cached_llm = LiteLLM(
+                    **common_args, stream=self.streaming_on
                 )
-            return llm
-        except Exception as e:
-            logger.error(f"Error in llm_handling: {e}")
+
+            return self._cached_llm
+        except AgentLLMInitializationError as e:
+            logger.error(
+                f"Error in llm_handling: {e} Your current configuration is not supported. Please check the configuration and parameters."
+            )
             return None
 
     def mcp_execution_flow(self, response: any):
@@ -2336,6 +2386,8 @@ class Agent:
 
         Args:
             task (str): The task to be performed by the `llm` object.
+            img (str, optional): Path or URL to an image file.
+            audio (str, optional): Path or URL to an audio file.
             *args: Variable length argument list.
             **kwargs: Arbitrary keyword arguments.
 
@@ -2347,22 +2399,22 @@ class Agent:
             TypeError: If task is not a string or llm object is None.
             ValueError: If task is empty.
         """
-        if not isinstance(task, str):
-            raise TypeError("Task must be a string")
+        # if not isinstance(task, str):
+        #     task = any_to_str(task)
 
-        if task is None:
-            raise ValueError("Task cannot be None")
+        # if img is not None:
+        #     kwargs['img'] = img
 
-        # if self.llm is None:
-        #     raise TypeError("LLM object cannot be None")
+        # if audio is not None:
+        #     kwargs['audio'] = audio
 
         try:
-            out = self.llm.run(task, *args, **kwargs)
+            out = self.llm.run(task=task, *args, **kwargs)
 
             return out
-        except AttributeError as e:
+        except AgentLLMError as e:
             logger.error(
-                f"Error calling LLM: {e} You need a class with a run(task: str) method"
+                f"Error calling LLM: {e}. Task: {task}, Args: {args}, Kwargs: {kwargs}"
             )
             raise e
 

swarms/utils/litellm_wrapper.py

@@ -5,7 +5,7 @@ import asyncio
 from typing import List
 
 from loguru import logger
-
+import litellm
 
 try:
     from litellm import completion, acompletion
@@ -77,6 +77,8 @@ class LiteLLM:
         tool_choice: str = "auto",
         parallel_tool_calls: bool = False,
         audio: str = None,
+        retries: int = 3,
+        verbose: bool = False,
         *args,
         **kwargs,
     ):
@@ -100,7 +102,18 @@ class LiteLLM:
         self.tools_list_dictionary = tools_list_dictionary
         self.tool_choice = tool_choice
         self.parallel_tool_calls = parallel_tool_calls
-        self.modalities = ["text"]
+        self.modalities = []
+        self._cached_messages = {}  # Cache for prepared messages
+        self.messages = []  # Initialize messages list
+
+        # Configure litellm settings
+        litellm.set_verbose = (
+            verbose  # Disable verbose mode for better performance
+        )
+        litellm.ssl_verify = ssl_verify
+        litellm.num_retries = (
+            retries  # Add retries for better reliability
+        )
 
     def _prepare_messages(self, task: str) -> list:
         """
@@ -112,15 +125,20 @@ class LiteLLM:
         Returns:
             list: A list of messages prepared for the task.
         """
-        messages = []
+        # Check cache first
+        cache_key = f"{self.system_prompt}:{task}"
+        if cache_key in self._cached_messages:
+            return self._cached_messages[cache_key].copy()
 
-        if self.system_prompt:  # Check if system_prompt is not None
+        messages = []
+        if self.system_prompt:
             messages.append(
                 {"role": "system", "content": self.system_prompt}
             )
-
         messages.append({"role": "user", "content": task})
 
+        # Cache the prepared messages
+        self._cached_messages[cache_key] = messages.copy()
         return messages
 
     def audio_processing(self, task: str, audio: str):
@@ -182,15 +200,16 @@ class LiteLLM:
         """
         Handle the modalities for the given task.
         """
+        self.messages = []  # Reset messages
+        self.modalities.append("text")
+
         if audio is not None:
             self.audio_processing(task=task, audio=audio)
+            self.modalities.append("audio")
 
         if img is not None:
             self.vision_processing(task=task, image=img)
-
-        if audio is not None and img is not None:
-            self.audio_processing(task=task, audio=audio)
-            self.vision_processing(task=task, image=img)
+            self.modalities.append("vision")
 
     def run(
         self,
@@ -205,58 +224,78 @@ class LiteLLM:
 
         Args:
             task (str): The task to run the model for.
-            *args: Additional positional arguments to pass to the model.
-            **kwargs: Additional keyword arguments to pass to the model.
+            audio (str, optional): Audio input if any. Defaults to None.
+            img (str, optional): Image input if any. Defaults to None.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             str: The content of the response from the model.
+
+        Raises:
+            Exception: If there is an error in processing the request.
         """
         try:
-
             messages = self._prepare_messages(task)
 
-            self.handle_modalities(task=task, audio=audio, img=img)
+            if audio is not None or img is not None:
+                self.handle_modalities(
+                    task=task, audio=audio, img=img
+                )
+                messages = (
+                    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,
+                **kwargs,
+            }
 
+            # Handle tool-based completion
             if self.tools_list_dictionary is not None:
-                response = completion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    tools=self.tools_list_dictionary,
-                    modalities=self.modalities,
-                    tool_choice=self.tool_choice,
-                    parallel_tool_calls=self.parallel_tool_calls,
-                    *args,
-                    **kwargs,
+                completion_params.update(
+                    {
+                        "tools": self.tools_list_dictionary,
+                        "tool_choice": self.tool_choice,
+                        "parallel_tool_calls": self.parallel_tool_calls,
+                    }
                 )
-
+                response = completion(**completion_params)
                 return (
                     response.choices[0]
                     .message.tool_calls[0]
                     .function.arguments
                 )
 
-            else:
-                response = completion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    modalities=self.modalities,
-                    *args,
-                    **kwargs,
+            # Handle modality-based completion
+            if (
+                self.modalities and len(self.modalities) > 1
+            ):  # More than just text
+                completion_params.update(
+                    {"modalities": self.modalities}
                 )
+                response = completion(**completion_params)
+                return response.choices[0].message.content
 
-                content = response.choices[
-                    0
-                ].message.content  # Accessing the content
+            # Standard completion
+            response = completion(**completion_params)
+            return response.choices[0].message.content
 
-                return content
         except Exception as error:
-            logger.error(f"Error in LiteLLM: {error}")
+            logger.error(f"Error in LiteLLM run: {str(error)}")
+            if "rate_limit" in str(error).lower():
+                logger.warning(
+                    "Rate limit hit, retrying with exponential backoff..."
+                )
+                import time
+
+                time.sleep(2)  # Add a small delay before retry
+                return self.run(task, audio, img, *args, **kwargs)
             raise error
 
     def __call__(self, task: str, *args, **kwargs):
@@ -275,12 +314,12 @@ class LiteLLM:
 
     async def arun(self, task: str, *args, **kwargs):
         """
-        Run the LLM model for the given task.
+        Run the LLM model asynchronously for the given task.
 
         Args:
             task (str): The task to run the model for.
-            *args: Additional positional arguments to pass to the model.
-            **kwargs: Additional keyword arguments to pass to the model.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             str: The content of the response from the model.
@@ -288,72 +327,113 @@ class LiteLLM:
         try:
             messages = self._prepare_messages(task)
 
+            # Prepare common completion parameters
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": self.stream,
+                "temperature": self.temperature,
+                "max_tokens": self.max_tokens,
+                **kwargs,
+            }
+
+            # Handle tool-based completion
             if self.tools_list_dictionary is not None:
-                response = await acompletion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    tools=self.tools_list_dictionary,
-                    tool_choice=self.tool_choice,
-                    parallel_tool_calls=self.parallel_tool_calls,
-                    *args,
-                    **kwargs,
+                completion_params.update(
+                    {
+                        "tools": self.tools_list_dictionary,
+                        "tool_choice": self.tool_choice,
+                        "parallel_tool_calls": self.parallel_tool_calls,
+                    }
                 )
-
-                content = (
+                response = await acompletion(**completion_params)
+                return (
                     response.choices[0]
                     .message.tool_calls[0]
                     .function.arguments
                 )
 
-                # return response
-
-            else:
-                response = await acompletion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    *args,
-                    **kwargs,
-                )
+            # Standard completion
+            response = await acompletion(**completion_params)
+            return response.choices[0].message.content
 
-                content = response.choices[
-                    0
-                ].message.content  # Accessing the content
-
-            return content
         except Exception as error:
-            logger.error(f"Error in LiteLLM: {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)
             raise error
 
+    async def _process_batch(
+        self, tasks: List[str], batch_size: int = 10
+    ):
+        """
+        Process a batch of tasks asynchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
+        """
+        results = []
+        for i in range(0, len(tasks), batch_size):
+            batch = tasks[i : i + batch_size]
+            batch_results = await asyncio.gather(
+                *[self.arun(task) for task in batch],
+                return_exceptions=True,
+            )
+
+            # Handle any exceptions in the batch
+            for result in batch_results:
+                if isinstance(result, Exception):
+                    logger.error(
+                        f"Error in batch processing: {str(result)}"
+                    )
+                    results.append(str(result))
+                else:
+                    results.append(result)
+
+            # Add a small delay between batches to avoid rate limits
+            if i + batch_size < len(tasks):
+                await asyncio.sleep(0.5)
+
+        return results
+
     def batched_run(self, tasks: List[str], batch_size: int = 10):
         """
-        Run the LLM model for the given tasks in batches.
+        Run multiple tasks in batches synchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
         """
         logger.info(
-            f"Running tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
+            f"Running {len(tasks)} tasks in batches of {batch_size}"
         )
-        results = []
-        for task in tasks:
-            logger.info(f"Running task: {task}")
-            results.append(self.run(task))
-        logger.info("Completed all tasks.")
-        return results
+        return asyncio.run(self._process_batch(tasks, batch_size))
 
-    def batched_arun(self, tasks: List[str], batch_size: int = 10):
+    async def batched_arun(
+        self, tasks: List[str], batch_size: int = 10
+    ):
         """
-        Run the LLM model for the given tasks in batches.
+        Run multiple tasks in batches asynchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
         """
         logger.info(
-            f"Running asynchronous tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
+            f"Running {len(tasks)} tasks asynchronously in batches of {batch_size}"
         )
-        results = []
-        for task in tasks:
-            logger.info(f"Running asynchronous task: {task}")
-            results.append(asyncio.run(self.arun(task)))
-        logger.info("Completed all asynchronous tasks.")
-        return results
+        return await self._process_batch(tasks, batch_size)

{swarms-7.6.5.dist-info → swarms-7.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.6.5
+Version: 7.6.6
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT
@@ -23,6 +23,7 @@ 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.5.dist-info → swarms-7.6.6.dist-info}/RECORD

@@ -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=ER0HI-9RQI22i10x6XQj6TaKoWJgk1a5XIP1KxiBsCU,4310
-swarms/structs/agent.py,sha256=IChi9EZiFUwCmj7dPa9H70TBkYd6VnTt-5Jx5TLPbWI,95234
+swarms/structs/agent.py,sha256=L8ZnvSNrmvK6z0n6RwHZ7MfZtRbwtQ5t6pQPcL2OLfA,96742
 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
@@ -172,7 +172,7 @@ 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=cXZ6nUrHnGhpVgolgbpNsyKq1_TzupJs8vmw-_XtCRM,11255
+swarms/utils/litellm_wrapper.py,sha256=wmWFD_TJI1_puVJTm9w3ZZYN6R0vQ6IRxAoEULHcysg,14194
 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
@@ -183,8 +183,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.5.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.6.5.dist-info/METADATA,sha256=2w553wEExRZlKYKxX_LCvhpbyJbhefIxw43-I1Jvwmw,104909
-swarms-7.6.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-swarms-7.6.5.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.6.5.dist-info/RECORD,,
+swarms-7.6.6.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.6.6.dist-info/METADATA,sha256=TEtg7nZgZwYoprC2ACZmn1n_CC_c7LOWXBIs1aPLLeM,104928
+swarms-7.6.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+swarms-7.6.6.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.6.6.dist-info/RECORD,,