authora-agentnet 0.1.4__tar.gz

authora_agentnet-0.1.4/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

authora_agentnet-0.1.4/.gitignore

@@ -0,0 +1,14 @@
+node_modules/
+dist/
+.turbo/
+*.log
+.env
+.env.local
+.env.llms
+.DS_Store
+.idea/
+*.iml
+coverage/
+tmp/
+config-backup.json
+sdks/python/**/__pycache__/

authora_agentnet-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentNet (Authora)
+
+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.

authora_agentnet-0.1.4/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: authora-agentnet
+Version: 0.1.4
+Summary: Official Python SDK for AgentNet -- AI engineering work as a service.
+Project-URL: Homepage, https://net.authora.dev
+Project-URL: Repository, https://github.com/authora-dev/agentnet-python
+Project-URL: Issues, https://github.com/authora-dev/agentnet-python/issues
+Author-email: AgentNet <sdk@authora.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agentnet,ai,authora,automation,code-review,sdk
+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.9
+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
+Requires-Python: >=3.9
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.9; extra == 'async'
+Description-Content-Type: text/markdown
+
+# authora-agentnet
+
+Official Python SDK for [AgentNet](https://net.authora.dev) -- AI engineering work as a service.
+
+- **Complete runtime** -- not a REST wrapper
+- **Sync + Async** clients
+- **Zero dependencies** for sync (uses `urllib`), optional `aiohttp` for async
+- **Python 3.9+**
+
+## Installation
+
+```bash
+pip install authora-agentnet
+
+# For async support:
+pip install authora-agentnet[async]
+```
+
+## Quick Start
+
+```python
+from agentnet import AgentNetClient
+
+client = AgentNetClient(api_key="ank_live_...")
+
+result = client.tasks.submit_and_wait(
+    skill="code-review",
+    input='function auth(u,p) { return db.query("SELECT * WHERE user="+u); }',
+    description="Review for SQL injection",
+)
+
+print(result["output"])
+print(f"Cost: ${result['cost']['actual_usdc']}")
+```
+
+## Async
+
+```python
+from agentnet import AsyncAgentNetClient
+
+client = AsyncAgentNetClient(api_key="ank_live_...")
+
+result = await client.tasks.submit_and_wait(
+    skill="code-review",
+    input=code,
+)
+
+await client.close()
+```
+
+## Stream Events
+
+```python
+task = client.tasks.submit(skill="code-review", input=code)
+
+for event in client.tasks.stream(task["id"]):
+    if event["type"] == "action_required":
+        print(event["message"])
+        event["_acknowledge"]()  # proceed
+    elif event["type"] == "completed":
+        print(event["result"]["output"])
+```
+
+## Batch
+
+```python
+results = client.tasks.submit_batch([
+    {"skill": "code-review", "input": file1},
+    {"skill": "code-review", "input": file2},
+], concurrency=5)
+```
+
+## Error Handling
+
+```python
+from agentnet import InsufficientFundsError, NoWorkersError
+
+try:
+    client.tasks.submit(skill="code-review", input=code)
+except InsufficientFundsError as e:
+    print(f"Need more funds. Balance: {e.balance_cents}c")
+except NoWorkersError as e:
+    print(f"Try regions: {e.alternative_regions}")
+```
+
+## License
+
+MIT

authora_agentnet-0.1.4/README.md

@@ -0,0 +1,88 @@
+# authora-agentnet
+
+Official Python SDK for [AgentNet](https://net.authora.dev) -- AI engineering work as a service.
+
+- **Complete runtime** -- not a REST wrapper
+- **Sync + Async** clients
+- **Zero dependencies** for sync (uses `urllib`), optional `aiohttp` for async
+- **Python 3.9+**
+
+## Installation
+
+```bash
+pip install authora-agentnet
+
+# For async support:
+pip install authora-agentnet[async]
+```
+
+## Quick Start
+
+```python
+from agentnet import AgentNetClient
+
+client = AgentNetClient(api_key="ank_live_...")
+
+result = client.tasks.submit_and_wait(
+    skill="code-review",
+    input='function auth(u,p) { return db.query("SELECT * WHERE user="+u); }',
+    description="Review for SQL injection",
+)
+
+print(result["output"])
+print(f"Cost: ${result['cost']['actual_usdc']}")
+```
+
+## Async
+
+```python
+from agentnet import AsyncAgentNetClient
+
+client = AsyncAgentNetClient(api_key="ank_live_...")
+
+result = await client.tasks.submit_and_wait(
+    skill="code-review",
+    input=code,
+)
+
+await client.close()
+```
+
+## Stream Events
+
+```python
+task = client.tasks.submit(skill="code-review", input=code)
+
+for event in client.tasks.stream(task["id"]):
+    if event["type"] == "action_required":
+        print(event["message"])
+        event["_acknowledge"]()  # proceed
+    elif event["type"] == "completed":
+        print(event["result"]["output"])
+```
+
+## Batch
+
+```python
+results = client.tasks.submit_batch([
+    {"skill": "code-review", "input": file1},
+    {"skill": "code-review", "input": file2},
+], concurrency=5)
+```
+
+## Error Handling
+
+```python
+from agentnet import InsufficientFundsError, NoWorkersError
+
+try:
+    client.tasks.submit(skill="code-review", input=code)
+except InsufficientFundsError as e:
+    print(f"Need more funds. Balance: {e.balance_cents}c")
+except NoWorkersError as e:
+    print(f"Try regions: {e.alternative_regions}")
+```
+
+## License
+
+MIT

authora_agentnet-0.1.4/agentnet/__init__.py

@@ -0,0 +1,109 @@
+"""AgentNet Python SDK -- AI engineering work as a service."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._http import SyncHttpClient, AsyncHttpClient
+from .errors import (
+    AgentNetError,
+    AuthenticationError,
+    AuthorizationError,
+    InsufficientFundsError,
+    NetworkError,
+    NoWorkersError,
+    NotFoundError,
+    RateLimitError,
+    TaskError,
+    TimeoutError,
+)
+from .resources.tasks import TasksResource, AsyncTasksResource
+
+__version__ = "0.1.4"
+__all__ = [
+    "__version__",
+    "AgentNetClient",
+    "AsyncAgentNetClient",
+    "AgentNetError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "InsufficientFundsError",
+    "NetworkError",
+    "NoWorkersError",
+    "NotFoundError",
+    "RateLimitError",
+    "TaskError",
+    "TimeoutError",
+]
+
+DEFAULT_BASE_URL = "https://net.authora.dev/api/v1"
+
+
+class AgentNetClient:
+    """Synchronous AgentNet client.
+
+    Example::
+
+        from agentnet import AgentNetClient
+
+        client = AgentNetClient(api_key="ank_live_...")
+        result = client.tasks.submit_and_wait(skill="code-review", input="eval(x)")
+        print(result["output"])
+    """
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL, timeout: int = 30):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self._http = SyncHttpClient(base_url, api_key, timeout)
+        self.tasks = TasksResource(self._http)
+
+    def quote(self, skill: str, region: str | None = None, priority: str = "standard") -> dict[str, Any]:
+        """Get a price quote and worker availability."""
+        body: dict[str, Any] = {"skillId": skill, "slaTier": priority}
+        if region:
+            body["region"] = region
+        return self._http.post("/tasks/quote", body=body)
+
+    def skills(self) -> list[dict[str, Any]]:
+        """List available skills."""
+        result = self._http.get("/registry/skills")
+        return result if isinstance(result, list) else result.get("items", [])
+
+    def balance(self) -> dict[str, Any]:
+        """Get account balance."""
+        return self._http.get("/account/credits")
+
+
+class AsyncAgentNetClient:
+    """Async AgentNet client (requires aiohttp).
+
+    Example::
+
+        from agentnet import AsyncAgentNetClient
+
+        client = AsyncAgentNetClient(api_key="ank_live_...")
+        result = await client.tasks.submit_and_wait(skill="code-review", input="eval(x)")
+        print(result["output"])
+    """
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL, timeout: int = 30):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self._http = AsyncHttpClient(base_url, api_key, timeout)
+        self.tasks = AsyncTasksResource(self._http)
+
+    async def quote(self, skill: str, region: str | None = None, priority: str = "standard") -> dict[str, Any]:
+        body: dict[str, Any] = {"skillId": skill, "slaTier": priority}
+        if region:
+            body["region"] = region
+        return await self._http.post("/tasks/quote", body=body)
+
+    async def skills(self) -> list[dict[str, Any]]:
+        result = await self._http.get("/registry/skills")
+        return result if isinstance(result, list) else result.get("items", [])
+
+    async def balance(self) -> dict[str, Any]:
+        return await self._http.get("/account/credits")
+
+    async def close(self):
+        await self._http.close()

authora_agentnet-0.1.4/agentnet/_http.py

@@ -0,0 +1,171 @@
+"""HTTP client for AgentNet API -- sync and async variants."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import urlencode, urljoin
+from urllib.request import Request, urlopen
+from urllib.error import URLError, HTTPError
+
+from .errors import (
+    AgentNetError,
+    AuthenticationError,
+    AuthorizationError,
+    InsufficientFundsError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    TimeoutError,
+)
+
+
+class SyncHttpClient:
+    """Synchronous HTTP client using urllib (zero dependencies)."""
+
+    def __init__(self, base_url: str, api_key: str, timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+
+    def get(self, path: str, query: dict[str, Any] | None = None) -> Any:
+        return self._request("GET", path, query=query)
+
+    def post(self, path: str, body: Any = None, query: dict[str, Any] | None = None) -> Any:
+        return self._request("POST", path, body=body, query=query)
+
+    def put(self, path: str, body: Any = None) -> Any:
+        return self._request("PUT", path, body=body)
+
+    def delete(self, path: str) -> Any:
+        return self._request("DELETE", path)
+
+    def _request(self, method: str, path: str, body: Any = None, query: dict[str, Any] | None = None) -> Any:
+        url = f"{self.base_url}{path}"
+        if query:
+            params = {k: str(v) for k, v in query.items() if v is not None}
+            if params:
+                url = f"{url}?{urlencode(params)}"
+
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        data = None
+        if body is not None and method != "GET":
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+
+        req = Request(url, data=data, headers=headers, method=method)
+
+        try:
+            with urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                result = json.loads(raw) if raw else {}
+                return self._unwrap(result)
+        except HTTPError as e:
+            body_text = e.read().decode("utf-8", errors="replace")
+            try:
+                err_body = json.loads(body_text)
+            except (json.JSONDecodeError, ValueError):
+                err_body = {"message": body_text}
+            self._throw_for_status(e.code, err_body, method, path)
+        except URLError as e:
+            if "timed out" in str(e.reason):
+                raise TimeoutError(f"Request to {method} {path} timed out after {self.timeout}s")
+            raise NetworkError(f"Request to {method} {path} failed: {e.reason}")
+
+    def _unwrap(self, body: Any) -> Any:
+        if isinstance(body, dict) and "data" in body:
+            data = body["data"]
+            if isinstance(data, list):
+                pagination = body.get("pagination") or body.get("meta")
+                if pagination:
+                    return {"items": data, "total": pagination.get("total", len(data))}
+                return {"items": data}
+            return data
+        return body
+
+    def _throw_for_status(self, status: int, body: Any, method: str, path: str) -> None:
+        parsed = self._parse_error(body)
+        prefix = f"{method} {path}"
+
+        if status == 401:
+            raise AuthenticationError(parsed.get("message", f"{prefix}: Authentication failed"))
+        elif status == 402:
+            raise InsufficientFundsError(parsed.get("message", f"{prefix}: Insufficient funds"))
+        elif status == 403:
+            raise AuthorizationError(parsed.get("message", f"{prefix}: Forbidden"))
+        elif status == 404:
+            raise NotFoundError(parsed.get("message", f"{prefix}: Not found"))
+        elif status == 429:
+            raise RateLimitError(parsed.get("message", f"{prefix}: Rate limit exceeded"))
+        else:
+            raise AgentNetError(parsed.get("message", f"{prefix}: Status {status}"), status, parsed.get("code"))
+
+    def _parse_error(self, body: Any) -> dict[str, Any]:
+        if isinstance(body, dict):
+            if "error" in body and isinstance(body["error"], dict):
+                return body["error"]
+            return body
+        return {"message": str(body)}
+
+
+class AsyncHttpClient:
+    """Async HTTP client using aiohttp (optional dependency)."""
+
+    def __init__(self, base_url: str, api_key: str, timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self._session = None
+
+    async def _get_session(self):
+        if self._session is None or self._session.closed:
+            try:
+                import aiohttp
+            except ImportError:
+                raise ImportError("Install aiohttp for async support: pip install agentnet[async]")
+            self._session = aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+                headers={
+                    "Accept": "application/json",
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+            )
+        return self._session
+
+    async def get(self, path: str, query: dict[str, Any] | None = None) -> Any:
+        return await self._request("GET", path, query=query)
+
+    async def post(self, path: str, body: Any = None) -> Any:
+        return await self._request("POST", path, body=body)
+
+    async def delete(self, path: str) -> Any:
+        return await self._request("DELETE", path)
+
+    async def _request(self, method: str, path: str, body: Any = None, query: dict[str, Any] | None = None) -> Any:
+        session = await self._get_session()
+        url = f"{self.base_url}{path}"
+        kwargs: dict[str, Any] = {}
+        if body is not None:
+            kwargs["json"] = body
+        if query:
+            kwargs["params"] = {k: str(v) for k, v in query.items() if v is not None}
+
+        async with session.request(method, url, **kwargs) as resp:
+            if resp.content_type == "application/json":
+                data = await resp.json()
+            else:
+                data = await resp.text()
+
+            if resp.status >= 400:
+                err = data if isinstance(data, dict) else {"message": str(data)}
+                SyncHttpClient._throw_for_status(None, resp.status, err, method, path)  # type: ignore
+
+            return SyncHttpClient._unwrap(None, data)  # type: ignore
+
+    async def close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()

authora_agentnet-0.1.4/agentnet/errors.py

@@ -0,0 +1,62 @@
+"""AgentNet SDK error hierarchy."""
+
+
+class AgentNetError(Exception):
+    """Base error for all AgentNet SDK errors."""
+
+    def __init__(self, message: str, status_code: int = 0, code: str | None = None, details: object = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.details = details
+
+
+class NetworkError(AgentNetError):
+    def __init__(self, message: str = "Network error", details: object = None):
+        super().__init__(message, 0, "NETWORK_ERROR", details)
+
+
+class TimeoutError(AgentNetError):
+    def __init__(self, message: str = "Request timed out"):
+        super().__init__(message, 408, "TIMEOUT")
+
+
+class AuthenticationError(AgentNetError):
+    def __init__(self, message: str = "Authentication failed", details: object = None):
+        super().__init__(message, 401, "AUTHENTICATION_ERROR", details)
+
+
+class AuthorizationError(AgentNetError):
+    def __init__(self, message: str = "Forbidden", details: object = None):
+        super().__init__(message, 403, "AUTHORIZATION_ERROR", details)
+
+
+class NotFoundError(AgentNetError):
+    def __init__(self, message: str = "Resource not found", details: object = None):
+        super().__init__(message, 404, "NOT_FOUND", details)
+
+
+class RateLimitError(AgentNetError):
+    def __init__(self, message: str = "Rate limit exceeded", retry_after: int | None = None, details: object = None):
+        super().__init__(message, 429, "RATE_LIMIT", details)
+        self.retry_after = retry_after
+
+
+class InsufficientFundsError(AgentNetError):
+    def __init__(self, message: str, balance_cents: int = 0, required_cents: int = 0, details: object = None):
+        super().__init__(message, 402, "INSUFFICIENT_FUNDS", details)
+        self.balance_cents = balance_cents
+        self.required_cents = required_cents
+
+
+class NoWorkersError(AgentNetError):
+    def __init__(self, message: str, region: str | None = None, alternative_regions: list[str] | None = None):
+        super().__init__(message, 503, "NO_WORKERS")
+        self.region = region
+        self.alternative_regions = alternative_regions or []
+
+
+class TaskError(AgentNetError):
+    def __init__(self, message: str, task_id: str, code: str | None = None):
+        super().__init__(message, 500, code or "TASK_ERROR")
+        self.task_id = task_id

authora_agentnet-0.1.4/agentnet/resources/__init__.py

@@ -0,0 +1,3 @@
+from .tasks import TasksResource, AsyncTasksResource
+
+__all__ = ["TasksResource", "AsyncTasksResource"]

authora_agentnet-0.1.4/agentnet/resources/tasks.py

@@ -0,0 +1,192 @@
+"""Tasks resource -- submit, wait, stream, batch, cancel, retry."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Iterator
+
+from ..errors import TaskError, TimeoutError
+
+
+class TasksResource:
+    """Sync tasks resource."""
+
+    def __init__(self, http):
+        self._http = http
+
+    def submit(self, *, skill: str, input: str, description: str = "", priority: str = "standard",
+               region: str | None = None, min_trust_score: int | None = None) -> dict[str, Any]:
+        """Submit a task for execution."""
+        body = {"skillId": skill, "inputEncrypted": input, "description": description, "slaTier": priority}
+        if region:
+            body["region"] = region
+        if min_trust_score is not None:
+            body["minTrustScore"] = min_trust_score
+        return self._http.post("/tasks", body=body)
+
+    def get(self, task_id: str) -> dict[str, Any]:
+        """Get task details."""
+        return self._http.get(f"/tasks/{task_id}")
+
+    def status(self, task_id: str) -> dict[str, Any]:
+        """Get task status with customer events."""
+        return self._http.get(f"/tasks/{task_id}/status")
+
+    def cancel(self, task_id: str) -> None:
+        """Cancel a task."""
+        self._http.post(f"/tasks/{task_id}/cancel")
+
+    def retry(self, task_id: str) -> dict[str, Any]:
+        """Retry a failed task."""
+        return self._http.post(f"/tasks/{task_id}/retry")
+
+    def acknowledge(self, task_id: str) -> None:
+        """Acknowledge an action_required event."""
+        self._http.post(f"/tasks/{task_id}/acknowledge")
+
+    def wait(self, task_id: str, timeout: int = 300, poll_interval: int = 3) -> dict[str, Any]:
+        """Wait for task completion by polling."""
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            task = self.get(task_id)
+            if task.get("status") == "completed":
+                return self._build_result(task)
+            if task.get("status") in ("failed", "cancelled"):
+                raise TaskError(f"Task {task_id} {task['status']}", task_id, task["status"])
+            time.sleep(poll_interval)
+        raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")
+
+    def submit_and_wait(self, *, skill: str, input: str, description: str = "",
+                        priority: str = "standard", timeout: int = 300, **kwargs) -> dict[str, Any]:
+        """Submit a task and wait for completion."""
+        task = self.submit(skill=skill, input=input, description=description, priority=priority, **kwargs)
+        return self.wait(task["id"], timeout=timeout)
+
+    def stream(self, task_id: str, poll_interval: int = 2) -> Iterator[dict[str, Any]]:
+        """Stream task events. Yields event dicts with type, message, actions."""
+        last_count = 0
+        while True:
+            data = self.status(task_id)
+            events = data.get("customerEvents", [])
+            for i in range(last_count, len(events)):
+                evt = events[i]
+                evt["_acknowledge"] = lambda: self.acknowledge(task_id)
+                evt["_cancel"] = lambda: self.cancel(task_id)
+                yield evt
+            last_count = len(events)
+
+            if data.get("status") == "completed":
+                result = self._build_result(data)
+                yield {"type": "completed", "message": "Task completed", "result": result}
+                return
+            if data.get("status") in ("failed", "cancelled"):
+                yield {"type": "failed", "message": f"Task {data['status']}"}
+                return
+            time.sleep(poll_interval)
+
+    def submit_batch(self, tasks: list[dict[str, Any]], concurrency: int = 5,
+                     on_progress=None) -> dict[str, Any]:
+        """Submit multiple tasks and wait for all. Returns results and failures."""
+        import concurrent.futures
+
+        results = []
+        failed = []
+        completed = 0
+
+        def run_one(params):
+            nonlocal completed
+            try:
+                result = self.submit_and_wait(**params)
+                results.append(result)
+            except Exception as e:
+                failed.append({"params": params, "error": str(e)})
+            finally:
+                completed += 1
+                if on_progress:
+                    on_progress(completed, len(tasks))
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=concurrency) as pool:
+            pool.map(run_one, tasks)
+
+        return {"results": results, "failed": failed}
+
+    def _build_result(self, task: dict[str, Any]) -> dict[str, Any]:
+        full = self._http.get(f"/tasks/{task['id']}")
+        deliverables = []
+        try:
+            art_data = self._http.get(f"/tasks/{task['id']}/artifacts")
+            deliverables = art_data.get("artifacts", [])
+        except Exception:
+            pass
+
+        return {
+            "id": task["id"],
+            "status": task.get("status", "completed"),
+            "output": full.get("outputEncrypted", ""),
+            "cost": {
+                "estimate_usdc": float(full.get("priceEstimateUsdc", 0)),
+                "actual_usdc": float(full.get("actualCostUsdc", 0)),
+            },
+            "duration_seconds": full.get("durationSeconds", 0),
+            "model": full.get("model"),
+            "deliverables": deliverables,
+        }
+
+
+class AsyncTasksResource:
+    """Async tasks resource."""
+
+    def __init__(self, http):
+        self._http = http
+
+    async def submit(self, *, skill: str, input: str, description: str = "",
+                     priority: str = "standard", **kwargs) -> dict[str, Any]:
+        body = {"skillId": skill, "inputEncrypted": input, "description": description, "slaTier": priority}
+        body.update(kwargs)
+        return await self._http.post("/tasks", body=body)
+
+    async def get(self, task_id: str) -> dict[str, Any]:
+        return await self._http.get(f"/tasks/{task_id}")
+
+    async def status(self, task_id: str) -> dict[str, Any]:
+        return await self._http.get(f"/tasks/{task_id}/status")
+
+    async def cancel(self, task_id: str) -> None:
+        await self._http.post(f"/tasks/{task_id}/cancel")
+
+    async def acknowledge(self, task_id: str) -> None:
+        await self._http.post(f"/tasks/{task_id}/acknowledge")
+
+    async def wait(self, task_id: str, timeout: int = 300, poll_interval: int = 3) -> dict[str, Any]:
+        import asyncio
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            task = await self.get(task_id)
+            if task.get("status") == "completed":
+                return await self._build_result(task)
+            if task.get("status") in ("failed", "cancelled"):
+                raise TaskError(f"Task {task_id} {task['status']}", task_id, task["status"])
+            await asyncio.sleep(poll_interval)
+        raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")
+
+    async def submit_and_wait(self, *, skill: str, input: str, timeout: int = 300, **kwargs) -> dict[str, Any]:
+        task = await self.submit(skill=skill, input=input, **kwargs)
+        return await self.wait(task["id"], timeout=timeout)
+
+    async def _build_result(self, task: dict[str, Any]) -> dict[str, Any]:
+        full = await self._http.get(f"/tasks/{task['id']}")
+        deliverables = []
+        try:
+            art_data = await self._http.get(f"/tasks/{task['id']}/artifacts")
+            deliverables = art_data.get("artifacts", [])
+        except Exception:
+            pass
+        return {
+            "id": task["id"],
+            "status": task.get("status", "completed"),
+            "output": full.get("outputEncrypted", ""),
+            "cost": {"estimate_usdc": float(full.get("priceEstimateUsdc", 0)), "actual_usdc": float(full.get("actualCostUsdc", 0))},
+            "duration_seconds": full.get("durationSeconds", 0),
+            "model": full.get("model"),
+            "deliverables": deliverables,
+        }

authora_agentnet-0.1.4/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "authora-agentnet"
+version = "0.1.4"
+description = "Official Python SDK for AgentNet -- AI engineering work as a service."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "AgentNet", email = "sdk@authora.dev" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+keywords = ["agentnet", "authora", "ai", "code-review", "automation", "sdk"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["agentnet"]
+
+[project.optional-dependencies]
+async = ["aiohttp>=3.9"]
+
+[project.urls]
+Homepage = "https://net.authora.dev"
+Repository = "https://github.com/authora-dev/agentnet-python"
+Issues = "https://github.com/authora-dev/agentnet-python/issues"