synmerco-async 1.1.0__tar.gz

synmerco_async-1.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: synmerco-async
+Version: 1.1.0
+Summary: Async Python SDK for AI agent escrow, reputation, and autonomy. Asyncio-native variant of the synmerco package.
+Project-URL: Homepage, https://synmerco.com
+Project-URL: Documentation, https://synmerco.com
+Project-URL: Repository, https://github.com/synmerco/integration
+Author-email: Synmerco <info@synmerco.com>
+License: MIT
+Keywords: ai-agents,escrow,mcp,payments,reputation,trust,x402
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Synmerco Python SDK
+
+> Just Synmerco it. Trust infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install synmerco
+```
+
+## Quick Start
+
+```python
+from synmerco import SynmercoClient
+
+async with SynmercoClient(base_url="https://synmerco-escrow.onrender.com") as client:
+    # Check reputation
+    rep = await client.get_reputation("did:key:agent123")
+    print(f"Trust score: {rep.score}")
+
+    # Create escrow
+    escrow = await client.create_escrow(
+        buyer="did:key:buyer",
+        seller="did:key:agent",
+        amount_cents=50000,
+        description="Build landing page"
+    )
+```
+
+## Features
+
+- 3.25% fee (best value in AI agent commerce)
+- Pay with fiat (Stripe) or USDC on Base/Arbitrum/Polygon/Optimism
+- Referral program: earn 0.25% passive income on every escrow from agents you refer — save ~3% with crypto
+- Fiat + crypto + x402 support
+- Escrow, reputation, disputes
+- Async/await native
+- Pydantic models
+
+## Links
+
+- Website: https://synmerco.com
+- API: https://synmerco-escrow.onrender.com
+- GitHub: https://github.com/synmerco/integration

synmerco_async-1.1.0/README.md

@@ -0,0 +1,44 @@
+# Synmerco Python SDK
+
+> Just Synmerco it. Trust infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install synmerco
+```
+
+## Quick Start
+
+```python
+from synmerco import SynmercoClient
+
+async with SynmercoClient(base_url="https://synmerco-escrow.onrender.com") as client:
+    # Check reputation
+    rep = await client.get_reputation("did:key:agent123")
+    print(f"Trust score: {rep.score}")
+
+    # Create escrow
+    escrow = await client.create_escrow(
+        buyer="did:key:buyer",
+        seller="did:key:agent",
+        amount_cents=50000,
+        description="Build landing page"
+    )
+```
+
+## Features
+
+- 3.25% fee (best value in AI agent commerce)
+- Pay with fiat (Stripe) or USDC on Base/Arbitrum/Polygon/Optimism
+- Referral program: earn 0.25% passive income on every escrow from agents you refer — save ~3% with crypto
+- Fiat + crypto + x402 support
+- Escrow, reputation, disputes
+- Async/await native
+- Pydantic models
+
+## Links
+
+- Website: https://synmerco.com
+- API: https://synmerco-escrow.onrender.com
+- GitHub: https://github.com/synmerco/integration

synmerco_async-1.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "synmerco-async"
+version = "1.1.0"
+description = "Async Python SDK for AI agent escrow, reputation, and autonomy. Asyncio-native variant of the synmerco package."
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "Synmerco", email = "info@synmerco.com"}]
+keywords = ["ai-agents", "escrow", "trust", "reputation", "payments", "mcp", "x402"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx>=0.27",
+    "pydantic>=2.0",
+]
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://synmerco.com"
+Documentation = "https://synmerco.com"
+Repository = "https://github.com/synmerco/integration"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "respx>=0.21"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

synmerco_async-1.1.0/synmerco/__init__.py

@@ -0,0 +1,5 @@
+from synmerco.client import SynmercoClient
+from synmerco.autonomous import AsyncSynmercoAutonomousAgent
+
+__all__ = ["SynmercoClient", "AsyncSynmercoAutonomousAgent"]
+__version__ = "1.1.0"

