swarms 7.6.2__py3-none-any.whl → 7.6.5__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/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/hybrid_hiearchical_peer_swarm.py

@@ -2,6 +2,7 @@ import os
 from typing import List
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
+from swarms.structs.multi_agent_exec import get_swarms_info
 from swarms.structs.swarm_router import SwarmRouter
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
@@ -120,12 +121,27 @@ class HybridHierarchicalClusterSwarm:
         self.router_agent = Agent(
             agent_name="Router Agent",
             agent_description="A router agent that routes tasks to the appropriate swarms.",
-            system_prompt=f"{router_system_prompt}\n\n{self.get_swarms_info()}",
+            system_prompt=f"{router_system_prompt}\n\n{get_swarms_info()}",
             tools_list_dictionary=tools,
             model_name=router_agent_model_name,
             max_loops=1,
+            output_type="final",
         )
 
+    def convert_str_to_dict(self, response: str):
+        # Handle response whether it's a string or dictionary
+        if isinstance(response, str):
+            try:
+                import json
+
+                response = json.loads(response)
+            except json.JSONDecodeError:
+                raise ValueError(
+                    "Invalid JSON response from router agent"
+                )
+
+        return response
+
     def run(self, task: str, *args, **kwargs):
         """
         Runs the routing process for a given task.
@@ -146,23 +162,19 @@ class HybridHierarchicalClusterSwarm:
 
         response = self.router_agent.run(task=task)
 
-        # Handle response whether it's a string or dictionary
         if isinstance(response, str):
-            try:
-                import json
-
-                response = json.loads(response)
-            except json.JSONDecodeError:
-                raise ValueError(
-                    "Invalid JSON response from router agent"
-                )
+            response = self.convert_str_to_dict(response)
+        else:
+            pass
 
         swarm_name = response.get("swarm_name")
         task_description = response.get("task_description")
 
         if not swarm_name or not task_description:
             raise ValueError(
-                "Invalid response from router agent: missing swarm_name or task_description."
+                "Invalid response from router agent: both 'swarm_name' and 'task_description' must be present. "
+                f"Received: swarm_name={swarm_name}, task_description={task_description}. "
+                f"Please check the response format from the model: {self.router_agent.model_name}."
             )
 
         self.route_task(swarm_name, task_description)
@@ -242,32 +254,3 @@ class HybridHierarchicalClusterSwarm:
                     results.append(f"Error processing task: {str(e)}")
 
         return results
-
-    def get_swarms_info(self) -> str:
-        """
-        Fetches and formats information about all available swarms in the system.
-
-        Returns:
-            str: A formatted string containing names and descriptions of all swarms.
-        """
-        if not self.swarms:
-            return "No swarms currently available in the system."
-
-        swarm_info = [
-            "Available Swarms:",
-            "",
-        ]  # Empty string for line spacing
-
-        for idx, swarm in enumerate(self.swarms, 1):
-            swarm_info.extend(
-                [
-                    f"[Swarm {idx}]",
-                    f"Name: {swarm.name}",
-                    f"Description: {swarm.description}",
-                    f"Length of Agents: {len(swarm.agents)}",
-                    f"Swarm Type: {swarm.swarm_type}",
-                    "",  # Empty string for line spacing between swarms
-                ]
-            )
-
-        return "\n".join(swarm_info).strip()

swarms/structs/multi_agent_exec.py

@@ -5,7 +5,7 @@ from concurrent.futures import (
     ThreadPoolExecutor,
 )
 from dataclasses import dataclass
-from typing import Any, List
+from typing import Any, Callable, List, Union
 
 import psutil
 
@@ -415,141 +415,65 @@ def run_agents_with_tasks_concurrently(
     )
 
 
-# from joblib import Parallel, delayed
-
-
-# def run_agents_joblib(
-#     agents: List[Any],
-#     tasks: List[str] = [],
-#     img: List[str] = None,
-#     max_workers: int = None,
-#     max_loops: int = 1,
-#     prefer: str = "threads",
-# ) -> List[Any]:
-#     """
-#     Executes a list of agents with their corresponding tasks concurrently using joblib.
-
-#     Each agent is expected to have a .run() method that accepts at least:
-#         - task: A string indicating the task to execute.
-#         - img: (Optional) A string representing image input.
-
-#     Args:
-#         agents (List[Any]): A list of agent instances.
-#         tasks (List[str], optional): A list of task strings. If provided, each agent gets a task.
-#                                      If fewer tasks than agents, the first task is reused.
-#         img (List[str], optional): A list of image strings. If provided, each agent gets an image.
-#                                    If fewer images than agents, the first image is reused.
-#         max_workers (int, optional): The maximum number of processes to use.
-#                                      Defaults to all available CPU cores.
-#         max_loops (int, optional): Number of times to execute the whole batch.
-
-#     Returns:
-#         List[Any]: The list of results returned by each agent’s run() method.
-#     """
-#     max_workers = max_workers or os.cpu_count()
-#     results = []
-
-#     for _ in range(max_loops):
-#         results.extend(
-#             Parallel(n_jobs=max_workers, prefer=prefer)(
-#                 delayed(lambda a, t, i: a.run(task=t, img=i))(
-#                     agent,
-#                     (
-#                         tasks[idx]
-#                         if tasks and idx < len(tasks)
-#                         else (tasks[0] if tasks else "")
-#                     ),
-#                     (
-#                         img[idx]
-#                         if img and idx < len(img)
-#                         else (img[0] if img else None)
-#                     ),
-#                 )
-#                 for idx, agent in enumerate(agents)
-#             )
-#         )
-
-#     return results
-
-
-# # Example usage:
-# if __name__ == '__main__':
-#     # Dummy Agent class for demonstration.
-#     class Agent:
-#         def __init__(self, agent_name, max_loops, model_name):
-#             self.agent_name = agent_name
-#             self.max_loops = max_loops
-#             self.model_name = model_name
-
-#         def run(self, task: str, img: str = None) -> str:
-#             img_info = f" with image '{img}'" if img else ""
-#             return (f"{self.agent_name} using model '{self.model_name}' processed task: '{task}'{img_info}")
-
-#     # Create a few Agent instances.
-#     agents = [
-#         Agent(
-#             agent_name=f"Financial-Analysis-Agent_parallel_swarm{i}",
-#             max_loops=1,
-#             model_name="gpt-4o-mini",
-#         )
-#         for i in range(3)
-#     ]
-
-#     task = "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria"
-#     outputs = run_agents_process_pool(agents, tasks=[task])
-
-#     for i, output in enumerate(outputs):
-#         print(f"Output from agent {i+1}:\n{output}")
-
-# # Example usage:
-# if __name__ == '__main__':
-#     # A sample agent class with a run method.
-#     class SampleAgent:
-#         def __init__(self, name):
-#             self.name = name
-
-#         def run(self, task, device, device_id, no_clusterops):
-#             # Simulate some processing.
-#             return (f"Agent {self.name} processed task '{task}' on {device} "
-#                     f"(device_id={device_id}), no_clusterops={no_clusterops}")
-
-#     # Create a list of sample agents.
-#     agents = [SampleAgent(f"Agent_{i}") for i in range(5)]
-#     # Define tasks; if fewer tasks than agents, the first task will be reused.
-#     tasks = ["task1", "task2", "task3"]
-
-#     outputs = run_agents_with_tasks_concurrently(
-#         agents=agents,
-#         tasks=tasks,
-#         max_workers=4,
-#         device="cpu",
-#         device_id=1,
-#         all_cores=True,
-#         no_clusterops=False
-#     )
-
-#     for output in outputs:
-#         print(output)
-
-
-# # Example usage:
-# if __name__ == "__main__":
-#     # Initialize your agents (for example, 3 agents)
-#     agents = [
-#         Agent(
-#             agent_name=f"Financial-Analysis-Agent_parallel_swarm{i}",
-#             max_loops=1,
-#             model_name="gpt-4o-mini",
-#         )
-#         for i in range(3)
-#     ]
-
-#     # Generate a list of tasks.
-#     tasks = [
-#         "How can I establish a ROTH IRA to buy stocks and get a tax break?",
-#         "What are the criteria for establishing a ROTH IRA?",
-#         "What are the tax benefits of a ROTH IRA?",
-#         "How to buy stocks using a ROTH IRA?",
-#         "What are the limitations of a ROTH IRA?",
-#     ]
-#     outputs = run_agents_joblib(agents, tasks)
+def get_swarms_info(swarms: List[Callable]) -> str:
+    """
+    Fetches and formats information about all available swarms in the system.
+
+    Returns:
+        str: A formatted string containing names and descriptions of all swarms.
+    """
+    if not swarms:
+        return "No swarms currently available in the system."
+
+    swarm_info = [
+        "Available Swarms:",
+        "",
+    ]  # Empty string for line spacing
+
+    for idx, swarm in enumerate(swarms, 1):
+        swarm_info.extend(
+            [
+                f"[Swarm {idx}]",
+                f"Name: {swarm.name}",
+                f"Description: {swarm.description}",
+                f"Length of Agents: {len(swarm.agents)}",
+                f"Swarm Type: {swarm.swarm_type}",
+                "",  # Empty string for line spacing between swarms
+            ]
+        )
+
+    return "\n".join(swarm_info).strip()
+
+
+def get_agents_info(
+    agents: List[Union[Agent, Callable]], team_name: str = None
+) -> str:
+    """
+    Fetches and formats information about all available agents in the system.
+
+    Returns:
+        str: A formatted string containing names and descriptions of all swarms.
+    """
+    if not agents:
+        return "No agents currently available in the system."
+
+    agent_info = [
+        f"Available Agents for Team: {team_name}",
+        "",
+    ]  # Empty string for line spacing
+
+    for idx, agent in enumerate(agents, 1):
+        agent_info.extend(
+            [
+                "\n",
+                f"[Agent {idx}]",
+                f"Name: {agent.agent_name}",
+                f"Description: {agent.agent_description}",
+                f"Role: {agent.role}",
+                f"Model: {agent.model_name}",
+                f"Max Loops: {agent.max_loops}",
+                "\n",
+            ]
+        )
+
+    return "\n".join(agent_info).strip()