trace-agent-server 0.4.0__tar.gz → 0.6.0__tar.gz

{trace_agent_server-0.4.0 → trace_agent_server-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trace-agent-server
-Version: 0.4.0
+Version: 0.6.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.4.0 → trace_agent_server-0.6.0}/pyproject.toml

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

{trace_agent_server-0.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server/api/runs.py

@@ -12,7 +12,7 @@ from sqlalchemy.orm import Session
 
 from trace_agent_server.db import get_session
 from trace_agent_server.models import Artifact, Decision, Event, Run, Turn
-from trace_agent_sdk.redaction import stable_hash, summarize_value
+from trace_agent_sdk.redaction import redact_keys, stable_hash, summarize_value
 from trace_agent_server.schemas import (
     ArtifactOut,
     DashboardResponse,
@@ -36,6 +36,7 @@ from trace_agent_server.schemas import (
     TurnCreateResponse,
     TurnOut,
 )
+from trace_agent_server.services.stored_redaction import redact_messages, redact_tool_calls
 from trace_agent_server.services.analytics import build_similar_runs, build_tool_graph, build_tool_metrics
 from trace_agent_server.services.compare import compare_runs
 from trace_agent_server.services.events import create_artifact, record_event
@@ -295,6 +296,8 @@ def create_turn(
             raise HTTPException(status_code=400, detail="Input blocked by guardrails.")
 
     tool_redaction = {tool.name: tool.redact_fields for tool in payload.tools}
+    # What is stored is a masked copy; the provider and the agent keep the real data.
+    stored_messages = redact_messages(sanitized_messages, tool_redaction)
     if payload.tools:
         run.run_metadata = {
             **run.run_metadata,
@@ -315,7 +318,7 @@ def create_turn(
         provider=payload.provider,
         model=payload.model,
         payload_hash=stable_hash(sanitized_messages),
-        payload_full={"messages": sanitized_messages} if capture_full else None,
+        payload_full={"messages": stored_messages} if capture_full else None,
         metadata={
             "registered_tool_count": len(payload.tools),
             "tool_names": [tool.name for tool in payload.tools],
@@ -355,6 +358,10 @@ def create_turn(
     run.provider = payload.provider
     run.model = payload.model
 
+    stored_assistant_message = (
+        redact_messages([response.assistant_message], tool_redaction)[0] if response.assistant_message else None
+    )
+
     # Create Turn record with full messages and token usage
     usage = response.metadata.get("usage", {}) if response.metadata else {}
     turn = Turn(
@@ -362,9 +369,12 @@ def create_turn(
         seq=run.last_event_seq + 1,
         provider=payload.provider,
         model=payload.model,
-        messages=sanitized_messages,
-        assistant_message=response.assistant_message,
-        tool_calls=[{"id": c.id, "name": c.name, "arguments": c.arguments, "step_id": c.step_id} for c in response.tool_calls],
+        messages=stored_messages,
+        assistant_message=stored_assistant_message,
+        tool_calls=redact_tool_calls(
+            [{"id": c.id, "name": c.name, "arguments": c.arguments, "step_id": c.step_id} for c in response.tool_calls],
+            tool_redaction,
+        ),
         prompt_tokens=usage.get("prompt_tokens"),
         completion_tokens=usage.get("completion_tokens"),
         total_tokens=usage.get("total_tokens"),
@@ -409,7 +419,7 @@ def create_turn(
         provider=payload.provider,
         model=payload.model,
         payload_hash=stable_hash(response.assistant_message or [tool_call.__dict__ for tool_call in response.tool_calls]),
-        payload_full={"assistant_message": response.assistant_message, "tool_calls": turn.tool_calls} if capture_full else None,
+        payload_full={"assistant_message": stored_assistant_message, "tool_calls": turn.tool_calls} if capture_full else None,
         turn_id=turn.id,
         metadata=response_metadata,
     )
@@ -430,7 +440,7 @@ def create_turn(
             model=payload.model,
             tool_name=call.name,
             payload_hash=stable_hash(call.arguments),
-            payload_full={"arguments": call.arguments} if capture_full else None,
+            payload_full={"arguments": redact_keys(call.arguments, tool_redaction.get(call.name, []))} if capture_full else None,
             turn_id=turn.id,
             metadata={"call_id": call.id},
         )
@@ -710,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,
@@ -799,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"])}
 
@@ -962,7 +974,7 @@ def get_artifacts(run_id: str, session: Session = Depends(get_session)) -> list[
 
 
 @router.get("/runs/{run_id}/audit")
-def get_run_audit(run_id: str, session: Session = Depends(get_session)) -> dict[str, Any]:
+def get_run_audit(run_id: str, request: Request, session: Session = Depends(get_session)) -> dict[str, Any]:
     """Return a structured audit report for a run based on guardrail events."""
     run = _get_run_or_404(session, run_id)
     events = list(session.scalars(select(Event).where(Event.run_id == run_id).order_by(Event.seq)))
@@ -1020,6 +1032,8 @@ def get_run_audit(run_id: str, session: Session = Depends(get_session)) -> dict[
 
     return {
         "run_id": run_id,
+        # Without guardrails nothing is checked, so the score would only be a meaningless 100.
+        "guardrails_enabled": bool(getattr(request.app.state.settings, "audit_enable_guardrails", False)),
         "security_score": security_score,
         "pii_hit_count": pii_hit_count,
         "injection_hit_count": injection_hit_count,

{trace_agent_server-0.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server/config.py

@@ -45,6 +45,8 @@ class Settings(BaseSettings):
     capture_full_payloads: bool = True
     otlp_enabled: bool = True
     otlp_max_body_bytes: int = 10_000_000
+    # A run with no event for this long is closed as failed (0 turns it off).
+    run_inactivity_timeout_seconds: int = 3600
 
     model_config = SettingsConfigDict(
         env_prefix="TRACE_AGENT_",

{trace_agent_server-0.4.0 → trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server/main.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
 
+import asyncio
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from datetime import timedelta
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
@@ -9,6 +14,7 @@ from trace_agent_server.config import Settings, get_settings
 from trace_agent_server.db import Base, create_session_factory
 from trace_agent_server.services.audit_guardrails import AuditGuardrails
 from trace_agent_server.services.observability import AppObservability, configure_opentelemetry
+from trace_agent_server.services.run_lifecycle import expire_inactive_runs
 from trace_agent_server.services.provider import (
     AnthropicProviderAdapter,
     BaseProviderAdapter,
@@ -41,9 +47,38 @@ def build_provider_registry(settings: Settings) -> dict[str, BaseProviderAdapter
     return registry
 
 
+def _close_inactive_runs(app: FastAPI, timeout: timedelta) -> None:
+    with app.state.session_factory() as session:
+        expire_inactive_runs(session, timeout=timeout)
+
+
+@asynccontextmanager
+async def _lifespan(app: FastAPI) -> AsyncIterator[None]:
+    """While the server is up, close the runs whose agent disappeared without finishing them."""
+    seconds = app.state.settings.run_inactivity_timeout_seconds
+    task: asyncio.Task[None] | None = None
+    if seconds > 0:
+        timeout = timedelta(seconds=seconds)
+
+        async def sweep() -> None:
+            while True:
+                await asyncio.sleep(min(60.0, max(1.0, seconds / 4)))
+                try:
+                    await asyncio.to_thread(_close_inactive_runs, app, timeout)
+                except Exception:  # a failed sweep must never take the server down; try again next time
+                    pass
+
+        task = asyncio.create_task(sweep())
+    try:
+        yield
+    finally:
+        if task is not None:
+            task.cancel()
+
+
 def create_app(settings: Settings | None = None) -> FastAPI:
     current_settings = settings or get_settings()
-    app = FastAPI(title=current_settings.app_name)
+    app = FastAPI(title=current_settings.app_name, lifespan=_lifespan)
     app.add_middleware(
         CORSMiddleware,
         allow_origins=current_settings.cors_origins,

{trace_agent_server-0.4.0 → trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.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(
@@ -360,6 +373,7 @@ def _tool_steps(session: Session, run: Run, span: SpanRecord, capture_full: bool
         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=_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.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server/services/run_lifecycle.py

@@ -3,9 +3,10 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any
 
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from trace_agent_sdk.redaction import stable_hash, summarize_value
@@ -85,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,
         )
@@ -146,8 +151,12 @@ 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."""
+    """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) if final_output is not None else "Run finished without final output."
     run.final_output_summary = final_summary
     run.status = "completed"
@@ -160,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:
@@ -213,3 +223,23 @@ def fail_run_with(
         timestamp=ended_at,
     )
     derive_explanation(session, run)
+
+
+def expire_inactive_runs(session: Session, *, timeout: timedelta, now: datetime | None = None) -> int:
+    """Fail the runs that are still running but have had no event for ``timeout``.
+
+    An agent that dies without calling finish or fail would otherwise stay "running" forever and keep
+    counting as active. Returns how many runs were closed.
+    """
+    now = now or utcnow()
+    stale = list(session.scalars(select(Run).where(Run.status == "running", Run.updated_at < now - timeout)))
+    minutes = max(1, int(timeout.total_seconds() // 60))
+    for run in stale:
+        fail_run_with(
+            session,
+            run,
+            "RunAbandoned",
+            f"No activity for {minutes} minutes: the agent stopped without finishing the run.",
+        )
+    session.commit()
+    return len(stale)

trace_agent_server-0.6.0/src/trace_agent_server/services/stored_redaction.py

@@ -0,0 +1,57 @@
+"""Copies of a model turn with the sensitive keys of each tool masked, for what the server stores.
+
+The provider and the agent still get the real data; only what is saved (events, turns) is masked.
+A tool names its sensitive keys with ``redact_fields``; they apply to that tool's arguments and result.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from trace_agent_sdk.redaction import redact_keys
+
+
+def _redact_json_text(text: Any, fields: list[str]) -> Any:
+    if not fields or not isinstance(text, str):
+        return text
+    try:
+        parsed = json.loads(text)
+    except ValueError:
+        return text
+    return json.dumps(redact_keys(parsed, fields), ensure_ascii=False)
+
+
+def redact_messages(messages: list[dict[str, Any]], tool_redaction: dict[str, list[str]]) -> list[dict[str, Any]]:
+    """The conversation with the arguments and results of each tool masked."""
+    if not any(tool_redaction.values()):
+        return messages
+
+    tool_names: dict[str, str] = {}
+    for message in messages:
+        for call in message.get("tool_calls") or []:
+            tool_names[str(call.get("id"))] = str((call.get("function") or {}).get("name"))
+
+    redacted: list[dict[str, Any]] = []
+    for message in messages:
+        message = dict(message)
+        if message.get("role") == "tool":
+            fields = tool_redaction.get(tool_names.get(str(message.get("tool_call_id")), ""), [])
+            message["content"] = _redact_json_text(message.get("content"), fields)
+        if message.get("tool_calls"):
+            calls = []
+            for call in message["tool_calls"]:
+                function = dict(call.get("function") or {})
+                function["arguments"] = _redact_json_text(function.get("arguments"), tool_redaction.get(str(function.get("name")), []))
+                calls.append({**call, "function": function})
+            message["tool_calls"] = calls
+        redacted.append(message)
+    return redacted
+
+
+def redact_tool_calls(tool_calls: list[dict[str, Any]], tool_redaction: dict[str, list[str]]) -> list[dict[str, Any]]:
+    """Tool calls ({"name", "arguments", ...}) with the arguments of each tool masked."""
+    return [
+        {**call, "arguments": redact_keys(call.get("arguments"), tool_redaction.get(str(call.get("name")), []))}
+        for call in tool_calls
+    ]

{trace_agent_server-0.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trace-agent-server
-Version: 0.4.0
+Version: 0.6.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.4.0 → trace_agent_server-0.6.0}/src/trace_agent_server.egg-info/SOURCES.txt

@@ -30,10 +30,14 @@ src/trace_agent_server/services/otlp_decode.py
 src/trace_agent_server/services/provider.py
 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
 tests/test_providers.py
@@ -41,4 +45,5 @@ tests/test_run_lifecycle.py
 tests/test_runs_api.py
 tests/test_sdk_wrappers.py
 tests/test_sse.py
+tests/test_stored_redaction.py
 tests/test_turns.py

{trace_agent_server-0.4.0 → trace_agent_server-0.6.0}/tests/test_audit_guardrails_api.py

@@ -137,3 +137,19 @@ def test_metrics_endpoint_is_available_when_enabled(tmp_path) -> None:
     body = metrics.text
     assert "TRACE_AGENT_http_requests_total" in body
     assert "TRACE_AGENT_http_request_duration_seconds" in body
+
+
+def test_audit_says_guardrails_are_off_by_default(tmp_path) -> None:
+    client = build_client(tmp_path, CountingProvider())
+
+    report = client.get(f"/api/runs/{_create_run(client)}/audit").json()
+
+    assert report["guardrails_enabled"] is False
+
+
+def test_audit_says_guardrails_are_on_when_enabled(tmp_path) -> None:
+    client = build_client(tmp_path, CountingProvider(), audit_enable_guardrails=True)
+
+    report = client.get(f"/api/runs/{_create_run(client)}/audit").json()
+
+    assert report["guardrails_enabled"] is True

trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.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.6.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.6.0/tests/test_inactivity_sweep.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import time
+
+from fastapi.testclient import TestClient
+
+from trace_agent_server.config import Settings
+from trace_agent_server.main import create_app
+
+
+def build_app(tmp_path, timeout_seconds: int):
+    return create_app(
+        Settings(
+            database_url=f"sqlite:///{tmp_path / 'sweep.db'}",
+            cors_origins=["http://localhost:5173"],
+            run_inactivity_timeout_seconds=timeout_seconds,
+        )
+    )
+
+
+def wait_for_status(client: TestClient, run_id: str, status: str, seconds: float) -> str:
+    deadline = time.time() + seconds
+    current = ""
+    while time.time() < deadline:
+        current = client.get(f"/api/runs/{run_id}").json()["status"]
+        if current == status:
+            break
+        time.sleep(0.25)
+    return current
+
+
+class TestInactivitySweep:
+    def test_a_running_server_closes_a_run_whose_agent_disappeared(self, tmp_path) -> None:
+        with TestClient(build_app(tmp_path, timeout_seconds=1)) as client:
+            run_id = client.post("/api/runs", json={"agent_name": "a", "goal": "g"}).json()["run_id"]
+
+            assert wait_for_status(client, run_id, "failed", seconds=8) == "failed"
+
+            events = client.get(f"/api/runs/{run_id}/events").json()
+            events = events if isinstance(events, list) else events["events"]
+            assert events[-1]["type"] == "run.failed"
+            assert events[-1]["error_code"] == "RunAbandoned"
+
+    def test_a_timeout_of_zero_turns_the_sweep_off(self, tmp_path) -> None:
+        with TestClient(build_app(tmp_path, timeout_seconds=0)) as client:
+            run_id = client.post("/api/runs", json={"agent_name": "a", "goal": "g"}).json()["run_id"]
+
+            time.sleep(2.5)
+
+            assert client.get(f"/api/runs/{run_id}").json()["status"] == "running"

{trace_agent_server-0.4.0 → trace_agent_server-0.6.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.4.0 → trace_agent_server-0.6.0}/tests/test_run_lifecycle.py

@@ -13,6 +13,7 @@ from trace_agent_server.services.events import record_event
 from trace_agent_server.services.run_lifecycle import (
     apply_llm_usage,
     complete_run,
+    expire_inactive_runs,
     fail_run_with,
     record_tool_result,
     token_count,
@@ -99,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)
@@ -115,3 +146,44 @@ class TestRunEnd:
         assert (run.status, run.error_count, run.final_output_summary) == ("failed", 1, "boom")
         last = events_of(session, run)[-1]
         assert (last.type, last.error_code) == ("run.failed", "ValueError")
+
+
+class TestExpireInactiveRuns:
+    def stale_run(self, session, *, minutes_ago: int, status: str = "running") -> Run:
+        run = Run(agent_name="agent", goal="goal", status=status)
+        session.add(run)
+        session.flush()
+        run.updated_at = START - timedelta(minutes=minutes_ago)
+        session.flush()
+        return run
+
+    def test_a_run_with_no_activity_is_failed_with_a_clear_reason(self, session) -> None:
+        run = self.stale_run(session, minutes_ago=90)
+
+        closed = expire_inactive_runs(session, timeout=timedelta(minutes=60), now=START)
+
+        assert closed == 1
+        assert run.status == "failed"
+        assert "No activity for 60 minutes" in run.final_output_summary
+        last = events_of(session, run)[-1]
+        assert (last.type, last.error_code) == ("run.failed", "RunAbandoned")
+
+    def test_a_recent_run_is_left_running(self, session) -> None:
+        run = self.stale_run(session, minutes_ago=5)
+
+        assert expire_inactive_runs(session, timeout=timedelta(minutes=60), now=START) == 0
+        assert run.status == "running"
+
+    def test_finished_runs_are_not_touched(self, session) -> None:
+        run = self.stale_run(session, minutes_ago=500, status="completed")
+
+        assert expire_inactive_runs(session, timeout=timedelta(minutes=60), now=START) == 0
+        assert run.status == "completed"
+
+    def test_an_active_run_keeps_going_as_events_arrive(self, session) -> None:
+        run = self.stale_run(session, minutes_ago=90)
+        record_event(session, run, actor="sdk", event_type="tool.started", summary="still working", timestamp=START)
+        run.updated_at = START
+
+        assert expire_inactive_runs(session, timeout=timedelta(minutes=60), now=START) == 0
+        assert run.status == "running"

{trace_agent_server-0.4.0 → trace_agent_server-0.6.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"

trace_agent_server-0.6.0/tests/test_stored_redaction.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+from fastapi.testclient import TestClient
+
+from trace_agent_sdk import TraceAgentClient
+from trace_agent_server.config import Settings
+from trace_agent_server.main import create_app
+from trace_agent_server.models import Event, Turn
+from trace_agent_server.services.provider import ProviderToolCall, ProviderTurnRequest, ProviderTurnResponse
+from trace_agent_server.services.stored_redaction import redact_messages, redact_tool_calls
+
+SECRET = "SECRET-KEY-123"
+CARD = "4111111111111111"
+
+
+class ChargingProvider:
+    """Asks for the `charge` tool once, then answers. Keeps what it was sent."""
+
+    provider_name = "openai"
+
+    def __init__(self) -> None:
+        self.seen: list[list[dict]] = []
+
+    def generate_turn(self, request: ProviderTurnRequest) -> ProviderTurnResponse:
+        self.seen.append(request.messages)
+        if not any(m.get("role") == "tool" for m in request.messages):
+            return ProviderTurnResponse(
+                assistant_message={
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [
+                        {"id": "call_1", "type": "function", "function": {"name": "charge", "arguments": json.dumps({"customer": "ana", "api_key": SECRET})}}
+                    ],
+                },
+                tool_calls=[ProviderToolCall(id="call_1", name="charge", arguments={"customer": "ana", "api_key": SECRET}, step_id="step-1")],
+                summary="calls charge",
+            )
+        return ProviderTurnResponse(assistant_message={"role": "assistant", "content": "Charged."}, summary="Charged.")
+
+
+@pytest.fixture
+def provider() -> ChargingProvider:
+    return ChargingProvider()
+
+
+@pytest.fixture
+def client(tmp_path, provider) -> TestClient:
+    app = create_app(Settings(database_url=f"sqlite:///{tmp_path / 'test.db'}", cors_origins=["http://localhost:5173"]))
+    app.state.provider_registry = {"openai": provider}
+    return TestClient(app)
+
+
+def everything_stored(client: TestClient) -> str:
+    with client.app.state.session_factory() as session:
+        events = [(e.summary, e.payload_full, e.event_metadata) for e in session.query(Event).all()]
+        turns = [(t.messages, t.assistant_message, t.tool_calls) for t in session.query(Turn).all()]
+    return json.dumps([events, turns], default=str)
+
+
+class TestToolRedactionOnStoredData:
+    def run_agent(self, client: TestClient, redact_fields: list[str]):
+        run = TraceAgentClient("http://testserver", http_client=client).start_run("billing", "Charge ana")
+        received: dict = {}
+
+        @run.tool(name="charge", description="Charge a customer.", redact_fields=redact_fields)
+        def charge(customer: str, api_key: str) -> dict:
+            received["args"] = {"customer": customer, "api_key": api_key}
+            return {"ok": True, "customer": customer, "card": CARD}
+
+        result = run.create_model_turn([{"role": "user", "content": "Charge ana"}], model="m")
+        run.finish(result.assistant_message["content"])
+        return received, result
+
+    def test_nothing_sensitive_is_stored_anywhere(self, client, provider) -> None:
+        self.run_agent(client, ["api_key", "card"])
+
+        stored = everything_stored(client)
+        assert SECRET not in stored
+        assert CARD not in stored
+        assert "[redacted]" in stored
+
+    def test_the_tool_and_the_model_still_get_the_real_data(self, client, provider) -> None:
+        received, _ = self.run_agent(client, ["api_key", "card"])
+
+        assert received["args"] == {"customer": "ana", "api_key": SECRET}
+        tool_message = next(m for m in provider.seen[-1] if m.get("role") == "tool")
+        assert CARD in tool_message["content"]
+
+    def test_the_agent_is_handed_the_real_tool_call_arguments(self, client, provider) -> None:
+        _, result = self.run_agent(client, ["api_key", "card"])
+
+        assert result.executed_tools[0]["status"] == "succeeded"
+
+    def test_without_redact_fields_the_data_is_stored_as_before(self, client, provider) -> None:
+        self.run_agent(client, [])
+
+        assert SECRET in everything_stored(client)
+
+    def test_other_values_are_kept_in_full(self, client, provider) -> None:
+        self.run_agent(client, ["api_key"])
+
+        stored = everything_stored(client)
+        assert "ana" in stored
+        assert CARD in stored  # `card` was not listed, so it is not masked
+
+
+class TestRedactMessages:
+    def test_masks_the_arguments_of_a_call_and_the_result_of_its_tool(self) -> None:
+        messages = [
+            {"role": "user", "content": "hi"},
+            {"role": "assistant", "content": None, "tool_calls": [{"id": "c1", "type": "function", "function": {"name": "charge", "arguments": json.dumps({"api_key": "k", "n": 1})}}]},
+            {"role": "tool", "tool_call_id": "c1", "content": json.dumps({"card": "4111", "ok": True})},
+        ]
+
+        masked = redact_messages(messages, {"charge": ["api_key", "card"]})
+
+        assert json.loads(masked[1]["tool_calls"][0]["function"]["arguments"]) == {"api_key": "[redacted]", "n": 1}
+        assert json.loads(masked[2]["content"]) == {"card": "[redacted]", "ok": True}
+        assert messages[2]["content"] == json.dumps({"card": "4111", "ok": True})  # the original is untouched
+
+    def test_a_tool_without_redact_fields_and_plain_text_are_left_alone(self) -> None:
+        messages = [
+            {"role": "assistant", "tool_calls": [{"id": "c1", "function": {"name": "other", "arguments": '{"a": 1}'}}]},
+            {"role": "tool", "tool_call_id": "c1", "content": "plain text"},
+        ]
+
+        assert redact_messages(messages, {"charge": ["api_key"]}) == messages
+        assert redact_messages(messages, {}) is messages
+
+    def test_accents_survive_the_masking(self) -> None:
+        messages = [
+            {"role": "assistant", "tool_calls": [{"id": "c1", "function": {"name": "t", "arguments": json.dumps({"pw": "x", "msg": "bajó"}, ensure_ascii=False)}}]},
+        ]
+
+        masked = redact_messages(messages, {"t": ["pw"]})
+
+        assert "bajó" in masked[0]["tool_calls"][0]["function"]["arguments"]
+
+
+class TestRedactToolCalls:
+    def test_masks_the_arguments_of_the_listed_tools(self) -> None:
+        calls = [{"id": "c1", "name": "charge", "arguments": {"api_key": "k", "n": 1}, "step_id": "s"}]
+
+        assert redact_tool_calls(calls, {"charge": ["api_key"]})[0]["arguments"] == {"api_key": "[redacted]", "n": 1}
+        assert calls[0]["arguments"]["api_key"] == "k"