feat(harness): mark derived tool spans as errored from ToolResponseContent.is_error

Now that the SDK carries ToolResponseContent.is_error (AGX1-371), thread it
through the harness surface: CloseSpan gains an is_error field, the span
deriver populates it when closing a tool span on a ToolResponseContent, and
the tracer records the status on span.data (Span has no dedicated error
field; None means the harness reported no status, so data is left untouched).

This preserves tool-error tracing fidelity for harnesses that report tool
failures (e.g. golden agent's ToolCompleted.is_error) once they move onto the
unified surface, instead of silently dropping the status.

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

Author: declan-scale

src/agentex/lib/core/harness/span_derivation.py

@@ -124,7 +124,14 @@ def _on_full(self, event: StreamTaskMessageFull) -> list[SpanSignal]:
             tcid = content.tool_call_id
             if tcid in self._open_tool_ids:
                 self._open_tool_ids.pop(tcid, None)
-                return [CloseSpan(key=tcid, output=content.content, is_complete=True)]
+                return [
+                    CloseSpan(
+                        key=tcid,
+                        output=content.content,
+                        is_complete=True,
+                        is_error=content.is_error,
+                    )
+                ]
         return []
 
     def _on_done(self, event: StreamTaskMessageDone) -> list[SpanSignal]:

src/agentex/lib/core/harness/tracer.py

@@ -74,6 +74,12 @@ async def handle(self, signal: SpanSignal) -> None:
                     #   end_span(trace_id, span, start_to_close_timeout, heartbeat_timeout, retry_policy)
                     # It does not accept an output= kwarg.
                     span.output = signal.output
+                    # Tool failure status (ToolResponseContent.is_error) is recorded
+                    # on span.data when the harness reports one; Span has no dedicated
+                    # error field. None means no status was reported, so leave data alone.
+                    if signal.is_error is not None:
+                        data = span.data if isinstance(span.data, dict) else {}
+                        span.data = {**data, "is_error": signal.is_error}
                     await self._tracing.end_span(
                         trace_id=self.trace_id,
                         span=span,

src/agentex/lib/core/harness/types.py

@@ -42,6 +42,7 @@ class CloseSpan:
     key: str
     output: Any = None
     is_complete: bool = True  # False when closed by flush() without a result
+    is_error: bool | None = None  # tool failure status; None when the harness reports no status
 
 
 SpanSignal = Union[OpenSpan, CloseSpan]

tests/lib/core/harness/test_span_derivation.py

@@ -57,6 +57,35 @@ def test_single_tool_opens_on_done_closes_on_response():
         OpenSpan(key="call_1", kind="tool", name="Bash", input={"cmd": "ls"}),
         CloseSpan(key="call_1", output="files", is_complete=True),
     ]
+    # No status reported -> CloseSpan carries is_error=None.
+    assert sigs[1].is_error is None
+
+
+def test_tool_response_is_error_propagates_to_close_span():
+    """ToolResponseContent.is_error flows onto the CloseSpan so a derived tool
+    span can be marked as a failure (AGX1-371)."""
+    d = SpanDeriver()
+    events = [
+        _tool_req(0, "call_err", "Bash", {"cmd": "false"}),
+        StreamTaskMessageDone(type="done", index=0),
+        StreamTaskMessageFull(
+            type="full",
+            index=1,
+            content=ToolResponseContent(
+                type="tool_response",
+                author="agent",
+                tool_call_id="call_err",
+                name="Bash",
+                content="boom",
+                is_error=True,
+            ),
+        ),
+    ]
+    sigs = _signals(d, events)
+    assert sigs == [
+        OpenSpan(key="call_err", kind="tool", name="Bash", input={"cmd": "false"}),
+        CloseSpan(key="call_err", output="boom", is_complete=True, is_error=True),
+    ]
 
 
 def test_reasoning_opens_on_start_closes_on_done():

tests/lib/core/harness/test_tracer.py

@@ -10,19 +10,22 @@ class _FakeSpan:
     def __init__(self, name):
         self.name = name
         self.output = None
+        self.data = None
 
 
 class _FakeTracing:
     def __init__(self):
         self.started = []
         self.ended = []
+        self.ended_spans = []
 
     async def start_span(self, *, trace_id, name, input=None, parent_id=None, data=None, task_id=None):
         self.started.append((name, parent_id, input))
         return _FakeSpan(name)
 
     async def end_span(self, *, trace_id, span):
         self.ended.append((span.name, span.output))
+        self.ended_spans.append(span)
 
 
 @pytest.mark.asyncio
@@ -35,6 +38,26 @@ async def test_open_then_close_starts_and_ends_span():
     assert fake.ended == [("Bash", "files")]
 
 
+@pytest.mark.asyncio
+async def test_close_records_is_error_on_span_data():
+    """A CloseSpan carrying is_error records the status on span.data (AGX1-371)."""
+    fake = _FakeTracing()
+    tracer = SpanTracer(trace_id="t1", parent_span_id="p1", tracing=fake)
+    await tracer.handle(OpenSpan(key="call_err", kind="tool", name="Bash", input={}))
+    await tracer.handle(CloseSpan(key="call_err", output="boom", is_complete=True, is_error=True))
+    assert fake.ended_spans[0].data == {"is_error": True}
+
+
+@pytest.mark.asyncio
+async def test_close_without_status_leaves_span_data_untouched():
+    """is_error=None (no status reported) must not write to span.data."""
+    fake = _FakeTracing()
+    tracer = SpanTracer(trace_id="t1", parent_span_id="p1", tracing=fake)
+    await tracer.handle(OpenSpan(key="call_1", kind="tool", name="Bash", input={}))
+    await tracer.handle(CloseSpan(key="call_1", output="files", is_complete=True))
+    assert fake.ended_spans[0].data is None
+
+
 @pytest.mark.asyncio
 async def test_no_trace_id_is_noop():
     fake = _FakeTracing()