beekkon-bridge 1.0.0__tar.gz

beekkon_bridge-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BeekKon Team
+
+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.

beekkon_bridge-1.0.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: beekkon-bridge
+Version: 1.0.0
+Summary: Secure communication protocol for AI agents - The TCP/IP for the post-AI era
+Author-email: erabytse <contact@fbfconsulting.org>
+Maintainer-email: erabytse <contact@fbfconsulting.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/erabytse/BeekKon-Bridge
+Project-URL: Repository, https://github.com/erabytse/BeekKon-Bridge
+Project-URL: Issues, https://github.com/erabytse/BeekKon-Bridge/issues
+Keywords: ai,agents,protocol,p2p,encryption,zero-knowledge
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyNaCl>=1.5.0
+Requires-Dist: msgpack>=1.0.5
+Dynamic: license-file
+
+<div align="center">
+<img src="logo.png" alt="BKB">
+
+<strong><p><h3>The Protocol for AI Agents - Secure communication protocol for the
+post-AI era.</h3></p></strong>
+
+</div>
+
+## 🎯 What is BeekKon-Bridge?
+
+BeekKon Bridge is a peer-to-peer communication protocol designed specifically for AI agents. It provides:
+
+- 🔐 **Zero-knowledge authentication** (based on CryptoLogin V2)
+- 🔒 **End-to-end encryption** (AES-256-GCM via Curve25519)
+- ✍️ **Message signatures** (Ed25519)
+- 🔍 **Automatic peer discovery** (UDP broadcast)
+- 🤖 **Simple high-level API** (5 lines of code)
+
+## 🚀 Quick Start
+
+### Install
+
+```bash
+pip install beekon-bridge
+```
+
+## Create an Agent
+
+```python
+from beekkon import BeekKonAgent
+
+# Create agent
+agent = BeekKonAgent(
+    name="my_agent",
+    secret="my-super-secret-key-1234567890",  # min 32 chars
+    capabilities=["parse_data", "generate_report"]
+)
+
+# Register handler
+@agent.handler("process_request")
+async def handle_request(data):
+    return {"result": "processed", "input": data}
+
+# Start agent
+agent.start()
+```
+
+## Request Another Agent
+
+```python
+from beekkon import BeekKonAgent
+
+agent = BeekKonAgent(
+    name="client_agent",
+    secret="client-secret-0987654321",
+    capabilities=[]
+)
+
+agent.start(blocking=False)
+
+# Send request
+response = agent.request(
+    target="my_agent",
+    task="process_request",
+    data={"value": 42}
+)
+
+print(response)  # {'success': True, 'data': {'result': 'processed', ...}}
+```
+
+## 🎬 Real-World Example: 3-Agent Workflow
+
+See the `examples/` folder for a complete workflow with 3 specialized agents:
+
+- **CRM Officer** (`agent_crm.py`): Client relationship management
+- **Legal Officer** (`agent_juridique.py`): Contract validation & compliance
+- **Accounting Clerk** (`agent_comptable.py`): Invoice generation & VAT calculation
+
+### Run the demo
+
+```bash
+# Terminal 1: Start Accounting Clerk
+python examples/agent_comptable.py
+
+# Terminal 2: Start Legal Officer
+python examples/agent_juridique.py
+
+# Terminal 3: Start CRM Officer
+python examples/agent_crm.py
+
+# Terminal 4: Trigger workflow
+python examples/run_workflow.py
+```
+
+### What happens
+
+1. Client requests onboarding via CRM
+2. CRM asks Legal to validate the contract
+3. Legal validates and stores contract in shared memory
+4. CRM asks Accounting to generate invoice
+5. Accounting retrieves contract, calculates VAT, issues invoice
+6. CRM validates payment
+7. Workflow completes ✅
+
+## 🔐 Security Model
+
+- Zero-knowledge: Server never stores master secrets, only derived user_ids
+- E2E encryption: All messages encrypted with AES-256-GCM
+- Forward secrecy: Session keys derived via Curve25519 Diffie-Hellman
+- Message integrity: Ed25519 signatures on all messages
+- Local-first: No cloud, no central server, 100% P2P
+
+## 📊 Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                  BeekKonAgent (API)                 │
+│  - agent.start()                                    │
+│  - agent.request(target, task, data)                │
+│  - @agent.handler("task")                           │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│              BeekKonDiscovery (UDP)                 │
+│  - Automatic peer discovery                         │
+│  - Capability-based filtering                       │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│              BeekKonProtocol (TCP)                  │
+│  - Handshake (zero-knowledge auth)                  │
+│  - Encrypted communication (AES-256-GCM)            │
+│  - Request/Response pattern                         │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│                BeekKonAuth (Crypto)                 │
+│  - Ed25519 signatures                               │
+│  - Curve25519 key exchange                          │
+│  - PBKDF2-HMAC-SHA512 key derivation                │
+└─────────────────────────────────────────────────────┘
+```
+
+## 🧪 Tests
+
+```bash
+pytest tests/ -v
+# 36 tests passed
+```
+
+## 📄 License
+
+MIT License - See LICENSE file for details.
+
+## 🤝 Contributing
+
+Contributions welcome! Please read CONTRIBUTING.md for guidelines.
+
+## 📧 Contact
+
+GitHub: https://github.com/erabytse/BeekKon-Bridge
+
+Issues: https://github.com/erabytse/BeekKon-Bridge/issues

beekkon_bridge-1.0.0/README.md

@@ -0,0 +1,163 @@
+<div align="center">
+<img src="logo.png" alt="BKB">
+
+<strong><p><h3>The Protocol for AI Agents - Secure communication protocol for the
+post-AI era.</h3></p></strong>
+
+</div>
+
+## 🎯 What is BeekKon-Bridge?
+
+BeekKon Bridge is a peer-to-peer communication protocol designed specifically for AI agents. It provides:
+
+- 🔐 **Zero-knowledge authentication** (based on CryptoLogin V2)
+- 🔒 **End-to-end encryption** (AES-256-GCM via Curve25519)
+- ✍️ **Message signatures** (Ed25519)
+- 🔍 **Automatic peer discovery** (UDP broadcast)
+- 🤖 **Simple high-level API** (5 lines of code)
+
+## 🚀 Quick Start
+
+### Install
+
+```bash
+pip install beekon-bridge
+```
+
+## Create an Agent
+
+```python
+from beekkon import BeekKonAgent
+
+# Create agent
+agent = BeekKonAgent(
+    name="my_agent",
+    secret="my-super-secret-key-1234567890",  # min 32 chars
+    capabilities=["parse_data", "generate_report"]
+)
+
+# Register handler
+@agent.handler("process_request")
+async def handle_request(data):
+    return {"result": "processed", "input": data}
+
+# Start agent
+agent.start()
+```
+
+## Request Another Agent
+
+```python
+from beekkon import BeekKonAgent
+
+agent = BeekKonAgent(
+    name="client_agent",
+    secret="client-secret-0987654321",
+    capabilities=[]
+)
+
+agent.start(blocking=False)
+
+# Send request
+response = agent.request(
+    target="my_agent",
+    task="process_request",
+    data={"value": 42}
+)
+
+print(response)  # {'success': True, 'data': {'result': 'processed', ...}}
+```
+
+## 🎬 Real-World Example: 3-Agent Workflow
+
+See the `examples/` folder for a complete workflow with 3 specialized agents:
+
+- **CRM Officer** (`agent_crm.py`): Client relationship management
+- **Legal Officer** (`agent_juridique.py`): Contract validation & compliance
+- **Accounting Clerk** (`agent_comptable.py`): Invoice generation & VAT calculation
+
+### Run the demo
+
+```bash
+# Terminal 1: Start Accounting Clerk
+python examples/agent_comptable.py
+
+# Terminal 2: Start Legal Officer
+python examples/agent_juridique.py
+
+# Terminal 3: Start CRM Officer
+python examples/agent_crm.py
+
+# Terminal 4: Trigger workflow
+python examples/run_workflow.py
+```
+
+### What happens
+
+1. Client requests onboarding via CRM
+2. CRM asks Legal to validate the contract
+3. Legal validates and stores contract in shared memory
+4. CRM asks Accounting to generate invoice
+5. Accounting retrieves contract, calculates VAT, issues invoice
+6. CRM validates payment
+7. Workflow completes ✅
+
+## 🔐 Security Model
+
+- Zero-knowledge: Server never stores master secrets, only derived user_ids
+- E2E encryption: All messages encrypted with AES-256-GCM
+- Forward secrecy: Session keys derived via Curve25519 Diffie-Hellman
+- Message integrity: Ed25519 signatures on all messages
+- Local-first: No cloud, no central server, 100% P2P
+
+## 📊 Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                  BeekKonAgent (API)                 │
+│  - agent.start()                                    │
+│  - agent.request(target, task, data)                │
+│  - @agent.handler("task")                           │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│              BeekKonDiscovery (UDP)                 │
+│  - Automatic peer discovery                         │
+│  - Capability-based filtering                       │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│              BeekKonProtocol (TCP)                  │
+│  - Handshake (zero-knowledge auth)                  │
+│  - Encrypted communication (AES-256-GCM)            │
+│  - Request/Response pattern                         │
+└─────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────┐
+│                BeekKonAuth (Crypto)                 │
+│  - Ed25519 signatures                               │
+│  - Curve25519 key exchange                          │
+│  - PBKDF2-HMAC-SHA512 key derivation                │
+└─────────────────────────────────────────────────────┘
+```
+
+## 🧪 Tests
+
+```bash
+pytest tests/ -v
+# 36 tests passed
+```
+
+## 📄 License
+
+MIT License - See LICENSE file for details.
+
+## 🤝 Contributing
+
+Contributions welcome! Please read CONTRIBUTING.md for guidelines.
+
+## 📧 Contact
+
+GitHub: https://github.com/erabytse/BeekKon-Bridge
+
+Issues: https://github.com/erabytse/BeekKon-Bridge/issues

