backspin 0.5.1__py3-none-any.whl

backspin/ui/index.html

@@ -0,0 +1,68 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>backspin — agent 运行查看器</title>
+<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='0.9em' font-size='90'%3E%E2%8F%AA%3C/text%3E%3C/svg%3E">
+<link rel="stylesheet" href="style.css">
+</head>
+<body>
+<header>
+  <div id="logo">backspin<span class="logo-dim" data-i18n="logo.sub">· agent 飞行记录仪</span></div>
+  <div id="toolbar">
+    <select id="diff-select" hidden></select>
+    <button id="btn-diff" disabled data-i18n="btn.compare" data-i18n-title="tip.compare">对比…</button>
+    <button id="btn-close-diff" hidden data-i18n="btn.closeDiff">关闭对比</button>
+    <button id="btn-lang" data-i18n-title="tip.lang">EN</button>
+  </div>
+</header>
+
+<div id="layout">
+  <aside id="sidebar">
+    <h2 data-i18n="side.runs">运行记录</h2>
+    <ul id="run-list"></ul>
+  </aside>
+
+  <main id="main">
+    <div id="empty">
+      <h3 data-i18n="empty.title">尚未选择运行</h3>
+      <p data-i18n="empty.pick">从左侧选择一次运行,或者先录制一次:</p>
+      <pre>from backspin import Recorder
+
+with Recorder(agent="my-agent") as rec:
+    client = rec.capture_openai(OpenAI())
+    ...  # 你的 agent 代码</pre>
+      <p class="dim"><span data-i18n="empty.then">然后运行</span> <code>backspin ui</code> <span data-i18n="empty.refresh">并刷新本页。</span></p>
+    </div>
+    <section id="summary" class="cards" hidden></section>
+    <div id="banner" hidden></div>
+    <section id="waterfall-wrap" hidden>
+      <h2 id="wf-title" data-i18n="side.timeline">时间线</h2>
+      <div id="waterfall"></div>
+    </section>
+    <section id="diff-table-wrap" hidden>
+      <h2 data-i18n="side.diff">对比</h2>
+      <table id="diff-table"></table>
+    </section>
+  </main>
+
+  <aside id="inspector" hidden>
+    <div id="insp-head">
+      <span id="insp-title"></span>
+      <button id="insp-close" data-i18n-title="tip.close">✕</button>
+    </div>
+    <div id="insp-meta"></div>
+    <div id="insp-tabs" role="tablist">
+      <button class="tab" role="tab" data-tab="request" data-i18n="tab.request">请求</button>
+      <button class="tab" role="tab" data-tab="response" data-i18n="tab.response">响应</button>
+      <button class="tab active" role="tab" aria-selected="true" data-tab="raw" data-i18n="tab.raw">原始</button>
+    </div>
+    <pre id="insp-body"></pre>
+  </aside>
+</div>
+
+<script src="i18n.js"></script>
+<script src="app.js"></script>
+</body>
+</html>

backspin/ui/style.css

