swarms 7.9.9__py3-none-any.whl → 8.0.0__py3-none-any.whl

swarms/agents/reasoning_agents.py

@@ -30,20 +30,12 @@ Example usage:
     >>> results = router.batched_run(["2+2?", "3+3?"])
     >>> print(results)
 
-See also:
-    - docs/swarms/agents/reasoning_agent_router.md for detailed documentation and architecture diagrams.
-    - consistency_example.py for a usage example with SelfConsistencyAgent.
-
 """
 
+import traceback
 from typing import (
     List,
     Literal,
-    Dict,
-    Callable,
-    Any,
-    Tuple,
-    Hashable,
     Optional,
 )
 
@@ -71,6 +63,22 @@ agent_types = Literal[
 ]
 
 
+class ReasoningAgentExecutorError(Exception):
+    """
+    Exception raised when an error occurs during the execution of a reasoning agent.
+    """
+
+    pass
+
+
+class ReasoningAgentInitializationError(Exception):
+    """
+    Exception raised when an error occurs during the initialization of a reasoning agent.
+    """
+
+    pass
+
+
 class ReasoningAgentRouter:
     """
     A router for advanced reasoning agent swarms.
@@ -99,9 +107,6 @@ class ReasoningAgentRouter:
         >>> print(result)
     """
 
-    # Class variable to store cached agent instances
-    _agent_cache: Dict[Tuple[Hashable, ...], Any] = {}
-
     def __init__(
         self,
         agent_name: str = "reasoning_agent",
@@ -117,6 +122,9 @@ class ReasoningAgentRouter:
         eval: bool = False,
         random_models_on: bool = False,
         majority_voting_prompt: Optional[str] = None,
+        reasoning_model_name: Optional[
+            str
+        ] = "claude-3-5-sonnet-20240620",
     ):
         """
         Initialize the ReasoningAgentRouter with the specified configuration.
@@ -136,9 +144,29 @@ class ReasoningAgentRouter:
         self.eval = eval
         self.random_models_on = random_models_on
         self.majority_voting_prompt = majority_voting_prompt
+        self.reasoning_model_name = reasoning_model_name
+
+        self.reliability_check()
+
+    def reliability_check(self):
+
+        if self.max_loops == 0:
+            raise ReasoningAgentInitializationError(
+                "ReasoningAgentRouter Error: Max loops must be greater than 0"
+            )
+
+        if self.model_name == "" or self.model_name is None:
+            raise ReasoningAgentInitializationError(
+                "ReasoningAgentRouter Error: Model name must be provided"
+            )
+
+        if self.swarm_type == "" or self.swarm_type is None:
+            raise ReasoningAgentInitializationError(
+                "ReasoningAgentRouter Error: Swarm type must be provided. This is the type of reasoning agent you want to use. For example, 'reasoning-duo' for a reasoning duo agent, 'self-consistency' for a self-consistency agent, 'ire' for an iterative reflective expansion agent, 'reasoning-agent' for a reasoning agent, 'consistency-agent' for a consistency agent, 'ire-agent' for an iterative reflective expansion agent, 'ReflexionAgent' for a reflexion agent, 'GKPAgent' for a generated knowledge prompting agent, 'AgentJudge' for an agent judge."
+            )
 
         # Initialize the factory mapping dictionary
-        self._initialize_agent_factories()
+        self.agent_factories = self._initialize_agent_factories()
 
     def _initialize_agent_factories(self) -> None:
         """
@@ -146,46 +174,19 @@ class ReasoningAgentRouter:
 
         This method replaces the original if-elif chain, making the code more maintainable and extensible.
         """
