swarms 7.6.1__py3-none-any.whl → 7.6.4__py3-none-any.whl

swarms/structs/conversation.py

@@ -119,7 +119,7 @@ class Conversation(BaseStructure):
             content (Union[str, dict, list]): The content of the message to be added.
         """
         now = datetime.datetime.now()
-        timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
+        now.strftime("%Y-%m-%d %H:%M:%S")
 
         # Base message with role
         message = {
@@ -129,8 +129,12 @@ class Conversation(BaseStructure):
         # Handle different content types
         if isinstance(content, dict) or isinstance(content, list):
             message["content"] = content
+        elif self.time_enabled:
+            message["content"] = (
+                f"Time: {now.strftime('%Y-%m-%d %H:%M:%S')} \n {content}"
+            )
         else:
-            message["content"] = f"Time: {timestamp} \n {content}"
+            message["content"] = content
 
         # Add the message to history immediately without waiting for token count
         self.conversation_history.append(message)
@@ -510,6 +514,16 @@ class Conversation(BaseStructure):
         """
         return f"{self.conversation_history[-1]['role']}: {self.conversation_history[-1]['content']}"
 
+    def get_final_message_content(self):
+        """Return the content of the final message from the conversation history.
+
+        Returns:
+            str: The content of the final message.
+        """
+        output = self.conversation_history[-1]["content"]
+        # print(output)
+        return output
+
 
 # # Example usage
 # # conversation = Conversation()

swarms/structs/de_hallucination_swarm.py

@@ -4,7 +4,8 @@ from loguru import logger
 from swarms.structs.agent import Agent
 
 # Prompt templates for different agent roles
-GENERATOR_PROMPT = """You are a knowledgeable assistant tasked with providing accurate information on a wide range of topics.
+GENERATOR_PROMPT = """
+You are a knowledgeable assistant tasked with providing accurate information on a wide range of topics.
 
 Your responsibilities:
 1. Provide accurate information based on your training data
@@ -22,7 +23,8 @@ When responding to queries:
 Remember, it's better to acknowledge ignorance than to provide incorrect information.
 """
 
-CRITIC_PROMPT = """You are a critical reviewer tasked with identifying potential inaccuracies, hallucinations, or unsupported claims in AI-generated text.
+CRITIC_PROMPT = """
+You are a critical reviewer tasked with identifying potential inaccuracies, hallucinations, or unsupported claims in AI-generated text.
 
 Your responsibilities:
 1. Carefully analyze the provided text for factual errors
@@ -47,7 +49,8 @@ Focus particularly on:
 Be thorough and specific in your critique. Provide actionable feedback for improvement.
 """
 
-REFINER_PROMPT = """You are a refinement specialist tasked with improving text based on critical feedback.
+REFINER_PROMPT = """
+You are a refinement specialist tasked with improving text based on critical feedback.
 
 Your responsibilities:
 1. Carefully review the original text and the critical feedback
