Metadata-Version: 2.4
Name: burnd
Version: 1.0.0
Summary: SDK + CLI prototype for disposable identity workflows in AI agent testing
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: typer>=0.12.0
Requires-Dist: faker>=24.0.0
Requires-Dist: httpx[http2]>=0.27.0
Requires-Dist: playwright>=1.43.0
Requires-Dist: playwright-stealth>=1.0.6
Requires-Dist: python-slugify>=8.0.4
Requires-Dist: pydantic>=2.7.0
Requires-Dist: pydantic-settings>=2.2.1
Requires-Dist: structlog>=24.1.0
Requires-Dist: cryptography>=42.0.0
Provides-Extra: dev
Requires-Dist: pytest>=8.2.0; extra == "dev"
Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
Requires-Dist: ruff>=0.4.0; extra == "dev"
Requires-Dist: mypy>=1.10.0; extra == "dev"
Provides-Extra: langchain
Requires-Dist: langchain-core>=0.2.0; extra == "langchain"
Provides-Extra: crewai
Requires-Dist: crewai>=0.70.0; extra == "crewai"
Provides-Extra: autogen
Requires-Dist: autogen-agentchat>=0.4.0; extra == "autogen"
Provides-Extra: all-frameworks
Requires-Dist: langchain-core>=0.2.0; extra == "all-frameworks"
Requires-Dist: crewai>=0.70.0; extra == "all-frameworks"
Requires-Dist: autogen-agentchat>=0.4.0; extra == "all-frameworks"
Dynamic: license-file

# burnd

`burnd` is a Python toolkit for creating disposable identities for AI agent workflows.

It provides:
- A typed Python SDK
- A CLI for identity lifecycle operations
- Framework helpers for LangChain, CrewAI, and AutoGen

## Installation

### From PyPI

```bash
pip install burnd
```

### From source

```bash
git clone <your-repo-url>
cd Burner
python -m venv venv
# Windows PowerShell
.\venv\Scripts\Activate.ps1
# macOS/Linux
# source venv/bin/activate
pip install -e .
```

### Optional framework extras

```bash
pip install "burnd[langchain]"
pip install "burnd[crewai]"
pip install "burnd[autogen]"
pip install "burnd[all-frameworks]"
```

> Distribution name is `burnd`; import package path is `burner`.

## SDK Usage

### Sync example

```python
from burner.models import IdentityRequest
from burner.sdk import create_identity, poll_inbox, rotate_identity, dispose_identity

bundle = create_identity(
    IdentityRequest(
        task="signup verification flow",
        provider="stub",
        include_email=True,
        include_browser_profile=True,
    ),
    include_secrets=True,
)

identity_id = str(bundle.public.identity_id)
print(bundle.public.persona.full_name)
print(bundle.public.email.address if bundle.public.email else None)

messages = poll_inbox(identity_id, limit=5)
print([m.subject for m in messages])

rotated = rotate_identity(identity_id, reason="refresh")
dispose_identity(str(rotated.public.identity_id))
```

### Async example

```python
import asyncio
from burner.models import IdentityRequest
from burner.sdk import acreate_identity, apoll_inbox, adispose_identity

async def main() -> None:
    bundle = await acreate_identity(
        IdentityRequest(task="async smoke", provider="stub"),
        include_secrets=True,
    )
    identity_id = str(bundle.public.identity_id)
    _ = await apoll_inbox(identity_id, limit=3)
    await adispose_identity(identity_id)

asyncio.run(main())
```

## CLI Usage

### Create identity

```bash
burnd create --task "signup verification flow" --provider stub -o identity.json
```

### Create identity with secrets output

```bash
burnd create --task "email flow" --provider stub -o identity.json --secrets-output secrets.json
```

### Get identity

```bash
burnd get <identity-id>
```

### Poll inbox

```bash
burnd poll --identity-id <identity-id> --limit 10
```

or using exported files:

```bash
burnd poll --identity-file identity.json --secrets-file secrets.json --limit 10
```

### Rotate and dispose

```bash
burnd rotate <identity-id> --reason "refresh identity"
burnd dispose <identity-id>
```

### Show runtime config

```bash
burnd status
```

## Framework Examples

### LangChain

```python
from burner.adapters.langchain import get_langchain_tools

tools = get_langchain_tools()
```

### CrewAI

```python
from burner.adapters.crewai import get_crewai_tools

tools = get_crewai_tools()
```

### AutoGen

```python
from burner.adapters.autogen import get_autogen_function_map, get_autogen_tool_specs

function_map = get_autogen_function_map()
tool_specs = get_autogen_tool_specs()
```

## Config

Configuration is loaded from `BURNER_` environment variables (or `.env`).

Common settings:
- `BURNER_DEFAULT_REGION`
- `BURNER_DEFAULT_PROVIDER`
- `BURNER_DEFAULT_TTL_SECONDS`
- `BURNER_GUARDRAIL_MODE`
- `BURNER_ALLOWED_PURPOSES`
- `BURNER_ALLOWED_TARGET_DOMAINS`
- `BURNER_MAX_IDENTITY_TTL_SECONDS`
- `BURNER_MAX_ROTATIONS_PER_HOUR`
- `BURNER_PROVIDER_FALLBACK_ORDER`
- `BURNER_ENCRYPTED_STORAGE_KEY`
- `BURNER_ENCRYPTED_STORAGE_PATH`

## Development

```bash
pip install -e .[dev]
python -m pytest
python -m ruff check .
python -m mypy burner
```

