trace-agent-server 0.5.0__tar.gz → 0.7.0__tar.gz

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trace-agent-server
-Version: 0.5.0
+Version: 0.7.0
 Summary: TraceAgent FastAPI backend server.
 Author-email: Enrique Javier Villar Cea <villarcea.enriquejavier@gmail.com>, Javier Rodriguez Castellano <javirodriguezcastellano@gmail.com>
 License: MIT

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trace-agent-server"
-version = "0.5.0"
+version = "0.7.0"
 description = "TraceAgent FastAPI backend server."
 readme = "README.md"
 authors = [

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/api/runs.py

@@ -720,7 +720,7 @@ def store_observations(
                 model=observation.model,
                 error_code=observation.error_code,
                 payload_hash=stable_hash(observation.metadata),
-                payload_full=observation.metadata if capture_full else None,
+                payload_full={**observation.metadata, **(observation.content or {})} if capture_full else None,
                 metadata={
                     "provider": observation.provider,
                     "model": observation.model,
@@ -809,10 +809,12 @@ def store_observations(
 def finish_run(
     run_id: str,
     payload: FinishRunRequest,
+    request: Request,
     session: Session = Depends(get_session),
 ) -> dict[str, Any]:
     run = _get_run_or_404(session, run_id)
-    derivation = complete_run(session, run, payload.final_output, payload.artifacts)
+    capture_full = getattr(request.app.state.settings, "capture_full_payloads", True)
+    derivation = complete_run(session, run, payload.final_output, payload.artifacts, capture_full=capture_full)
     session.commit()
     return {"status": "completed", "run_id": run.id, "decisions": len(derivation["decisions"])}
 

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/db.py

@@ -12,7 +12,8 @@ class Base(DeclarativeBase):
 
 
 def create_session_factory(database_url: str) -> tuple[object, sessionmaker[Session]]:
-    connect_args = {"check_same_thread": False} if database_url.startswith("sqlite") else {}
+    # SQLite lets one writer at a time: a request that finds the database busy waits for it instead of failing.
+    connect_args = {"check_same_thread": False, "timeout": 30} if database_url.startswith("sqlite") else {}
     engine = create_engine(database_url, connect_args=connect_args, future=True)
     session_factory = sessionmaker(bind=engine, autoflush=False, autocommit=False, expire_on_commit=False)
     return engine, session_factory

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/schemas.py

@@ -61,6 +61,8 @@ class ToolResultInput(BaseModel):
     status: Literal["succeeded", "failed"]
     args: dict[str, Any] = Field(default_factory=dict)
     output_summary: str | None = None
+    # What the tool returned, whole (masked by the sender). Stored only with full payloads on.
+    output: Any | None = None
     output_hash: str | None = None
     error_code: str | None = None
     error_summary: str | None = None
@@ -113,6 +115,8 @@ class ObservationInput(BaseModel):
     provider: str | None = None
     input_summary: str | None = None
     artifact: ArtifactInput | None = None
+    # What a model call was asked and answered (input_messages / output_messages). Stored only with full payloads on.
+    content: dict[str, Any] | None = None
     metadata: dict[str, Any] = Field(default_factory=dict)
 
 

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/services/events.py

@@ -4,6 +4,7 @@ import asyncio
 from datetime import datetime, timezone
 from typing import Any
 
+from sqlalchemy import update
 from sqlalchemy.orm import Session
 
 from trace_agent_server.models import Artifact, Event, Run
@@ -66,8 +67,11 @@ def record_event(
     timestamp: datetime | None = None,
 ) -> Event:
     """Record an event; ``timestamp`` overrides "now" for sources that report when it happened."""
-    run.last_event_seq += 1
-    run.updated_at = utcnow()
+    # The database increments the counter, it is not computed here: two requests writing to the same run at once
+    # (the agent recording by hand while the capability posts from its thread) would read the same value and
+    # collide on (run_id, seq). The second request waits for the first one's commit and gets the next number.
+    session.execute(update(Run).where(Run.id == run.id).values(last_event_seq=Run.last_event_seq + 1, updated_at=utcnow()))
+    session.refresh(run, ["last_event_seq"])
     event = Event(
         run_id=run.id,
         turn_id=turn_id,

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/services/graph.py

@@ -5,36 +5,65 @@ from typing import Any
 from trace_agent_server.models import Artifact, Decision, Event
 
 
+def _steps(events: list[Event]) -> list[list[Event]]:
+    """Events grouped by the step they belong to (a tool call's start and end, a model call's request and
+    response), in the order the steps began. An event without a step is a step of its own."""
+    steps: list[list[Event]] = []
+    position: dict[str, int] = {}
+    for event in events:
+        if event.step_id and event.step_id in position:
+            steps[position[event.step_id]].append(event)
+            continue
+        if event.step_id:
+            position[event.step_id] = len(steps)
+        steps.append([event])
+    return steps
+
+
 def build_execution_graph(events: list[Event], artifacts: list[Artifact]) -> dict[str, Any]:
+    """One node per step, not per event: a tool is one node with its result, not a 'started' and a 'finished'."""
     nodes: list[dict[str, Any]] = []
     edges: list[dict[str, Any]] = []
+    node_of_event: dict[int, str] = {}
     x = 0.0
     y = 0.0
 
-    for index, event in enumerate(events):
+    steps = _steps(events)
+    for index, step in enumerate(steps):
+        last = step[-1]
+        node_id = f"event-{last.id}"
+        for event in step:
+            node_of_event[event.id] = node_id
+        failed = any(event.status == "failed" for event in step)
+        command = next((e.event_metadata.get("command") for e in step if e.type.startswith("command.") and e.event_metadata), None)
         nodes.append(
             {
-                "id": f"event-{event.id}",
+                "id": node_id,
                 "type": "event",
-                "label": event.type,
+                "label": last.type,
                 "position": {"x": x, "y": y},
                 "data": {
-                    "summary": event.summary,
-                    "eventId": event.id,
-                    "toolName": event.tool_name,
-                    "status": event.status,
-                    "evidenceIds": [event.id],
+                    "summary": last.summary,
+                    # The last event of the step (its result) is the one the inspector opens.
+                    "eventId": last.id,
+                    "toolName": last.tool_name,
+                    "status": "failed" if failed else last.status,
+                    "durationMs": last.duration_ms,
+                    "stepKind": step[0].type.split(".")[0],
+                    "command": command,
+                    "evidenceIds": [event.id for event in step],
                 },
             }
         )
         if index > 0:
+            previous = nodes[index - 1]
             edges.append(
                 {
-                    "id": f"edge-event-{events[index - 1].id}-{event.id}",
-                    "source": f"event-{events[index - 1].id}",
-                    "target": f"event-{event.id}",
+                    "id": f"edge-{previous['id']}-{node_id}",
+                    "source": previous["id"],
+                    "target": node_id,
                     "label": None,
-                    "animated": event.type in {"tool.failed", "run.failed"},
+                    "animated": failed or last.type == "run.failed",
                 }
             )
         x += 220
@@ -62,7 +91,7 @@ def build_execution_graph(events: list[Event], artifacts: list[Artifact]) -> dic
             edges.append(
                 {
                     "id": f"edge-artifact-{artifact.id}",
-                    "source": f"event-{artifact.source_event_id}",
+                    "source": node_of_event.get(artifact.source_event_id, f"event-{artifact.source_event_id}"),
                     "target": f"artifact-{artifact.id}",
                     "label": "artifact",
                     "animated": False,

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/services/otlp.py

@@ -120,6 +120,17 @@ def _first_user_text(input_messages: Any) -> str | None:
     return None
 
 
+def _with_instructions(input_messages: Any, instructions: Any) -> Any:
+    """The instructions of the agent come beside the messages in the GenAI conventions: show them first, as a system message."""
+    parts = _parse_json(instructions)
+    if isinstance(parts, str):
+        parts = [{"type": "text", "content": parts}]
+    if not isinstance(parts, list) or not parts:
+        return input_messages
+    messages = input_messages if isinstance(input_messages, list) else []
+    return [{"role": "system", "parts": parts}, *messages]
+
+
 def _requested_tools(output_messages: Any) -> list[str]:
     names: list[str] = []
     for message in output_messages if isinstance(output_messages, list) else []:
@@ -196,7 +207,7 @@ def _ingest_run(session: Session, run_id: str, spans: list[SpanRecord], capture_
     _track_agent_calls(run, fresh)
     closing = _closing_span(run, fresh) if was_open else None
     if closing is not None:
-        _close_run(session, run, closing)
+        _close_run(session, run, closing, capture_full)
     elif not was_open:
         # Late spans of a finished run: refresh its decisions and flags.
         derive_explanation(session, run)
@@ -328,7 +339,9 @@ def _model_steps(session: Session, run: Run, span: SpanRecord, capture_full: boo
         payload = None
         if capture_full:
             payload = {
-                "input_messages": _parse_json(attributes.get("gen_ai.input.messages")),
+                "input_messages": _with_instructions(
+                    _parse_json(attributes.get("gen_ai.input.messages")), attributes.get("gen_ai.system_instructions")
+                ),
                 "output_messages": output_messages,
             }
         record_event(
@@ -359,7 +372,8 @@ def _tool_steps(session: Session, run: Run, span: SpanRecord, capture_full: bool
         parent_step_id=span.parent_span_id,
         status="failed" if failed else "succeeded",
         args=redact_payload(arguments if isinstance(arguments, dict) else {"input": arguments} if arguments is not None else {}),
-        output_summary=summarize_value(_readable(result_text)) if result_text is not None else None,
+        output_summary=summarize_value(_readable(result_text), sort_keys=False) if result_text is not None else None,
+        output=_parse_json(result_text) if result_text is not None and not failed else None,
         output_hash=stable_hash(result_text if not failed else {"error": message}),
         error_code=code,
         error_summary=message,
@@ -448,9 +462,9 @@ def _closing_span(run: Run, spans: list[SpanRecord]) -> SpanRecord | None:
     return max(agents, key=lambda s: s.end)
 
 
-def _close_run(session: Session, run: Run, span: SpanRecord) -> None:
+def _close_run(session: Session, run: Run, span: SpanRecord, capture_full: bool) -> None:
     if span.status_code == "ERROR":
         code, message = _error_of(span)
         fail_run_with(session, run, code, message, ended_at=span.end)
     else:
-        complete_run(session, run, span.attributes.get("final_result"), ended_at=span.end)
+        complete_run(session, run, span.attributes.get("final_result"), ended_at=span.end, capture_full=capture_full)

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server/services/run_lifecycle.py

@@ -86,7 +86,11 @@ def record_tool_result(
             tool_name=result.name,
             duration_ms=result.duration_ms,
             payload_hash=result.output_hash,
-            payload_full={"output_summary": result.output_summary} if capture_full else None,
+            payload_full=(
+                {"output_summary": result.output_summary, **({"output": result.output} if result.output is not None else {})}
+                if capture_full
+                else None
+            ),
             metadata={"call_id": result.call_id, "artifact_count": len(result.artifacts)},
             timestamp=ended_at,
         )
@@ -147,9 +151,13 @@ def complete_run(
     artifacts: Sequence[ArtifactInput] = (),
     *,
     ended_at: datetime | None = None,
+    capture_full: bool = False,
 ) -> dict[str, Any]:
-    """Mark a run completed, record its final output and derive its explanation."""
-    final_summary = summarize_value(final_output) if final_output is not None else "Run finished without final output."
+    """Mark a run completed, record its final output and derive its explanation.
+
+    The summary of the output is always kept; the whole output only with ``capture_full``.
+    """
+    final_summary = summarize_value(final_output, sort_keys=False) if final_output is not None else "Run finished without final output."
     run.final_output_summary = final_summary
     run.status = "completed"
     run.ended_at = ended_at or utcnow()
@@ -161,6 +169,7 @@ def complete_run(
         summary=final_summary,
         status="completed",
         payload_hash=stable_hash(final_output),
+        payload_full={"final_output": final_output} if capture_full and final_output is not None else None,
         timestamp=ended_at,
     )
     for artifact_input in artifacts:

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trace-agent-server
-Version: 0.5.0
+Version: 0.7.0
 Summary: TraceAgent FastAPI backend server.
 Author-email: Enrique Javier Villar Cea <villarcea.enriquejavier@gmail.com>, Javier Rodriguez Castellano <javirodriguezcastellano@gmail.com>
 License: MIT

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/src/trace_agent_server.egg-info/SOURCES.txt

@@ -32,9 +32,11 @@ src/trace_agent_server/services/run_lifecycle.py
 src/trace_agent_server/services/run_summary.py
 src/trace_agent_server/services/stored_redaction.py
 tests/test_audit_guardrails_api.py
+tests/test_concurrent_writers.py
 tests/test_dashboard.py
 tests/test_events.py
 tests/test_framework_observations.py
+tests/test_graph.py
 tests/test_inactivity_sweep.py
 tests/test_otlp_decode.py
 tests/test_otlp_ingest.py

trace_agent_server-0.7.0/tests/test_concurrent_writers.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import threading
+
+import pytest
+from fastapi.testclient import TestClient
+
+from trace_agent_server.config import Settings
+from trace_agent_server.main import create_app
+from trace_agent_server.models import Event, Run
+from trace_agent_server.services.events import record_event
+
+WRITERS = 6
+EVENTS_EACH = 25
+
+
+@pytest.fixture
+def app(tmp_path):
+    return create_app(Settings(database_url=f"sqlite:///{tmp_path / 'writers.db'}", cors_origins=["http://localhost:5173"]))
+
+
+class TestSeveralWritersOnOneRun:
+    """The capability posts from a background thread while the agent records by hand: both write to the same run."""
+
+    def test_events_recorded_at_the_same_time_never_collide(self, app) -> None:
+        with app.state.session_factory() as session:
+            run = Run(agent_name="agent", goal="goal")
+            session.add(run)
+            session.commit()
+            run_id = run.id
+
+        errors: list[BaseException] = []
+        start = threading.Barrier(WRITERS)
+
+        def write(writer: int) -> None:
+            try:
+                start.wait()
+                for index in range(EVENTS_EACH):
+                    # Each request loads the run, records an event and commits, as the endpoints do.
+                    with app.state.session_factory() as session:
+                        run = session.get(Run, run_id)
+                        record_event(session, run, actor="sdk", event_type="tool.started", summary=f"writer {writer} event {index}")
+                        session.commit()
+            except BaseException as exc:  # noqa: BLE001 - reported by the test below
+                errors.append(exc)
+
+        threads = [threading.Thread(target=write, args=(writer,)) for writer in range(WRITERS)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join(timeout=120)
+
+        assert errors == []
+        with app.state.session_factory() as session:
+            sequence = [seq for (seq,) in session.query(Event.seq).filter_by(run_id=run_id).order_by(Event.seq)]
+            assert session.get(Run, run_id).last_event_seq == WRITERS * EVENTS_EACH
+        assert sequence == list(range(1, WRITERS * EVENTS_EACH + 1))
+
+    def test_requests_to_the_same_run_at_the_same_time_all_succeed(self, app) -> None:
+        client = TestClient(app)
+        run_id = client.post("/api/runs", json={"agent_name": "agent", "goal": "goal"}).json()["run_id"]
+        failures: list[int] = []
+        start = threading.Barrier(4)
+
+        def post(writer: int) -> None:
+            start.wait()
+            for index in range(10):
+                response = client.post(
+                    f"/api/runs/{run_id}/observations",
+                    json={"observations": [{"kind": "command", "command": f"echo {writer}-{index}", "step_id": f"c-{writer}-{index}", "status": "succeeded", "exit_code": 0}]},
+                )
+                if response.status_code != 200:
+                    failures.append(response.status_code)
+
+        threads = [threading.Thread(target=post, args=(writer,)) for writer in range(4)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join(timeout=120)
+
+        assert failures == []
+        with app.state.session_factory() as session:
+            seqs = [seq for (seq,) in session.query(Event.seq).filter_by(run_id=run_id).order_by(Event.seq)]
+        assert seqs == list(range(1, len(seqs) + 1))
+        assert len(seqs) == 1 + 4 * 10 * 2  # run.started, then command.started and command.succeeded for each command

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/tests/test_framework_observations.py

@@ -120,6 +120,45 @@ class TestLlmCallUsage:
         assert execution["assistant_turn_count"] == 2
 
 
+class TestLlmCallContent:
+    content = {
+        "input_messages": [{"role": "user", "parts": [{"type": "text", "content": "¿Por qué bajó el OEE?"}]}],
+        "output_messages": [{"role": "assistant", "parts": [{"type": "text", "content": "Por las paradas."}]}],
+    }
+
+    def completed_event(self, client, run_id: str) -> Event:
+        with client.app.state.session_factory() as session:
+            event = session.query(Event).filter_by(run_id=run_id, type="llm.completed").one()
+            session.expunge(event)
+            return event
+
+    def test_what_the_model_was_asked_and_answered_is_stored_with_the_event(self, client) -> None:
+        run_id = start_run(client)
+        observe(client, run_id, kind="llm_call", step_id="l1", status="succeeded", provider="openai", model="m",
+                content=self.content, metadata={"prompt_tokens": 3})
+
+        event = self.completed_event(client, run_id)
+        assert event.payload_full["input_messages"] == self.content["input_messages"]
+        assert event.payload_full["output_messages"] == self.content["output_messages"]
+        assert event.payload_full["prompt_tokens"] == 3
+        # The content is not copied into the metadata that is always kept and listed.
+        assert "input_messages" not in event.event_metadata
+
+    def test_it_is_not_stored_when_full_payloads_are_off(self, tmp_path) -> None:
+        app = create_app(Settings(database_url=f"sqlite:///{tmp_path / 'off.db'}", cors_origins=["http://localhost:5173"], capture_full_payloads=False))
+        client = TestClient(app)
+        run_id = start_run(client)
+        observe(client, run_id, kind="llm_call", step_id="l1", status="succeeded", provider="openai", model="m", content=self.content)
+
+        assert self.completed_event(client, run_id).payload_full is None
+
+    def test_a_call_without_content_is_stored_as_before(self, client) -> None:
+        run_id = start_run(client)
+        observe(client, run_id, kind="llm_call", step_id="l1", status="succeeded", provider="openai", model="m", metadata={"prompt_tokens": 3})
+
+        assert self.completed_event(client, run_id).payload_full == {"prompt_tokens": 3}
+
+
 class TestTokenUsageOfFrameworkRuns:
     def model_call(self, client, run_id, step, **tokens) -> None:
         observe(client, run_id, kind="llm_call", step_id=step, status="succeeded", provider="openai", model="m", metadata=tokens)

trace_agent_server-0.7.0/tests/test_graph.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from trace_agent_server.models import Artifact, Event
+from trace_agent_server.services.graph import build_execution_graph
+
+
+def event(event_id: int, event_type: str, step_id: str | None, *, status: str | None = None, tool_name: str | None = None,
+          summary: str = "", metadata: dict | None = None, duration_ms: int | None = None) -> Event:
+    return Event(id=event_id, run_id="r", seq=event_id, actor="sdk", type=event_type, summary=summary, status=status,
+                 step_id=step_id, tool_name=tool_name, event_metadata=metadata or {}, duration_ms=duration_ms)
+
+
+class TestExecutionGraphSteps:
+    def test_a_tool_is_one_node_with_its_result_not_a_started_and_a_finished_node(self) -> None:
+        events = [
+            event(1, "run.started", None),
+            event(2, "tool.started", "t1", tool_name="search", status="completed"),
+            event(3, "tool.succeeded", "t1", tool_name="search", status="succeeded", summary="3 results", duration_ms=40),
+            event(4, "run.completed", None),
+        ]
+
+        graph = build_execution_graph(events, [])
+
+        assert [n["data"]["eventId"] for n in graph["nodes"]] == [1, 3, 4]
+        tool = graph["nodes"][1]
+        assert (tool["label"], tool["data"]["summary"], tool["data"]["durationMs"], tool["data"]["toolName"]) == ("tool.succeeded", "3 results", 40, "search")
+        assert tool["data"]["evidenceIds"] == [2, 3]
+        assert tool["data"]["stepKind"] == "tool"
+
+    def test_the_nodes_are_chained_in_the_order_the_steps_began(self) -> None:
+        events = [event(1, "llm.started", "l1"), event(2, "tool.started", "t1"), event(3, "llm.completed", "l1"), event(4, "tool.succeeded", "t1")]
+
+        graph = build_execution_graph(events, [])
+
+        assert [n["data"]["eventId"] for n in graph["nodes"]] == [3, 4]  # each node is named after the last event of its step
+        assert [(e["source"], e["target"]) for e in graph["edges"]] == [("event-3", "event-4")]
+
+    def test_a_step_that_failed_at_any_point_is_failed_and_its_edge_animated(self) -> None:
+        events = [event(1, "tool.started", "t1", status="completed"), event(2, "tool.failed", "t1", status="failed"), event(3, "tool.started", "t2")]
+
+        graph = build_execution_graph(events, [])
+
+        assert graph["nodes"][0]["data"]["status"] == "failed"
+        assert graph["edges"][0]["animated"] is False  # the edge into the next step follows that step, which did not fail
+
+    def test_the_command_of_a_command_step_is_kept_for_its_title(self) -> None:
+        events = [event(1, "command.started", "c1", metadata={"command": "python -c # Leer\nprint(1)"}), event(2, "command.succeeded", "c1", metadata={"command": "python -c # Leer\nprint(1)"})]
+
+        graph = build_execution_graph(events, [])
+
+        assert graph["nodes"][0]["data"]["command"] == "python -c # Leer\nprint(1)"
+        assert graph["nodes"][0]["data"]["stepKind"] == "command"
+
+    def test_an_artifact_hangs_from_the_node_of_the_step_that_made_it(self) -> None:
+        events = [event(1, "tool.started", "t1"), event(2, "tool.succeeded", "t1")]
+        artifact = Artifact(id=9, run_id="r", kind="file", label="report", summary="the report", source_event_id=1)
+
+        graph = build_execution_graph(events, [artifact])
+
+        assert ("event-2", "artifact-9") in [(e["source"], e["target"]) for e in graph["edges"]]

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/tests/test_otlp_ingest.py

@@ -190,6 +190,25 @@ class TestRunCreationAndMapping:
         assert completed.event_metadata["prompt_tokens"] == 60
         assert completed.event_metadata["requested_tools"] == ["get_weather"]
 
+    def test_what_the_model_was_asked_and_answered_is_kept_with_the_instructions_first(self, client) -> None:
+        spans = agent_spans()
+        spans[1].attributes["gen_ai__system_instructions"] = json.dumps([{"type": "text", "content": "Be brief."}])
+
+        post(client, export(*spans))
+
+        _, events = load(client)
+        payload = next(e for e in events if e.type == "llm.completed").payload_full
+        assert payload["input_messages"][0] == {"role": "system", "parts": [{"type": "text", "content": "Be brief."}]}
+        assert payload["input_messages"][1]["role"] == "user"
+        assert payload["output_messages"][0]["parts"][0]["name"] == "get_weather"
+
+    def test_without_instructions_the_messages_are_kept_as_they_came(self, client) -> None:
+        post(client, export(*agent_spans()))
+
+        _, events = load(client)
+        payload = next(e for e in events if e.type == "llm.completed").payload_full
+        assert [m["role"] for m in payload["input_messages"]] == ["user"]
+
     def test_tool_arguments_and_result_are_recorded(self, client) -> None:
         post(client, export(*agent_spans()))
 

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/tests/test_run_lifecycle.py

@@ -100,6 +100,36 @@ class TestRecordToolResult:
         assert all(e.payload_full is None for e in events_of(session, run))
 
 
+class TestFinalOutputAndToolOutput:
+    def test_the_whole_final_output_is_kept_with_full_payloads_on_and_only_the_summary_without(self, session, run) -> None:
+        long_output = {"recomendacion": "x" * 600, "causa": "avería"}
+
+        complete_run(session, run, long_output, capture_full=True)
+        completed = [e for e in events_of(session, run) if e.type == "run.completed"][0]
+
+        assert completed.payload_full == {"final_output": long_output}
+        assert len(completed.summary) <= 220
+
+    def test_without_full_payloads_only_the_summary_is_stored(self, session, run) -> None:
+        complete_run(session, run, {"a": 1})
+
+        assert [e for e in events_of(session, run) if e.type == "run.completed"][0].payload_full is None
+
+    def test_the_whole_tool_output_is_kept_next_to_its_summary(self, session, run) -> None:
+        result = ToolResultInput(call_id="c1", name="check", step_id="s1", status="succeeded", args={}, output_summary="{...}", output={"veredicto": "descartado", "ventana": [60, 120]})
+
+        record_tool_result(session, run, result, capture_full=True)
+
+        done = [e for e in events_of(session, run) if e.type == "tool.succeeded"][0]
+        assert done.payload_full == {"output_summary": "{...}", "output": {"veredicto": "descartado", "ventana": [60, 120]}}
+
+    def test_a_tool_without_output_is_stored_as_before(self, session, run) -> None:
+        record_tool_result(session, run, ToolResultInput(call_id="c1", name="check", step_id="s1", status="succeeded", args={}, output_summary="ok"), capture_full=True)
+
+        done = [e for e in events_of(session, run) if e.type == "tool.succeeded"][0]
+        assert done.payload_full == {"output_summary": "ok"}
+
+
 class TestRunEnd:
     def test_complete_run_sets_status_summary_and_end_time(self, session, run) -> None:
         derivation = complete_run(session, run, {"answer": 42}, ended_at=START)

{trace_agent_server-0.5.0 → trace_agent_server-0.7.0}/tests/test_runs_api.py

@@ -282,7 +282,10 @@ def test_successful_run_generates_timeline_graph_and_explanation(tmp_path) -> No
     assert all(decision["alternatives"] == [] for decision in explanation["decisions"])
 
     graph = test_client.get(f"/api/runs/{run.run_id}/graph?view=execution").json()
-    assert len(graph["nodes"]) >= len(event_types)
+    # One node per step: a tool's start and end are one node, and every event is evidence of some node.
+    assert 0 < len(graph["nodes"]) < len(event_types)
+    evidence = {event_id for node in graph["nodes"] for event_id in node["data"]["evidenceIds"]}
+    assert len(evidence) == len(event_types)
 
     analytics = test_client.get(f"/api/runs/{run.run_id}/analytics").json()
     assert analytics["tool_graph"]["view"] == "tool_chain"