Merge remote-tracking branch 'origin/master' into HEAD

# Conflicts:
#	swarms/structs/agent.py
#	swarms/utils/get_reasoning_efforts.py
#	tests/structs/test_agent.py

Author: ayaangazali

CLAUDE.md

@@ -1086,8 +1086,6 @@ from swarms import Agent
 
 **Don't instantiate heavyweight structures inside tight loops** — create agents and workflows once, reuse them across calls.
 
-**Don't pass `tools=[]` (empty list)** — pass `tools=None` instead. An empty list can confuse schema generation.
-
 **Don't use `streaming_on=True` and `streaming_callback` together on the same agent** — `streaming_on` streams to stdout; `streaming_callback` streams to your function. Pick one.
 
 **Don't set `context_compression=False` on very long autonomous sessions** — without compression the agent will eventually hit the context limit and raise an error.

examples/multi_agent/hierarchical_swarm/example_hierarchical.py

@@ -1,13 +1,3 @@
-"""
-Hierarchical Multi-Agent Example
-
-This example demonstrates hierarchical execution using HierarchicalSwarm,
-where a director agent coordinates worker agents: creates plans, assigns tasks,
-and iterates on results.
-
-Use Case: Project execution where a director delegates to specialized teams.
-"""
-
 from swarms import Agent
 from swarms.structs import HierarchicalSwarm
 

examples/multi_agent/hierarchical_swarm/hierarchical_swarm_autosave_example.py

@@ -1,14 +1,3 @@
-#!/usr/bin/env python3
-"""
-HierarchicalSwarm Autosave Example
-
-This example demonstrates how to use the autosave feature to automatically
-save conversation history after swarm execution.
-
-Usage:
-    python hierarchical_swarm_autosave_example.py
-"""
-
 from swarms import Agent, HierarchicalSwarm
 
 

examples/multi_agent/hierarchical_swarm/hierarchical_swarm_batch_demo.py

@@ -1,11 +1,3 @@
-#!/usr/bin/env python3
-"""
-Hierarchical Swarm Batch Processing Demo
-
-This demo shows how to use streaming callbacks with batch processing
-to handle multiple tasks sequentially with real-time feedback.
-"""
-
 import time
 from typing import Callable
 from swarms.structs.hiearchical_swarm import HierarchicalSwarm

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "14.0.0"
+version = "14.0.2"
 description = "Swarms - TGSC"
 license = "Apache-2.0"
 authors = ["Kye Gomez <kye@swarms.world>"]
@@ -99,6 +99,9 @@ pytest = "*"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+# Without this, pytest-asyncio's strict default silently skips every bare
+# `async def test_`, reporting it as a failure that never ran.
+asyncio_mode = "auto"
 markers = [
     "remote: tests that hit a real remote MCP server over the network",
 ]

swarms/structs/agent.py

