semantic-trace 0.1.0__tar.gz

semantic_trace-0.1.0/.gitignore

@@ -0,0 +1,48 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Ruff
+.ruff_cache/
+
+# Trace output files (uncomment to ignore)
+# traces/
+# *.jsonl
+
+# Misc
+=

semantic_trace-0.1.0/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-04-07
+
+Initial release.
+
+### Added
+- Core Pydantic models: `TraceModel`, `Span`, `IntentInvariant`, `TraceMetadata`
+- `Trace` context manager for simplified capture workflow with auto-serialization
+- `ReplayReport` class with `.summary()`, `.print_violations()`, `.is_clean`, `.pass_rate`
+- `InvariantResult` dataclass for per-invariant check details
+- Enum types: `InvariantType`, `ActionType`
+- JSONL serialization with orjson and file locking
+- Built-in invariant checkers: `SchemaInvariantChecker`, `SubstringInvariantChecker`, `LLMAsJudgeChecker`
+- `BaseInvariantChecker` ABC for custom checkers
+- Mechanical replay (structural validation)
+- Semantic replay (invariant checking)
+- `validate_trace()` for combined mechanical + semantic validation
+- LangGraph callback handler integration
+- CLI with `info`, `validate`, `replay`, `spans` commands and `--json` output
+- Optional extras: `langgraph`, `llm-judge`, `dev`
+- Comprehensive test suite (71 tests)
+- GitHub Actions CI workflow
+
+[Unreleased]: https://github.com/sznmelvin/agent-trace/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/sznmelvin/agent-trace/releases/tag/v0.1.0

