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

swarms/structs/mixture_of_agents.py

@@ -1,59 +1,20 @@
 import asyncio
 import os
-import time
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
-from pydantic import BaseModel, Field
 
 from swarms.structs.agent import Agent
-from swarms.telemetry.main import log_agent_data
-from swarms.schemas.agent_step_schemas import ManySteps
-from swarms.prompts.ag_prompt import aggregator_system_prompt
+from swarms.prompts.ag_prompt import aggregator_system_prompt_main
 from swarms.utils.loguru_logger import initialize_logger
 import concurrent.futures
 from swarms.structs.output_types import OutputType
 from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 
 logger = initialize_logger(log_folder="mixture_of_agents")
 
-time_stamp = time.strftime("%Y-%m-%d %H:%M:%S")
-
-
-class MixtureOfAgentsInput(BaseModel):
-    name: str = "MixtureOfAgents"
-    description: str = (
-        "A class to run a mixture of agents and aggregate their responses."
-    )
-    agents: List[Dict[str, Any]]
-    aggregator_agent: Any = Field(
-        ...,
-        description="An aggregator agent to be used in the mixture.",
-    )
-    aggregator_system_prompt: str = Field(
-        default=aggregator_system_prompt.get_prompt(),
-        description=aggregator_system_prompt.description,
-    )
-    layers: int = 3
-    time_created: str = Field(
-        time_stamp,
-        description="The time the mixture of agents was created.",
-    )
-
-
-class MixtureOfAgentsOutput(BaseModel):
-    id: str = Field(
-        ..., description="The ID of the mixture of agents."
-    )
-    task: str = Field(..., description="None")
-    InputConfig: MixtureOfAgentsInput
-    # output: List[ManySteps]
-    normal_agent_outputs: List[ManySteps]
-    aggregator_agent_summary: str
-    time_completed: str = Field(
-        time_stamp,
-        description="The time the mixture of agents was completed.",
-    )
-
 
 class MixtureOfAgents:
     """
@@ -66,7 +27,7 @@ class MixtureOfAgents:
         description: str = "A class to run a mixture of agents and aggregate their responses.",
         agents: List[Agent] = [],
         aggregator_agent: Agent = None,
-        aggregator_system_prompt: str = "",
+        aggregator_system_prompt: str = aggregator_system_prompt_main,
         layers: int = 3,
         max_loops: int = 1,
         return_str_on: bool = False,
@@ -85,31 +46,13 @@ class MixtureOfAgents:
         """
         self.name = name
         self.description = description
-        self.agents: List[Agent] = agents
-        self.aggregator_agent: Agent = aggregator_agent
-        self.aggregator_system_prompt: str = aggregator_system_prompt
-        self.layers: int = layers
-        self.max_loops: int = max_loops
-        self.return_str_on: bool = return_str_on
-        self.output_type: OutputType = output_type
-
-        self.input_schema = MixtureOfAgentsInput(
-            name=name,
-            description=description,
-            agents=[agent.to_dict() for agent in self.agents],
-            aggregator_agent=aggregator_agent.to_dict(),
-            aggregator_system_prompt=self.aggregator_system_prompt,
-            layers=self.layers,
-            time_created=time_stamp,
-        )
-
-        self.output_schema = MixtureOfAgentsOutput(
-            id="MixtureOfAgents",
-            InputConfig=self.input_schema.model_dump(),
-            normal_agent_outputs=[],
-            aggregator_agent_summary="",
-            task="",
-        )
+        self.agents = agents
+        self.aggregator_agent = aggregator_agent
+        self.aggregator_system_prompt = aggregator_system_prompt_main
+        self.layers = layers
+        self.max_loops = max_loops
+        self.return_str_on = return_str_on
+        self.output_type = output_type
 
         self.reliability_check()
 
@@ -182,9 +125,6 @@ class MixtureOfAgents:
         Returns:
             str: The response from the agent.
         """
-        # Update the task in the output schema
-        self.output_schema.task = task
-
         # If there are previous responses, update the agent's system prompt
         if prev_responses:
             system_prompt_with_responses = (
@@ -197,9 +137,7 @@ class MixtureOfAgents:
         # Run the agent asynchronously
         response = await asyncio.to_thread(agent.run, task)
 
-        self.output_schema.normal_agent_outputs.append(
-            agent.agent_output
-        )
+        self.conversation.add(agent.agent_name, response)
 
         # Log the agent's response
         print(f"Agent {agent.agent_name} response: {response}")
@@ -235,7 +173,6 @@ class MixtureOfAgents:
         final_result = await self._run_agent_async(
             self.aggregator_agent, task, prev_responses=results
         )
-        self.output_schema.aggregator_agent_summary = final_result
 
         print(f"Final Aggregated Response: {final_result}")
 
@@ -248,38 +185,18 @@ class MixtureOfAgents:
         """
         try:
             self.conversation.add("user", task)
