agentautopsy 0.1.0__py3-none-any.whl

agentautopsy/__init__.py

@@ -0,0 +1,62 @@
+"""AgentAutopsy — when your agent fails, this tells you exactly why."""
+
+import atexit
+
+from agentautopsy.db import create_tables, get_db, insert_run
+from agentautopsy.interceptor import (
+    start_interceptor,
+    start_anthropic_interceptor,
+    start_http_interceptor,
+)
+from agentautopsy.reporter import print_report
+
+
+def watch():
+    db = get_db()
+    create_tables(db)
+    from agentautopsy.cache import setup_cache
+
+    setup_cache(db)
+    run_id = insert_run(db)
+    start_interceptor(run_id, db)
+    start_anthropic_interceptor(run_id, db)
+    start_http_interceptor(run_id, db)
+    print(f"[AgentAutopsy] watching — run {run_id}")
+
+    def on_exit():
+        from agentautopsy.detector import detect_failure, take_snapshot
+        from agentautopsy.pruner import prune
+        from agentautopsy.analyzer import analyze
+        from agentautopsy.replay import replay
+        from agentautopsy.cache import lookup_fix, store_fix
+
+        result = detect_failure(run_id, db)
+        if not result["failed"]:
+            print(f"[AgentAutopsy] run completed cleanly — {run_id}")
+            return
+
+        print(f"\n[AgentAutopsy] failure detected: {result['error_type']}: {result['message']}")
+
+        cached = lookup_fix(db, result["error_type"], result["message"])
+        if cached:
+            print(f"[AgentAutopsy] cache hit — fix found instantly:")
+            print(cached)
+            return
+
+        snapshot = take_snapshot(run_id, db)
+        pruned = prune(snapshot, result["failure_event_id"])
+        analysis = analyze(pruned, result)
+        print(f"\n[AgentAutopsy] analysis:\n{analysis}")
+
+        replay_result = replay(run_id, db, analysis)
+        if replay_result["verified"]:
+            print(f"\n[AgentAutopsy] fix verified ✓")
+            print("✓ Replay passed")
+            print("✓ Failure resolved")
+            store_fix(db, result["error_type"], result["message"], analysis, verified=True)
+        else:
+            print(f"\n[AgentAutopsy] fix not verified — review manually")
+
+        print_report(run_id, db)
+
+    atexit.register(on_exit)

agentautopsy/analyzer.py

