agentmesh-platform 1.0.0a1__py3-none-any.whl

agentmesh/trust/handshake.py

@@ -0,0 +1,334 @@
+"""
+Trust Handshake
+
+IATP-compatible trust handshakes for cross-agent and cross-cloud
+communication. Handshake completes in <200ms.
+"""
+
+from datetime import datetime
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
+import hashlib
+import secrets
+import asyncio
+
+
+class HandshakeChallenge(BaseModel):
+    """Challenge issued during trust handshake."""
+    
+    challenge_id: str
+    nonce: str
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    expires_in_seconds: int = 30
+    
+    @classmethod
+    def generate(cls) -> "HandshakeChallenge":
+        """Generate a new challenge."""
+        return cls(
+            challenge_id=f"challenge_{secrets.token_hex(8)}",
+            nonce=secrets.token_hex(32),
+        )
+    
+    def is_expired(self) -> bool:
+        """Check if challenge has expired."""
+        elapsed = (datetime.utcnow() - self.timestamp).total_seconds()
+        return elapsed > self.expires_in_seconds
+
+
+class HandshakeResponse(BaseModel):
+    """Response to a handshake challenge."""
+    
+    challenge_id: str
+    response_nonce: str
+    
+    # Agent attestation
+    agent_did: str
+    capabilities: list[str] = Field(default_factory=list)
+    trust_score: int = Field(default=0, ge=0, le=1000)
+    
+    # Cryptographic proof
+    signature: str  # Signature over challenge + response
+    public_key: str  # For verification
+    
+    # Metadata
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+
+class HandshakeResult(BaseModel):
+    """Result of a trust handshake."""
+    
+    verified: bool
+    peer_did: str
+    peer_name: Optional[str] = None
+    
+    # Trust details
+    trust_score: int = Field(default=0, ge=0, le=1000)
+    trust_level: Literal["verified_partner", "trusted", "standard", "untrusted"] = "untrusted"
+    
+    # Capabilities
+    capabilities: list[str] = Field(default_factory=list)
+    
+    # Timing
+    handshake_started: datetime = Field(default_factory=datetime.utcnow)
+    handshake_completed: Optional[datetime] = None
+    latency_ms: Optional[int] = None
+    
+    # Rejection reason (if not verified)
+    rejection_reason: Optional[str] = None
+    
+    @classmethod
+    def success(
+        cls,
+        peer_did: str,
+        trust_score: int,
+        capabilities: list[str],
+        peer_name: Optional[str] = None,
+        started: Optional[datetime] = None,
+    ) -> "HandshakeResult":
+        """Create a successful handshake result."""
+        now = datetime.utcnow()
+        start = started or now
+        latency = int((now - start).total_seconds() * 1000)
+        
+        # Determine trust level
+        if trust_score >= 900:
+            level = "verified_partner"
+        elif trust_score >= 700:
+            level = "trusted"
+        elif trust_score >= 400:
+            level = "standard"
+        else:
+            level = "untrusted"
+        
+        return cls(
+            verified=True,
+            peer_did=peer_did,
+            peer_name=peer_name,
+            trust_score=trust_score,
+            trust_level=level,
+            capabilities=capabilities,
+            handshake_started=start,
+            handshake_completed=now,
+            latency_ms=latency,
+        )
+    
+    @classmethod
+    def failure(
+        cls,
+        peer_did: str,
+        reason: str,
+        started: Optional[datetime] = None,
+    ) -> "HandshakeResult":
+        """Create a failed handshake result."""
+        now = datetime.utcnow()
+        start = started or now
+        latency = int((now - start).total_seconds() * 1000)
+        
+        return cls(
+            verified=False,
+            peer_did=peer_did,
+            trust_score=0,
+            handshake_started=start,
+            handshake_completed=now,
+            latency_ms=latency,
+            rejection_reason=reason,
+        )
+
+
+class TrustHandshake:
+    """
+    Implements IATP trust handshakes.
+    
+    The handshake verifies:
+    1. Agent identity (via signature verification)
+    2. Trust score (from registry/Nexus)
+    3. Capabilities (attestation)
+    
+    Target: <200ms for cross-cloud handshakes.
+    """
+    
+    MAX_HANDSHAKE_MS = 200
+    
+    def __init__(self, agent_did: str):
+        self.agent_did = agent_did
+        self._pending_challenges: dict[str, HandshakeChallenge] = {}
+    
+    async def initiate(
+        self,
+        peer_did: str,
+        protocol: str = "iatp",
+        required_trust_score: int = 700,
+        required_capabilities: Optional[list[str]] = None,
+    ) -> HandshakeResult:
+        """
+        Initiate a trust handshake with a peer.
+        
+        Three-phase handshake:
+        1. Challenge: Send nonce to peer
+        2. Response: Peer signs nonce + attestation
+        3. Verification: Verify signature + trust score
+        """
+        start = datetime.utcnow()
+        
+        try:
+            # Phase 1: Generate and send challenge
+            challenge = HandshakeChallenge.generate()
+            self._pending_challenges[challenge.challenge_id] = challenge
+            
+            # Phase 2: Get response (would be async HTTP in production)
+            response = await self._get_peer_response(peer_did, challenge)
+            
+            if not response:
+                return HandshakeResult.failure(
+                    peer_did, "No response from peer", start
+                )
+            
+            # Phase 3: Verify response
+            verification = await self._verify_response(
+                response, challenge, required_trust_score, required_capabilities
+            )
+            
+            if not verification["valid"]:
+                return HandshakeResult.failure(
+                    peer_did, verification["reason"], start
+                )
+            
+            return HandshakeResult.success(
+                peer_did=peer_did,
+                trust_score=response.trust_score,
+                capabilities=response.capabilities,
+                started=start,
+            )
+            
+        except asyncio.TimeoutError:
+            return HandshakeResult.failure(
+                peer_did, "Handshake timeout", start
+            )
+        except Exception as e:
+            return HandshakeResult.failure(
+                peer_did, f"Handshake error: {str(e)}", start
+            )
+        finally:
+            # Cleanup
+            if challenge.challenge_id in self._pending_challenges:
+                del self._pending_challenges[challenge.challenge_id]
+    
+    async def respond(
+        self,
+        challenge: HandshakeChallenge,
+        my_capabilities: list[str],
+        my_trust_score: int,
+        private_key: any,  # Ed25519 private key
+    ) -> HandshakeResponse:
+        """
+        Respond to a trust handshake challenge.
+        
+        Signs the challenge with our private key and attests capabilities.
+        """
+        # Check challenge not expired
+        if challenge.is_expired():
+            raise ValueError("Challenge expired")
+        
+        # Generate response nonce
+        response_nonce = secrets.token_hex(16)
+        
+        # Create signature payload
+        payload = f"{challenge.challenge_id}:{challenge.nonce}:{response_nonce}:{self.agent_did}"
+        
+        # Sign (would use actual Ed25519 in production)
+        signature = hashlib.sha256(payload.encode()).hexdigest()
+        
+        return HandshakeResponse(
+            challenge_id=challenge.challenge_id,
+            response_nonce=response_nonce,
+            agent_did=self.agent_did,
+            capabilities=my_capabilities,
+            trust_score=my_trust_score,
+            signature=signature,
+            public_key="placeholder_public_key",
+        )
+    
+    async def _get_peer_response(
+        self,
+        peer_did: str,
+        challenge: HandshakeChallenge,
+    ) -> Optional[HandshakeResponse]:
+        """
+        Send challenge to peer and get response.
+        
+        In production, this would:
+        1. Resolve peer DID to endpoint
+        2. POST challenge to peer's IATP endpoint
+        3. Receive and parse response
+        """
+        # Simulate peer response for now
+        # In production, would make HTTP request to peer
+        await asyncio.sleep(0.05)  # Simulate network latency
+        
+        return HandshakeResponse(
+            challenge_id=challenge.challenge_id,
+            response_nonce=secrets.token_hex(16),
+            agent_did=peer_did,
+            capabilities=["read:data", "write:reports"],
+            trust_score=750,
+            signature="simulated_signature",
+            public_key="simulated_public_key",
+        )
+    
+    async def _verify_response(
+        self,
+        response: HandshakeResponse,
+        challenge: HandshakeChallenge,
+        required_score: int,
+        required_capabilities: Optional[list[str]],
+    ) -> dict:
+        """
+        Verify a handshake response.
+        
+        Checks:
+        1. Challenge ID matches
+        2. Signature is valid
+        3. Trust score meets threshold
+        4. Required capabilities present
+        """
+        # Verify challenge ID
+        if response.challenge_id != challenge.challenge_id:
+            return {"valid": False, "reason": "Challenge ID mismatch"}
+        
+        # Verify not expired
+        if challenge.is_expired():
+            return {"valid": False, "reason": "Challenge expired"}
+        
+        # Verify signature (simplified - would verify Ed25519 in production)
+        # In production: verify response.signature against response.public_key
+        
+        # Verify trust score
+        if response.trust_score < required_score:
+            return {
+                "valid": False,
+                "reason": f"Trust score {response.trust_score} below required {required_score}"
+            }
+        
+        # Verify capabilities
+        if required_capabilities:
+            missing = set(required_capabilities) - set(response.capabilities)
+            if missing:
+                return {
+                    "valid": False,
+                    "reason": f"Missing capabilities: {missing}"
+                }
+        
+        return {"valid": True, "reason": None}
+    
+    def create_challenge(self) -> HandshakeChallenge:
+        """Create a new challenge for incoming handshake."""
+        challenge = HandshakeChallenge.generate()
+        self._pending_challenges[challenge.challenge_id] = challenge
+        return challenge
+    
+    def validate_challenge(self, challenge_id: str) -> bool:
+        """Check if a challenge ID is valid and pending."""
+        challenge = self._pending_challenges.get(challenge_id)
+        if not challenge:
+            return False
+        return not challenge.is_expired()

