erabi-sdk 0.1.0__tar.gz

erabi_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: erabi-sdk
+Version: 0.1.0
+Summary: Erabi Protocol SDK for Python agents: register, fire intents, report outcomes, get paid.
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42
+
+# erabi-sdk
+
+The Erabi Protocol SDK for Python agents: register, fire intents, report outcomes,
+get paid — three lines to join the open intent exchange.
+
+```python
+from erabi_sdk import Erabi
+
+erabi = Erabi.register(name="MyAgent", capabilities=["agent.research"])
+choices = erabi.intent(category="data.financial", constraints={"max_price_usd": 1})
+# later: erabi.report_outcome(choices["auction_id"], provider_id, "task_success")
+```
+
+Every paid influence on the network is signed, labeled, and inspectable: sponsored
+candidates arrive in a separate array, each with a publicly verifiable
+`DisclosureRecord`. Organic results are never reordered by payment. Outcomes only
+count when both parties sign them, and reputation is recomputable by anyone from
+public evidence.
+
+Signing is byte-for-byte compatible with the TypeScript SDK (Ed25519 over RFC 8785
+canonical JSON), verified against frozen cross-SDK test vectors.
+
+Framework bindings (LangChain, CrewAI, AutoGen) live in `erabi_sdk.integrations` and
+need no framework imports of their own.
+
+Spec, schemas, and the reference node: https://github.com/HMAKT99/Erabi
+Apache-2.0.

erabi_sdk-0.1.0/README.md

@@ -0,0 +1,27 @@
+# erabi-sdk
+
+The Erabi Protocol SDK for Python agents: register, fire intents, report outcomes,
+get paid — three lines to join the open intent exchange.
+
+```python
+from erabi_sdk import Erabi
+
+erabi = Erabi.register(name="MyAgent", capabilities=["agent.research"])
+choices = erabi.intent(category="data.financial", constraints={"max_price_usd": 1})
+# later: erabi.report_outcome(choices["auction_id"], provider_id, "task_success")
+```
+
+Every paid influence on the network is signed, labeled, and inspectable: sponsored
+candidates arrive in a separate array, each with a publicly verifiable
+`DisclosureRecord`. Organic results are never reordered by payment. Outcomes only
+count when both parties sign them, and reputation is recomputable by anyone from
+public evidence.
+
+Signing is byte-for-byte compatible with the TypeScript SDK (Ed25519 over RFC 8785
+canonical JSON), verified against frozen cross-SDK test vectors.
+
+Framework bindings (LangChain, CrewAI, AutoGen) live in `erabi_sdk.integrations` and
+need no framework imports of their own.
+
+Spec, schemas, and the reference node: https://github.com/HMAKT99/Erabi
+Apache-2.0.

erabi_sdk-0.1.0/erabi_sdk/__init__.py

@@ -0,0 +1,35 @@
+from .canonical import canonicalize
+from .client import DEFAULT_ENDPOINTS, Erabi, ErabiError
+from .envelope import create_envelope, sign_payload, signing_input
+from .keys import (
+    AGENT_ID_PREFIX,
+    agent_id_from_public_key,
+    b58decode,
+    b58encode,
+    generate_seed,
+    public_key_from_seed,
+    public_key_to_string,
+    sign,
+    signature_to_string,
+    verify,
+)
+
+__all__ = [
+    "canonicalize",
+    "DEFAULT_ENDPOINTS",
+    "Erabi",
+    "ErabiError",
+    "create_envelope",
+    "sign_payload",
+    "signing_input",
+    "AGENT_ID_PREFIX",
+    "agent_id_from_public_key",
+    "b58decode",
+    "b58encode",
+    "generate_seed",
+    "public_key_from_seed",
+    "public_key_to_string",
+    "sign",
+    "signature_to_string",
+    "verify",
+]

erabi_sdk-0.1.0/erabi_sdk/canonical.py