@@ -67,7 +70,8 @@ Guidelines for refinement:
 The refined text should be helpful and informative while being scrupulously accurate.
 """
 
-VALIDATOR_PROMPT = """You are a validation expert tasked with ensuring the highest standards of accuracy in refined AI outputs.
+VALIDATOR_PROMPT = """
+You are a validation expert tasked with ensuring the highest standards of accuracy in refined AI outputs.
 
 Your responsibilities:
 1. Verify that all critical issues from previous feedback have been properly addressed

swarms/structs/dynamic_conversational_swarm.py

@@ -0,0 +1,226 @@
+import json
+import random
+from swarms.structs.agent import Agent
+from typing import List
+from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from swarms.utils.any_to_str import any_to_str
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "select_agent",
+            "description": "Analyzes the input task and selects the most appropriate agent configuration, outputting both the agent name and the formatted response.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "respond_or_no_respond": {
+                        "type": "boolean",
+                        "description": "Whether the agent should respond to the response or not.",
+                    },
+                    "reasoning": {
+                        "type": "string",
+                        "description": "The reasoning behind the selection of the agent and response.",
+                    },
+                    "agent_name": {
+                        "type": "string",
+                        "description": "The name of the selected agent that is most appropriate for handling the given task.",
+                    },
+                    "response": {
+                        "type": "string",
+                        "description": "A clear and structured description of the response for the next agent.",
+                    },
+                },
+                "required": [
+                    "reasoning",
+                    "agent_name",
+                    "response",
+                    "respond_or_no_respond",
+                ],
+            },
+        },
+    },
+]
+
+
+class DynamicConversationalSwarm:
+    def __init__(
+        self,
+        name: str = "Dynamic Conversational Swarm",
+        description: str = "A swarm that uses a dynamic conversational model to solve complex tasks.",
+        agents: List[Agent] = [],
+        max_loops: int = 1,
+        output_type: str = "list",
+        *args,
+        **kwargs,
+    ):
+        self.name = name
+        self.description = description
+        self.agents = agents
+        self.max_loops = max_loops
+        self.output_type = output_type
+
+        self.conversation = Conversation()
+
+        # Agents in the chat
+        agents_in_chat = self.get_agents_info()
+        self.conversation.add(
+            role="Conversation Log", content=agents_in_chat
+        )
+
+        self.inject_tools()
+
+    # Inject tools into the agents
+    def inject_tools(self):
+        for agent in self.agents:
+            agent.tools_list_dictionary = tools
+
+    def parse_json_into_dict(self, json_str: str) -> dict:
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON string")
+
+    def find_agent_by_name(self, agent_name: str) -> Agent:
+        for agent in self.agents:
+            if agent.name == agent_name:
+                return agent
+        raise ValueError(f"Agent with name {agent_name} not found")
+
+    def run_agent(self, agent_name: str, task: str) -> str:
+        agent = self.find_agent_by_name(agent_name)
+        return agent.run(task)
+
+    def fetch_random_agent_name(self) -> str:
+        return random.choice(self.agents).agent_name
+
+    def run(self, task: str) -> str:
+        """
+        Run the dynamic conversational swarm for a specified number of loops.
+        Each agent has access to the full conversation history.
+
+        Args:
+            task (str): The initial task/prompt to process
+
+        Returns:
+            str: The final response after all loops are complete
+        """
+        self.conversation.add(
+            role=f"{self.fetch_random_agent_name()}", content=task
+        )
+
+        # for loop in range(self.max_loops):
+        #     # Add loop marker to conversation for clarity
+        #     self.conversation.add(
+        #         role="System",
+        #         content=f"=== Starting Loop {loop + 1}/{self.max_loops} ==="
+        #     )
+
+        #     # First agent interaction
+        #     current_agent = self.randomly_select_agent()
+        #     response = self.run_agent(current_agent.name, self.conversation.get_str())
+        #     self.conversation.add(role=current_agent.name, content=any_to_str(response))
+
+        #     try:
+        #         # Parse response and get next agent
+        #         response_dict = self.parse_json_into_dict(response)
+
+        #         # Check if we should continue or end the loop
+        #         if not response_dict.get("respond_or_no_respond", True):
+        #             break
+
+        #         # Get the task description for the next agent
+        #         next_task = response_dict.get("task_description", self.conversation.get_str())
+
+        #         # Run the next agent with the specific task description
+        #         next_agent = self.find_agent_by_name(response_dict["agent_name"])
+        #         next_response = self.run_agent(next_agent.name, next_task)
+
+        #         # Add both the task description and response to the conversation
+        #         self.conversation.add(
+        #             role="System",
+        #             content=f"Response from {response_dict['agent_name']}: {next_task}"
+        #         )
+        #         self.conversation.add(role=next_agent.name, content=any_to_str(next_response))
+
+        #     except (ValueError, KeyError) as e:
+        #         self.conversation.add(
+        #             role="System",
+        #             content=f"Error in loop {loop + 1}: {str(e)}"
+        #         )
+        #         break
+
+        # Run first agent
+        current_agent = self.randomly_select_agent()
+        response = self.run_agent(
+            current_agent.agent_name, self.conversation.get_str()
+        )
+        self.conversation.add(
+            role=current_agent.agent_name,
+            content=any_to_str(response),
+        )
+
+        # Convert to json
+        response_dict = self.parse_json_into_dict(response)
+
+        # Fetch task
+        respone_two = response_dict["response"]
+        agent_name = response_dict["agent_name"]
+
+        print(f"Response from {agent_name}: {respone_two}")
+
+        # Run next agent
+        next_response = self.run_agent(
+            agent_name, self.conversation.get_str()
+        )
+        self.conversation.add(
+            role=agent_name, content=any_to_str(next_response)
+        )
+
+        # # Get the next agent
+        # response_three = self.parse_json_into_dict(next_response)
+        # agent_name_three = response_three["agent_name"]
+        # respone_four = response_three["response"]
+
+        # print(f"Response from {agent_name_three}: {respone_four}")
+        # # Run the next agent
+        # next_response = self.run_agent(agent_name_three, self.conversation.get_str())
+        # self.conversation.add(role=agent_name_three, content=any_to_str(next_response))
+
+        # Format and return the final conversation history
+        return history_output_formatter(
+            self.conversation, type=self.output_type
+        )
+
+    def randomly_select_agent(self) -> Agent:
+        return random.choice(self.agents)
+
+    def get_agents_info(self) -> str:
+        """
+        Fetches and formats information about all available agents in the system.
+
+        Returns:
+            str: A formatted string containing names and descriptions of all agents.
+        """
+        if not self.agents:
+            return "No agents currently available in the system."
+
+        agents_info = [
+            "Agents In the System:",
+            "",
+        ]  # Empty string for line spacing
+
+        for idx, agent in enumerate(self.agents, 1):
+            agents_info.extend(
+                [
+                    f"[Agent {idx}]",
+                    f"Name: {agent.name}",
+                    f"Description: {agent.description}",
+                    "",  # Empty string for line spacing between agents
+                ]
+            )
+
+        return "\n".join(agents_info).strip()

swarms/structs/groupchat.py

@@ -1,4 +1,5 @@
 import concurrent.futures
+import random
 from datetime import datetime
 from typing import Callable, List
 
@@ -7,6 +8,13 @@ from pydantic import BaseModel, Field
 
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
+from swarms.structs.multi_agent_exec import get_agents_info
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from swarms.prompts.multi_agent_collab_prompt import (
+    MULTI_AGENT_COLLAB_PROMPT_TWO,
+)
 
 
 class AgentResponse(BaseModel):
@@ -230,15 +238,23 @@ class GroupChat:
         speaker_fn: SpeakerFunction = round_robin,
         max_loops: int = 1,
         rules: str = "",
+        output_type: str = "string",
     ):
         self.name = name
         self.description = description
         self.agents = agents
         self.speaker_fn = speaker_fn
         self.max_loops = max_loops
-        self.conversation = Conversation(time_enabled=False)
+        self.output_type = output_type
         self.rules = rules
 
+        self.conversation = Conversation(
+            time_enabled=False, rules=rules
+        )
+
+        agent_context = f"\n Group Chat Name: {self.name}\nGroup Chat Description: {self.description}\n Agents in your Group Chat: {get_agents_info(self.agents)}"
+        self.conversation.add(role="System", content=agent_context)
+
         self.reliability_check()
 
     def reliability_check(self):
@@ -248,23 +264,24 @@ class GroupChat:
         Raises:
             ValueError: If any required components are missing or invalid
         """
