langgraph-ledger 0.2.0__tar.gz

langgraph_ledger-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hty8870
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langgraph_ledger-0.2.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: langgraph-ledger
+Version: 0.2.0
+Summary: Full, tamper-evident traceability for LangGraph agents — a port of DeepSeek Harness (dsh)'s traceability design: hash-chained, content-addressed, replayable, rewindable.
+License: MIT
+Project-URL: Homepage, https://github.com/hty8870/langgraph-ledger
+Project-URL: Repository, https://github.com/hty8870/langgraph-ledger
+Keywords: langgraph,agent,traceability,audit,hash-chain,checkpoint,rollback,replay,dsh,deepseek-harness,ledger,agent-observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langgraph-checkpoint>=2.0
+Requires-Dist: langchain-core>=0.3
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: langgraph>=0.2; extra == "test"
+Dynamic: license-file
+
+# langgraph-ledger
+
+**Full, tamper-evident traceability for LangGraph agents** — a port of DeepSeek Harness (dsh)'s traceability design: content-addressed labels on every tool call, a hash-chained append-only event ledger, the execution DAG, replay, crash recovery, and first-class fork/rollback.
+
+[English](README.md) · [中文](README.zh.md)
+
+## Why
+
+LangGraph already checkpoints state and can time-travel. What it does *not* give you is an **audit-grade record**: were these events edited after the fact? Which tool call exactly — same name, or same *content*? What did the run look like as a graph, and can I fork from any point of it?
+
+This plugin ports the traceability design of [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) — append-only session log as the single source of truth, format versioning, fork lineage — onto LangGraph's checkpointer contract, and adds what neither has out of the box: **content hashing**.
+
+The combination is the point:
+
+| Capability | Mechanism |
+|---|---|
+| Tool-call identity | content-addressed label `tl_<hash>` — same (name, input) ⇒ same label |
+| Tamper evidence | every event hash-chained to its predecessor (merkle-style) |
+| Execution structure | DAG over chain + call/result + checkpoint-parent edges |
+| Rollback | `time_travel_config` (native fork) and `fork_thread` (dsh-style seeded fork with lineage event) |
+| Failure analysis | error timeline, exact-repeat loop detection (falls out of the labels) |
+| Verification | `verify_log` re-checks the chain; `verify_thread` re-hashes stored checkpoints against logged claims |
+
+## Differentiation (as of 2026-08)
+
+Honest snapshot of the neighborhood — see [POSITIONING](docs/positioning.md) for details:
+
+| Project | Hash chain | Execution DAG | State rollback/fork | LangGraph-native |
+|---|---|---|---|---|
+| **langgraph-ledger** | ✅ | ✅ | ✅ | ✅ (checkpointer drop-in) |
+| LangSmith / Langfuse / AgentOps | ✗ (hosted observability) | trace view | ✗ | SDK |
+| CONTINUUM | ✅ | ✗ | crash recovery focus | ✗ (MCP server) |
+| burnout / VeritasAgent / memtrail | ✅ | ✗ | ✗ | partial |
+| langgraph checkpointers (redis/mysql/…) | ✗ | parent links only | time-travel only | ✅ |
+
+Nobody else ships hash-labels + DAG + rollback as one LangGraph-native unit. That is the slot this project occupies.
+
+## Install
+
+```bash
+pip install langgraph-ledger
+```
+
+## Quickstart
+
+```python
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph_ledger import TracingCheckpointSaver, DshTraceCallbackHandler
+
+saver = TracingCheckpointSaver(InMemorySaver(), trace_root="./traces")
+graph = builder.compile(checkpointer=saver)          # your graph, unchanged
+
+graph.invoke(input, config={
+    "configurable": {"thread_id": "run-42"},
+    "callbacks": [DshTraceCallbackHandler()],         # LLM/tool/node events
+})
+```
+
+Every run now leaves `./traces/run-42.jsonl` — one hash-chained JSON event per line:
+
+```json
+{"v":0,"seq":7,"ts":"…","kind":"tool/call","payload":{"label":"tl_9f2e…","name":"search",…},"id":"…","prev":"…"}
+{"v":0,"seq":8,"ts":"…","kind":"state/snapshot","payload":{"checkpoint_id":"…","label":"cp_2c01…","parent_checkpoint_id":"…","checkpoint_sha256":"…"},"id":"…","prev":"…"}
+```
+
+### Rollback & fork
+
+```python
+from langgraph_ledger import time_travel_config, fork_thread
+
+# resume/fork from any recorded checkpoint (LangGraph-native time travel)
+cfg = time_travel_config("run-42", checkpoint_id="<past-id>")
+graph.update_state(cfg, {"count": 100})              # forks from that point
+
+# dsh-style: a new thread seeded with the ancestry up to a checkpoint
+new_tid = fork_thread(saver, "run-42", at_checkpoint_id="<past-id>")
+```
+
+### Audit
+
+```bash
+python -m langgraph_ledger verify  traces/run-42.jsonl   # hash chain intact?
+python -m langgraph_ledger analyze traces/run-42.jsonl   # errors, loops, timeline
+python -m langgraph_ledger dag     traces/run-42.jsonl --mermaid
+python -m langgraph_ledger repair  traces/               # close crash-orphaned runs
+python -m langgraph_ledger replay  traces/run-42.jsonl   # rebuild the message timeline
+```
+
+```python
+from langgraph_ledger import verify_thread
+report = verify_thread(saver, "traces/run-42.jsonl")  # stored state == logged claim?
+assert report["ok"]
+```
+
+### Crash recovery & replay
+
+If the process dies mid-run, the log ends with an unclosed `run/start`.
+`verify` flags it as an *open run*; `repair` appends an honest
+`run/end {status: "interrupted"}` through the hash chain (idempotent, never
+rewrites history). `replay_messages()` rebuilds the conversation timeline from
+the log — digests by default, full text when the handler was created with
+`record_full=True`. For fail-closed operation (a run that cannot record must
+not proceed), use `TraceRecorder(..., strict=True)`.
+
+## Design mapping from DeepSeek Harness
+
+A design study, not a port of code (dsh is TypeScript/Node; this is Python/LangGraph):
+
+| dsh concept | here |
+|---|---|
+| `SessionEvent` append-only log, single source of truth | one hash-chained JSONL per thread |
+| `SESSION_FORMAT_VERSION` + `ignorable` marker | `v` field; unknown kinds counted, not rejected |
+| turn / step hierarchy | `run/*` / `node/*` events |
+| `parentSession` + `seedLength` fork lineage | `fork` event payload |
+| `sourceEventSeqs` provenance | DAG edges: chain, call→result, snapshot→parent |
+| Model-Visible ⟺ Logged invariant | payload digests (sha256 + head); `strict=True` enforces fail-closed recording |
+| crash-orphaned turns closed as `interrupted` on reload | `repair` — appends `run/end {status: interrupted}` through the hash chain |
+| `deriveMessages` (log → conversation) | `replay_messages` — digests or full text (`record_full=True`) |
+| fail-closed invariants | append-time strict JSON validation; `verify_*` refuse on mismatch |
+
+Deliberate deviations: prompt/response full text is **not** stored by default (digest only, opt-in via `record_full=True`); dsh's byte-level replay and compaction are out of scope.
+
+## What it is NOT
+
+- Not a hosted observability platform — the log is a local file you own.
+- Not byte-level replay of model streams — it is for error localization, audit and state rollback.
+- Rollback restores *agent state*; side effects your tools made in the world are yours to undo (pair tool calls with your own preimages if you need that).
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest tests/
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

