swarms 7.8.3__py3-none-any.whl → 7.8.7__py3-none-any.whl

swarms/structs/ma_blocks.py

@@ -0,0 +1,159 @@
+from typing import Union
+from swarms.structs.agent import Agent
+from typing import List, Callable
+from swarms.structs.conversation import Conversation
+from swarms.structs.multi_agent_exec import run_agents_concurrently
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+    HistoryOutputType,
+)
+
+from swarms.prompts.agent_conversation_aggregator import (
+    AGGREGATOR_SYSTEM_PROMPT,
+)
+
+
+def aggregator_agent_task_prompt(
+    task: str, workers: List[Agent], conversation: Conversation
+):
+    return f"""
+    Please analyze and summarize the following multi-agent conversation, following your guidelines for comprehensive synthesis:
+
+    Conversation Context:
+    Original Task: {task}
+    Number of Participating Agents: {len(workers)}
+
+    Conversation Content:
+    {conversation.get_str()}
+
+    Please provide a 3,000 word comprehensive summary report of the conversation.
+    """
+
+
+def aggregate(
+    workers: List[Callable],
+    task: str = None,
+    type: HistoryOutputType = "all",
+    aggregator_model_name: str = "anthropic/claude-3-sonnet-20240229",
+):
+    """
+    Aggregate a list of tasks into a single task.
+    """
+
+    if task is None:
+        raise ValueError("Task is required in the aggregator block")
+
+    if workers is None:
+        raise ValueError(
+            "Workers is required in the aggregator block"
+        )
+
+    if not isinstance(workers, list):
+        raise ValueError("Workers must be a list of Callable")
+
+    if not all(isinstance(worker, Callable) for worker in workers):
+        raise ValueError("Workers must be a list of Callable")
+
+    conversation = Conversation()
+
+    aggregator_agent = Agent(
+        agent_name="Aggregator",
+        agent_description="Expert agent specializing in analyzing and synthesizing multi-agent conversations",
+        system_prompt=AGGREGATOR_SYSTEM_PROMPT,
+        max_loops=1,
+        model_name=aggregator_model_name,
+        output_type="final",
+        max_tokens=4000,
+    )
+
+    results = run_agents_concurrently(agents=workers, task=task)
+
+    # Zip the results with the agents
+    for result, agent in zip(results, workers):
+        conversation.add(content=result, role=agent.agent_name)
+
+    final_result = aggregator_agent.run(
+        task=aggregator_agent_task_prompt(task, workers, conversation)
+    )
+
+    conversation.add(
+        content=final_result, role=aggregator_agent.agent_name
+    )
+
+    return history_output_formatter(
+        conversation=conversation, type=type
+    )
+
+
+def run_agent(
+    agent: Agent,
+    task: str,
+    type: HistoryOutputType = "all",
+    *args,
+    **kwargs,
+):
+    """
+    Run an agent on a task.
+
+    Args:
+        agent (Agent): The agent to run
+        task (str): The task to run the agent on
+        type (HistoryOutputType, optional): The type of history output. Defaults to "all".
+        *args: Variable length argument list
+        **kwargs: Arbitrary keyword arguments
+
+    Returns:
+        Any: The result of running the agent
+
+    Raises:
+        ValueError: If agent or task is None
+        TypeError: If agent is not an instance of Agent
+    """
+    if agent is None:
+        raise ValueError("Agent cannot be None")
+
+    if task is None:
+        raise ValueError("Task cannot be None")
+
+    if not isinstance(agent, Agent):
+        raise TypeError("Agent must be an instance of Agent")
+
+    try:
+        return agent.run(task=task, *args, **kwargs)
+    except Exception as e:
+        raise RuntimeError(f"Error running agent: {str(e)}")
+
+
+def find_agent_by_name(
+    agents: List[Union[Agent, Callable]], agent_name: str
+) -> Agent:
+    """
+    Find an agent by its name in a list of agents.
+
+    Args:
+        agents (List[Union[Agent, Callable]]): List of agents to search through
+        agent_name (str): Name of the agent to find
+
+    Returns:
+        Agent: The found agent
+
+    Raises:
+        ValueError: If agents list is empty or agent not found
+        TypeError: If agent_name is not a string
+    """
+    if not agents:
+        raise ValueError("Agents list cannot be empty")
+
+    if not isinstance(agent_name, str):
+        raise TypeError("Agent name must be a string")
+
+    if not agent_name.strip():
+        raise ValueError("Agent name cannot be empty or whitespace")
+
+    try:
+        for agent in agents:
+            if hasattr(agent, "name") and agent.name == agent_name:
+                return agent
+        raise ValueError(f"Agent with name '{agent_name}' not found")
+    except Exception as e:
+        raise RuntimeError(f"Error finding agent: {str(e)}")

swarms/structs/majority_voting.py

@@ -9,7 +9,7 @@ from typing import Any, Callable, List, Optional
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 from swarms.structs.multi_agent_exec import run_agents_concurrently
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.utils.formatter import formatter
 from swarms.utils.loguru_logger import initialize_logger
 

