ldp-protocol 0.1.0__tar.gz

ldp_protocol-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+/target
+Cargo.lock
+*.swp
+*.swo
+.DS_Store
+.venv/
+__pycache__/
+
+# Private planning docs (local only)
+/private/

ldp_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: ldp-protocol
+Version: 0.1.0
+Summary: LDP — LLM Delegate Protocol: identity-aware communication for multi-agent LLM systems
+Project-URL: Homepage, https://github.com/sunilp/ldp-protocol
+Project-URL: Documentation, https://github.com/sunilp/ldp-protocol/tree/main/sdk/python
+Project-URL: Repository, https://github.com/sunilp/ldp-protocol
+Project-URL: Issues, https://github.com/sunilp/ldp-protocol/issues
+Author: Sunil Prakash
+License-Expression: Apache-2.0
+Keywords: a2a,agents,delegation,llm,mcp,multi-agent,protocol
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+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
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: server
+Requires-Dist: starlette>=0.27; extra == 'server'
+Requires-Dist: uvicorn>=0.23; extra == 'server'
+Description-Content-Type: text/markdown
+
+# LDP Protocol — Python SDK
+
+Identity-aware communication protocol for multi-agent LLM systems.
+
+```bash
+pip install ldp-protocol
+```
+
+## Quick Start
+
+### Create a delegate
+
+```python
+from ldp_protocol import LdpDelegate, LdpCapability, QualityMetrics
+
+class MyDelegate(LdpDelegate):
+    async def handle_task(self, skill, input_data, task_id):
+        return {"answer": "42"}, 0.95
+
+delegate = MyDelegate(
+    delegate_id="ldp:delegate:my-agent",
+    name="My Agent",
+    model_family="claude",
+    model_version="claude-sonnet-4-6",
+    capabilities=[
+        LdpCapability(
+            name="reasoning",
+            quality=QualityMetrics(quality_score=0.85, cost_per_call_usd=0.01),
+        ),
+    ],
+)
+delegate.run(port=8090)  # requires: pip install ldp-protocol[server]
+```
+
+### Discover and invoke
+
+```python
+from ldp_protocol import LdpClient
+
+async with LdpClient() as client:
+    identity = await client.discover("http://localhost:8090")
+    print(f"Found: {identity.name} ({identity.model_family})")
+
+    result = await client.submit_task(
+        "http://localhost:8090",
+        skill="reasoning",
+        input_data={"prompt": "Analyze the tradeoffs..."},
+    )
+    print(f"Output: {result['output']}")
+    print(f"Provenance: {result['provenance']}")
+```
+
+### Multi-delegate routing
+
+```python
+from ldp_protocol import LdpRouter, RoutingStrategy
+
+async with LdpRouter() as router:
+    await router.discover_delegates([
+        "http://fast-model:8091",
+        "http://deep-model:8092",
+    ])
+
+    # Route by quality, cost, latency, or balanced score
+    result = await router.route_and_submit(
+        skill="reasoning",
+        input_data={"prompt": "Complex analysis..."},
+        strategy=RoutingStrategy.QUALITY,
+    )
+    print(f"Routed to: {result['routed_to']['name']}")
+```
+
+## Links
+
+- [Protocol specification](https://github.com/sunilp/ldp-protocol)
+- [Research paper](https://arxiv.org/abs/2603.08852)
+- [Rust reference implementation](https://github.com/sunilp/ldp-protocol)

ldp_protocol-0.1.0/README.md

@@ -0,0 +1,77 @@
+# LDP Protocol — Python SDK
+
+Identity-aware communication protocol for multi-agent LLM systems.
+
+```bash
+pip install ldp-protocol
+```
+
+## Quick Start
+
+### Create a delegate
+
+```python
+from ldp_protocol import LdpDelegate, LdpCapability, QualityMetrics
+
+class MyDelegate(LdpDelegate):
+    async def handle_task(self, skill, input_data, task_id):
+        return {"answer": "42"}, 0.95
+
+delegate = MyDelegate(
+    delegate_id="ldp:delegate:my-agent",
+    name="My Agent",
+    model_family="claude",
+    model_version="claude-sonnet-4-6",
+    capabilities=[
+        LdpCapability(
+            name="reasoning",
+            quality=QualityMetrics(quality_score=0.85, cost_per_call_usd=0.01),
+        ),
+    ],
+)
+delegate.run(port=8090)  # requires: pip install ldp-protocol[server]
+```
+
+### Discover and invoke
+
+```python
+from ldp_protocol import LdpClient
+
+async with LdpClient() as client:
+    identity = await client.discover("http://localhost:8090")
+    print(f"Found: {identity.name} ({identity.model_family})")
+
+    result = await client.submit_task(
+        "http://localhost:8090",
+        skill="reasoning",
+        input_data={"prompt": "Analyze the tradeoffs..."},
+    )
+    print(f"Output: {result['output']}")
+    print(f"Provenance: {result['provenance']}")
+```
+
+### Multi-delegate routing
+
+```python
+from ldp_protocol import LdpRouter, RoutingStrategy
+
+async with LdpRouter() as router:
+    await router.discover_delegates([
+        "http://fast-model:8091",
+        "http://deep-model:8092",
+    ])
+
+    # Route by quality, cost, latency, or balanced score
+    result = await router.route_and_submit(
+        skill="reasoning",
+        input_data={"prompt": "Complex analysis..."},
+        strategy=RoutingStrategy.QUALITY,
+    )
+    print(f"Routed to: {result['routed_to']['name']}")
+```
+
+## Links
+
+- [Protocol specification](https://github.com/sunilp/ldp-protocol)
+- [Research paper](https://arxiv.org/abs/2603.08852)
+- [Rust reference implementation](https://github.com/sunilp/ldp-protocol)

ldp_protocol-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ldp-protocol"
+version = "0.1.0"
+description = "LDP — LLM Delegate Protocol: identity-aware communication for multi-agent LLM systems"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Sunil Prakash" },
+]
+keywords = ["llm", "agents", "protocol", "delegation", "multi-agent", "a2a", "mcp"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "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",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.0",
+    "httpx>=0.25",
+]
+
+[project.optional-dependencies]
+server = ["starlette>=0.27", "uvicorn>=0.23"]
+dev = ["pytest>=7.0", "pytest-asyncio>=0.21", "ruff>=0.1"]
+
+[project.urls]
+Homepage = "https://github.com/sunilp/ldp-protocol"
+Documentation = "https://github.com/sunilp/ldp-protocol/tree/main/sdk/python"
+Repository = "https://github.com/sunilp/ldp-protocol"
+Issues = "https://github.com/sunilp/ldp-protocol/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ldp_protocol"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

ldp_protocol-0.1.0/src/ldp_protocol/__init__.py

@@ -0,0 +1,49 @@
+"""LDP — LLM Delegate Protocol.
+
+Identity-aware communication protocol for multi-agent LLM systems.
+LDP adds delegation intelligence on top of A2A and MCP: rich identity,
+progressive payload modes, governed sessions, structured provenance,
+and trust domains.
+"""
+
+from ldp_protocol.types import (
+    LdpCapability,
+    LdpEnvelope,
+    LdpIdentityCard,
+    LdpMessageBody,
+    LdpSession,
+    NegotiatedPayload,
+    PayloadMode,
+    Provenance,
+    QualityMetrics,
+    SessionConfig,
+    SessionState,
+    TrustDomain,
+)
+from ldp_protocol.client import LdpClient
+from ldp_protocol.delegate import LdpDelegate
+from ldp_protocol.router import LdpRouter
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Types
+    "LdpIdentityCard",
+    "LdpCapability",
+    "QualityMetrics",
+    "TrustDomain",
+    "PayloadMode",
+    "NegotiatedPayload",
+    "SessionConfig",
+    "SessionState",
+    "LdpSession",
+    "LdpEnvelope",
+    "LdpMessageBody",
+    "Provenance",
+    # Client
+    "LdpClient",
+    # Delegate
+    "LdpDelegate",
+    # Router
+    "LdpRouter",
+]

ldp_protocol-0.1.0/src/ldp_protocol/client.py

@@ -0,0 +1,203 @@
+"""LDP HTTP client — discover delegates, manage sessions, submit tasks."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import uuid4
+
+import httpx
+
+from ldp_protocol.types.identity import LdpIdentityCard
+from ldp_protocol.types.messages import LdpEnvelope, LdpMessageBody
+from ldp_protocol.types.payload import PayloadMode, negotiate_payload_mode
+from ldp_protocol.types.provenance import Provenance
+from ldp_protocol.types.session import LdpSession, SessionConfig, SessionState
+from ldp_protocol.types.trust import TrustDomain
+
+
+class LdpClient:
+    """Async HTTP client for LDP protocol communication.
+
+    Handles discovery, session management, and task submission.
+
+    Usage:
+        async with LdpClient() as client:
+            identity = await client.discover("http://localhost:8090")
+            result = await client.submit_task(
+                "http://localhost:8090",
+                skill="reasoning",
+                input_data={"prompt": "Analyze..."},
+            )
+    """
+
+    def __init__(
+        self,
+        delegate_id: str = "ldp:client:default",
+        config: SessionConfig | None = None,
+        timeout: float = 30.0,
+    ):
+        self.delegate_id = delegate_id
+        self.config = config or SessionConfig()
+        self._http = httpx.AsyncClient(timeout=timeout)
+        self._sessions: dict[str, LdpSession] = {}
+
+    async def __aenter__(self) -> LdpClient:
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self._http.aclose()
+
+    async def discover(self, url: str) -> LdpIdentityCard:
+        """Fetch a delegate's identity card.
+
+        Args:
+            url: Base URL of the delegate (e.g., "http://localhost:8090").
+
+        Returns:
+            The delegate's identity card with full metadata.
+        """
+        endpoint = f"{url.rstrip('/')}/ldp/identity"
+        resp = await self._http.get(endpoint)
+        resp.raise_for_status()
+        return LdpIdentityCard.model_validate(resp.json())
+
+    async def send_message(self, url: str, envelope: LdpEnvelope) -> LdpEnvelope:
+        """Send an LDP message and receive a response."""
+        endpoint = f"{url.rstrip('/')}/ldp/messages"
+        resp = await self._http.post(
+            endpoint,
+            json=envelope.model_dump(by_alias=True),
+        )
+        resp.raise_for_status()
+        return LdpEnvelope.model_validate(resp.json())
+
+    async def establish_session(self, url: str) -> LdpSession:
+        """Establish a new LDP session with a delegate.
+
+        Performs the full handshake: HELLO -> CAPABILITY_MANIFEST ->
+        SESSION_PROPOSE -> SESSION_ACCEPT.
+        """
+        # Step 1: HELLO
+        hello = LdpEnvelope.create(
+            session_id="",
+            from_id=self.delegate_id,
+            to_id=url,
+            body=LdpMessageBody.hello(
+                delegate_id=self.delegate_id,
+                supported_modes=self.config.preferred_payload_modes,
+            ),
+        )
+        hello_resp = await self.send_message(url, hello)
+
+        # Step 2: SESSION_PROPOSE
+        session_id = str(uuid4())
+        propose = LdpEnvelope.create(
+            session_id=session_id,
+            from_id=self.delegate_id,
+            to_id=url,
+            body=LdpMessageBody.session_propose(
+                config={
+                    "preferred_payload_modes": [
+                        m.value for m in self.config.preferred_payload_modes
+                    ],
+                    "ttl_secs": self.config.ttl_secs,
+                }
+            ),
+        )
+        propose_resp = await self.send_message(url, propose)
+
+        if propose_resp.body.type == "SESSION_REJECT":
+            raise ConnectionError(
+                f"Session rejected: {propose_resp.body.reason}"
+            )
+
+        # Build session from response
+        negotiated_mode = propose_resp.body.negotiated_mode or PayloadMode.TEXT
+        identity = await self.discover(url)
+
+        session = LdpSession(
+            session_id=propose_resp.body.session_id or session_id,
+            remote_url=url,
+            remote_delegate_id=identity.delegate_id,
+            state=SessionState.ACTIVE,
+            trust_domain=identity.trust_domain,
+            ttl_secs=self.config.ttl_secs,
+        )
+        session.payload.mode = negotiated_mode
+
+        self._sessions[url] = session
+        return session
+
+    async def get_or_establish_session(self, url: str) -> LdpSession:
+        """Get an existing session or establish a new one."""
+        session = self._sessions.get(url)
+        if session and session.is_active:
+            return session
+        return await self.establish_session(url)
+
+    async def submit_task(
+        self,
+        url: str,
+        *,
+        skill: str,
+        input_data: Any,
+        session: LdpSession | None = None,
+    ) -> dict[str, Any]:
+        """Submit a task to a delegate and get the result.
+
+        Args:
+            url: Delegate URL.
+            skill: Skill to invoke.
+            input_data: Input data for the task.
+            session: Optional existing session (auto-establishes if None).
+
+        Returns:
+            Dict with 'output' and 'provenance' keys.
+        """
+        if session is None:
+            session = await self.get_or_establish_session(url)
+
+        task_id = str(uuid4())
+        submit = LdpEnvelope.create(
+            session_id=session.session_id,
+            from_id=self.delegate_id,
+            to_id=session.remote_delegate_id,
+            body=LdpMessageBody.task_submit(
+                task_id=task_id,
+                skill=skill,
+                input=input_data,
+            ),
+            payload_mode=session.payload.mode,
+        )
+
+        response = await self.send_message(url, submit)
+        session.touch()
+        session.task_count += 1
+
+        if response.body.type == "TASK_RESULT":
+            return {
+                "task_id": response.body.task_id,
+                "output": response.body.output,
+                "provenance": (
+                    response.body.provenance.model_dump()
+                    if response.body.provenance
+                    else None
+                ),
+            }
+        elif response.body.type == "TASK_FAILED":
+            raise RuntimeError(f"Task failed: {response.body.error}")
+        else:
+            return {
+                "task_id": task_id,
+                "status": response.body.type,
+                "message": response.body.message,
+            }
+
+    @property
+    def active_sessions(self) -> int:
+        """Number of active sessions."""
+        return sum(1 for s in self._sessions.values() if s.is_active)