beekkon_bridge-1.0.0/beekkon/__init__.py

@@ -0,0 +1,34 @@
+"""
+BeekKon Bridge - Secure communication protocol for AI agents
+The TCP/IP for the post-AI era
+"""
+
+__version__ = "1.0.0"
+__author__ = "BeekKon Team"
+
+from .auth import BeekKonAuth
+from .discovery import BeekKonDiscovery, PeerInfo
+from .models import BeekKonMessage, MessageType
+from .protocol import BeekKonProtocol, BeekKonServer
+from .agent import BeekKonAgent
+from .crypto import BeekKonCrypto
+from .memory import BeekKonMemory, MemoryEntry
+from .router import BeekKonRouter, Route
+from .api import BeekKonAPI
+
+__all__ = [
+    "BeekKonAuth",
+    "BeekKonDiscovery",
+    "PeerInfo",
+    "BeekKonMessage",
+    "MessageType",
+    "BeekKonProtocol",
+    "BeekKonServer",
+    "BeekKonAgent",
+    "BeekKonCrypto",
+    "BeekKonMemory",
+    "MemoryEntry",
+    "BeekKonRouter",
+    "Route",
+    "BeekKonAPI"
+]

beekkon_bridge-1.0.0/beekkon/agent.py

@@ -0,0 +1,247 @@
+"""
+BeekKon Bridge - High-Level Agent API
+Simple interface for creating AI agents with automatic discovery, authentication, and communication
+"""
+
+import asyncio
+import threading
+import time
+from typing import Dict, List, Callable, Any, Optional
+from .auth import BeekKonAuth
+from .discovery import BeekKonDiscovery, PeerInfo
+from .protocol import BeekKonProtocol, BeekKonServer
+from .models import BeekKonMessage
+
+
+class BeekKonAgent:
+    """
+    High-level API for creating AI agents
+    
+    Example:
+        agent = BeekKonAgent(
+            name="agent_comptable",
+            secret="my-super-secret-12345678901234567890",
+            capabilities=["parse_invoice", "calculate_vat"]
+        )
+        
+        @agent.handler("validate_contract")
+        async def handle_validation(data):
+            return {"status": "approved"}
+        
+        agent.start()  # Starts discovery, auth, and listening
+    """
+    
+    def __init__(
+        self,
+        name: str,
+        secret: str,
+        capabilities: List[str],
+        port: int = 8765,
+        host: str = "0.0.0.0"
+    ):
+        """
+        Initialize a BeekKon agent
+        
+        Args:
+            name: Agent name (public identifier)
+            secret: Master secret (min 32 chars, NEVER share)
+            capabilities: List of agent capabilities
+            port: Port to listen on
+            host: Host to bind to
+        """
+        self.name = name
+        self.secret = secret
+        self.capabilities = capabilities
+        self.port = port
+        self.host = host
+        
+        # Initialize components
+        self.auth = BeekKonAuth(name, secret)
+        self.discovery = BeekKonDiscovery(
+            agent_id=name,
+            capabilities=capabilities,
+            port=port,
+            public_key_sign=self.auth.verify_key.encode().hex(),
+            public_key_exchange=self.auth.public_key.encode().hex()
+        )
+        self.server = BeekKonServer(self.auth, host=host, port=port)
+        
+        # State
+        self.handlers: Dict[str, Callable] = {}
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self.connections: Dict[str, BeekKonProtocol] = {}
+    
+    def authorize_agent(self, agent_name: str, agent_secret: str) -> None:
+        """
+        Authorize a remote agent (server-side only)
+        Call this before start() for each agent you want to accept
+        
+        Args:
+            agent_name: Remote agent's name
+            agent_secret: Remote agent's master secret (used to derive user_id)
+        """
+        temp_auth = BeekKonAuth(agent_name, agent_secret)
+        self.auth.add_authorized_agent(agent_name, temp_auth.user_id)
+    
+    def handler(self, task_name: str):
+        """
+        Decorator to register a handler for a task
+        
+        Example:
+            @agent.handler("parse_invoice")
+            async def handle_parse(data):
+                return {"result": "parsed"}
+        """
+        def decorator(func: Callable):
+            self.handlers[task_name] = func
+            return func
+        return decorator
+    
+    async def _handle_connection(self, protocol: BeekKonProtocol):
+        """Handle a new incoming connection"""
+        peer_id = protocol.peer_agent_id
+        self.connections[peer_id] = protocol
+        
+        # Register request handler
+        async def handle_request(msg):
+            task = msg.payload.get("task")
+            data = msg.payload.get("data", {})
+            
+            handler = self.handlers.get(task)
+            if handler:
+                try:
+                    result = await handler(data) if asyncio.iscoroutinefunction(handler) else handler(data)
+                    await protocol.send_response(
+                        request_id=msg.id,
+                        success=True,
+                        data=result if isinstance(result, dict) else {"result": result}
+                    )
+                except Exception as e:
+                    await protocol.send_response(
+                        request_id=msg.id,
+                        success=False,
+                        error=str(e)
+                    )
+            else:
+                await protocol.send_response(
+                    request_id=msg.id,
+                    success=False,
+                    error=f"Unknown task: {task}"
+                )
+        
+        protocol.register_handler("request", handle_request)
+        
+        # Start listening
+        await protocol.listen()
+    
+    async def _run_async(self):
+        """Async main loop"""
+        self._loop = asyncio.get_running_loop()
+        
+        # Register connection handler
+        self.server.on_connection(self._handle_connection)
+        
+        # Start server
+        await self.server.start()
+        
+        # Start discovery
+        self.discovery.start()
+        
+        print(f"🤖 Agent '{self.name}' started")
+        print(f"   Capabilities: {self.capabilities}")
+        print(f"   Port: {self.port}")
+        
+        # Keep running
+        while self._running:
+            await asyncio.sleep(0.1)
+        
+        # Cleanup
+        self.discovery.stop()
+        await self.server.stop()
+    
+    def start(self, blocking: bool = True):
+        """
+        Start the agent
+        
+        Args:
+            blocking: If True, blocks the main thread. If False, runs in background thread.
+        """
+        self._running = True
+        
+        if blocking:
+            asyncio.run(self._run_async())
+        else:
+            self._thread = threading.Thread(target=self._run_in_thread, daemon=True)
+            self._thread.start()
+            time.sleep(0.5)  # Wait for startup
+    
+    def _run_in_thread(self):
+        """Run async loop in background thread"""
+        asyncio.run(self._run_async())
+    
+    def stop(self):
+        """Stop the agent"""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+    
+    def get_peers(self, capability: Optional[str] = None) -> List[PeerInfo]:
+        """Get discovered peers"""
+        return self.discovery.get_peers(capability=capability)
+    
+    async def _request_async(self, target: str, task: str, data: Dict[str, Any], timeout: float = 30.0) -> Dict[str, Any]:
+        """Async request to another agent"""
+        peer = self.discovery.get_peer(target)
+        if not peer:
+            raise ValueError(f"Peer '{target}' not found")
+        
+        protocol = BeekKonProtocol(self.auth)
+        listen_task = None
+        
+        try:
+            # Connect to peer
+            success = await protocol.connect(peer.ip, peer.port)
+            if not success:
+                raise ConnectionError(f"Failed to connect to {target}")
+            
+            # CRITICAL: Start listening in background to receive the response
+            listen_task = asyncio.create_task(protocol.listen())
+            await asyncio.sleep(0.1)  # Let listen() start
+            
+            # Send request and wait for response
+            response = await protocol.send_request(target, task, data, timeout)
+            return response.payload
+        
+        finally:
+            # Cleanup
+            if listen_task:
+                listen_task.cancel()
+                try:
+                    await listen_task
+                except asyncio.CancelledError:
+                    pass
+            await protocol.close()
+    
+    def request(self, target: str, task: str, data: Dict[str, Any], timeout: float = 30.0) -> Dict[str, Any]:
+        """
+        Send a request to another agent (synchronous)
+        
+        Args:
+            target: Target agent name
+            task: Task name
+            data: Task data
+            timeout: Response timeout
+        
+        Returns:
+            Response data
+        """
+        if not self._loop:
+            raise RuntimeError("Agent not started")
+        
+        future = asyncio.run_coroutine_threadsafe(
+            self._request_async(target, task, data, timeout),
+            self._loop
+        )
+        return future.result(timeout=timeout + 1)