swarms 7.6.1__tar.gz → 7.6.2__tar.gz

{swarms-7.6.1 → swarms-7.6.2}/PKG-INFO

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

{swarms-7.6.1 → swarms-7.6.2}/pyproject.toml

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

{swarms-7.6.1 → swarms-7.6.2}/swarms/agents/__init__.py

@@ -1,9 +1,10 @@
+from swarms.agents.agent_judge import AgentJudge
 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.flexion_agent import ReflexionAgent
+from swarms.agents.gkp_agent import GKPAgent
 from swarms.agents.i_agent import IterativeReflectiveExpansion
 from swarms.agents.reasoning_agents import (
     ReasoningAgentRouter,
@@ -23,8 +24,8 @@ from swarms.structs.stopping_conditions import (
     check_success,
 )
 
-from swarms.agents.flexion_agent import ReflexionAgent
-from swarms.agents.gkp_agent import GKPAgent
+# Hybrid Hierarchical-Peer Model
+
 
 __all__ = [
     # "ToolAgent",
@@ -46,4 +47,5 @@ __all__ = [
     "agent_types",
     "ReflexionAgent",
     "GKPAgent",
+    "AgentJudge",
 ]

{swarms-7.6.1 → swarms-7.6.2}/swarms/agents/reasoning_agents.py

@@ -8,6 +8,7 @@ from swarms.agents.i_agent import (
 )
 from swarms.agents.reasoning_duo import ReasoningDuo
 from swarms.structs.output_types import OutputType
+from swarms.agents.agent_judge import AgentJudge
 
 agent_types = Literal[
     "reasoning-duo",
@@ -18,6 +19,7 @@ agent_types = Literal[
     "ire-agent",
     "ReflexionAgent",
     "GKPAgent",
+    "AgentJudge",
 ]
 
 
@@ -106,6 +108,14 @@ class ReasoningAgentRouter:
                 output_type=self.output_type,
             )
 
+        elif self.swarm_type == "AgentJudge":
+            return AgentJudge(
+                agent_name=self.agent_name,
+                model_name=self.model_name,
+                system_prompt=self.system_prompt,
+                max_loops=self.max_loops,
+            )
+
         elif self.swarm_type == "ReflexionAgent":
             return ReflexionAgent(
                 agent_name=self.agent_name,

{swarms-7.6.1 → swarms-7.6.2}/swarms/structs/__init__.py

@@ -8,6 +8,8 @@ from swarms.structs.base_swarm import BaseSwarm
 from swarms.structs.base_workflow import BaseWorkflow
 from swarms.structs.concurrent_workflow import ConcurrentWorkflow
 from swarms.structs.conversation import Conversation
+from swarms.structs.de_hallucination_swarm import DeHallucinationSwarm
+from swarms.structs.deep_research_swarm import DeepResearchSwarm
 from swarms.structs.graph_workflow import (
     Edge,
     GraphWorkflow,
@@ -18,6 +20,9 @@ from swarms.structs.groupchat import (
     GroupChat,
     expertise_based,
 )
+from swarms.structs.hybrid_hiearchical_peer_swarm import (
+    HybridHierarchicalClusterSwarm,
+)
 from swarms.structs.majority_voting import (
     MajorityVoting,
     majority_voting,
@@ -83,9 +88,6 @@ from swarms.structs.swarms_api import (
     SwarmValidationError,
 )
 
-from swarms.structs.de_hallucination_swarm import DeHallucinationSwarm
-from swarms.structs.deep_research_swarm import DeepResearchSwarm
-
 __all__ = [
     "Agent",
     "AsyncWorkflow",
@@ -161,4 +163,5 @@ __all__ = [
     "MALT",
     "DeHallucinationSwarm",
     "DeepResearchSwarm",
+    "HybridHierarchicalClusterSwarm",
 ]

{swarms-7.6.1 → swarms-7.6.2}/swarms/structs/agent.py

@@ -6,6 +6,7 @@ import random
 import threading
 import time
 import uuid
+
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from typing import (
@@ -49,12 +50,14 @@ from swarms.structs.safe_loading import (
 from swarms.telemetry.main import log_agent_data
 from swarms.tools.base_tool import BaseTool
 from swarms.tools.tool_parse_exec import parse_and_execute_json
+from swarms.utils.any_to_str import any_to_str
 from swarms.utils.data_to_text import data_to_text
 from swarms.utils.file_processing import create_file_in_folder
 from swarms.utils.formatter import formatter
 from swarms.utils.litellm_tokenizer import count_tokens
 from swarms.utils.pdf_to_text import pdf_to_text
 from swarms.structs.agent_roles import agent_roles
+from swarms.utils.str_to_dict import str_to_dict
 
 
 # Utils
@@ -803,7 +806,7 @@ class Agent:
     # Main function
     def _run(
         self,
-        task: Optional[str] = None,
+        task: Optional[Union[str, Any]] = None,
         img: Optional[str] = None,
         speech: Optional[str] = None,
         video: Optional[str] = None,
@@ -1113,6 +1116,7 @@ class Agent:
             # )
 
             log_agent_data(self.to_dict())
+
             if self.autosave is True:
                 self.save()
 
@@ -2494,7 +2498,7 @@ class Agent:
 
     def run(
         self,
-        task: Optional[str] = None,
+        task: Optional[Union[str, Any]] = None,
         img: Optional[str] = None,
         device: Optional[str] = "cpu",  # gpu
         device_id: Optional[int] = 0,
@@ -2531,6 +2535,9 @@ class Agent:
             Exception: If any other error occurs during execution.
         """
 
+        if not isinstance(task, str):
+            task = any_to_str(task)
+
         if scheduled_run_date:
             while datetime.now() < scheduled_run_date:
                 time.sleep(
@@ -2539,13 +2546,18 @@ class Agent:
 
         try:
             # If cluster ops disabled, run directly
-            return self._run(
+            output = self._run(
                 task=task,
                 img=img,
                 *args,
                 **kwargs,
             )
 
+            if self.tools_list_dictionary is not None:
+                return str_to_dict(output)
+            else:
+                return output
+
         except ValueError as e:
             self._handle_run_error(e)
 
@@ -2635,7 +2647,7 @@ class Agent:
         )
 
         return agent.run(
-            task=f"From {self.agent_name}: {output}",
+            task=f"From {self.agent_name}: Message: {output}",
             img=img,
             *args,
             **kwargs,
@@ -2651,10 +2663,27 @@ class Agent:
         """
         Talk to multiple agents.
         """
-        outputs = []
-        for agent in agents:
-            output = self.talk_to(agent, task, *args, **kwargs)
-            outputs.append(output)
+        # o# Use the existing executor from self.executor or create a new one if needed
+        with ThreadPoolExecutor() as executor:
+            # Create futures for each agent conversation
+            futures = [
+                executor.submit(
+                    self.talk_to, agent, task, *args, **kwargs
+                )
+                for agent in agents
+            ]
+
+            # Wait for all futures to complete and collect results
+            outputs = []
+            for future in futures:
+                try:
+                    result = future.result()
+                    outputs.append(result)
+                except Exception as e:
+                    logger.error(f"Error in agent communication: {e}")
+                    outputs.append(
+                        None
+                    )  # or handle error case as needed
 
         return outputs
 

{swarms-7.6.1 → swarms-7.6.2}/swarms/structs/concurrent_workflow.py

@@ -12,7 +12,7 @@ from swarms.utils.file_processing import create_file_in_folder
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.structs.conversation import Conversation
 from swarms.structs.swarm_id_generator import generate_swarm_id
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 
 logger = initialize_logger(log_folder="concurrent_workflow")
 

swarms-7.6.2/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-7.6.1 → swarms-7.6.2}/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