+
         if len(self.agents) < 2:
             raise ValueError(
                 "At least two agents are required for a group chat"
             )
-        if self.speaker_fn is None:
-            raise ValueError("No speaker function provided")
+
         if self.max_loops <= 0:
             raise ValueError("Max loops must be greater than 0")
+
         for agent in self.agents:
-            if not isinstance(agent, Agent):
-                raise ValueError(
-                    f"Invalid agent type: {type(agent)}. Must be Agent instance"
-                )
+            agent.system_prompt += MULTI_AGENT_COLLAB_PROMPT_TWO
 
     def run(self, task: str, img: str = None, *args, **kwargs) -> str:
         """
-        Executes a conversation between agents about the given task.
+        Executes a dynamic conversation between agents about the given task.
+
+        Agents are selected randomly to speak, creating a more natural flow
+        with varying conversation lengths.
 
         Args:
             task (str): The task or topic for agents to discuss
@@ -279,106 +296,85 @@ class GroupChat:
             ValueError: If task is empty or invalid
             Exception: If any error occurs during conversation
         """
+
         if not task or not isinstance(task, str):
             raise ValueError("Task must be a non-empty string")
 
         # Initialize conversation with context
-        agent_context = f"Group Chat Name: {self.name}\nGroup Chat Description: {self.description}\nRules: {self.rules}\n Other agents: {', '.join([a.agent_name for a in self.agents])}"
-        self.conversation.add(role="system", content=agent_context)
         self.conversation.add(role="User", content=task)
 
-        print(
-            f"....... conversation history: \n {self.conversation.return_history_as_string()}"
-        )
-
         try:
             turn = 0
