tbn-agent-network 0.1.0__tar.gz

tbn_agent_network-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (c) 2026 Hardin Enterprises Ltd (trading as Hardin AI Solutions)
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, contact: burhan@hardinai.co.uk

tbn_agent_network-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include requirements.txt

tbn_agent_network-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: tbn-agent-network
+Version: 0.1.0
+Summary: Trust-verified communication network for AI agents. The governed internet for AI.
+Home-page: https://github.com/burhanyanbolu-design/project-hardin
+Author: Burhan Yanbolu
+Author-email: burhan@hardinai.co.uk
+License: AGPL-3.0
+Project-URL: Homepage, https://net.hardinai.co.uk
+Project-URL: TBN Protocol, https://tbn.hardinai.co.uk
+Project-URL: Documentation, https://github.com/burhanyanbolu-design/project-hardin
+Project-URL: Bug Tracker, https://github.com/burhanyanbolu-design/project-hardin/issues
+Keywords: ai,agents,trust,verification,governance,network,communication,cryptography,eu-ai-act,compliance,certification,identity,tbn
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: flask>=3.0.0
+Requires-Dist: tbn-protocol>=0.1.0
+Provides-Extra: server
+Requires-Dist: gunicorn>=21.0.0; extra == "server"
+Provides-Extra: multinode
+Requires-Dist: redis>=5.0.0; extra == "multinode"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TBN Agent Network — Trust-Verified Agent Communication
+
+The missing trust layer for AI agent-to-agent communication.
+
+## What is this?
+
+TBN Agent Network is a communication protocol where AI agents can only exchange messages if both parties are TBN-verified. Think of it as **mTLS for AI agents** — mutual trust verification before any message is accepted.
+
+Built on top of [TBN Protocol](https://github.com/burhanyanbolu-design/tbn-protocol) (the identity and certification layer for AI agents).
+
+## How it works
+
+```
+Agent A                    TBN Agent Network                    Agent B
+   |                              |                               |
+   |-- "I want to send msg" ----->|                               |
+   |                              |-- Verify Agent A (TBN) ------>|
+   |                              |<-- A is VALID ----------------|
+   |                              |-- Verify Agent B (TBN) ------>|
+   |                              |<-- B is VALID ----------------|
+   |                              |                               |
+   |                              |-- Deliver signed envelope --->|
+   |                              |                               |
+   |<-- Delivery receipt ---------|                               |
+```
+
+Every message carries a **TBN Verification Envelope**:
+- Sender's TBN verification proof (cryptographically signed)
+- Receiver's TBN verification proof
+- Message payload (encrypted)
+- Timestamp + nonce (replay protection)
+- Network signature (proves the network verified both parties)
+
+## Key Features
+
+- **Mutual trust verification** — Both sender and receiver must be TBN-certified
+- **Cryptographic envelopes** — Every message is signed and verifiable
+- **Offline verification** — Recipients can verify envelopes without calling TBN again
+- **Replay protection** — Nonce + timestamp prevents message replay attacks
+- **Agent discovery** — Find certified agents by capability
+- **Scalable** — Designed for thousands of concurrent agents
+- **Uses live TBN** — Connects to tbn.hardinai.co.uk for real verification
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 TBN Agent Network                     │
+│                                                      │
+│  ┌──────────┐  ┌──────────────┐  ┌──────────────┐  │
+│  │  Router  │  │  Envelope    │  │  Discovery   │  │
+│  │  Layer   │  │  Signing     │  │  Registry    │  │
+│  └────┬─────┘  └──────┬───────┘  └──────┬───────┘  │
+│       │               │                  │          │
+│  ┌────┴───────────────┴──────────────────┴───────┐  │
+│  │           TBN Verification Gate                │  │
+│  │     (calls tbn.hardinai.co.uk/api/verify)     │  │
+│  └────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────┘
+```
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+python demo_network.py
+```
+
+## License
+
+AGPL-3.0 — Hardin Enterprises Ltd (trading as Hardin AI Solutions)
+
+## Links
+
+- TBN Protocol: https://tbn.hardinai.co.uk
+- GitHub: https://github.com/burhanyanbolu-design/tbn-protocol
+- PyPI: https://pypi.org/project/tbn-protocol/

tbn_agent_network-0.1.0/README.md

@@ -0,0 +1,77 @@
+# TBN Agent Network — Trust-Verified Agent Communication
+
+The missing trust layer for AI agent-to-agent communication.
+
+## What is this?
+
+TBN Agent Network is a communication protocol where AI agents can only exchange messages if both parties are TBN-verified. Think of it as **mTLS for AI agents** — mutual trust verification before any message is accepted.
+
+Built on top of [TBN Protocol](https://github.com/burhanyanbolu-design/tbn-protocol) (the identity and certification layer for AI agents).
+
+## How it works
+
+```
+Agent A                    TBN Agent Network                    Agent B
+   |                              |                               |
+   |-- "I want to send msg" ----->|                               |
+   |                              |-- Verify Agent A (TBN) ------>|
+   |                              |<-- A is VALID ----------------|
+   |                              |-- Verify Agent B (TBN) ------>|
+   |                              |<-- B is VALID ----------------|
+   |                              |                               |
+   |                              |-- Deliver signed envelope --->|
+   |                              |                               |
+   |<-- Delivery receipt ---------|                               |
+```
+
+Every message carries a **TBN Verification Envelope**:
+- Sender's TBN verification proof (cryptographically signed)
+- Receiver's TBN verification proof
+- Message payload (encrypted)
+- Timestamp + nonce (replay protection)
+- Network signature (proves the network verified both parties)
+
+## Key Features
+
+- **Mutual trust verification** — Both sender and receiver must be TBN-certified
+- **Cryptographic envelopes** — Every message is signed and verifiable
+- **Offline verification** — Recipients can verify envelopes without calling TBN again
+- **Replay protection** — Nonce + timestamp prevents message replay attacks
+- **Agent discovery** — Find certified agents by capability
+- **Scalable** — Designed for thousands of concurrent agents
+- **Uses live TBN** — Connects to tbn.hardinai.co.uk for real verification
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 TBN Agent Network                     │
+│                                                      │
+│  ┌──────────┐  ┌──────────────┐  ┌──────────────┐  │
+│  │  Router  │  │  Envelope    │  │  Discovery   │  │
+│  │  Layer   │  │  Signing     │  │  Registry    │  │
+│  └────┬─────┘  └──────┬───────┘  └──────┬───────┘  │
+│       │               │                  │          │
+│  ┌────┴───────────────┴──────────────────┴───────┐  │
+│  │           TBN Verification Gate                │  │
+│  │     (calls tbn.hardinai.co.uk/api/verify)     │  │
+│  └────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────┘
+```
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+python demo_network.py
+```
+
+## License
+
+AGPL-3.0 — Hardin Enterprises Ltd (trading as Hardin AI Solutions)
+
+## Links
+
+- TBN Protocol: https://tbn.hardinai.co.uk
+- GitHub: https://github.com/burhanyanbolu-design/tbn-protocol
+- PyPI: https://pypi.org/project/tbn-protocol/

tbn_agent_network-0.1.0/auth.py

@@ -0,0 +1,58 @@
+"""
+TBN Agent Network — Authentication & Authorization
+
+API key authentication for network access.
+Every request must include a valid key.
+
+Usage:
+    Header: Authorization: Bearer tbn_net_xxxx
+    Or query param: ?api_key=tbn_net_xxxx
+
+(c) 2026 Hardin Enterprises Ltd. AGPL-3.0
+"""
+
+from functools import wraps
+from flask import request, jsonify
+from database import validate_key, log_event
+
+
+def require_network_key(f):
+    """Decorator: require a valid TBN Agent Network API key."""
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        # Check Authorization header
+        auth_header = request.headers.get("Authorization", "")
+        if auth_header.startswith("Bearer "):
+            key = auth_header[7:]
+        else:
+            # Check query param
+            key = request.args.get("api_key") or (request.get_json() or {}).get("api_key")
+        
+        if not key:
+            return jsonify({
+                "error": "API key required",
+                "detail": "Include 'Authorization: Bearer tbn_net_xxxx' header or 'api_key' parameter",
+                "docs": "https://tbn.hardinai.co.uk/docs"
+            }), 401
+        
+        # Validate key
+        key_record = validate_key(key)
+        if not key_record:
+            log_event("AUTH_FAILED", detail=f"Invalid key attempt: {key[:12]}...")
+            return jsonify({
+                "error": "Invalid API key",
+                "detail": "Key not found or deactivated"
+            }), 403
+        
+        # Attach key info to request
+        request.network_key = key_record
+        return f(*args, **kwargs)
+    
+    return decorated
+
+
+def check_permission(key_record, permission):
+    """Check if a key has a specific permission."""
+    import json
+    permissions = json.loads(key_record.get("permissions", "[]"))
+    return permission in permissions or "admin" in permissions

tbn_agent_network-0.1.0/database.py

@@ -0,0 +1,309 @@
+"""
+TBN Agent Network — Database Persistence Layer
+
+SQLite-backed storage for agents, messages, governance decisions,
+and compliance records. Survives restarts.
+
+(c) 2026 Hardin Enterprises Ltd. AGPL-3.0
+"""
+
+import sqlite3
+import json
+import os
+from datetime import datetime, timezone
+
+
+DB_PATH = os.environ.get("TBN_NET_DB", "data/tbn_network.db")
+
+
+def get_db():
+    """Get database connection."""
+    os.makedirs(os.path.dirname(DB_PATH) or ".", exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+def init_db():
+    """Initialize database tables."""
+    conn = get_db()
+    conn.executescript("""
+        -- Registered agents
+        CREATE TABLE IF NOT EXISTS agents (
+            agent_id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            capabilities TEXT DEFAULT '[]',
+            owner_id TEXT,
+            owner_name TEXT,
+            owner_email TEXT,
+            status TEXT DEFAULT 'active',
+            connected_at TEXT NOT NULL,
+            last_seen TEXT,
+            metadata TEXT DEFAULT '{}'
+        );
+
+        -- Message envelopes (audit trail)
+        CREATE TABLE IF NOT EXISTS messages (
+            envelope_id TEXT PRIMARY KEY,
+            sender_id TEXT NOT NULL,
+            receiver_id TEXT NOT NULL,
+            content_hash TEXT NOT NULL,
+            content_type TEXT DEFAULT 'application/json',
+            sender_status TEXT,
+            receiver_status TEXT,
+            signature TEXT,
+            delivered INTEGER DEFAULT 0,
+            blocked_reason TEXT,
+            timestamp TEXT NOT NULL,
+            latency_ms REAL
+        );
+
+        -- Governance decisions
+        CREATE TABLE IF NOT EXISTS governance_decisions (
+            receipt_id TEXT PRIMARY KEY,
+            agent_id TEXT NOT NULL,
+            action_class TEXT NOT NULL,
+            decision TEXT NOT NULL,
+            reason TEXT,
+            message_id TEXT,
+            human_approver TEXT,
+            decision_hash TEXT NOT NULL,
+            timestamp TEXT NOT NULL
+        );
+
+        -- Agent authorities
+        CREATE TABLE IF NOT EXISTS authorities (
+            agent_id TEXT PRIMARY KEY,
+            owner_id TEXT NOT NULL,
+            owner_name TEXT NOT NULL,
+            owner_email TEXT NOT NULL,
+            permitted_actions TEXT DEFAULT '[]',
+            max_risk_level TEXT DEFAULT 'medium',
+            daily_action_limit INTEGER DEFAULT 1000,
+            requires_approval TEXT DEFAULT '[]',
+            created_at TEXT NOT NULL
+        );
+
+        -- EU compliance records
+        CREATE TABLE IF NOT EXISTS compliance_records (
+            agent_id TEXT PRIMARY KEY,
+            risk_category TEXT NOT NULL,
+            overall_status TEXT NOT NULL,
+            compliance_score REAL,
+            article_status TEXT DEFAULT '{}',
+            recommendations TEXT DEFAULT '[]',
+            assessed_at TEXT NOT NULL,
+            agent_info TEXT DEFAULT '{}'
+        );
+
+        -- Network events (real-time log)
+        CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            event_type TEXT NOT NULL,
+            agent_id TEXT,
+            detail TEXT,
+            timestamp TEXT NOT NULL
+        );
+
+        -- API keys for network access
+        CREATE TABLE IF NOT EXISTS api_keys (
+            key_hash TEXT PRIMARY KEY,
+            key_prefix TEXT NOT NULL,
+            owner_name TEXT NOT NULL,
+            owner_email TEXT NOT NULL,
+            permissions TEXT DEFAULT '["connect","send","receive","discover"]',
+            rate_limit INTEGER DEFAULT 1000,
+            calls_today INTEGER DEFAULT 0,
+            last_reset TEXT,
+            created_at TEXT NOT NULL,
+            active INTEGER DEFAULT 1
+        );
+
+        -- Indexes for performance
+        CREATE INDEX IF NOT EXISTS idx_messages_sender ON messages(sender_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_receiver ON messages(receiver_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_governance_agent ON governance_decisions(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+    """)
+    conn.commit()
+    conn.close()
+    print("[DB] Database initialized: " + DB_PATH)
+
+
+# ── Agent Operations ──────────────────────────────────────────────────
+
+def save_agent(agent_id, name, capabilities, owner_id=None, owner_name=None, owner_email=None):
+    conn = get_db()
+    conn.execute("""
+        INSERT OR REPLACE INTO agents (agent_id, name, capabilities, owner_id, owner_name, owner_email, status, connected_at, last_seen)
+        VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?)
+    """, (agent_id, name, json.dumps(capabilities), owner_id, owner_name, owner_email,
+          datetime.now(timezone.utc).isoformat(), datetime.now(timezone.utc).isoformat()))
+    conn.commit()
+    conn.close()
+
+
+def get_agent(agent_id):
+    conn = get_db()
+    row = conn.execute("SELECT * FROM agents WHERE agent_id = ?", (agent_id,)).fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+
+def list_agents(status="active"):
+    conn = get_db()
+    rows = conn.execute("SELECT * FROM agents WHERE status = ?", (status,)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def revoke_agent(agent_id):
+    conn = get_db()
+    conn.execute("UPDATE agents SET status = 'revoked' WHERE agent_id = ?", (agent_id,))
+    conn.commit()
+    conn.close()
+
+
+def reactivate_agent(agent_id):
+    conn = get_db()
+    conn.execute("UPDATE agents SET status = 'active' WHERE agent_id = ?", (agent_id,))
+    conn.commit()
+    conn.close()
+
+
+# ── Message Operations ────────────────────────────────────────────────
+
+def save_message(envelope_id, sender_id, receiver_id, content_hash, content_type,
+                sender_status, receiver_status, signature, delivered, blocked_reason=None, latency_ms=None):
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO messages (envelope_id, sender_id, receiver_id, content_hash, content_type,
+                             sender_status, receiver_status, signature, delivered, blocked_reason, timestamp, latency_ms)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (envelope_id, sender_id, receiver_id, content_hash, content_type,
+          sender_status, receiver_status, signature, 1 if delivered else 0,
+          blocked_reason, datetime.now(timezone.utc).isoformat(), latency_ms))
+    conn.commit()
+    conn.close()
+
+
+def get_messages(agent_id=None, limit=100):
+    conn = get_db()
+    if agent_id:
+        rows = conn.execute(
+            "SELECT * FROM messages WHERE sender_id = ? OR receiver_id = ? ORDER BY timestamp DESC LIMIT ?",
+            (agent_id, agent_id, limit)).fetchall()
+    else:
+        rows = conn.execute("SELECT * FROM messages ORDER BY timestamp DESC LIMIT ?", (limit,)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def get_message_stats():
+    conn = get_db()
+    total = conn.execute("SELECT COUNT(*) as c FROM messages").fetchone()["c"]
+    delivered = conn.execute("SELECT COUNT(*) as c FROM messages WHERE delivered = 1").fetchone()["c"]
+    blocked = conn.execute("SELECT COUNT(*) as c FROM messages WHERE delivered = 0").fetchone()["c"]
+    conn.close()
+    return {"total": total, "delivered": delivered, "blocked": blocked}
+
+
+# ── Governance Operations ─────────────────────────────────────────────
+
+def save_governance_decision(receipt_id, agent_id, action_class, decision, reason, 
+                            decision_hash, message_id=None, human_approver=None):
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO governance_decisions (receipt_id, agent_id, action_class, decision, reason,
+                                         message_id, human_approver, decision_hash, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (receipt_id, agent_id, action_class, decision, reason, message_id,
+          human_approver, decision_hash, datetime.now(timezone.utc).isoformat()))
+    conn.commit()
+    conn.close()
+
+
+def get_governance_trail(agent_id=None, limit=100):
+    conn = get_db()
+    if agent_id:
+        rows = conn.execute(
+            "SELECT * FROM governance_decisions WHERE agent_id = ? ORDER BY timestamp DESC LIMIT ?",
+            (agent_id, limit)).fetchall()
+    else:
+        rows = conn.execute("SELECT * FROM governance_decisions ORDER BY timestamp DESC LIMIT ?", (limit,)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+# ── Event Log ─────────────────────────────────────────────────────────
+
+def log_event(event_type, agent_id=None, detail=None):
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO events (event_type, agent_id, detail, timestamp)
+        VALUES (?, ?, ?, ?)
+    """, (event_type, agent_id, detail, datetime.now(timezone.utc).isoformat()))
+    conn.commit()
+    conn.close()
+
+
+def get_events(limit=100):
+    conn = get_db()
+    rows = conn.execute("SELECT * FROM events ORDER BY timestamp DESC LIMIT ?", (limit,)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+# ── API Key Operations ────────────────────────────────────────────────
+
+import hashlib
+import secrets
+
+
+def generate_network_key(owner_name, owner_email, permissions=None):
+    """Generate a new API key for network access."""
+    raw_key = f"tbn_net_{secrets.token_hex(16)}"
+    key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
+    key_prefix = raw_key[:12]
+    
+    conn = get_db()
+    conn.execute("""
+        INSERT INTO api_keys (key_hash, key_prefix, owner_name, owner_email, permissions, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+    """, (key_hash, key_prefix, owner_name, owner_email,
+          json.dumps(permissions or ["connect", "send", "receive", "discover"]),
+          datetime.now(timezone.utc).isoformat()))
+    conn.commit()
+    conn.close()
+    
+    return raw_key
+
+
+def validate_key(raw_key):
+    """Validate an API key. Returns key record or None."""
+    if not raw_key or not raw_key.startswith("tbn_net_"):
+        return None
+    
+    key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
+    conn = get_db()
+    row = conn.execute("SELECT * FROM api_keys WHERE key_hash = ? AND active = 1", (key_hash,)).fetchone()
+    conn.close()
+    
+    if row:
+        return dict(row)
+    return None
+
+
+def list_keys():
+    """List all API keys (prefix only, not full key)."""
+    conn = get_db()
+    rows = conn.execute("SELECT key_prefix, owner_name, owner_email, active, created_at FROM api_keys").fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+# Initialize on import
+init_db()