lime-agents-sdk 0.1.0__py3-none-any.whl

lime_agents/__init__.py

@@ -0,0 +1,25 @@
+"""Official Python SDK for LIME AI agent workers."""
+
+from lime_agents._agent import LimeAgent
+from lime_agents._errors import (
+    ApiError,
+    AuthenticationError,
+    LimeError,
+    PowTimeoutError,
+    RateLimitError,
+)
+from lime_agents._types import AgentProfile, ApprovalResult
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AgentProfile",
+    "ApiError",
+    "ApprovalResult",
+    "AuthenticationError",
+    "LimeAgent",
+    "LimeError",
+    "PowTimeoutError",
+    "RateLimitError",
+    "__version__",
+]

lime_agents/_agent.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from types import TracebackType
+
+import httpx
+
+from lime_agents._client import LimeClient
+from lime_agents._errors import AuthenticationError
+from lime_agents._pow import solve
+from lime_agents._types import AgentProfile, ApprovalResult
+
+_DEFAULT_BASE_URL = "https://lime.pics/api/v1"
+
+
+class LimeAgent:
+    """Async client for LIME agent workers."""
+
+    def __init__(
+        self,
+        *,
+        agent_token: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        pow_timeout: float = 10.0,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        resolved_token = (agent_token or os.getenv("LIME_AGENT_TOKEN") or "").strip()
+        if not resolved_token:
+            raise AuthenticationError(
+                "Agent token is required. Pass agent_token= or set LIME_AGENT_TOKEN.",
+            )
+
+        resolved_base = (
+            base_url
+            or os.getenv("LIME_API_BASE")
+            or _DEFAULT_BASE_URL
+        ).rstrip("/")
+
+        self._pow_timeout = pow_timeout
+        self._client = LimeClient(
+            agent_token=resolved_token,
+            base_url=resolved_base,
+            timeout=timeout,
+            max_retries=max_retries,
+            http_client=http_client,
+        )
+
+    async def __aenter__(self) -> LimeAgent:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def approve(self, request_id: str) -> ApprovalResult:
+        """Fetch PoW challenge, solve it, and approve the login request."""
+        challenge_data = await self._client.get_public(f"/auth/requests/{request_id}")
+        pow_challenge = str(challenge_data["pow_challenge"])
+        pow_difficulty = int(challenge_data["pow_difficulty"])
+
+        pow_nonce = await asyncio.to_thread(
+            solve,
+            pow_challenge,
+            pow_difficulty,
+            max_timeout=self._pow_timeout,
+        )
+
+        approve_data = await self._client.post(
+            f"/modules/agent-login/requests/{request_id}/approve",
+            {"pow_nonce": pow_nonce},
+        )
+        return ApprovalResult.from_api(approve_data)
+
+    async def get_profile(self) -> AgentProfile:
+        """Return the authenticated agent's Core profile."""
+        profile_data = await self._client.get("/core/agents/me/profile")
+        return AgentProfile.from_api(profile_data)

lime_agents/_client.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+from typing import Any
+
+import httpx
+
+from lime_agents._errors import ApiError, AuthenticationError, LimeError, RateLimitError
+
+logger = logging.getLogger("lime")
+
+_RETRYABLE_STATUS = frozenset({408, 429, 500, 502, 503, 504})
+_AUTH_CODES = frozenset(
+    {
+        "MISSING_AGENT_TOKEN",
+        "INVALID_AGENT_TOKEN",
+    },
+)
+
+
+class LimeClient:
+    """Internal HTTP client with envelope parsing and retries."""
+
+    def __init__(
+        self,
+        *,
+        agent_token: str,
+        base_url: str,
+        timeout: float,
+        max_retries: int,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self._agent_token = agent_token
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.AsyncClient(
+            timeout=timeout,
+            headers={"Accept": "application/json"},
+        )
+
+    async def aclose(self) -> None:
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def get_public(self, path: str) -> dict[str, Any]:
+        return await self._request("GET", path, authenticated=False)
+
+    async def get(self, path: str) -> dict[str, Any]:
+        return await self._request("GET", path, authenticated=True)
+
+    async def post(self, path: str, body: dict[str, Any]) -> dict[str, Any]:
+        return await self._request("POST", path, authenticated=True, json_body=body)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        authenticated: bool,
+        json_body: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self._base_url}/{path.lstrip('/')}"
+        headers: dict[str, str] = {}
+        if authenticated:
+            headers["X-Agent-Token"] = self._agent_token
+            headers["Content-Type"] = "application/json"
+
+        attempt = 0
+        while True:
+            try:
+                response = await self._send(method, url, headers=headers, json_body=json_body)
+            except (httpx.TimeoutException, httpx.TransportError) as exc:
+                if attempt >= self._max_retries:
+                    raise LimeError(str(exc)) from exc
+                await self._backoff(attempt, method, path)
+                attempt += 1
+                continue
+
+            if response.status_code in _RETRYABLE_STATUS and attempt < self._max_retries:
+                logger.warning(
+                    "Retrying %s %s after HTTP %s (attempt %s)",
+                    method,
+                    path,
+                    response.status_code,
+                    attempt + 1,
+                )
+                await self._backoff(attempt, method, path)
+                attempt += 1
+                continue
+
+            return self._parse_envelope(response)
+
+    async def _send(
+        self,
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str],
+        json_body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        logger.debug("%s %s", method, url)
+        if method == "GET":
+            return await self._client.get(url, headers=headers)
+        return await self._client.post(url, headers=headers, json=json_body)
+
+    async def _backoff(self, attempt: int, method: str, path: str) -> None:
+        delay = (2**attempt) * 0.25 + random.uniform(0, 0.1)
+        logger.warning("Backing off %.2fs before retry %s %s", delay, method, path)
+        await asyncio.sleep(delay)
+
+    def _parse_envelope(self, response: httpx.Response) -> dict[str, Any]:
+        status = response.status_code
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise LimeError(
+                f"Invalid JSON response (HTTP {status})",
+                http_status=status,
+            ) from exc
+
+        if not isinstance(payload, dict):
+            raise LimeError(f"Unexpected response shape (HTTP {status})", http_status=status)
+
+        if payload.get("ok") is True:
+            data = payload.get("data")
+            if not isinstance(data, dict):
+                raise LimeError("Success envelope missing data object", http_status=status)
+            return data
+
+        error = payload.get("error")
+        if not isinstance(error, dict):
+            raise LimeError(
+                f"Error envelope missing error object (HTTP {status})",
+                http_status=status,
+            )
+
+        code = str(error.get("code", "UNKNOWN_ERROR"))
+        message = str(error.get("message", "Unknown error"))
+        detail = error.get("detail")
+        detail_dict = detail if isinstance(detail, dict) else None
+
+        if status == 429 or code == "RATE_LIMIT_EXCEEDED":
+            raise RateLimitError(message, code=code, http_status=status, detail=detail_dict)
+
+        if status == 401 or code in _AUTH_CODES:
+            raise AuthenticationError(message, code=code, http_status=status, detail=detail_dict)
+
+        raise ApiError(code, message, http_status=status, detail=detail_dict)

lime_agents/_errors.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class LimeError(Exception):
+    """Base class for SDK errors."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str | None = None,
+        http_status: int | None = None,
+        detail: dict[str, Any] | None = None,
+    ) -> None:
+        self.message = message
+        self.code = code
+        self.http_status = http_status
+        self.detail = detail
+        super().__init__(message)
+
+
+class AuthenticationError(LimeError):
+    """Missing or invalid agent token."""
+
+
+class PowTimeoutError(LimeError):
+    """PoW was not solved within the allotted time."""
+
+
+class RateLimitError(LimeError):
+    """HTTP 429 — rate limit exceeded."""
+
+
+class ApiError(LimeError):
+    """General API error with code and message."""
+
+    def __init__(
+        self,
+        code: str,
+        message: str,
+        *,
+        http_status: int,
+        detail: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(
+            message,
+            code=code,
+            http_status=http_status,
+            detail=detail,
+        )

lime_agents/_pow.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import hashlib
+import time
+
+from lime_agents._errors import PowTimeoutError
+
+
+def _is_valid_pow(challenge: str, nonce: str, difficulty: int) -> bool:
+    digest_hex = hashlib.sha256(f"{challenge}{nonce}".encode()).hexdigest()
+    threshold = 2 ** (256 - difficulty)
+    return bool(int(digest_hex, 16) < threshold)
+
+
+def solve(challenge: str, difficulty: int, *, max_timeout: float = 10.0) -> str:
+    """Find a nonce satisfying the LIME PoW policy."""
+    if difficulty <= 0:
+        return "0"
+
+    deadline = time.monotonic() + max_timeout
+    nonce = 0
+    while time.monotonic() < deadline:
+        candidate = str(nonce)
+        if _is_valid_pow(challenge, candidate, difficulty):
+            return candidate
+        nonce += 1
+
+    raise PowTimeoutError(
+        f"PoW not solved within {max_timeout}s (difficulty={difficulty})",
+    )

lime_agents/_types.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+def _parse_datetime(value: str) -> datetime:
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))
+
+
+@dataclass(frozen=True, slots=True)
+class ApprovalResult:
+    request_id: str
+    site_id: str
+    status: str
+    expires_at: datetime
+    approved_agent_id: str | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> ApprovalResult:
+        return cls(
+            request_id=str(data["request_id"]),
+            site_id=str(data["site_id"]),
+            status=str(data["status"]),
+            expires_at=_parse_datetime(str(data["expires_at"])),
+            approved_agent_id=(
+                str(data["approved_agent_id"]) if data.get("approved_agent_id") else None
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class AgentProfile:
+    agent_id: str
+    owner_id: str
+    display_name: str | None
+    avatar_url: str | None
+    description: str | None
+    owner_kyc_level: int | None
+    agent_reputation: int | None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> AgentProfile:
+        return cls(
+            agent_id=str(data["agent_id"]),
+            owner_id=str(data["owner_id"]),
+            display_name=data.get("display_name"),
+            avatar_url=data.get("avatar_url"),
+            description=data.get("description"),
+            owner_kyc_level=data.get("owner_kyc_level"),
+            agent_reputation=data.get("agent_reputation"),
+        )

lime_agents_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,394 @@
+Metadata-Version: 2.4
+Name: lime-agents-sdk
+Version: 0.1.0
+Summary: Python SDK for LIME 2.0 agent authentication. Zero-config, Proof-of-Work auto-solve, async-first.
+Project-URL: Homepage, https://github.com/Mawyxx/lime-agents-sdk
+Project-URL: Repository, https://github.com/Mawyxx/lime-agents-sdk
+Project-URL: Documentation, https://lime.pics/docs
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LIME Agents SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/lime-agents-sdk)](https://pypi.org/project/lime-agents-sdk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/lime-agents-sdk)](https://pypi.org/project/lime-agents-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![CI](https://github.com/Mawyxx/lime-agents-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/Mawyxx/lime-agents-sdk/actions/workflows/ci.yml)
+
+Official Python SDK for [LIME](https://lime.pics) agent workers. Async-first client that performs site-login approval end-to-end: fetch Proof-of-Work challenge, solve SHA-256 PoW, submit approve with retries.
+
+## Installation
+
+```bash
+pip install lime-agents-sdk
+```
+
+Install the latest commit from GitHub:
+
+```bash
+pip install git+https://github.com/Mawyxx/lime-agents-sdk.git
+```
+
+**Requirements:** Python 3.10+
+
+## Quick start
+
+Examples use readable names (`Lime`, `login`) on top of the shipped API (`LimeAgent`, `approve`). See [API reference](#api-reference) for exact types and parameters.
+
+### Minimal
+
+```python
+from lime_agents import LimeAgent as _LimeAgent
+
+
+class Lime(_LimeAgent):
+    """aiogram-style client: token first, login() instead of approve()."""
+
+    def __init__(self, token: str):
+        super().__init__(agent_token=token)
+
+    async def login(self, request_id: str):
+        return await self.approve(request_id)
+
+
+AGENT_TOKEN = "at_..."  # LIME Owner Portal → agent token (copy once)
+
+async def login_to_site(request_id: str) -> str:
+    """Agent confirms sign-in to a site. Returns status."""
+    lime = Lime(AGENT_TOKEN)
+    try:
+        result = await lime.login(request_id)
+        return result.status  # "DELIVERED"
+    finally:
+        await lime.aclose()
+```
+
+### Production
+
+```python
+from lime_agents import LimeAgent as _LimeAgent, PowTimeoutError, ApiError
+
+
+class Lime(_LimeAgent):
+    def __init__(self, token: str):
+        super().__init__(agent_token=token)
+
+    async def login(self, request_id: str):
+        return await self.approve(request_id)
+
+
+AGENT_TOKEN = "at_..."
+
+
+class Agent:
+    """Autonomous worker that signs in to sites when asked."""
+
+    def __init__(self):
+        self.lime = Lime(AGENT_TOKEN)
+
+    async def on_login_required(self, request_id: str) -> str | None:
+        """Site requires login — agent confirms."""
+        try:
+            result = await self.lime.login(request_id)
+            return result.status
+        except PowTimeoutError:
+            # Proof-of-Work exceeded pow_timeout (default 10s) — retry once
+            try:
+                result = await self.lime.login(request_id)
+                return result.status
+            except PowTimeoutError:
+                return None
+        except ApiError as exc:
+            print(f"[{exc.code}] {exc.message}")
+            return None
+```
+
+## Authentication
+
+The SDK authenticates agent HTTP calls with the `X-Agent-Token` header.
+
+**Resolution order:**
+
+1. Constructor argument `agent_token="at_..."`
+2. Environment variable `LIME_AGENT_TOKEN`
+
+If neither is set (or the value is empty after trimming), construction raises `AuthenticationError`:
+
+```python
+from lime_agents import LimeAgent, AuthenticationError
+
+try:
+    agent = LimeAgent()
+except AuthenticationError as exc:
+    print(exc.message)
+```
+
+Obtain the agent token once when registering an agent in the LIME owner portal. Store it as a server-side secret in your worker environment.
+
+## Integration pattern: Headless agent
+
+Typical embedding: hold one `LimeAgent` per worker process and call `approve()` when a login request arrives.
+
+```python
+from lime_agents import LimeAgent
+
+
+class TradingAgent:
+    def __init__(self, token: str):
+        self.lime = LimeAgent(agent_token=token)
+
+    async def on_login_required(self, request_id: str) -> str:
+        result = await self.lime.approve(request_id)
+        return result.status
+```
+
+The site backend creates the request (`POST /modules/agent-login/requests`), delivers `login_request_id` to your worker, and long-polls events until status becomes `DELIVERED`. Your worker only runs the approve step above.
+
+## API reference
+
+### `LimeAgent`
+
+Async client for agent-runtime operations (approve login, read profile).
+
+#### Constructor
+
+All arguments are keyword-only.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `agent_token` | `str \| None` | `None` | Agent secret. Falls back to `LIME_AGENT_TOKEN`. |
+| `base_url` | `str \| None` | `None` | API root including `/api/v1`. Falls back to `LIME_API_BASE`, then `https://lime.pics/api/v1`. |
+| `timeout` | `float` | `30.0` | Per-request HTTP timeout in seconds (httpx). |
+| `max_retries` | `int` | `3` | Maximum retries on transient network errors and HTTP 408/429/5xx. |
+| `pow_timeout` | `float` | `10.0` | Wall-clock budget in seconds for the PoW solver loop. |
+| `http_client` | `httpx.AsyncClient \| None` | `None` | Inject a custom async HTTP client (tests, corporate proxy/TLS). When omitted, the SDK creates and owns a client. |
+
+```python
+agent = LimeAgent(
+    agent_token="at_live_...",
+    base_url="https://lime.pics/api/v1",
+    timeout=60.0,
+    max_retries=5,
+    pow_timeout=15.0,
+)
+```
+
+**Context manager:** `async with LimeAgent() as agent:` calls `aclose()` on exit. Call `await agent.aclose()` manually when not using a context manager.
+
+#### `async approve(request_id: str) -> ApprovalResult`
+
+Confirms a site login request on behalf of the agent.
+
+**Internal steps:**
+
+1. `GET /auth/requests/{request_id}` (public, no auth) — read `pow_challenge`, `pow_difficulty`
+2. Solve PoW: find `nonce` such that `int(SHA256(challenge + nonce), 16) < 2**(256 - difficulty)`
+3. `POST /modules/agent-login/requests/{request_id}/approve` with `X-Agent-Token` and body `{"pow_nonce": "<nonce>"}`
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `request_id` | `str` | Login request ID from the site backend (`login_request_id` from create). |
+
+**Returns:** `ApprovalResult` with FSM status (typically `DELIVERED` after successful approve).
+
+```python
+from lime_agents import LimeAgent, PowTimeoutError, ApiError
+
+async with LimeAgent() as agent:
+    try:
+        result = await agent.approve("550e8400-e29b-41d4-a716-446655440000")
+        print(result.status, result.approved_agent_id)
+    except PowTimeoutError:
+        print("PoW not solved in time; increase pow_timeout or retry")
+    except ApiError as exc:
+        print(exc.code, exc.http_status, exc.message)
+```
+
+#### `async get_profile() -> AgentProfile`
+
+Returns the authenticated agent's Core profile.
+
+**HTTP:** `GET /core/agents/me/profile` with `X-Agent-Token`.
+
+```python
+async with LimeAgent() as agent:
+    profile = await agent.get_profile()
+    print(profile.agent_id)
+    print(profile.owner_kyc_level)
+    print(profile.agent_reputation)
+```
+
+## Types
+
+### `ApprovalResult`
+
+Frozen dataclass returned by `approve()`.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `request_id` | `str` | Login request ID |
+| `site_id` | `str` | Site that created the request |
+| `status` | `str` | FSM value, e.g. `APPROVED`, `DELIVERED` |
+| `expires_at` | `datetime` | Request expiry (timezone-aware when API sends offset) |
+| `approved_agent_id` | `str \| None` | Agent that approved (set after approve) |
+
+### `AgentProfile`
+
+Frozen dataclass returned by `get_profile()`. Matches `GET /core/agents/me/profile` response fields.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `agent_id` | `str` | Agent identifier |
+| `owner_id` | `str` | Owning LIME user |
+| `display_name` | `str \| None` | Public display name |
+| `avatar_url` | `str \| None` | Avatar URL |
+| `description` | `str \| None` | Public description |
+| `owner_kyc_level` | `int \| None` | Owner KYC level synced from Foundation |
+| `agent_reputation` | `int \| None` | Reputation score |
+
+## Error handling
+
+All SDK exceptions inherit from `LimeError`. Each carries `message`, and optionally `code`, `http_status`, and `detail` (API envelope).
+
+| Exception | When |
+|-----------|------|
+| `LimeError` | Base class; transport failures after retries, malformed JSON |
+| `AuthenticationError` | Missing/empty token at construct; HTTP 401; `MISSING_AGENT_TOKEN`, `INVALID_AGENT_TOKEN` |
+| `PowTimeoutError` | PoW solver exceeded `pow_timeout` |
+| `RateLimitError` | HTTP 429 / `RATE_LIMIT_EXCEEDED` |
+| `ApiError` | Other API errors (`ok: false` envelope) |
+
+`ApiError` attributes: `code`, `message`, `http_status`, `detail`.
+
+```python
+import asyncio
+
+from lime_agents import (
+    LimeAgent,
+    LimeError,
+    AuthenticationError,
+    PowTimeoutError,
+    RateLimitError,
+    ApiError,
+)
+
+async def run() -> None:
+    try:
+        async with LimeAgent() as agent:
+            await agent.approve("lr_abc123")
+    except AuthenticationError as exc:
+        print("auth:", exc.message)
+    except PowTimeoutError as exc:
+        print("pow:", exc.message)
+    except RateLimitError as exc:
+        print("rate limit:", exc.http_status)
+    except ApiError as exc:
+        print(f"api [{exc.http_status}] {exc.code}: {exc.message}")
+    except LimeError as exc:
+        print("sdk:", exc.message)
+
+asyncio.run(run())
+```
+
+**Non-retried HTTP statuses:** 400, 401, 403, 404, 409 (e.g. `INVALID_POW`, `SITE_LOGIN_CONFLICT`).
+
+## Configuration
+
+### Environment variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `LIME_AGENT_TOKEN` | Yes (unless `agent_token=` passed) | Agent secret (`at_...`) |
+| `LIME_API_BASE` | No | API root, e.g. `https://lime.pics/api/v1` |
+
+### Constructor tuning
+
+| Use case | Suggestion |
+|----------|------------|
+| Slow network | Increase `timeout` (e.g. `60.0`) |
+| Flaky upstream | Increase `max_retries` (e.g. `5`) |
+| High PoW difficulty / slow CPU | Increase `pow_timeout` (e.g. `30.0`) |
+| Staging / self-hosted API | Set `base_url` or `LIME_API_BASE` |
+
+### Logging
+
+HTTP and retry events are logged under the **`lime`** logger (not `lime_agents`):
+
+```python
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+logging.getLogger("lime").setLevel(logging.DEBUG)
+```
+
+At `DEBUG`, the client logs request method and URL. Tokens, `pow_challenge`, and `pow_nonce` are never logged.
+
+## Advanced usage
+
+### Custom `httpx.AsyncClient`
+
+Inject a client for custom TLS, proxies, or tests. **You own the client lifecycle** when injecting; the SDK does not close an injected client.
+
+```python
+import httpx
+from lime_agents import LimeAgent
+
+
+async def approve_with_proxy() -> None:
+    client = httpx.AsyncClient(
+        timeout=60.0,
+        verify="/path/to/corporate-ca.pem",
+        proxy="http://proxy.corp.example:8080",
+    )
+    agent = LimeAgent(agent_token="at_...", http_client=client)
+    try:
+        await agent.approve("lr_abc123")
+    finally:
+        await client.aclose()
+```
+
+### Retries and timeouts
+
+Retries use exponential backoff with jitter on connection errors, timeouts, and HTTP 408, 429, 500, 502, 503, 504. Each retry attempt is bounded by `max_retries` (default 3).
+
+```python
+agent = LimeAgent(
+    agent_token="at_...",
+    max_retries=5,
+    timeout=45.0,
+    pow_timeout=20.0,
+)
+```
+
+### PoW debugging
+
+PoW runs in a thread pool (`asyncio.to_thread`) so the event loop stays responsive. To observe HTTP flow (not nonce values):
+
+```python
+import logging
+
+logging.getLogger("lime").setLevel(logging.DEBUG)
+```
+
+If `PowTimeoutError` occurs, increase `pow_timeout` or verify `pow_difficulty` from `GET /auth/requests/{id}` (default 15 on production).
+
+## Links
+
+- **SDK repository:** [github.com/Mawyxx/lime-agents-sdk](https://github.com/Mawyxx/lime-agents-sdk)
+- **LIME API docs:** [lime.pics/docs](https://lime.pics/docs)
+- **LIME platform:** [github.com/Mawyxx/Lime](https://github.com/Mawyxx/Lime)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

lime_agents_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+lime_agents/__init__.py,sha256=Qq1LkGhxCL7H7rsEmqyEjj_ibYpiubiQ0Sti4vBRIQ4,507
+lime_agents/_agent.py,sha256=Bs8K8C1-9buQEhamEq5ZZK2erARzrbWwLTKryJzWuUI,2679
+lime_agents/_client.py,sha256=lLysm5Y9WCRQCSXJo43iUaCCzrNsC4aiUXkDf6Fj4QQ,5122
+lime_agents/_errors.py,sha256=Ffrugaa_Acnl8xxKCljg3uZTueWwvm8qhjneR90Gb_4,1132
+lime_agents/_pow.py,sha256=IjfmcfihScceC3CoNXqNF7IzaXgpvI78Haryt_qiLzk,880
+lime_agents/_types.py,sha256=K7uOBH9_nbInTOEH7k46JSUa8ehOjYcQwYsxYgaugh8,1559
+lime_agents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lime_agents_sdk-0.1.0.dist-info/METADATA,sha256=9FG2FNsJ4xBoLndth22ypvilscv9Ae7w4iPz0q01k0I,12606
+lime_agents_sdk-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lime_agents_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=oMe8Sdbwa3jl3bGG50j_6QicG-Zm_aQwFMq60XW3H9M,1061
+lime_agents_sdk-0.1.0.dist-info/RECORD,,

lime_agents_sdk-0.1.0.dist-info/WHEEL

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

lime_agents_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LIME
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.