langchain-aotrust 0.1.0__tar.gz

langchain_aotrust-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A&O Trust Layer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

langchain_aotrust-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: langchain-aotrust
+Version: 0.1.0
+Summary: LangChain tools for AOTrust notarization — cryptographic proof-of-existence for AI agent outputs (x402, NEAR-anchored PDRs)
+Author: A&O Trust Layer
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: aotrust-protocol>=2.3.6
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# langchain-aotrust
+
+<!-- mcp-name: link.aotrust/notary -->
+
+LangChain tools for **AOTrust** notarization — cryptographic
+proof-of-existence for AI agent outputs. Free tier (no wallet required),
+PDRs signed with Ed25519, Merkle-included and anchored on NEAR.
+
+Works with any agent built on `langchain-core` (LangChain, LangGraph,
+CrewAI via the standard BaseTool interface, pydantic-ai adapters).
+
+## Install
+
+```bash
+pip install langchain-aotrust
+```
+
+## Quickstart
+
+```python
+from langchain_aotrust import (
+    aotrust_notarize_free,
+    aotrust_verify,
+    aotrust_status,
+)
+
+# 1. Notarize an artifact (free tier — no API key, no wallet)
+print(aotrust_notarize_free.invoke({"artifact_text": "analysis v3: portfolio risk moderate"}))
+# Notarized (tier=free). shield_id=9f2c... job_id=7a1b... work_hash=...
+# Verify later at https://verify.aotrust.link or with aotrust_verify(job_id).
+
+# 2. Check pipeline status
+print(aotrust_status.invoke({"job_id": "<job_id>"}))
+# Status for job_id=7a1b...: status=anchored, anchored=yes, payment_hash=...
+
+# 3. Full cryptographic verification
+print(aotrust_verify.invoke({"job_id": "<job_id>"}))
+# Verification for job_id=7a1b...: valid=True, payment_anchor_type=0, ...
+```
+
+Wiring into a LangChain agent:
+
+```python
+from langchain_aotrust import aotrust_notarize_free, aotrust_verify
+from langchain.agents import create_tool_calling_agent  # any agent works
+
+tools = [aotrust_notarize_free, aotrust_verify, aotrust_status]
+```
+
+Async agents (LangGraph) can await the plain functions directly:
+
+```python
+from langchain_aotrust import aotrust_notarize_free_async
+result = await aotrust_notarize_free_async(artifact_text="...")
+```
+
+Configuration (optional — defaults to the public endpoint):
+
+```python
+from langchain_aotrust import configure
+configure(base_url="https://api.aotrust.link")  # NO /v1 suffix — the SDK appends paths
+```
+
+## What the proofs mean
+
+| Horizon | Guarantee |
+|---|---|
+| **Instant** | SHA-256 work_hash bound into a signed PDR (Ed25519, notary key) — tamper-evident from notarization time |
+| **Python** | PDR bytes verifiable offline by anyone with the notary public key |
+| **Forever** | Daily Merkle root anchored on NEAR blockchain — proof survives even if the service disappears |
+
+## Free tier
+
+- No API key, no wallet, no payment.
+- Rate limited per IP (5 notarizations / 24h) — paid x402 tier ($0.01) in a
+  future release for higher throughput.
+
+## Links
+
+- Docs: https://docs.aotrust.link
+- Live verifier: https://verify.aotrust.link
+- SDK: https://pypi.org/project/aotrust-protocol/
+
+## License
+
+MIT

langchain_aotrust-0.1.0/README.md

