nosocial-langgraph 0.1.0__tar.gz

nosocial_langgraph-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: nosocial-langgraph
+Version: 0.1.0
+Summary: NoSocial reputation reporting for LangGraph/LangChain — auto-reports agent interactions to the NoSocial oracle
+Author-email: NoSocial <hello@nosocial.me>
+License-Expression: MIT
+Project-URL: Homepage, https://nosocial.me
+Project-URL: Repository, https://github.com/pcdkd/nosocial-protocol
+Project-URL: Specification, https://nosocial.me/extensions/agent-profile
+Keywords: nosocial,langgraph,langchain,agent,reputation,a2a
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: langgraph>=0.2.0
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: cryptography>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: responses>=0.25.0; extra == "dev"
+
+# nosocial-langgraph
+
+NoSocial reputation reporting for [LangGraph](https://langchain-ai.github.io/langgraph/) and [LangChain](https://python.langchain.com). Add a callback handler — your graph nodes and tools build reputation automatically.
+
+## Install
+
+```bash
+pip install nosocial-langgraph
+```
+
+## Usage
+
+```python
+from nosocial_langgraph import NoSocialCallbackHandler
+
+handler = NoSocialCallbackHandler(oracle_url="https://api.nosocial.me")
+
+# Pass handler to any LangGraph graph invocation
+result = graph.invoke({"messages": []}, config={"callbacks": [handler]})
+```
+
+**Note:** Reports are only generated for node-level events (where `parent_run_id` is set). This works with LangGraph graphs where nodes execute as sub-runs. Standalone LangChain chain calls may not trigger reports since they run as top-level invocations.
+
+## What it does
+
+The callback handler intercepts LangChain/LangGraph events and submits signed interaction reports:
+
+| Event | Domain | Score |
+|---|---|---|
+| `on_chain_end` (node completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_chain_error` (node fails) | `reliability` | -0.8 |
+| `on_tool_end` (tool completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_retriever_end` (retriever returns) | `information_quality` | 0.7 if docs returned, -0.3 if empty |
+
+Only node-level events are reported — top-level graph runs are skipped to avoid double-counting.
+
+## Identity mapping
+
+- **Reporter:** The graph itself, identified by `graph_name`
+- **Subject:** Each node/tool in the graph, namespaced as `{graph_name}:{node_name}`
+
+Each identity gets a persistent Ed25519 keypair stored in `.nosocial/keys/`.
+
+## Configuration
+
+```python
+handler = NoSocialCallbackHandler(
+    oracle_url="https://api.nosocial.me",  # Oracle endpoint
+    keys_dir=".nosocial/keys",             # Where to store agent keypairs
+    graph_name="my-graph",                 # Name for the graph's identity
+    auto_register=True,                    # Auto-register agents with oracle
+)
+```
+
+## Key storage
+
+Agent keypairs are stored as PEM files in `.nosocial/keys/` with `0600` permissions. Add this to your `.gitignore`:
+
+```
+.nosocial/
+```
+
+## License
+
+MIT

nosocial_langgraph-0.1.0/README.md

@@ -0,0 +1,65 @@
+# nosocial-langgraph
+
+NoSocial reputation reporting for [LangGraph](https://langchain-ai.github.io/langgraph/) and [LangChain](https://python.langchain.com). Add a callback handler — your graph nodes and tools build reputation automatically.
+
+## Install
+
+```bash
+pip install nosocial-langgraph
+```
+
+## Usage
+
+```python
+from nosocial_langgraph import NoSocialCallbackHandler
+
+handler = NoSocialCallbackHandler(oracle_url="https://api.nosocial.me")
+
+# Pass handler to any LangGraph graph invocation
+result = graph.invoke({"messages": []}, config={"callbacks": [handler]})
+```
+
+**Note:** Reports are only generated for node-level events (where `parent_run_id` is set). This works with LangGraph graphs where nodes execute as sub-runs. Standalone LangChain chain calls may not trigger reports since they run as top-level invocations.
+
+## What it does
+
+The callback handler intercepts LangChain/LangGraph events and submits signed interaction reports:
+
+| Event | Domain | Score |
+|---|---|---|
+| `on_chain_end` (node completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_chain_error` (node fails) | `reliability` | -0.8 |
+| `on_tool_end` (tool completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_retriever_end` (retriever returns) | `information_quality` | 0.7 if docs returned, -0.3 if empty |
+
+Only node-level events are reported — top-level graph runs are skipped to avoid double-counting.
+
+## Identity mapping
+
+- **Reporter:** The graph itself, identified by `graph_name`
+- **Subject:** Each node/tool in the graph, namespaced as `{graph_name}:{node_name}`
+
+Each identity gets a persistent Ed25519 keypair stored in `.nosocial/keys/`.
+
+## Configuration
+
+```python
+handler = NoSocialCallbackHandler(
+    oracle_url="https://api.nosocial.me",  # Oracle endpoint
+    keys_dir=".nosocial/keys",             # Where to store agent keypairs
+    graph_name="my-graph",                 # Name for the graph's identity
+    auto_register=True,                    # Auto-register agents with oracle
+)
+```
+
+## Key storage
+
+Agent keypairs are stored as PEM files in `.nosocial/keys/` with `0600` permissions. Add this to your `.gitignore`:
+
+```
+.nosocial/
+```
+
+## License
+
+MIT

nosocial_langgraph-0.1.0/nosocial_langgraph/__init__.py

@@ -0,0 +1,4 @@
+from nosocial_langgraph.handler import NoSocialCallbackHandler
+from nosocial_langgraph.identity import AgentIdentity
+
+__all__ = ["NoSocialCallbackHandler", "AgentIdentity"]

nosocial_langgraph-0.1.0/nosocial_langgraph/handler.py

@@ -0,0 +1,230 @@
+"""
+NoSocial callback handler for LangGraph/LangChain.
+
+Usage:
+    from nosocial_langgraph import NoSocialCallbackHandler
+
+    handler = NoSocialCallbackHandler(oracle_url="https://api.nosocial.me")
+    result = graph.invoke(input, config={"callbacks": [handler]})
+"""
+
+import logging
+import time
+import uuid
+from typing import Any, Optional, Sequence
+
+import requests
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.documents import Document
+
+from nosocial_langgraph.identity import AgentIdentity
+from nosocial_langgraph.mapping import (
+    map_chain_end,
+    map_chain_error,
+    map_retriever_end,
+    map_tool_end,
+)
+
+logger = logging.getLogger("nosocial")
+
+
+class NoSocialCallbackHandler(BaseCallbackHandler):
+    """Reports LangGraph/LangChain events as NoSocial interaction reports.
+
+    The graph itself is the reporter. Each node/tool is a subject.
+    Only reports on node-level completions (where parent_run_id is set)
+    to avoid double-counting top-level graph runs.
+    """
+
+    def __init__(
+        self,
+        oracle_url: str = "https://api.nosocial.me",
+        keys_dir: str = ".nosocial/keys",
+        graph_name: str = "default-graph",
+        auto_register: bool = True,
+    ):
+        super().__init__()
+        self.oracle_url = oracle_url.rstrip("/")
+        self.keys_dir = keys_dir
+        self.graph_name = graph_name
+        self.auto_register = auto_register
+        self._identities: dict[str, AgentIdentity] = {}
+        self._registered: set[str] = set()
+        self._graph_identity = self._get_or_create_identity(f"graph:{graph_name}")
+
+    def _get_or_create_identity(self, name: str) -> AgentIdentity:
+        if name not in self._identities:
+            self._identities[name] = AgentIdentity.load_or_create(name, self.keys_dir)
+        return self._identities[name]
+
+    def _ensure_registered(self, identity: AgentIdentity, name: str) -> bool:
+        if identity.did in self._registered:
+            return True
+        if not self.auto_register:
+            return False
+
+        try:
+            resp = requests.post(
+                f"{self.oracle_url}/v1/agents/challenge",
+                json={"publicKey": identity.public_key_str},
+                timeout=10,
+            )
+            if resp.status_code == 409:
+                # Check if this is genuinely "already registered" vs another 409 error
+                error_msg = ""
+                try:
+                    error_msg = (resp.json().get("error", "") or "").lower()
+                except ValueError:
+                    pass
+                if "already registered" in error_msg or "already exists" in error_msg:
+                    self._registered.add(identity.did)
+                    return True
+                logger.warning(f"Oracle 409 during challenge for '{name}': {error_msg}")
+                return False
+            resp.raise_for_status()
+            challenge_data = resp.json()
+
+            signature = identity.sign({"challenge": challenge_data["challenge"]})
+            resp = requests.post(
+                f"{self.oracle_url}/v1/agents/register",
+                json={
+                    "challengeId": challenge_data["challengeId"],
+                    "signature": signature,
+                    "publicKey": identity.public_key_str,
+                    "name": name,
+                },
+                timeout=10,
+            )
+            if resp.status_code == 409:
+                self._registered.add(identity.did)
+                return True
+            resp.raise_for_status()
+            self._registered.add(identity.did)
+            logger.info(f"Registered agent '{name}' as {identity.did}")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Failed to register '{name}' with oracle: {e}")
+            return False
+
+    def _submit_report(
+        self,
+        reporter: AgentIdentity,
+        subject: AgentIdentity,
+        domain: str,
+        score: float,
+        context: Optional[dict] = None,
+    ) -> bool:
+        report = {
+            "id": str(uuid.uuid4()),
+            "reporter": reporter.did,
+            "subject": subject.did,
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "domain": domain,
+            "score": max(-1.0, min(1.0, score)),
+        }
+        if context:
+            report["context"] = context
+
+        signature = reporter.sign(report)
+        report["signature"] = signature
+
+        try:
+            resp = requests.post(
+                f"{self.oracle_url}/v1/reports",
+                json=report,
+                timeout=10,
+            )
+            if resp.status_code == 201:
+                logger.debug(
+                    f"Reported: {reporter.did[:20]}... → {subject.did[:20]}... "
+                    f"domain={domain} score={score}"
+                )
+                return True
+            else:
+                logger.warning(f"Oracle rejected report: {resp.json()}")
+                return False
+        except Exception as e:
+            logger.warning(f"Failed to submit report: {e}")
+            return False
+
+    def _report_event(
+        self,
+        node_name: str,
+        domain: str,
+        score: float,
+        context: dict,
+        parent_run_id: Optional[uuid.UUID] = None,
+    ) -> None:
+        """Submit a report for a node-level event. Skips top-level graph runs."""
+        if parent_run_id is None:
+            return
+
+        subject_name = f"{self.graph_name}:{node_name}"
+        subject = self._get_or_create_identity(subject_name)
+
+        if not self._ensure_registered(self._graph_identity, f"graph:{self.graph_name}"):
+            return
+        if not self._ensure_registered(subject, subject_name):
+            return
+
+        self._submit_report(
+            reporter=self._graph_identity,
+            subject=subject,
+            domain=domain,
+            score=score,
+            context=context,
+        )
+
+    # --- LangChain callback methods ---
+    # TODO: Consider an AsyncNoSocialCallbackHandler using httpx for
+    # async LangGraph graphs. Sync callbacks are acceptable for now since
+    # LangChain v0.3+ backgrounds callbacks by default.
+
+    def on_chain_end(
+        self,
+        outputs: dict[str, Any],
+        *,
+        run_id: uuid.UUID,
+        parent_run_id: Optional[uuid.UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        node_name = kwargs.get("name", "unknown-node")
+        domain, score, context = map_chain_end(outputs)
+        self._report_event(node_name, domain, score, context, parent_run_id)
+
+    def on_chain_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: uuid.UUID,
+        parent_run_id: Optional[uuid.UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        node_name = kwargs.get("name", "unknown-node")
+        domain, score, context = map_chain_error(error)
+        self._report_event(node_name, domain, score, context, parent_run_id)
+
+    def on_tool_end(
+        self,
+        output: Any,
+        *,
+        run_id: uuid.UUID,
+        parent_run_id: Optional[uuid.UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        tool_name = kwargs.get("name", "unknown-tool")
+        domain, score, context = map_tool_end(str(output))
+        self._report_event(tool_name, domain, score, context, parent_run_id)
+
+    def on_retriever_end(
+        self,
+        documents: Optional[Sequence[Document]],
+        *,
+        run_id: uuid.UUID,
+        parent_run_id: Optional[uuid.UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        retriever_name = kwargs.get("name", "unknown-retriever")
+        domain, score, context = map_retriever_end(list(documents or []))
+        self._report_event(retriever_name, domain, score, context, parent_run_id)

nosocial_langgraph-0.1.0/nosocial_langgraph/identity.py

@@ -0,0 +1,90 @@
+"""
+NoSocial agent identity — Ed25519 keypairs and DID derivation.
+
+Each agent gets a persistent NoSocial identity (keypair + DID).
+Keys are stored as PEM files in a configurable directory.
+"""
+
+import base64
+import hashlib
+import json
+import os
+from pathlib import Path
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from cryptography.hazmat.primitives.serialization import (
+    Encoding,
+    NoEncryption,
+    PrivateFormat,
+    PublicFormat,
+)
+
+
+def _base64url_encode(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _safe_filename(name: str) -> str:
+    """Derive a safe filename from an agent name using a hash prefix."""
+    h = hashlib.sha256(name.encode()).hexdigest()[:12]
+    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in name)
+    return f"{safe}_{h}"
+
+
+class AgentIdentity:
+    """A NoSocial identity for an agent."""
+
+    def __init__(self, private_key: Ed25519PrivateKey):
+        self._private_key = private_key
+        self._public_key = private_key.public_key()
+        raw_pub = self._public_key.public_bytes(Encoding.Raw, PublicFormat.Raw)
+        self.public_key_str = f"ed25519:{_base64url_encode(raw_pub)}"
+        self.did = f"did:nosocial:{hashlib.sha256(raw_pub).hexdigest()}"
+
+    @classmethod
+    def generate(cls) -> "AgentIdentity":
+        """Generate a new random identity."""
+        return cls(Ed25519PrivateKey.generate())
+
+    @classmethod
+    def load_or_create(cls, name: str, keys_dir: str = ".nosocial/keys") -> "AgentIdentity":
+        """Load an existing identity for an agent name, or create one."""
+        path = Path(keys_dir)
+        path.mkdir(parents=True, exist_ok=True)
+        key_file = path / f"{_safe_filename(name)}.pem"
+
+        if key_file.exists():
+            pem_data = key_file.read_bytes()
+            from cryptography.hazmat.primitives.serialization import load_pem_private_key
+            private_key = load_pem_private_key(pem_data, password=None)
+            if not isinstance(private_key, Ed25519PrivateKey):
+                raise ValueError(f"Key in {key_file} is not Ed25519")
+            return cls(private_key)
+
+        identity = cls.generate()
+        pem_data = identity._private_key.private_bytes(
+            Encoding.PEM, PrivateFormat.PKCS8, NoEncryption()
+        )
+        fd = os.open(key_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "wb") as f:
+            f.write(pem_data)
+        return identity
+
+    def sign(self, obj: dict) -> str:
+        """Sign a canonical JSON object, returning 'ed25519:{base64url}'."""
+        message = _canonicalize(obj).encode("utf-8")
+        sig = self._private_key.sign(message)
+        return f"ed25519:{_base64url_encode(sig)}"
+
+
+def _canonicalize(obj) -> str:
+    """Recursive canonical JSON: keys sorted at every level, no whitespace."""
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return json.dumps(obj)
+    if isinstance(obj, list):
+        return "[" + ",".join(_canonicalize(v) for v in obj) + "]"
+    if isinstance(obj, dict):
+        entries = sorted(obj.keys())
+        parts = [json.dumps(k) + ":" + _canonicalize(obj[k]) for k in entries]
+        return "{" + ",".join(parts) + "}"
+    return json.dumps(obj)

nosocial_langgraph-0.1.0/nosocial_langgraph/mapping.py

@@ -0,0 +1,48 @@
+"""
+Event-to-report mapping for LangChain/LangGraph callbacks.
+
+Maps LangChain callback events to NoSocial report parameters (domain + score).
+"""
+
+def map_chain_end(outputs: dict) -> tuple[str, float, dict]:
+    """Map on_chain_end to a NoSocial report."""
+    has_output = bool(outputs) and any(
+        v is not None and v != "" for v in (outputs.values() if isinstance(outputs, dict) else [outputs])
+    )
+    score = 0.8 if has_output else -0.5
+    return (
+        "task_completion",
+        score,
+        {"taskType": "langgraph-node", "outputAccepted": has_output},
+    )
+
+
+def map_chain_error(error: Exception) -> tuple[str, float, dict]:
+    """Map on_chain_error to a NoSocial report."""
+    return (
+        "reliability",
+        -0.8,
+        {"taskType": "langgraph-node", "error": type(error).__name__},
+    )
+
+
+def map_tool_end(output: str) -> tuple[str, float, dict]:
+    """Map on_tool_end to a NoSocial report."""
+    has_output = bool(output and str(output).strip())
+    score = 0.8 if has_output else -0.5
+    return (
+        "task_completion",
+        score,
+        {"taskType": "langgraph-tool", "outputAccepted": has_output},
+    )
+
+
+def map_retriever_end(documents: list) -> tuple[str, float, dict]:
+    """Map on_retriever_end to a NoSocial report."""
+    has_docs = bool(documents) and len(documents) > 0
+    score = 0.7 if has_docs else -0.3
+    return (
+        "information_quality",
+        score,
+        {"taskType": "langgraph-retriever", "docCount": len(documents) if documents else 0},
+    )

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

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: nosocial-langgraph
+Version: 0.1.0
+Summary: NoSocial reputation reporting for LangGraph/LangChain — auto-reports agent interactions to the NoSocial oracle
+Author-email: NoSocial <hello@nosocial.me>
+License-Expression: MIT
+Project-URL: Homepage, https://nosocial.me
+Project-URL: Repository, https://github.com/pcdkd/nosocial-protocol
+Project-URL: Specification, https://nosocial.me/extensions/agent-profile
+Keywords: nosocial,langgraph,langchain,agent,reputation,a2a
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: langgraph>=0.2.0
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: cryptography>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: responses>=0.25.0; extra == "dev"
+
+# nosocial-langgraph
+
+NoSocial reputation reporting for [LangGraph](https://langchain-ai.github.io/langgraph/) and [LangChain](https://python.langchain.com). Add a callback handler — your graph nodes and tools build reputation automatically.
+
+## Install
+
+```bash
+pip install nosocial-langgraph
+```
+
+## Usage
+
+```python
+from nosocial_langgraph import NoSocialCallbackHandler
+
+handler = NoSocialCallbackHandler(oracle_url="https://api.nosocial.me")
+
+# Pass handler to any LangGraph graph invocation
+result = graph.invoke({"messages": []}, config={"callbacks": [handler]})
+```
+
+**Note:** Reports are only generated for node-level events (where `parent_run_id` is set). This works with LangGraph graphs where nodes execute as sub-runs. Standalone LangChain chain calls may not trigger reports since they run as top-level invocations.
+
+## What it does
+
+The callback handler intercepts LangChain/LangGraph events and submits signed interaction reports:
+
+| Event | Domain | Score |
+|---|---|---|
+| `on_chain_end` (node completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_chain_error` (node fails) | `reliability` | -0.8 |
+| `on_tool_end` (tool completes) | `task_completion` | 0.8 if output non-empty, -0.5 if empty |
+| `on_retriever_end` (retriever returns) | `information_quality` | 0.7 if docs returned, -0.3 if empty |
+
+Only node-level events are reported — top-level graph runs are skipped to avoid double-counting.
+
+## Identity mapping
+
+- **Reporter:** The graph itself, identified by `graph_name`
+- **Subject:** Each node/tool in the graph, namespaced as `{graph_name}:{node_name}`
+
+Each identity gets a persistent Ed25519 keypair stored in `.nosocial/keys/`.
+
+## Configuration
+
+```python
+handler = NoSocialCallbackHandler(
+    oracle_url="https://api.nosocial.me",  # Oracle endpoint
+    keys_dir=".nosocial/keys",             # Where to store agent keypairs
+    graph_name="my-graph",                 # Name for the graph's identity
+    auto_register=True,                    # Auto-register agents with oracle
+)
+```
+
+## Key storage
+
+Agent keypairs are stored as PEM files in `.nosocial/keys/` with `0600` permissions. Add this to your `.gitignore`:
+
+```
+.nosocial/
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+nosocial_langgraph/__init__.py
+nosocial_langgraph/handler.py
+nosocial_langgraph/identity.py
+nosocial_langgraph/mapping.py
+nosocial_langgraph.egg-info/PKG-INFO
+nosocial_langgraph.egg-info/SOURCES.txt
+nosocial_langgraph.egg-info/dependency_links.txt
+nosocial_langgraph.egg-info/requires.txt
+nosocial_langgraph.egg-info/top_level.txt
+tests/test_handler.py
+tests/test_identity.py
+tests/test_mapping.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,8 @@
+langgraph>=0.2.0
+langchain-core>=0.3.0
+requests>=2.31.0
+cryptography>=42.0.0
+
+[dev]
+pytest>=8.0.0
+responses>=0.25.0

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

@@ -0,0 +1 @@
+nosocial_langgraph

nosocial_langgraph-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nosocial-langgraph"
+version = "0.1.0"
+description = "NoSocial reputation reporting for LangGraph/LangChain — auto-reports agent interactions to the NoSocial oracle"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "NoSocial", email = "hello@nosocial.me" },
+]
+keywords = ["nosocial", "langgraph", "langchain", "agent", "reputation", "a2a"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "langgraph>=0.2.0",
+    "langchain-core>=0.3.0",
+    "requests>=2.31.0",
+    "cryptography>=42.0.0",
+]
+
+[project.urls]
+Homepage = "https://nosocial.me"
+Repository = "https://github.com/pcdkd/nosocial-protocol"
+Specification = "https://nosocial.me/extensions/agent-profile"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "responses>=0.25.0",
+]

nosocial_langgraph-0.1.0/setup.cfg

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

nosocial_langgraph-0.1.0/tests/test_handler.py

@@ -0,0 +1,206 @@
+"""Tests for NoSocial LangGraph callback handler."""
+
+import tempfile
+import uuid
+
+import responses
+
+from nosocial_langgraph.handler import NoSocialCallbackHandler
+
+
+ORACLE_URL = "http://test-oracle:3000"
+
+
+def _mock_oracle(oracle_url: str = ORACLE_URL):
+    """Set up mock oracle endpoints."""
+    responses.post(
+        f"{oracle_url}/v1/agents/challenge",
+        json={
+            "challengeId": "test-challenge-id",
+            "challenge": "test-challenge-string",
+            "did": "did:nosocial:abc",
+            "expiresAt": "2099-01-01T00:00:00Z",
+        },
+        status=201,
+    )
+    responses.post(
+        f"{oracle_url}/v1/agents/register",
+        json={"did": "did:nosocial:abc", "name": "test"},
+        status=201,
+    )
+    responses.post(
+        f"{oracle_url}/v1/reports",
+        json={"accepted": True},
+        status=201,
+    )
+
+
+class TestHandlerInit:
+    def test_creates_graph_identity(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                keys_dir=tmpdir,
+                auto_register=False,
+            )
+            assert handler._graph_identity.did.startswith("did:nosocial:")
+
+    def test_graph_identity_persists(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            h1 = NoSocialCallbackHandler(keys_dir=tmpdir, graph_name="test", auto_register=False)
+            h2 = NoSocialCallbackHandler(keys_dir=tmpdir, graph_name="test", auto_register=False)
+            assert h1._graph_identity.did == h2._graph_identity.did
+
+
+class TestOnChainEnd:
+    @responses.activate
+    def test_reports_on_node_completion(self):
+        _mock_oracle()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                oracle_url=ORACLE_URL,
+                keys_dir=tmpdir,
+                graph_name="test-graph",
+            )
+            handler.on_chain_end(
+                outputs={"result": "done"},
+                run_id=uuid.uuid4(),
+                parent_run_id=uuid.uuid4(),
+                name="my-node",
+            )
+
+            report_calls = [c for c in responses.calls if "/v1/reports" in c.request.url]
+            assert len(report_calls) == 1
+
+    def test_skips_top_level_graph_run(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                keys_dir=tmpdir,
+                auto_register=False,
+            )
+            # parent_run_id=None means this is the top-level graph run
+            handler.on_chain_end(
+                outputs={"result": "done"},
+                run_id=uuid.uuid4(),
+                parent_run_id=None,
+                name="graph",
+            )
+            # No exception, no report submitted
+
+
+class TestOnChainError:
+    @responses.activate
+    def test_reports_negative_reliability(self):
+        _mock_oracle()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                oracle_url=ORACLE_URL,
+                keys_dir=tmpdir,
+            )
+            handler.on_chain_error(
+                error=ValueError("something broke"),
+                run_id=uuid.uuid4(),
+                parent_run_id=uuid.uuid4(),
+                name="failing-node",
+            )
+
+            report_calls = [c for c in responses.calls if "/v1/reports" in c.request.url]
+            assert len(report_calls) == 1
+
+            import json
+            body = json.loads(report_calls[0].request.body)
+            assert body["domain"] == "reliability"
+            assert body["score"] == -0.8
+
+
+class TestOnToolEnd:
+    @responses.activate
+    def test_reports_tool_completion(self):
+        _mock_oracle()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                oracle_url=ORACLE_URL,
+                keys_dir=tmpdir,
+            )
+            handler.on_tool_end(
+                output="search results",
+                run_id=uuid.uuid4(),
+                parent_run_id=uuid.uuid4(),
+                name="search-tool",
+            )
+
+            report_calls = [c for c in responses.calls if "/v1/reports" in c.request.url]
+            assert len(report_calls) == 1
+
+
+class TestOnRetrieverEnd:
+    @responses.activate
+    def test_reports_retriever_with_docs(self):
+        _mock_oracle()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                oracle_url=ORACLE_URL,
+                keys_dir=tmpdir,
+            )
+            from langchain_core.documents import Document
+            handler.on_retriever_end(
+                documents=[Document(page_content="relevant doc")],
+                run_id=uuid.uuid4(),
+                parent_run_id=uuid.uuid4(),
+                name="my-retriever",
+            )
+
+            report_calls = [c for c in responses.calls if "/v1/reports" in c.request.url]
+            assert len(report_calls) == 1
+
+            import json
+            body = json.loads(report_calls[0].request.body)
+            assert body["domain"] == "information_quality"
+            assert body["score"] == 0.7
+
+
+class TestNamespacing:
+    def test_node_identities_namespaced_by_graph(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            h1 = NoSocialCallbackHandler(keys_dir=tmpdir, graph_name="graph-a", auto_register=False)
+            h2 = NoSocialCallbackHandler(keys_dir=tmpdir, graph_name="graph-b", auto_register=False)
+            id1 = h1._get_or_create_identity("graph-a:researcher")
+            id2 = h2._get_or_create_identity("graph-b:researcher")
+            assert id1.did != id2.did
+
+    def test_identity_reused_across_calls(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(keys_dir=tmpdir, auto_register=False)
+            id1 = handler._get_or_create_identity("node-a")
+            id2 = handler._get_or_create_identity("node-a")
+            assert id1.did == id2.did
+
+
+class TestAlreadyRegistered:
+    @responses.activate
+    def test_handles_409_already_registered(self):
+        """Handler should treat 409 as successful registration."""
+        responses.post(
+            f"{ORACLE_URL}/v1/agents/challenge",
+            json={"error": "Already registered"},
+            status=409,
+        )
+        responses.post(
+            f"{ORACLE_URL}/v1/reports",
+            json={"accepted": True},
+            status=201,
+        )
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            handler = NoSocialCallbackHandler(
+                oracle_url=ORACLE_URL,
+                keys_dir=tmpdir,
+            )
+            handler.on_chain_end(
+                outputs={"result": "done"},
+                run_id=uuid.uuid4(),
+                parent_run_id=uuid.uuid4(),
+                name="my-node",
+            )
+
+            report_calls = [c for c in responses.calls if "/v1/reports" in c.request.url]
+            assert len(report_calls) == 1

nosocial_langgraph-0.1.0/tests/test_identity.py

@@ -0,0 +1,50 @@
+"""Tests for NoSocial agent identity."""
+
+import tempfile
+
+from nosocial_langgraph.identity import AgentIdentity, _canonicalize
+
+
+def test_generate_identity():
+    identity = AgentIdentity.generate()
+    assert identity.public_key_str.startswith("ed25519:")
+    assert identity.did.startswith("did:nosocial:")
+    assert len(identity.did) == len("did:nosocial:") + 64  # sha256 hex
+
+
+
+def test_load_or_create_persists():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        id1 = AgentIdentity.load_or_create("test-agent", keys_dir=tmpdir)
+        id2 = AgentIdentity.load_or_create("test-agent", keys_dir=tmpdir)
+        assert id1.did == id2.did
+        assert id1.public_key_str == id2.public_key_str
+
+
+def test_different_names_different_keys():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        id1 = AgentIdentity.load_or_create("agent-a", keys_dir=tmpdir)
+        id2 = AgentIdentity.load_or_create("agent-b", keys_dir=tmpdir)
+        assert id1.did != id2.did
+
+
+def test_sign_produces_valid_format():
+    identity = AgentIdentity.generate()
+    sig = identity.sign({"hello": "world"})
+    assert sig.startswith("ed25519:")
+    assert len(sig) > 20
+
+
+def test_canonicalize_sorts_keys():
+    result = _canonicalize({"b": 1, "a": 2})
+    assert result == '{"a":2,"b":1}'
+
+
+def test_canonicalize_nested():
+    result = _canonicalize({"z": {"b": 1, "a": 2}, "a": 3})
+    assert result == '{"a":3,"z":{"a":2,"b":1}}'
+
+
+def test_canonicalize_array():
+    result = _canonicalize({"items": [3, 1, 2]})
+    assert result == '{"items":[3,1,2]}'

nosocial_langgraph-0.1.0/tests/test_mapping.py

@@ -0,0 +1,70 @@
+"""Tests for event-to-report mapping."""
+
+from nosocial_langgraph.mapping import (
+    map_chain_end,
+    map_chain_error,
+    map_retriever_end,
+    map_tool_end,
+)
+
+
+class TestMapChainEnd:
+    def test_non_empty_output(self):
+        domain, score, ctx = map_chain_end({"result": "hello"})
+        assert domain == "task_completion"
+        assert score == 0.8
+        assert ctx["outputAccepted"] is True
+
+    def test_empty_output(self):
+        domain, score, ctx = map_chain_end({})
+        assert domain == "task_completion"
+        assert score == -0.5
+        assert ctx["outputAccepted"] is False
+
+    def test_none_values(self):
+        domain, score, ctx = map_chain_end({"result": None})
+        assert score == -0.5
+
+    def test_empty_string_value(self):
+        domain, score, ctx = map_chain_end({"result": ""})
+        assert score == -0.5
+
+
+class TestMapChainError:
+    def test_error_report(self):
+        domain, score, ctx = map_chain_error(ValueError("test"))
+        assert domain == "reliability"
+        assert score == -0.8
+        assert ctx["error"] == "ValueError"
+
+
+class TestMapToolEnd:
+    def test_non_empty_output(self):
+        domain, score, ctx = map_tool_end("search results here")
+        assert domain == "task_completion"
+        assert score == 0.8
+
+    def test_empty_output(self):
+        domain, score, ctx = map_tool_end("")
+        assert score == -0.5
+
+    def test_whitespace_only(self):
+        domain, score, ctx = map_tool_end("   ")
+        assert score == -0.5
+
+
+class TestMapRetrieverEnd:
+    def test_docs_returned(self):
+        domain, score, ctx = map_retriever_end([{"page_content": "doc1"}])
+        assert domain == "information_quality"
+        assert score == 0.7
+        assert ctx["docCount"] == 1
+
+    def test_no_docs(self):
+        domain, score, ctx = map_retriever_end([])
+        assert score == -0.3
+        assert ctx["docCount"] == 0
+
+    def test_none_docs(self):
+        domain, score, ctx = map_retriever_end(None)
+        assert score == -0.3