synchronity-sdk 0.1.1__py3-none-any.whl

agentmesh/__init__.py

@@ -0,0 +1,62 @@
+from .client import AgentMeshClient
+from .config import AgentMeshConfig, SDK_VERSION
+from .errors import (
+    AgentMeshError,
+    AuthenticationError,
+    AuthorizationError,
+    ConnectorError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    TimeoutError,
+    ValidationError,
+)
+from .http import HttpClient
+from .modules import (
+    CartModule,
+    CheckoutModule,
+    DiscoveryModule,
+    OrdersModule,
+    ProductsModule,
+    ShippingAddressParams,
+)
+from .types import (
+    AMPSCapabilityManifest,
+    AMPSCart,
+    AMPSOrder,
+    AMPSOrderStatus,
+    AMPSProduct,
+    AvailabilityStatus,
+    MonetaryAmount,
+    SiteListItem,
+)
+
+__all__ = [
+    "AgentMeshClient",
+    "AgentMeshConfig",
+    "SDK_VERSION",
+    "AgentMeshError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "ConnectorError",
+    "NetworkError",
+    "NotFoundError",
+    "RateLimitError",
+    "TimeoutError",
+    "ValidationError",
+    "HttpClient",
+    "CartModule",
+    "CheckoutModule",
+    "DiscoveryModule",
+    "OrdersModule",
+    "ProductsModule",
+    "ShippingAddressParams",
+    "AMPSCapabilityManifest",
+    "AMPSCart",
+    "AMPSOrder",
+    "AMPSOrderStatus",
+    "AMPSProduct",
+    "AvailabilityStatus",
+    "MonetaryAmount",
+    "SiteListItem",
+]

agentmesh/client.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .config import AgentMeshConfig
+from .http import HttpClient
+from .modules.cart import CartModule
+from .modules.checkout import CheckoutModule
+from .modules.discovery import DiscoveryModule
+from .modules.orders import OrdersModule
+from .modules.products import ProductsModule
+
+
+class AgentMeshClient:
+    def __init__(self, config: AgentMeshConfig) -> None:
+        self._http = HttpClient(config)
+        self.discovery = DiscoveryModule(self._http)
+        self.products = ProductsModule(self._http)
+        self.cart = CartModule(self._http)
+        self.checkout = CheckoutModule(self._http)
+        self.orders = OrdersModule(self._http)
+
+    async def __aenter__(self) -> "AgentMeshClient":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._http.close()
+
+    async def close(self) -> None:
+        await self._http.close()
+
+    @classmethod
+    def with_http_client(
+        cls, config: AgentMeshConfig, http_client: HttpClient
+    ) -> "AgentMeshClient":
+        """Inject a pre-built HttpClient — useful for testing."""
+        instance = cls.__new__(cls)
+        instance._http = http_client
+        instance.discovery = DiscoveryModule(http_client)
+        instance.products = ProductsModule(http_client)
+        instance.cart = CartModule(http_client)
+        instance.checkout = CheckoutModule(http_client)
+        instance.orders = OrdersModule(http_client)
+        return instance

agentmesh/config.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+SDK_VERSION = "0.1.0"
+DEFAULT_BASE_URL = "https://gateway.agentmesh.ai"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_RETRIES = 3
+DEFAULT_RETRY_DELAY = 1.0
+
+
+@dataclass
+class AgentMeshConfig:
+    agent_token: str
+    base_url: str = DEFAULT_BASE_URL
+    timeout: float = DEFAULT_TIMEOUT
+    retries: int = DEFAULT_RETRIES
+    retry_delay: float = DEFAULT_RETRY_DELAY