@@ -0,0 +1,86 @@
+# langchain-aotrust
+
+<!-- mcp-name: link.aotrust/notary -->
+
+LangChain tools for **AOTrust** notarization — cryptographic
+proof-of-existence for AI agent outputs. Free tier (no wallet required),
+PDRs signed with Ed25519, Merkle-included and anchored on NEAR.
+
+Works with any agent built on `langchain-core` (LangChain, LangGraph,
+CrewAI via the standard BaseTool interface, pydantic-ai adapters).
+
+## Install
+
+```bash
+pip install langchain-aotrust
+```
+
+## Quickstart
+
+```python
+from langchain_aotrust import (
+    aotrust_notarize_free,
+    aotrust_verify,
+    aotrust_status,
+)
+
+# 1. Notarize an artifact (free tier — no API key, no wallet)
+print(aotrust_notarize_free.invoke({"artifact_text": "analysis v3: portfolio risk moderate"}))
+# Notarized (tier=free). shield_id=9f2c... job_id=7a1b... work_hash=...
+# Verify later at https://verify.aotrust.link or with aotrust_verify(job_id).
+
+# 2. Check pipeline status
+print(aotrust_status.invoke({"job_id": "<job_id>"}))
+# Status for job_id=7a1b...: status=anchored, anchored=yes, payment_hash=...
+
+# 3. Full cryptographic verification
+print(aotrust_verify.invoke({"job_id": "<job_id>"}))
+# Verification for job_id=7a1b...: valid=True, payment_anchor_type=0, ...
+```
+
+Wiring into a LangChain agent:
+
+```python
+from langchain_aotrust import aotrust_notarize_free, aotrust_verify
+from langchain.agents import create_tool_calling_agent  # any agent works
+
+tools = [aotrust_notarize_free, aotrust_verify, aotrust_status]
+```
+
+Async agents (LangGraph) can await the plain functions directly:
+
+```python
+from langchain_aotrust import aotrust_notarize_free_async
+result = await aotrust_notarize_free_async(artifact_text="...")
+```
+
+Configuration (optional — defaults to the public endpoint):
+
+```python
+from langchain_aotrust import configure
+configure(base_url="https://api.aotrust.link")  # NO /v1 suffix — the SDK appends paths
+```
+
+## What the proofs mean
+
+| Horizon | Guarantee |
+|---|---|
+| **Instant** | SHA-256 work_hash bound into a signed PDR (Ed25519, notary key) — tamper-evident from notarization time |
+| **Python** | PDR bytes verifiable offline by anyone with the notary public key |
+| **Forever** | Daily Merkle root anchored on NEAR blockchain — proof survives even if the service disappears |
+
+## Free tier
+
+- No API key, no wallet, no payment.
+- Rate limited per IP (5 notarizations / 24h) — paid x402 tier ($0.01) in a
+  future release for higher throughput.
+
+## Links
+
+- Docs: https://docs.aotrust.link
+- Live verifier: https://verify.aotrust.link
+- SDK: https://pypi.org/project/aotrust-protocol/
+
+## License
+
+MIT

langchain_aotrust-0.1.0/langchain_aotrust/__init__.py

@@ -0,0 +1,33 @@
+"""langchain-aotrust — LangChain tools for AOTrust notarization.
+
+Cryptographic proof-of-existence for AI agent outputs: free-tier notarization
+(SHA-256 work_hash -> PDR, NEAR-anchored) and public verification, exposed
+as LangChain BaseTool instances compatible with any agent built on
+langchain-core (LangChain, LangGraph, CrewAI, pydantic-ai via the standard
+BaseTool interface).
+"""
+
+__version__ = "0.1.0"
+
+from ._client import get_client, configure, reset_client
+from .tools import (
+    aotrust_notarize_free,
+    aotrust_verify,
+    aotrust_status,
+    aotrust_notarize_free_async,
+    aotrust_verify_async,
+    aotrust_status_async,
+)
+
+__all__ = [
+    "__version__",
+    "get_client",
+    "configure",
+    "reset_client",
+    "aotrust_notarize_free",
+    "aotrust_verify",
+    "aotrust_status",
+    "aotrust_notarize_free_async",
+    "aotrust_verify_async",
+    "aotrust_status_async",
+]

langchain_aotrust-0.1.0/langchain_aotrust/_client.py