@@ -0,0 +1,214 @@
+:root {
+  --bg: #0d1117;
+  --panel: #161b22;
+  --panel-2: #1c2333;
+  --border: #30363d;
+  --text: #e6edf3;
+  --dim: #8b949e;
+  --accent: #58a6ff;
+  --green: #3fb950;
+  --red: #f85149;
+  --yellow: #d29922;
+  --purple: #bc8cff;
+  --mono: ui-monospace, "Cascadia Code", Consolas, "Courier New", monospace;
+}
+
+* { box-sizing: border-box; }
+
+[hidden] { display: none !important; }
+
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--text);
+  font: 14px/1.5 -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+}
+
+header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 16px;
+  border-bottom: 1px solid var(--border);
+  background: var(--panel);
+}
+
+#logo { font-weight: 700; font-size: 15px; letter-spacing: 0.3px; }
+.logo-dim { color: var(--dim); font-weight: 400; margin-left: 8px; font-size: 12px; }
+
+button, select {
+  background: var(--panel-2);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 5px 12px;
+  font: inherit;
+  cursor: pointer;
+}
+button:hover:not(:disabled) { border-color: var(--accent); }
+button:disabled { opacity: 0.45; cursor: default; }
+
+#layout {
+  display: flex;
+  align-items: stretch;
+  height: calc(100vh - 53px);
+}
+
+/* ---- sidebar ---- */
+#sidebar {
+  width: 280px;
+  flex-shrink: 0;
+  border-right: 1px solid var(--border);
+  overflow-y: auto;
+  padding: 12px;
+}
+#sidebar h2, #wf-title, #diff-table-wrap h2 {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+  color: var(--dim);
+  margin: 4px 0 10px;
+}
+#run-list { list-style: none; margin: 0; padding: 0; }
+#run-list li {
+  padding: 8px 10px;
+  border-radius: 6px;
+  cursor: pointer;
+  border: 1px solid transparent;
+  margin-bottom: 4px;
+}
+#run-list li:hover { background: var(--panel-2); }
+#run-list li.active { background: var(--panel-2); border-color: var(--accent); }
+#run-list .name { font-family: var(--mono); font-size: 12px; word-break: break-all; }
+#run-list .meta { color: var(--dim); font-size: 11px; margin-top: 2px; }
+
+/* ---- main ---- */
+#main { flex: 1; overflow-y: auto; padding: 14px 18px; min-width: 0; }
+
+#empty { color: var(--dim); max-width: 480px; margin: 60px auto; text-align: center; }
+#empty pre {
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 12px;
+  text-align: left;
+  font-family: var(--mono);
+  font-size: 12px;
+  overflow-x: auto;
+}
+#empty .dim, .dim { color: var(--dim); }
+
+.cards { display: flex; gap: 10px; flex-wrap: wrap; margin-bottom: 14px; }
+.card {
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 10px 14px;
+  min-width: 110px;
+}
+.card .k { color: var(--dim); font-size: 11px; text-transform: uppercase; letter-spacing: 0.6px; }
+.card .v { font-size: 18px; font-weight: 600; font-family: var(--mono); }
+.card .v small { font-size: 11px; color: var(--dim); font-weight: 400; }
+
+#banner {
+  background: rgba(210, 153, 34, 0.12);
+  border: 1px solid var(--yellow);
+  color: var(--text);
+  border-radius: 8px;
+  padding: 10px 14px;
+  margin-bottom: 14px;
+}
+#banner.ok { border-color: var(--green); background: rgba(63, 185, 80, 0.1); }
+
+/* ---- waterfall ---- */
+.row {
+  display: grid;
+  grid-template-columns: 38px 190px 1fr 70px 90px;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 6px;
+  border-radius: 6px;
+  cursor: pointer;
+  font-family: var(--mono);
+  font-size: 12px;
+}
+.row:hover { background: var(--panel-2); }
+.row.selected { background: var(--panel-2); outline: 1px solid var(--accent); }
+.row .seq { color: var(--dim); }
+.row .lbl { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.row .dur, .row .tok { text-align: right; color: var(--dim); }
+.track { background: var(--panel-2); border-radius: 4px; height: 14px; position: relative; overflow: hidden; }
+.bar { position: absolute; left: 0; top: 0; bottom: 0; min-width: 2px; border-radius: 3px; }
+.kind-llm .bar { background: var(--accent); }
+.kind-tool .bar { background: var(--green); }
+.kind-log .bar { background: #3d444d; }
+.kind-error .bar { background: var(--red); }
+.kind-custom .bar { background: var(--purple); }
+.kind-span .bar { background: var(--purple); opacity: 0.55; }
+.kind-llm .lbl { color: var(--accent); }
+.kind-tool .lbl { color: var(--green); }
+.kind-span .lbl { color: var(--purple); }
+.kind-error .lbl { color: var(--red); }
+.row.error .dur { color: var(--red); }
+
+/* ---- diff table ---- */
+#diff-table { width: 100%; border-collapse: collapse; font-family: var(--mono); font-size: 12px; }
+#diff-table th, #diff-table td {
+  text-align: left;
+  padding: 6px 10px;
+  border-bottom: 1px solid var(--border);
+}
+#diff-table th { color: var(--dim); font-weight: 500; text-transform: uppercase; font-size: 10px; letter-spacing: 0.8px; }
+#diff-table tr.diverged td { background: rgba(248, 81, 73, 0.12); }
+#diff-table tr.solo td { color: var(--dim); }
+.badge-yes { color: var(--green); }
+.badge-no { color: var(--red); font-weight: 700; }
+.badge-solo { color: var(--dim); }
+
+/* ---- inspector ---- */
+#inspector {
+  width: 420px;
+  flex-shrink: 0;
+  border-left: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  background: var(--panel);
+}
+#insp-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 10px 14px;
+  border-bottom: 1px solid var(--border);
+  font-weight: 600;
+}
+#insp-close { border: none; background: none; color: var(--dim); font-size: 14px; }
+#insp-meta { padding: 8px 14px; color: var(--dim); font-family: var(--mono); font-size: 11px; }
+#insp-tabs { display: flex; gap: 4px; padding: 0 14px; border-bottom: 1px solid var(--border); }
+.tab {
+  border: none;
+  border-bottom: 2px solid transparent;
+  background: none;
+  color: var(--dim);
+  border-radius: 0;
+  padding: 6px 10px;
+}
+.tab.active { color: var(--text); border-bottom-color: var(--accent); }
+#insp-body {
+  margin: 0;
+  padding: 12px 14px;
+  overflow: auto;
+  flex: 1;
+  font-family: var(--mono);
+  font-size: 12px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* keyboard focus rings for the clickable non-button elements */
+#run-list li:focus-visible,
+#waterfall .row:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+  border-radius: 4px;
+}