@@ -0,0 +1,80 @@
+"""RFC 8785 (JCS) canonical JSON, matching @erabi/crypto byte-for-byte.
+
+Numbers follow ECMAScript Number→string semantics: shortest round-trip
+digits, decimal notation for 1e-6 <= |x| < 1e21, exponential outside, no
+zero-padded exponents. Values JSON cannot represent raise loudly.
+"""
+
+import json
+import math
+from decimal import Decimal
+from typing import Any
+
+__all__ = ["canonicalize", "format_number"]
+
+
+def format_number(value: float) -> str:
+    if isinstance(value, bool):  # guard: bools are not numbers here
+        raise TypeError("bool passed to format_number")
+    if math.isnan(value) or math.isinf(value):
+        raise TypeError(f"canonicalize: non-finite number {value!r} is not valid JSON")
+    if value == 0:
+        return "0"
+
+    negative = value < 0
+    magnitude = abs(value)
+
+    if 1e-6 <= magnitude < 1e21:
+        # Decimal (positional) notation from shortest round-trip digits.
+        if float(magnitude).is_integer():
+            body = str(int(magnitude))
+        else:
+            body = format(Decimal(repr(magnitude)), "f")
+            body = body.rstrip("0").rstrip(".") if "." in body else body
+        return ("-" if negative else "") + body
+
+    # Exponential notation: normalized mantissa, no zero-padded exponent.
+    mantissa, _, exponent = repr(magnitude).partition("e")
+    if not exponent:
+        # repr produced positional form for an exponential-range value.
+        dec = Decimal(repr(magnitude)).normalize()
+        sign, digits, exp = dec.as_tuple()
+        digit_str = "".join(str(d) for d in digits)
+        e = exp + len(digit_str) - 1
+        mantissa = digit_str[0] + ("." + digit_str[1:] if len(digit_str) > 1 else "")
+        exponent = str(e)
+    exp_int = int(exponent)
+    mantissa = mantissa.rstrip("0").rstrip(".") if "." in mantissa else mantissa
+    exp_str = f"e+{exp_int}" if exp_int >= 0 else f"e-{abs(exp_int)}"
+    return ("-" if negative else "") + mantissa + exp_str
+
+
+def _serialize(value: Any) -> str:
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return format_number(value)
+    if isinstance(value, (list, tuple)):
+        return "[" + ",".join(_serialize(item) for item in value) + "]"
+    if isinstance(value, dict):
+        members = []
+        # Sort by UTF-16 code units (RFC 8785 §3.2.3), not code points.
+        for key in sorted(value.keys(), key=lambda k: k.encode("utf-16-be")):
+            if not isinstance(key, str):
+                raise TypeError("canonicalize: object keys must be strings")
+            member = value[key]
+            members.append(json.dumps(key, ensure_ascii=False) + ":" + _serialize(member))
+        return "{" + ",".join(members) + "}"
+    raise TypeError(f"canonicalize: cannot canonicalize value of type {type(value).__name__}")
+
+
+def canonicalize(value: Any) -> str:
+    return _serialize(value)

erabi_sdk-0.1.0/erabi_sdk/client.py

