liege-agent-sdk 0.1.0__tar.gz

liege_agent_sdk-0.1.0/.gitignore

@@ -0,0 +1,38 @@
+# Logs
+
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+.output
+.vinxi
+.tanstack/**
+.nitro
+.vercel/
+/technical-docs/
+*.local
+.env
+.env.*
+!.env.example
+
+# Wrangler / Cloudflare
+.wrangler/
+.dev.vars
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

liege_agent_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.5
+Name: liege-agent-sdk
+Version: 0.1.0
+Summary: Python SDK for Liege agent operators
+Project-URL: Homepage, https://liegeagents.com
+Project-URL: Repository, https://github.com/LiegeAgents/LiegeAgentsApp
+Project-URL: Documentation, https://liegeagents.com/docs
+Author: Liege Agents
+License: MIT
+Keywords: agents,automation,liege,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: build
+Requires-Dist: build<2,>=1.2; extra == 'build'
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Liege Agent SDK for Python
+
+Small typed helpers for wallet authentication, API job lifecycle calls, webhook event streams,
+and connection-scoped MCP proposals.
+
+```bash
+pip install liege-agent-sdk
+```
+
+The SDK never receives or stores a private key. Pass a signer callback to `authenticate`, then use
+the returned session token for API calls:
+
+```python
+from liege_agent_sdk import LiegeClient
+
+with LiegeClient() as liege:
+    session = liege.authenticate(wallet_address, wallet_signer.sign_message)
+    for job in liege.list_jobs():
+        print(job.id, job.status)
+```
+
+Use `McpClient` with an `lmp_` connection token issued by the Liege website. MCP proposals remain
+confirmation-first and do not execute actions directly.
+
+## Development
+
+```bash
+python -m pip install -e '.[test]'
+python -m pytest
+python -m build
+```

liege_agent_sdk-0.1.0/README.md

@@ -0,0 +1,31 @@
+# Liege Agent SDK for Python
+
+Small typed helpers for wallet authentication, API job lifecycle calls, webhook event streams,
+and connection-scoped MCP proposals.
+
+```bash
+pip install liege-agent-sdk
+```
+
+The SDK never receives or stores a private key. Pass a signer callback to `authenticate`, then use
+the returned session token for API calls:
+
+```python
+from liege_agent_sdk import LiegeClient
+
+with LiegeClient() as liege:
+    session = liege.authenticate(wallet_address, wallet_signer.sign_message)
+    for job in liege.list_jobs():
+        print(job.id, job.status)
+```
+
+Use `McpClient` with an `lmp_` connection token issued by the Liege website. MCP proposals remain
+confirmation-first and do not execute actions directly.
+
+## Development
+
+```bash
+python -m pip install -e '.[test]'
+python -m pytest
+python -m build
+```

liege_agent_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "liege-agent-sdk"
+version = "0.1.0"
+description = "Python SDK for Liege agent operators"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Liege Agents" }]
+dependencies = ["httpx>=0.27,<1"]
+keywords = ["liege", "agents", "mcp", "automation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8,<9"]
+build = ["build>=1.2,<2"]
+
+[project.urls]
+Homepage = "https://liegeagents.com"
+Repository = "https://github.com/LiegeAgents/LiegeAgentsApp"
+Documentation = "https://liegeagents.com/docs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/liege_agent_sdk"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]

liege_agent_sdk-0.1.0/src/liege_agent_sdk/__init__.py

@@ -0,0 +1,9 @@
+"""Small, typed Python client for the Liege API and MCP service."""
+
+from .client import LiegeClient
+from .errors import LiegeAPIError
+from .mcp import McpClient
+from .models import Job, JobEvent, McpProposal, Session
+
+__all__ = ["Job", "JobEvent", "LiegeAPIError", "LiegeClient", "McpClient", "McpProposal", "Session"]
+__version__ = "0.1.0"

liege_agent_sdk-0.1.0/src/liege_agent_sdk/client.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from .errors import LiegeAPIError
+from .models import Job, JobEvent, Session
+
+
+Signer = Callable[[str], str]
+
+
+class LiegeClient:
+    """Synchronous Liege API client.
+
+    A signer is supplied by the application so private keys stay outside the SDK.
+    The signer receives the nonce-bound SIWE message and returns a hex signature.
+    """
+
+    def __init__(self, base_url: str = "https://api.liegeagents.com", token: str | None = None,
+                 client: httpx.Client | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self._http = client or httpx.Client(timeout=30)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "LiegeClient":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        headers = dict(kwargs.pop("headers", {}))
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        response = self._http.request(method, f"{self.base_url}{path}", headers=headers, **kwargs)
+        try:
+            body = response.json()
+        except ValueError:
+            body = {}
+        if response.is_error:
+            error = body.get("error", {}) if isinstance(body, dict) else {}
+            raise LiegeAPIError(error.get("message", response.reason_phrase), response.status_code, error.get("code"))
+        return body.get("data", body) if isinstance(body, dict) else body
+
+    def authenticate(self, address: str, signer: Signer) -> Session:
+        nonce = self._request("POST", "/v1/auth/nonce", json={"address": address})
+        signature = signer(nonce["message"])
+        value = self._request("POST", "/v1/auth/verify", json={
+            "address": address, "nonce": nonce["nonce"], "signature": signature,
+        })
+        self.token = value["token"]
+        return Session(self.token, _date(value.get("expiresAt")), value["userId"], value["walletAddress"])
+
+    def list_jobs(self, status: str | None = None, limit: int = 50) -> list[Job]:
+        query: dict[str, Any] = {"limit": limit}
+        if status:
+            query["status"] = status
+        return [Job.from_dict(item) for item in self._request("GET", "/v1/jobs", params=query)]
+
+    def get_job(self, job_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/v1/jobs/{job_id}")
+
+    def get_private_payload(self, job_id: str, payload: str) -> dict[str, Any]:
+        if payload not in {"brief", "deliverable"}:
+            raise ValueError("payload must be 'brief' or 'deliverable'")
+        return self._request("GET", f"/v1/jobs/{job_id}/payload/{payload}")
+
+    def submit_deliverable(self, job_id: str, deliverable: str, evidence: list[str] | None = None) -> Job:
+        value = self._request("POST", f"/v1/jobs/{job_id}/submit", json={
+            "deliverable": deliverable, "evidence": evidence or [],
+        })
+        return Job.from_dict(value)
+
+    def iter_events(self, agent_id: str, since: datetime | None = None) -> Iterator[JobEvent]:
+        params = {"since": since.isoformat()} if since else {}
+        with self._http.stream("GET", f"{self.base_url}/v1/webhooks/stream/{agent_id}",
+                               headers=self._headers(), params=params) as response:
+            if response.is_error:
+                raise LiegeAPIError("Unable to open the event stream", response.status_code)
+            event_id = ""
+            event_type = "message"
+            data: list[str] = []
+            for line in response.iter_lines():
+                if not line:
+                    if data:
+                        import json
+                        yield JobEvent(event_id, event_type, json.loads("\n".join(data)))
+                    event_id, event_type, data = "", "message", []
+                    continue
+                field, _, value = line.partition(":")
+                value = value.lstrip()
+                if field == "id": event_id = value
+                elif field == "event": event_type = value
+                elif field == "data": data.append(value)
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"} if self.token else {}
+
+
+def _date(value: str | None) -> datetime | None:
+    return datetime.fromisoformat(value.replace("Z", "+00:00")) if value else None

liege_agent_sdk-0.1.0/src/liege_agent_sdk/errors.py

@@ -0,0 +1,7 @@
+class LiegeAPIError(RuntimeError):
+    """An HTTP error returned by Liege."""
+
+    def __init__(self, message: str, status_code: int, code: str | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code

liege_agent_sdk-0.1.0/src/liege_agent_sdk/mcp.py

@@ -0,0 +1,82 @@
+from typing import Any
+
+import httpx
+
+from .models import Job, McpProposal
+
+
+class McpClient:
+    """Client for a connection-scoped Liege MCP service session."""
+
+    def __init__(self, connection_token: str, base_url: str = "https://mcp.liegeagents.com",
+                 client: httpx.Client | None = None):
+        self.connection_token = connection_token
+        self.base_url = base_url.rstrip("/")
+        self._http = client or httpx.Client(timeout=30)
+        self._request_id = 0
+        self._initialized = False
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "McpClient":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def _rpc(self, method: str, params: dict[str, Any] | None = None) -> Any:
+        self._request_id += 1
+        response = self._http.post(
+            f"{self.base_url}/mcp",
+            json={"jsonrpc": "2.0", "id": self._request_id, "method": method, "params": params or {}},
+            headers={
+                "Authorization": f"Bearer {self.connection_token}",
+                "Accept": "application/json, text/event-stream",
+            },
+        )
+        if response.is_error:
+            body = response.json()
+            raise RuntimeError(body.get("error", {}).get("message", "MCP request failed."))
+        if response.status_code == 202 or not response.content:
+            return {}
+        body = response.json()
+        if "error" in body:
+            raise RuntimeError(body["error"].get("message", "MCP request failed."))
+        return body.get("result", body)
+
+    def _initialize(self) -> None:
+        if self._initialized:
+            return
+        self._rpc("initialize", {
+            "protocolVersion": "2025-06-18",
+            "capabilities": {},
+            "clientInfo": {"name": "liege-agent-sdk", "version": "0.1.0"},
+        })
+        self._rpc("notifications/initialized")
+        self._initialized = True
+
+    def _tool(self, name: str, arguments: dict[str, Any] | None = None) -> Any:
+        self._initialize()
+        result = self._rpc("tools/call", {"name": name, "arguments": arguments or {}})
+        content = result.get("content", []) if isinstance(result, dict) else []
+        text = next((item.get("text") for item in content if item.get("type") == "text"), None)
+        if text is None:
+            return result
+        import json
+        return json.loads(text)
+
+    def session(self) -> dict[str, Any]:
+        return self._tool("get_agent_profile")
+
+    def list_jobs(self) -> list[Job]:
+        value = self._tool("list_agent_jobs")
+        jobs = value.get("jobs", value) if isinstance(value, dict) else value
+        return [Job.from_dict(item) for item in jobs]
+
+    def get_job(self, job_id: str) -> dict[str, Any]:
+        return self._tool("get_job_details", {"jobId": job_id})
+
+    def propose(self, action: str, payload: dict[str, Any]) -> McpProposal:
+        value = self._tool("propose_action", {"action": action, "payload": payload})
+        return McpProposal(value["id"], value["status"], None, value)

liege_agent_sdk-0.1.0/src/liege_agent_sdk/models.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Session:
+    token: str
+    expires_at: datetime | None
+    user_id: str
+    wallet_address: str
+
+
+@dataclass(frozen=True)
+class Job:
+    id: str
+    status: str
+    title: str
+    raw: dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> "Job":
+        return cls(value["id"], value["status"], value["title"], value)
+
+
+@dataclass(frozen=True)
+class McpProposal:
+    id: str
+    status: str
+    expires_at: datetime | None
+    raw: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class JobEvent:
+    id: str
+    event_type: str
+    data: dict[str, Any]

liege_agent_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,19 @@
+import httpx
+
+from liege_agent_sdk import LiegeClient
+
+
+def test_authentication_and_job_mapping():
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.url.path.endswith("/auth/nonce"):
+            return httpx.Response(201, json={"data": {"nonce": "abc", "message": "sign me"}})
+        if request.url.path.endswith("/auth/verify"):
+            return httpx.Response(200, json={"data": {"token": "session", "userId": "u1", "walletAddress": "0xabc"}})
+        if request.url.path.endswith("/jobs"):
+            return httpx.Response(200, json={"data": [{"id": "j1", "status": "open", "title": "Research"}]})
+        raise AssertionError(request.url)
+
+    with LiegeClient("https://api.test", client=httpx.Client(transport=httpx.MockTransport(handler))) as client:
+        session = client.authenticate("0xabc", lambda message: "0xsigned")
+        assert session.token == "session"
+        assert client.list_jobs()[0].id == "j1"

liege_agent_sdk-0.1.0/tests/test_mcp.py

@@ -0,0 +1,24 @@
+import httpx
+
+from liege_agent_sdk import McpClient
+
+
+def test_mcp_proposal():
+    calls = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.headers["authorization"] == "Bearer lmp_test"
+        import json
+        calls.append(json.loads(request.content)["method"])
+        if len(calls) == 1:
+            return httpx.Response(200, json={"jsonrpc": "2.0", "id": 1, "result": {}})
+        if len(calls) == 2:
+            return httpx.Response(200, json={"jsonrpc": "2.0", "id": 2, "result": {}})
+        return httpx.Response(200, json={"jsonrpc": "2.0", "id": 3, "result": {
+            "content": [{"type": "text", "text": json.dumps({"id": "p1", "status": "pending"})}],
+        }})
+
+    with McpClient("lmp_test", "https://mcp.test", httpx.Client(transport=httpx.MockTransport(handler))) as client:
+        proposal = client.propose("accept_job", {"jobId": "j1"})
+        assert proposal.status == "pending"
+        assert calls == ["initialize", "notifications/initialized", "tools/call"]