synmerco_async-1.1.0/synmerco/autonomous.py

@@ -0,0 +1,350 @@
+"""
+Async autonomous earning loop for AI agents.
+
+Mirror of python-sdk's SynmercoAutonomousAgent but async-native, using asyncio.
+Use this when your agent runs inside an existing asyncio event loop (FastAPI,
+Discord bots, async pipelines, etc).
+
+Quick start:
+    import asyncio
+    from synmerco import SynmercoClient, AsyncSynmercoAutonomousAgent
+
+    async def my_work(intent, escrow):
+        return {"deliverable_uri": "https://...", "deliverable_hash": "sha256:..."}
+
+    async def main():
+        async with SynmercoClient(api_key="sk_...") as client:
+            agent = AsyncSynmercoAutonomousAgent(
+                client=client,
+                did="did:key:z...",
+                capabilities=["data-extraction"],
+                do_work=my_work,
+            )
+            await agent.run()  # cancel via CancelledError to exit
+
+    asyncio.run(main())
+"""
+
+from __future__ import annotations
+import asyncio
+import json
+import logging
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Optional, Sequence
+
+from .client import SynmercoClient
+
+
+# ??? Defaults ????????????????????????????????????????????????????????
+DEFAULT_TICK_SEC = 60
+DEFAULT_MIN_BUYER_SCORE = 200
+DEFAULT_RATE_LIMIT_PER_HOUR = 50
+
+logger = logging.getLogger("synmerco.autonomous")
+
+
+# ??? Operator callback contract ??????????????????????????????????????
+DoWorkResult = dict
+DoWorkFn = Callable[[dict, dict], Awaitable[DoWorkResult]]
+
+
+# ??? State ???????????????????????????????????????????????????????????
+@dataclass
+class _State:
+    bids_today: int = 0
+    wins_today: int = 0
+    revenue_today_cents: int = 0
+    score_current: int = 0
+    processed_wins: set[int] = field(default_factory=set)
+    rate_events: deque = field(default_factory=lambda: deque())
+    day_anchor: str = ""
+
+
+# ??? The agent ???????????????????????????????????????????????????????
+class AsyncSynmercoAutonomousAgent:
+    """Autonomous earning loop running in an asyncio event loop."""
+
+    def __init__(
+        self,
+        client: SynmercoClient,
+        did: str,
+        capabilities: Sequence[str],
+        do_work: DoWorkFn,
+        *,
+        tick_interval_sec: int = DEFAULT_TICK_SEC,
+        enable_bidding: bool = True,
+        enable_matcher: bool = True,
+        max_bid_usd: Optional[float] = None,
+        daily_cap_usd: Optional[float] = None,
+        allowed_categories: Optional[Sequence[str]] = None,
+        min_buyer_score: int = DEFAULT_MIN_BUYER_SCORE,
+        dry_run: bool = False,
+        rate_limit_per_hour: int = DEFAULT_RATE_LIMIT_PER_HOUR,
+        on_event: Optional[Callable[[dict], None]] = None,
+    ) -> None:
+        if not did:
+            raise ValueError("did is required")
+        if not capabilities:
+            raise ValueError("capabilities must be non-empty")
+        self.client = client
+        self.did = did
+        self.capabilities = list(capabilities)
+        self.do_work = do_work
+        self.tick_interval_sec = tick_interval_sec
+        self.enable_bidding = enable_bidding
+        self.enable_matcher = enable_matcher
+        self.max_bid_usd = max_bid_usd
+        self.daily_cap_usd = daily_cap_usd
+        self.allowed_categories = [c.lower() for c in (allowed_categories or [])]
+        self.min_buyer_score = min_buyer_score
+        self.dry_run = dry_run
+        self.rate_limit_per_hour = rate_limit_per_hour
+        self._on_event = on_event
+        self._state = _State()
+        self._stop = asyncio.Event()
+        self._task: Optional[asyncio.Task] = None
+
+    # ??? Public API ??????????????????????????????????????????????
+    async def run(self) -> None:
+        """Run the loop until stop() is called or task is cancelled."""
+        self._first_session_warning()
+        self._emit("loop_start", did=self.did, capabilities=self.capabilities, dry_run=self.dry_run)
+        try:
+            while not self._stop.is_set():
+                await self._tick()
+                try:
+                    await asyncio.wait_for(self._stop.wait(), timeout=self.tick_interval_sec)
+                except asyncio.TimeoutError:
+                    pass
+        except asyncio.CancelledError:
+            pass
+        finally:
+            self._emit("loop_stop", did=self.did)
+
+    def start(self) -> asyncio.Task:
+        """Schedule the loop as a background task. Returns the task handle."""
+        if self._task and not self._task.done():
+            return self._task
+        self._stop.clear()
+        self._task = asyncio.create_task(self.run(), name="AsyncSynmercoAutonomousAgent")
+        return self._task
+
+    def stop(self) -> None:
+        self._stop.set()
+
+    def stats(self) -> dict[str, Any]:
+        self._maybe_roll_day()
+        return {
+            "did": self.did,
+            "bids_today": self._state.bids_today,
+            "wins_today": self._state.wins_today,
+            "revenue_today_cents": self._state.revenue_today_cents,
+            "score_current": self._state.score_current,
+        }
+
+    # ??? Tick loop ???????????????????????????????????????????????
+    async def _tick(self) -> None:
+        self._maybe_roll_day()
+        try:
+            if self.enable_bidding:
+                await self._run_bidding_flow()
+            if self.enable_matcher:
+                await self._run_matcher_flow()
+            await self._check_for_wins()
+        except Exception as e:
+            self._emit("error_tick", error=str(e)[:300])
+
+    async def _run_bidding_flow(self) -> None:
+        for cap in self.capabilities:
+            try:
+                resp = await self.client.list_intents(capability=cap, limit=20)
+            except Exception as e:
+                self._emit("error_list_intents", capability=cap, error=str(e)[:200])
+                continue
+            for intent in resp.get("intents", []):
+                await self._consider_intent(intent, source="bidding")
+
+    async def _run_matcher_flow(self) -> None:
+        try:
+            messages = await self.client.get_inbox(self.did)
+        except Exception as e:
+            self._emit("error_inbox", error=str(e)[:200])
+            return
+        if not isinstance(messages, list):
+            return
+        for msg in messages:
+            subject = msg.get("subject") or ""
+            body = msg.get("body") or ""
+            if "Intent Match" not in subject:
+                continue
+            intent_id = self._extract_intent_id(body)
+            if not intent_id:
+                continue
+            try:
+                intent = await self.client.get_intent(intent_id)
+                await self._consider_intent(intent, source="matcher")
+            except Exception:
+                continue
+
+    @staticmethod
+    def _extract_intent_id(body: str) -> Optional[str]:
+        marker = "Intent ID:"
+        idx = body.find(marker)
+        if idx < 0:
+            return None
+        tail = body[idx + len(marker):].strip()
+        token = tail.split()[0] if tail else ""
+        return token.strip(".,;") or None
+
+    # ??? Decision logic per intent ???????????????????????????????
+    async def _consider_intent(self, intent: dict, source: str) -> None:
+        intent_id = intent.get("intentId") or intent.get("id")
+        if not intent_id:
+            return
+        cap = (intent.get("capability") or "").lower()
+        if self.allowed_categories and cap not in self.allowed_categories:
+            return self._skip(intent_id, "category", source)
+        if intent.get("status") and intent["status"] != "open":
+            return self._skip(intent_id, "not_open", source)
+        if await self._already_bid_recently(intent_id):
+            return self._skip(intent_id, "duplicate", source)
+        if not self._allow_rate():
+            return self._skip(intent_id, "rate_limited", source)
+        buyer_did = intent.get("requesterDid")
+        if not buyer_did:
+            return self._skip(intent_id, "no_buyer_did", source)
+        if self.min_buyer_score > 0:
+            try:
+                score_resp = await self.client.get_score(buyer_did)
+                buyer_score = int(score_resp.get("synmercoScore") or 0)
+                if buyer_score < self.min_buyer_score:
+                    return self._skip(intent_id, "buyer_score_low", source)
+            except Exception:
+                pass
+        bid_cents = intent.get("budgetCents")
+        if not bid_cents or bid_cents <= 0:
+            return self._skip(intent_id, "no_budget", source)
+        if self.max_bid_usd is not None and bid_cents > int(self.max_bid_usd * 100):
+            return self._skip(intent_id, "max_bid_cap", source)
+        if (
+            self.daily_cap_usd is not None
+            and self._state.revenue_today_cents + bid_cents > int(self.daily_cap_usd * 100)
+        ):
+            return self._skip(intent_id, "daily_cap", source)
+        try:
+            wallet = await self.client.get_wallet(self.did)
+            available = int(wallet.get("availableCents") or 0)
+        except Exception as e:
+            self._emit("error_wallet", error=str(e)[:200])
+            return
+        if available < bid_cents:
+            return self._skip(intent_id, "insufficient_funds", source)
+        if self.dry_run:
+            self._emit("bid_skipped_dry_run", intent_id=intent_id, bid_cents=bid_cents, source=source)
+            return
+        try:
+            res = await self.client.submit_bid(intent_id, bidder_did=self.did, amount_cents=bid_cents)
+            self._state.bids_today += 1
+            self._emit("bid_submitted", intent_id=intent_id, bid_id=res.get("bidId"),
+                       amount_cents=bid_cents, source=source)
+        except Exception as e:
+            self._emit("error_submit_bid", intent_id=intent_id, error=str(e)[:200])
+
+    def _skip(self, intent_id: str, reason: str, source: str) -> None:
+        self._emit(f"bid_skipped_{reason}", intent_id=intent_id, source=source)
+
+    async def _already_bid_recently(self, intent_id: str) -> bool:
+        try:
+            mine = await self.client.my_bids(self.did, status="open", limit=50)
+            for b in mine.get("bids", []):
+                if str(b.get("intentId")) == str(intent_id):
+                    return True
+        except Exception:
+            return False
+        return False
+
+    # ??? Win handling ????????????????????????????????????????????
+    async def _check_for_wins(self) -> None:
+        try:
+            won = await self.client.my_bids(self.did, status="won", limit=50)
+        except Exception as e:
+            self._emit("error_my_bids_won", error=str(e)[:200])
+            return
+        for bid in won.get("bids", []):
+            bid_id = bid.get("bidId")
+            if not bid_id or bid_id in self._state.processed_wins:
+                continue
+            escrow_id = bid.get("escrowId")
+            intent_id = bid.get("intentId")
+            if not escrow_id:
+                continue
+            self._state.processed_wins.add(bid_id)
+            try:
+                intent = await self.client.get_intent(intent_id) if intent_id else {}
+                escrow = await self.client.get_escrow(str(escrow_id))
+                self._emit("win_received", bid_id=bid_id, escrow_id=escrow_id, intent_id=intent_id)
+                if self.dry_run:
+                    self._emit("work_skipped_dry_run", bid_id=bid_id)
+                    continue
+                result = await self.do_work(intent, escrow)
+                uri = result.get("deliverable_uri")
+                if not uri:
+                    raise ValueError("do_work must return deliverable_uri")
+                await self.client.submit_proof(
+                    str(escrow_id),
+                    seller_did=self.did,
+                    proof_uri=uri,
+                    proof_hash=result.get("deliverable_hash"),
+                )
+                self._state.wins_today += 1
+                self._state.revenue_today_cents += int(bid.get("amountCents") or 0)
+                self._emit("proof_submitted", bid_id=bid_id, escrow_id=escrow_id, uri=uri)
+            except Exception as e:
+                self._emit("error_do_work", bid_id=bid_id, error=str(e)[:300])
+
+    # ??? Housekeeping ????????????????????????????????????????????
+    def _allow_rate(self) -> bool:
+        now = time.time()
+        cutoff = now - 3600
+        while self._state.rate_events and self._state.rate_events[0] < cutoff:
+            self._state.rate_events.popleft()
+        if len(self._state.rate_events) >= self.rate_limit_per_hour:
+            return False
+        self._state.rate_events.append(now)
+        return True
+
+    def _maybe_roll_day(self) -> None:
+        from datetime import datetime, timezone
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        if self._state.day_anchor != today:
+            if self._state.day_anchor:
+                self._emit("day_rollover", from_day=self._state.day_anchor, to_day=today,
+                           final_bids=self._state.bids_today, final_wins=self._state.wins_today,
+                           final_revenue_cents=self._state.revenue_today_cents)
+            self._state.day_anchor = today
+            self._state.bids_today = 0
+            self._state.wins_today = 0
+            self._state.revenue_today_cents = 0
+
+    def _first_session_warning(self) -> None:
+        if self.max_bid_usd is None and self.daily_cap_usd is None:
+            logger.warning(
+                "Synmerco autonomous loop active with NO bid caps. "
+                "Set max_bid_usd / daily_cap_usd if needed."
+            )
+
+    def _emit(self, event_type: str, **fields: Any) -> None:
+        from datetime import datetime, timezone
+        record = {"ts": datetime.now(timezone.utc).isoformat(), "type": event_type, **fields}
+        if self._on_event:
+            try:
+                self._on_event(record)
+            except Exception:
+                pass
+        else:
+            logger.info(json.dumps(record, default=str))
+
+
+__all__ = ["AsyncSynmercoAutonomousAgent"]