-        self.agent_factories: Dict[str, Callable[[], Any]] = {
-            # ReasoningDuo factory method
+        agent_factories = {
             "reasoning-duo": self._create_reasoning_duo,
             "reasoning-agent": self._create_reasoning_duo,
-            # SelfConsistencyAgent factory methods
             "self-consistency": self._create_consistency_agent,
             "consistency-agent": self._create_consistency_agent,
-            # IREAgent factory methods
             "ire": self._create_ire_agent,
             "ire-agent": self._create_ire_agent,
-            # Other agent type factory methods
             "AgentJudge": self._create_agent_judge,
             "ReflexionAgent": self._create_reflexion_agent,
             "GKPAgent": self._create_gkp_agent,
         }
 
-    def _get_cache_key(self) -> Tuple[Hashable, ...]:
-        """
-        Generate a unique key for cache lookup.
-
-        The key is based on all relevant configuration parameters of the agent.
-
-        Returns:
-            Tuple[Hashable, ...]: A hashable tuple to serve as the cache key.
-        """
-        return (
-            self.swarm_type,
-            self.agent_name,
-            self.description,
-            self.model_name,
-            self.system_prompt,
-            self.max_loops,
-            self.num_samples,
-            self.output_type,
-            self.num_knowledge_items,
-            self.memory_capacity,
-            self.eval,
-            self.random_models_on,
-            self.majority_voting_prompt,
-        )
+        return agent_factories
 
     def _create_reasoning_duo(self):
         """
@@ -200,6 +201,8 @@ class ReasoningAgentRouter:
             model_name=[self.model_name, self.model_name],
             system_prompt=self.system_prompt,
             output_type=self.output_type,
+            reasoning_model_name=self.reasoning_model_name,
+            max_loops=self.max_loops,
         )
 
     def _create_consistency_agent(self):
@@ -285,32 +288,23 @@ class ReasoningAgentRouter:
         """
         Select and initialize the appropriate reasoning swarm based on the specified swarm type.
 
-        Uses a caching mechanism to return a cached instance if an agent with the same configuration already exists.
-
         Returns:
             The selected reasoning swarm instance.
 
         Raises:
             ValueError: If the specified swarm type is invalid.
         """
-        # Generate cache key
-        cache_key = self._get_cache_key()
-
-        # Check if an instance with the same configuration already exists in the cache
-        if cache_key in self.__class__._agent_cache:
-            return self.__class__._agent_cache[cache_key]
-
         try:
-            # Use the factory method to create a new instance
-            agent = self.agent_factories[self.swarm_type]()
-
-            # Add the newly created instance to the cache
-            self.__class__._agent_cache[cache_key] = agent
-
-            return agent
-        except KeyError:
-            # Keep the same error handling as the original code
-            raise ValueError(f"Invalid swarm type: {self.swarm_type}")
+            if self.swarm_type in self.agent_factories:
+                return self.agent_factories[self.swarm_type]()
+            else:
+                raise ReasoningAgentInitializationError(
+                    f"ReasoningAgentRouter Error: Invalid swarm type: {self.swarm_type}"
+                )
+        except Exception as e:
+            raise ReasoningAgentInitializationError(
+                f"ReasoningAgentRouter Error: {e} Traceback: {traceback.format_exc()} If the error persists, please check the agent's configuration and try again. If you would like support book a call with our team at https://cal.com/swarms"
+            )
 
     def run(self, task: str, *args, **kwargs):
         """
@@ -324,8 +318,13 @@ class ReasoningAgentRouter:
         Returns:
             The result of the reasoning process (format depends on agent and output_type).
         """
-        swarm = self.select_swarm()
-        return swarm.run(task=task, *args, **kwargs)
+        try:
+            swarm = self.select_swarm()
+            return swarm.run(task=task, *args, **kwargs)
+        except Exception as e:
+            raise ReasoningAgentExecutorError(
+                f"ReasoningAgentRouter Error: {e} Traceback: {traceback.format_exc()} If the error persists, please check the agent's configuration and try again. If you would like support book a call with our team at https://cal.com/swarms"
+            )
 
     def batched_run(self, tasks: List[str], *args, **kwargs):
         """
@@ -343,12 +342,3 @@ class ReasoningAgentRouter:
         for task in tasks:
             results.append(self.run(task, *args, **kwargs))
         return results
-
-    @classmethod
-    def clear_cache(cls):
-        """
-        Clear the agent instance cache.
-
-        Use this when you need to free memory or force the creation of new instances.
-        """
-        cls._agent_cache.clear()

swarms/agents/reasoning_duo.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 
 from loguru import logger
 
@@ -9,6 +9,7 @@ from swarms.structs.conversation import Conversation
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
 )
+import uuid
 
 
 class ReasoningDuo:
