swarms 7.7.2__py3-none-any.whl → 7.7.4__py3-none-any.whl

swarms/structs/queue_swarm.py

@@ -1,193 +0,0 @@
-import queue
-import threading
-from typing import List
-from swarms.structs.agent import Agent
-from pydantic import BaseModel
-import os
-from swarms.utils.loguru_logger import logger
-from swarms.structs.base_swarm import BaseSwarm
-import time
-
-
-class AgentOutput(BaseModel):
-    agent_name: str
-    task: str
-    result: str
-    timestamp: str
-
-
-class SwarmRunMetadata(BaseModel):
-    run_id: str
-    name: str
-    description: str
-    agents: List[str]
-    start_time: str
-    end_time: str
-    tasks_completed: int
-    outputs: List[AgentOutput]
-
-
-class TaskQueueSwarm(BaseSwarm):
-    """
-    A swarm that processes tasks from a queue using multiple agents on different threads.
-
-    Args:
-        agents (List[Agent]): A list of agents of class Agent.
-        name (str, optional): The name of the swarm. Defaults to "Task-Queue-Swarm".
-        description (str, optional): The description of the swarm. Defaults to "A swarm that processes tasks from a queue using multiple agents on different threads.".
-        autosave_on (bool, optional): Whether to automatically save the swarm metadata. Defaults to True.
-        save_file_path (str, optional): The file path to save the swarm metadata. Defaults to "swarm_run_metadata.json".
-        workspace_dir (str, optional): The directory path of the workspace. Defaults to os.getenv("WORKSPACE_DIR").
-        return_metadata_on (bool, optional): Whether to return the swarm metadata after running. Defaults to False.
-        max_loops (int, optional): The maximum number of loops to run the swarm. Defaults to 1.
-
-    Attributes:
-        agents (List[Agent]): A list of agents of class Agent.
-        task_queue (queue.Queue): A queue to store the tasks.
-        lock (threading.Lock): A lock for thread synchronization.
-        autosave_on (bool): Whether to automatically save the swarm metadata.
-        save_file_path (str): The file path to save the swarm metadata.
-        workspace_dir (str): The directory path of the workspace.
-        return_metadata_on (bool): Whether to return the swarm metadata after running.
-        max_loops (int): The maximum number of loops to run the swarm.
-        metadata (SwarmRunMetadata): The metadata of the swarm run.
-    """
-
-    def __init__(
-        self,
-        agents: List[Agent],
-        name: str = "Task-Queue-Swarm",
-        description: str = "A swarm that processes tasks from a queue using multiple agents on different threads.",
-        autosave_on: bool = True,
-        save_file_path: str = "swarm_run_metadata.json",
-        workspace_dir: str = os.getenv("WORKSPACE_DIR"),
-        return_metadata_on: bool = False,
-        max_loops: int = 1,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(
-            name=name,
-            description=description,
-            agents=agents,
-            *args,
-            **kwargs,
-        )
-        self.agents = agents
-        self.task_queue = queue.Queue()
-        self.lock = threading.Lock()
-        self.autosave_on = autosave_on
-        self.save_file_path = save_file_path
-        self.workspace_dir = workspace_dir or os.getenv(
-            "WORKSPACE_DIR", "agent_workspace"
-        )
-        self.return_metadata_on = return_metadata_on
-        self.max_loops = max_loops
-
-        current_time = time.strftime("%Y%m%d%H%M%S")
-        self.metadata = SwarmRunMetadata(
-            run_id=f"swarm_run_{current_time}",
-            name=name,
-            description=description,
-            agents=[agent.agent_name for agent in agents],
-            start_time=current_time,
-            end_time="",
-            tasks_completed=0,
-            outputs=[],
-        )
-
-    def reliability_checks(self):
-        logger.info("Initializing reliability checks.")
-
-        if not self.agents:
-            raise ValueError(
-                "You must provide a non-empty list of Agent instances."
-            )
-
-        if self.max_loops <= 0:
-            raise ValueError("max_loops must be greater than zero.")
-
-        logger.info(
-            "Reliability checks successful. Swarm is ready for usage."
-        )
-
-    def add_task(self, task: str):
-        """Adds a task to the queue."""
-        self.task_queue.put(task)
-
-    def _process_task(self, agent: Agent):
-        """Processes tasks from the queue using the provided agent."""
-        while True:
-            try:
-                task = self.task_queue.get_nowait()
-            except queue.Empty:
-                break
-            try:
-                logger.info(
-                    f"Agent {agent.agent_name} is running task: {task}"
-                )
-                result = agent.run(task)
-                with self.lock:
-                    self.metadata.tasks_completed += 1
-                    self.metadata.outputs.append(
-                        AgentOutput(
-                            agent_name=agent.agent_name,
-                            task=task,
-                            result=result,
-                            timestamp=time.strftime(
-                                "%Y-%m-%d %H:%M:%S"
-                            ),
-                        )
-                    )
-                logger.info(
-                    f"Agent {agent.agent_name} completed task: {task}"
-                )
-                logger.debug(f"Result: {result}")
-            except Exception as e:
-                logger.error(
-                    f"Agent {agent.agent_name} failed to complete task: {task}"
-                )
-                logger.exception(e)
-            finally:
-                self.task_queue.task_done()
-
-    def run(self):
-        """Runs the swarm by having agents pick up tasks from the queue."""
-        logger.info(f"Starting swarm run: {self.metadata.run_id}")
-
-        threads = [
-            threading.Thread(
-                target=self._process_task, args=(agent,), daemon=True
-            )
-            for agent in self.agents
-        ]
-
-        for thread in threads:
-            thread.start()
-
-        self.task_queue.join()
-
-        for thread in threads:
-            thread.join()
-
-        self.metadata.end_time = time.strftime("%Y%m%d%H%M%S")
-
-        if self.autosave_on:
-            self.save_json_to_file()
-
-        # if self.return_metadata_on:
-        #     return self.metadata.model_dump_json(indent=4)
-        return self.export_metadata()
-
-    def save_json_to_file(self):
-        json_string = self.export_metadata()
-        file_path = os.path.join(
-            self.workspace_dir, self.save_file_path
-        )
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        with open(file_path, "w") as f:
-            f.write(json_string)
-        logger.info(f"Metadata saved to {file_path}")
-
-    def export_metadata(self):
-        return self.metadata.model_dump_json(indent=4)

swarms/structs/swarm_builder.py

@@ -1,395 +0,0 @@
-import os
-from typing import List, Optional
-
-from loguru import logger
-from pydantic import BaseModel, Field
-from pydantic.v1 import validator
-from tenacity import (
-    retry,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-from swarms.structs.agent import Agent
-from swarms.structs.swarm_router import SwarmRouter, SwarmType
-from swarms.utils.function_caller_model import OpenAIFunctionCaller
-
-
-BOSS_SYSTEM_PROMPT = """
-Manage a swarm of worker agents to efficiently serve the user by deciding whether to create new agents or delegate tasks. Ensure operations are efficient and effective.
-
-### Instructions:
-
-1. **Task Assignment**:
-   - Analyze available worker agents when a task is presented.
-   - Delegate tasks to existing agents with clear, direct, and actionable instructions if an appropriate agent is available.
-   - If no suitable agent exists, create a new agent with a fitting system prompt to handle the task.
-
-2. **Agent Creation**:
-   - Name agents according to the task they are intended to perform (e.g., "Twitter Marketing Agent").
-   - Provide each new agent with a concise and clear system prompt that includes its role, objectives, and any tools it can utilize.
-
-3. **Efficiency**:
-   - Minimize redundancy and maximize task completion speed.
-   - Avoid unnecessary agent creation if an existing agent can fulfill the task.
-
-4. **Communication**:
-   - Be explicit in task delegation instructions to avoid ambiguity and ensure effective task execution.
-   - Require agents to report back on task completion or encountered issues.
-
-5. **Reasoning and Decisions**:
-   - Offer brief reasoning when selecting or creating agents to maintain transparency.
-   - Avoid using an agent if unnecessary, with a clear explanation if no agents are suitable for a task.
-
-# Output Format
-
-Present your plan in clear, bullet-point format or short concise paragraphs, outlining task assignment, agent creation, efficiency strategies, and communication protocols.
-
-# Notes
-
-- Preserve transparency by always providing reasoning for task-agent assignments and creation.
-- Ensure instructions to agents are unambiguous to minimize error.
-
-"""
-
-
-class AgentConfig(BaseModel):
-    """Configuration for an individual agent in a swarm"""
-
-    name: str = Field(
-        description="The name of the agent",
-    )
-    description: str = Field(
-        description="A description of the agent's purpose and capabilities",
-    )
-    system_prompt: str = Field(
-        description="The system prompt that defines the agent's behavior",
-    )
-
-
-class SwarmConfig(BaseModel):
-    """Configuration for a swarm of cooperative agents"""
-
-    name: str = Field(
-        description="The name of the swarm",
-        example="Research-Writing-Swarm",
-    )
-    description: str = Field(
-        description="The description of the swarm's purpose and capabilities",
-        example="A swarm of agents that work together to research topics and write articles",
-    )
-    agents: List[AgentConfig] = Field(
-        description="The list of agents that make up the swarm",
-    )
-    max_loops: int = Field(
-        description="The maximum number of loops for the swarm to iterate on",
-    )
-
-    @validator("agents")
-    def validate_agents(cls, v):
-        if not v:
-            raise ValueError("Swarm must have at least one agent")
-        return v
-
-
-class AutoSwarmBuilderOutput(BaseModel):
-    """A class that automatically builds and manages swarms of AI agents with enhanced error handling."""
-
-    name: Optional[str] = Field(
-        description="The name of the swarm",
-        example="DefaultSwarm",
-        default=None,
-    )
-    description: Optional[str] = Field(
-        description="The description of the swarm's purpose and capabilities",
-        example="Generic AI Agent Swarm",
-        default=None,
-    )
-    verbose: Optional[bool] = Field(
-        description="Whether to display verbose output",
-        default=None,
-    )
-    model_name: Optional[str] = Field(
-        description="The name of the OpenAI model to use",
-        default=None,
-    )
-    boss_output_schema: Optional[list] = Field(
-        description="The schema for the output of the BOSS system prompt",
-        default=None,
-    )
-    director_agents_created: Optional[SwarmConfig] = Field(
-        description="The agents created by the director",
-        default=None,
-    )
-    swarm_router_outputs: Optional[list] = Field(
-        description="The outputs from the swarm router",
-        default=None,
-    )
-    max_loops: Optional[int] = Field(
-        description="The maximum number of loops for the swarm to iterate on",
-        default=None,
-    )
-    swarm_type: Optional[SwarmType] = Field(
-        description="The type of swarm to build",
-        default=None,
-    )
-
-
-class AutoSwarmBuilder:
-    """A class that automatically builds and manages swarms of AI agents with enhanced error handling."""
-
-    def __init__(
-        self,
-        name: Optional[str] = "autonomous-swarm-builder",
-        description: Optional[
-            str
-        ] = "Given a task, this swarm will automatically create specialized agents and route it to the appropriate agents.",
-        verbose: bool = True,
-        model_name: str = "gpt-4o",
-        boss_output_schema: list = None,
-        swarm_router_outputs: AutoSwarmBuilderOutput = None,
-        max_loops: int = 1,
-        swarm_type: str = "SequentialWorkflow",
-        auto_generate_prompts_for_agents: bool = False,
-        shared_memory_system: callable = None,
-    ):
-        self.name = name or "DefaultSwarm"
-        self.description = description or "Generic AI Agent Swarm"
-        self.verbose = verbose
-        self.agents_pool = []
-        self.api_key = os.getenv("OPENAI_API_KEY")
-        self.model_name = model_name
-        self.boss_output_schema = boss_output_schema
-        self.max_loops = max_loops
-        self.swarm_type = swarm_type
-        self.auto_generate_prompts_for_agents = (
-            auto_generate_prompts_for_agents
-        )
-        self.shared_memory_system = shared_memory_system
-        self.auto_swarm_builder_output = AutoSwarmBuilderOutput(
-            name=name,
-            description=description,
-            verbose=verbose,
-            model_name=model_name,
-            boss_output_schema=boss_output_schema or [],
-            swarm_router_outputs=swarm_router_outputs or [],
-            max_loops=max_loops,
-            swarm_type=swarm_type,
-        )
-
-        logger.info(
-            "Initialized AutoSwarmBuilder",
-            extra={
-                "swarm_name": self.name,
-                "description": self.description,
-                "model": self.model_name,
-            },
-        )
-
-    def run(
-        self,
-        task: str,
-        image_url: Optional[str] = None,
-        *args,
-        **kwargs,
-    ):
-        """Run the swarm on a given task with error handling and retries."""
-        if not task or not task.strip():
-            raise ValueError("Task cannot be empty")
-
-        logger.info("Starting swarm execution", extra={"task": task})
-
-        try:
-            # Create agents for the task
-            agents = self._create_agents(task)
-            if not agents:
-                raise ValueError(
-                    "No agents were created for the task"
-                )
-
-            # Execute the task through the swarm router
-            logger.info(
-                "Routing task through swarm",
-                extra={"num_agents": len(agents)},
-            )
-            output = self.swarm_router(
-                agents=agents,
-                task=task,
-                image_url=image_url,
-                *args,
-                **kwargs,
-            )
-            self.auto_swarm_builder_output.swarm_router_outputs.append(
-                output
-            )
-            print(output)
-
-            logger.info("Swarm execution completed successfully")
-            # return output
-            return self.auto_swarm_builder_output.model_dump_json(
-                indent=4
-            )
-
-        except Exception as e:
-            logger.error(
-                f"Error during swarm execution: {str(e)}",
-            )
-            raise e
-
-    def _create_agents(
-        self,
-        task: str,
-    ) -> List[Agent]:
-        """Create the necessary agents for a task with enhanced error handling."""
-        logger.info("Creating agents for task", extra={"task": task})
-
-        try:
-            model = OpenAIFunctionCaller(
-                system_prompt=BOSS_SYSTEM_PROMPT,
-                api_key=self.api_key,
-                temperature=0.1,
-                base_model=SwarmConfig,
-            )
-
-            agents_config = model.run(task)
-            logger.info(
-                f"Director has successfully created agents: {agents_config}"
-            )
-            self.auto_swarm_builder_output.director_agents_created = (
-                agents_config
-            )
-
-            if isinstance(agents_config, dict):
-                agents_config = SwarmConfig(**agents_config)
-
-            # Update swarm configuration
-            self.name = agents_config.name
-            self.description = agents_config.description
-
-            # Create agents from configuration
-            agents = []
-            for agent_config in agents_config.agents:
-                if isinstance(agent_config, dict):
-                    agent_config = AgentConfig(**agent_config)
-
-                agent = self.build_agent(
-                    agent_name=agent_config.name,
-                    agent_description=agent_config.description,
-                    agent_system_prompt=agent_config.system_prompt,
-                )
-                agents.append(agent)
-
-                print(
-                    f"Agent created: {agent_config.name}: Description: {agent_config.description}"
-                )
-
-            # # Add available agents showcase to system prompts
-            # agents_available = showcase_available_agents(
-            #     name=self.name,
-            #     description=self.description,
-            #     agents=agents,
-            # )
-
-            # for agent in agents:
-            #     agent.system_prompt += "\n" + agents_available
-
-            logger.info(
-                "Successfully created agents",
-                extra={"num_agents": len(agents)},
-            )
-            return agents
-
-        except Exception as e:
-            logger.error(
-                f"Error creating agents: {str(e)}", exc_info=True
-            )
-            raise
-
-    def build_agent(
-        self,
-        agent_name: str,
-        agent_description: str,
-        agent_system_prompt: str,
-        *args,
-        **kwargs,
-    ) -> Agent:
-        """Build a single agent with enhanced error handling."""
-        logger.info(
-            "Building agent", extra={"agent_name": agent_name}
-        )
-
-        try:
-            agent = Agent(
-                agent_name=agent_name,
-                description=agent_description,
-                system_prompt=agent_system_prompt,
-                model_name="gpt-4o",
-                verbose=self.verbose,
-                dynamic_temperature_enabled=False,
-                return_step_meta=False,
-                output_type="str",
-                streaming_on=True,
-            )
-            return agent
-
-        except Exception as e:
-            logger.error(
-                f"Error building agent: {str(e)}", exc_info=True
-            )
-            raise
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-    )
-    def swarm_router(
-        self,
-        agents: List[Agent],
-        task: str,
-        img: Optional[str] = None,
-        *args,
-        **kwargs,
-    ) -> str:
-        """Route tasks between agents in the swarm with error handling and retries."""
-        logger.info(
-            "Initializing swarm router",
-            extra={"num_agents": len(agents)},
-        )
-
-        try:
-            swarm_router_instance = SwarmRouter(
-                name=self.name,
-                description=self.description,
-                agents=agents,
-                swarm_type=self.swarm_type,
-                auto_generate_prompts=self.auto_generate_prompts_for_agents,
-            )
-
-            # formatted_task = f"{self.name} {self.description} {task}"
-            result = swarm_router_instance.run(
-                task=task, *args, **kwargs
-            )
-
-            logger.info("Successfully completed swarm routing")
-            return result
-
-        except Exception as e:
-            logger.error(
-                f"Error in swarm router: {str(e)}", exc_info=True
-            )
-            raise
-
-
-# swarm = AutoSwarmBuilder(
-#     name="ChipDesign-Swarm",
-#     description="A swarm of specialized AI agents for chip design",
-#     swarm_type="ConcurrentWorkflow",
-# )
-
-# try:
-#     result = swarm.run(
-#         "Design a new AI accelerator chip optimized for transformer model inference..."
-#     )
-#     print(result)
-# except Exception as e:
-#     print(f"An error occurred: {e}")

swarms/structs/swarm_output_type.py

@@ -1,23 +0,0 @@
-import time
-from typing import List
-import uuid
-from pydantic import BaseModel, Field
-
-
-class AgentRespond(BaseModel):
-    id: str = Field(default=uuid.uuid4().hex)
-    timestamp: str = Field(default=time.time())
-    agent_position: int = Field(description="Agent in swarm position")
-    agent_name: str
-    agent_response: str = Field(description="Agent response")
-
-
-class SwarmOutput(BaseModel):
-    id: str = Field(default=uuid.uuid4().hex)
-    timestamp: str = Field(default=time.time())
-    name: str = Field(description="Swarm name")
-    description: str = Field(description="Swarm description")
-    swarm_type: str = Field(description="Swarm type")
-    agent_outputs: List[AgentRespond] = Field(
-        description="List of agent responses"
-    )