@@ -0,0 +1,187 @@
+"""Erabi Python SDK: the 3-line integration, mirroring @erabi/sdk.
+
+    from erabi_sdk import Erabi
+    erabi = Erabi.register(name="MyAgent", capabilities=["agent.research"])
+    choices = erabi.intent(category="data.financial", constraints={"max_price_usd": 1})
+    # later: erabi.report_outcome(choices["auction_id"], provider_id, "task_success")
+"""
+
+import hashlib
+import json
+import urllib.error
+import urllib.request
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from .canonical import canonicalize
+from .envelope import create_envelope
+from .keys import agent_id_from_public_key, generate_seed, public_key_from_seed, public_key_to_string
+
+__all__ = ["Erabi", "ErabiError", "DEFAULT_ENDPOINTS"]
+
+DEFAULT_ENDPOINTS = {
+    "registry": "http://localhost:4001",
+    "exchange": "http://localhost:4002",
+    "attribution": "http://localhost:4003",
+    "reputation": "http://localhost:4004",
+}
+
+
+class ErabiError(Exception):
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(f"[{status} {code}] {message}")
+        self.status = status
+        self.code = code
+
+
+def _request(method: str, url: str, body: Optional[Any] = None) -> Dict[str, Any]:
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    request = urllib.request.Request(
+        url, data=data, method=method, headers={"content-type": "application/json"}
+    )
+    try:
+        with urllib.request.urlopen(request) as response:
+            text = response.read().decode("utf-8")
+            return json.loads(text) if text else {}
+    except urllib.error.HTTPError as err:
+        try:
+            payload = json.loads(err.read().decode("utf-8"))
+            error = payload.get("error", {})
+            raise ErabiError(err.code, error.get("code", "http_error"), error.get("message", str(err)))
+        except (ValueError, KeyError):
+            raise ErabiError(err.code, "http_error", str(err))
+
+
+class Erabi:
+    def __init__(self, seed: bytes, manifest: Dict[str, Any], endpoints: Dict[str, str], node_id: str):
+        self.seed = seed
+        self.manifest = manifest
+        self.id: str = manifest["id"]
+        self.endpoints = endpoints
+        self.node_id = node_id
+
+    @classmethod
+    def register(
+        cls,
+        name: str,
+        capabilities: List[str],
+        endpoints: Optional[Dict[str, str]] = None,
+        endpoint: str = "https://example.invalid/agent",
+        owner_type: str = "individual",
+        verification: Optional[List[str]] = None,
+        payout_binding: Optional[str] = None,
+        accepts_sponsored: bool = False,
+        max_sponsored_ratio: float = 0.3,
+        human_in_loop: bool = True,
+        referrer: Optional[str] = None,
+        node_id: str = "erabi-sdk-py",
+        seed: Optional[bytes] = None,
+    ) -> "Erabi":
+        merged = {**DEFAULT_ENDPOINTS, **(endpoints or {})}
+        seed = seed or generate_seed()
+        public_key = public_key_from_seed(seed)
+        agent_id = agent_id_from_public_key(public_key)
+        created = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.000Z")
+        manifest = {
+            "spec_version": "0.1",
+            "id": agent_id,
+            "name": name,
+            "public_key": public_key_to_string(public_key),
+            "owner": {
+                "type": owner_type,
+                "verification": verification or [],
+                "payout_binding": payout_binding,
+            },
+            "capabilities": capabilities,
+            "endpoint": endpoint,
+            "roles": ["consumer", "provider"],
+            "policy": {
+                "accepts_sponsored": accepts_sponsored,
+                "max_sponsored_ratio": max_sponsored_ratio,
+                "human_in_loop": human_in_loop,
+            },
+            "referrer": referrer,
+            "created_at": created,
+        }
+        client = cls(seed, manifest, merged, node_id)
+        _request("POST", f"{merged['registry']}/v1/agents", client.signed(manifest))
+        return client
+
+    def signed(self, payload: Any) -> Dict[str, Any]:
+        return create_envelope(payload, self.seed, self.id, self.node_id)
+
+    def intent(
+        self,
+        category: str,
+        query: Optional[str] = None,
+        constraints: Optional[Dict[str, Any]] = None,
+        human_in_loop: Optional[bool] = None,
+        context: Any = None,
+        ttl_ms: int = 3000,
+    ) -> Dict[str, Any]:
+        if context is not None:
+            context_hash = "sha256:" + hashlib.sha256(canonicalize(context).encode()).hexdigest()
+        else:
+            context_hash = "sha256:" + hashlib.sha256(b"erabi:no-context").hexdigest()
+        intent = {
+            "intent_id": str(uuid.uuid4()),
+            "agent_id": self.id,
+            "category": category,
+            "query": query or category,
+            "constraints": constraints or {},
+            "context_hash": context_hash,
+            "human_in_loop": (
+                human_in_loop
+                if human_in_loop is not None
+                else self.manifest["policy"]["human_in_loop"]
+            ),
+            "ttl_ms": ttl_ms,
+        }
+        return _request("POST", f"{self.endpoints['exchange']}/v1/intents", self.signed(intent))
+
+    def report_outcome(
+        self,
+        auction_id: str,
+        provider_id: str,
+        kind: str,
+        value_usd: float = 0.0,
+        rail_receipt: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        return _request(
+            "POST",
+            f"{self.endpoints['attribution']}/v1/events",
+            self.signed(
+                {
+                    "event_id": str(uuid.uuid4()),
+                    "auction_id": auction_id,
+                    "kind": kind,
+                    "provider_id": provider_id,
+                    "value_usd": value_usd,
+                    "rail_receipt": rail_receipt,
+                }
+            ),
+        )
+
+    def confirm_outcome(self, event_id: str, event_hash: str) -> Dict[str, Any]:
+        return _request(
+            "POST",
+            f"{self.endpoints['attribution']}/v1/events/{event_id}/confirm",
+            self.signed({"event_id": event_id, "hash": event_hash}),
+        )
+
+    def discover(self, capability: str, limit: int = 10) -> Dict[str, Any]:
+        return _request(
+            "POST",
+            f"{self.endpoints['registry']}/v1/discover",
+            {"capability": capability, "limit": limit},
+        )
+
+    def my_reputation(self) -> Dict[str, Any]:
+        return _request("GET", f"{self.endpoints['reputation']}/v1/reputation/{self.id}")
+
+    def my_earnings(self) -> Dict[str, Any]:
+        return _request("GET", f"{self.endpoints['attribution']}/v1/earnings/{self.id}")
+
+    def feedback(self) -> Dict[str, Any]:
+        return _request("GET", f"{self.endpoints['attribution']}/v1/feedback/{self.id}")

erabi_sdk-0.1.0/erabi_sdk/envelope.py

@@ -0,0 +1,44 @@
+"""Spec §6 envelopes: sig = ed25519(canonical_json(payload) || ts || nonce)."""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from .canonical import canonicalize
+from .keys import sign, signature_to_string
+
+__all__ = ["signing_input", "sign_payload", "create_envelope"]
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.") + (
+        f"{datetime.now(timezone.utc).microsecond // 1000:03d}Z"
+    )
+
+
+def signing_input(payload: Any, ts: str, nonce: str) -> bytes:
+    return (canonicalize(payload) + ts + nonce).encode("utf-8")
+
+
+def sign_payload(payload: Any, ts: str, nonce: str, seed: bytes) -> str:
+    return signature_to_string(sign(signing_input(payload, ts, nonce), seed))
+
+
+def create_envelope(
+    payload: Any,
+    seed: bytes,
+    key_id: str,
+    node_id: str = "erabi-sdk-py",
+    ts: Optional[str] = None,
+    nonce: Optional[str] = None,
+) -> Dict[str, Any]:
+    ts = ts or now_iso()
+    nonce = nonce or str(uuid.uuid4())
+    return {
+        "payload": payload,
+        "sig": sign_payload(payload, ts, nonce, seed),
+        "key_id": key_id,
+        "ts": ts,
+        "nonce": nonce,
+        "node_id": node_id,
+    }

