blocklog 0.2.5__tar.gz → 0.2.6__tar.gz

{blocklog-0.2.5 → blocklog-0.2.6}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Blocklog
+Copyright (c) 2026 Soumya Surana
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

blocklog-0.2.6/PKG-INFO

@@ -0,0 +1,332 @@
+Metadata-Version: 2.4
+Name: blocklog
+Version: 0.2.6
+Summary: Infrastructure for AI Decision-Making — record, replay, verify, and govern AI agent decisions
+Author-email: Blocklog <founder@blocklogsecurity.com>
+Maintainer-email: Blocklog <founder@blocklogsecurity.com>
+License: MIT
+Project-URL: Homepage, https://blocklogsecurity.com
+Project-URL: Documentation, https://blocklogsecurity.com/docs
+Project-URL: Repository, https://github.com/blockloglabs/blocklog-python
+Project-URL: Issues, https://github.com/blockloglabs/blocklog-python/issues
+Keywords: ai,agents,observability,governance,security,audit,replay
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: pydantic<3.0,>=2.8
+Provides-Extra: requests
+Requires-Dist: requests>=2.32.0; extra == "requests"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2.0; extra == "langchain"
+Provides-Extra: langgraph
+Requires-Dist: langchain-core>=0.2.0; extra == "langgraph"
+Requires-Dist: langgraph>=0.2.0; extra == "langgraph"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.40.0; extra == "litellm"
+Provides-Extra: all
+Requires-Dist: langchain-core>=0.2.0; extra == "all"
+Requires-Dist: langgraph>=0.2.0; extra == "all"
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: litellm>=1.40.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Requires-Dist: langchain-core>=0.2.0; extra == "dev"
+Requires-Dist: langgraph>=0.2.0; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: litellm>=1.40.0; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+  <h1>Official Python SDK for Blocklog</h1>
+  <p><strong>Typed Python SDK for integrating Blocklog into AI applications with structured audit logging, execution tracing, and cryptographic verification.
+  </strong></p>
+
+  [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+  ![CI](https://github.com/blockloglabs/blocklog-python-sdk/actions/workflows/ci.yml/badge.svg)
+  [![PyPI Version](https://img.shields.io/pypi/v/blocklog)](https://pypi.org/project/blocklog/)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+  [![Documentation](https://img.shields.io/badge/docs-available-blue.svg)](docs/index.md)
+</div>
+
+---
+
+Blocklog Python SDK is the official Python client for Blocklog. It enables Python applications to record AI execution traces, manage decision records, verify audit integrity, and interact with Blocklog's APIs through a clean, typed, and developer-friendly interface.
+
+## Features
+
+- **Client & Transport**: Synchronous and asynchronous (`AsyncBlocklogClient`) support, connection pooling, exponential backoff retries, and background event batching.
+- **Observability**: Decorator-based tracing for agents (`@blocklog.agent`) and tools (`@blocklog.tool`).
+- **Governance**: Human-in-the-loop (HITL) approval workflows and incident management.
+- **Security & Compliance**: Ed25519 cryptographic payload signing, timeline verification, and automated SOC2/GDPR compliance reports.
+- **Integrations**: Auto-instrumentation for LangChain, LangGraph, OpenAI, and LiteLLM.
+
+---
+
+## Installation
+
+The SDK requires **Python 3.10+**.
+
+### pip
+
+```bash
+pip install blocklog
+```
+
+*(Optional)* Install with all integrations (LangChain, LangGraph, OpenAI, LiteLLM):
+
+```bash
+pip install blocklog[all]
+```
+
+### uv
+
+```bash
+uv pip install blocklog
+```
+
+### poetry
+
+```bash
+poetry add blocklog
+```
+
+---
+
+## Quick Start
+
+The fastest way to get started is to initialize the client and record a single decision.
+
+```python
+import os
+from blocklog import BlocklogClient
+
+# 1. Initialize the client
+client = BlocklogClient(api_key=os.environ.get("BLOCKLOG_API_KEY"))
+
+# 2. Record an AI decision
+response = client.decisions.create(
+    decision_type="BUY_ORDER",
+    asset="TSLA",
+    confidence=0.91,
+    inputs={"price": 412.50, "signals": ["momentum"]},
+    outputs={"order_id": "ord_123984"},
+)
+
+print(f"Decision recorded: {response.get('id')}")
+```
+
+For advanced tracing, Blocklog provides decorators (`@blocklog.agent`, `@blocklog.tool`) to automatically capture inputs and outputs within a shared execution context.
+
+---
+
+## Authentication
+
+Blocklog primarily authenticates using API Keys for server-to-server communication. For user-specific or dashboard actions, an Access Token is used.
+
+### API Keys (Server-to-Server)
+
+API keys are required to record logs, decisions, and traces. Set it via environment variable:
+
+```bash
+export BLOCKLOG_API_KEY="blk_..."
+```
+
+Then instantiate the client:
+
+```python
+from blocklog import BlocklogClient
+
+# Automatically loads from BLOCKLOG_API_KEY
+client = BlocklogClient()
+```
+
+### Access Tokens (User Context)
+
+If you are interacting with team management or dashboard APIs on behalf of a specific user, provide an access token:
+
+```python
+client.set_access_token("user_access_token_here")
+```
+
+---
+
+## Examples
+
+### Human-in-the-Loop (HITL) Approval
+
+Flag a high-stakes decision for human review before allowing the system to proceed.
+
+```python
+# Request approval (non-blocking in the SDK, triggers webhook in backend)
+response = client.approval.request(
+    decision_id="dec_abc123",
+    reason="Trade exceeds $500k automated threshold",
+    reviewer="risk-team@fund.com",
+)
+print("Approval requested successfully.")
+```
+
+### Cryptographic Verification
+
+Verify that an agent's decision and its underlying evidence have not been tampered with.
+
+```python
+verification = client.verify.decision("dec_abc123")
+
+if verification["status"] == "verified":
+    print("Decision integrity mathematically proven.")
+else:
+    print("WARNING: Tampering detected!")
+```
+
+### Incident Management
+
+Create an incident based on an anomalous trace and assign it to an investigator.
+
+```python
+incident = client.incidents.create(
+    title="Unexpected SELL order for AAPL", trace_id="trace-xyz", severity="high"
+)
+
+incident.assign("alice@fund.com", notes="Please investigate this immediately.")
+incident.resolve(summary="False positive - corrected upstream model weights.")
+```
+
+### Export Compliance Evidence
+
+Generate a SOC2 compliance report scoped to a specific AI trace.
+
+```python
+report = client.compliance.generate(trace_id="trace-xyz", framework="SOC2")
+
+# Create a secure shareable link valid for 24 hours
+link = client.compliance.share(report["id"], expires_in=86400)
+print(f"Compliance report available at: {link['share_url']}")
+```
+
+---
+
+## SDK Architecture
+
+The SDK is organized into intuitive, domain-specific resource layers accessible directly from the `BlocklogClient`:
+
+- `client.decisions`: Manage AI decision records and evidence timelines.
+- `client.approval`: Human-in-the-Loop (HITL) workflow management.
+- `client.incidents`: Incident response lifecycle (assign, annotate, resolve).
+- `client.replay`: Forensic replay sessions and root-cause analysis.
+- `client.compliance`: Compliance dashboard and report generation.
+- `client.verify`: Cryptographic verification of logs and batches.
+- `client.traces`: Query trace and session execution paths.
+- `client.teams`: Manage organizations, users, and SLA rules.
+- `client.auth`: User signups and authentication flows.
+
+For modern asynchronous applications (e.g., FastAPI), use `AsyncBlocklogClient` which provides the exact same architecture but with `async/await` semantics.
+
+---
+
+## Error Handling
+
+The SDK raises specific typed exceptions (inheriting from `BlocklogError`) mapped to underlying HTTP status codes, allowing you to gracefully handle failures.
+
+```python
+from blocklog.exceptions import (
+    BlocklogError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+)
+
+try:
+    client.decisions.get("invalid_id")
+except AuthenticationError:
+    print("Invalid API Key provided.")
+except RateLimitError:
+    print("Throttled by Blocklog backend. Backing off.")
+except ValidationError as e:
+    print(f"Malformed request data: {e}")
+except BlocklogError as e:
+    print(f"An unexpected error occurred: {e}")
+```
+
+---
+
+## Configuration
+
+You can customize the SDK's behavior using the `BlocklogConfig` object or via environment variables:
+
+| Environment Variable | Description | Default |
+|----------------------|-------------|---------|
+| `BLOCKLOG_API_KEY` | Your Blocklog API key | `""` |
+| `BLOCKLOG_BASE_URL` | API base URL | `https://blocklogsecurity.com/api/v1` |
+| `BLOCKLOG_TIMEOUT` | Request timeout in seconds | `10` |
+| `BLOCKLOG_MAX_RETRIES` | Max exponential backoff retries | `3` |
+| `BLOCKLOG_BATCH_SIZE` | Telemetry event batch size | `100` |
+| `BLOCKLOG_FLUSH_INTERVAL` | Batch flush interval in seconds | `2` |
+| `BLOCKLOG_SDK_SIGNING_KEY` | Optional seed key for Ed25519 signing | `""` |
+
+---
+
+## Why Use the Python SDK?
+
+While you could interact with the Blocklog API using raw HTTP requests, the SDK provides significant developer experience improvements:
+
+1. **Context Propagation**: Leveraging `contextvars`, the SDK automatically propagates `trace_id` and `session_id` across your application boundaries without passing variables manually.
+2. **Background Batching**: High-volume telemetry (logs, tool inputs) are safely buffered in-memory and asynchronously flushed to prevent blocking your application's critical path.
+3. **Resilience**: Built-in exponential backoff and automatic retry logic for transient network failures.
+4. **Auto-Instrumentation**: One-line integrations to automatically trace LangChain, LangGraph, OpenAI SDK, and LiteLLM executions.
+5. **Ed25519 Signing**: The SDK handles the cryptographic signing of payloads natively when `BLOCKLOG_SDK_SIGNING_KEY` is provided.
+
+---
+
+## API Coverage
+
+The SDK implements comprehensive support for the Blocklog REST API:
+
+- ✅ **Decisions** (`create`, `list`, `get`, `timeline`, `evidence`)
+- ✅ **Approvals** (`request`, `reject`, `escalate`, `audit_trail`)
+- ✅ **Incidents** (`create`, `assign`, `resolve`, `close`, `report`, `annotate`)
+- ✅ **Forensics & Replay** (`create`, `timeline`, `root_cause`, `causal_graph`, `counterfactual`, `compare`)
+- ✅ **Compliance** (`generate`, `list`, `dashboard`, `share`, `export`)
+- ✅ **Verification** (`log`, `batch`, `decision`)
+- ✅ **Teams & Auth** (`signup`, `login`, `teams.list`, `teams.update`)
+
+---
+
+## Development & Testing
+
+We welcome contributions to the Blocklog Python SDK!
+
+1. Clone the repository.
+2. Install the package in editable mode with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run the test suite using `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

blocklog-0.2.6/README.md

@@ -0,0 +1,278 @@
+<div align="center">
+  <h1>Official Python SDK for Blocklog</h1>
+  <p><strong>Typed Python SDK for integrating Blocklog into AI applications with structured audit logging, execution tracing, and cryptographic verification.
+  </strong></p>
+
+  [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+  ![CI](https://github.com/blockloglabs/blocklog-python-sdk/actions/workflows/ci.yml/badge.svg)
+  [![PyPI Version](https://img.shields.io/pypi/v/blocklog)](https://pypi.org/project/blocklog/)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+  [![Documentation](https://img.shields.io/badge/docs-available-blue.svg)](docs/index.md)
+</div>
+
+---
+
+Blocklog Python SDK is the official Python client for Blocklog. It enables Python applications to record AI execution traces, manage decision records, verify audit integrity, and interact with Blocklog's APIs through a clean, typed, and developer-friendly interface.
+
+## Features
+
+- **Client & Transport**: Synchronous and asynchronous (`AsyncBlocklogClient`) support, connection pooling, exponential backoff retries, and background event batching.
+- **Observability**: Decorator-based tracing for agents (`@blocklog.agent`) and tools (`@blocklog.tool`).
+- **Governance**: Human-in-the-loop (HITL) approval workflows and incident management.
+- **Security & Compliance**: Ed25519 cryptographic payload signing, timeline verification, and automated SOC2/GDPR compliance reports.
+- **Integrations**: Auto-instrumentation for LangChain, LangGraph, OpenAI, and LiteLLM.
+
+---
+
+## Installation
+
+The SDK requires **Python 3.10+**.
+
+### pip
+
+```bash
+pip install blocklog
+```
+
+*(Optional)* Install with all integrations (LangChain, LangGraph, OpenAI, LiteLLM):
+
+```bash
+pip install blocklog[all]
+```
+
+### uv
+
+```bash
+uv pip install blocklog
+```
+
+### poetry
+
+```bash
+poetry add blocklog
+```
+
+---
+
+## Quick Start
+
+The fastest way to get started is to initialize the client and record a single decision.
+
+```python
+import os
+from blocklog import BlocklogClient
+
+# 1. Initialize the client
+client = BlocklogClient(api_key=os.environ.get("BLOCKLOG_API_KEY"))
+
+# 2. Record an AI decision
+response = client.decisions.create(
+    decision_type="BUY_ORDER",
+    asset="TSLA",
+    confidence=0.91,
+    inputs={"price": 412.50, "signals": ["momentum"]},
+    outputs={"order_id": "ord_123984"},
+)
+
+print(f"Decision recorded: {response.get('id')}")
+```
+
+For advanced tracing, Blocklog provides decorators (`@blocklog.agent`, `@blocklog.tool`) to automatically capture inputs and outputs within a shared execution context.
+
+---
+
+## Authentication
+
+Blocklog primarily authenticates using API Keys for server-to-server communication. For user-specific or dashboard actions, an Access Token is used.
+
+### API Keys (Server-to-Server)
+
+API keys are required to record logs, decisions, and traces. Set it via environment variable:
+
+```bash
+export BLOCKLOG_API_KEY="blk_..."
+```
+
+Then instantiate the client:
+
+```python
+from blocklog import BlocklogClient
+
+# Automatically loads from BLOCKLOG_API_KEY
+client = BlocklogClient()
+```
+
+### Access Tokens (User Context)
+
+If you are interacting with team management or dashboard APIs on behalf of a specific user, provide an access token:
+
+```python
+client.set_access_token("user_access_token_here")
+```
+
+---
+
+## Examples
+
+### Human-in-the-Loop (HITL) Approval
+
+Flag a high-stakes decision for human review before allowing the system to proceed.
+
+```python
+# Request approval (non-blocking in the SDK, triggers webhook in backend)
+response = client.approval.request(
+    decision_id="dec_abc123",
+    reason="Trade exceeds $500k automated threshold",
+    reviewer="risk-team@fund.com",
+)
+print("Approval requested successfully.")
+```
+
+### Cryptographic Verification
+
+Verify that an agent's decision and its underlying evidence have not been tampered with.
+
+```python
+verification = client.verify.decision("dec_abc123")
+
+if verification["status"] == "verified":
+    print("Decision integrity mathematically proven.")
+else:
+    print("WARNING: Tampering detected!")
+```
+
+### Incident Management
+
+Create an incident based on an anomalous trace and assign it to an investigator.
+
+```python
+incident = client.incidents.create(
+    title="Unexpected SELL order for AAPL", trace_id="trace-xyz", severity="high"
+)
+
+incident.assign("alice@fund.com", notes="Please investigate this immediately.")
+incident.resolve(summary="False positive - corrected upstream model weights.")
+```
+
+### Export Compliance Evidence
+
+Generate a SOC2 compliance report scoped to a specific AI trace.
+
+```python
+report = client.compliance.generate(trace_id="trace-xyz", framework="SOC2")
+
+# Create a secure shareable link valid for 24 hours
+link = client.compliance.share(report["id"], expires_in=86400)
+print(f"Compliance report available at: {link['share_url']}")
+```
+
+---
+
+## SDK Architecture
+
+The SDK is organized into intuitive, domain-specific resource layers accessible directly from the `BlocklogClient`:
+
+- `client.decisions`: Manage AI decision records and evidence timelines.
+- `client.approval`: Human-in-the-Loop (HITL) workflow management.
+- `client.incidents`: Incident response lifecycle (assign, annotate, resolve).
+- `client.replay`: Forensic replay sessions and root-cause analysis.
+- `client.compliance`: Compliance dashboard and report generation.
+- `client.verify`: Cryptographic verification of logs and batches.
+- `client.traces`: Query trace and session execution paths.
+- `client.teams`: Manage organizations, users, and SLA rules.
+- `client.auth`: User signups and authentication flows.
+
+For modern asynchronous applications (e.g., FastAPI), use `AsyncBlocklogClient` which provides the exact same architecture but with `async/await` semantics.
+
+---
+
+## Error Handling
+
+The SDK raises specific typed exceptions (inheriting from `BlocklogError`) mapped to underlying HTTP status codes, allowing you to gracefully handle failures.
+
+```python
+from blocklog.exceptions import (
+    BlocklogError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+)
+
+try:
+    client.decisions.get("invalid_id")
+except AuthenticationError:
+    print("Invalid API Key provided.")
+except RateLimitError:
+    print("Throttled by Blocklog backend. Backing off.")
+except ValidationError as e:
+    print(f"Malformed request data: {e}")
+except BlocklogError as e:
+    print(f"An unexpected error occurred: {e}")
+```
+
+---
+
+## Configuration
+
+You can customize the SDK's behavior using the `BlocklogConfig` object or via environment variables:
+
+| Environment Variable | Description | Default |
+|----------------------|-------------|---------|
+| `BLOCKLOG_API_KEY` | Your Blocklog API key | `""` |
+| `BLOCKLOG_BASE_URL` | API base URL | `https://blocklogsecurity.com/api/v1` |
+| `BLOCKLOG_TIMEOUT` | Request timeout in seconds | `10` |
+| `BLOCKLOG_MAX_RETRIES` | Max exponential backoff retries | `3` |
+| `BLOCKLOG_BATCH_SIZE` | Telemetry event batch size | `100` |
+| `BLOCKLOG_FLUSH_INTERVAL` | Batch flush interval in seconds | `2` |
+| `BLOCKLOG_SDK_SIGNING_KEY` | Optional seed key for Ed25519 signing | `""` |
+
+---
+
+## Why Use the Python SDK?
+
+While you could interact with the Blocklog API using raw HTTP requests, the SDK provides significant developer experience improvements:
+
+1. **Context Propagation**: Leveraging `contextvars`, the SDK automatically propagates `trace_id` and `session_id` across your application boundaries without passing variables manually.
+2. **Background Batching**: High-volume telemetry (logs, tool inputs) are safely buffered in-memory and asynchronously flushed to prevent blocking your application's critical path.
+3. **Resilience**: Built-in exponential backoff and automatic retry logic for transient network failures.
+4. **Auto-Instrumentation**: One-line integrations to automatically trace LangChain, LangGraph, OpenAI SDK, and LiteLLM executions.
+5. **Ed25519 Signing**: The SDK handles the cryptographic signing of payloads natively when `BLOCKLOG_SDK_SIGNING_KEY` is provided.
+
+---
+
+## API Coverage
+
+The SDK implements comprehensive support for the Blocklog REST API:
+
+- ✅ **Decisions** (`create`, `list`, `get`, `timeline`, `evidence`)
+- ✅ **Approvals** (`request`, `reject`, `escalate`, `audit_trail`)
+- ✅ **Incidents** (`create`, `assign`, `resolve`, `close`, `report`, `annotate`)
+- ✅ **Forensics & Replay** (`create`, `timeline`, `root_cause`, `causal_graph`, `counterfactual`, `compare`)
+- ✅ **Compliance** (`generate`, `list`, `dashboard`, `share`, `export`)
+- ✅ **Verification** (`log`, `batch`, `decision`)
+- ✅ **Teams & Auth** (`signup`, `login`, `teams.list`, `teams.update`)
+
+---
+
+## Development & Testing
+
+We welcome contributions to the Blocklog Python SDK!
+
+1. Clone the repository.
+2. Install the package in editable mode with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run the test suite using `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

blocklog-0.2.6/docs/architecture.md

@@ -0,0 +1,21 @@
+# SDK architecture
+
+The Python SDK is a context-aware wrapper over the Blocklog HTTP API. It owns
+authentication headers, timeouts, safe read retries, event serialization, and
+optional batching. The backend owns validation, persistence, rate limiting, and
+verification artifacts.
+
+```text
+Python application -> Python SDK -> HTTP/API -> Blocklog backend
+                                         -> execution/event infrastructure
+                                         -> verification and receipts
+```
+
+`record_event()` calls the backend-supported `POST /api/v1/logs` route. Batched
+events use `POST /api/v1/logs/batch`. These mutations are not automatically
+retried because the backend's ingestion contract does not document idempotent
+replay behavior. GET operations may be retried for transient errors.
+
+The execution-management backend currently exposes `/api/v1/executions` and
+its step/status routes; its request shape is defined by the backend FastAPI
+signatures and remains the source of truth.

{blocklog-0.2.5 → blocklog-0.2.6}/docs/async.md

@@ -10,6 +10,7 @@ If you need direct access to the low-level client for async operations (like man
 from blocklog.async_client import AsyncBlocklogClient
 from blocklog.config import BlocklogConfig
 
+
 async def setup():
     config = BlocklogConfig(api_key="blk_...")
     client = AsyncBlocklogClient(config)
@@ -26,23 +27,26 @@ import blocklog
 
 blocklog.init()
 
+
 @blocklog.tool
 async def fetch_async_data(url: str) -> dict:
     # Simulate async network request
     await asyncio.sleep(0.5)
     return {"status": 200, "data": "async payload"}
 
+
 @blocklog.agent(name="async-agent")
 async def main_agent():
     data = await fetch_async_data("https://api.example.com")
-    
+
     # Decisions work perfectly within async contexts
     with blocklog.decision(type="EVALUATE", asset="url") as d:
         d.record_input(data=data)
         d.record_output(valid=True)
-        
+
     return data
 
+
 if __name__ == "__main__":
     asyncio.run(main_agent())
 ```

{blocklog-0.2.5 → blocklog-0.2.6}/docs/configuration.md

@@ -15,7 +15,7 @@ blocklog.init(
     signing_key="ed25519_private_key_here",
     timeout=5.0,
     max_retries=5,
-    debug=True
+    debug=True,
 )
 ```