[bugf][agent][run_batched drops every task when imgs is omitted]

`run_batched` zips the tasks against `imgs` using `imgs` as the loop variable:

    return [
        self.run(task=task, imgs=imgs, *args, **kwargs)
        for task, imgs in zip(tasks, imgs)
    ]

Three problems in four lines:

1. `imgs` defaults to None and is documented as optional, but `zip(tasks, None)`
   raises `TypeError: 'NoneType' object is not iterable` — so the documented
   basic call `agent.run_batched(["a", "b"])` never runs a single task.
2. The loop variable rebinds the parameter, so each `self.run` call receives
   one image string in `imgs`, a field declared `List[str]` and passed straight
   through to the provider call. The single-image parameter is `img`.
3. Unequal lengths zip to the shorter one, so passing fewer images than tasks
   silently discards tasks rather than reporting the mismatch.

Now: no images runs the tasks plainly, paired images go through `img`, and a
length mismatch raises rather than dropping work. The docstring said
"concurrently" while the body was always a list comprehension; it now says
what it does. Making it actually concurrent is a behaviour change and belongs
in its own PR.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ayaangazali

swarms/structs/agent.py

@@ -3349,20 +3349,36 @@ def run_batched(
         **kwargs,
     ):
         """
-        Run a batch of tasks concurrently.
+        Run a batch of tasks, one after another.
 
         Args:
             tasks (List[str]): List of tasks to run.
-            imgs (List[str], optional): List of images to run. Defaults to None.
+            imgs (List[str], optional): One image per task, paired by position.
+                Omit to run the tasks without images. Defaults to None.
             *args: Additional positional arguments to be passed to the execution method.
             **kwargs: Additional keyword arguments to be passed to the execution method.
 
         Returns:
             List[Any]: List of results from each task execution.
         """
+        # `for task, imgs in zip(...)` rebound the parameter to one image per
+        # iteration, so a List[str] field received a bare str -- and with the
+        # documented default of imgs=None the zip raised before any task ran.
+        if imgs is None:
+            return [
+                self.run(task=task, *args, **kwargs) for task in tasks
+            ]
+
+        if len(imgs) != len(tasks):
+            raise ValueError(
+                f"run_batched got {len(tasks)} tasks and {len(imgs)} images; "
+                "pass one image per task, or omit imgs entirely. Zipping them "
+                "would silently drop the extras."
+            )
+
         return [
-            self.run(task=task, imgs=imgs, *args, **kwargs)
-            for task, imgs in zip(tasks, imgs)
+            self.run(task=task, img=img, *args, **kwargs)
+            for task, img in zip(tasks, imgs)
         ]
 
     def showcase_config(self):

tests/structs/test_agent.py

@@ -3170,3 +3170,42 @@ def test_pool_is_shut_down_after_each_call(self):
                 break
             time.sleep(0.02)
         assert threading.active_count() <= before
+
+
+class TestRunBatchedImagePairing:
+    """`for task, imgs in zip(tasks, imgs)` rebound the parameter to a single
+    image, so the List[str] `imgs` field received a bare str — and with the
+    documented default of imgs=None the zip raised before any task ran.
+    """
+
+    @staticmethod
+    def _agent():
+        agent = Agent.__new__(Agent)
+        agent.agent_name = "batched"
+        return agent
+
+    def test_tasks_without_images_run(self):
+        """The documented default: imgs is optional."""
+        agent = self._agent()
+        with patch.object(Agent, "run", side_effect=lambda **kw: kw):
+            assert Agent.run_batched(agent, ["t1", "t2"]) == [
+                {"task": "t1"},
+                {"task": "t2"},
+            ]
+
+    def test_each_task_gets_its_own_image_as_a_single_image(self):
+        agent = self._agent()
+        with patch.object(Agent, "run", side_effect=lambda **kw: kw):
+            assert Agent.run_batched(
+                agent, ["t1", "t2"], imgs=["a.png", "b.png"]
+            ) == [
+                {"task": "t1", "img": "a.png"},
+                {"task": "t2", "img": "b.png"},
+            ]
+
+    def test_mismatched_lengths_raise_instead_of_dropping_tasks(self):
+        """zip() would have run one task and discarded the rest in silence."""
+        agent = self._agent()
+        with patch.object(Agent, "run", side_effect=lambda **kw: kw):
+            with pytest.raises(ValueError, match="one image per task"):
+                Agent.run_batched(agent, ["t1", "t2", "t3"], imgs=["a.png"])