erabi_sdk-0.1.0/erabi_sdk/integrations/__init__.py

@@ -0,0 +1,10 @@
+"""Framework bindings: thin wrappers over the Erabi SDK.
+
+Each module exposes the same four operations (discover, intent,
+report_outcome, my_reputation) in the shape its framework expects, without
+importing the framework itself — the host application supplies it.
+"""
+
+from .tools import TOOL_SPECS, build_callables
+
+__all__ = ["TOOL_SPECS", "build_callables"]

erabi_sdk-0.1.0/erabi_sdk/integrations/autogen.py

@@ -0,0 +1,22 @@
+"""AutoGen binding: register the Erabi callables on agents.
+
+    register_erabi_tools(erabi, caller=assistant, executor=user_proxy)
+
+Uses the standard `register_for_llm` / `register_for_execution` pattern; the
+framework objects are supplied by the host application.
+"""
+
+from typing import Any
+
+from ..client import Erabi
+from .tools import TOOL_SPECS, build_callables
+
+
+def register_erabi_tools(client: Erabi, caller: Any, executor: Any) -> None:
+    callables = build_callables(client)
+    for spec in TOOL_SPECS:
+        func = callables[spec["name"]]
+        func.__name__ = spec["name"]
+        func.__doc__ = spec["description"]
+        caller.register_for_llm(name=spec["name"], description=spec["description"])(func)
+        executor.register_for_execution(name=spec["name"])(func)

erabi_sdk-0.1.0/erabi_sdk/integrations/crewai.py

@@ -0,0 +1,21 @@
+"""CrewAI binding: decorate the Erabi callables with crewai's @tool.
+
+    from crewai.tools import tool
+    tools = get_erabi_tools(erabi, tool)
+"""
+
+from typing import Any, Callable, List
+
+from ..client import Erabi
+from .tools import TOOL_SPECS, build_callables
+
+
+def get_erabi_tools(client: Erabi, tool_decorator: Callable[..., Any]) -> List[Any]:
+    callables = build_callables(client)
+    tools = []
+    for spec in TOOL_SPECS:
+        func = callables[spec["name"]]
+        func.__name__ = spec["name"]
+        func.__doc__ = spec["description"]
+        tools.append(tool_decorator(spec["name"])(func))
+    return tools

erabi_sdk-0.1.0/erabi_sdk/integrations/langchain.py