@@ -0,0 +1,61 @@
+"""Client singleton + sync/async bridge for langchain-aotrust.
+
+URL contract: the AOTrust NotaryClient assembles full endpoint paths itself
+(``/v1/shield/free``, ``/v1/status/{job_id}``, ...) — the ``base_url`` must
+NEVER include a trailing ``/v1`` segment. Passing ``https://api.aotrust.link/v1``
+would produce double-prefixed ``/v1/v1/...`` requests (the bug recorded in
+examples/langchain_tool.py of aotrust-protocol).
+"""
+import asyncio
+import concurrent.futures
+from typing import Optional
+
+from agent_notary import NotaryClient
+
+DEFAULT_BASE_URL = "https://api.aotrust.link"
+
+_client: Optional[NotaryClient] = None
+
+
+def get_client() -> NotaryClient:
+    """Lazy singleton of the async NotaryClient (aotrust-protocol)."""
+    global _client
+    if _client is None:
+        # base_url default https://api.aotrust.link — WITHOUT a /v1 suffix
+        _client = NotaryClient(base_url="https://api.aotrust.link")
+    return _client
+
+
+def configure(base_url: Optional[str] = None, api_key: Optional[str] = None) -> None:
+    """Replace the singleton (call before first use, or use reset_client()).
+
+    Args:
+        base_url: API origin WITHOUT the /v1 path segment (e.g.
+            https://api.aotrust.link or a testnet mirror).
+        api_key: optional key for authenticated endpoints (quote channel).
+    """
+    global _client
+    _client = NotaryClient(api_key=api_key, base_url=base_url)
+
+
+def reset_client() -> None:
+    """Drop the singleton (next get_client() re-creates it). Mainly for tests."""
+    global _client
+    _client = None
+
+
+def run_async(coro):
+    """Run a coroutine from sync code, safe inside a running event loop.
+
+    LangChain agents invoke tools synchronously by default, but agents can
+    also be driven from within an async application (LangGraph, Jupyter
+    kernels). Plain ``asyncio.run()`` raises ``RuntimeError`` when a loop is
+    already running, so this bridge detects a running loop and executes the
+    coroutine on a dedicated worker thread with its own fresh loop.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(asyncio.run, coro).result()

langchain_aotrust-0.1.0/langchain_aotrust/tools.py

@@ -0,0 +1,115 @@
+"""LangChain tools wrapping the AOTrust notary API.
+
+Every tool docstring doubles as the LLM-facing tool description — keep it
+actionable for agents: what it does, what it returns, when to use it.
+
+All sync tools bridge into the SDK's asyncio-native client via
+``langchain_aotrust._client.run_async`` (safe inside a running event loop —
+a dedicated worker-thread loop is used there; see _client.run_async).
+"""
+import hashlib
+from typing import Optional
+
+from langchain_core.tools import tool
+
+from ._client import get_client, run_async
+
+
+@tool
+def aotrust_notarize_free(artifact_text: str) -> str:
+    """Notarize an AI artifact on AOTrust (free tier, no wallet required).
+
+    Computes the SHA-256 work_hash of the artifact text and registers a
+    free UNPAID PDR (proof-of-existence record, NEAR-anchored, Ed25519
+    signed). Use this whenever an agent's output must be provably
+    timestamped and tamper-evident. Returns a human-readable confirmation
+    with the shield_id and job_id to verify later at
+    https://verify.aotrust.link. Rate limited per IP (free tier)."""
+    import hashlib
+
+    work_hash = hashlib.sha256(artifact_text.encode("utf-8")).hexdigest()
+    res = run_async(get_client().shield_free(work_hash))
+    shield_id = res.get("shield_id", "n/a")
+    job_id = res.get("job_id", "n/a")
+    tier = res.get("tier", "free")
+    return (
+        f"Notarized (tier={tier}). shield_id={shield_id} job_id={job_id} "
+        f"work_hash={work_hash} "
+        f"Verify later at https://verify.aotrust.link or with aotrust_verify(job_id)."
+    )
+
+
+@tool
+def aotrust_verify(job_id: str) -> str:
+    """Verify a previously notarized artifact on AOTrust by job_id.
+
+    Fetches the PDR for the given job_id and runs full cryptographic
+    verification (Ed25519 signature, Merkle inclusion, NEAR anchoring).
+    Returns validity (true/false), the payment_anchor_type and whether the
+    record is anchored on-chain. Use after aotrust_notarize_free or when a
+    user supplies a job_id to prove a record exists."""
+    pdr = run_async(get_client().get_pdr(job_id))
+    v = run_async(get_client().verify_pdr(pdr.pdr_b64))
+    valid = v.get("valid")
+    if valid is None:
+        valid = v.get("tx_verified_on_chain") is not None and v.get("sig_valid", False)
+    pat = v.get("payment_anchor_type") or pdr.payment_anchor_type
+    return (
+        f"Verification for job_id={job_id}: valid={valid}, "
+        f"payment_anchor_type={pat}, anchored status fetched, "
+        f"verify_url={pdr.verify_url or 'https://verify.aotrust.link'}"
+    )
+
+
+@tool
+def aotrust_status(job_id: str) -> str:
+    """Check the notarization status of a job_id on AOTrust.
+
+    Returns the current pipeline status (queued/anchored/etc.), whether the
+    record is already anchored on NEAR, and the anchoring timestamp when
+    available. Cheaper than aotrust_verify — use it to poll progress."""
+    st = run_async(get_client().get_status(job_id))
+    anchored = "yes" if st.is_anchored else "no"
+    ts = getattr(st, "payment_hash", None) or ""
+    return f"Status for job_id={job_id}: status={st.status}, anchored={anchored}, payment_hash={ts}"
+
+
+# ── plain async variants (NOT @tool) — for LangGraph async agents ──────────
+
+async def aotrust_notarize_free_async(artifact_text: str) -> str:
+    """Async counterpart of aotrust_notarize_free (await directly in async agents)."""
+    import hashlib
+
+    work_hash = hashlib.sha256(artifact_text.encode("utf-8")).hexdigest()
+    res = await get_client().shield_free(work_hash)
+    shield_id = res.get("shield_id", "n/a")
+    job_id = res.get("job_id", "n/a")
+    tier = res.get("tier", "free")
+    return (
+        f"Notarized (tier={tier}). shield_id={shield_id} job_id={job_id} "
+        f"work_hash={work_hash} "
+        f"Verify later at https://verify.aotrust.link or with aotrust_verify(job_id)."
+    )
+
+
+async def aotrust_verify_async(job_id: str) -> str:
+    """Async counterpart of aotrust_verify (await directly in async agents)."""
+    pdr = await get_client().get_pdr(job_id)
+    v = await get_client().verify_pdr(pdr.pdr_b64)
+    valid = v.get("valid")
+    if valid is None:
+        valid = v.get("tx_verified_on_chain") is not None and v.get("sig_valid", False)
+    pat = v.get("payment_anchor_type") or pdr.payment_anchor_type
+    return (
+        f"Verification for job_id={job_id}: valid={valid}, "
+        f"payment_anchor_type={pat}, anchored status fetched, "
+        f"verify_url={pdr.verify_url or 'https://verify.aotrust.link'}"
+    )
+
+
+async def aotrust_status_async(job_id: str) -> str:
+    """Async counterpart of aotrust_status (await directly in async agents)."""
+    st = await get_client().get_status(job_id)
+    anchored = "yes" if st.is_anchored else "no"
+    ts = getattr(st, "payment_hash", None) or ""
+    return f"Status for job_id={job_id}: status={st.status}, anchored={anchored}, payment_hash={ts}"

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

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: langchain-aotrust
+Version: 0.1.0
+Summary: LangChain tools for AOTrust notarization — cryptographic proof-of-existence for AI agent outputs (x402, NEAR-anchored PDRs)
+Author: A&O Trust Layer
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: aotrust-protocol>=2.3.6
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# langchain-aotrust
+
+<!-- mcp-name: link.aotrust/notary -->
+
+LangChain tools for **AOTrust** notarization — cryptographic
+proof-of-existence for AI agent outputs. Free tier (no wallet required),
+PDRs signed with Ed25519, Merkle-included and anchored on NEAR.
+
+Works with any agent built on `langchain-core` (LangChain, LangGraph,
+CrewAI via the standard BaseTool interface, pydantic-ai adapters).
+
+## Install
+
+```bash
+pip install langchain-aotrust
+```
+
+## Quickstart
+
+```python
+from langchain_aotrust import (
+    aotrust_notarize_free,
+    aotrust_verify,
+    aotrust_status,
+)
+
+# 1. Notarize an artifact (free tier — no API key, no wallet)
+print(aotrust_notarize_free.invoke({"artifact_text": "analysis v3: portfolio risk moderate"}))
+# Notarized (tier=free). shield_id=9f2c... job_id=7a1b... work_hash=...
+# Verify later at https://verify.aotrust.link or with aotrust_verify(job_id).
+
+# 2. Check pipeline status
+print(aotrust_status.invoke({"job_id": "<job_id>"}))
+# Status for job_id=7a1b...: status=anchored, anchored=yes, payment_hash=...
+
+# 3. Full cryptographic verification
+print(aotrust_verify.invoke({"job_id": "<job_id>"}))
+# Verification for job_id=7a1b...: valid=True, payment_anchor_type=0, ...
+```
+
+Wiring into a LangChain agent:
+
+```python
+from langchain_aotrust import aotrust_notarize_free, aotrust_verify
+from langchain.agents import create_tool_calling_agent  # any agent works
+
+tools = [aotrust_notarize_free, aotrust_verify, aotrust_status]
+```
+
+Async agents (LangGraph) can await the plain functions directly:
+
+```python
+from langchain_aotrust import aotrust_notarize_free_async
+result = await aotrust_notarize_free_async(artifact_text="...")
+```
+
+Configuration (optional — defaults to the public endpoint):
+
+```python
+from langchain_aotrust import configure
+configure(base_url="https://api.aotrust.link")  # NO /v1 suffix — the SDK appends paths
+```
+
+## What the proofs mean
+
+| Horizon | Guarantee |
+|---|---|
+| **Instant** | SHA-256 work_hash bound into a signed PDR (Ed25519, notary key) — tamper-evident from notarization time |
+| **Python** | PDR bytes verifiable offline by anyone with the notary public key |
+| **Forever** | Daily Merkle root anchored on NEAR blockchain — proof survives even if the service disappears |
+
+## Free tier
+
+- No API key, no wallet, no payment.
+- Rate limited per IP (5 notarizations / 24h) — paid x402 tier ($0.01) in a
+  future release for higher throughput.
+
+## Links
+
+- Docs: https://docs.aotrust.link
+- Live verifier: https://verify.aotrust.link
+- SDK: https://pypi.org/project/aotrust-protocol/
+
+## License
+
+MIT

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

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_aotrust/__init__.py
+langchain_aotrust/_client.py
+langchain_aotrust/tools.py
+langchain_aotrust.egg-info/PKG-INFO
+langchain_aotrust.egg-info/SOURCES.txt
+langchain_aotrust.egg-info/dependency_links.txt
+langchain_aotrust.egg-info/requires.txt
+langchain_aotrust.egg-info/top_level.txt
+tests/test_live.py
+tests/test_tools.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,7 @@
+langchain-core>=1.0
+aotrust-protocol>=2.3.6
+aiohttp>=3.9
+
+[dev]
+pytest
+pytest-asyncio

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

