Metadata-Version: 2.4
Name: agentlayer-sdk-py
Version: 1.0.0
Summary: Financial governance SDK for AI agents
Home-page: https://agentlayer-production-98fa.up.railway.app
Author: AgentLayer
Author-email: hello@agentlayer.io
Requires-Python: >=3.7
Description-Content-Type: text/markdown
Requires-Dist: requests>=2.28.0
Dynamic: author
Dynamic: author-email
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# AgentLayer Python SDK

The official Python SDK for [AgentLayer](https://agentlayer-production-98fa.up.railway.app) — the financial governance layer for AI agents.

## Installation

```bash
pip install agentlayer-sdk
```

## Quick Start

```python
from agentlayer import AgentLayer

agent = AgentLayer(token="agt_live_xxxxxxxxxxxxxxxxxxxxxxxx")

# Pay autonomously
result = agent.pay(10, "Market data purchase")
print(result["transaction"]["tx_id"])
```

## Agent API

Initialize with your agent token (generated from the dashboard):

```python
agent = AgentLayer(
    token="agt_live_xxx",      # required
    base_url="https://..."     # optional, defaults to AgentLayer production
)
```

### `agent.pay(amount, description)`

Execute a payment from the agent wallet.

```python
result = agent.pay(10, "API call fee")
# {
#   "success": True,
#   "transaction": { "tx_id", "amount", "description", "timestamp", "balance_after" },
#   "agent": { "agent_id", "agent_name", "balance_after", "trust_level" }
# }
```

### `agent.balance()`

Check the agent's current balance and spend limits.

```python
bal = agent.balance()
# {
#   "balance": 990,
#   "spent_today": 10,
#   "max_daily": 500,
#   "max_per_transaction": 100,
#   "trust_level": "verified",
#   "did": "did:agentlayer:..."
# }
```

### `agent.identity()`

Get the agent's cryptographic identity (KYA report).

```python
identity = agent.identity()
# {
#   "did": "did:agentlayer:bd18c2df...",
#   "trust_level": "verified",
#   "trust_score": 30,
#   "certificate_valid": { "valid": True, "expired": False }
# }
```

### `agent.can_pay(amount)`

Check if a payment is possible before executing it.

```python
check = agent.can_pay(50)
# {
#   "can_pay": True,
#   "balance": 990,
#   "remaining_today": 490,
#   "max_per_transaction": 100
# }
```

### `agent.safe_pay(amount, description)`

Pay only if possible — returns a blocked reason instead of raising.

```python
result = agent.safe_pay(500, "Large purchase")
if not result["success"]:
    print(result["reason"])  # 'Exceeds per-transaction limit ($100)'
```

## Admin API

Initialize with your API key for server-side operations:

```python
from agentlayer import AgentLayerAdmin

admin = AgentLayerAdmin(api_key="al_live_xxxxxxxxxxxxxxxxxxxxxxxx")
```

### `admin.create_wallet(agent_name, max_per_transaction, max_daily)`

```python
wallet = admin.create_wallet("Procurement Agent", 100, 500)
# { "agent_id", "agent_name", "balance", "kya": { "did", "trust_level" } }
```

### `admin.list_wallets()`

```python
wallets = admin.list_wallets()
```

### `admin.pay(agent_id, amount, description)`

```python
result = admin.pay("agent-id", 25, "Payment")
```

### `admin.verify_agent(agent_id)`

```python
verification = admin.verify_agent("agent-id")
# { "verified": True, "did", "trust_level", "certificate_valid" }
```

### `admin.delegate(parent_agent_id, child_agent_name, budget, max_per_transaction)`

```python
delegation = admin.delegate("parent-id", "Sub Agent", 100, 20)
# { "success": True, "child_wallet", "delegation_chain" }
```

## Error Handling

```python
from agentlayer import AgentLayer, AgentLayerError

agent = AgentLayer(token="agt_live_xxx")

try:
    result = agent.pay(1000, "Too much")
except AgentLayerError as e:
    print(e)         # 'Dépasse la limite par transaction (max $100)'
    print(e.status)  # 403
```

## Real-world Example

```python
from agentlayer import AgentLayer
import os

agent = AgentLayer(token=os.environ["AGENTLAYER_TOKEN"])

def buy_market_data(data_source, price):
    # Check before paying
    check = agent.can_pay(price)
    if not check["can_pay"]:
        print(f"Cannot pay: ${check['remaining_today']} remaining today")
        return None

    # Pay autonomously
    result = agent.safe_pay(price, f"Market data: {data_source}")
    if not result["success"]:
        print(f"Blocked: {result['reason']}")
        return None

    print(f"Paid ${price} for {data_source} — TX: {result['transaction']['tx_id']}")
    return result["transaction"]

# Your agent runs autonomously
buy_market_data("Bloomberg API", 15)
```

## LangChain Integration Example

```python
from langchain.tools import tool
from agentlayer import AgentLayer
import os

agent = AgentLayer(token=os.environ["AGENTLAYER_TOKEN"])

@tool
def pay_for_api(amount: float, description: str) -> str:
    """Pay for an external API or service using AgentLayer."""
    result = agent.safe_pay(amount, description)
    if result["success"]:
        return f"Payment successful. TX: {result['transaction']['tx_id']}"
    return f"Payment blocked: {result['reason']}"

# Use in your LangChain agent
# agent_executor.run("Pay $5 for the weather API")
```

## Links

- [Documentation](https://agentlayer-production-98fa.up.railway.app/docs.html)
- [Dashboard](https://agentlayer-production-98fa.up.railway.app/signup.html)
- [npm SDK](https://www.npmjs.com/package/agentlayer-sdk)
- [GitHub](https://github.com/ptrs82/agentlayer-sdk-python)

## License

MIT
