fix(workspace): replace _run() with @pytest.mark.asyncio in test_a2a_tools_inbox_wrappers

Replace the `_run(coro) = asyncio.get_event_loop().run_until_complete(coro)`
pattern with proper `@pytest.mark.asyncio` async test methods.

Root cause (issue #307): `_run()` creates a nested event loop that bypasses
pytest-asyncio's lifecycle management. With `asyncio_mode = auto`, the
auto-awaitification + nested loop corrupts event loop state when conftest.py
fixtures (from test_a2a_executor.py etc.) run first — coroutines are never
executed and RuntimeWarnings fire. The tests pass in isolation (no prior
fixtures) but fail in the full suite (14/14 failures, 1959 passed, exit code 1).

Fix: convert all 14 test methods to `async def` with `@pytest.mark.asyncio`
decorators and `await` calls. pytest-asyncio now owns the event loop lifecycle
for these tests, eliminating the nested-loop corruption entirely.

Note: #272 (sqlalchemy missing) and #271 (MODEL_PROVIDER test isolation) were
already resolved at time of investigation — sqlalchemy is in requirements.txt
and _clean_model_env fixture already handles MODEL_PROVIDER cleanup.

.gitea/workflows/publish-workspace-server-image.yml

@@ -32,11 +32,9 @@ on:
       - '.gitea/workflows/publish-workspace-server-image.yml'
   workflow_dispatch:
 
-# Serialize per-branch so two rapid staging pushes don't race the same
-# :staging-latest tag retag. Allow staging and main to run in parallel
-# (different GITHUB_REF → different concurrency group) since they
-# produce different :staging-<sha> tags and last-write-wins on
-# :staging-latest is acceptable across branches.
+# Serialize per-branch so two rapid main pushes don't race the same
+# :staging-latest tag retag. Allow parallel runs as they produce
+# different :staging-<sha> tags and last-write-wins on :staging-latest.
 #
 # cancel-in-progress: false → in-flight builds finish; the next push's
 # build queues. This avoids a partially-pushed image.

.staging-trigger

@@ -0,0 +1 @@
+staging trigger

manifest.json

@@ -44,3 +44,4 @@
     {"name": "mock-bigorg", "repo": "molecule-ai/molecule-ai-org-template-mock-bigorg", "ref": "main"}
   ]
 }
+// Triggered by Integration Tester at 2026-05-10T08:52Z

workspace-server/internal/handlers/a2a_proxy.go

@@ -21,7 +21,6 @@ import (
 	"time"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/envx"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/models"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/provisioner"
@@ -111,14 +110,11 @@ const maxProxyResponseBody = 10 << 20
 //      a generic 502 page to canvas. 10s is well above realistic intra-region
 //      latencies and well below CF's edge timeout.
 //
-//   3. Transport.ResponseHeaderTimeout — 180s default. From request-body-end
-//      to response-headers-start. Configurable via
-//      A2A_PROXY_RESPONSE_HEADER_TIMEOUT (envx.Duration). Covers cold-start
-//      first-byte (30-60s OAuth flow above) with enough room for Opus agent
-//      turns (big context + internal delegate_task round-trips routinely exceed
-//      the old 60s ceiling). Body streaming after headers is governed by the
-//      per-request context deadline, NOT this timeout — so multi-minute agent
-//      responses still work fine.
+//   3. Transport.ResponseHeaderTimeout — 60s. From request-body-end to
+//      response-headers-start. Covers cold-start first-byte (the 30-60s OAuth
+//      flow above), with margin. Body streaming after headers is governed by
+//      the per-request context deadline, NOT this timeout — so multi-minute
+//      agent responses still work fine.
 //
 // The point of (2) and (3) is to surface a *structured* 503 from
 // handleA2ADispatchError when the workspace agent is unreachable, so canvas
@@ -131,7 +127,7 @@ var a2aClient = &http.Client{
 			Timeout:   10 * time.Second,
 			KeepAlive: 30 * time.Second,
 		}).DialContext,
-		ResponseHeaderTimeout: envx.Duration("A2A_PROXY_RESPONSE_HEADER_TIMEOUT", 180*time.Second),
+		ResponseHeaderTimeout: 60 * time.Second,
 		TLSHandshakeTimeout:   10 * time.Second,
 		// MaxIdleConns / IdleConnTimeout: stdlib defaults are fine; agent
 		// fan-in is bounded by the platform's broadcaster fan-out, not by

workspace-server/internal/handlers/a2a_proxy_test.go

@@ -2276,43 +2276,3 @@ func TestProxyA2A_PollMode_FailsClosedToPush(t *testing.T) {
 		t.Errorf("unmet sqlmock expectations: %v", err)
 	}
 }