langgraph_ledger-0.2.0/README.md

@@ -0,0 +1,138 @@
+# langgraph-ledger
+
+**Full, tamper-evident traceability for LangGraph agents** — a port of DeepSeek Harness (dsh)'s traceability design: content-addressed labels on every tool call, a hash-chained append-only event ledger, the execution DAG, replay, crash recovery, and first-class fork/rollback.
+
+[English](README.md) · [中文](README.zh.md)
+
+## Why
+
+LangGraph already checkpoints state and can time-travel. What it does *not* give you is an **audit-grade record**: were these events edited after the fact? Which tool call exactly — same name, or same *content*? What did the run look like as a graph, and can I fork from any point of it?
+
+This plugin ports the traceability design of [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) — append-only session log as the single source of truth, format versioning, fork lineage — onto LangGraph's checkpointer contract, and adds what neither has out of the box: **content hashing**.
+
+The combination is the point:
+
+| Capability | Mechanism |
+|---|---|
+| Tool-call identity | content-addressed label `tl_<hash>` — same (name, input) ⇒ same label |
+| Tamper evidence | every event hash-chained to its predecessor (merkle-style) |
+| Execution structure | DAG over chain + call/result + checkpoint-parent edges |
+| Rollback | `time_travel_config` (native fork) and `fork_thread` (dsh-style seeded fork with lineage event) |
+| Failure analysis | error timeline, exact-repeat loop detection (falls out of the labels) |
+| Verification | `verify_log` re-checks the chain; `verify_thread` re-hashes stored checkpoints against logged claims |
+
+## Differentiation (as of 2026-08)
+
+Honest snapshot of the neighborhood — see [POSITIONING](docs/positioning.md) for details:
+
+| Project | Hash chain | Execution DAG | State rollback/fork | LangGraph-native |
+|---|---|---|---|---|
+| **langgraph-ledger** | ✅ | ✅ | ✅ | ✅ (checkpointer drop-in) |
+| LangSmith / Langfuse / AgentOps | ✗ (hosted observability) | trace view | ✗ | SDK |
+| CONTINUUM | ✅ | ✗ | crash recovery focus | ✗ (MCP server) |
+| burnout / VeritasAgent / memtrail | ✅ | ✗ | ✗ | partial |
+| langgraph checkpointers (redis/mysql/…) | ✗ | parent links only | time-travel only | ✅ |
+
+Nobody else ships hash-labels + DAG + rollback as one LangGraph-native unit. That is the slot this project occupies.
+
+## Install
+
+```bash
+pip install langgraph-ledger
+```
+
+## Quickstart
+
+```python
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph_ledger import TracingCheckpointSaver, DshTraceCallbackHandler
+
+saver = TracingCheckpointSaver(InMemorySaver(), trace_root="./traces")
+graph = builder.compile(checkpointer=saver)          # your graph, unchanged
+
+graph.invoke(input, config={
+    "configurable": {"thread_id": "run-42"},
+    "callbacks": [DshTraceCallbackHandler()],         # LLM/tool/node events
+})
+```
+
+Every run now leaves `./traces/run-42.jsonl` — one hash-chained JSON event per line:
+
+```json
+{"v":0,"seq":7,"ts":"…","kind":"tool/call","payload":{"label":"tl_9f2e…","name":"search",…},"id":"…","prev":"…"}
+{"v":0,"seq":8,"ts":"…","kind":"state/snapshot","payload":{"checkpoint_id":"…","label":"cp_2c01…","parent_checkpoint_id":"…","checkpoint_sha256":"…"},"id":"…","prev":"…"}
+```
+
+### Rollback & fork
+
+```python
+from langgraph_ledger import time_travel_config, fork_thread
+
+# resume/fork from any recorded checkpoint (LangGraph-native time travel)
+cfg = time_travel_config("run-42", checkpoint_id="<past-id>")
+graph.update_state(cfg, {"count": 100})              # forks from that point
+
+# dsh-style: a new thread seeded with the ancestry up to a checkpoint
+new_tid = fork_thread(saver, "run-42", at_checkpoint_id="<past-id>")
+```
+
+### Audit
+
+```bash
+python -m langgraph_ledger verify  traces/run-42.jsonl   # hash chain intact?
+python -m langgraph_ledger analyze traces/run-42.jsonl   # errors, loops, timeline
+python -m langgraph_ledger dag     traces/run-42.jsonl --mermaid
+python -m langgraph_ledger repair  traces/               # close crash-orphaned runs
+python -m langgraph_ledger replay  traces/run-42.jsonl   # rebuild the message timeline
+```
+
+```python
+from langgraph_ledger import verify_thread
+report = verify_thread(saver, "traces/run-42.jsonl")  # stored state == logged claim?
+assert report["ok"]
+```
+
+### Crash recovery & replay
+
+If the process dies mid-run, the log ends with an unclosed `run/start`.
+`verify` flags it as an *open run*; `repair` appends an honest
+`run/end {status: "interrupted"}` through the hash chain (idempotent, never
+rewrites history). `replay_messages()` rebuilds the conversation timeline from
+the log — digests by default, full text when the handler was created with
+`record_full=True`. For fail-closed operation (a run that cannot record must
+not proceed), use `TraceRecorder(..., strict=True)`.
+
+## Design mapping from DeepSeek Harness
+
+A design study, not a port of code (dsh is TypeScript/Node; this is Python/LangGraph):
+
+| dsh concept | here |
+|---|---|
+| `SessionEvent` append-only log, single source of truth | one hash-chained JSONL per thread |
+| `SESSION_FORMAT_VERSION` + `ignorable` marker | `v` field; unknown kinds counted, not rejected |
+| turn / step hierarchy | `run/*` / `node/*` events |
+| `parentSession` + `seedLength` fork lineage | `fork` event payload |
+| `sourceEventSeqs` provenance | DAG edges: chain, call→result, snapshot→parent |
+| Model-Visible ⟺ Logged invariant | payload digests (sha256 + head); `strict=True` enforces fail-closed recording |
+| crash-orphaned turns closed as `interrupted` on reload | `repair` — appends `run/end {status: interrupted}` through the hash chain |
+| `deriveMessages` (log → conversation) | `replay_messages` — digests or full text (`record_full=True`) |
+| fail-closed invariants | append-time strict JSON validation; `verify_*` refuse on mismatch |
+
+Deliberate deviations: prompt/response full text is **not** stored by default (digest only, opt-in via `record_full=True`); dsh's byte-level replay and compaction are out of scope.
+
+## What it is NOT
+
+- Not a hosted observability platform — the log is a local file you own.
+- Not byte-level replay of model streams — it is for error localization, audit and state rollback.
+- Rollback restores *agent state*; side effects your tools made in the world are yours to undo (pair tool calls with your own preimages if you need that).
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest tests/
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