backspin-0.5.1.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.5
+Name: backspin
+Version: 0.5.1
+Summary: The flight recorder for AI agents — record, replay, diff and debug agent runs, 100% local.
+Project-URL: Homepage, https://github.com/zaibuchihuoji/backspin
+Project-URL: Repository, https://github.com/zaibuchihuoji/backspin
+Project-URL: Issues, https://github.com/zaibuchihuoji/backspin/issues
+Project-URL: Changelog, https://github.com/zaibuchihuoji/backspin/blob/main/CHANGELOG.md
+Author: backspin contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,llm,mcp,observability,openai,record-replay,time-travel-debugging
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=1.0; (python_version >= '3.10') and extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: anthropic>=1.0; (python_version >= '3.10') and extra == 'dev'
+Requires-Dist: fastapi>=0.100; extra == 'dev'
+Requires-Dist: httpx>=0.24; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: openai>=1.30; extra == 'dev'
+Requires-Dist: pytest-cov>=4; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: uvicorn>=0.23; extra == 'dev'
+Provides-Extra: proxy
+Requires-Dist: fastapi>=0.100; extra == 'proxy'
+Requires-Dist: httpx>=0.24; extra == 'proxy'
+Requires-Dist: uvicorn>=0.23; extra == 'proxy'
+Provides-Extra: ui
+Requires-Dist: fastapi>=0.100; extra == 'ui'
+Requires-Dist: uvicorn>=0.23; extra == 'ui'
+Description-Content-Type: text/markdown
+
+# backspin
+
+[![CI](https://github.com/zaibuchihuoji/backspin/actions/workflows/ci.yml/badge.svg)](https://github.com/zaibuchihuoji/backspin/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/backspin)](https://pypi.org/project/backspin/)
+[![Python](https://img.shields.io/pypi/pyversions/backspin)](https://pypi.org/project/backspin/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**The flight recorder for AI agents.** Record every LLM call and tool call of an agent run into one portable file, replay the run deterministically with zero API access, and diff two runs to find the exact step where behavior diverged. 100% local, zero core dependencies.
+
+*Think [rr](https://rr-project.org/), but for agents instead of processes.*
+
+```python
+from backspin import Recorder
+
+with Recorder(agent="my-agent") as rec:
+    client = rec.capture_openai(OpenAI())   # any code that talks to chat.completions
+    ...                                     # your agent, unchanged
+```
+
+That's the whole integration. Everything the agent did — prompts, completions, tool calls, timings, token counts — is now in a single `runs/*.backspin.jsonl` file you can open, replay, diff, or attach to a bug report.
+
+[中文文档](README.zh-CN.md)
+
+## Why
+
+Your agent made forty LLM calls, called three tools, and then did something weird at 2am. Good luck reproducing that from a chat log.
+
+Cloud observability tools (Langfuse, LangSmith, AgentOps…) answer *"what happened?"* on a dashboard. **backspin answers "make it happen again, exactly."** It's a debugger, not a dashboard:
+
+- **Record** — one context manager captures every OpenAI-shaped call (sync, async, streaming) plus your own tool calls and logs.
+- **Replay** — the run becomes a *cassette*: your agent re-runs offline with recorded responses injected, deterministically. Perfect for regression tests and reproducing bugs without API keys or cost.
+- **Diff** — replay the same agent against a fix and diff the two runs; backspin pinpoints the first step where they stopped matching.
+- **Local-first** — runs are plain JSONL files. No server, no account, no telemetry. `git attach`-friendly: the failing run *is* the bug report.
+
+## Install
+
+```bash
+pip install "backspin[ui]"     # SDK + CLI + local viewer
+```
+
+Core has zero dependencies; `[ui]` adds FastAPI + uvicorn for the local viewer.
+
+## Record
+
+```python
+from openai import OpenAI
+from backspin import Recorder
+
+rec = Recorder(agent="support-bot")
+
+with rec:
+    client = rec.capture_openai(OpenAI())
+
+    @rec.tool
+    def lookup_order(order_id: str) -> str:
+        return "shipped"
+
+    rec.log("user asks about order #1234")
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": "Where is order #1234?"}],
+    )
+
+print(rec.path)   # runs/20260829-142300-support-bot-9f31c2.backspin.jsonl
+```
+
+Streaming and async clients are captured too; a streamed response is transparently reconstructed into one recorded completion.
+
+## Replay
+
+```python
+from backspin import Cassette, load_run, stub_client
+
+cassette = Cassette.from_run(load_run(rec.path))
+stub = stub_client(cassette)
+
+# Same agent code, zero network: responses come from the recording.
+answer = run_agent(stub)
+```
+
+Requests are matched by fingerprint (model + messages) and fall back to call order with a warning. Use `backspin.replay.patch_openai(cassette)` to patch `openai.OpenAI` itself when you can't inject a client.
+
+**In tests** this becomes deterministic agent regression testing: record once, assert forever, at zero token cost. The pytest plugin does the asserting for you:
+
+```python
+def test_my_agent(backspin):                       # pip-installed = auto-loaded
+    with backspin.record(agent="t") as rec:
+        run_agent(rec.capture_openai(client))
+    backspin.assert_replays_identically()          # strict: fingerprint-exact replay
+```
+
+## What-if branching
+
+The debugger superpower: change one answer, keep everything else constant, and see what the timeline looks like downstream.
+
+```python
+from backspin import branch, diff_runs, load_run
+
+branch_path = branch("runs/live.backspin.jsonl", {0: {"content": "Rome it is."}})
+report = diff_runs(load_run("runs/live.backspin.jsonl"), load_run(branch_path), llm_only=True)
+print(report.first_divergence)   # the step where the two timelines split
+```
+
+Or from the CLI: `backspin branch runs/live.jsonl --step 0 --content "Rome it is."` — writes a branch run (marked `branch_of`) and prints the divergence report.
+
+## Spans: structure, not just a flat list
+
+```python
+with rec.span("research", meta={"topic": "weather"}):
+    with rec.span("tool:search"):
+        ...
+    resp = client.chat.completions.create(...)   # recorded inside the span
+```
+
+Every event inside a span carries its `span_id` and nesting `depth`; spans are safe under concurrency (each asyncio task gets its own stack) and the viewer renders the tree. Spans never inflate duration totals.
+
+## Zero-code integration: `backspin proxy`
+
+Can't (or don't want to) instrument code? Run the OpenAI-compatible local proxy and point any agent at it — any framework, any language:
+
+```bash
+backspin proxy --upstream https://api.openai.com --port 8840
+# client: base_url = http://127.0.0.1:8840/v1   ← that's the whole integration
+```
+
+Every call is forwarded and captured, streaming included. Flip the same proxy into **replay mode** and it serves a recorded run back as an API — deterministic replay for agents written in any language, no SDK required:
+
+```bash
+backspin proxy --replay runs/live.backspin.jsonl --port 8840
+```
+
+## Multi-provider: OpenAI, Anthropic, and everything OpenAI-compatible
+
+Claude natively? Same story, two lines:
+
+```python
+rec.capture_anthropic(Anthropic())   # sync/async/streaming, tool_use included
+```
+
+Anthropic events record with `provider: "anthropic"` and usage normalized to
+the same token fields, so costs and diffs work across providers. And because
+the proxy speaks `/v1/messages` too, Claude-native agents get the same
+record-or-replay treatment with zero code changes.
+
+Anything that speaks the OpenAI protocol (DeepSeek, Qwen, Kimi, GLM,
+vLLM/Ollama, OpenRouter, …) is covered by `capture_openai` / the proxy out
+of the box.
+
+## Export, share, TUI
+
+```bash
+backspin export runs/live.jsonl --format sft -o train.jsonl   # eval/SFT datasets
+backspin share runs/live.jsonl        # one self-contained HTML: run + viewer
+backspin tui                          # keyboard-driven viewer for the terminal
+```
+
+`share` bundles the entire viewer and the run into a single `.html` — send it
+to a teammate, they open it in a browser and step through the run. Nothing
+is uploaded anywhere.
+
+## Costs
+
+A built-in price table (gpt-4o, claude, gemini, deepseek, …) turns token counts into money: `run.totals()["cost_usd"]`, a cost card in the viewer, `~$0.0142` in `backspin show`. Extending the table is a one-dict PR.
+
+## Diff
+
+```bash
+backspin diff runs/live.backspin.jsonl runs/replay.backspin.jsonl
+# runs diverge at step #14
+#   #13  llm   gpt-4o-mini        gpt-4o-mini        yes
+#   #14  llm   gpt-4o-mini        gpt-4o-mini        NO
+```
+
+Steps are aligned and signed by *what the agent chose to do* (LLM request fingerprint / tool name), so the first mismatch marks exactly where two runs stopped matching — before costs and latencies are even considered.
+
+## CLI & local viewer
+
+```bash
+backspin ls                  # list runs: agent, steps, tokens
+backspin show runs/...jsonl  # print a run's timeline
+backspin show runs/... --step 7   # dump one step as JSON
+backspin diff a b            # diff two runs (exit 1 if they differ)
+backspin ui                  # http://127.0.0.1:8787 — timeline, inspector, diff
+```
+
+The viewer is a zero-build vanilla JS app served by the CLI: a waterfall timeline, a step inspector (request / response / raw), and side-by-side run diffing.
+
+![backspin timeline viewer](docs/ui-timeline.png)
+
+![backspin diff view](docs/ui-diff.png)
+
+## Keeping secrets out of recordings
+
+Recordings contain full prompts and completions. When that's not okay, pass a `redact` function — every payload value goes through it before touching disk:
+
+```python
+from backspin import Recorder
+from backspin.redaction import mask, redact_strings
+
+rec = Recorder(
+    agent="support-bot",
+    redact=redact_strings(mask(r"sk-[A-Za-z0-9]{8,}")),
+)
+```
+
+Structural fields (model, tool name, fingerprint, durations) stay readable so the viewer and diff keep working; everything else — including unknown custom payload keys — passes through the redactor. Fingerprints are computed pre-redaction, so replay matching is unaffected. Note the tradeoff: a redacted run still replays, but replayed values are the redacted ones.
+
+## The run file
+
+One run = one self-contained JSONL file. First line is a header, every following line is a step:
+
+```json
+{"kind": "llm", "seq": 3, "ts": 1756448402.1, "model": "gpt-4o-mini",
+ "duration_ms": 812.4, "fingerprint": "9f31c2ab77e01d44",
+ "request": {"messages": [...]}, "response": {"choices": [...]},
+ "usage": {"prompt_tokens": 120, "completion_tokens": 45}}
+```
+
+Kinds: `llm`, `tool`, `log`, `error`, plus whatever custom events you record via `rec.event(kind, **payload)`. Because a run is one file, "please attach the failing run" finally works.
+
+## How backspin compares
+
+| | Langfuse / LangSmith / AgentOps | backspin |
+|---|---|---|
+| Question it answers | what happened? | make it happen again, exactly |
+| Where | cloud SaaS | your machine, plain files |
+| Replay with recorded responses | no | yes, deterministic |
+| First-divergence diffing | no | yes |
+| Setup | SDK + account + ingestion | one context manager |
+| Token cost of debugging | full price | zero after recording |
+
+They compose well: keep the dashboard if you like it, attach a backspin run when someone says "I can't reproduce it."
+
+## Status & roadmap
+
+backspin is a young project (v0.5) — record → replay → what-if → diff → view works end to end across OpenAI and Anthropic protocols, from Python and TypeScript, verified against the real SDKs. Next:
+
+- [x] ~~Async + streaming capture, spans, redaction, costs, pytest plugin~~ (0.2/0.3)
+- [x] ~~Sidecar proxy: record + replay, OpenAI protocol~~ (0.3)
+- [x] ~~Anthropic native: SDK capture + proxy `/v1/messages`; TypeScript SDK; export/share/TUI~~ (0.4)
+- [x] ~~Agent-level what-if (re-run the whole agent against a mutated cassette)~~ (0.5)
+- [ ] Docs site with runnable examples
+- [ ] Deterministic clock/random stubs for full boundary capture
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest                      # full suite incl. real-SDK integration tests
+ruff check backspin/ tests/ # lint
+mypy backspin/              # types
+python examples/mock_agent.py   # zero-setup demo: record → replay → diff
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for ground rules (core stays
+dependency-free; the run format is a contract) and [SECURITY.md](SECURITY.md)
+for how to report vulnerabilities.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

backspin-0.5.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+backspin/__init__.py,sha256=bQpKJx_sdmdtrALxANCxfEsOfvmt8pjKnKEtOOzgsZE,837
+backspin/cli.py,sha256=8lbdsXeYXG-eFwGYmkca1DnYQG6Pl1SjY5D-R-Kw7-Y,13365
+backspin/cost.py,sha256=oyGuGDP8fAPIVXhdA69pKJPZpXxwbIxH--bhByF4XME,2912
+backspin/diff.py,sha256=EPJnCEGpjtVz8qToPewbqoGlTYeZHOZLvDv0PWJLMcU,3850
+backspin/export.py,sha256=eTyVtbN8wiA6RPq0RrhgLzCaYLdwWm8Vwef6HEenRDk,2498
+backspin/fakes.py,sha256=vTr3DHaiOcw8R7PYz5VmpEIfRjxBuPQi8SeqTaN52bw,5780
+backspin/proxy.py,sha256=efccAvB3IM49uqI3WbsLY2lWa4KQLi_36XJkKGCoMlA,14463
+backspin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backspin/pytest_plugin.py,sha256=z0SrlZha2-x4CNWg7gtAdwi0SbGeO8Z_cJ9YAlEWy5c,3252
+backspin/recorder.py,sha256=ZKVgyrnSHBWxDCY8bIUDpjgJqYNF3YuVPVGJCzOj-0I,12760
+backspin/redaction.py,sha256=jre1ntKyHnI0YyGvOeGDrKR6TUzABfzJm-UPapniPUk,1623
+backspin/replay.py,sha256=6CuknY0vbm1DFoB_LPpuwjrgZ-3GuF3PE5RCfalEqB0,13116
+backspin/runfile.py,sha256=XvoCQTlfZwE4AuGGcC50qjYFKgstX3yfpZfqd7zt2BA,5733
+backspin/server.py,sha256=bK0WFH_jkGW8FrZ70fFht0Yv87K7cVWZS1sbP3YdIuk,3074
+backspin/share.py,sha256=AGK_k4JdkhPDjgZCXu71h5zgU2R6ykk1raBhcannogg,2128
+backspin/testing.py,sha256=aL2bqGZJim78fMmkfFKwymK-Y33QmrZJ7qonCYbx9lE,4102
+backspin/tui.py,sha256=N3g-7mzCzvLNnfDtp3V1e-TVczJMHPX8nK2Q-gsXnfs,4631
+backspin/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backspin/integrations/anthropic.py,sha256=_RzIfVdpl7fIKEu5bwMzWIqF93kOdyrwffnglHQqKog,9636
+backspin/integrations/openai.py,sha256=YI81Fig6kVTXnFBWnF5earrmirJ4H6OjtkQ31IXWgBA,9416
+backspin/ui/app.js,sha256=50BocxnDWDbd4IuJ9JsTB8op7IoVCsRGiKuGs3xqys8,11719
+backspin/ui/i18n.js,sha256=odjpuEFh_FWATima9H70Yr-BFPH5ObK2DFx8OgMJFJM,4303
+backspin/ui/index.html,sha256=rqDULcSsSBisBJ2SRqUkW6jNkXGKJiY7q4Lp-rWbbJg,2616
+backspin/ui/style.css,sha256=vHVgGd_OySXVOAqQxBKLPFk1GdXfnALLaHEH4YHT27o,6263
+backspin-0.5.1.dist-info/METADATA,sha256=1lZ3BjhR4GWOQw2DIo_EY7WvDWqGQLdh-I5ckqrZVok,13363
+backspin-0.5.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+backspin-0.5.1.dist-info/entry_points.txt,sha256=WDSjbXprsV95jBR_k_R0G96cOq0iEHEgd9J9i2hdZv8,93
+backspin-0.5.1.dist-info/licenses/LICENSE,sha256=PU2EnDY2G9XOKy00CB8cwS2F-GQC0eoCqGLUy-_QE1o,1078
+backspin-0.5.1.dist-info/RECORD,,

backspin-0.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

backspin-0.5.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+backspin = backspin.cli:main
+
+[pytest11]
+backspin = backspin.pytest_plugin

backspin-0.5.1.dist-info/licenses/LICENSE

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