agledger 0.1.0__tar.gz

agledger-0.1.0/.gitignore

@@ -0,0 +1,26 @@
+node_modules/
+dist/
+.turbo/
+*.tsbuildinfo
+coverage/
+.DS_Store
+*.log
+.env
+.env.*
+*.db
+*.sqlite
+*.tgz
+.vscode/
+.idea/
+.claude/
+CLAUDE.md
+agledger-sdk/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+.venv/
+.pytest_cache/
+dist/

agledger-0.1.0/LICENSE

@@ -0,0 +1,34 @@
+Copyright (c) 2026 AGLedger LLC. All rights reserved.
+
+PROPRIETARY SOFTWARE LICENSE
+
+This software and associated documentation files (the "Software") are the
+proprietary property of AGLedger LLC. The Software is provided for use
+exclusively with the AGLedger API (https://api.agledger.ai).
+
+Permission is hereby granted to use the Software solely for the purpose of
+integrating with AGLedger services via the AGLedger API, subject to the
+following conditions:
+
+1. You may not copy, modify, merge, publish, distribute, sublicense, or sell
+   copies of the Software, except as required to use it with the AGLedger API.
+
+2. You may not use the Software to create a competing product or service.
+
+3. You may not reverse engineer, decompile, or disassemble the Software,
+   except to the extent permitted by applicable law.
+
+Use of this SDK is subject to the AGLedger Terms of Service at
+https://agledger.ai/terms.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+AGLEDGER LLC BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+AGLedger™ and the Agentic Contract Specification™ are trademarks of
+AGLedger LLC. Patent pending.

agledger-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: agledger
+Version: 0.1.0
+Summary: AGLedger SDK — Accountability and audit infrastructure for agentic systems.
+Author-email: AGLedger LLC <support@agledger.ai>
+License-Expression: LicenseRef-Proprietary
+License-File: LICENSE
+Keywords: accountability,agents,agledger,audit,mandates
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.25.0
+Requires-Dist: pydantic<3,>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.22; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AGLedger Python SDK
+
+Accountability and audit infrastructure for agentic systems.
+
+```python
+from agledger import AgledgerClient
+
+client = AgledgerClient(api_key="ach_ent_...")
+mandate = client.mandates.create(
+    enterpriseId="ent_123",
+    contractType="ACH-PROC-v1",
+    contractVersion="1",
+    platform="internal",
+    criteria={"item": "widgets", "maxQuantity": 100},
+)
+```
+
+See [agledger.ai](https://agledger.ai) for documentation.

agledger-0.1.0/README.md

@@ -0,0 +1,18 @@
+# AGLedger Python SDK
+
+Accountability and audit infrastructure for agentic systems.
+
+```python
+from agledger import AgledgerClient
+
+client = AgledgerClient(api_key="ach_ent_...")
+mandate = client.mandates.create(
+    enterpriseId="ent_123",
+    contractType="ACH-PROC-v1",
+    contractVersion="1",
+    platform="internal",
+    criteria={"item": "widgets", "maxQuantity": 100},
+)
+```
+
+See [agledger.ai](https://agledger.ai) for documentation.

agledger-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agledger"
+version = "0.1.0"
+description = "AGLedger SDK — Accountability and audit infrastructure for agentic systems."
+readme = "README.md"
+license = "LicenseRef-Proprietary"
+requires-python = ">=3.9"
+authors = [{ name = "AGLedger LLC", email = "support@agledger.ai" }]
+keywords = ["agledger", "mandates", "accountability", "agents", "audit"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.25.0,<1",
+    "pydantic>=2.0.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "respx>=0.22",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agledger"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.pyright]
+typeCheckingMode = "strict"

agledger-0.1.0/src/agledger/__init__.py

@@ -0,0 +1,100 @@
+"""
+AGLedger SDK — Accountability and audit infrastructure for agentic systems.
+
+Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+"""
+
+from agledger._client import AgledgerClient, AsyncAgledgerClient
+from agledger._errors import (
+    AgledgerError,
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthenticationError,
+    BadRequestError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    UnprocessableError,
+)
+from agledger.scopes import (
+    SCOPE_PROFILES,
+    ScopeProfile,
+    ScopeProfileName,
+    Scopes,
+)
+from agledger.types import (
+    AccountProfile,
+    AuditChain,
+    AuditStreamResult,
+    ComplianceRecord,
+    ContractType,
+    DashboardSummary,
+    Dispute,
+    DisputeStatus,
+    EnterpriseAgentRecord,
+    Event,
+    HealthResponse,
+    Mandate,
+    MandateStatus,
+    MandateStatusSummary,
+    MandateTransitionAction,
+    OperatingMode,
+    OutcomeResult,
+    Page,
+    Receipt,
+    RegisterResult,
+    ReputationScore,
+    VerificationMode,
+    VerificationResult,
+    Webhook,
+    WebhookEventType,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "AgledgerClient",
+    "AsyncAgledgerClient",
+    # Errors
+    "AgledgerError",
+    "APIError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "BadRequestError",
+    "UnprocessableError",
+    "RateLimitError",
+    "APIConnectionError",
+    "APITimeoutError",
+    # Scopes
+    "Scopes",
+    "ScopeProfile",
+    "SCOPE_PROFILES",
+    "ScopeProfileName",
+    # Types
+    "Mandate",
+    "MandateStatus",
+    "MandateTransitionAction",
+    "Receipt",
+    "ContractType",
+    "OperatingMode",
+    "VerificationMode",
+    "VerificationResult",
+    "Dispute",
+    "DisputeStatus",
+    "Webhook",
+    "WebhookEventType",
+    "ReputationScore",
+    "Event",
+    "AuditChain",
+    "DashboardSummary",
+    "AccountProfile",
+    "RegisterResult",
+    "EnterpriseAgentRecord",
+    "HealthResponse",
+    "Page",
+    "OutcomeResult",
+    "MandateStatusSummary",
+    "ComplianceRecord",
+    "AuditStreamResult",
+]

agledger-0.1.0/src/agledger/_client.py

@@ -0,0 +1,179 @@
+"""
+AGLedger SDK — Client with 18 resource sub-clients.
+Supports context manager protocol for proper connection cleanup.
+"""
+
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Optional
+
+import httpx
+
+from agledger._http import (
+    AsyncHttpClient,
+    HttpClient,
+    DEFAULT_BASE_URL,
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_TIMEOUT,
+    _resolve_api_key,
+)
+from agledger.resources.a2a import A2AResource, AsyncA2AResource
+from agledger.resources.admin import AdminResource, AsyncAdminResource
+from agledger.resources.capabilities import AsyncCapabilitiesResource, CapabilitiesResource
+from agledger.resources.compliance import AsyncComplianceResource, ComplianceResource
+from agledger.resources.dashboard import AsyncDashboardResource, DashboardResource
+from agledger.resources.disputes import AsyncDisputesResource, DisputesResource
+from agledger.resources.enterprises import AsyncEnterprisesResource, EnterprisesResource
+from agledger.resources.events import AsyncEventsResource, EventsResource
+from agledger.resources.health import AsyncHealthResource, HealthResource
+from agledger.resources.mandates import AsyncMandatesResource, MandatesResource
+from agledger.resources.notarize import AsyncNotarizeResource, NotarizeResource
+from agledger.resources.projects import AsyncProjectsResource, ProjectsResource
+from agledger.resources.proxy import AsyncProxyResource, ProxyResource
+from agledger.resources.receipts import AsyncReceiptsResource, ReceiptsResource
+from agledger.resources.registration import AsyncRegistrationResource, RegistrationResource
+from agledger.resources.reputation import AsyncReputationResource, ReputationResource
+from agledger.resources.schemas import AsyncSchemasResource, SchemasResource
+from agledger.resources.verification import AsyncVerificationResource, VerificationResource
+from agledger.resources.webhooks import AsyncWebhooksResource, WebhooksResource
+
+
+class AgledgerClient:
+    """
+    Synchronous AGLedger API client with 18 resource sub-clients.
+
+    Supports context manager for automatic connection cleanup::
+
+        with AgledgerClient(api_key="ach_ent_...") as client:
+            mandate = client.mandates.create(
+                enterprise_id="ent_123",
+                contract_type="ACH-PROC-v1",
+                contract_version="1",
+                platform="internal",
+                criteria={"item": "widgets"},
+            )
+
+    Or pass ``AGLEDGER_API_KEY`` env var::
+
+        client = AgledgerClient()  # reads from env
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+        idempotency_key_prefix: str = "",
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        resolved_key = _resolve_api_key(api_key)
+        self._http = HttpClient(
+            api_key=resolved_key,
+            base_url=base_url,
+            max_retries=max_retries,
+            timeout=timeout,
+            idempotency_key_prefix=idempotency_key_prefix,
+            http_client=http_client,
+        )
+        self.mandates = MandatesResource(self._http)
+        self.receipts = ReceiptsResource(self._http)
+        self.verification = VerificationResource(self._http)
+        self.disputes = DisputesResource(self._http)
+        self.webhooks = WebhooksResource(self._http)
+        self.reputation = ReputationResource(self._http)
+        self.events = EventsResource(self._http)
+        self.schemas = SchemasResource(self._http)
+        self.dashboard = DashboardResource(self._http)
+        self.compliance = ComplianceResource(self._http)
+        self.registration = RegistrationResource(self._http)
+        self.health = HealthResource(self._http)
+        self.admin = AdminResource(self._http)
+        self.a2a = A2AResource(self._http)
+        self.capabilities = CapabilitiesResource(self._http)
+        self.notarize = NotarizeResource(self._http)
+        self.enterprises = EnterprisesResource(self._http)
+        self.proxy = ProxyResource(self._http)
+        self.projects = ProjectsResource(self._http)
+
+    @property
+    def last_request_id(self) -> str | None:
+        """Request ID from the most recent API response (``X-Request-Id`` header)."""
+        return self._http.last_request_id
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._http.close()
+
+    def __enter__(self) -> AgledgerClient:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None) -> None:
+        self.close()
+
+
+class AsyncAgledgerClient:
+    """
+    Async AGLedger API client with 18 resource sub-clients.
+
+    Supports async context manager::
+
+        async with AsyncAgledgerClient(api_key="ach_ent_...") as client:
+            mandate = await client.mandates.get("mnd-123")
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+        idempotency_key_prefix: str = "",
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        resolved_key = _resolve_api_key(api_key)
+        self._http = AsyncHttpClient(
+            api_key=resolved_key,
+            base_url=base_url,
+            max_retries=max_retries,
+            timeout=timeout,
+            idempotency_key_prefix=idempotency_key_prefix,
+            http_client=http_client,
+        )
+        self.mandates = AsyncMandatesResource(self._http)
+        self.receipts = AsyncReceiptsResource(self._http)
+        self.verification = AsyncVerificationResource(self._http)
+        self.disputes = AsyncDisputesResource(self._http)
+        self.webhooks = AsyncWebhooksResource(self._http)
+        self.reputation = AsyncReputationResource(self._http)
+        self.events = AsyncEventsResource(self._http)
+        self.schemas = AsyncSchemasResource(self._http)
+        self.dashboard = AsyncDashboardResource(self._http)
+        self.compliance = AsyncComplianceResource(self._http)
+        self.registration = AsyncRegistrationResource(self._http)
+        self.health = AsyncHealthResource(self._http)
+        self.admin = AsyncAdminResource(self._http)
+        self.a2a = AsyncA2AResource(self._http)
+        self.capabilities = AsyncCapabilitiesResource(self._http)
+        self.notarize = AsyncNotarizeResource(self._http)
+        self.enterprises = AsyncEnterprisesResource(self._http)
+        self.proxy = AsyncProxyResource(self._http)
+        self.projects = AsyncProjectsResource(self._http)
+
+    @property
+    def last_request_id(self) -> str | None:
+        """Request ID from the most recent API response (``X-Request-Id`` header)."""
+        return self._http.last_request_id
+
+    async def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        await self._http.close()
+
+    async def __aenter__(self) -> AsyncAgledgerClient:
+        return self
+
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None) -> None:
+        await self.close()

agledger-0.1.0/src/agledger/_errors.py

@@ -0,0 +1,153 @@
+"""
+AGLedger SDK — Error classes.
+Follows Anthropic/OpenAI naming conventions. Never shadows Python builtins.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class AgledgerError(Exception):
+    """Base error for all SDK errors."""
+
+    pass
+
+
+class APIError(AgledgerError):
+    """API returned an error response.
+
+    Key properties for agent consumers:
+
+    - ``status`` — HTTP status code
+    - ``code`` — stable machine-readable error code
+    - ``suggestion`` — agent-friendly recovery hint
+    - ``retryable`` — whether this error can be retried
+    - ``doc_url`` — link to error documentation
+    """
+
+    status: int
+    code: str
+    request_id: Optional[str]
+    details: Optional[Any]
+    retryable: bool
+    doc_url: str
+    suggestion: Optional[str]
+
+    __slots__ = ("status", "code", "request_id", "details", "retryable", "doc_url", "suggestion")
+
+    _DEFAULT_SUGGESTIONS: dict[int, str] = {
+        401: "Check your API key. Set AGLEDGER_API_KEY or pass api_key to the client constructor.",
+        403: "Check API key scopes. See error.missing_scopes for required scopes, or use a broader scope profile.",
+        404: "The resource was not found. Verify the ID is correct, or list resources to find valid IDs.",
+        409: "A conflicting operation is in progress. Wait and retry, or check the current resource state.",
+        422: "The resource is in the wrong state for this operation. Check the current status before retrying.",
+        429: "Rate limit exceeded. The SDK retries automatically — if you see this, increase max_retries or add backoff.",
+    }
+
+    def __init__(
+        self,
+        status: int,
+        *,
+        message: str = "",
+        code: str = "unknown",
+        request_id: Optional[str] = None,
+        details: Optional[Any] = None,
+        retryable: Optional[bool] = None,
+        suggestion: Optional[str] = None,
+    ) -> None:
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.details = details
+        self.retryable = retryable if retryable is not None else (status == 429 or status >= 500)
+        self.doc_url = f"https://docs.agledger.ai/errors/{self.code}"
+        self.suggestion = suggestion or self._DEFAULT_SUGGESTIONS.get(status)
+        super().__init__(message or f"API error {status}")
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(status={self.status}, code={self.code!r}, message={str(self)!r})"
+
+    def is_retryable(self) -> bool:
+        """Whether this error can be retried (429, 5xx, network errors)."""
+        return self.retryable
+
+    def is_input_error(self) -> bool:
+        """Whether this is a 400 validation error — fix the request and retry."""
+        return self.status == 400
+
+    def is_state_error(self) -> bool:
+        """Whether this is a 422 state error — resource is in the wrong state."""
+        return self.status == 422
+
+    def is_auth_error(self) -> bool:
+        """Whether this is an auth error (401/403)."""
+        return self.status in (401, 403)
+
+
+class AuthenticationError(APIError):
+    """401 — invalid or missing API key."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(401, **kwargs)
+
+
+class PermissionDeniedError(APIError):
+    """403 — insufficient scopes or permissions."""
+
+    missing_scopes: list[str]
+    key_scopes: Optional[list[str]]
+
+    def __init__(
+        self,
+        *,
+        missing_scopes: Optional[list[str]] = None,
+        key_scopes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.missing_scopes = missing_scopes or []
+        self.key_scopes = key_scopes
+        super().__init__(403, **kwargs)
+
+
+class NotFoundError(APIError):
+    """404 — resource not found."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(404, **kwargs)
+
+
+class BadRequestError(APIError):
+    """400 — request validation failed."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(400, **kwargs)
+
+
+class UnprocessableError(APIError):
+    """422 — resource in wrong state for the requested operation."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(422, **kwargs)
+
+
+class RateLimitError(APIError):
+    """429 — rate limit exceeded."""
+
+    retry_after: Optional[float]
+
+    def __init__(self, *, retry_after: Optional[float] = None, **kwargs: Any) -> None:
+        self.retry_after = retry_after
+        super().__init__(429, **kwargs)
+
+
+class APIConnectionError(AgledgerError):
+    """Network connectivity error."""
+
+    pass
+
+
+class APITimeoutError(APIConnectionError):
+    """Request timed out."""
+
+    pass