agentdebugx 0.1.0__tar.gz → 0.2.0__tar.gz

{agentdebugx-0.1.0 → agentdebugx-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentdebugx
-Version: 0.1.0
+Version: 0.2.0
 Summary: Portable error analysis, tracing, and recovery framework for agentic AI systems. Import as `agentdebug`.
 License: MIT
 License-File: LICENSE
@@ -26,7 +26,9 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: System :: Monitoring
 Classifier: Typing :: Typed
 Provides-Extra: all
+Provides-Extra: hub-hf
 Provides-Extra: langgraph
+Provides-Extra: openhands
 Provides-Extra: otel
 Provides-Extra: ui
 Requires-Dist: httpx (>=0.24,<1.0)
@@ -101,7 +103,7 @@ spell out the proposed path before we lock into heavy abstractions.
 ## Install
 
 ```bash
-# From PyPI (distribution name: agentdebugx; import as `agentdebug`)
+# From PyPI (distribution name `agentdebugx`; the short import is `agentdebug`)
 pip install agentdebugx
 
 # With the optional local dashboard
@@ -113,6 +115,12 @@ pip install 'agentdebugx[langgraph]'
 # With OpenTelemetry GenAI export shim
 pip install 'agentdebugx[otel]'
 
+# With Hugging Face Datasets backend for the Error Hub
+pip install 'agentdebugx[hub-hf]'
+
+# With OpenHands EventStream bridge
+pip install 'agentdebugx[openhands]'
+
 # Everything
 pip install 'agentdebugx[all]'
 ```
@@ -123,6 +131,10 @@ From source:
 pip install -e .         # or: poetry install
 ```
 
+> The PyPI distribution name is `agentdebugx` because PyPI's name policy
+> (PEP 503 normalization) collides `agentdebug` with the existing
+> `agent-debug` package. The Python import is always `import agentdebug`.
+
 ## Quick Start
 
 ```python
@@ -172,6 +184,21 @@ agentdebug judge examples/sample_trace.json --attribute
 # Launch the local dashboard at http://127.0.0.1:7777
 agentdebug serve --store-sqlite .agentdebug/errors.sqlite
 
+# DeepDebug — iterative multi-turn analysis (plan -> hypothesize -> verify -> refine)
+agentdebug deep <trajectory.json>
+
+# Error Hub: package + push a trace to a Git remote or HF dataset
+agentdebug hub push <trace_id> \
+    --to git:git@github.com:your-org/agentdebug-bundles.git#bundles \
+    --store-sqlite .agentdebug/errors.sqlite
+
+# Pull a bundle someone else shared
+agentdebug hub pull git:... --bundle bundle_01ABCD --into .agentdebug/hub_pulls
+
+# Host integrations: generate a Claude Code Skill, or an OpenHands microagent
+agentdebug integrations skill --target ~/.claude/skills
+agentdebug integrations openhands-microagent --target .openhands/microagents
+
 # Diagnose which adapters / integrations are available
 agentdebug doctor
 ```

{agentdebugx-0.1.0 → agentdebugx-0.2.0}/README.md

@@ -63,7 +63,7 @@ spell out the proposed path before we lock into heavy abstractions.
 ## Install
 
 ```bash
-# From PyPI (distribution name: agentdebugx; import as `agentdebug`)
+# From PyPI (distribution name `agentdebugx`; the short import is `agentdebug`)
 pip install agentdebugx
 
 # With the optional local dashboard
@@ -75,6 +75,12 @@ pip install 'agentdebugx[langgraph]'
 # With OpenTelemetry GenAI export shim
 pip install 'agentdebugx[otel]'
 
+# With Hugging Face Datasets backend for the Error Hub
+pip install 'agentdebugx[hub-hf]'
+
+# With OpenHands EventStream bridge
+pip install 'agentdebugx[openhands]'
+
 # Everything
 pip install 'agentdebugx[all]'
 ```
@@ -85,6 +91,10 @@ From source:
 pip install -e .         # or: poetry install
 ```
 
+> The PyPI distribution name is `agentdebugx` because PyPI's name policy
+> (PEP 503 normalization) collides `agentdebug` with the existing
+> `agent-debug` package. The Python import is always `import agentdebug`.
+
 ## Quick Start
 
 ```python
@@ -134,6 +144,21 @@ agentdebug judge examples/sample_trace.json --attribute
 # Launch the local dashboard at http://127.0.0.1:7777
 agentdebug serve --store-sqlite .agentdebug/errors.sqlite
 
+# DeepDebug — iterative multi-turn analysis (plan -> hypothesize -> verify -> refine)
+agentdebug deep <trajectory.json>
+
+# Error Hub: package + push a trace to a Git remote or HF dataset
+agentdebug hub push <trace_id> \
+    --to git:git@github.com:your-org/agentdebug-bundles.git#bundles \
+    --store-sqlite .agentdebug/errors.sqlite
+
+# Pull a bundle someone else shared
+agentdebug hub pull git:... --bundle bundle_01ABCD --into .agentdebug/hub_pulls
+
+# Host integrations: generate a Claude Code Skill, or an OpenHands microagent
+agentdebug integrations skill --target ~/.claude/skills
+agentdebug integrations openhands-microagent --target .openhands/microagents
+
 # Diagnose which adapters / integrations are available
 agentdebug doctor
 ```

agentdebugx-0.2.0/docs/19_error_hub.md

@@ -0,0 +1,148 @@
+# 19 — Error Hub
+
+## 1. What it solves
+
+A team-or-community channel for **packaging a failing agent trajectory + its
+analysis** and pushing it to a backend (Git remote, Hugging Face Datasets
+repo, or a local directory), plus pulling and listing what others have
+shared. The Hub is how AgentDebugX makes the trace your colleague is staring
+at into the regression case your CI rejects.
+
+## 2. Unit of share — the `Bundle`
+
+```
+bundle_<id>/
+├── manifest.json     # typed metadata (BundleManifest, schema 1.0.0)
+├── trajectory.json   # AgentTrajectory JSON
+├── report.json       # DiagnosticReport JSON (optional)
+├── artifacts/        # binary attachments (screenshots, files) — optional
+└── README.md         # auto-generated human summary
+```
+
+`BundleManifest` carries: `bundle_id`, `trace_id`, `framework`, `goal_summary`
+(truncated, post-scrub), `failure_families`, `failure_mode_ids`,
+`root_cause_step_index`, `root_cause_agent`, `n_events`, `has_report`,
+`has_artifacts`, `license`, `contributor`, `contributor_org`, `scrubbed`,
+`scrubber_version`, `notes`.
+
+The directory layout is intentionally framework-, language-, and
+storage-agnostic — anything that can read JSON can ingest a bundle.
+
+## 3. Backends — `HubBackend` Protocol
+
+| Scheme | Class | Dependencies | Use for |
+|---|---|---|---|
+| `local:/path` | `LocalHubBackend` | stdlib only | tests, air-gapped envs, NFS shares |
+| `git:<remote>[#<subpath>]` | `GitHubBackend` | `git` CLI | GitHub / GitLab / Gitea / self-hosted git |
+| `hf:<repo_id>[#<subpath>]` | `HuggingFaceBackend` | `huggingface_hub` (`[hub-hf]` extra) | community datasets, discoverable corpora |
+
+All three implement:
+
+```python
+class HubBackend(Protocol):
+    scheme: str
+    def push(self, bundle: Bundle, *, message: str | None = None) -> str: ...
+    def pull(self, bundle_id: str, *, into: Path) -> Path: ...
+    def list_bundles(self, *, limit: int = 100) -> list[str]: ...
+```
+
+`backend_from_spec("git:...#...")` dispatches by scheme prefix; the CLI
+calls this so a single `--to` arg can target any backend.
+
+## 4. Privacy: scrubbing is default-on
+
+Every `agentdebug hub push` runs `Scrubber.scrub_trajectory` first. The
+default `DEFAULT_REDACTIONS` cover:
+
+- API keys: OpenAI, Anthropic, AWS access key + secret, Google, GitHub, PyPI
+- Bearer tokens, URL-embedded credentials
+- PII: emails, E.164 phone numbers, US SSNs, credit cards
+
+Opt-out via `--no-scrub` for trusted internal hubs only — the CLI prints a
+warning when used. The scrubber is **idempotent** (running it twice changes
+nothing), versioned (`SCRUBBER_VERSION` is recorded in the manifest), and
+produces an audit report (`ScrubReport.replacements`).
+
+For higher recall, drop in a Microsoft Presidio backend via a custom
+`Scrubber` subclass — the architecture is built for replacement.
+
+## 5. CLI
+
+```bash
+# Push to a local hub
+agentdebug hub push <trace_id> \
+    --to local:/srv/agentdebug-hub \
+    --store-sqlite .agentdebug/errors.sqlite
+
+# Push to a Git remote (any SSH/HTTPS git host)
+agentdebug hub push <trace_id> \
+    --to git:git@github.com:your-org/agentdebug-bundles.git#bundles \
+    --store-sqlite .agentdebug/errors.sqlite \
+    --message "Customer escalation 2026-05-16"
+
+# Push to a Hugging Face dataset (requires HF_TOKEN)
+agentdebug hub push <trace_id> \
+    --to hf:your-org/agentdebug-bundles \
+    --store-sqlite .agentdebug/errors.sqlite \
+    --license CC-BY-4.0
+
+# Pull a bundle from anywhere
+agentdebug hub pull git:git@github.com:org/repo.git#bundles \
+    --bundle bundle_01ABCD --into .agentdebug/hub_pulls
+
+# List what's there
+agentdebug hub list hf:your-org/agentdebug-bundles --limit 100
+```
+
+## 6. Authentication
+
+By design, AgentDebugX never holds credentials.
+
+- Git: relies on `git` being configured (SSH key, credential helper, env-based
+  PAT). Whatever lets you `git push` works.
+- Hugging Face: relies on `HF_TOKEN` or `huggingface-cli login`. Standard.
+- Local: filesystem permissions.
+
+This keeps the security surface small and lets ops teams use their existing
+key-management.
+
+## 7. Programmatic API
+
+```python
+from agentdebug.hub import (
+    Bundle, build_manifest, backend_from_spec, scrub_trajectory,
+)
+from agentdebug.analyzers import HeuristicAnalyzer
+
+scrub_trajectory(trajectory)  # mutates in place
+report = HeuristicAnalyzer().analyze(trajectory)
+manifest = build_manifest(trajectory, report=report, scrubbed=True)
+backend = backend_from_spec("local:/srv/hub")
+ref = backend.push(Bundle(manifest=manifest, trajectory=trajectory, report=report))
+```
+
+## 8. Discoverability + Hugging Face
+
+The HF backend uploads each bundle under `bundles/<bundle_id>/` in a Datasets
+repo. Once a project accumulates enough bundles, generate a Parquet roll-up
+of the manifests (planned for v0.3) so you can search by failure family,
+framework, or root-cause step in the HF dataset viewer.
+
+## 9. Status (v0.1)
+
+Shipping:
+
+- `Bundle`, `BundleManifest`, `pack_bundle`, `unpack_bundle`
+- `Scrubber` + `DEFAULT_REDACTIONS` (12 patterns) + `ScrubReport`
+- `LocalHubBackend` (stdlib only)
+- `GitHubBackend` (via `git` CLI; tested against a local bare repo in CI)
+- `HuggingFaceBackend` (gated on `huggingface_hub`)
+- CLI: `hub push | pull | list`
+
+Roadmap:
+
+- Bundle signing + provenance (Sigstore)
+- Parquet manifest roll-up for fast `hub search`
+- Community moderation queue + take-down workflow
+- Differential bundles (push only what changed since last push)
+- Dataset card auto-generation for HF uploads

agentdebugx-0.2.0/docs/20_deep_debug.md

@@ -0,0 +1,135 @@
+# 20 — DeepDebug: Iterative Multi-Turn Error Analysis
+
+## 1. Why a deeper loop
+
+A one-shot LLM judge (`LLMJudgeAnalyzer`) is fast but biased:
+
+- It tends to flag *manifestations* (tool exceptions, system errors) and miss
+  *root causes* (planner ignored a constraint, agent dropped handoff context).
+- It does not separate "I see a finding" from "the trajectory actually supports
+  this finding."
+- It returns a flat list, not a causal chain.
+
+DeepDebug is the **deep-research-style** counterpart, modeled after recent
+agent-as-judge and deep-research methods. The cost is higher (multiple LLM
+calls per trace) and the quality is higher.
+
+## 2. Loop structure
+
+```
+R0 plan        — LLM proposes investigation focus (which event_ids, what questions)
+R1 hypothesize — LLM produces candidate findings on the focus set
+R2 verify (per-h) — LLM re-reads the trajectory and rates each hypothesis:
+                    corroborated / weak / contradicted
+R3 refine      — LLM merges, drops weak/contradicted, picks single root cause
+Rfinal report  — DiagnosticReport + DeepDebugTrace audit trail
+```
+
+Each round is recorded as a typed `DeepDebugRound`:
+
+```python
+@dataclass
+class DeepDebugRound:
+    name: str                # plan | hypothesize | verify:<h_id> | refine
+    request_summary: str
+    response_summary: str
+    duration_ms: int
+    payload: dict
+```
+
+This audit trail is the point. Users can replay *how* the diagnosis was
+reached, not just *what* it is.
+
+## 3. Public API
+
+```python
+from agentdebug.deep import DeepDebugAnalyzer
+from agentdebug.llm import OpenAICompatClient
+
+llm = OpenAICompatClient(base_url=..., api_key=..., model='gpt-4o-mini',
+                        default_max_tokens=8192, timeout=180.0)
+
+result = DeepDebugAnalyzer(
+    llm=llm,
+    max_focus_events=7,
+    max_hypotheses_to_verify=6,
+    max_tokens=4096,
+).analyze(trajectory)
+
+print(result.report.summary)
+for r in result.rounds:                       # audit trail
+    print(r.name, r.duration_ms, 'ms')
+for h in result.hypotheses:                   # all hypotheses, verified or not
+    print(h.id, h.verdict, h.confidence_posterior)
+```
+
+CLI:
+
+```bash
+agentdebug deep <trajectory.json> --out deep.json
+agentdebug deep <trace_id> --store-sqlite .agentdebug/errors.sqlite \
+    --base-url https://.../v1 --api-key sk-... --model gemini-3-flash
+```
+
+## 4. Cost and latency model
+
+Per trace: roughly `1 plan + 1 hypothesize + K verify + 1 refine` calls,
+where `K ≤ max_hypotheses_to_verify`. For a 4-event trace with K=3 against
+Gemini-3-flash we observed 6 rounds in ~29 seconds. Use:
+
+- `LLMJudgeAnalyzer` for inline / per-step quick scans.
+- `DeepDebugAnalyzer` for postmortems, escalations, hard regressions.
+
+## 5. What "verify" actually does
+
+Crucially, **verification does not re-execute the agent's tools**. It re-reads
+the *existing* trajectory more carefully against the specific hypothesis.
+Verdict choices:
+
+- `corroborated` — trajectory evidence supports the hypothesis.
+- `weak`         — trajectory is ambiguous; no clear support either way.
+- `contradicted` — trajectory explicitly conflicts with the hypothesis.
+
+Counterfactual replay (where the agent IS re-rolled to test causality) is a
+separate v2 feature; it composes with DeepDebug but is not required for it.
+
+## 6. Live result (v0.1, gemini-3-flash, 4-event trace)
+
+DeepDebug on a synthetic trace where the planner called `search_web` with
+`args={}` and then summarized a fabricated answer:
+
+```
+summary       : "The search agent failed to provide a query parameter to the
+                 search tool, and the planner subsequently ignored this failure,
+                 hallucinated a result, and terminated the task without emailing
+                 the summary as required."
+findings      : action.parameter_error (s2, 1.00)
+                reflection.progress_misjudge (s4, 1.00)
+                verification.premature_stop (s4, 1.00)
+root_cause    : step=2, agent=search
+rounds        : plan (4.6s) hypothesize (11.0s)
+                verify:h1 (2.0s) verify:h2 (2.4s) verify:h3 (2.7s)
+                refine (6.4s)
+```
+
+The single-pass `LLMJudgeAnalyzer` on the same trace returned only the first
+finding. DeepDebug recovered the full cascade and selected the upstream cause.
+
+## 7. Failure modes
+
+- **Cost blowout** — if `max_hypotheses_to_verify` is high and verify is
+  expensive, costs scale linearly. Pin a budget.
+- **Hypothesis fishing** — the LLM may invent hypotheses to look thorough.
+  The verify round filters most of these (`contradicted` / `weak`); the
+  refine round drops any low-confidence stragglers.
+- **Thinking-token budgets** — Gemini-3-flash and o-series models spend a
+  large fraction of `max_tokens` on reasoning. Default `max_tokens=4096` is
+  conservative; raise to 8192 for long traces or fine-grained verifiers.
+
+## 8. Roadmap
+
+- Counterfactual-replay round (re-roll oracle-corrected step + re-judge).
+- Step-by-step verifier mode (Who&When-style sweep).
+- Adaptive K — decide how many hypotheses to verify based on round-1 spread.
+- Specialized verifiers (tool-call-arg verifier, multi-agent handoff verifier).
+- Persistent reasoning cache so re-runs on the same trace skip re-thought.

agentdebugx-0.2.0/docs/21_integrations.md

@@ -0,0 +1,140 @@
+# 21 — Host-Runtime Integrations: Claude Code Skill + OpenHands
+
+This doc covers how AgentDebugX plugs into existing host agent runtimes as a
+sub-module the host can call on demand.
+
+The constraints we honor:
+
+1. **No fork.** The integration always calls back into the locally installed
+   `agentdebug` CLI / Python API, never duplicates AgentDebugX code into the
+   host's runtime tree. Upgrading AgentDebugX upgrades the integration.
+2. **Suggest-only by default.** Recovery proposals are never auto-applied;
+   the host agent surfaces them to the user.
+3. **Privacy boundary.** Integrations never auto-upload to the community Hub
+   without explicit user opt-in.
+
+## 1. Claude Code Skill
+
+`agentdebug.integrations.claude_skill` generates a Claude Code
+[Skill](https://www.claude.com/claude-code) package that wraps the
+AgentDebugX CLI. Skills are folders of `SKILL.md` + assets that Claude can
+match against and invoke on demand.
+
+### Generate
+
+```bash
+agentdebug integrations skill --target ~/.claude/skills --name agentdebug
+# wrote Claude Skill -> /home/<user>/.claude/skills/agentdebug
+```
+
+Or programmatically:
+
+```python
+from pathlib import Path
+from agentdebug.integrations import build_skill_bundle, write_skill_bundle
+
+bundle = build_skill_bundle(name='agentdebug')
+write_skill_bundle(bundle, target_dir=Path.home() / '.claude' / 'skills')
+```
+
+### What it contains
+
+- `SKILL.md` — frontmatter (`name`, `description`, `license`) + trigger
+  phrases (e.g., "debug this agent run", "why did this agent fail", "find
+  the root cause", "analyze this trajectory") + a recipe for choosing
+  between quick-scan / judge / DeepDebug / Hub push based on user intent.
+- `README.md` — refresh instructions.
+
+### How Claude uses it
+
+When the user mentions a trajectory file, store path, or asks debugging
+questions, Claude's skill matcher fires and Claude invokes the right CLI
+command:
+
+| User intent | Skill recipe |
+|---|---|
+| "what failed?" | `agentdebug analyze <file> --suggest` |
+| "who caused it?" | `agentdebug judge <file|trace_id> --attribute` |
+| "I need a thorough postmortem" | `agentdebug deep <file|trace_id>` |
+| "share this with the team" | `agentdebug hub push <trace_id> --to git:...` |
+
+## 2. OpenHands integration
+
+`agentdebug.integrations.openhands` ships two complementary pieces.
+
+### 2.1 Microagent contract (passive — host invokes us)
+
+```bash
+agentdebug integrations openhands-microagent --target .openhands/microagents
+# wrote OpenHands microagent -> .openhands/microagents/agentdebug.md
+```
+
+The generated markdown is a [knowledge
+microagent](https://github.com/All-Hands-AI/OpenHands) — Claude / GPT
+running inside OpenHands reads it as context when a trigger phrase fires
+("debug agent failure", "root cause analysis", "analyze trajectory", …),
+then calls the `agentdebug` CLI through OpenHands' shell tool.
+
+### 2.2 Event-stream bridge (active — we record OpenHands)
+
+```python
+from agentdebug import AgentDebug
+from agentdebug.integrations import OpenHandsBridge
+
+debugger = AgentDebug()
+trajectory = debugger.start_trace(goal="...", framework="openhands")
+bridge = OpenHandsBridge(debugger=debugger, trajectory=trajectory).attach(
+    conversation.event_stream
+)
+
+# ...run the OpenHands session normally...
+
+bridge.detach()
+debugger.finish_trace(trajectory, success=success)
+report = HeuristicAnalyzer().analyze(trajectory)
+```
+
+The bridge subscribes to `EventStreamSubscriber.MAIN` and translates each
+typed `Action` / `Observation` into an `AgentEvent`. `*Action` → `TOOL_CALL`,
+`*Observation` → `TOOL_RESULT`, everything else → `OBSERVATION`. The
+mapping is heuristic but consistent because OpenHands' class names follow
+a strict convention.
+
+## 3. Why two entry points?
+
+- **Microagent** is the *deferred* path: AgentDebugX runs only when the host
+  agent or user asks for it. Zero overhead when idle, no instrumentation of
+  the host's hot loop.
+- **EventStreamBridge** is the *passive* path: AgentDebugX captures every
+  session, even when nothing went wrong. Costs a small per-step overhead but
+  gives you a complete trajectory store you can later analyze (or push to a
+  Hub for review).
+
+Most teams want both — microagent for on-demand debugging during
+development, bridge for production passive observability.
+
+## 4. Beyond Claude Code / OpenHands
+
+The same pattern applies to any host runtime that has a tool/skill registry
++ an event stream. Concretely, the abstractions to copy are:
+
+- A **trigger-matched documentation contract** (Skill.md, microagent.md) that
+  describes when to invoke AgentDebugX and what arguments to pass.
+- A **structured event stream subscription** that maps host events into
+  `AgentEvent`.
+
+Future targets include LangGraph's checkpointer hooks, AutoGen's group-chat
+event bus, and Pydantic-AI's OTel integration. See
+[docs/05_adapters.md](./05_adapters.md) for the per-framework adapter plan.
+
+## 5. Testing
+
+`tests/test_deep_and_integrations.py` covers:
+
+- Skill bundle generates valid `SKILL.md` with trigger phrases.
+- OpenHands microagent emits valid YAML front-matter and references
+  `CodeActAgent` / suggest-only safety language.
+
+Live integration tests (Claude Code + OpenHands) are out of scope for CI —
+they require the host runtimes installed. The generated artifacts are pure
+files, so eyeballing them after generation is the recommended QA path.

{agentdebugx-0.1.0 → agentdebugx-0.2.0}/docs/README.md

@@ -28,6 +28,9 @@ This `docs/` directory contains the full design specification.
 | 17 | [17_claude_code_design_patterns.md](./17_claude_code_design_patterns.md) | Claude Code-inspired runtime patterns: hooks, permissions, skills, subagents, MCP, plugins |
 | 18 | [18_comparison_codex_vs_design.md](./18_comparison_codex_vs_design.md) | Comparison of the working Codex scaffold and the expanded design spec |
 | 18 | [18_comparison_codex_vs_design.md](./18_comparison_codex_vs_design.md) | Reconciliation of the Codex scaffold with this design spec — the merged v0.1 plan |
+| 19 | [19_error_hub.md](./19_error_hub.md) | **Error Hub** — bundle format, Local / Git / HF backends, scrubbing |
+| 20 | [20_deep_debug.md](./20_deep_debug.md) | **DeepDebug** — iterative multi-turn analysis (plan → hypothesize → verify → refine) |
+| 21 | [21_integrations.md](./21_integrations.md) | **Claude Code Skill** + **OpenHands** microagent + EventStream bridge |
 
 Plus three **narrative** docs that pre-dated this engineering spec and are kept for paper-style framing:
 

{agentdebugx-0.1.0 → agentdebugx-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agentdebugx"
-version = "0.1.0"
+version = "0.2.0"
 description = "Portable error analysis, tracing, and recovery framework for agentic AI systems. Import as `agentdebug`."
 authors = ["ULab @ UIUC <ulab@illinois.edu>"]
 license = "MIT"
@@ -54,12 +54,15 @@ httpx = ">=0.24,<1.0"
 langgraph = ["langchain-core"]
 otel = ["opentelemetry-api", "opentelemetry-sdk"]
 ui = ["fastapi", "uvicorn"]
+hub-hf = ["huggingface_hub"]
+openhands = ["openhands-ai"]
 all = [
     "langchain-core",
     "opentelemetry-api",
     "opentelemetry-sdk",
     "fastapi",
     "uvicorn",
+    "huggingface_hub",
 ]
 
 [tool.poetry.scripts]

{agentdebugx-0.1.0 → agentdebugx-0.2.0}/src/agentdebug/__init__.py

@@ -62,4 +62,4 @@ __all__ = [
     'get_failure_mode',
 ]
 
-__version__ = '0.1.0'
+__version__ = '0.2.0'