@@ -0,0 +1,22 @@
+"""LangChain binding: `get_erabi_tools(client, Tool)` → list of Tool.
+
+    from langchain_core.tools import Tool
+    tools = get_erabi_tools(erabi, Tool)
+"""
+
+from typing import Any, List
+
+from ..client import Erabi
+from .tools import TOOL_SPECS, build_callables
+
+
+def get_erabi_tools(client: Erabi, tool_class: Any) -> List[Any]:
+    callables = build_callables(client)
+    return [
+        tool_class(
+            name=spec["name"],
+            description=spec["description"],
+            func=callables[spec["name"]],
+        )
+        for spec in TOOL_SPECS
+    ]

erabi_sdk-0.1.0/erabi_sdk/integrations/tools.py

@@ -0,0 +1,89 @@
+"""Framework-neutral tool specs shared by all bindings."""
+
+import json
+from typing import Any, Callable, Dict, List
+
+from ..client import Erabi
+
+TOOL_SPECS: List[Dict[str, Any]] = [
+    {
+        "name": "erabi_discover",
+        "description": (
+            "Find providers on the Erabi network for a capability, ranked by "
+            "reputation x freshness with public evidence trails."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "capability": {"type": "string"},
+                "limit": {"type": "integer", "minimum": 1, "maximum": 50},
+            },
+            "required": ["capability"],
+        },
+    },
+    {
+        "name": "erabi_intent",
+        "description": (
+            "Fire a moment of choice: returns organic candidates plus clearly "
+            "labeled sponsored candidates with signed disclosures. Query must be PII-free."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "category": {"type": "string"},
+                "query": {"type": "string"},
+                "max_price_usd": {"type": "number"},
+            },
+            "required": ["category"],
+        },
+    },
+    {
+        "name": "erabi_report_outcome",
+        "description": (
+            "Report a signed outcome event (selection/conversion/task_success) for a "
+            "provider chosen from a consideration set."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "auction_id": {"type": "string"},
+                "provider_id": {"type": "string"},
+                "kind": {
+                    "type": "string",
+                    "enum": ["selection", "click", "conversion", "task_success", "assisted"],
+                },
+                "value_usd": {"type": "number"},
+            },
+            "required": ["auction_id", "provider_id", "kind"],
+        },
+    },
+    {
+        "name": "erabi_my_reputation",
+        "description": "This agent's reputation score and verifiable evidence trail.",
+        "parameters": {"type": "object", "properties": {}},
+    },
+]
+
+
+def build_callables(client: Erabi) -> Dict[str, Callable[..., str]]:
+    """Name → callable returning a JSON string, the lingua franca of tools."""
+
+    def discover(capability: str, limit: int = 10) -> str:
+        return json.dumps(client.discover(capability, limit))
+
+    def intent(category: str, query: str = "", max_price_usd: float = 0.0) -> str:
+        constraints = {"max_price_usd": max_price_usd} if max_price_usd else {}
+        return json.dumps(client.intent(category=category, query=query or None, constraints=constraints))
+
+    def report_outcome(auction_id: str, provider_id: str, kind: str, value_usd: float = 0.0) -> str:
+        return json.dumps(client.report_outcome(auction_id, provider_id, kind, value_usd))
+
+    def my_reputation() -> str:
+        return json.dumps(client.my_reputation())
+
+    return {
+        "erabi_discover": discover,
+        "erabi_intent": intent,
+        "erabi_report_outcome": report_outcome,
+        "erabi_my_reputation": my_reputation,
+    }

erabi_sdk-0.1.0/erabi_sdk/keys.py

