agenttape 0.1.0__tar.gz

agenttape-0.1.0/.gitignore

@@ -0,0 +1,36 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.eggs/
+build/
+dist/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.mypy_cache/
+.ruff_cache/
+
+# Docs
+site/
+
+# OS / editor
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+
+# AgentTape scratch
+*.derived.yaml
+.agenttape_tmp/

agenttape-0.1.0/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project are documented here. 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]
+
+### Changed
+
+- Bumped optional/dev/docs dependency floors to current stable major lines while
+  preserving Python 3.10–3.13 support: `openai>=1.66` (matches `responses.create`),
+  `langgraph>=1.0`, `langchain-core>=0.3`, `llama-index-core>=0.12`, `crewai>=1.0`,
+  `pyautogen>=0.9`, `mcp>=1.9`, `httpx>=0.27`, `requests>=2.32.4` (security),
+  `numpy>=1.26`, `opentelemetry-sdk>=1.30`, `pytest>=8.0`, `pytest-cov>=5.0`,
+  `ruff>=0.6`, `mypy>=1.11`, `types-PyYAML>=6.0.12`, `mkdocs-material>=9.5`,
+  `mkdocstrings[python]>=0.26`, `PyYAML>=6.0.1`.
+
+### Added
+
+- Python 3.14 to the CI test matrix and the PyPI classifiers.
+
+## [0.1.0] - 2026-06-16
+
+### Added
+
+- Core interception engine: record / replay of LLM, tool, retrieval, memory and
+  raw HTTP boundaries into ordered cassettes.
+- Cassette format (YAML default, JSON supported) with assets sidecar for large
+  payloads referenced by content hash. Pure-stdlib YAML reader/writer with
+  optional PyYAML acceleration.
+- Cassette modes: `none`, `once`, `new_episodes`, `all`, `record`.
+- Request canonicalization + sha256 match keys; pluggable matchers (`exact`,
+  `ignore_volatile`, `ordered`, `custom`).
+- Mixed / partial replay (`live` / `frozen` sets) with side-effect guardrail and
+  record-back into a derived cassette.
+- Determinism freeze layer: clock, RNG, UUID freeze; env snapshot + drift warning.
+- Record-time redaction of secrets/PII (denylist + regex rules + header redaction).
+- Public API: `record` / `replay` decorators, `use_cassette` context manager, and
+  an `AgentTape` callback/hook object.
+- OpenAI adapter (chat + responses + tool calling) and an always-on
+  `httpx` / `requests` fallback. LangGraph adapter and a documented extension
+  interface for the rest.
+- CLI: `init`, `record`, `replay`, `inspect`, `timeline`, `diff`, `redact`,
+  `validate`, `export` (json/otel), `view`, `rm`.
+- Diff engine: run / prompt / state-memory / output diffs (CLI + importable).
+- `pytest-agenttape` plugin: marker, fixture, offline-by-default mode, record
+  flag, mode flag, mismatch diffs, snapshot assertions.
+- Self-contained static HTML viewer (single + two-cassette diff), no server.
+
+[Unreleased]: https://github.com/MITHRAN-BALACHANDER/AgentTape/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/MITHRAN-BALACHANDER/AgentTape/releases/tag/v0.1.0

agenttape-0.1.0/LICENSE

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