@@ -26,26 +27,44 @@ class ReasoningDuo:
 
     def __init__(
         self,
+        id: str = str(uuid.uuid4()),
         agent_name: str = "reasoning-agent-01",
         agent_description: str = "A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
         model_name: str = "gpt-4o-mini",
         description: str = "A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
         model_names: list[str] = ["gpt-4o-mini", "gpt-4o"],
         system_prompt: str = "You are a helpful assistant that can answer questions and help with tasks.",
-        output_type: OutputType = "dict",
+        output_type: OutputType = "dict-all-except-first",
+        reasoning_model_name: Optional[
+            str
+        ] = "claude-3-5-sonnet-20240620",
+        max_loops: int = 1,
+        *args,
+        **kwargs,
     ):
+        self.id = id
         self.agent_name = agent_name
         self.agent_description = agent_description
         self.model_name = model_name
         self.description = description
         self.output_type = output_type
+        self.reasoning_model_name = reasoning_model_name
+        self.max_loops = max_loops
+
+        if self.reasoning_model_name is None:
+            self.reasoning_model_name = model_names[0]
+
+        self.conversation = Conversation()
+
         self.reasoning_agent = Agent(
-            agent_name="Your",
-            description="A highly intelligent and thoughtful AI designed to provide accurate and well-reasoned answers to the user's questions.",
+            agent_name=self.agent_name,
+            description=self.agent_description,
             system_prompt=REASONING_PROMPT,
             max_loops=1,
-            model_name=model_names[0],
+            model_name=self.reasoning_model_name,
             dynamic_temperature_enabled=True,
+            *args,
+            **kwargs,
         )
 
         self.main_agent = Agent(
@@ -55,55 +74,89 @@ class ReasoningDuo:
             max_loops=1,
             model_name=model_names[1],
             dynamic_temperature_enabled=True,
+            *args,
+            **kwargs,
         )
 
-        self.conversation = Conversation()
-
-    def run(self, task: str):
+    def step(self, task: str, img: Optional[str] = None):
         """
-        Executes the reasoning and main agents on the provided task.
+        Executes one step of reasoning and main agent processing.
 
         Args:
-            task (str): The task to be processed by the agents.
-
-        Returns:
-            str: The output from the main agent after processing the task.
+            task (str): The task to be processed.
+            img (Optional[str]): Optional image input.
         """
-        logger.info(f"Running task: {task}")
-
-        self.conversation.add(role="user", content=task)
-
-        output_reasoner = self.reasoning_agent.run(task)
+        # For reasoning agent, use the current task (which may include conversation context)
+        output_reasoner = self.reasoning_agent.run(task, img=img)
 
         self.conversation.add(
             role=self.reasoning_agent.agent_name,
             content=output_reasoner,
         )
 
-        prompt = f"Task: {task} \n\n Your thoughts: {output_reasoner}"
-
-        output_main = self.main_agent.run(prompt)
+        # For main agent, always use the full conversation context
+        output_main = self.main_agent.run(
+            task=self.conversation.get_str(), img=img
+        )
 
         self.conversation.add(
             role=self.main_agent.agent_name, content=output_main
         )
 
+    def run(self, task: str, img: Optional[str] = None):
+        """
+        Executes the reasoning and main agents on the provided task.
+
+        Args:
+            task (str): The task to be processed by the agents.
+            img (Optional[str]): Optional image input.
+
+        Returns:
+            str: The output from the main agent after processing the task.
+        """
+        logger.info(
+            f"Running task: {task} with max_loops: {self.max_loops}"
+        )
+        self.conversation.add(role="user", content=task)
+
+        for loop_iteration in range(self.max_loops):
+            logger.info(
+                f"Loop iteration {loop_iteration + 1}/{self.max_loops}"
+            )
+
+            if loop_iteration == 0:
+                # First iteration: use original task
+                current_task = task
+            else:
+                # Subsequent iterations: use task with context of previous reasoning
+                current_task = f"Continue reasoning and refining your analysis. Original task: {task}\n\nPrevious conversation context:\n{self.conversation.get_str()}"
+
+            self.step(task=current_task, img=img)
+
         return history_output_formatter(
             self.conversation, self.output_type
         )
 
-    def batched_run(self, tasks: List[str]):
+    def batched_run(
+        self, tasks: List[str], imgs: Optional[List[str]] = None
+    ):
         """
         Executes the run method for a list of tasks.
 
         Args:
             tasks (list[str]): A list of tasks to be processed.
+            imgs (Optional[List[str]]): Optional list of images corresponding to tasks.
 
         Returns:
             list: A list of outputs from the main agent for each task.
         """
         outputs = []