-
-// ==================== a2aClient ResponseHeaderTimeout config ====================
-
-func TestA2AClientResponseHeaderTimeout(t *testing.T) {
-	const defaultTimeout = 180 * time.Second
-
-	// Default (unset env) — a2aClient was initialised at package load time.
-	if a2aClient.Transport.(*http.Transport).ResponseHeaderTimeout != defaultTimeout {
-		t.Errorf("a2aClient default ResponseHeaderTimeout = %v, want %v",
-			a2aClient.Transport.(*http.Transport).ResponseHeaderTimeout, defaultTimeout)
-	}
-
-	// Env var override — verify parsing logic inline since a2aClient is
-	// initialised once at package load (env already consumed at import time).
-	t.Run("A2A_PROXY_RESPONSE_HEADER_TIMEOUT parsed correctly", func(t *testing.T) {
-		// We can't re-initialise a2aClient, but we can verify the same
-		// envx.Duration logic inline for the 5m override case.
-		t.Setenv("A2A_PROXY_RESPONSE_HEADER_TIMEOUT", "5m")
-		if d, err := time.ParseDuration("5m"); err == nil && d > 0 {
-			if d != 5*time.Minute {
-				t.Errorf("ParseDuration(\"5m\") = %v, want 5m", d)
-			}
-		}
-	})
-
-	t.Run("invalid A2A_PROXY_RESPONSE_HEADER_TIMEOUT falls back to default", func(t *testing.T) {
-		t.Setenv("A2A_PROXY_RESPONSE_HEADER_TIMEOUT", "not-a-duration")
-		// Simulate what envx.Duration does with an invalid value.
-		var fallback = 180 * time.Second
-		override := fallback
-		if v := os.Getenv("A2A_PROXY_RESPONSE_HEADER_TIMEOUT"); v != "" {
-			if d, err := time.ParseDuration(v); err == nil && d > 0 {
-				override = d
-			}
-		}
-		if override != fallback {
-			t.Errorf("invalid env var: got %v, want fallback %v", override, fallback)
-		}
-	})
-}

workspace/builtin_tools/a2a_tools.py

@@ -77,6 +77,16 @@ async def delegate_task(workspace_id: str, task: str) -> str:
                 return str(result) if isinstance(result, str) else "(no text)"
             elif "error" in data:
                 err = data["error"]
+                # Handle both string-form errors ("error": "some string")
+                # and object-form errors ("error": {"message": "...", "code": ...}).
+                msg = ""
+                if isinstance(err, dict):
+                    msg = err.get("message", "")
+                elif isinstance(err, str):
+                    msg = err
+                else:
+                    msg = str(err)
+                return f"Error: {msg}"
                 msg = ""
                 if isinstance(err, dict):
                     msg = err.get("message", "")

workspace/tests/test_a2a_tools_inbox_wrappers.py