semantic_trace-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,85 @@
+# Contributing to agent-trace
+
+Thank you for your interest in contributing! agent-trace is built on the belief that AI agent observability should be simple, composable, and open. Every contribution, whether a typo fix, a new checker, or a full integration, is welcome.
+
+## How to Contribute
+
+### Reporting Bugs
+
+- Check the [issue tracker](https://github.com/sznmelvin/agent-trace/issues) to see if it's already reported.
+- Open a new issue with a clear title, description, and minimal reproduction if possible.
+- Include your Python version and `agent-trace` version.
+
+### Suggesting Features
+
+- Open an issue with the label `enhancement`.
+- Describe the problem you're trying to solve, not just the solution you have in mind.
+- Keep scope focused; agent-trace values minimalism.
+
+### Pull Requests
+
+1. **Fork** the repository and create your branch from `main`.
+2. **Install dev dependencies**:
+   ```bash
+   pip install -e ".[dev]"
+   ```
+3. **Make your changes** with clear, minimal code and docstrings.
+4. **Add tests** for new functionality. We use pytest.
+5. **Run the checks**:
+   ```bash
+   ruff check src/agent_trace/ tests/ examples/
+   ruff format src/agent_trace/ tests/ examples/
+   pytest tests/ -v
+   ```
+6. **Open a PR** with a clear description of what and why.
+
+## Code Style
+
+- Follow [PEP 8](https://peps.python.org/pep-0008/) conventions.
+- Use [ruff](https://github.com/astral-sh/ruff) for linting and formatting.
+- Line length: 88 characters.
+- Type hints on all public functions and methods.
+- Docstrings on all public classes and functions.
+
+## Design Principles
+
+1. **Minimalism first**: If it can be one line, don't make it three.
+2. **No hidden magic**: What you see is what you get. No metaclass sorcery.
+3. **Composable**: Small pieces that work well together.
+4. **Backward compatible**: Don't break existing code without a major version bump.
+5. **Zero unnecessary dependencies**: Core is `pydantic` + `orjson`. Everything else is optional.
+
+## Development Setup
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/agent-trace.git
+cd agent-trace
+
+# Create a virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install in editable mode with dev deps
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+
+# Run linter
+ruff check src/agent_trace/ tests/ examples/
+```
+
+## Adding a New Invariant Checker
+
+If you want to contribute a new built-in checker:
+
+1. Add the checker class to `src/agent_trace/engine/invariants.py`.
+2. Register it in `CHECKER_REGISTRY` with a new `InvariantType` (or reuse an existing one).
+3. Add the type to the `InvariantType` enum in `src/agent_trace/core/schema.py`.
+4. Write tests in `tests/test_invariants.py`.
+5. Update the README invariant types table.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.

semantic_trace-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 melvin
+
+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.

semantic_trace-0.1.0/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: semantic-trace
+Version: 0.1.0
+Summary: Semantic tracing primitive for AI agents
+Project-URL: Homepage, https://github.com/sznmelvin/agent-trace
+Project-URL: Repository, https://github.com/sznmelvin/agent-trace
+Project-URL: Documentation, https://github.com/sznmelvin/agent-trace#readme
+Author: Trace Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,drift-detection,invariants,observability,replay,tracing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: orjson>=3.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.2.0; extra == 'langgraph'
+Provides-Extra: llm-judge
+Requires-Dist: httpx>=0.27; extra == 'llm-judge'
+Description-Content-Type: text/markdown
+
+# agent-trace
+
+[![PyPI - Version](https://img.shields.io/pypi/v/semantic-trace.svg?logo=pypi&labelColor=555555)](https://pypi.org/project/semantic-trace/)
+[![Python - Versions](https://img.shields.io/pypi/pyversions/semantic-trace.svg?logo=python&labelColor=555555)](https://pypi.org/project/semantic-trace/)
+[![License - MIT](https://img.shields.io/pypi/l/agent-trace.svg?logo=github&labelColor=555555)](https://github.com/sznmelvin/agent-trace/blob/main/LICENSE)
+[![CI](https://github.com/sznmelvin/agent-trace/actions/workflows/ci.yml/badge.svg)](https://github.com/sznmelvin/agent-trace/actions/workflows/ci.yml)
+
+**Semantic tracing primitive for AI agents.**
+
+Intent-anchored execution. Deterministic replay. Runtime drift detection.
+
+---
+
+## Philosophy
+
+Existing observability tools log **what** happened: every keystroke, token, and HTTP request. But they don't capture **intent**.
+
+agent-trace flips this. Instead of dumping raw logs, you attach *invariants* to your agent's actions:
+
+> "This LLM call should return a JSON object with `action` and `params` keys."
+> "This tool output must contain the substring `success`."
+
+When the agent runs, those invariants travel with the trace. Later, you replay the trace and check whether every invariant still holds. If a model upgrade, prompt change, or tool regression breaks an invariant, you catch it immediately.
+
+**agent-trace is a primitive, not a platform.** No web servers. No databases. No UI frameworks. Just strictly-typed Python data structures and JSONL files you can version-control, diff, and grep.
+
+## Installation
+
+```bash
+pip install semantic-trace
+```
+
+With optional integrations:
+
+```bash
+pip install semantic-trace[langgraph]    # LangGraph callback handler
+pip install semantic-trace[llm-judge]    # LLM-as-Judge invariant checker
+pip install semantic-trace[dev]          # pytest + ruff for contributors
+```
+
+## Quick Start
+
+```python
+from agent_trace import Trace, IntentInvariant, InvariantType, semantic_replay
+
+# 1. Define invariants: what your agent's output MUST satisfy
+invariants = [
+    IntentInvariant(
+        id="valid-json",
+        description="Output must be valid JSON with 'summary' key",
+        invariant_type=InvariantType.SUBSTRING_CHECK,
+        config={"substring": '"summary"'},
+        fidelity_threshold=1.0,
+    ),
+    IntentInvariant(
+        id="no-hallucination",
+        description="Must not invent fake citations",
+        invariant_type=InvariantType.LLM_AS_JUDGE,
+        config={"api_key": "your-key", "model": "qwen/qwen3.6-plus:free"},
+        fidelity_threshold=0.85,
+    ),
+]
+
+# 2. Capture trace: invariants auto-attach to every span
+with Trace(
+    name="research-assistant",
+    invariants=invariants,
+    output_file="traces/run.jsonl",
+) as trace:
+    # Your agent code here (LangGraph, CrewAI, custom, etc.)
+    # Spans are captured automatically via integrations
+    # or manually:
+    from agent_trace import Span, ActionType
+
+    trace.add_span(Span(
+        trace_id=trace.trace_id,
+        action_type=ActionType.LLM_CALL,
+        input_data={"prompt": "Summarize this document..."},
+        output_data={"summary": "The document discusses..."},
+        duration_ms=342.0,
+    ))
+
+# 3. Later: replay and check all invariants
+report = semantic_replay("traces/run.jsonl")
+print(report.summary())
+report.print_violations()
+```
+
+## Why agent-trace?
+
+| Problem | agent-trace solution |
+|---------|---------------------|
+| Agent behavior changes silently after a model upgrade | Replay old traces with invariants to catch regressions |
+| No way to codify "what good looks like" for agent output | Attach invariants as executable specifications |
+| Observability platforms are expensive and complex | JSONL files you own, version-control, and grep |
+| Testing agents is hard and non-deterministic | Semantic replay checks intent, not exact output |
+
+## Invariant Types
+
+| Type | What it does | Config |
+|------|-------------|--------|
+| `SUBSTRING_CHECK` | Checks for a target substring in JSON output | `{"substring": "..."}` |
+| `SCHEMA_MATCH` | Validates output against a Pydantic type | `{"schema": dict[str, str]}` |
+| `LLM_AS_JUDGE` | Uses an LLM to semantically evaluate | `{"api_key": "...", "model": "..."}` |
+| `CUSTOM` | Your own checker via `BaseInvariantChecker` | Any |
+
+## CLI
+
+```bash
+# Show trace metadata
+trace info traces/run.jsonl
+
+# Structural validation
+trace validate traces/run.jsonl
+
+# Full semantic replay (mechanical + invariant checks)
+trace replay traces/run.jsonl
+
+# List all spans with durations
+trace spans traces/run.jsonl
+
+# Machine-readable JSON output
+trace replay traces/run.jsonl --json
+```
+
+## Architecture
+
+```
+agent-trace/
+├── src/agent_trace/
+│   ├── __init__.py              # Public API re-exports
+│   ├── cli.py                   # `trace` CLI entry point
+│   ├── core/
+│   │   ├── schema.py            # Pydantic models + Trace context manager
+│   │   └── serializer.py        # JSONL read/write with orjson + file locking
+│   ├── engine/
+│   │   ├── invariants.py        # ABC + built-in checkers
+│   │   └── replay.py            # Mechanical + semantic replay
+│   └── integrations/
+│       └── langgraph.py         # Lazy-loaded LangGraph callback handler
+├── examples/
+│   ├── minimal_demo.py          # Full workflow demo
+│   └── drift_detection_demo.py  # Catching regressions with replay
+├── tests/                       # Comprehensive test suite
+├── pyproject.toml
+└── README.md
+```
+
+## Examples
+
+- [**minimal_demo.py**](examples/minimal_demo.py): Complete workflow: define invariants, capture trace, replay
+- [**drift_detection_demo.py**](examples/drift_detection_demo.py): Simulate a model regression and catch it with semantic replay
+
+## Extending
+
+### Custom Checker
+
+Write your own checker by subclassing `BaseInvariantChecker`:
+
+```python
+from agent_trace import BaseInvariantChecker, Span, IntentInvariant
+
+class EmbeddingSimilarityChecker(BaseInvariantChecker):
+    def check(self, span: Span, invariant: IntentInvariant) -> float:
+        # Your embedding-based logic here
+        expected = invariant.config["expected_embedding"]
+        actual = get_embedding(span.output_data["text"])
+        return cosine_similarity(expected, actual)
+```
+
+### LLM-as-Judge
+
+Use an LLM to semantically evaluate whether a span's output satisfies an invariant.
+Requires `pip install agent-trace[llm-judge]`.
+
+```python
+from agent_trace import IntentInvariant, InvariantType
+
+invariant = IntentInvariant(
+    id="quality-check",
+    description="The response should be helpful and well-structured",
+    invariant_type=InvariantType.LLM_AS_JUDGE,
+    config={
+        "api_key": "sk-or-your-key",
+        "model": "qwen/qwen3.6-plus:free",
+    },
+    fidelity_threshold=0.7,
+)
+```
+
+The judge sends the span context to an LLM (default: OpenRouter) and parses a
+structured JSON score. On any failure it returns `0.0` and logs a warning;
+it never crashes your replay pipeline.
+
+### LangGraph Integration
+
+```python
+from agent_trace.integrations.langgraph import TraceCallbackHandler
+
+handler = TraceCallbackHandler(
+    trace_file="traces/run.jsonl",
+    session_id="session-1",
+    agent_name="my-agent",
+    default_invariants=[invariant],
+)
+
+graph = create_react_agent(..., callbacks=[handler])
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, code style, and how to submit PRs.
+
+## License
+
+MIT

semantic_trace-0.1.0/README.md

@@ -0,0 +1,216 @@
+# agent-trace
+
+[![PyPI - Version](https://img.shields.io/pypi/v/semantic-trace.svg?logo=pypi&labelColor=555555)](https://pypi.org/project/semantic-trace/)
+[![Python - Versions](https://img.shields.io/pypi/pyversions/semantic-trace.svg?logo=python&labelColor=555555)](https://pypi.org/project/semantic-trace/)
+[![License - MIT](https://img.shields.io/pypi/l/agent-trace.svg?logo=github&labelColor=555555)](https://github.com/sznmelvin/agent-trace/blob/main/LICENSE)
+[![CI](https://github.com/sznmelvin/agent-trace/actions/workflows/ci.yml/badge.svg)](https://github.com/sznmelvin/agent-trace/actions/workflows/ci.yml)
+
+**Semantic tracing primitive for AI agents.**
+
+Intent-anchored execution. Deterministic replay. Runtime drift detection.
+
+---
+
+## Philosophy
+
+Existing observability tools log **what** happened: every keystroke, token, and HTTP request. But they don't capture **intent**.
+
+agent-trace flips this. Instead of dumping raw logs, you attach *invariants* to your agent's actions:
+
+> "This LLM call should return a JSON object with `action` and `params` keys."
+> "This tool output must contain the substring `success`."
+
+When the agent runs, those invariants travel with the trace. Later, you replay the trace and check whether every invariant still holds. If a model upgrade, prompt change, or tool regression breaks an invariant, you catch it immediately.
+
+**agent-trace is a primitive, not a platform.** No web servers. No databases. No UI frameworks. Just strictly-typed Python data structures and JSONL files you can version-control, diff, and grep.
+
+## Installation
+
+```bash
+pip install semantic-trace
+```
+
+With optional integrations:
+
+```bash
+pip install semantic-trace[langgraph]    # LangGraph callback handler
+pip install semantic-trace[llm-judge]    # LLM-as-Judge invariant checker
+pip install semantic-trace[dev]          # pytest + ruff for contributors
+```
+
+## Quick Start
+
+```python
+from agent_trace import Trace, IntentInvariant, InvariantType, semantic_replay
+
+# 1. Define invariants: what your agent's output MUST satisfy
+invariants = [
+    IntentInvariant(
+        id="valid-json",
+        description="Output must be valid JSON with 'summary' key",
+        invariant_type=InvariantType.SUBSTRING_CHECK,
+        config={"substring": '"summary"'},
+        fidelity_threshold=1.0,
+    ),
+    IntentInvariant(
+        id="no-hallucination",
+        description="Must not invent fake citations",
+        invariant_type=InvariantType.LLM_AS_JUDGE,
+        config={"api_key": "your-key", "model": "qwen/qwen3.6-plus:free"},
+        fidelity_threshold=0.85,
+    ),
+]
+
+# 2. Capture trace: invariants auto-attach to every span
+with Trace(
+    name="research-assistant",
+    invariants=invariants,
+    output_file="traces/run.jsonl",
+) as trace:
+    # Your agent code here (LangGraph, CrewAI, custom, etc.)
+    # Spans are captured automatically via integrations
+    # or manually:
+    from agent_trace import Span, ActionType
+
+    trace.add_span(Span(
+        trace_id=trace.trace_id,
+        action_type=ActionType.LLM_CALL,
+        input_data={"prompt": "Summarize this document..."},
+        output_data={"summary": "The document discusses..."},
+        duration_ms=342.0,
+    ))
+
+# 3. Later: replay and check all invariants
+report = semantic_replay("traces/run.jsonl")
+print(report.summary())
+report.print_violations()
+```
+
+## Why agent-trace?
+
+| Problem | agent-trace solution |
+|---------|---------------------|
+| Agent behavior changes silently after a model upgrade | Replay old traces with invariants to catch regressions |
+| No way to codify "what good looks like" for agent output | Attach invariants as executable specifications |
+| Observability platforms are expensive and complex | JSONL files you own, version-control, and grep |
+| Testing agents is hard and non-deterministic | Semantic replay checks intent, not exact output |
+
+## Invariant Types
+
+| Type | What it does | Config |
+|------|-------------|--------|
+| `SUBSTRING_CHECK` | Checks for a target substring in JSON output | `{"substring": "..."}` |
+| `SCHEMA_MATCH` | Validates output against a Pydantic type | `{"schema": dict[str, str]}` |
+| `LLM_AS_JUDGE` | Uses an LLM to semantically evaluate | `{"api_key": "...", "model": "..."}` |
+| `CUSTOM` | Your own checker via `BaseInvariantChecker` | Any |
+
+## CLI
+
+```bash
+# Show trace metadata
+trace info traces/run.jsonl
+
+# Structural validation
+trace validate traces/run.jsonl
+
+# Full semantic replay (mechanical + invariant checks)
+trace replay traces/run.jsonl
+
+# List all spans with durations
+trace spans traces/run.jsonl
+
+# Machine-readable JSON output
+trace replay traces/run.jsonl --json
+```
+
+## Architecture
+
+```
+agent-trace/
+├── src/agent_trace/
+│   ├── __init__.py              # Public API re-exports
+│   ├── cli.py                   # `trace` CLI entry point
+│   ├── core/
+│   │   ├── schema.py            # Pydantic models + Trace context manager
+│   │   └── serializer.py        # JSONL read/write with orjson + file locking
+│   ├── engine/
+│   │   ├── invariants.py        # ABC + built-in checkers
+│   │   └── replay.py            # Mechanical + semantic replay
+│   └── integrations/
+│       └── langgraph.py         # Lazy-loaded LangGraph callback handler
+├── examples/
+│   ├── minimal_demo.py          # Full workflow demo
+│   └── drift_detection_demo.py  # Catching regressions with replay
+├── tests/                       # Comprehensive test suite
+├── pyproject.toml
+└── README.md
+```
+
+## Examples
+
+- [**minimal_demo.py**](examples/minimal_demo.py): Complete workflow: define invariants, capture trace, replay
+- [**drift_detection_demo.py**](examples/drift_detection_demo.py): Simulate a model regression and catch it with semantic replay
+
+## Extending
+
+### Custom Checker
+
+Write your own checker by subclassing `BaseInvariantChecker`:
+
+```python
+from agent_trace import BaseInvariantChecker, Span, IntentInvariant
+
+class EmbeddingSimilarityChecker(BaseInvariantChecker):
+    def check(self, span: Span, invariant: IntentInvariant) -> float:
+        # Your embedding-based logic here
+        expected = invariant.config["expected_embedding"]
+        actual = get_embedding(span.output_data["text"])
+        return cosine_similarity(expected, actual)
+```
+
+### LLM-as-Judge
+
+Use an LLM to semantically evaluate whether a span's output satisfies an invariant.
+Requires `pip install agent-trace[llm-judge]`.
+
+```python
+from agent_trace import IntentInvariant, InvariantType
+
+invariant = IntentInvariant(
+    id="quality-check",
+    description="The response should be helpful and well-structured",
+    invariant_type=InvariantType.LLM_AS_JUDGE,
+    config={
+        "api_key": "sk-or-your-key",
+        "model": "qwen/qwen3.6-plus:free",
+    },
+    fidelity_threshold=0.7,
+)
+```
+
+The judge sends the span context to an LLM (default: OpenRouter) and parses a
+structured JSON score. On any failure it returns `0.0` and logs a warning;
+it never crashes your replay pipeline.
+
+### LangGraph Integration
+
+```python
+from agent_trace.integrations.langgraph import TraceCallbackHandler
+
+handler = TraceCallbackHandler(
+    trace_file="traces/run.jsonl",
+    session_id="session-1",
+    agent_name="my-agent",
+    default_invariants=[invariant],
+)
+
+graph = create_react_agent(..., callbacks=[handler])
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, code style, and how to submit PRs.
+
+## License
+
+MIT

semantic_trace-0.1.0/examples/demo.jsonl

@@ -0,0 +1,2 @@
+{"__metadata__":{"trace_id":"c32a5679-f8fe-4f65-99d3-256109898037","session_id":"demo","agent_name":"my-agent","start_time":"2026-04-07T12:02:51.293579Z","end_time":null}}
+{"span_id":"95b605f0-aad5-4d92-b8c4-fc583c62e62d","parent_id":null,"trace_id":"c32a5679-f8fe-4f65-99d3-256109898037","timestamp":"2026-04-07T12:02:51.293737Z","action_type":"llm_call","input_data":{"prompt":"Summarize this"},"output_data":{"summary":"Here is the summary"},"duration_ms":342.0,"attached_invariants":[{"id":"has-summary","description":"Output must contain a summary","invariant_type":"SUBSTRING_CHECK","config":{"substring":"summary"},"fidelity_threshold":1.0}],"invariant_results":null}