agenttape-0.1.0/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: agenttape
+Version: 0.1.0
+Summary: Deterministic record/replay of LLM and tool calls for AI agents, captured into human-readable cassettes.
+Project-URL: Homepage, https://github.com/MITHRAN-BALACHANDER/AgentTape
+Project-URL: Documentation, https://MITHRAN-BALACHANDER.github.io/AgentTape/
+Project-URL: Repository, https://github.com/MITHRAN-BALACHANDER/AgentTape
+Project-URL: Changelog, https://github.com/MITHRAN-BALACHANDER/AgentTape/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/MITHRAN-BALACHANDER/AgentTape/issues
+Author: AgentTape Contributors
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,cassette,determinism,langgraph,llm,openai,record,replay,testing
+Classifier: Development Status :: 4 - Beta
+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 :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.9; extra == 'autogen'
+Provides-Extra: crewai
+Requires-Dist: crewai>=1.0; extra == 'crewai'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0.1; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.12; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.26; extra == 'docs'
+Provides-Extra: http
+Requires-Dist: httpx>=0.27; extra == 'http'
+Requires-Dist: requests>=2.32.4; extra == 'http'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=1.0; extra == 'langgraph'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.12; extra == 'llamaindex'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.9; extra == 'mcp'
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.26; extra == 'numpy'
+Provides-Extra: openai
+Requires-Dist: openai>=1.66; extra == 'openai'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-sdk>=1.30; extra == 'otel'
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0.1; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# AgentTape
+
+**Deterministic record and replay for AI agents.** Capture every external
+interaction your agent makes — LLM calls *and* tool calls — into human-readable
+"cassettes", then replay them deterministically so your tests run **offline, for
+free, with zero side effects.**
+
+[![CI](https://github.com/MITHRAN-BALACHANDER/AgentTape/actions/workflows/ci.yml/badge.svg)](https://github.com/MITHRAN-BALACHANDER/AgentTape/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/agenttape.svg)](https://pypi.org/project/agenttape/)
+[![Python](https://img.shields.io/pypi/pyversions/agenttape.svg)](https://pypi.org/project/agenttape/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Why
+
+Agent tests today are slow, flaky, expensive, and dangerous: they hit real LLM
+APIs (cost + nondeterminism) and real tools (a tool that charges a card, writes a
+row, or posts to Slack *actually does it*). AgentTape records those interactions
+once and replays them deterministically afterwards. Your CI runs with **no network
+access, no API keys, and no risk of a real side effect.**
+
+* **Local-first** — no server, no telemetry, nothing leaves your machine.
+* **Deterministic** — same inputs produce the same recorded outputs, byte-for-byte.
+* **Zero side effects in replay** — a replayed tool *never* executes for real.
+* **Almost-no-code** — add a decorator or a `with` block.
+* **Git-friendly** — cassettes are YAML: diffable, reviewable, hand-editable.
+* **Zero core dependencies** — the engine is pure standard library.
+
+## Install
+
+```bash
+pip install agenttape            # core (stdlib only)
+pip install "agenttape[openai]"  # + OpenAI adapter
+pip install "agenttape[yaml]"    # + PyYAML for extra-robust YAML loading
+```
+
+## 30-second quickstart
+
+Record once (real API call), then replay forever (no network):
+
+```python
+import agenttape
+from openai import OpenAI
+
+def run_agent():
+    client = OpenAI()
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": "Say hi in 3 words"}],
+    )
+    return resp.choices[0].message.content
+
+# --- record (hits the real API once, writes cassettes/hello.yaml) ---
+with agenttape.use_cassette("hello", mode="record"):
+    print(run_agent())
+
+# --- replay (zero network calls, milliseconds, free, deterministic) ---
+with agenttape.use_cassette("hello", mode="none"):
+    print(run_agent())   # identical output, served from the cassette
+```
+
+Or as a decorator:
+
+```python
+@agenttape.replay("hello")          # mode="none": offline + deterministic
+def test_agent():
+    assert "hi" in run_agent().lower()
+```
+
+## Mixed / partial replay — "freeze all but one"
+
+Change *one* thing — a prompt, a model, a single tool — and re-run while every
+**other** expensive or dangerous boundary stays frozen from the recording:
+
+```python
+# Only the LLM runs for real; every tool is served from the cassette.
+# A *derived* cassette is written — the original is never mutated.
+with agenttape.use_cassette("checkout", live={"llm"}):
+    result = run_agent()   # new prompt → new LLM output, tools stay frozen
+
+# See exactly what changed:
+#   agenttape diff cassettes/checkout.yaml cassettes/checkout.derived.yaml
+```
+
+Any boundary that is **not** in `live` and has no recording raises
+`UnmatchedInteractionError` — AgentTape will never silently run a real side effect.
+
+## Hand-edit a response
+
+Cassettes are just YAML. Open `cassettes/hello.yaml`, edit a recorded LLM
+response, save, and re-run in `mode="none"` — your agent behaves differently with
+**no API call at all.** Perfect for testing edge cases and failure paths.
+
+## pytest plugin
+
+Ships in the box. Tests run offline and deterministically by default:
+
+```python
+import pytest
+
+@pytest.mark.agenttape("weather_agent")
+def test_weather(agenttape_cassette):
+    assert run_agent() == "It's sunny."
+```
+
+```bash
+pytest                       # replay mode, offline, free (CI default)
+pytest --agenttape-record    # (re)record cassettes against the real API
+```
+
+## CLI
+
+```bash
+agenttape init                       # scaffold agenttape.toml + cassettes/
+agenttape inspect cassettes/hello    # tokens, latency, cost, per-step I/O
+agenttape timeline cassettes/hello   # ASCII waterfall of the run
+agenttape diff a.yaml b.yaml         # prompt / model / tool / cost / output diff
+agenttape validate cassettes/hello   # schema + determinism + leaked-secret lint
+agenttape view cassettes/hello       # self-contained static HTML, no server
+agenttape redact cassettes/hello     # re-run secret/PII redaction
+agenttape export cassettes/hello --format otel
+```
+
+## What this is — and what it isn't
+
+**It is:**
+
+* A deterministic record/replay layer for agent I/O (LLM + tools + raw HTTP).
+* A way to make agent tests fast, free, offline and side-effect-free.
+* A diff/inspection toolkit for understanding and reviewing agent runs.
+
+**It isn't:**
+
+* It is **not** a way to "replay with a different prompt/model and get a
+  deterministic answer for free." Replay reconstructs *recorded* bytes. The moment
+  you change an input to a boundary marked `live`, that boundary **really executes**
+  (real API call, real cost) and produces a **new** recording. AgentTape is
+  explicit about this everywhere — pure replay vs. re-execution are different verbs
+  and we never blur them.
+* It is **not** an evaluation framework, a prompt optimizer, or a tracing SaaS.
+
+See the [determinism guide](docs/determinism.md) and the
+[cassette format spec](docs/format.md) for details.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

agenttape-0.1.0/README.md

@@ -0,0 +1,148 @@
+# AgentTape
+
+**Deterministic record and replay for AI agents.** Capture every external
+interaction your agent makes — LLM calls *and* tool calls — into human-readable
+"cassettes", then replay them deterministically so your tests run **offline, for
+free, with zero side effects.**
+
+[![CI](https://github.com/MITHRAN-BALACHANDER/AgentTape/actions/workflows/ci.yml/badge.svg)](https://github.com/MITHRAN-BALACHANDER/AgentTape/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/agenttape.svg)](https://pypi.org/project/agenttape/)
+[![Python](https://img.shields.io/pypi/pyversions/agenttape.svg)](https://pypi.org/project/agenttape/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Why
+
+Agent tests today are slow, flaky, expensive, and dangerous: they hit real LLM
+APIs (cost + nondeterminism) and real tools (a tool that charges a card, writes a
+row, or posts to Slack *actually does it*). AgentTape records those interactions
+once and replays them deterministically afterwards. Your CI runs with **no network
+access, no API keys, and no risk of a real side effect.**
+
+* **Local-first** — no server, no telemetry, nothing leaves your machine.
+* **Deterministic** — same inputs produce the same recorded outputs, byte-for-byte.
+* **Zero side effects in replay** — a replayed tool *never* executes for real.
+* **Almost-no-code** — add a decorator or a `with` block.
+* **Git-friendly** — cassettes are YAML: diffable, reviewable, hand-editable.
+* **Zero core dependencies** — the engine is pure standard library.
+
+## Install
+
+```bash
+pip install agenttape            # core (stdlib only)
+pip install "agenttape[openai]"  # + OpenAI adapter
+pip install "agenttape[yaml]"    # + PyYAML for extra-robust YAML loading
+```
+
+## 30-second quickstart
+
+Record once (real API call), then replay forever (no network):
+
+```python
+import agenttape
+from openai import OpenAI
+
+def run_agent():
+    client = OpenAI()
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": "Say hi in 3 words"}],
+    )
+    return resp.choices[0].message.content
+
+# --- record (hits the real API once, writes cassettes/hello.yaml) ---
+with agenttape.use_cassette("hello", mode="record"):
+    print(run_agent())
+
+# --- replay (zero network calls, milliseconds, free, deterministic) ---
+with agenttape.use_cassette("hello", mode="none"):
+    print(run_agent())   # identical output, served from the cassette
+```
+
+Or as a decorator:
+
+```python
+@agenttape.replay("hello")          # mode="none": offline + deterministic
+def test_agent():
+    assert "hi" in run_agent().lower()
+```
+
+## Mixed / partial replay — "freeze all but one"
+
+Change *one* thing — a prompt, a model, a single tool — and re-run while every
+**other** expensive or dangerous boundary stays frozen from the recording:
+
+```python
+# Only the LLM runs for real; every tool is served from the cassette.
+# A *derived* cassette is written — the original is never mutated.
+with agenttape.use_cassette("checkout", live={"llm"}):
+    result = run_agent()   # new prompt → new LLM output, tools stay frozen
+
+# See exactly what changed:
+#   agenttape diff cassettes/checkout.yaml cassettes/checkout.derived.yaml
+```
+
+Any boundary that is **not** in `live` and has no recording raises
+`UnmatchedInteractionError` — AgentTape will never silently run a real side effect.
+
+## Hand-edit a response
+
+Cassettes are just YAML. Open `cassettes/hello.yaml`, edit a recorded LLM
+response, save, and re-run in `mode="none"` — your agent behaves differently with
+**no API call at all.** Perfect for testing edge cases and failure paths.
+
+## pytest plugin
+
+Ships in the box. Tests run offline and deterministically by default:
+
+```python
+import pytest
+
+@pytest.mark.agenttape("weather_agent")
+def test_weather(agenttape_cassette):
+    assert run_agent() == "It's sunny."
+```
+
+```bash
+pytest                       # replay mode, offline, free (CI default)
+pytest --agenttape-record    # (re)record cassettes against the real API
+```
+
+## CLI
+
+```bash
+agenttape init                       # scaffold agenttape.toml + cassettes/
+agenttape inspect cassettes/hello    # tokens, latency, cost, per-step I/O
+agenttape timeline cassettes/hello   # ASCII waterfall of the run
+agenttape diff a.yaml b.yaml         # prompt / model / tool / cost / output diff
+agenttape validate cassettes/hello   # schema + determinism + leaked-secret lint
+agenttape view cassettes/hello       # self-contained static HTML, no server
+agenttape redact cassettes/hello     # re-run secret/PII redaction
+agenttape export cassettes/hello --format otel
+```
+
+## What this is — and what it isn't
+
+**It is:**
+
+* A deterministic record/replay layer for agent I/O (LLM + tools + raw HTTP).
+* A way to make agent tests fast, free, offline and side-effect-free.
+* A diff/inspection toolkit for understanding and reviewing agent runs.
+
+**It isn't:**
+
+* It is **not** a way to "replay with a different prompt/model and get a
+  deterministic answer for free." Replay reconstructs *recorded* bytes. The moment
+  you change an input to a boundary marked `live`, that boundary **really executes**
+  (real API call, real cost) and produces a **new** recording. AgentTape is
+  explicit about this everywhere — pure replay vs. re-execution are different verbs
+  and we never blur them.
+* It is **not** an evaluation framework, a prompt optimizer, or a tracing SaaS.
+
+See the [determinism guide](docs/determinism.md) and the
+[cassette format spec](docs/format.md) for details.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

agenttape-0.1.0/pyproject.toml

@@ -0,0 +1,163 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agenttape"
+version = "0.1.0"
+description = "Deterministic record/replay of LLM and tool calls for AI agents, captured into human-readable cassettes."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "AgentTape Contributors" }]
+keywords = [
+    "ai",
+    "agents",
+    "llm",
+    "testing",
+    "record",
+    "replay",
+    "cassette",
+    "determinism",
+    "openai",
+    "langgraph",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+# Zero required runtime dependencies for the core — stdlib only.
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/MITHRAN-BALACHANDER/AgentTape"
+Documentation = "https://MITHRAN-BALACHANDER.github.io/AgentTape/"
+Repository = "https://github.com/MITHRAN-BALACHANDER/AgentTape"
+Changelog = "https://github.com/MITHRAN-BALACHANDER/AgentTape/blob/main/CHANGELOG.md"
+Issues = "https://github.com/MITHRAN-BALACHANDER/AgentTape/issues"
+
+[project.optional-dependencies]
+# Robust YAML round-tripping when present; core falls back to a stdlib subset emitter/parser.
+yaml = ["PyYAML>=6.0.1"]
+# responses.create (patched by OpenAIAdapter) only exists from openai 1.66+.
+openai = ["openai>=1.66"]
+langgraph = ["langgraph>=1.0"]
+langchain = ["langchain-core>=0.3"]
+llamaindex = ["llama-index-core>=0.12"]
+crewai = ["crewai>=1.0"]
+autogen = ["pyautogen>=0.9"]
+mcp = ["mcp>=1.9"]
+http = ["httpx>=0.27", "requests>=2.32.4"]
+# numpy 1.26 is the last 1.x line; numpy 2.3+ drops Python 3.10.
+numpy = ["numpy>=1.26"]
+otel = ["opentelemetry-sdk>=1.30"]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "PyYAML>=6.0.1",
+    "types-PyYAML>=6.0.12",
+]
+docs = [
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.26",
+]
+
+[project.scripts]
+agenttape = "agenttape.cli:main"
+
+[project.entry-points.pytest11]
+agenttape = "agenttape.pytest_plugin"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agenttape"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/agenttape", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "C4", "SIM", "RUF"]
+ignore = [
+    "E501",   # line length handled by formatter
+    "B008",   # function calls in argument defaults (used intentionally)
+    "SIM105", # contextlib.suppress not always clearer
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["B011", "B017", "SIM117"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+files = ["src/agenttape"]
+warn_unused_configs = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+# Optional adapter deps are typed when installed but absent in the strict core
+# type-check environment. Skipping their imports makes them Any consistently, so the
+# dynamic monkeypatching in adapters type-checks the same with or without them.
+[[tool.mypy.overrides]]
+module = [
+    "yaml",
+    "numpy",
+    "openai",
+    "openai.*",
+    "langgraph",
+    "langgraph.*",
+    "httpx",
+    "requests",
+    "requests.*",
+    "tomli",
+    "tomllib",
+]
+ignore_missing_imports = true
+follow_imports = "skip"
+
+# pytest is typed when installed (dev extra); only stub it out if entirely absent.
+[[tool.mypy.overrides]]
+module = ["pytest", "_pytest.*"]
+ignore_missing_imports = true
+
+# Adapters patch third-party (Any) classes; tolerate ignores that may be redundant
+# depending on whether the optional dependency is installed.
+[[tool.mypy.overrides]]
+module = ["agenttape.adapters.*"]
+warn_unused_ignores = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+markers = [
+    "agenttape: bind a test to an AgentTape cassette (see pytest-agenttape plugin).",
+]
+
+[tool.coverage.run]
+branch = true
+source = ["agenttape"]
+omit = ["*/adapters/_scaffold_*.py"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "@(abc\\.)?abstractmethod",
+    "\\.\\.\\.",
+]