agentmesh/errors.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from typing import Optional, Union
+
+
+class AgentMeshError(Exception):
+    def __init__(
+        self,
+        message: str,
+        code: str,
+        status_code: int,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.status_code = status_code
+        self.request_id = request_id
+
+
+class AuthenticationError(AgentMeshError):
+    """Raised on HTTP 401 responses."""
+
+
+class AuthorizationError(AgentMeshError):
+    """Raised on HTTP 403 responses."""
+
+
+class NotFoundError(AgentMeshError):
+    """Raised on HTTP 404 / 410 responses."""
+
+
+class ValidationError(AgentMeshError):
+    """Raised on HTTP 400 responses."""
+
+
+class RateLimitError(AgentMeshError):
+    """Raised on HTTP 429 responses."""
+
+    def __init__(
+        self,
+        message: str,
+        code: str,
+        status_code: int,
+        request_id: Optional[str] = None,
+        retry_after: int = 60,
+    ) -> None:
+        super().__init__(message, code, status_code, request_id)
+        self.retry_after = retry_after
+
+
+class ConnectorError(AgentMeshError):
+    """Raised on HTTP 422 responses (upstream connector failure)."""
+
+
+class NetworkError(AgentMeshError):
+    """Raised on network-level failures (connection errors, etc.)."""
+
+    def __init__(self, message: str, request_id: Optional[str] = None) -> None:
+        super().__init__(message, "NETWORK_ERROR", 0, request_id)
+
+
+class TimeoutError(AgentMeshError):
+    """Raised when a request times out."""
+
+    def __init__(self, message: str, request_id: Optional[str] = None) -> None:
+        super().__init__(message, "TIMEOUT", 0, request_id)
+
+
+def parse_error_response(
+    status: int,
+    body: dict,
+    request_id: Optional[str] = None,
+    retry_after: Optional[int] = None,
+) -> AgentMeshError:
+    error = body.get("error", {})
+    code = error.get("code", "UNKNOWN_ERROR")
+    message = error.get("message", f"HTTP {status}")
+
+    if status == 400:
+        return ValidationError(message, code, status, request_id)
+    elif status == 401:
+        return AuthenticationError(message, code, status, request_id)
+    elif status == 403:
+        return AuthorizationError(message, code, status, request_id)
+    elif status in (404, 410):
+        return NotFoundError(message, code, status, request_id)
+    elif status == 422:
+        return ConnectorError(message, code, status, request_id)
+    elif status == 429:
+        return RateLimitError(
+            message,
+            code,
+            status,
+            request_id,
+            retry_after=retry_after if retry_after is not None else 60,
+        )
+    else:
+        return AgentMeshError(message, code, status, request_id)

agentmesh/http.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from .config import AgentMeshConfig, SDK_VERSION
+from .errors import (
+    AgentMeshError,
+    NetworkError,
+    TimeoutError,
+    parse_error_response,
+)
+
+
+class HttpClient:
+    def __init__(
+        self,
+        config: AgentMeshConfig,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._config = config
+        self._base_url = config.base_url.rstrip("/")
+        self._headers = {
+            "Authorization": f"Bearer {config.agent_token}",
+            "User-Agent": f"agentmesh-python/{SDK_VERSION}",
+            "Accept": "application/json",
+        }
+        self._owned = http_client is None
+        self._client = http_client or httpx.AsyncClient(
+            timeout=config.timeout,
+        )
+
+    async def __aenter__(self) -> "HttpClient":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._owned:
+            await self._client.aclose()
+
+    async def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> dict:
+        return await self._request("GET", path, params=params)
+
+    async def post(self, path: str, body: Optional[dict] = None) -> dict:
+        return await self._request("POST", path, body=body)
+
+    async def delete(self, path: str) -> dict:
+        return await self._request("DELETE", path)
+
+    def _build_url(self, path: str) -> str:
+        return f"{self._base_url}{path}"
+
+    def _clean_params(
+        self, params: Optional[Dict[str, Any]]
+    ) -> Optional[Dict[str, str]]:
+        if not params:
+            return None
+        result: Dict[str, str] = {}
+        for k, v in params.items():
+            if v is None:
+                continue
+            if isinstance(v, list):
+                result[k] = ",".join(str(i) for i in v)
+            else:
+                result[k] = str(v)
+        return result or None
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[dict] = None,
+        attempt: int = 0,
+    ) -> dict:
+        url = self._build_url(path)
+        cleaned_params = self._clean_params(params)
+
+        headers = dict(self._headers)
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+
+        try:
+            response = await self._client.request(
+                method,
+                url,
+                params=cleaned_params,
+                json=body,
+                headers=headers,
+            )
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(f"Request timed out: {method} {path}") from exc
+        except httpx.RequestError as exc:
+            raise NetworkError(f"Network error: {method} {path}: {exc}") from exc
+
+        request_id = response.headers.get("X-AgentMesh-Request-Id")
+
+        if response.is_success:
+            if response.status_code == 204:
+                return {}
+            return response.json()
+
+        # Parse retry-after header for 429
+        retry_after: Optional[int] = None
+        raw_retry = response.headers.get("Retry-After")
+        if raw_retry is not None:
+            try:
+                retry_after = int(raw_retry)
+            except ValueError:
+                retry_after = 60
+
+        # Retry on 429 and 5xx
+        should_retry = attempt < self._config.retries and (
+            response.status_code == 429 or response.status_code >= 500
+        )
+
+        if should_retry:
+            if response.status_code == 429 and retry_after is not None:
+                delay = float(retry_after)
+            else:
+                delay = self._config.retry_delay * (2**attempt)
+            await asyncio.sleep(delay)
+            return await self._request(method, path, params=params, body=body, attempt=attempt + 1)
+
+        try:
+            error_body = response.json()
+        except Exception:
+            error_body = {
+                "error": {
+                    "code": "UNKNOWN_ERROR",
+                    "message": f"HTTP {response.status_code}: {response.text}",
+                }
+            }
+
+        raise parse_error_response(response.status_code, error_body, request_id, retry_after)

agentmesh/modules/__init__.py

@@ -0,0 +1,14 @@
+from .cart import CartModule
+from .checkout import CheckoutModule, ShippingAddressParams
+from .discovery import DiscoveryModule
+from .orders import OrdersModule
+from .products import ProductsModule
+
+__all__ = [
+    "CartModule",
+    "CheckoutModule",
+    "ShippingAddressParams",
+    "DiscoveryModule",
+    "OrdersModule",
+    "ProductsModule",
+]

agentmesh/modules/cart.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from typing import Optional, Union
+
+from ..http import HttpClient
+from ..types.amps import AMPSCart
+
+
+class CartModule:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    async def create(self, site_id: str, currency: Optional[str] = None) -> AMPSCart:
+        body: dict = {}
+        if currency is not None:
+            body["currency"] = currency
+        raw = await self._http.post(f"/v1/sites/{site_id}/cart", body)
+        return AMPSCart.model_validate(raw)
+
+    async def get(self, site_id: str, cart_id: str) -> AMPSCart:
+        raw = await self._http.get(f"/v1/sites/{site_id}/cart/{cart_id}")
+        return AMPSCart.model_validate(raw)
+
+    async def add_item(
+        self,
+        site_id: str,
+        cart_id: str,
+        product_id: str,
+        quantity: int,
+        variant_id: Optional[str] = None,
+    ) -> AMPSCart:
+        body: dict = {"product_id": product_id, "quantity": quantity}
+        if variant_id is not None:
+            body["variant_id"] = variant_id
+        raw = await self._http.post(f"/v1/sites/{site_id}/cart/{cart_id}/items", body)
+        return AMPSCart.model_validate(raw)
+
+    async def remove_item(
+        self, site_id: str, cart_id: str, item_id: str
+    ) -> AMPSCart:
+        raw = await self._http.delete(
+            f"/v1/sites/{site_id}/cart/{cart_id}/items/{item_id}"
+        )
+        return AMPSCart.model_validate(raw)
+
+    async def apply_coupon(
+        self, site_id: str, cart_id: str, code: str
+    ) -> AMPSCart:
+        raw = await self._http.post(
+            f"/v1/sites/{site_id}/cart/{cart_id}/coupon", {"code": code}
+        )
+        return AMPSCart.model_validate(raw)

agentmesh/modules/checkout.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from typing import Optional, Union
+
+from dataclasses import dataclass
+
+from ..http import HttpClient
+from ..types.amps import AMPSOrder
+
+
+@dataclass
+class ShippingAddressParams:
+    name: str
+    line1: str
+    city: str
+    state: str
+    postal_code: str
+    country: str
+    line2: Optional[str] = None
+
+
+class CheckoutModule:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    async def execute(
+        self,
+        site_id: str,
+        cart_id: str,
+        buyer_delegation_token: str,
+        shipping_address: ShippingAddressParams,
+    ) -> AMPSOrder:
+        address: dict = {
+            "name": shipping_address.name,
+            "line1": shipping_address.line1,
+            "city": shipping_address.city,
+            "state": shipping_address.state,
+            "postal_code": shipping_address.postal_code,
+            "country_code": shipping_address.country,
+        }
+        if shipping_address.line2 is not None:
+            address["line2"] = shipping_address.line2
+
+        body = {
+            "cart_id": cart_id,
+            "buyer_delegation_token": buyer_delegation_token,
+            "shipping_address": address,
+        }
+        raw = await self._http.post(f"/v1/sites/{site_id}/checkout", body)
+        return AMPSOrder.model_validate(raw)

agentmesh/modules/discovery.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+from typing import Optional, Union, List
+
+from ..http import HttpClient
+from ..types.amps import AMPSCapabilityManifest, PaginatedSiteResponse
+
+
+class DiscoveryModule:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    async def list_sites(
+        self,
+        category: Optional[str] = None,
+        ships_to: Optional[str] = None,
+        capabilities: Optional[List[str]] = None,
+        page: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> dict:
+        params: dict = {}
+        if category is not None:
+            params["category"] = category
+        if ships_to is not None:
+            params["ships_to"] = ships_to
+        if capabilities is not None:
+            params["capabilities"] = capabilities
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+
+        raw = await self._http.get("/v1/sites", params or None)
+        response = PaginatedSiteResponse.model_validate(raw)
+        return {
+            "sites": [s.model_dump() for s in response.data],
+            "total": response.pagination.total,
+            "page": response.pagination.page,
+        }
+
+    async def get_manifest(self, site_id: str) -> AMPSCapabilityManifest:
+        raw = await self._http.get(f"/v1/sites/{site_id}/manifest")
+        return AMPSCapabilityManifest.model_validate(raw)

agentmesh/modules/orders.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Optional, Union
+
+from ..http import HttpClient
+from ..types.amps import AMPSOrder, AMPSOrderStatus, PaginatedOrderResponse
+
+
+class OrdersModule:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    async def get(self, site_id: str, order_id: str) -> AMPSOrder:
+        raw = await self._http.get(f"/v1/sites/{site_id}/orders/{order_id}")
+        return AMPSOrder.model_validate(raw)
+
+    async def list(
+        self,
+        site_id: str,
+        page: Optional[int] = None,
+        limit: Optional[int] = None,
+        status: AMPSOrderStatus | Optional[str] = None,
+    ) -> dict:
+        params: dict = {}
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+        if status is not None:
+            params["status"] = str(status.value if isinstance(status, AMPSOrderStatus) else status)
+
+        raw = await self._http.get(f"/v1/sites/{site_id}/orders", params or None)
+        response = PaginatedOrderResponse.model_validate(raw)
+        return {
+            "orders": [o.model_dump() for o in response.data],
+            "total": response.pagination.total,
+        }

agentmesh/modules/products.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from typing import Optional, Union, List
+
+from ..http import HttpClient
+from ..types.amps import AMPSProduct, PaginatedProductResponse
+
+
+class ProductsModule:
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    async def search(
+        self,
+        site_id: str,
+        q: Optional[str] = None,
+        category: Optional[str] = None,
+        min_price: Optional[float] = None,
+        max_price: Optional[float] = None,
+        in_stock: Optional[bool] = None,
+        page: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> dict:
+        params: dict = {}
+        if q is not None:
+            params["q"] = q
+        if category is not None:
+            params["category"] = category
+        if min_price is not None:
+            params["min_price"] = min_price
+        if max_price is not None:
+            params["max_price"] = max_price
+        if in_stock is not None:
+            params["in_stock"] = in_stock
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+
+        raw = await self._http.get(f"/v1/sites/{site_id}/products", params or None)
+        response = PaginatedProductResponse.model_validate(raw)
+        pg = response.pagination
+        total_pages = (pg.total + pg.limit - 1) // pg.limit if pg.limit > 0 else 1
+        return {
+            "products": [p.model_dump() for p in response.data],
+            "total": pg.total,
+            "page": pg.page,
+            "total_pages": total_pages,
+        }
+
+    async def get_by_id(self, site_id: str, product_id: str) -> AMPSProduct:
+        raw = await self._http.get(f"/v1/sites/{site_id}/products/{product_id}")
+        return AMPSProduct.model_validate(raw)
+
+    async def compare(
+        self,
+        site_ids: List[str],
+        query: str,
+        min_price: Optional[float] = None,
+        max_price: Optional[float] = None,
+        in_stock: Optional[bool] = None,
+    ) -> dict:
+        body: dict = {"query": query, "site_ids": site_ids}
+        filters: dict = {}
+        if min_price is not None:
+            filters["min_price"] = min_price
+        if max_price is not None:
+            filters["max_price"] = max_price
+        if in_stock is not None:
+            filters["in_stock"] = in_stock
+        if filters:
+            body["filters"] = filters
+
+        return await self._http.post("/v1/multi/products/compare", body)

agentmesh/tools/__init__.py

@@ -0,0 +1,6 @@
+from .anthropic import anthropic_tools
+from .executor import ToolExecutor
+from .langchain import langchain_tools
+from .openai import openai_tools
+
+__all__ = ["anthropic_tools", "openai_tools", "langchain_tools", "ToolExecutor"]