-            prev_context = None
 
             for _ in range(self.max_loops):
                 # Add previous context to task if available
-                current_task = (
-                    f"{task}\n\nPrevious context:\n{prev_context}"
-                    if prev_context
-                    else task
-                )
+                prompt = f"History: {self.conversation.get_str()}\n\nTask: {task}"
 
                 # Run async process
-                asyncio.run(self._run_async(current_task))
+                asyncio.run(self._run_async(prompt))
 
-                # Store current results as context for next loop
-                prev_context = (
-                    self.output_schema.aggregator_agent_summary
-                )
-
-            self.output_schema.task = task
-
-            log_agent_data(self.output_schema.model_dump())
-
-            if self.return_str_on or self.output_type == "str":
-                return self.conversation.get_str()
-            elif self.output_type == "dict":
-                return (
-                    self.conversation.return_messages_as_dictionary()
-                )
-            elif self.output_type == "list":
-                return self.conversation.return_messages_as_list()
-            else:
-                return self.output_schema.model_dump_json(indent=4)
+            return history_output_formatter(
+                conversation=self.conversation,
+                type=self.output_type,
+            )
 
         except Exception as e:
             logger.error(f"Error running mixture of agents: {str(e)}")

swarms/structs/{multi_agent_orchestrator.py → multi_agent_router.py}

@@ -9,8 +9,6 @@ Todo:
 """
 
 import os
-import uuid
-from datetime import datetime
 from typing import List, Optional
 
 from loguru import logger
@@ -20,6 +18,10 @@ from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 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,
+)
+from swarms.utils.formatter import formatter
 
 
 class AgentResponse(BaseModel):
@@ -62,7 +64,7 @@ class MultiAgentRouter:
         temperature: float = 0.1,
         shared_memory_system: callable = None,
         output_type: OutputType = "dict",
-        execute_task: bool = True,
+        if_print: bool = True,
     ):
         """
         Initializes the MultiAgentRouter with a list of agents and configuration options.
@@ -80,15 +82,15 @@ class MultiAgentRouter:
         self.description = description
         self.shared_memory_system = shared_memory_system
         self.output_type = output_type
-        self.execute_task = execute_task
         self.model = model
         self.temperature = temperature
-
+        self.if_print = if_print
         # Initialize Agents
         self.agents = {agent.name: agent for agent in agents}
         self.conversation = Conversation()
 
         self.api_key = os.getenv("OPENAI_API_KEY")
+
         if not self.api_key:
             raise ValueError("OpenAI API key must be provided")
 
@@ -99,6 +101,7 @@ class MultiAgentRouter:
             system_prompt=self.boss_system_prompt,
             api_key=self.api_key,
             temperature=temperature,
+            base_model=AgentResponse,
         )
 
     def __repr__(self):
@@ -140,21 +143,6 @@ class MultiAgentRouter:
         Always select exactly one agent that best matches the task requirements.
         """
 
-    def find_agent_in_list(self, agent_name: str) -> Optional[Agent]:
-        """
-        Find an agent by name in a list of agents.
-
-        Args:
-            agent_name (str): The name of the agent to find.
-
-        Returns:
-            Optional[Agent]: The agent object if found, otherwise None.
-        """
-        for agent in self.agent_list:
-            if agent.name == agent_name:
-                return agent
-        return None
-
     def route_task(self, task: str) -> dict:
         """
         Routes a task to the appropriate agent and returns their response.