-            consecutive_silent_turns = 0
-            max_silent_turns = 2  # End conversation if no one speaks for this many turns
-
-            while turn < self.max_loops:
-                context = self.conversation.return_messages_as_list()
-
-                # Get agents who should speak this turn
-                speaking_agents = [
-                    agent
-                    for agent in self.agents
-                    if self.speaker_fn(context, agent)
-                ]
-
-                if not speaking_agents:
-                    consecutive_silent_turns += 1
-                    if consecutive_silent_turns >= max_silent_turns:
-                        logger.debug(
-                            "Multiple silent turns, ending conversation"
-                        )
-                        break
-                    continue
+            # Determine a random number of conversation turns
+            target_turns = random.randint(1, 4)
+            logger.debug(
+                f"Planning for approximately {target_turns} conversation turns"
+            )
 
-                consecutive_silent_turns = (
-                    0  # Reset counter when agents speak
-                )
+            # Keep track of which agent spoke last to create realistic exchanges
+            last_speaker = None
 
-                # Process each speaking agent
-                for agent in speaking_agents:
-                    try:
-                        # Build context-aware prompt
-                        prompt = (
-                            f"You're {agent.agent_name} participating in a group chat.\n"
-                            f"Chat Purpose: {self.description}\n"
-                            f"Current Discussion: {task}\n"
-                            f"Chat History:\n{self.conversation.return_history_as_string()}\n"
-                            f"As {agent.agent_name}, please provide your response:"
-                        )
+            while turn < target_turns:
 
-                        print(
-                            f"....... what the agent sees prompt: \n {prompt}"
-                        )
+                # Select an agent to speak (different from the last speaker if possible)
+                available_agents = self.agents.copy()
 
-                        message = agent.run(
-                            task=prompt,
-                            img=img,
-                            *args,
-                            **kwargs,
-                        )
+                if last_speaker and len(available_agents) > 1:
+                    available_agents.remove(last_speaker)
 
-                        if not message or message.isspace():
-                            logger.warning(
-                                f"Empty response from {agent.agent_name}, skipping"
-                            )
-                            continue
+                current_speaker = random.choice(available_agents)
+
+                try:
+                    # Build complete context with conversation history
+                    conversation_history = (
+                        self.conversation.return_history_as_string()
+                    )
+
+                    # Prepare a prompt that explicitly encourages responding to others
+                    if last_speaker:
+                        prompt = f"The previous message was from {last_speaker.agent_name}. As {current_speaker.agent_name}, please respond to what they and others have said about: {task}"
+                    else:
+                        prompt = f"As {current_speaker.agent_name}, please start the discussion about: {task}"
 
+                    # Get the agent's response with full context awareness
+                    message = current_speaker.run(
+                        task=f"{conversation_history} {prompt}",
+                    )
+
+                    # Only add meaningful responses
+                    if message and not message.isspace():
                         self.conversation.add(
-                            role=agent.agent_name, content=message
+                            role=current_speaker.agent_name,
+                            content=message,
                         )
 
                         logger.info(
-                            f"Turn {turn}, {agent.agent_name} responded"
+                            f"Turn {turn}, {current_speaker.agent_name} responded"
                         )
 
-                    except Exception as e:
-                        logger.error(
-                            f"Error from {agent.agent_name}: {e}"
-                        )
-                        # Continue with other agents instead of crashing
-                        continue
+                        # Update the last speaker
+                        last_speaker = current_speaker
+                        turn += 1
 
-                turn += 1
+                        # Occasionally end early to create natural variation
+                        if (
+                            turn > 3 and random.random() < 0.15
+                        ):  # 15% chance to end after at least 3 turns
+                            logger.debug(
+                                "Random early conversation end"
+                            )
+                            break
 
-                # Check if conversation has reached a natural conclusion
-                last_messages = (
-                    context[-3:] if len(context) >= 3 else context
-                )
-                if all(
-                    "conclusion" in msg.lower()
-                    for msg in last_messages
-                ):
-                    logger.debug(
-                        "Natural conversation conclusion detected"
+                except Exception as e:
+                    logger.error(
+                        f"Error from {current_speaker.agent_name}: {e}"
                     )
-                    break
+                    # Skip this agent and continue conversation
+                    continue
 
-            return self.conversation.return_history_as_string()
+            return history_output_formatter(
+                self.conversation, self.output_type
+            )
 
         except Exception as e:
             logger.error(f"Error in chat: {e}")

swarms/structs/hiearchical_swarm.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field
 from swarms.structs.agent import Agent
 from swarms.structs.base_swarm import BaseSwarm
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.formatter import formatter
 
 from swarms.utils.function_caller_model import OpenAIFunctionCaller