agentmesh_platform-1.0.0a1.dist-info/METADATA

@@ -0,0 +1,332 @@
+Metadata-Version: 2.4
+Name: agentmesh-platform
+Version: 1.0.0a1
+Summary: The Secure Nervous System for Cloud-Native Agent Ecosystems - Identity, Trust, Reward, Governance
+Project-URL: Homepage, https://github.com/imran-siddique/agent-mesh
+Project-URL: Documentation, https://github.com/imran-siddique/agent-mesh#readme
+Project-URL: Repository, https://github.com/imran-siddique/agent-mesh
+Project-URL: Issues, https://github.com/imran-siddique/agent-mesh/issues
+Project-URL: Changelog, https://github.com/imran-siddique/agent-mesh/blob/master/CHANGELOG.md
+Author-email: Imran Siddique <imran.siddique@microsoft.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: a2a,agents,ai,compliance,eu-ai-act,governance,hipaa,iatp,identity,mcp,security,soc2,trust,zero-trust
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration :: Authentication/Directory
+Requires-Python: >=3.11
+Requires-Dist: agent-os-kernel[iatp,nexus]>=1.2.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pynacl>=1.5.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: structlog>=24.1.0
+Provides-Extra: dev
+Requires-Dist: black>=24.1.0; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.109.0; extra == 'server'
+Requires-Dist: uvicorn[standard]>=0.27.0; extra == 'server'
+Description-Content-Type: text/markdown
+
+# AgentMesh
+
+**The Secure Nervous System for Cloud-Native Agent Ecosystems**
+
+*Identity · Trust · Reward · Governance*
+
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.11+-blue.svg)](https://python.org)
+
+---
+
+## Overview
+
+AgentMesh is the first platform purpose-built for the **Governed Agent Mesh** — the cloud-native, multi-vendor network of AI agents that will define enterprise operations.
+
+The protocols exist (A2A, MCP, IATP). The agents are shipping. **The trust layer does not.** AgentMesh fills that gap.
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           AGENTMESH ARCHITECTURE                            │
+├─────────────────────────────────────────────────────────────────────────────┤
+│  LAYER 4  │  Reward & Learning Engine                                       │
+│           │  Per-agent trust scores · Multi-dimensional rewards · Adaptive  │
+├───────────┼─────────────────────────────────────────────────────────────────┤
+│  LAYER 3  │  Governance & Compliance Plane                                  │
+│           │  Policy engine · EU AI Act / SOC2 / HIPAA · Merkle audit logs   │
+├───────────┼─────────────────────────────────────────────────────────────────┤
+│  LAYER 2  │  Trust & Protocol Bridge                                        │
+│           │  A2A · MCP · IATP · Protocol translation · Capability scoping   │
+├───────────┼─────────────────────────────────────────────────────────────────┤
+│  LAYER 1  │  Identity & Zero-Trust Core                                     │
+│           │  Agent CA · Ephemeral creds · SPIFFE/SVID · Human sponsors      │
+└───────────┴─────────────────────────────────────────────────────────────────┘
+```
+
+## Why AgentMesh?
+
+### The Problem
+
+- **40:1 to 100:1** — Non-human identities now outnumber human identities in enterprises
+- **AI agents** are the fastest-growing, least-governed identity category
+- **A2A gives agents a common language. MCP gives agents tools. Neither enforces trust.**
+
+### The Solution
+
+AgentMesh provides:
+
+| Capability | Description |
+|------------|-------------|
+| **Agent Identity** | First-class identity with human sponsor accountability |
+| **Ephemeral Credentials** | 15-minute TTL by default, auto-rotation |
+| **Protocol Bridge** | Native A2A, MCP, IATP with unified trust model |
+| **Reward Engine** | Continuous behavioral scoring, not static rules |
+| **Compliance Automation** | EU AI Act, SOC 2, HIPAA, GDPR mapping |
+
+## Quick Start
+
+```bash
+# Install AgentMesh CLI
+pip install agentmesh
+
+# Initialize a governed agent in 30 seconds
+agentmesh init --name my-agent --sponsor alice@company.com
+
+# Register with the mesh
+agentmesh register
+
+# Start with governance enabled
+agentmesh run
+```
+
+## Installation
+
+```bash
+pip install agentmesh
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/imran-siddique/agent-mesh.git
+cd agent-mesh
+pip install -e .
+```
+
+## Core Concepts
+
+### 1. Agent Identity
+
+Every agent gets a unique, cryptographically bound identity:
+
+```python
+from agentmesh import AgentIdentity
+
+identity = AgentIdentity.create(
+    name="data-analyst-agent",
+    sponsor="alice@company.com",  # Human accountability
+    capabilities=["read:data", "write:reports"],
+)
+```
+
+### 2. Delegation Chains
+
+Agents can delegate to sub-agents, but scope **always narrows**:
+
+```python
+# Parent agent delegates to child
+child_identity = parent_identity.delegate(
+    name="summarizer-subagent",
+    capabilities=["read:data"],  # Subset of parent's capabilities
+)
+```
+
+### 3. Trust Handshakes (IATP)
+
+Cross-agent communication requires trust verification:
+
+```python
+from agentmesh import TrustBridge
+
+bridge = TrustBridge()
+
+# Verify peer before communication
+verification = await bridge.verify_peer(
+    peer_id="did:mesh:other-agent",
+    required_trust_score=700,
+)
+
+if verification.verified:
+    await bridge.send_message(peer_id, message)
+```
+
+### 4. Reward Scoring
+
+Every action is scored across multiple dimensions:
+
+```python
+from agentmesh import RewardEngine
+
+engine = RewardEngine()
+
+# Actions are automatically scored
+score = engine.get_agent_score("did:mesh:my-agent")
+# {
+#   "total": 847,
+#   "dimensions": {
+#     "policy_compliance": 95,
+#     "resource_efficiency": 82,
+#     "output_quality": 88,
+#     "security_posture": 91,
+#     "collaboration_health": 84
+#   }
+# }
+```
+
+### 5. Policy Engine
+
+Declarative governance policies:
+
+```yaml
+# policy.yaml
+version: "1.0"
+agent: "data-analyst-agent"
+
+rules:
+  - name: "no-pii-export"
+    condition: "action.type == 'export' and data.contains_pii"
+    action: "deny"
+    
+  - name: "rate-limit-api"
+    condition: "action.type == 'api_call'"
+    limit: "100/hour"
+    
+  - name: "require-approval-for-delete"
+    condition: "action.type == 'delete'"
+    action: "require_approval"
+    approvers: ["security-team"]
+```
+
+## Protocol Support
+
+| Protocol | Status | Description |
+|----------|--------|-------------|
+| A2A | ✅ Alpha | Agent-to-agent coordination |
+| MCP | ✅ Alpha | Tool and resource binding |
+| IATP | ✅ Alpha | Trust handshakes (via agent-os) |
+| ACP | 🔄 Beta | Lightweight messaging |
+| SPIFFE | ✅ Alpha | Workload identity |
+
+## Architecture
+
+```
+agentmesh/
+├── identity/           # Layer 1: Identity & Zero-Trust
+│   ├── agent_id.py     # Agent identity management
+│   ├── credentials.py  # Ephemeral credential issuance
+│   ├── delegation.py   # Delegation chains
+│   └── spiffe.py       # SPIFFE/SVID integration
+│
+├── trust/              # Layer 2: Trust & Protocol Bridge
+│   ├── bridge.py       # Protocol bridge
+│   ├── handshake.py    # Trust handshakes
+│   └── capability.py   # Capability scoping
+│
+├── protocols/          # Protocol implementations
+│   ├── a2a/            # A2A support
+│   ├── mcp/            # MCP support
+│   └── iatp/           # IATP (uses agent-os)
+│
+├── governance/         # Layer 3: Governance & Compliance
+│   ├── policy.py       # Policy engine
+│   ├── compliance.py   # Compliance mapping
+│   ├── audit.py        # Merkle-chained audit logs
+│   └── shadow.py       # Shadow mode
+│
+├── reward/             # Layer 4: Reward & Learning
+│   ├── engine.py       # Reward engine
+│   ├── scoring.py      # Multi-dimensional scoring
+│   └── learning.py     # Adaptive learning
+│
+├── cli/                # Command-line interface
+└── sdk/                # Python SDK
+```
+
+## Compliance
+
+AgentMesh automates compliance mapping for:
+
+- **EU AI Act** — Risk classification, transparency requirements
+- **SOC 2** — Security, availability, processing integrity
+- **HIPAA** — PHI handling, audit controls
+- **GDPR** — Data processing, consent, right to explanation
+
+```python
+from agentmesh import ComplianceEngine
+
+compliance = ComplianceEngine(frameworks=["soc2", "hipaa"])
+
+# Generate compliance report
+report = compliance.generate_report(
+    agent_id="did:mesh:healthcare-agent",
+    period="2026-01",
+)
+```
+
+## Threat Model
+
+| Threat | AgentMesh Defense |
+|--------|-------------------|
+| Prompt Injection | Tool output sanitized at Protocol Bridge |
+| Credential Theft | 15-min TTL, instant revocation on trust breach |
+| Shadow Agents | Unregistered agents blocked at network layer |
+| Delegation Escalation | Chains are cryptographically narrowing |
+| Cascade Failure | Per-agent trust scoring isolates blast radius |
+
+## Roadmap
+
+| Phase | Timeline | Deliverables |
+|-------|----------|--------------|
+| Alpha | Q1 2026 | Identity Core, A2A+MCP bridge, CLI |
+| Beta | Q2 2026 | IATP handshake, Reward Engine v1, Dashboard |
+| GA | Q3 2026 | Compliance automation, Enterprise features |
+| Scale | Q4 2026 | Agent Marketplace, Partner integrations |
+
+## Dependencies
+
+AgentMesh builds on:
+
+- **[agent-os](https://github.com/imran-siddique/agent-os)** — IATP protocol, Nexus trust exchange
+- **SPIFFE/SPIRE** — Workload identity
+- **OpenTelemetry** — Observability
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+Apache 2.0 — See [LICENSE](LICENSE) for details.
+
+---
+
+**Agents shouldn't be islands. But they also shouldn't be ungoverned.**
+
+*AgentMesh is the trust layer that makes the mesh safe enough to scale.*

agentmesh_platform-1.0.0a1.dist-info/RECORD

@@ -0,0 +1,28 @@
+agentmesh/__init__.py,sha256=kZu_8m1IuUu24dS4O7Ba-Dfr3vaPqd6zH3dez1gZBUk,2414
+agentmesh/cli/__init__.py,sha256=mwZuqtifIxKGbSy3p_0hhuGdxb1kttg7b84c9kfUAkk,208
+agentmesh/cli/main.py,sha256=xTZ6TTQ_yQGzw6T2YiyAjtDsA5hLfPVzoRuJodbs8wY,13209
+agentmesh/governance/__init__.py,sha256=WL3JiY-wwnZCMHLfl0eA4o11vfeXvvZ7OAL4J6-mvJY,702
+agentmesh/governance/audit.py,sha256=T85ToKmoyUoYsBDLHHddQHOzg8osbPtM3CEC_ufH2PU,11795
+agentmesh/governance/compliance.py,sha256=LIAQt0jy2UuoN6K9oMMJKMEpTCAqYguGYGzZvbRkE6Q,15843
+agentmesh/governance/policy.py,sha256=5rkDf6UVmomQZTUabjDwzGL9XHjvw6w_kw60GrfOR9g,12412
+agentmesh/governance/shadow.py,sha256=Mw20pjq1ew6VBcRd7eXCRpoU5zElGcazwhksQxEcI38,9085
+agentmesh/identity/__init__.py,sha256=xQFwY-C5e35VF61oSOKgzJMTqTWv-VUArej74G8HFU8,748
+agentmesh/identity/agent_id.py,sha256=iCIPCpBRsiCyFjT2rFwxZgYfgTxGYstnX8EQfIk6Sjg,11657
+agentmesh/identity/credentials.py,sha256=yksJbQAzBBwiacOu-Wl7Pg1diNxX68_sjlUCyVtPvp8,11458
+agentmesh/identity/delegation.py,sha256=t74Ly9SHqY_4Y8pRTjgPycfayr2_iMQ5oIfLbLYVkYY,10441
+agentmesh/identity/risk.py,sha256=Fb531ECeKA5RfCUFAQS9Qd4qiqPeXuDexBT19m0uO_Q,9749
+agentmesh/identity/spiffe.py,sha256=f7HzeD13WGzxYVoJDaQwmWW_cZ2qi5D6IVroRJhNvn0,7426
+agentmesh/identity/sponsor.py,sha256=93WaV2U3Db2mGNUHOWKg15uiuni2U4XZV_BfHqq7urw,6195
+agentmesh/reward/__init__.py,sha256=Rf0f9NMN1_oEuNUjolzciifnj7navvsuGnF5-3ja4co,471
+agentmesh/reward/engine.py,sha256=M2AiwcS2EN-AcgjPeyx-N3CNG-jlr15ybChVTr6xLEg,16528
+agentmesh/reward/learning.py,sha256=vmEQFYYXDwQE551cOK5Ylnp8arIdClKr4wTxMTHikt0,9408
+agentmesh/reward/scoring.py,sha256=13yUExcnC_oWlyO--mEfOx96EHUNQuqDeHqpVyLas5w,6269
+agentmesh/trust/__init__.py,sha256=Xs0LwlFdX94rP1UPYzwi_ObaPAc2M-WgKw0vqGHU_Wg,489
+agentmesh/trust/bridge.py,sha256=KDQW4nXTYmv2cqtvmFyguWknaNWPX7VYcbozSNgJkvI,12596
+agentmesh/trust/capability.py,sha256=1Esvk43GeMcxWVt6ewkgNHARxAiVUwDuXp44E_3Fmok,9670
+agentmesh/trust/handshake.py,sha256=na8obvrL1hJDy45H3NJaXSpiWOqouIG4GFNl5RLEf6Y,10988
+agentmesh_platform-1.0.0a1.dist-info/METADATA,sha256=J7GjTxBAXKznYOMMOXzB4n00XN1T20PabiW0WxINtow,11623
+agentmesh_platform-1.0.0a1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+agentmesh_platform-1.0.0a1.dist-info/entry_points.txt,sha256=uncSoKr8tqS-QEJJh7fIOvnGp2lnvgbulztvV_5t27E,54
+agentmesh_platform-1.0.0a1.dist-info/licenses/LICENSE,sha256=sIkoGVzkakz4LseiSYurIlLFlmPKfOkCtqyDQOZh6Ww,10953
+agentmesh_platform-1.0.0a1.dist-info/RECORD,,

agentmesh_platform-1.0.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentmesh_platform-1.0.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentmesh = agentmesh.cli.main:main