swarms 7.7.2__py3-none-any.whl → 7.7.4__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_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)}")