@@ -167,15 +155,21 @@ class MultiAgentRouter:
         """
         try:
             self.conversation.add(role="user", content=task)
-            start_time = datetime.now()
 
             # Get boss decision using function calling
-            boss_response = self.function_caller.get_completion(task)
-
+            boss_response = self.function_caller.run(task)
             boss_response_str = any_to_str(boss_response)
 
+            if self.if_print:
+                formatter.print_panel(
+                    boss_response_str,
+                    title="Multi-Agent Router Decision",
+                )
+            else:
+                pass
+
             self.conversation.add(
-                role="assistant", content=boss_response_str
+                role="Agent Router", content=boss_response_str
             )
 
             # Validate that the selected agent exists
@@ -190,60 +184,16 @@ class MultiAgentRouter:
             # Use the modified task if provided, otherwise use original task
             final_task = boss_response.modified_task or task
 
-            # Execute the task with the selected agent if enabled
-            execution_start = datetime.now()
-            agent_response = None
-            execution_time = 0
+            # Use the agent's run method directly
+            agent_response = selected_agent.run(final_task)
 
-            if self.execute_task:
-                # Use the agent's run method directly
-                agent_response = selected_agent.run(final_task)
-                self.conversation.add(
-                    role=selected_agent.name, content=agent_response
-                )
-                execution_time = (
-                    datetime.now() - execution_start
-                ).total_seconds()
-            else:
-                logger.info(
-                    "Task execution skipped (execute_task=False)"
-                )
+            self.conversation.add(
+                role=selected_agent.name, content=agent_response
+            )
 
-            total_time = (datetime.now() - start_time).total_seconds()
-
-            result = {
-                "id": str(uuid.uuid4()),
-                "timestamp": datetime.now().isoformat(),
-                "task": {
-                    "original": task,
-                    "modified": (
-                        final_task
-                        if boss_response.modified_task
-                        else None
-                    ),
-                },
-                "boss_decision": {
-                    "selected_agent": boss_response.selected_agent,
-                    "reasoning": boss_response.reasoning,
-                },
-                "execution": {
-                    "agent_name": selected_agent.name,
-                    "agent_id": selected_agent.id,
-                    "was_executed": self.execute_task,
-                    "response": (
-                        agent_response if self.execute_task else None
-                    ),
-                    "execution_time": (
-                        execution_time if self.execute_task else None
-                    ),
-                },
-                "total_time": total_time,
-            }
-
-            logger.info(
-                f"Successfully routed task to {selected_agent.name}"
+            return history_output_formatter(
+                conversation=self.conversation, type=self.output_type
             )
-            return result
 
         except Exception as e:
             logger.error(f"Error routing task: {str(e)}")
@@ -312,31 +262,18 @@ class MultiAgentRouter:
 #         ),
 #     ]
 
-#     # Initialize routers with different configurations
-#     router_execute = MultiAgentRouter(agents=agents, execute_task=True)
-#     # router_no_execute = MultiAgentRouter(agents=agents, execute_task=False)
+#     # Initialize router
+#     router = MultiAgentRouter(agents=agents)
 
 #     # Example task
 #     task = "Write a Python function to calculate fibonacci numbers"
 
 #     try:
-#         # Process the task with execution
-#         print("\nWith task execution:")
-#         result_execute = router_execute.route_task(task)
-#         print(
-#             f"Selected Agent: {result_execute['boss_decision']['selected_agent']}"
-#         )
-#         print(
-#             f"Reasoning: {result_execute['boss_decision']['reasoning']}"
-#         )
-#         if result_execute["execution"]["response"]:
-#             print(
-#                 f"Response Preview: {result_execute['execution']['response'][:200]}..."
-#             )
-#             print(
-#                 f"Execution Time: {result_execute['execution']['execution_time']:.2f}s"
-#             )
-#         print(f"Total Time: {result_execute['total_time']:.2f}s")
+#         # Process the task
+#         result = router.route_task(task)
+#         print(f"Selected Agent: {result['boss_decision']['selected_agent']}")
+#         print(f"Reasoning: {result['boss_decision']['reasoning']}")
+#         print(f"Total Time: {result['total_time']:.2f}s")
 
 #     except Exception as e:
 #         print(f"Error occurred: {str(e)}")

swarms/structs/output_types.py

@@ -1,19 +1,6 @@
-from typing import Literal
-
-# Literal of output types
-OutputType = Literal[
-    "all",
-    "final",
-    "list",
-    "dict",
-    ".json",
-    ".md",
-    ".txt",
-    ".yaml",
-    ".toml",
-    "string",
-    "str",
-]
+from swarms.utils.history_output_formatter import (
+    HistoryOutputType as OutputType,
+)
 
 # Use the OutputType for type annotations
 output_type: OutputType

swarms/structs/stopping_conditions.py

@@ -36,3 +36,33 @@ def check_exit(s):
 
 def check_end(s):
     return "end" in s
+
+
+def check_stopping_conditions(input: str) -> str:
+    """
+    Checks a string against all stopping conditions and returns an appropriate message.
+
+    Args:
+        s (str): The input string to check
+
+    Returns:
+        str: A message indicating which stopping condition was met, or None if no condition was met
+    """
+    conditions = [
+        (check_done, "Task is done"),
+        (check_finished, "Task is finished"),
+        (check_complete, "Task is complete"),
+        (check_success, "Task succeeded"),
+        (check_failure, "Task failed"),
+        (check_error, "Task encountered an error"),
+        (check_stopped, "Task was stopped"),
+        (check_cancelled, "Task was cancelled"),
+        (check_exit, "Task exited"),
+        (check_end, "Task ended"),
+    ]
+
+    for check_func, message in conditions:
+        if check_func(input):
+            return message
+
+    return None

swarms/structs/swarm_router.py

@@ -5,7 +5,9 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field
 
-from swarms.prompts.ag_prompt import aggregator_system_prompt
+from swarms.prompts.multi_agent_collab_prompt import (
+    MULTI_AGENT_COLLAB_PROMPT_TWO,
+)
 from swarms.structs.agent import Agent
 from swarms.structs.concurrent_workflow import ConcurrentWorkflow
 from swarms.structs.csv_to_agent import AgentLoader
@@ -13,7 +15,7 @@ from swarms.structs.groupchat import GroupChat
 from swarms.structs.hiearchical_swarm import HierarchicalSwarm
 from swarms.structs.majority_voting import MajorityVoting
 from swarms.structs.mixture_of_agents import MixtureOfAgents
-from swarms.structs.multi_agent_orchestrator import MultiAgentRouter
+from swarms.structs.multi_agent_router import MultiAgentRouter
 from swarms.structs.rearrange import AgentRearrange
 from swarms.structs.sequential_workflow import SequentialWorkflow
 from swarms.structs.spreadsheet_swarm import SpreadSheetSwarm
@@ -66,6 +68,38 @@ class SwarmLog(BaseModel):
     documents: List[Document] = []
 
 
+class SwarmRouterConfig(BaseModel):
+    """Configuration model for SwarmRouter."""
+
+    name: str = Field(
+        description="Name identifier for the SwarmRouter instance",
+    )
+    description: str = Field(
+        description="Description of the SwarmRouter's purpose",
+    )
+    # max_loops: int = Field(
+    #     description="Maximum number of execution loops"
+    # )
+    swarm_type: SwarmType = Field(
+        description="Type of swarm to use",
+    )
+    rearrange_flow: Optional[str] = Field(
+        description="Flow configuration string"
+    )
+    rules: Optional[str] = Field(
+        description="Rules to inject into every agent"
+    )
+    multi_agent_collab_prompt: bool = Field(
+        description="Whether to enable multi-agent collaboration prompts",
+    )
+    task: str = Field(
+        description="The task to be executed by the swarm",
+    )
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
 class SwarmRouter:
     """
     A class that dynamically routes tasks to different swarm types based on user selection or automatic matching.