@@ -0,0 +1 @@
+langchain_aotrust

langchain_aotrust-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-aotrust"
+version = "0.1.0"
+description = "LangChain tools for AOTrust notarization — cryptographic proof-of-existence for AI agent outputs (x402, NEAR-anchored PDRs)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "A&O Trust Layer"}]
+dependencies = [
+    "langchain-core>=1.0",
+    "aotrust-protocol>=2.3.6",
+    "aiohttp>=3.9",
+]
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio"]
+
+[tool.pytest.ini_options]
+addopts = "-m 'not live'"
+markers = ["live: touches live API"]
+
+[tool.setuptools.packages.find]
+include = ["langchain_aotrust*"]

langchain_aotrust-0.1.0/setup.cfg

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

langchain_aotrust-0.1.0/tests/test_live.py

@@ -0,0 +1,45 @@
+"""test_live.py — live smoke against https://api.aotrust.link.
+
+Excluded from the default run (pyproject addopts -m 'not live').
+Run explicitly: pytest -m live
+"""
+import hashlib
+import os
+
+import pytest
+
+from langchain_aotrust import (
+    aotrust_notarize_free,
+    aotrust_status,
+)
+import langchain_aotrust._client as client_mod
+
+
+@pytest.mark.live
+def test_live_notarize_free_roundtrip():
+    fake = client_mod._client
+    try:
+        client_mod._client = None  # force the real singleton
+        artifact = f"langchain-aotrust live smoke {os.urandom(4).hex()}"
+        out = aotrust_notarize_free.invoke({"artifact_text": artifact})
+        assert "shield_id=" in out
+        assert "job_id=" in out
+        # extract job_id and check status
+        job_id = out.split("job_id=")[1].split(" ")[0].strip()
+        status_out = aotrust_status.invoke({"job_id": job_id})
+        assert "status=" in status_out
+    finally:
+        client_mod._client = fake
+
+
+@pytest.mark.live
+def test_live_free_tier_shape():
+    import asyncio
+    from langchain_aotrust import get_client
+
+    work_hash = hashlib.sha256(b"langchain-aotrust live shape probe").hexdigest()
+    res = asyncio.run(get_client().shield_free(work_hash))
+    assert isinstance(res, dict)
+    assert "shield_id" in res
+    assert "job_id" in res
+    assert res.get("tier") in ("free", None)

