{label}
diff --git a/workspace/a2a_client.py b/workspace/a2a_client.py
index 514dc438..8893e2e7 100644
--- a/workspace/a2a_client.py
+++ b/workspace/a2a_client.py
@@ -87,10 +87,35 @@ async def send_a2a_message(target_url: str, message: str) -> str:
return f"{_A2A_ERROR_PREFIX}{text}"
return text
elif "error" in data:
- return f"{_A2A_ERROR_PREFIX}{data['error'].get('message', 'unknown')}"
- return str(data)
+ err = data["error"]
+ msg = (err.get("message") or "").strip()
+ code = err.get("code")
+ if msg and code is not None:
+ detail = f"{msg} (code={code})"
+ elif msg:
+ detail = msg
+ elif code is not None:
+ detail = f"JSON-RPC error with no message (code={code})"
+ else:
+ detail = "JSON-RPC error with no message"
+ return f"{_A2A_ERROR_PREFIX}{detail} [target={target_url}]"
+ return f"{_A2A_ERROR_PREFIX}unexpected response shape (no result, no error): {str(data)[:200]} [target={target_url}]"
except Exception as e:
- return f"{_A2A_ERROR_PREFIX}{e}"
+ # Some httpx exceptions stringify to empty (RemoteProtocolError,
+ # ConnectionReset variants) — the canvas would then render
+ # "[A2A_ERROR] " with no detail and the operator has no signal
+ # to act on. Always include the exception class name and the
+ # target URL so the activity log + Agent Comms panel have
+ # actionable information without a trip through container logs.
+ msg = str(e).strip()
+ type_name = type(e).__name__
+ if not msg:
+ detail = f"{type_name} (no message — likely connection reset or silent timeout)"
+ elif type_name in msg:
+ detail = msg
+ else:
+ detail = f"{type_name}: {msg}"
+ return f"{_A2A_ERROR_PREFIX}{detail} [target={target_url}]"
async def get_peers() -> list[dict]:
diff --git a/workspace/a2a_tools.py b/workspace/a2a_tools.py
index 691491d7..4834870b 100644
--- a/workspace/a2a_tools.py
+++ b/workspace/a2a_tools.py
@@ -112,7 +112,7 @@ def _auth_headers_for_heartbeat() -> dict[str, str]:
async def report_activity(
activity_type: str, target_id: str = "", summary: str = "", status: str = "ok",
- task_text: str = "", response_text: str = "",
+ task_text: str = "", response_text: str = "", error_detail: str = "",
):
"""Report activity to the platform for live progress tracking."""
try:
@@ -129,6 +129,13 @@ async def report_activity(
payload["request_body"] = {"task": task_text}
if response_text:
payload["response_body"] = {"result": response_text}
+ if error_detail:
+ # error_detail is a top-level activity row column on the
+ # platform (handlers/activity.go). Surfacing the cleaned
+ # exception string here lets the Activity tab render a
+ # red error chip + the cause without forcing the user
+ # to scroll into the raw response_body JSON.
+ payload["error_detail"] = error_detail
await client.post(
f"{PLATFORM_URL}/workspaces/{WORKSPACE_ID}/activity",
json=payload,
@@ -178,11 +185,16 @@ async def tool_delegate_task(workspace_id: str, task: str) -> str:
# Detect delegation failures — wrap them clearly so the calling agent
# can decide to retry, use another peer, or handle the task itself.
is_error = result.startswith(_A2A_ERROR_PREFIX)
+ # Strip the sentinel prefix so error_detail is the human-readable
+ # cause directly. The Activity tab's red error chip surfaces this
+ # without the user having to scroll into the raw response JSON.
+ error_detail = result[len(_A2A_ERROR_PREFIX):].strip() if is_error else ""
await report_activity(
"a2a_receive", workspace_id,
- f"{peer_name} responded ({len(result)} chars)" if not is_error else f"{peer_name} failed",
+ f"{peer_name} responded ({len(result)} chars)" if not is_error else f"{peer_name} failed: {error_detail[:120]}",
task_text=task, response_text=result,
status="error" if is_error else "ok",
+ error_detail=error_detail,
)
if is_error:
return (
diff --git a/workspace/tests/test_a2a_client.py b/workspace/tests/test_a2a_client.py
index fbae0ea0..a9fb522a 100644
--- a/workspace/tests/test_a2a_client.py
+++ b/workspace/tests/test_a2a_client.py
@@ -199,10 +199,16 @@ class TestSendA2AMessage:
result = await a2a_client.send_a2a_message("http://target/a2a", "task")
assert result.startswith(a2a_client._A2A_ERROR_PREFIX)
- assert "unknown" in result
+ # The error includes the JSON-RPC code so the operator can look it
+ # up; "no message" surfaces the missing-message condition explicitly
+ # instead of the previous opaque "unknown".
+ assert "code=-32600" in result
+ assert "no message" in result.lower()
+ # Target URL is included so chained delegations are traceable.
+ assert "target=http://target/a2a" in result
- async def test_neither_result_nor_error_returns_str_of_data(self):
- """Response with neither 'result' nor 'error' → str(data)."""
+ async def test_neither_result_nor_error_returns_a2a_error_with_payload(self):
+ """Response with neither 'result' nor 'error' → A2A_ERROR + payload context."""
import a2a_client
payload = {"jsonrpc": "2.0", "id": "abc123"}
@@ -212,7 +218,14 @@ class TestSendA2AMessage:
with patch("a2a_client.httpx.AsyncClient", return_value=mock_client):
result = await a2a_client.send_a2a_message("http://target/a2a", "task")
- assert result == str(payload)
+ # Pre-fix this returned bare str(payload) which the canvas
+ # rendered as a confusing "looks like a successful response"
+ # block. Now it's tagged so downstream UI / delegate_task
+ # routes it through the error path.
+ assert result.startswith(a2a_client._A2A_ERROR_PREFIX)
+ assert "unexpected response shape" in result
+ assert "abc123" in result # snippet of payload included for context
+ assert "target=http://target/a2a" in result
async def test_exception_returns_error_prefix_and_message(self):
"""Network exception → returns _A2A_ERROR_PREFIX + exception text."""
@@ -225,6 +238,39 @@ class TestSendA2AMessage:
assert result.startswith(a2a_client._A2A_ERROR_PREFIX)
assert "connection refused" in result
+ # Exception class name is prepended when the message doesn't
+ # already include it — gives the operator a typed handle to
+ # search for in container logs.
+ assert "ConnectionError" in result
+ assert "target=http://target/a2a" in result
+
+ async def test_empty_stringifying_exception_falls_back_to_class_name(self):
+ """The user's reported bug: httpx.RemoteProtocolError and similar
+ exceptions can stringify to "" — pre-fix the canvas rendered
+ "[A2A_ERROR] " with no detail. Verify the empty path now
+ produces an actionable message including the exception type
+ and the target URL."""
+ import a2a_client
+
+ # Subclass Exception with __str__ → "" to simulate the
+ # silent-exception variants without depending on a specific
+ # httpx version's behavior.
+ class _SilentRemoteProtocolError(Exception):
+ def __str__(self) -> str:
+ return ""
+
+ mock_client = _make_mock_client(post_exc=_SilentRemoteProtocolError())
+
+ with patch("a2a_client.httpx.AsyncClient", return_value=mock_client):
+ result = await a2a_client.send_a2a_message("http://target/a2a", "task")
+
+ # Must NOT be just the bare prefix — that's the regression.
+ assert result != a2a_client._A2A_ERROR_PREFIX.strip()
+ assert result != f"{a2a_client._A2A_ERROR_PREFIX}"
+ # Must include the class name + something explanatory.
+ assert "_SilentRemoteProtocolError" in result
+ assert "no message" in result.lower()
+ assert "target=http://target/a2a" in result
async def test_result_text_part_missing_text_key_returns_empty(self):
"""Part dict without 'text' key → falls back to '' (empty string returned)."""