swarms/structs/mixture_of_agents.py

@@ -7,7 +7,7 @@ from swarms.structs.agent import Agent
 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.utils.output_types import OutputType
 from swarms.structs.conversation import Conversation
 from swarms.utils.history_output_formatter import (
     history_output_formatter,

swarms/structs/multi_agent_exec.py

@@ -1,3 +1,4 @@
+import concurrent.futures
 import asyncio
 import os
 import threading
@@ -5,7 +6,7 @@ from concurrent.futures import (
     ThreadPoolExecutor,
 )
 from dataclasses import dataclass
-from typing import Any, Callable, List, Union
+from typing import Any, Callable, List, Optional, Union
 
 import psutil
 
@@ -68,44 +69,42 @@ async def run_agents_concurrently_async(
 def run_agents_concurrently(
     agents: List[AgentType],
     task: str,
-    batch_size: int = None,
-    max_workers: int = None,
+    max_workers: Optional[int] = None,
 ) -> List[Any]:
     """
-    Optimized concurrent agent runner using both uvloop and ThreadPoolExecutor.
+    Optimized concurrent agent runner using ThreadPoolExecutor.
 
     Args:
         agents: List of Agent instances to run concurrently
         task: Task string to execute
-        batch_size: Number of agents to run in parallel in each batch (defaults to CPU count)
-        max_workers: Maximum number of threads in the executor (defaults to CPU count * 2)
+        max_workers: Maximum number of threads in the executor (defaults to 95% of CPU cores)
 
     Returns:
         List of outputs from each agent
     """
-    # Optimize defaults based on system resources
-    cpu_cores = os.cpu_count()
-    batch_size = batch_size or cpu_cores
-    max_workers = max_workers or cpu_cores * 2
+    if max_workers is None:
+        # 95% of the available CPU cores
+        num_cores = os.cpu_count()
+        max_workers = int(num_cores * 0.95) if num_cores else 1
 
     results = []
 
-    # Get or create event loop
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-    # Create a shared thread pool executor with optimal worker count
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # Process agents in batches
-        for i in range(0, len(agents), batch_size):
-            batch = agents[i : i + batch_size]
-            batch_results = loop.run_until_complete(
-                run_agents_concurrently_async(batch, task, executor)
-            )
-            results.extend(batch_results)
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=max_workers
+    ) as executor:
+        # Submit all tasks and get futures
+        futures = [
+            executor.submit(agent.run, task) for agent in agents
+        ]
+
+        # Wait for all futures to complete and get results
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                result = future.result()
+                results.append(result)
+            except Exception as e:
+                # Append the error if an agent fails
+                results.append(e)
 
     return results
 

swarms/structs/multi_agent_router.py

@@ -16,12 +16,13 @@ from pydantic import BaseModel, Field
 from swarms.utils.function_caller_model import OpenAIFunctionCaller
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_types import OutputType
+from swarms.utils.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
+from typing import Callable, Union
 
 
 class AgentResponse(BaseModel):
@@ -59,7 +60,7 @@ class MultiAgentRouter:
         self,
         name: str = "swarm-router",
         description: str = "Routes tasks to specialized agents based on their capabilities",
-        agents: List[Agent] = [],
+        agents: List[Union[Agent, Callable]] = [],
         model: str = "gpt-4o-mini",
         temperature: float = 0.1,
         shared_memory_system: callable = None,

swarms/structs/rearrange.py

@@ -2,7 +2,7 @@ import asyncio
 import json
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Union
 
 
 from swarms.structs.agent import Agent
@@ -15,7 +15,7 @@ from swarms.utils.history_output_formatter import (
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.telemetry.main import log_agent_data
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.structs.multi_agent_exec import get_agents_info
 
 logger = initialize_logger(log_folder="rearrange")
@@ -68,7 +68,7 @@ class AgentRearrange(BaseSwarm):
         id: str = swarm_id(),
         name: str = "AgentRearrange",
         description: str = "A swarm of agents for rearranging tasks.",
-        agents: List[Agent] = None,
+        agents: List[Union[Agent, Callable]] = None,
         flow: str = None,
         max_loops: int = 1,
         verbose: bool = True,

swarms/structs/sequential_workflow.py

@@ -1,8 +1,8 @@
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import List, Optional
+from typing import Callable, List, Optional, Union
 
 from swarms.structs.agent import Agent
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.structs.rearrange import AgentRearrange
 from swarms.utils.loguru_logger import initialize_logger
 
@@ -31,7 +31,7 @@ class SequentialWorkflow:
         self,
         name: str = "SequentialWorkflow",
         description: str = "Sequential Workflow, where agents are executed in a sequence.",
-        agents: List[Agent] = [],
+        agents: List[Union[Agent, Callable]] = [],
         max_loops: int = 1,
         output_type: OutputType = "dict",
         shared_memory_system: callable = None,