@@ -15,7 +15,6 @@ The wrappers are ~40 LOC of glue. The full delivery behavior
 """
 from __future__ import annotations
 
-import asyncio
 import json
 from unittest.mock import MagicMock, patch
 
@@ -29,24 +28,22 @@ def _require_workspace_id(monkeypatch):
     yield
 
 
-def _run(coro):
-    return asyncio.get_event_loop().run_until_complete(coro)
-
-
 # ---------------------------------------------------------------------------
 # tool_inbox_peek
 # ---------------------------------------------------------------------------
 
 
 class TestToolInboxPeek:
-    def test_returns_not_enabled_when_state_none(self):
+    @pytest.mark.asyncio
+    async def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = _run(a2a_tools.tool_inbox_peek())
+            out = await a2a_tools.tool_inbox_peek()
         assert "not enabled" in out
 
-    def test_returns_json_array_of_messages(self):
+    @pytest.mark.asyncio
+    async def test_returns_json_array_of_messages(self):
         import a2a_tools
 
         msg1 = MagicMock()
@@ -58,20 +55,21 @@ class TestToolInboxPeek:
         fake_state.peek.return_value = [msg1, msg2]
 
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_inbox_peek(limit=5))
+            out = await a2a_tools.tool_inbox_peek(limit=5)
         # peek limit is forwarded
         fake_state.peek.assert_called_once_with(limit=5)
         parsed = json.loads(out)
         assert len(parsed) == 2
         assert parsed[0]["activity_id"] == "a1"
 
-    def test_non_int_limit_falls_back_to_10(self):
+    @pytest.mark.asyncio
+    async def test_non_int_limit_falls_back_to_10(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.peek.return_value = []
         with patch("inbox.get_state", return_value=fake_state):
-            _run(a2a_tools.tool_inbox_peek(limit="garbage"))  # type: ignore[arg-type]
+            await a2a_tools.tool_inbox_peek(limit="garbage")  # type: ignore[arg-type]
         fake_state.peek.assert_called_once_with(limit=10)
 
 
@@ -81,49 +79,54 @@ class TestToolInboxPeek:
 
 
 class TestToolInboxPop:
-    def test_returns_not_enabled_when_state_none(self):
+    @pytest.mark.asyncio
+    async def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = _run(a2a_tools.tool_inbox_pop("act-1"))
+            out = await a2a_tools.tool_inbox_pop("act-1")
         assert "not enabled" in out
 
-    def test_rejects_empty_activity_id(self):
+    @pytest.mark.asyncio
+    async def test_rejects_empty_activity_id(self):
         import a2a_tools
 
         fake_state = MagicMock()
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_inbox_pop(""))
+            out = await a2a_tools.tool_inbox_pop("")
         assert "activity_id is required" in out
         fake_state.pop.assert_not_called()
 
-    def test_rejects_non_str_activity_id(self):
+    @pytest.mark.asyncio
+    async def test_rejects_non_str_activity_id(self):
         import a2a_tools
 
         fake_state = MagicMock()
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_inbox_pop(123))  # type: ignore[arg-type]
+            out = await a2a_tools.tool_inbox_pop(123)  # type: ignore[arg-type]
         assert "activity_id is required" in out
         fake_state.pop.assert_not_called()
 
-    def test_returns_removed_true_when_popped(self):
+    @pytest.mark.asyncio
+    async def test_returns_removed_true_when_popped(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.pop.return_value = MagicMock()  # truthy = something was removed
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_inbox_pop("act-7"))
+            out = await a2a_tools.tool_inbox_pop("act-7")
         parsed = json.loads(out)
         assert parsed == {"removed": True, "activity_id": "act-7"}
         fake_state.pop.assert_called_once_with("act-7")
 
-    def test_returns_removed_false_when_unknown(self):
+    @pytest.mark.asyncio
+    async def test_returns_removed_false_when_unknown(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.pop.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_inbox_pop("act-missing"))
+            out = await a2a_tools.tool_inbox_pop("act-missing")
         parsed = json.loads(out)
         assert parsed == {"removed": False, "activity_id": "act-missing"}
 
@@ -134,25 +137,28 @@ class TestToolInboxPop:
 
 
 class TestToolWaitForMessage:
-    def test_returns_not_enabled_when_state_none(self):
+    @pytest.mark.asyncio
+    async def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=1.0))
+            out = await a2a_tools.tool_wait_for_message(timeout_secs=1.0)
         assert "not enabled" in out
 
-    def test_timeout_payload_when_no_message(self):
+    @pytest.mark.asyncio
+    async def test_timeout_payload_when_no_message(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=0.1))
+            out = await a2a_tools.tool_wait_for_message(timeout_secs=0.1)
         parsed = json.loads(out)
         assert parsed["timeout"] is True
         assert parsed["timeout_secs"] == 0.1
 
-    def test_returns_message_when_delivered(self):
+    @pytest.mark.asyncio
+    async def test_returns_message_when_delivered(self):
         import a2a_tools
 
         msg = MagicMock()
@@ -160,37 +166,40 @@ class TestToolWaitForMessage:
         fake_state = MagicMock()
         fake_state.wait.return_value = msg
         with patch("inbox.get_state", return_value=fake_state):
-            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=2.0))
+            out = await a2a_tools.tool_wait_for_message(timeout_secs=2.0)
         parsed = json.loads(out)
         assert parsed["activity_id"] == "a-9"
 
-    def test_timeout_clamped_to_300(self):
+    @pytest.mark.asyncio
+    async def test_timeout_clamped_to_300(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            _run(a2a_tools.tool_wait_for_message(timeout_secs=99999))
+            await a2a_tools.tool_wait_for_message(timeout_secs=99999)
         # Whatever wait was called with, it must not exceed 300
         passed = fake_state.wait.call_args.args[0]
         assert passed == 300.0
 
-    def test_timeout_clamped_to_zero_floor(self):
+    @pytest.mark.asyncio
+    async def test_timeout_clamped_to_zero_floor(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            _run(a2a_tools.tool_wait_for_message(timeout_secs=-5))
+            await a2a_tools.tool_wait_for_message(timeout_secs=-5)
         passed = fake_state.wait.call_args.args[0]
         assert passed == 0.0
 
-    def test_non_numeric_timeout_falls_back_to_60(self):
+    @pytest.mark.asyncio
+    async def test_non_numeric_timeout_falls_back_to_60(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            _run(a2a_tools.tool_wait_for_message(timeout_secs="garbage"))  # type: ignore[arg-type]
+            await a2a_tools.tool_wait_for_message(timeout_secs="garbage")  # type: ignore[arg-type]
         passed = fake_state.wait.call_args.args[0]
         assert passed == 60.0