langchain_aotrust-0.1.0/tests/test_tools.py

@@ -0,0 +1,160 @@
+"""test_tools.py — mock-based tests, NO network."""
+import hashlib
+import asyncio
+import unittest
+from unittest.mock import patch
+
+from langchain_aotrust import (
+    aotrust_notarize_free,
+    aotrust_verify,
+    aotrust_status,
+    aotrust_notarize_free_async,
+    aotrust_verify_async,
+    aotrust_status_async,
+)
+import langchain_aotrust._client as client_mod
+
+
+class _FakeClient:
+    """Stands in for aotrust_protocol.NotaryClient — records base_url, no network."""
+
+    def __init__(self):
+        self.base_url = "https://api.aotrust.link"
+        self.calls = []
+
+    async def shield_free(self, work_hash):
+        self.calls.append(("shield_free", work_hash))
+        return {
+            "status": "queued",
+            "job_id": "job-123",
+            "pdr_b64": "QUJD",
+            "shield_id": "9f2c1a",
+            "payment_anchor_type": 0,
+            "tier": "free",
+        }
+
+    async def get_status(self, job_id):
+        self.calls.append(("get_status", job_id))
+        return asyncio.stub_status if False else _status_result()
+
+    async def get_pdr(self, job_id):
+        self.calls.append(("get_pdr", job_id))
+        return _pdr_result()
+
+    async def verify_pdr(self, pdr_b64):
+        self.calls.append(("verify_pdr", pdr_b64))
+        return {"valid": True, "payment_anchor_type": 0, "sig_valid": True}
+
+
+def _status_result():
+    from agent_notary import StatusResult
+    return StatusResult(status="anchored", pdr_b64="QUJD", payment_hash="deadbeef")
+
+
+def _pdr_result():
+    from agent_notary import PdrResult
+    return PdrResult(
+        pdr_b64="QUJD",
+        payment_hash="deadbeef",
+        payment_anchor_type=0,
+        verify_url="https://verify.aotrust.link/?pdr=QUJD",
+    )
+
+
+class TestNotarizeFree(unittest.TestCase):
+    def setUp(self):
+        self.fake = _FakeClient()
+        client_mod._client = self.fake
+
+    def tearDown(self):
+        client_mod._client = None
+
+    def test_returns_string_with_shield_id(self):
+        out = aotrust_notarize_free.invoke({"artifact_text": "hello world"})
+        self.assertIsInstance(out, str)
+        self.assertIn("shield_id=9f2c1a", out)
+        self.assertIn("job_id=job-123", out)
+        self.assertIn("verify.aotrust.link", out)
+
+    def test_sha256_stable(self):
+        expected = hashlib.sha256(b"hello world").hexdigest()
+        aotrust_notarize_free.invoke({"artifact_text": "hello world"})
+        self.assertEqual(self.fake.calls[0][1], expected)
+        # determinism: same input -> same hash
+        aotrust_notarize_free.invoke({"artifact_text": "hello world"})
+        self.assertEqual(self.fake.calls[0][1], self.fake.calls[1][1])
+
+
+class TestVerify(unittest.TestCase):
+    def setUp(self):
+        self.fake = _FakeClient()
+        client_mod._client = self.fake
+
+    def tearDown(self):
+        client_mod._client = self.fake
+
+    def test_parses_valid(self):
+        out = aotrust_verify.invoke({"job_id": "job-123"})
+        self.assertIn("valid=True", out)
+        self.assertIn("payment_anchor_type=0", out)
+        # get_pdr + verify_pdr both called
+        names = [c[0] for c in self.fake.calls]
+        self.assertIn("get_pdr", names)
+        self.assertIn("verify_pdr", names)
+
+
+class TestStatus(unittest.TestCase):
+    def setUp(self):
+        self.fake = _FakeClient()
+        client_mod._client = self.fake
+
+    def tearDown(self):
+        client_mod._client = self.fake
+
+    def test_status_anchored(self):
+        out = aotrust_status.invoke({"job_id": "job-123"})
+        self.assertIn("status=anchored", out)
+        self.assertIn("anchored=yes", out)
+
+
+class TestAsyncVariants(unittest.TestCase):
+    def setUp(self):
+        self.fake = _FakeClient()
+        client_mod._client = self.fake
+
+    def tearDown(self):
+        client_mod._client = self.fake
+
+    def test_async_notarize(self):
+        out = asyncio.run(aotrust_notarize_free_async("hello world"))
+        self.assertIn("shield_id=9f2c1a", out)
+
+    def test_async_verify(self):
+        out = asyncio.run(aotrust_verify_async("job-123"))
+        self.assertIn("valid=True", out)
+
+    def test_async_status(self):
+        out = asyncio.run(aotrust_status_async("job-123"))
+        self.assertIn("status=anchored", out)
+
+
+class TestBaseUrlNoV1(unittest.TestCase):
+    """Двойной /v1 — ловится здесь: singleton обязан строиться БЕЗ /v1 суффикса."""
+
+    def test_default_client_base_url_has_no_v1(self):
+        from langchain_aotrust import get_client
+        c = get_client()
+        self.assertFalse(c.base_url.rstrip("/").endswith("/v1"),
+                         f"base_url must NOT contain /v1 (got {c.base_url})")
+        self.assertTrue(c.base_url.startswith("https://api.aotrust.link"))
+
+    def test_configure_respects_custom_url(self):
+        from langchain_aotrust import configure, get_client, reset_client
+        configure(base_url="https://test.example.org")
+        c = get_client()
+        self.assertEqual(c.base_url, "https://test.example.org")
+        reset_client()
+
+
+if __name__ == "__main__":
+    unittest.main()