langgraph_ledger-0.2.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langgraph-ledger"
+version = "0.2.0"
+description = "Full, tamper-evident traceability for LangGraph agents — a port of DeepSeek Harness (dsh)'s traceability design: hash-chained, content-addressed, replayable, rewindable."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["langgraph", "agent", "traceability", "audit", "hash-chain", "checkpoint", "rollback", "replay", "dsh", "deepseek-harness", "ledger", "agent-observability"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: System :: Logging",
+]
+dependencies = [
+    "langgraph-checkpoint>=2.0",
+    "langchain-core>=0.3",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "langgraph>=0.2"]
+
+[project.urls]
+Homepage = "https://github.com/hty8870/langgraph-ledger"
+Repository = "https://github.com/hty8870/langgraph-ledger"
+
+[project.scripts]
+langgraph-ledger = "langgraph_ledger.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+langgraph_ledger = ["py.typed"]

langgraph_ledger-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langgraph_ledger-0.2.0/src/langgraph_ledger/__init__.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""Public API of langgraph-ledger."""
+from __future__ import annotations
+
+from .analysis import analyze_log
+from .callbacks import DshTraceCallbackHandler
+from .checkpointer import TracingCheckpointSaver
+from .dag import RunDAG, build_dag, build_dag_from_file
+from .events import EVENT_KINDS, FORMAT_VERSION
+from .hashing import (canonical_json, checkpoint_label, event_id, sha256_hex,
+                      tool_call_label)
+from .recorder import (TracePayloadError, TraceRecorder, active_recorder,
+                       bind_recorder, current_recorder, emit_event, read_log,
+                       recorder_for)
+from .repair import close_orphaned_run, find_orphaned_runs, repair_all
+from .replay import ReplayError, replay_messages
+from .rollback import find_checkpoint_by_label, fork_thread, time_travel_config
+from .verify import VerifyReport, verify_log, verify_thread
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "__version__",
+    # recording
+    "TraceRecorder", "TracePayloadError", "bind_recorder", "current_recorder",
+    "active_recorder", "emit_event", "read_log", "recorder_for",
+    # integration
+    "TracingCheckpointSaver", "DshTraceCallbackHandler",
+    # labels / hashing
+    "canonical_json", "sha256_hex", "event_id", "tool_call_label",
+    "checkpoint_label", "EVENT_KINDS", "FORMAT_VERSION",
+    # dag / rollback / audit
+    "RunDAG", "build_dag", "build_dag_from_file",
+    "fork_thread", "time_travel_config", "find_checkpoint_by_label",
+    "verify_log", "verify_thread", "VerifyReport", "analyze_log",
+    # crash recovery / replay
+    "find_orphaned_runs", "close_orphaned_run", "repair_all",
+    "replay_messages", "ReplayError",
+]

langgraph_ledger-0.2.0/src/langgraph_ledger/__main__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""Enable `python -m langgraph_ledger <command>`."""
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