@@ -380,7 +380,7 @@ def __init__(
         reasoning_prompt_on: bool = True,
         dynamic_context_window: bool = True,
         show_tool_execution_output: bool = True,
-        reasoning_effort: ReasoningEffort = "medium",
+        reasoning_effort: Optional[ReasoningEffort] = None,
         thinking_tokens: int = 1024,
         think_tool: bool = False,
         dynamic_tools: bool = True,
@@ -411,7 +411,6 @@ def __init__(
         self.stopping_token = stopping_token
         self.interactive = interactive
         self.dashboard = dashboard
-        self.saved_state_path = saved_state_path
         self.dynamic_temperature_enabled = dynamic_temperature_enabled
         self.dynamic_loops = dynamic_loops
         self.user_name = user_name
@@ -422,8 +421,8 @@ def __init__(
         self.system_prompt = system_prompt or ""
         self.agent_name = agent_name
         self.agent_description = agent_description
-        # self.saved_state_path = f"{self.agent_name}_{generate_api_key(prefix='agent-')}_state.json"
-        self.saved_state_path = (
+        # Fallback: this once overwrote the caller's own path.
+        self.saved_state_path = saved_state_path or (
             f"{generate_api_key(prefix='agent-')}_state.json"
         )
         self.autosave = autosave
@@ -664,9 +663,9 @@ def __init__(
                 )
                 self.system_prompt += "\n\n" + handoff_prompt
 
-        # One condition so the notice cannot diverge from the loader.
+        # Not exists(): exists([]) is True, so tools=[] deferred.
         defers_tools = self.dynamic_tools and (
-            exists(self.tools)
+            bool(self.tools)
             or self.mcp_enabled
             or self.max_loops == "auto"
         )
@@ -675,7 +674,7 @@ def __init__(
         if defers_tools:
             self.system_prompt += DYNAMIC_TOOLS_NOTICE
             self.setup_dynamic_tools()
-        elif exists(self.tools):
+        elif self.tools:
             self.tool_handling()
 
         if self.llm is None:

swarms/structs/auto_agent_builder.py

@@ -5,6 +5,7 @@
     AUTO_AGENT_BUILDER_SYSTEM_PROMPT,
 )
 from swarms.structs.agent import Agent
+from swarms.structs.execution_utils import batched_run
 from swarms.telemetry.otel import capture_init, trace_run
 from swarms.utils.loguru_logger import initialize_logger
 
@@ -430,3 +431,14 @@ def __call__(
             returns for this builder's ``return_dict`` setting.
         """
         return self.run(task)
+
+    def batch_run(self, tasks: List[str]) -> Any:
+        """Generate the roster for each task in sequence.
+
+        Args:
+            tasks (List[str]): The tasks the generated team should be able to handle.
+
+        Returns:
+            List[Union[List[Agent], List[Dict[str, str]]]]: The rosters for each task.
+        """
+        return batched_run(self.run, tasks)

swarms/structs/concat.py

@@ -94,6 +94,10 @@ def __init__(
             max_loops: Stored configuration value for compatibility.
             output_type: Desired formatted output type.
             aggregator_model_name: Model used for the default aggregator.
+            max_workers: Cap on concurrent worker agents per layer.
+            aggegrator_args: Extra keyword arguments forwarded to the
+                default aggregator agent. Ignored when ``aggregator_agent``
+                is supplied.
 
         Raises:
             ValueError: If no agents, aggregator system prompt, or layers
@@ -110,6 +114,7 @@ def __init__(
         self.output_type = output_type
         self.aggregator_model_name = aggregator_model_name
         self.max_workers = max_workers
+        self.aggegrator_args = aggegrator_args or {}
 
         self.reliability_check()
 

swarms/structs/mixture_of_agents.py

@@ -5,12 +5,55 @@
 from loguru import logger
 
 
+def _prepare_workspace() -> None:
+    """
+    Resolve ``WORKSPACE_DIR`` and make sure that directory exists.
+
+    Defers to :func:`ensure_workspace_env` rather than defaulting the variable
+    here as well, so bootup and ``WorkspaceManager`` cannot drift apart — and
+    so ``get_workspace_dir``'s ``lru_cache`` is invalidated when a default has
+    to be invented.
+
+    A caller-supplied path that cannot be created falls back to the default
+    instead of raising: an unusable workspace should not stop ``import
+    swarms``, which is what an uncaught ``OSError`` here would do.
+    """
+    # Imported here, not at module scope: swarms.utils.workspace_manager pulls
+    # in swarms/utils/__init__, which calls initialize_logger at import. At
+    # module scope that would run before WORKSPACE_DIR is settled, so the
+    # logger would resolve its directory from the unprepared value.
+    from swarms.utils.workspace_manager import ensure_workspace_env
+    from swarms.utils.workspace_utils import get_workspace_dir
+
+    fallback = Path.cwd() / "agent_workspace"
+    workspace = ensure_workspace_env() or str(fallback)
+
+    try:
+        Path(workspace).mkdir(parents=True, exist_ok=True)
+        return
+    except OSError as e:
+        # Covers unwritable paths and a WORKSPACE_DIR that already exists as a
+        # file, which exist_ok does not suppress.
+        logger.warning(
+            f"WORKSPACE_DIR={workspace!r} could not be created ({e}); "
+            f"falling back to {fallback}"
+        )
+
+    os.environ["WORKSPACE_DIR"] = str(fallback)
+    get_workspace_dir.cache_clear()
+    try:
+        fallback.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        logger.warning(
+            f"Default workspace {fallback} is unavailable too: {e}"
+        )
+
+
 def bootup():
     """Super-fast initialization of swarms environment"""
     try:
         # Cache env vars
         verbose = os.getenv("SWARMS_VERBOSE_GLOBAL", "False").lower()
-        workspace_path = Path.cwd() / "agent_workspace"
 
         # Configure logging early
         if verbose == "false":
@@ -21,10 +64,9 @@ def bootup():
         # Silence wandb
         os.environ["WANDB_SILENT"] = "true"
 
-        # Setup workspace dir only if needed
-        if not workspace_path.exists():
-            workspace_path.mkdir(parents=True, exist_ok=True)
-        os.environ["WORKSPACE_DIR"] = str(workspace_path)
+        # Only default it. Assigning unconditionally discarded whatever the
+        # caller had exported, so WORKSPACE_DIR never survived `import swarms`.
+        _prepare_workspace()
 
         # Suppress deprecation warnings
         warnings.filterwarnings("ignore", category=DeprecationWarning)