-        for task in tasks:
+
+        # Handle case where imgs is None
+        if imgs is None:
+            imgs = [None] * len(tasks)
+
+        for task, img in zip(tasks, imgs):
             logger.info(f"Processing task: {task}")
-            outputs.append(self.run(task))
+            outputs.append(self.run(task, img=img))
         return outputs

swarms/structs/__init__.py

@@ -92,6 +92,7 @@ from swarms.structs.interactive_groupchat import (
 )
 
 from swarms.structs.hiearchical_swarm import HierarchicalSwarm
+from swarms.structs.heavy_swarm import HeavySwarm
 
 __all__ = [
     "Agent",
@@ -169,4 +170,5 @@ __all__ = [
     "priority_speaker",
     "random_dynamic_speaker",
     "HierarchicalSwarm",
+    "HeavySwarm",
 ]

swarms/structs/agent.py

@@ -1110,6 +1110,8 @@ class Agent:
                                     f"Structured Output - Attempting Function Call Execution [{time.strftime('%H:%M:%S')}] \n\n Output: {format_data_structure(response)} ",
                                     loop_count,
                                 )
+                            elif self.streaming_on:
+                                pass
                             else:
                                 self.pretty_print(
                                     response, loop_count
@@ -1239,12 +1241,13 @@ class Agent:
         traceback_info = traceback.format_exc()
 
         logger.error(
-            f"Error detected running your agent {self.agent_name}\n"
+            f"An error occurred while running your agent {self.agent_name}.\n"
             f"Error Type: {error_type}\n"
             f"Error Message: {error_message}\n"
             f"Traceback:\n{traceback_info}\n"
             f"Agent State: {self.to_dict()}\n"
-            f"Optimize your input parameters and or add an issue on the swarms github and contact our team on discord for support ;)"
+            f"Please optimize your input parameters, or create an issue on the Swarms GitHub and contact our team on Discord for support. "
+            f"For technical support, refer to this document: https://docs.swarms.world/en/latest/swarms/support/"
         )
 
         raise error
@@ -1539,15 +1542,16 @@ class Agent:
 
         if self.tools_list_dictionary is not None:
             if not supports_function_calling(self.model_name):
-                raise AgentInitializationError(
+                logger.warning(
                     f"The model '{self.model_name}' does not support function calling. Please use a model that supports function calling."
                 )
 
         try:
             if self.max_tokens > get_max_tokens(self.model_name):
-                raise AgentInitializationError(
+                logger.warning(
                     f"Max tokens is set to {self.max_tokens}, but the model '{self.model_name}' only supports {get_max_tokens(self.model_name)} tokens. Please set max tokens to {get_max_tokens(self.model_name)} or less."
                 )
+
         except Exception:
             pass
 
@@ -2683,9 +2687,18 @@ class Agent:
 
             return output
 
-        except ValueError as e:
+        except AgentRunError as e:
             self._handle_run_error(e)
 
+        except KeyboardInterrupt:
+            logger.warning(
+                f"Keyboard interrupt detected for agent '{self.agent_name}'. "
+                "If autosave is enabled, the agent's state will be saved to the workspace directory. "
+                "To enable autosave, please initialize the agent with Agent(autosave=True)."
+                "For technical support, refer to this document: https://docs.swarms.world/en/latest/swarms/support/"
+            )
+            raise KeyboardInterrupt
+
     def handle_artifacts(
         self, text: str, file_output_path: str, file_extension: str
     ) -> None:
@@ -2824,6 +2837,9 @@ class Agent:
         if response is None:
             response = "No response generated"
 
+        if self.streaming_on:
+            pass
+
         if self.print_on:
             formatter.print_panel(
                 response,
@@ -3231,13 +3247,3 @@ class Agent:
                 f"Full traceback: {traceback.format_exc()}. "
                 f"Attempting to retry tool execution with 3 attempts"
             )
-
-    def add_tool_schema(self, tool_schema: dict):
-        self.tools_list_dictionary = [tool_schema]
-
-        self.output_type = "dict-all-except-first"
-
-    def add_multiple_tool_schemas(self, tool_schemas: list[dict]):
-        self.tools_list_dictionary = tool_schemas
-
-        self.output_type = "dict-all-except-first"