swarms 7.5.4__tar.gz → 7.5.6__tar.gz

{swarms-7.5.4 → swarms-7.5.6}/PKG-INFO

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

{swarms-7.5.4 → swarms-7.5.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "7.5.4"
+version = "7.5.6"
 description = "Swarms - TGSC"
 license = "MIT"
 authors = ["Kye Gomez <kye@apac.ai>"]

{swarms-7.5.4 → swarms-7.5.6}/swarms/agents/__init__.py

@@ -1,3 +1,15 @@
+from swarms.agents.consistency_agent import SelfConsistencyAgent
+
+# from swarms.agents.tool_agent import ToolAgent
+from swarms.agents.create_agents_from_yaml import (
+    create_agents_from_yaml,
+)
+from swarms.agents.i_agent import IterativeReflectiveExpansion
+from swarms.agents.reasoning_agents import (
+    ReasoningAgentRouter,
+    agent_types as reasoning_agent_types,
+)
+from swarms.agents.reasoning_duo import ReasoningDuo
 from swarms.structs.stopping_conditions import (
     check_cancelled,
     check_complete,
@@ -11,15 +23,6 @@ from swarms.structs.stopping_conditions import (
     check_success,
 )
 
-# from swarms.agents.tool_agent import ToolAgent
-from swarms.agents.create_agents_from_yaml import (
-    create_agents_from_yaml,
-)
-
-from swarms.agents.i_agent import IterativeReflectiveExpansion
-from swarms.agents.consistency_agent import SelfConsistencyAgent
-from swarms.agents.reasoning_duo import ReasoningDuo
-
 __all__ = [
     # "ToolAgent",
     "check_done",
@@ -36,4 +39,6 @@ __all__ = [
     "IterativeReflectiveExpansion",
     "SelfConsistencyAgent",
     "ReasoningDuo",
+    "ReasoningAgentRouter",
+    "reasoning_agent_types",
 ]

{swarms-7.5.4 → swarms-7.5.6}/swarms/agents/consistency_agent.py

@@ -7,7 +7,11 @@ from loguru import logger
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 from swarms.structs.malt import majority_voting_prompt
+from swarms.structs.output_types import OutputType
 from swarms.utils.any_to_str import any_to_str
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 
 CONSISTENCY_SYSTEM_PROMPT = """
 You are a reasoning agent designed for complex problem-solving and decision-making. Your objective is to provide clear and reliable responses through structured reasoning. Begin by thoroughly understanding the problem, rephrasing it for clarity, and identifying key components. Develop a logical plan that breaks the problem into manageable steps, detailing your approach and any assumptions made. Validate your information with reliable sources and assess the accuracy of your calculations. Explore multiple solutions, weighing their pros and cons, and maintain transparency by documenting your reasoning process, uncertainties, and biases. Summarize your findings in a concise final answer that reflects your thorough analysis, ensuring it is well-organized and accessible. Adapt your reasoning to the context of the problem, integrating new information as needed, and implement error-handling strategies to address any issues that arise. Finally, reflect on your reasoning process to identify areas for improvement and ensure consistency across all reasoning paths.
@@ -42,13 +46,12 @@ class SelfConsistencyAgent(Agent):
         self,
         name: str = "Self-Consistency-Agent",
         description: str = "An agent that uses self consistency to generate a final answer.",
+        system_prompt: str = CONSISTENCY_SYSTEM_PROMPT,
         num_samples: int = 5,
-        return_list: bool = False,
         max_loops: int = 1,
-        return_dict: bool = False,
-        return_json: bool = False,
         majority_voting_prompt: str = None,
         eval: bool = False,
+        output_type: OutputType = "dict",
         **kwargs,
     ):
         """
@@ -61,17 +64,15 @@ class SelfConsistencyAgent(Agent):
         super().__init__(
             name=name,
             description=description,
-            system_prompt=CONSISTENCY_SYSTEM_PROMPT,
             **kwargs,
         )
         self.num_samples = num_samples
         self.conversation = Conversation()
-        self.return_list = return_list
         self.max_loops = max_loops
-        self.return_dict = return_dict
-        self.return_json = return_json
         self.majority_voting_prompt = majority_voting_prompt
         self.eval = eval
+        self.output_type = output_type
+        self.system_prompt = system_prompt
 
     def run(
         self, task: str, answer: str = None, *args, **kwargs
@@ -124,12 +125,9 @@ class SelfConsistencyAgent(Agent):
             role="Majority Voting Agent", content=final_answer
         )
 
-        if self.return_list:
-            self.conversation.return_messages_as_list()
-        elif self.return_dict:
-            self.conversation.return_json()
-        else:
-            return final_answer
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
 
     def aggregate(self, responses: List[str]) -> str:
         """

{swarms-7.5.4 → swarms-7.5.6}/swarms/agents/i_agent.py

@@ -22,6 +22,10 @@ from typing import List, Tuple
 from loguru import logger
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
+from swarms.structs.output_types import OutputType
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 
 # Define a new system prompt for general problem solving
 GENERAL_REASONING_AGENT_SYS_PROMPT = """
@@ -43,12 +47,13 @@ class IterativeReflectiveExpansion:
 
     def __init__(
         self,
+        agent_name: str = "General-Reasoning-Agent",
+        description: str = "A reasoning agent that can answer questions and help with tasks.",
         agent: Agent = None,
         max_iterations: int = 5,
-        return_list: bool = False,
-        return_dict: bool = False,
-        prompt: str = GENERAL_REASONING_AGENT_SYS_PROMPT,
+        system_prompt: str = GENERAL_REASONING_AGENT_SYS_PROMPT,
         model_name: str = "gpt-4o-mini",
+        output_type: OutputType = "dict",
     ) -> None:
         """
         Initialize the Iterative Reflective Expansion engine.
@@ -56,16 +61,17 @@ class IterativeReflectiveExpansion:
         :param agent: The Swarms agent instance used to perform reasoning tasks.
         :param max_iterations: Maximum number of iterations for the reasoning process.
         """
+        self.agent_name = agent_name
+        self.description = description
         self.agent = agent
         self.max_iterations = max_iterations
-        self.return_list = return_list
-        self.return_dict = return_dict
-
+        self.output_type = output_type
+        self.system_prompt = system_prompt
         self.conversation = Conversation()
 
         self.agent = Agent(
-            agent_name="General-Reasoning-Agent",
-            system_prompt=prompt,
+            agent_name=self.agent_name,
+            system_prompt=self.system_prompt,
             model_name=model_name,
             max_loops=1,
             dynamic_temperature_enabled=True,
@@ -273,18 +279,12 @@ class IterativeReflectiveExpansion:
                 f"Candidate paths for next iteration: {candidate_paths}"
             )
 
-        final_solution = self.synthesize_solution(
-            candidate_paths, memory_pool
-        )
+        self.synthesize_solution(candidate_paths, memory_pool)
         logger.info("Final solution generated.")
 
-        if self.return_list:
-            return self.conversation.return_messages_as_list()
-        elif self.return_dict:
-            return self.conversation.return_messages_as_dict()
-
-        else:
-            return final_solution
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
 
 
 # def main() -> None:

swarms-7.5.6/swarms/agents/reasoning_agents.py

@@ -0,0 +1,130 @@
+from typing import List, Literal
+
+from swarms.agents.consistency_agent import SelfConsistencyAgent
+from swarms.agents.i_agent import (
+    IterativeReflectiveExpansion as IREAgent,
+)
+from swarms.agents.reasoning_duo import ReasoningDuo
+from swarms.structs.output_types import OutputType
+
+agent_types = Literal[
+    "reasoning-duo",
+    "self-consistency",
+    "ire",
+    "reasoning-agent",
+    "consistency-agent",
+    "ire-agent",
+]
+
+
+class ReasoningAgentRouter:
+    """
+    A Reasoning Agent that can answer questions and assist with various tasks using different reasoning strategies.
+
+    Attributes:
+        agent_name (str): The name of the agent.
+        description (str): A brief description of the agent's capabilities.
+        model_name (str): The name of the model used for reasoning.
+        system_prompt (str): The prompt that guides the agent's reasoning process.
+        max_loops (int): The maximum number of loops for the reasoning process.
+        swarm_type (agent_types): The type of reasoning swarm to use (e.g., reasoning duo, self-consistency, IRE).
+        num_samples (int): The number of samples to generate for self-consistency agents.
+        output_type (OutputType): The format of the output (e.g., dict, list).
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "reasoning_agent",
+        description: str = "A reasoning agent that can answer questions and help with tasks.",
+        model_name: str = "gpt-4o-mini",
+        system_prompt: str = "You are a helpful assistant that can answer questions and help with tasks.",
+        max_loops: int = 1,
+        swarm_type: agent_types = "reasoning_duo",
+        num_samples: int = 1,
+        output_type: OutputType = "dict",
+    ):
+        self.agent_name = agent_name
+        self.description = description
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.max_loops = max_loops
+        self.swarm_type = swarm_type
+        self.num_samples = num_samples
+        self.output_type = output_type
+
+    def select_swarm(self):
+        """
+        Selects and initializes the appropriate reasoning swarm based on the specified swarm type.
+
+        Returns:
+            An instance of the selected reasoning swarm.
+        """
+        if (
+            self.swarm_type == "reasoning-duo"
+            or self.swarm_type == "reasoning-agent"
+        ):
+            return ReasoningDuo(
+                agent_name=self.agent_name,
+                agent_description=self.description,
+                model_name=[self.model_name, self.model_name],
+                system_prompt=self.system_prompt,
+                output_type=self.output_type,
+            )
+
+        elif (
+            self.swarm_type == "self-consistency"
+            or self.swarm_type == "consistency-agent"
+        ):
+            return SelfConsistencyAgent(
+                agent_name=self.agent_name,
+                description=self.description,
+                model_name=self.model_name,
+                system_prompt=self.system_prompt,
+                max_loops=self.max_loops,
+                num_samples=self.num_samples,
+                output_type=self.output_type,
+            )
+
+        elif (
+            self.swarm_type == "ire" or self.swarm_type == "ire-agent"
+        ):
+            return IREAgent(
+                agent_name=self.agent_name,
+                description=self.description,
+                model_name=self.model_name,
+                system_prompt=self.system_prompt,
+                max_loops=self.max_loops,
+                max_iterations=self.num_samples,
+                output_type=self.output_type,
+            )
+
+        else:
+            raise ValueError(f"Invalid swarm type: {self.swarm_type}")
+
+    def run(self, task: str, *args, **kwargs):
+        """
+        Executes the selected swarm's reasoning process on the given task.
+
+        Args:
+            task (str): The task or question to be processed by the reasoning agent.
+
+        Returns:
+            The result of the reasoning process.
+        """
+        swarm = self.select_swarm()
+        return swarm.run(task=task)
+
+    def batched_run(self, tasks: List[str], *args, **kwargs):
+        """
+        Executes the reasoning process on a batch of tasks.
+
+        Args:
+            tasks (List[str]): A list of tasks to be processed.
+
+        Returns:
+            List of results from the reasoning process for each task.
+        """
+        results = []
+        for task in tasks:
+            results.append(self.run(task, *args, **kwargs))
+        return results

{swarms-7.5.4 → swarms-7.5.6}/swarms/agents/reasoning_duo.py

@@ -4,6 +4,11 @@ from loguru import logger
 
 from swarms.prompts.reasoning_prompt import REASONING_PROMPT
 from swarms.structs.agent import Agent
+from swarms.structs.output_types import OutputType
+from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 
 
 class ReasoningDuo:
@@ -21,14 +26,19 @@ class ReasoningDuo:
 
     def __init__(
         self,
-        model_name: str = "reasoning-agent-01",
+        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",
     ):
+        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_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.",
@@ -39,14 +49,16 @@ class ReasoningDuo:
         )
 
         self.main_agent = Agent(
-            agent_name="Main Agent",
-            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=system_prompt,
             max_loops=1,
             model_name=model_names[1],
             dynamic_temperature_enabled=True,
         )
 
+        self.conversation = Conversation()
+
     def run(self, task: str):
         """
         Executes the reasoning and main agents on the provided task.
@@ -58,14 +70,27 @@ class ReasoningDuo:
             str: The output from the main agent after processing the task.
         """
         logger.info(f"Running task: {task}")
+
+        self.conversation.add(role="user", content=task)
+
         output_reasoner = self.reasoning_agent.run(task)
 
-        output_main = self.main_agent.run(
-            f"Task: {task} \n\n Your thoughts: {output_reasoner}"
+        self.conversation.add(
+            role=self.reasoning_agent.agent_name,
+            content=output_reasoner,
         )
 
-        logger.info(f"Output from main agent: {output_main}")
-        return output_main
+        prompt = f"Task: {task} \n\n Your thoughts: {output_reasoner}"
+
+        output_main = self.main_agent.run(prompt)
+
+        self.conversation.add(
+            role=self.main_agent.agent_name, content=output_main
+        )
+
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
 
     def batched_run(self, tasks: List[str]):
         """

swarms-7.5.6/swarms/utils/history_output_formatter.py

@@ -0,0 +1,14 @@
+from swarms.structs.conversation import Conversation
+
+
+def history_output_formatter(
+    conversation: Conversation, type: str = "list"
+):
+    if type == "list":
+        return conversation.return_messages_as_list()
+    elif type == "dict":
+        return conversation.to_dict()
+    elif type == "string" or type == "str":
+        return conversation.get_str()
+    else:
+        raise ValueError(f"Invalid type: {type}")