@@ -0,0 +1,44 @@
+"""Fix analyzer for AgentAutopsy."""
+
+import anthropic
+
+
+def analyze(pruned_snapshot, failure):
+    lines = [
+        f"Error: {failure['error_type']}: {failure['message']}",
+        "Trace:"
+    ]
+    for e in pruned_snapshot:
+        lines.append(f"- [{e['type']}] {e['payload']}")
+    user_message = "\n".join(lines)
+
+    client = anthropic.Anthropic()
+    response = client.messages.create(
+        model="claude-haiku-4-5-20251001",
+        max_tokens=500,
+        system=(
+            "You are AgentAutopsy, an expert AI agent debugger. "
+            "Given a trace of an AI agent's decisions leading up to a failure, output:\n"
+            "FAILURE NODE: <exact step that caused failure>\n"
+            "ROOT CAUSE: <one sentence>\n"
+            "FIX: <concrete patch or instruction>"
+        ),
+        messages=[{"role": "user", "content": user_message}]
+    )
+    return response.content[0].text
+
+
+if __name__ == "__main__":
+    fake_snapshot = [
+        {"id": "1", "type": "llm_call", "payload": {"model": "gpt-4", "messages": [{"role": "user", "content": "fetch data from api"}]}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:01"},
+        {"id": "2", "type": "error", "payload": {"error_type": "TimeoutError", "message": "request timed out after 30s"}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:02"},
+    ]
+    fake_failure = {
+        "failed": True,
+        "error_type": "TimeoutError",
+        "message": "request timed out after 30s",
+        "run_id": "test-123",
+        "failure_event_id": "2"
+    }
+    result = analyze(fake_snapshot, fake_failure)
+    print(result)

agentautopsy/cache.py

@@ -0,0 +1,116 @@
+"""Fix cache for AgentAutopsy."""
+
+import re
+import uuid
+from typing import Any
+
+from sqlite_utils import Database
+
+
+def _words(text: str) -> set[str]:
+    return {w.lower() for w in re.findall(r"\w+", text) if w}
+
+
+def _match_score(query_text: str, stored_text: str) -> float:
+    query_words = _words(query_text)
+    if not query_words:
+        return 0.0
+    stored_words = _words(stored_text)
+    overlap = len(query_words & stored_words)
+    return overlap / len(query_words)
+
+
+def setup_cache(db: Database) -> None:
+    db["fix_cache"].create(
+        {
+            "id": str,
+            "failure_type": str,
+            "failure_text": str,
+            "patch": str,
+            "verified": bool,
+            "hits": int,
+        },
+        pk="id",
+        if_not_exists=True,
+    )
+
+
+def store_fix(
+    db: Database,
+    failure_type: str,
+    failure_text: str,
+    patch: str,
+    verified: bool = True,
+) -> str:
+    fix_id = str(uuid.uuid4())
+    db["fix_cache"].insert(
+        {
+            "id": fix_id,
+            "failure_type": failure_type,
+            "failure_text": failure_text,
+            "patch": patch,
+            "verified": verified,
+            "hits": 0,
+        },
+        pk="id",
+    )
+    return fix_id
+
+
+def lookup_fix(
+    db: Database,
+    failure_type: str,
+    failure_text: str,
+    threshold: float = 0.6,
+) -> str | None:
+    if not db["fix_cache"].exists():
+        return None
+
+    best_patch: str | None = None
+    best_score = -1.0
+    best_id: str | None = None
+
+    for row in db["fix_cache"].rows_where(
+        where="failure_type = ?",
+        where_args=[failure_type],
+    ):
+        score = _match_score(failure_text, row["failure_text"])
+        if score >= threshold and score > best_score:
+            best_score = score
+            best_patch = row["patch"]
+            best_id = row["id"]
+
+    if best_id is None:
+        return None
+
+    db.execute(
+        "UPDATE fix_cache SET hits = hits + 1 WHERE id = ?",
+        [best_id],
+    )
+    return best_patch
+
+
+def cache_stats(db: Database) -> dict[str, int]:
+    if not db["fix_cache"].exists():
+        return {"total_fixes": 0, "total_hits": 0}
+
+    total_fixes = db["fix_cache"].count
+    row = db.execute("SELECT COALESCE(SUM(hits), 0) FROM fix_cache").fetchone()
+    total_hits = int(row[0]) if row else 0
+    return {"total_fixes": total_fixes, "total_hits": total_hits}
+
+
+if __name__ == "__main__":
+    from agentautopsy.db import create_tables, get_db
+
+    db = get_db()
+    create_tables(db)
+    setup_cache(db)
+    store_fix(db, "TimeoutError", "request timed out after 30s calling external api", "Add timeout=60 and retry logic")
+    store_fix(db, "AuthenticationError", "invalid api key provided", "Check OPENAI_API_KEY environment variable")
+    result = lookup_fix(db, "TimeoutError", "timed out calling api")
+    print(f"Cache hit: {result}")
+    miss = lookup_fix(db, "TimeoutError", "memory allocation failed")
+    print(f"Cache miss: {miss}")
+    stats = cache_stats(db)
+    print(f"Stats: {stats}")

agentautopsy/cassette.py

@@ -0,0 +1,30 @@
+"""Cassette serialization for AgentAutopsy LLM responses."""
+
+import json
+
+
+def save_cassette(response_object: object) -> bytes:
+    try:
+        dumped = response_object.model_dump()
+        return json.dumps(dumped).encode()
+    except Exception:
+        return str(response_object).encode()
+
+
+def load_cassette(cassette_bytes: bytes) -> dict:
+    try:
+        data = json.loads(cassette_bytes.decode())
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+if __name__ == "__main__":
+    test_bytes = save_cassette(
+        type("R", (), {"model_dump": lambda self: {"id": "test", "content": "hello"}})()
+    )
+    print(f"Cassette saved: {len(test_bytes)} bytes")
+    result = load_cassette(test_bytes)
+    print(f"Cassette loaded: {result}")
+    bad = load_cassette(b"not json at all")
+    print(f"Bad cassette returns: {bad}")

agentautopsy/cli.py

@@ -0,0 +1,65 @@
+"""Command-line interface for AgentAutopsy."""
+
+import sys
+
+from agentautopsy.cache import cache_stats, setup_cache
+from agentautopsy.db import create_tables, get_db
+from agentautopsy.reporter import print_report
+
+
+def _usage() -> None:
+    print(
+        """Usage: agentautopsy <command>
+
+Commands:
+  runs              List all runs (id, start_time, status)
+  replay <run_id>   Print the event report for a run
+  stats             Show fix cache statistics
+
+Examples:
+  agentautopsy runs
+  agentautopsy replay abc-123-def
+  agentautopsy stats"""
+    )
+
+
+def main() -> None:
+    argv = sys.argv[1:]
+    if not argv:
+        _usage()
+        return
+
+    cmd = argv[0]
+    db = get_db()
+    create_tables(db)
+
+    if cmd == "runs":
+        if not db["runs"].exists():
+            print("No runs table yet.")
+            return
+        rows = list(db["runs"].rows_where(order_by="start_time desc"))
+        if not rows:
+            print("No runs found.")
+            return
+        for row in rows:
+            print(f"{row['id']}\t{row['start_time']}\t{row['status']}")
+        return
+
+    if cmd == "replay":
+        if len(argv) < 2:
+            print("usage: agentautopsy replay <run_id>", file=sys.stderr)
+            sys.exit(2)
+        run_id = argv[1]
+        print_report(run_id, db)
+        return
+
+    if cmd == "stats":
+        setup_cache(db)
+        stats = cache_stats(db)
+        print(f"total_fixes: {stats['total_fixes']}")
+        print(f"total_hits: {stats['total_hits']}")
+        return
+
+    print(f"Unknown command: {cmd}", file=sys.stderr)
+    _usage()
+    sys.exit(2)

agentautopsy/db.py

@@ -0,0 +1,79 @@
+"""Database layer for AgentAutopsy."""
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+from sqlite_utils import Database
+
+
+def get_db() -> Database:
+    return Database(Path.cwd() / "agentautopsy.db")
+
+
+def create_tables(db: Database) -> None:
+    db["runs"].create(
+        {
+            "id": str,
+            "start_time": str,
+            "status": str,
+            "framework": str,
+        },
+        pk="id",
+        if_not_exists=True,
+    )
+    db["events"].create(
+        {
+            "id": str,
+            "run_id": str,
+            "timestamp": str,
+            "type": str,
+            "payload": str,
+            "cassette": bytes,
+        },
+        pk="id",
+        if_not_exists=True,
+    )
+
+
+def insert_run(db: Database) -> str:
+    run_id = str(uuid.uuid4())
+    start_time = datetime.now(timezone.utc).isoformat()
+    db["runs"].insert(
+        {
+            "id": run_id,
+            "start_time": start_time,
+            "status": "running",
+            "framework": "unknown",
+        },
+        pk="id",
+    )
+    return run_id
+
+
+def insert_event(
+    db: Database, run_id: str, type: str, payload: dict, cassette: bytes | None = None
+) -> None:
+    event_id = str(uuid.uuid4())
+    timestamp = datetime.now(timezone.utc).isoformat()
+    db["events"].insert(
+        {
+            "id": event_id,
+            "run_id": run_id,
+            "timestamp": timestamp,
+            "type": type,
+            "payload": json.dumps(payload),
+            "cassette": cassette,
+        },
+        pk="id",
+    )
+
+
+if __name__ == "__main__":
+    db = get_db()
+    create_tables(db)
+    run_id = insert_run(db)
+    insert_event(db, run_id, "test", {"msg": "day 2 works"})
+    print(f"Run created: {run_id}")
+    print(f"Events in db: {db['events'].count}")

agentautopsy/detector.py

@@ -0,0 +1,85 @@
+"""Failure detection and trace snapshots for AgentAutopsy."""
+
+import json
+from typing import Any
+
+from sqlite_utils import Database
+
+
+def detect_failure(run_id: str, db: Database) -> dict[str, Any]:
+    errors = list(
+        db["events"].rows_where(
+            where='run_id = ? AND "type" = ?',
+            where_args=[run_id, "error"],
+            order_by="timestamp",
+        )
+    )
+    if not errors:
+        return {"failed": False, "run_id": run_id}
+
+    row = errors[0]
+    payload: dict[str, Any]
+    raw_payload = row.get("payload")
+    try:
+        payload = json.loads(raw_payload) if raw_payload else {}
+    except (json.JSONDecodeError, TypeError):
+        payload = {}
+
+    return {
+        "failed": True,
+        "run_id": run_id,
+        "error_type": payload.get("error_type"),
+        "message": payload.get("message"),
+        "failure_event_id": row["id"],
+    }
+
+
+def take_snapshot(run_id: str, db: Database) -> list[dict[str, Any]]:
+    rows = list(
+        db["events"].rows_where(
+            where="run_id = ?",
+            where_args=[run_id],
+            order_by="timestamp",
+        )
+    )
+    snapshot: list[dict[str, Any]] = []
+    for row in rows:
+        raw_payload = row.get("payload")
+        try:
+            payload_obj: Any = (
+                json.loads(raw_payload) if raw_payload is not None else {}
+            )
+            if not isinstance(payload_obj, dict):
+                payload_obj = {}
+        except (json.JSONDecodeError, TypeError):
+            payload_obj = {}
+
+        cassette = row.get("cassette")
+        cassette_size = len(cassette) if cassette is not None else 0
+
+        snapshot.append(
+            {
+                "id": row["id"],
+                "type": row["type"],
+                "payload": payload_obj,
+                "cassette_size": cassette_size,
+                "timestamp": row["timestamp"],
+            }
+        )
+    return snapshot
+
+
+if __name__ == "__main__":
+    from agentautopsy.db import create_tables, get_db, insert_event, insert_run
+
+    db = get_db()
+    create_tables(db)
+    run_id = insert_run(db)
+    insert_event(db, run_id, "llm_call", {"model": "gpt-4", "messages": []})
+    insert_event(db, run_id, "error", {"error_type": "TimeoutError", "message": "request timed out"})
+    result = detect_failure(run_id, db)
+    print(f"Failed: {result['failed']}")
+    print(f"Error: {result['error_type']}: {result['message']}")
+    snapshot = take_snapshot(run_id, db)
+    print(f"Snapshot has {len(snapshot)} events")
+    print(f"Event types: {[e['type'] for e in snapshot]}")

agentautopsy/interceptor.py

@@ -0,0 +1,137 @@
+"""OpenAI and Anthropic LLM interceptors for AgentAutopsy."""
+
+from typing import Any, Callable
+
+import openai
+
+from agentautopsy.cassette import save_cassette
+from agentautopsy.db import insert_event
+
+
+def start_interceptor(run_id: str, db: Any) -> None:
+    completions = openai.chat.completions
+    original_create: Callable[..., Any] = completions.create
+
+    def create_wrapper(*args: Any, **kwargs: Any) -> Any:
+        model_name = kwargs.get("model")
+        messages_list = kwargs.get("messages")
+        insert_event(
+            db,
+            run_id,
+            "llm_call",
+            {"model": model_name, "messages": messages_list},
+        )
+        try:
+            response = original_create(*args, **kwargs)
+        except Exception as e:
+            insert_event(
+                db,
+                run_id,
+                "error",
+                {"error_type": type(e).__name__, "message": str(e)},
+            )
+            raise
+        insert_event(
+            db,
+            run_id,
+            "llm_response",
+            {},
+            cassette=save_cassette(response),
+        )
+        return response
+
+    completions.create = create_wrapper
+
+
+def start_anthropic_interceptor(run_id: str, db: Any) -> None:
+    import anthropic
+
+    client_class = anthropic.Anthropic
+    original_init = client_class.__init__
+
+    def patched_init(self, *args: Any, **kwargs: Any) -> None:
+        original_init(self, *args, **kwargs)
+        original_create = self.messages.create
+
+        def create_wrapper(*args: Any, **kwargs: Any) -> Any:
+            insert_event(
+                db,
+                run_id,
+                "llm_call",
+                {
+                    "provider": "anthropic",
+                    "model": kwargs.get("model"),
+                    "messages": kwargs.get("messages"),
+                },
+            )
+            try:
+                response = original_create(*args, **kwargs)
+            except Exception as e:
+                insert_event(
+                    db,
+                    run_id,
+                    "error",
+                    {"error_type": type(e).__name__, "message": str(e)},
+                )
+                raise
+            insert_event(
+                db,
+                run_id,
+                "llm_response",
+                {},
+                cassette=save_cassette(response),
+            )
+            return response
+
+        self.messages.create = create_wrapper
+
+    client_class.__init__ = patched_init
+
+
+def start_http_interceptor(run_id: str, db: Any) -> None:
+    import httpx
+
+    original_send = httpx.Client.send
+
+    def patched_send(self, request, **kwargs):
+        insert_event(
+            db,
+            run_id,
+            "http_request",
+            {"method": request.method, "url": str(request.url)},
+        )
+        try:
+            response = original_send(self, request, **kwargs)
+        except Exception as e:
+            insert_event(
+                db,
+                run_id,
+                "error",
+                {"error_type": type(e).__name__, "message": str(e)},
+            )
+            raise
+        insert_event(
+            db,
+            run_id,
+            "http_response",
+            {"status_code": response.status_code},
+            cassette=response.content,
+        )
+        return response
+
+    httpx.Client.send = patched_send
+
+
+if __name__ == "__main__":
+    from agentautopsy.db import create_tables, get_db, insert_run
+
+    db = get_db()
+    create_tables(db)
+    run_id = insert_run(db)
+    start_interceptor(run_id, db)
+    start_anthropic_interceptor(run_id, db)
+    start_http_interceptor(run_id, db)
+    print("OpenAI patched")
+    print("Anthropic patched")
+    print("HTTP patched")
+    print("Both interceptors active")

agentautopsy/pruner.py

@@ -0,0 +1,58 @@
+"""Counterfactual pruner for AgentAutopsy snapshots."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def prune(snapshot: list[dict[str, Any]], failure_event_id: str) -> list[dict[str, Any]]:
+    by_id = {e.get("id"): e for e in snapshot}
+    failure = by_id.get(failure_event_id)
+    if failure is None:
+        return []
+
+    ordered = sorted(snapshot, key=lambda e: e.get("timestamp", ""))
+    failure_index = next(
+        (i for i, e in enumerate(ordered) if e.get("id") == failure_event_id), None
+    )
+
+    keep_ids: set[str] = {failure_event_id}
+
+    if failure_index is not None and failure_index > 0:
+        prev = ordered[failure_index - 1]
+        prev_id = prev.get("id")
+        if isinstance(prev_id, str):
+            keep_ids.add(prev_id)
+
+    for e in ordered:
+        ev_id = e.get("id")
+        ev_type = e.get("type")
+        if not isinstance(ev_id, str):
+            continue
+
+        if ev_type in ("llm_call", "tool_call", "error"):
+            keep_ids.add(ev_id)
+
+    pruned = [e for e in ordered if e.get("id") in keep_ids]
+    pruned = [e for e in pruned if e.get("type") not in ("llm_response", "http_response")]
+
+    pruned = sorted(pruned, key=lambda e: e.get("timestamp", ""))
+    if len(pruned) > 10:
+        pruned = pruned[-10:]
+
+    return pruned
+
+
+if __name__ == "__main__":
+    fake_snapshot = [
+        {"id": "1", "type": "llm_call", "payload": {"model": "gpt-4"}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:01"},
+        {"id": "2", "type": "llm_response", "payload": {}, "cassette_size": 142, "timestamp": "2024-01-01T00:00:02"},
+        {"id": "3", "type": "http_request", "payload": {"method": "GET", "url": "https://api.example.com"}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:03"},
+        {"id": "4", "type": "http_response", "payload": {"status_code": 200}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:04"},
+        {"id": "5", "type": "llm_call", "payload": {"model": "gpt-4"}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:05"},
+        {"id": "6", "type": "error", "payload": {"error_type": "TimeoutError", "message": "timed out"}, "cassette_size": 0, "timestamp": "2024-01-01T00:00:06"},
+    ]
+    pruned = prune(fake_snapshot, "6")
+    print(f"Original events: {len(fake_snapshot)}")
+    print(f"Pruned events: {len(pruned)}")
+    print(f"Kept types: {[e['type'] for e in pruned]}")

agentautopsy/replay.py

@@ -0,0 +1,75 @@
+"""Replay sandbox for AgentAutopsy."""
+
+from typing import Any
+
+import openai
+
+from agentautopsy.cassette import load_cassette
+from agentautopsy.detector import take_snapshot
+
+
+def replay(run_id: str, db: Any, patch_instructions: str) -> dict[str, Any]:
+    snapshot = take_snapshot(run_id, db)
+
+    cassette_map: dict[int, dict[str, Any]] = {}
+    index = 0
+    for event in snapshot:
+        if event["type"] != "llm_response":
+            continue
+        if event["cassette_size"] <= 0:
+            continue
+        row = db["events"].get(event["id"])
+        if row is None:
+            continue
+        cassette_bytes = row.get("cassette")
+        if cassette_bytes is None:
+            continue
+        response_dict = load_cassette(cassette_bytes)
+        if not response_dict:
+            continue
+        cassette_map[index] = response_dict
+        index += 1
+
+    original_create = openai.chat.completions.create
+    responses = [cassette_map[i] for i in range(len(cassette_map))]
+    call_index = [0]
+
+    def replay_create(*args: Any, **kwargs: Any) -> dict[str, Any]:
+        if call_index[0] >= len(responses):
+            raise RuntimeError("No more cassette responses to replay")
+        response = responses[call_index[0]]
+        call_index[0] += 1
+        return response
+
+    openai.chat.completions.create = replay_create
+    verified = False
+    try:
+        if cassette_map:
+            result = openai.chat.completions.create(model="gpt-4", messages=[])
+            verified = result == cassette_map[0]
+    finally:
+        openai.chat.completions.create = original_create
+
+    return {
+        "verified": verified,
+        "patch_instructions": patch_instructions,
+        "events_replayed": len(cassette_map),
+    }
+
+
+if __name__ == "__main__":
+    import json
+
+    from agentautopsy.db import create_tables, get_db, insert_event, insert_run
+
+    db = get_db()
+    create_tables(db)
+    run_id = insert_run(db)
+    fake_response = {"id": "chatcmpl-123", "choices": [{"message": {"content": "hello"}}]}
+    insert_event(db, run_id, "llm_call", {"model": "gpt-4", "messages": []})
+    insert_event(db, run_id, "llm_response", {}, cassette=json.dumps(fake_response).encode())
+    insert_event(db, run_id, "error", {"error_type": "TimeoutError", "message": "timed out"})
+    result = replay(run_id, db, "Add timeout=60 to the API call")
+    print(f"Verified: {result['verified']}")
+    print(f"Events replayed: {result['events_replayed']}")
+    print(f"Patch: {result['patch_instructions']}")

agentautopsy/reporter.py

@@ -0,0 +1,105 @@
+"""Terminal reporter for AgentAutopsy."""
+
+import json
+from typing import Any
+
+RESET = "\033[0m"
+CYAN = "\033[96m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+RED_BOLD = "\033[91;1m"
+
+EVENT_COLORS: dict[str, str] = {
+    "llm_call": CYAN,
+    "error": RED,
+    "http_request": YELLOW,
+    "http_response": GREEN,
+    "llm_response": BLUE,
+}
+
+TAG_WIDTH = 17
+
+
+def _colored_event_tag(ev_type: str) -> str:
+    color = EVENT_COLORS.get(ev_type)
+    if color:
+        return f"{color}[{ev_type}]{RESET}"
+    return f"[{ev_type}]"
+
+
+def _print_event_line(ev_type: str, detail: str) -> None:
+    plain_tag = f"[{ev_type}]"
+    colored_tag = _colored_event_tag(ev_type)
+    padding = " " * max(0, TAG_WIDTH - len(plain_tag))
+    if detail:
+        print(f"{colored_tag}{padding}{detail}")
+    else:
+        print(colored_tag)
+
+
+def print_report(run_id: str, db: Any) -> None:
+    sep = "═══════════════════════════════════"
+    rows = list(
+        db["events"].rows_where(
+            where="run_id = ?",
+            where_args=[run_id],
+            order_by="timestamp",
+        )
+    )
+
+    print(sep)
+    print(" AgentAutopsy — Run Report")
+    print(f" Run ID: {run_id}")
+    print(sep)
+
+    for row in rows:
+        ev_type = row["type"]
+        try:
+            payload = json.loads(row["payload"]) if row.get("payload") else {}
+        except (json.JSONDecodeError, TypeError):
+            payload = {}
+        cassette = row.get("cassette")
+        blob = cassette if cassette is not None else b""
+
+        if ev_type == "llm_call":
+            detail = f"model: {payload.get('model')}"
+        elif ev_type == "llm_response":
+            detail = f"cassette: {len(blob)} bytes"
+        elif ev_type == "http_request":
+            detail = f"{payload.get('method')} {payload.get('url')}"
+        elif ev_type == "http_response":
+            detail = f"status: {payload.get('status_code')}"
+        elif ev_type == "error":
+            detail = f"{payload.get('error_type')}: {payload.get('message')}"
+        else:
+            detail = ""
+
+        _print_event_line(ev_type, detail)
+
+    root_sep = "══════════════════════════════════════"
+    error_index = None
+    error_payload: dict[str, Any] = {}
+    for i, row in enumerate(rows, start=1):
+        if row["type"] == "error" and error_index is None:
+            error_index = i
+            try:
+                error_payload = (
+                    json.loads(row["payload"]) if row.get("payload") else {}
+                )
+            except (json.JSONDecodeError, TypeError):
+                error_payload = {}
+            if not isinstance(error_payload, dict):
+                error_payload = {}
+
+    if error_index is not None:
+        print(f"{RED_BOLD}→ Divergence detected at event {error_index}{RESET}")
+        error_type = error_payload.get("error_type")
+        message = error_payload.get("message")
+        print(root_sep)
+        print(f"{RED_BOLD}Root Cause: {error_type} — {message}{RESET}")
+        print(root_sep)
+
+    print(sep)
+    print(f"Total events: {len(rows)}")

agentautopsy-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: agentautopsy
+Version: 0.1.0
+Summary: When your agent fails, this tells you exactly why.
+Project-URL: Homepage, https://github.com/Abhisekhpatel/AgentAutopsy
+Author: Abhishek Patel
+Keywords: ai-agents,debugging,llm,observability
+Requires-Python: >=3.11
+Requires-Dist: anthropic
+Requires-Dist: httpx
+Requires-Dist: openai
+Requires-Dist: sqlite-utils
+Requires-Dist: sqlite-vec
+Description-Content-Type: text/markdown
+
+# AgentAutopsy
+
+> When your agent fails, this tells you exactly why.
+
+![demo](assets/demo.png)
+
+![Python](https://img.shields.io/badge/python-3.11+-blue)
+![License](https://img.shields.io/badge/license-Apache%202.0-green)
+![Zero Config](https://img.shields.io/badge/config-zero-brightgreen)
+![Works with](https://img.shields.io/badge/works%20with-OpenAI%20%2B%20Anthropic-orange)
+
+## CLI
+
+agentautopsy runs        # see all agent runs
+agentautopsy replay <id> # replay any failure
+agentautopsy stats       # fix cache stats
+
+## Install
+
+```bash
+pip install git+https://github.com/Abhisekhpatel/AgentAutopsy.git
+```
+
+## Usage
+
+```python
+import agentautopsy
+agentautopsy.watch()
+# your existing agent code here — nothing else changes
+```
+
+AgentAutopsy automatically intercepts every LLM call, detects failures, finds root cause, outputs a verified fix, and caches it for next time.
+
+## Setup
+
+Windows: `set ANTHROPIC_API_KEY=your-key-here`
+Mac/Linux: `export ANTHROPIC_API_KEY=your-key-here`
+Get your free key at console.anthropic.com
+
+## Quick start
+
+Create test_agent.py and paste this:
+
+```python
+import agentautopsy
+agentautopsy.watch()
+```
+
+Run: `python test_agent.py`
+
+## Works with
+
+OpenAI, Anthropic, LangChain, any framework using openai or anthropic
+
+## Requirements
+
+Python 3.11+, ANTHROPIC_API_KEY
+
+## License
+
+Apache 2.0

agentautopsy-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+agentautopsy/__init__.py,sha256=qw_iAS2wgLpGeBVGSbUU5bUjd5XUJLoVbYO6kszme4I,2164
+agentautopsy/analyzer.py,sha256=WPlPuzc9hDdBqABfNPpwJtxvR5-WtECxlyey9QXjtao,1649
+agentautopsy/cache.py,sha256=DiW20PS6bvtQWrBzS4iI3z6qxNrfkJZ2ph4eiA9Iaj0,3149
+agentautopsy/cassette.py,sha256=KBVh12rJgLVoMl2MSLwV-QlmigEEUjatqiLRs0OBT08,905
+agentautopsy/cli.py,sha256=mwxlQvjrSekGPB9uGq-gfyhMYIGseLhIGx-G3V-A1fE,1591
+agentautopsy/db.py,sha256=jZfcuxsidH-YoZyKZrnluAA0Og-3zO3XJLI6Nu7boh4,1893
+agentautopsy/detector.py,sha256=MawIiivn-VvWDrZYwHbtNyHScsNpnQ5zhoI3nz7xgeI,2661
+agentautopsy/interceptor.py,sha256=urJqubXws7z0F5KYeLOpaoAvRij1ZBIvvI01oaCf6qc,3922
+agentautopsy/pruner.py,sha256=NswqXphnhNsmbWrZcDiWXzwgEkddkEpHDzj6sr8hc_I,2441
+agentautopsy/replay.py,sha256=IKIyrxnEgjZp-0oJKWkax-miaejZx1KSWYH8ixDRX-8,2592
+agentautopsy/reporter.py,sha256=8G4nYHqVsTlEXsAgQAIvwAbYN6TuAfiDt3s9N-CMiNE,3333
+agentautopsy-0.1.0.dist-info/METADATA,sha256=aJJvgw6Gkau9YmC543G5bg6u6plA8nmq4nd2Q99UUMk,1777
+agentautopsy-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentautopsy-0.1.0.dist-info/entry_points.txt,sha256=VPCwaHHBQ29Mq7a71w1tNCHDVzprkH8K6yAPxvx5SoE,55
+agentautopsy-0.1.0.dist-info/RECORD,,

agentautopsy-0.1.0.dist-info/WHEEL

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

agentautopsy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentautopsy = agentautopsy.cli:main