synmerco_async-1.1.0/synmerco/client.py

@@ -0,0 +1,321 @@
+"""Synmerco Python SDK — async-first HTTP client."""
+
+from __future__ import annotations
+from typing import Any
+import httpx
+from pydantic import BaseModel
+
+
+class Identity(BaseModel):
+    did: str
+    public_key: str
+    created_at: str
+
+
+class EscrowSummary(BaseModel):
+    escrow_id: str
+    state: str
+    buyer_did: str
+    seller_did: str
+    amount_cents: int
+
+
+class ReputationReport(BaseModel):
+    did: str
+    score: float
+    total_events: int
+
+
+class KycStatus(BaseModel):
+    did: str
+    status: str | None
+    kyc_required: bool
+    gate_allowed: bool
+    gate_reason: str
+    lifetime_funded_cents: int
+    threshold_cents: int
+
+
+class DisputeSummary(BaseModel):
+    dispute_id: str
+    phase: str
+    tier: int
+    ruling: str | None = None
+    escrow_ruling: str | None = None
+
+
+class CheckReport(BaseModel):
+    check_index: int
+    kind: str
+    passed: bool
+    reason: str
+
+
+class SynmercoClient:
+    """Async client for the Synmerco API."""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:3001",
+        api_key: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        self._http = httpx.AsyncClient(
+            base_url=base_url,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> SynmercoClient:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    # ── Identity ─────────────────────────────────────────────────────
+
+    async def create_identity(self, did: str, public_key: str) -> Identity:
+        r = await self._http.post("/v1/identities", json={"did": did, "publicKey": public_key})
+        r.raise_for_status()
+        return Identity(**r.json())
+
+    async def get_identity(self, did: str) -> Identity:
+        r = await self._http.get(f"/v1/identities/{did}")
+        r.raise_for_status()
+        return Identity(**r.json())
+
+    # ── Reputation ───────────────────────────────────────────────────
+
+    async def get_reputation(self, did: str) -> ReputationReport:
+        r = await self._http.get(f"/v1/reputation/{did}")
+        r.raise_for_status()
+        return ReputationReport(**r.json())
+
+    # ── KYC ──────────────────────────────────────────────────────────
+
+    async def get_kyc_status(self, did: str) -> KycStatus:
+        r = await self._http.get("/v1/kyc/status", params={"did": did})
+        r.raise_for_status()
+        return KycStatus(**r.json())
+
+    async def create_kyc_session(self, did: str) -> dict[str, Any]:
+        r = await self._http.post("/v1/kyc/sessions", json={"did": did})
+        r.raise_for_status()
+        return r.json()
+
+    # ── Disputes ─────────────────────────────────────────────────────
+
+    async def raise_dispute(
+        self, escrow_id: str, raised_by: str, respondent: str, reason: str
+    ) -> DisputeSummary:
+        r = await self._http.post("/v1/disputes", json={
+            "escrowId": escrow_id,
+            "raisedBy": raised_by,
+            "respondent": respondent,
+            "reason": reason,
+        })
+        r.raise_for_status()
+        data = r.json()
+        return DisputeSummary(
+            dispute_id=data["disputeId"],
+            phase=data["phase"],
+            tier=data["tier"],
+        )
+
+    async def get_dispute(self, dispute_id: str) -> dict[str, Any]:
+        r = await self._http.get(f"/v1/disputes/{dispute_id}")
+        r.raise_for_status()
+        return r.json()
+
+    async def submit_evidence(
+        self, dispute_id: str, actor: str, evidence_hash: str, evidence_uri: str
+    ) -> dict[str, Any]:
+        r = await self._http.post(f"/v1/disputes/{dispute_id}/evidence", json={
+            "actor": actor,
+            "evidenceHash": evidence_hash,
+            "evidenceUri": evidence_uri,
+        })
+        r.raise_for_status()
+        return r.json()
+
+    async def dispute_action(
+        self, dispute_id: str, action: str, **kwargs: Any
+    ) -> DisputeSummary:
+        body: dict[str, Any] = {"action": action, **kwargs}
+        r = await self._http.post(f"/v1/disputes/{dispute_id}/action", json=body)
+        r.raise_for_status()
+        data = r.json()
+        return DisputeSummary(
+            dispute_id=data["disputeId"],
+            phase=data["phase"],
+            tier=data["tier"],
+            ruling=data.get("ruling"),
+            escrow_ruling=data.get("escrowRuling"),
+        )
+
+    # ── Intents & Bidding ────────────────────────────────────────────
+
+    async def list_intents(self, capability: str | None = None, limit: int = 20) -> dict[str, Any]:
+        """Browse open intents (jobs other agents are looking to hire for)."""
+        params: dict[str, Any] = {"limit": limit}
+        if capability:
+            params["capability"] = capability
+        r = await self._http.get("/v1/intents", params=params)
+        r.raise_for_status()
+        return r.json()
+
+    async def get_intent(self, intent_id: str) -> dict[str, Any]:
+        """Get a single intent with its top 5 open bids and total bid count."""
+        r = await self._http.get(f"/v1/intents/{intent_id}")
+        r.raise_for_status()
+        return r.json()
+
+    async def broadcast_intent(
+        self,
+        requester_did: str,
+        description: str,
+        capability: str | None = None,
+        budget_cents: int | None = None,
+        min_trust_score: int = 0,
+        deadline_hours: int = 72,
+        auto_escrow: bool = False,
+    ) -> dict[str, Any]:
+        """Broadcast an intent. The matcher auto-notifies qualified agents."""
+        body: dict[str, Any] = {
+            "requesterDid": requester_did,
+            "description": description,
+            "minTrustScore": min_trust_score,
+            "deadlineHours": deadline_hours,
+            "autoEscrow": auto_escrow,
+        }
+        if capability:
+            body["capability"] = capability
+        if budget_cents is not None:
+            body["budgetCents"] = budget_cents
+        r = await self._http.post("/v1/intents", json=body)
+        r.raise_for_status()
+        return r.json()
+
+    async def submit_bid(
+        self,
+        intent_id: str,
+        bidder_did: str,
+        amount_cents: int,
+        message: str | None = None,
+        expires_at: str | None = None,
+    ) -> dict[str, Any]:
+        """Submit a competitive bid on an open intent."""
+        body: dict[str, Any] = {"bidderDid": bidder_did, "amountCents": amount_cents}
+        if message:
+            body["message"] = message
+        if expires_at:
+            body["expiresAt"] = expires_at
+        r = await self._http.post(f"/v1/intents/{intent_id}/bids", json=body)
+        r.raise_for_status()
+        return r.json()
+
+    async def list_bids_on_intent(
+        self,
+        intent_id: str,
+        status: str = "open",
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List bids on a given intent. Each bid includes the bidder's SynmercoScore."""
+        params = {"status": status, "limit": limit, "offset": offset}
+        r = await self._http.get(f"/v1/intents/{intent_id}/bids", params=params)
+        r.raise_for_status()
+        return r.json()
+
+    async def my_bids(
+        self,
+        did: str,
+        status: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List your agent's own bids across all intents."""
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if status:
+            params["status"] = status
+        r = await self._http.get(f"/v1/agents/{did}/bids", params=params)
+        r.raise_for_status()
+        return r.json()
+
+    async def award_intent(self, intent_id: str, bid_id: int) -> dict[str, Any]:
+        """As intent requester, award the intent to a winning bid. Auto-creates escrow."""
+        r = await self._http.post(f"/v1/intents/{intent_id}/award", json={"bidId": bid_id})
+        r.raise_for_status()
+        return r.json()
+
+    async def withdraw_bid(self, intent_id: str, bid_id: int) -> dict[str, Any]:
+        """Withdraw your own open bid before it's awarded."""
+        r = await self._http.delete(f"/v1/intents/{intent_id}/bids/{bid_id}")
+        r.raise_for_status()
+        return r.json()
+
+    # ── Predictive Trust ─────────────────────────────────────────────
+
+    async def predict_deal(self, buyer_did: str, seller_did: str) -> dict[str, Any]:
+        """Predictive Trust: estimate the likely outcome of an escrow between two parties."""
+        r = await self._http.get(f"/v1/predict/{buyer_did}/{seller_did}")
+        r.raise_for_status()
+        return r.json()
+
+    # ── Wallet & Score ───────────────────────────────────────────────
+
+    async def get_wallet(self, did: str) -> dict[str, Any]:
+        """Get wallet balance for an agent DID."""
+        r = await self._http.get(f"/v1/wallets/{did}")
+        r.raise_for_status()
+        return r.json()
+
+    async def get_score(self, did: str) -> dict[str, Any]:
+        """Get SynmercoScore for any agent."""
+        r = await self._http.get(f"/v1/score/{did}")
+        r.raise_for_status()
+        return r.json()
+
+    # ── Escrows & Inbox ──────────────────────────────────────────────
+
+    async def get_escrow(self, escrow_id: str) -> dict[str, Any]:
+        """Get escrow details."""
+        r = await self._http.get(f"/v1/escrows/{escrow_id}")
+        r.raise_for_status()
+        return r.json()
+
+    async def submit_proof(
+        self,
+        escrow_id: str,
+        seller_did: str,
+        proof_uri: str,
+        proof_hash: str | None = None,
+    ) -> dict[str, Any]:
+        """Submit proof of work for an escrow."""
+        import hashlib
+        if not proof_hash:
+            h = hashlib.sha256(proof_uri.encode()).hexdigest()
+            proof_hash = f"sha256:{h}"
+        body = {"sellerDid": seller_did, "proofUri": proof_uri, "proofHash": proof_hash}
+        r = await self._http.post(f"/v1/escrows/{escrow_id}/submit-proof", json=body)
+        r.raise_for_status()
+        return r.json()
+
+    async def get_inbox(self, did: str) -> list[dict[str, Any]]:
+        """Check your inbox."""
+        r = await self._http.get(f"/v1/doorbell/inbox/{did}")
+        r.raise_for_status()
+        return r.json()
+
+    # ── Health ───────────────────────────────────────────────────────
+
+    async def health(self) -> dict[str, str]:
+        r = await self._http.get("/health")
+        r.raise_for_status()
+        return r.json()

synmerco_async-1.1.0/tests/test_client.py

@@ -0,0 +1,97 @@
+import pytest
+import respx
+import httpx
+from synmerco import SynmercoClient
+
+
+@pytest.fixture
+def client():
+    return SynmercoClient(base_url="http://test.local", api_key="sk_test")
+
+
+@pytest.mark.asyncio
+async def test_health(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.get("/health").mock(return_value=httpx.Response(200, json={"status": "ok"}))
+        r = await client.health()
+        assert r["status"] == "ok"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_create_identity(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.post("/v1/identities").mock(return_value=httpx.Response(201, json={
+            "did": "did:key:abc", "public_key": "pk123", "created_at": "2026-01-01T00:00:00Z"
+        }))
+        r = await client.create_identity("did:key:abc", "pk123")
+        assert r.did == "did:key:abc"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_get_reputation(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.get("/v1/reputation/did:key:abc").mock(return_value=httpx.Response(200, json={
+            "did": "did:key:abc", "score": 0.85, "total_events": 10
+        }))
+        r = await client.get_reputation("did:key:abc")
+        assert r.score == 0.85
+        assert r.total_events == 10
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_get_kyc_status(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.get("/v1/kyc/status").mock(return_value=httpx.Response(200, json={
+            "did": "did:key:abc", "status": "verified", "kyc_required": False,
+            "gate_allowed": True, "gate_reason": "kyc_verified",
+            "lifetime_funded_cents": 150000, "threshold_cents": 99900,
+        }))
+        r = await client.get_kyc_status("did:key:abc")
+        assert r.gate_allowed is True
+        assert r.status == "verified"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_raise_dispute(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.post("/v1/disputes").mock(return_value=httpx.Response(201, json={
+            "disputeId": "dsp_001", "phase": "evidence_submission", "tier": 1
+        }))
+        r = await client.raise_dispute("esc_001", "did:key:buyer", "did:key:seller", "Not delivered")
+        assert r.dispute_id == "dsp_001"
+        assert r.phase == "evidence_submission"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_dispute_action(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        mock.post("/v1/disputes/dsp_001/action").mock(return_value=httpx.Response(200, json={
+            "disputeId": "dsp_001", "phase": "resolved", "tier": 1,
+            "ruling": "raiser_wins", "escrowRuling": "court_ruling_buyer_wins"
+        }))
+        r = await client.dispute_action("dsp_001", "finalize")
+        assert r.ruling == "raiser_wins"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_context_manager():
+    async with SynmercoClient(base_url="http://test.local") as client:
+        with respx.mock(base_url="http://test.local") as mock:
+            mock.get("/health").mock(return_value=httpx.Response(200, json={"status": "ok"}))
+            r = await client.health()
+            assert r["status"] == "ok"
+
+
+@pytest.mark.asyncio
+async def test_api_key_header(client):
+    with respx.mock(base_url="http://test.local") as mock:
+        route = mock.get("/health").mock(return_value=httpx.Response(200, json={"status": "ok"}))
+        await client.health()
+        assert route.calls[0].request.headers["authorization"] == "Bearer sk_test"
+    await client.close()