langgraph_ledger-0.2.0/src/langgraph_ledger/analysis.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+"""Failure analysis over a recorded log.
+
+Because every tool call carries a content-addressed label, exact-repeat loops
+(the agent calling the same tool with the same input over and over) fall out
+for free. Combined with error events and node timings this gives a compact
+first-stop failure report:
+
+    python -m langgraph_ledger analyze <log.jsonl>
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from . import events as ev
+from .recorder import read_log
+
+__all__ = ["analyze_log"]
+
+
+def analyze_log(path: str | Path) -> dict[str, Any]:
+    """Summarize one thread log: counts, errors, loops, timeline, checkpoints."""
+    by_kind: dict[str, int] = {}
+    errors: list[dict[str, Any]] = []
+    tool_labels: dict[str, dict[str, Any]] = {}
+    checkpoints = 0
+    interrupted_runs = 0
+    models: dict[str, int] = {}
+    node_ms: dict[str, int] = {}
+    first_ts: str | None = None
+    last_ts: str | None = None
+    unknown: dict[str, int] = {}
+
+    prev_call_label: str | None = None
+    streaks: list[dict[str, Any]] = []
+    streak: dict[str, Any] | None = None
+
+    for e in read_log(path):
+        kind = str(e.get("kind") or "")
+        payload = e.get("payload") or {}
+        seq = e.get("seq")
+        first_ts = first_ts or e.get("ts")
+        last_ts = e.get("ts") or last_ts
+        if kind in ev.EVENT_KINDS:
+            by_kind[kind] = by_kind.get(kind, 0) + 1
+        else:
+            unknown[kind] = unknown.get(kind, 0) + 1
+
+        if kind == ev.KIND_TOOL_CALL:
+            label = str(payload.get("label") or "")
+            name = str(payload.get("name") or "")
+            slot = tool_labels.setdefault(label, {"name": name, "count": 0, "seqs": []})
+            slot["count"] += 1
+            slot["seqs"].append(seq)
+            if label == prev_call_label:
+                if streak is None:
+                    streak = {"label": label, "name": name, "start_seq": seq, "length": 2}
+                else:
+                    streak["length"] += 1
+            else:
+                if streak is not None:
+                    streaks.append(streak)
+                    streak = None
+            prev_call_label = label
+        elif kind == ev.KIND_TOOL_RESULT:
+            if not payload.get("ok"):
+                errors.append({"seq": seq, "kind": kind,
+                               "name": payload.get("name"),
+                               "error": payload.get("error")})
+        elif kind == ev.KIND_LLM_CALL and payload.get("error"):
+            errors.append({"seq": seq, "kind": kind, "node": payload.get("node"),
+                           "error": payload.get("error")})
+        if kind == ev.KIND_LLM_CALL and payload.get("model"):
+            m = str(payload["model"])
+            models[m] = models.get(m, 0) + 1
+        elif kind == ev.KIND_NODE_END and not payload.get("ok", True):
+            errors.append({"seq": seq, "kind": kind, "run_id": payload.get("run_id"),
+                           "error": payload.get("error")})
+        if kind == ev.KIND_NODE_END and payload.get("node"):
+            node = str(payload["node"])
+            node_ms[node] = node_ms.get(node, 0) + int(payload.get("ms") or 0)
+        elif kind == ev.KIND_RUN_END and payload.get("status") == "interrupted":
+            interrupted_runs += 1
+        elif kind == ev.KIND_ERROR:
+            errors.append({"seq": seq, "kind": kind, "where": payload.get("where"),
+                           "error": payload.get("error")})
+        elif kind == ev.KIND_STATE_SNAPSHOT:
+            checkpoints += 1
+            prev_call_label = None
+
+    if streak is not None:
+        streaks.append(streak)
+
+    loops = [{"label": k, "name": v["name"], "count": v["count"], "seqs": v["seqs"]}
+             for k, v in tool_labels.items() if v["count"] > 1]
+
+    return {
+        "log": str(path),
+        "events": sum(by_kind.values()) + sum(unknown.values()),
+        "by_kind": by_kind,
+        "unknown_kinds": unknown,
+        "checkpoints": checkpoints,
+        "interrupted_runs": interrupted_runs,
+        "models": models,
+        "node_time_ms": node_ms,
+        "errors": errors,
+        "error_count": len(errors),
+        "repeated_tool_calls": loops,
+        "consecutive_repeat_streaks": streaks,
+        "first_ts": first_ts,
+        "last_ts": last_ts,
+    }