fix(social-algorithms): time out with a joined thread, not SIGALRM

`_execute_with_timeout` installed a `signal.SIGALRM` handler, and
`signal.signal` only works on the main thread. `run_async` hands `run` to a
worker thread via `asyncio.to_thread`, and `max_execution_time` defaults to
300.0, which selects the timeout path -- so the default configuration always
raised `ValueError: signal only works in main thread of the main interpreter`.

The same mechanism carried two more defects. `signal.alarm(int(...))`
truncates, and `alarm(0)` means cancel, so any budget under one second
disabled the timeout instead of tightening it. And `SIGALRM` does not exist
on Windows, where the default path raised `AttributeError`.

Run the call on a joined daemon thread instead. That works from any thread,
keeps sub-second budgets, and is portable. A timed-out worker is abandoned
rather than interrupted -- it is a daemon, so it cannot hold up interpreter
exit.

Closes kyegomez#2070

Author: ayaangazali

swarms/structs/social_algorithms.py

@@ -1,3 +1,4 @@
+import threading
 import time
 import uuid
 from typing import Any, Callable, Dict, List, Optional
@@ -287,24 +288,25 @@ def _execute_with_timeout(
         Raises:
             TimeoutError: If the function execution exceeds max_execution_time.
         """
-        import signal
+        outcome: Dict[str, Any] = {}
 
-        def timeout_handler(signum, frame):
+        def target() -> None:
+            try:
+                outcome["result"] = func(*args, **kwargs)
+            except BaseException as exc:
+                outcome["error"] = exc
+
+        worker = threading.Thread(target=target, daemon=True)
+        worker.start()
+        worker.join(self.max_execution_time)
+
+        if worker.is_alive():
             raise TimeoutError(
                 f"Algorithm execution exceeded {self.max_execution_time} seconds"
             )
-
-        # Set up timeout
-        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
-        signal.alarm(int(self.max_execution_time))
-
-        try:
-            result = func(*args, **kwargs)
-            return result
-        finally:
-            # Restore original handler
-            signal.alarm(0)
-            signal.signal(signal.SIGALRM, old_handler)
+        if "error" in outcome:
+            raise outcome["error"]
+        return outcome.get("result")
 
     def _format_output(self, result: Any) -> Any:
         """

tests/structs/test_social_algorithms.py

@@ -1,3 +1,5 @@
+import time
+
 import pytest
 
 from swarms.structs.agent import Agent
@@ -56,3 +58,29 @@ def test_remove_agent_raises_agent_not_found_for_empty_agent_list():
 
     with pytest.raises(AgentNotFoundError):
         social_algorithm.remove_agent("researcher")
+
+
+def test_run_async_works_on_the_default_timeout_configuration():
+    social_algorithm = SocialAlgorithms(
+        agents=[_agent("worker")],
+        social_algorithm=lambda agents, task, **kwargs: f"done:{task}",
+    )
+
+    result = social_algorithm.run_async("t")
+
+    assert result.final_outputs == {"result": "done:t"}
+
+
+def test_sub_second_max_execution_time_still_times_out():
+    def slow_algorithm(agents, task, **kwargs):
+        time.sleep(5)
+        return "never"
+
+    social_algorithm = SocialAlgorithms(
+        agents=[_agent("worker")],
+        social_algorithm=slow_algorithm,
+        max_execution_time=0.1,
+    )
+
+    with pytest.raises(TimeoutError):
+        social_algorithm.run("t")