@@ -157,6 +191,7 @@ class SwarmRouter:
         load_agents_from_csv: bool = False,
         csv_file_path: str = None,
         return_entire_history: bool = True,
+        multi_agent_collab_prompt: bool = True,
         *args,
         **kwargs,
     ):
@@ -179,14 +214,18 @@ class SwarmRouter:
         self.load_agents_from_csv = load_agents_from_csv
         self.csv_file_path = csv_file_path
         self.return_entire_history = return_entire_history
+        self.multi_agent_collab_prompt = multi_agent_collab_prompt
 
+        # Reliability check
+        self.reliability_check()
+
+        # Load agents from CSV
         if self.load_agents_from_csv:
             self.agents = AgentLoader(
                 csv_path=self.csv_file_path
             ).load_agents()
 
-        self.reliability_check()
-
+        # Log initialization
         self._log(
             "info",
             f"SwarmRouter initialized with swarm type: {swarm_type}",
@@ -345,7 +384,6 @@ class SwarmRouter:
                 name=self.name,
                 description=self.description,
                 agents=self.agents,
-                aggregator_system_prompt=aggregator_system_prompt.get_prompt(),
                 aggregator_agent=self.agents[-1],
                 layers=self.max_loops,
                 output_type=self.output_type,
@@ -421,6 +459,17 @@ class SwarmRouter:
                 f"Invalid swarm type: {self.swarm_type} try again with a valid swarm type such as 'SequentialWorkflow' or 'ConcurrentWorkflow' or 'auto' or 'AgentRearrange' or 'MixtureOfAgents' or 'SpreadSheetSwarm'"
             )
 
+    def update_system_prompt_for_agent_in_swarm(self):
+        # Use list comprehension for faster iteration
+        [
+            setattr(
+                agent,
+                "system_prompt",
+                agent.system_prompt + MULTI_AGENT_COLLAB_PROMPT_TWO,
+            )
+            for agent in self.agents
+        ]
+
     def _log(
         self,
         level: str,
@@ -464,6 +513,9 @@ class SwarmRouter:
         """
         self.swarm = self._create_swarm(task, *args, **kwargs)
 
+        if self.multi_agent_collab_prompt is True:
+            self.update_system_prompt_for_agent_in_swarm()
+
         try:
             logger.info(
                 f"Running task on {self.swarm_type} swarm with task: {task}"