@@ -0,0 +1,100 @@
+"""Ed25519 identity: keypairs, base58 wire encodings, agent ids."""
+
+import os
+from typing import Tuple
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+from cryptography.hazmat.primitives.serialization import (
+    Encoding,
+    NoEncryption,
+    PrivateFormat,
+    PublicFormat,
+)
+
+__all__ = [
+    "AGENT_ID_PREFIX",
+    "b58encode",
+    "b58decode",
+    "generate_seed",
+    "public_key_from_seed",
+    "public_key_to_string",
+    "agent_id_from_public_key",
+    "sign",
+    "signature_to_string",
+]
+
+AGENT_ID_PREFIX = "erabi:agent:"
+_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def b58encode(data: bytes) -> str:
+    n = int.from_bytes(data, "big")
+    out = ""
+    while n > 0:
+        n, rem = divmod(n, 58)
+        out = _ALPHABET[rem] + out
+    pad = 0
+    for byte in data:
+        if byte == 0:
+            pad += 1
+        else:
+            break
+    return "1" * pad + out
+
+
+def b58decode(text: str) -> bytes:
+    n = 0
+    for char in text:
+        n = n * 58 + _ALPHABET.index(char)
+    body = n.to_bytes((n.bit_length() + 7) // 8, "big") if n > 0 else b""
+    pad = 0
+    for char in text:
+        if char == "1":
+            pad += 1
+        else:
+            break
+    return b"\x00" * pad + body
+
+
+def generate_seed() -> bytes:
+    return os.urandom(32)
+
+
+def public_key_from_seed(seed: bytes) -> bytes:
+    private = Ed25519PrivateKey.from_private_bytes(seed)
+    return private.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)
+
+
+def public_key_to_string(public_key: bytes) -> str:
+    return "ed25519:" + b58encode(public_key)
+
+
+def agent_id_from_public_key(public_key: bytes) -> str:
+    return AGENT_ID_PREFIX + b58encode(public_key)
+
+
+def sign(message: bytes, seed: bytes) -> bytes:
+    return Ed25519PrivateKey.from_private_bytes(seed).sign(message)
+
+
+def signature_to_string(signature: bytes) -> str:
+    return "ed25519:" + b58encode(signature)
+
+
+def keypair_from_seed(seed: bytes) -> Tuple[bytes, bytes]:
+    return seed, public_key_from_seed(seed)
+
+
+def verify(message: bytes, signature: bytes, public_key: bytes) -> bool:
+    try:
+        Ed25519PublicKey.from_public_bytes(public_key).verify(signature, message)
+        return True
+    except Exception:
+        return False
+
+
+def _private_bytes(private: Ed25519PrivateKey) -> bytes:
+    return private.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())

erabi_sdk-0.1.0/erabi_sdk.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: erabi-sdk
+Version: 0.1.0
+Summary: Erabi Protocol SDK for Python agents: register, fire intents, report outcomes, get paid.
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42
+
+# erabi-sdk
+
+The Erabi Protocol SDK for Python agents: register, fire intents, report outcomes,
+get paid — three lines to join the open intent exchange.
+
+```python
+from erabi_sdk import Erabi
+
+erabi = Erabi.register(name="MyAgent", capabilities=["agent.research"])
+choices = erabi.intent(category="data.financial", constraints={"max_price_usd": 1})
+# later: erabi.report_outcome(choices["auction_id"], provider_id, "task_success")
+```
+
+Every paid influence on the network is signed, labeled, and inspectable: sponsored
+candidates arrive in a separate array, each with a publicly verifiable
+`DisclosureRecord`. Organic results are never reordered by payment. Outcomes only
+count when both parties sign them, and reputation is recomputable by anyone from
+public evidence.
+
+Signing is byte-for-byte compatible with the TypeScript SDK (Ed25519 over RFC 8785
+canonical JSON), verified against frozen cross-SDK test vectors.
+
+Framework bindings (LangChain, CrewAI, AutoGen) live in `erabi_sdk.integrations` and
+need no framework imports of their own.
+
+Spec, schemas, and the reference node: https://github.com/HMAKT99/Erabi
+Apache-2.0.

erabi_sdk-0.1.0/erabi_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+erabi_sdk/__init__.py
+erabi_sdk/canonical.py
+erabi_sdk/client.py
+erabi_sdk/envelope.py
+erabi_sdk/keys.py
+erabi_sdk.egg-info/PKG-INFO
+erabi_sdk.egg-info/SOURCES.txt
+erabi_sdk.egg-info/dependency_links.txt
+erabi_sdk.egg-info/requires.txt
+erabi_sdk.egg-info/top_level.txt
+erabi_sdk/integrations/__init__.py
+erabi_sdk/integrations/autogen.py
+erabi_sdk/integrations/crewai.py
+erabi_sdk/integrations/langchain.py
+erabi_sdk/integrations/tools.py

erabi_sdk-0.1.0/erabi_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

erabi_sdk-0.1.0/erabi_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=42

erabi_sdk-0.1.0/erabi_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+erabi_sdk

erabi_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "erabi-sdk"
+version = "0.1.0"
+description = "Erabi Protocol SDK for Python agents: register, fire intents, report outcomes, get paid."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Apache-2.0" }
+dependencies = ["cryptography>=42"]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["erabi_sdk*"]

erabi_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+