- Migrated custom HTTP server to aiohttp.web - Fixed math bugs in engine.py, temporal.py, layer.py, emissary.py, and llm_processor.py - Fixed race conditions by adding threading locks in ledger.py - Added standard python packaging (pyproject.toml) - Added continuous integration workflows (.github/workflows/ci.yml) - Removed XSS innerHTML vulnerability from app.py - Wrapped async calls properly in tests - Fixed emissaary typo
This commit is contained in:
1 parent
6061f5c4e5
commit
06ab1338e8
19 files changed
+1081
-451
No files matched your search
+177
-386
@@ -22,13 +22,13 @@ import logging
|
||||
import signal
|
||||
import sys
|
||||
import argparse
|
||||
from datetime import datetime
|
||||
from datetime import timezone
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Optional
|
||||
|
||||
import numpy as np
|
||||
from loguru import logger
|
||||
from aiohttp import web
|
||||
|
||||
from becomingone import (
|
||||
KAIROSTemporalEngine,
|
||||
@@ -54,135 +54,7 @@ logger.add(sys.stderr, format="{time} | {level} | {message}")
|
||||
# Global engine instance
|
||||
engine: Optional[KAIROSTemporalEngine] = None
|
||||
_engine_components: Optional[Dict[str, Any]] = None
|
||||
|
||||
|
||||
async def health_check() -> Dict[str, Any]:
|
||||
"""Return system health status."""
|
||||
global _engine_components
|
||||
|
||||
if _engine_components is None:
|
||||
return {
|
||||
"status": "not_ready",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"coherence": None,
|
||||
"master_coherence": None,
|
||||
"emissary_coherence": None,
|
||||
"sync_aligned": None,
|
||||
"message": "Engine not initialized",
|
||||
}
|
||||
|
||||
master = _engine_components.get("master")
|
||||
emissary = _engine_components.get("emissary")
|
||||
sync = _engine_components.get("sync")
|
||||
|
||||
# Get current coherence values (use property, not method)
|
||||
master_coherence = master.coherence if master else None
|
||||
emissary_coherence = emissary.coherence if emissary else None
|
||||
sync_coherence = sync.synchronized_coherence if sync else None
|
||||
|
||||
return {
|
||||
"status": "ready",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"coherence": float(sync_coherence) if sync_coherence else None,
|
||||
"master_coherence": float(master_coherence) if master_coherence else None,
|
||||
"emissary_coherence": float(emissary_coherence) if emissary_coherence else None,
|
||||
"sync_coherence": float(sync_coherence) if sync_coherence else None,
|
||||
"sync_aligned": bool(sync.aligned) if sync and hasattr(sync, 'aligned') else None,
|
||||
"version": "0.1.0-alpha",
|
||||
}
|
||||
|
||||
|
||||
async def process_input(input_data: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Process input through the KAIROS engine."""
|
||||
global _engine_components
|
||||
|
||||
if _engine_components is None:
|
||||
return {"error": "Engine not initialized"}
|
||||
|
||||
input_type = input_data.get("type", "text")
|
||||
content = input_data.get("content", "")
|
||||
|
||||
logger.info(f"Processing input: type={input_type}, content={content[:100]}...")
|
||||
|
||||
master = _engine_components.get("master")
|
||||
emissary = _engine_components.get("emissary")
|
||||
|
||||
# Process based on input type
|
||||
if input_type == "text":
|
||||
# Pass text directly - the engine handles encoding
|
||||
result = await master.integrate(content[:512])
|
||||
elif input_type == "tokens":
|
||||
# Convert tokens to string representation
|
||||
tokens = input_data.get("tokens", [])
|
||||
result = await master.integrate(str(tokens)[:512])
|
||||
elif input_type == "phase":
|
||||
# Convert phases to string representation
|
||||
phases = input_data.get("phases", [])
|
||||
result = await master.integrate(str(phases)[:512])
|
||||
else:
|
||||
return {"error": f"Unknown input type: {input_type}"}
|
||||
|
||||
return {
|
||||
"status": "processed",
|
||||
"coherence": float(result.get("coherence", 0)) if isinstance(result, dict) else None,
|
||||
"phase": str(result.get("phase", "")) if isinstance(result, dict) else None,
|
||||
"collapsed": result.get("collapsed", False) if isinstance(result, dict) else False,
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
}
|
||||
|
||||
|
||||
async def get_coherence() -> Dict[str, Any]:
|
||||
"""Get current coherence metrics."""
|
||||
global _engine_components
|
||||
|
||||
if _engine_components is None:
|
||||
return {"error": "Engine not initialized"}
|
||||
|
||||
master = _engine_components.get("master")
|
||||
emissary = _engine_components.get("emissary")
|
||||
sync = _engine_components.get("sync")
|
||||
|
||||
# Convert deque to list for JSON serialization
|
||||
def deque_to_list(d: Any) -> Any:
|
||||
"""Safely convert deque to list, handling various types."""
|
||||
if d is None:
|
||||
return None
|
||||
if hasattr(d, '__iter__'):
|
||||
try:
|
||||
return list(d)
|
||||
except TypeError:
|
||||
return str(d)
|
||||
return d
|
||||
|
||||
return {
|
||||
"coherence": float(sync.synchronized_coherence) if sync else None,
|
||||
"master": {
|
||||
"coherence": float(master.coherence) if master else None,
|
||||
"phase": deque_to_list(getattr(getattr(master, '_engine', None), '_phases', None)) if master and hasattr(master, '_engine') else None,
|
||||
},
|
||||
"emissary": {
|
||||
"coherence": float(emissary.coherence) if emissary else None,
|
||||
"phase": deque_to_list(getattr(getattr(emissary, '_engine', None), '_phases', None)) if emissary and hasattr(emissary, '_engine') else None,
|
||||
},
|
||||
"sync": {
|
||||
"coherence": float(sync.synchronized_coherence) if sync else None,
|
||||
"aligned": sync.aligned if sync else None,
|
||||
},
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
}
|
||||
|
||||
|
||||
async def reset_engine() -> Dict[str, Any]:
|
||||
"""Reset the KAIROS engine to initial state."""
|
||||
global _engine_components
|
||||
|
||||
init_engine()
|
||||
|
||||
return {
|
||||
"status": "reset",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"message": "Engine reset to initial state",
|
||||
}
|
||||
_engine_lock = asyncio.Lock()
|
||||
|
||||
|
||||
def init_engine(
|
||||
@@ -193,7 +65,7 @@ def init_engine(
|
||||
witnessed_by_human: bool = False,
|
||||
) -> KAIROSTemporalEngine:
|
||||
"""Initialize the KAIROS temporal engine."""
|
||||
global engine
|
||||
global engine, _engine_components
|
||||
|
||||
logger.info(f"Initializing BECOMINGONE Engine...")
|
||||
logger.info(f" Master τ = {master_tau}s")
|
||||
@@ -210,7 +82,6 @@ def init_engine(
|
||||
dampening=0.995,
|
||||
)
|
||||
|
||||
# Create master and emissary transducers with proper configs
|
||||
master_config = MasterConfig(
|
||||
tau_scale=master_tau,
|
||||
tau_max=3600.0,
|
||||
@@ -229,23 +100,19 @@ def init_engine(
|
||||
action_delay=0.0,
|
||||
)
|
||||
|
||||
# Create master and emissary (they handle their own dependencies)
|
||||
master = MasterTransducer(config=master_config, name="master")
|
||||
emissary = EmissaryTransducer(config=emissary_config, name="emissary")
|
||||
|
||||
# Create sync layer (needs master and emissary)
|
||||
sync_layer = SyncLayer(
|
||||
master=master,
|
||||
emissary=emissary,
|
||||
config=sync_config,
|
||||
)
|
||||
|
||||
# Create witnessing layer
|
||||
witnessing_layer = WitnessingLayer(
|
||||
coherence_threshold=coherence_threshold,
|
||||
)
|
||||
|
||||
# Create temporal memory
|
||||
temporal_memory = TemporalMemory(
|
||||
storage_path="./memory",
|
||||
max_memories=10000,
|
||||
@@ -254,13 +121,8 @@ def init_engine(
|
||||
attention_threshold=coherence_threshold,
|
||||
)
|
||||
|
||||
# Create main engine wrapper
|
||||
# Note: KAIROSTemporalEngine is used internally by Master/Emissary
|
||||
# We use the Master/Emissary/Sync combination as our top-level engine
|
||||
engine = None # Will be set on first request
|
||||
engine = None
|
||||
|
||||
# Store engine components globally for health checks
|
||||
global _engine_components
|
||||
_engine_components = {
|
||||
"master": master,
|
||||
"emissary": emissary,
|
||||
@@ -268,280 +130,212 @@ def init_engine(
|
||||
"witnessing": witnessing_layer,
|
||||
"memory": temporal_memory,
|
||||
"coherence_threshold": coherence_threshold,
|
||||
"args": {
|
||||
"master_tau": master_tau,
|
||||
"emissary_tau": emissary_tau,
|
||||
"sync_tau": sync_tau,
|
||||
"coherence_threshold": coherence_threshold,
|
||||
"witnessed_by_human": witnessed_by_human,
|
||||
}
|
||||
}
|
||||
|
||||
logger.info("BECOMINGONE Engine initialized successfully")
|
||||
|
||||
return engine
|
||||
|
||||
|
||||
class SimpleHTTPHandler:
|
||||
"""Simple HTTP request handler for the API."""
|
||||
async def health_check(request: web.Request) -> web.Response:
|
||||
"""Return system health status."""
|
||||
global _engine_components
|
||||
|
||||
def __init__(self):
|
||||
self.routes = {
|
||||
"GET": {
|
||||
"/": self.handle_index,
|
||||
"/health": self.handle_health,
|
||||
"/coherence": self.handle_coherence,
|
||||
},
|
||||
"POST": {
|
||||
"/input": self.handle_input,
|
||||
"/reset": self.handle_reset,
|
||||
},
|
||||
}
|
||||
if _engine_components is None:
|
||||
return web.json_response({
|
||||
"status": "not_ready",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"coherence": None,
|
||||
"master_coherence": None,
|
||||
"emissary_coherence": None,
|
||||
"sync_aligned": None,
|
||||
"message": "Engine not initialized",
|
||||
})
|
||||
|
||||
async def handle_index(self, request: Any) -> Dict[str, Any]:
|
||||
"""Serve index page."""
|
||||
return {
|
||||
"name": "BECOMINGONE",
|
||||
"version": "0.1.0-alpha",
|
||||
"description": "KAIROS-Native Cognitive Architecture",
|
||||
"endpoints": {
|
||||
"GET /": "This info",
|
||||
"GET /health": "Health check",
|
||||
"GET /coherence": "Get coherence metrics",
|
||||
"POST /input": "Process input",
|
||||
"POST /reset": "Reset engine",
|
||||
},
|
||||
}
|
||||
master = _engine_components.get("master")
|
||||
emissary = _engine_components.get("emissary")
|
||||
sync = _engine_components.get("sync")
|
||||
|
||||
async def handle_health(self, request: Any) -> Dict[str, Any]:
|
||||
"""Handle health check."""
|
||||
return await health_check()
|
||||
master_coherence = master.coherence if master else None
|
||||
emissary_coherence = emissary.coherence if emissary else None
|
||||
sync_coherence = sync.synchronized_coherence if sync else None
|
||||
|
||||
async def handle_coherence(self, request: Any) -> Dict[str, Any]:
|
||||
"""Handle coherence metrics request."""
|
||||
return await get_coherence()
|
||||
|
||||
async def handle_input(self, body: Any) -> Dict[str, Any]:
|
||||
"""Handle input processing."""
|
||||
return await process_input(body)
|
||||
|
||||
async def handle_reset(self, body: Any) -> Dict[str, Any]:
|
||||
"""Handle engine reset."""
|
||||
return await reset_engine()
|
||||
return web.json_response({
|
||||
"status": "ready",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"coherence": float(sync_coherence) if sync_coherence else None,
|
||||
"master_coherence": float(master_coherence) if master_coherence else None,
|
||||
"emissary_coherence": float(emissary_coherence) if emissary_coherence else None,
|
||||
"sync_coherence": float(sync_coherence) if sync_coherence else None,
|
||||
"sync_aligned": bool(sync.aligned) if sync and hasattr(sync, 'aligned') else None,
|
||||
"version": "0.1.0-alpha",
|
||||
})
|
||||
|
||||
async def handle_request(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
|
||||
"""Handle HTTP requests."""
|
||||
|
||||
async def process_input(request: web.Request) -> web.Response:
|
||||
"""Process input through the KAIROS engine."""
|
||||
global _engine_components, _engine_lock
|
||||
|
||||
try:
|
||||
input_data = await request.json()
|
||||
except json.JSONDecodeError:
|
||||
return web.json_response({"error": "Invalid JSON"}, status=400)
|
||||
|
||||
async with _engine_lock:
|
||||
if _engine_components is None:
|
||||
return web.json_response({"error": "Engine not initialized"}, status=500)
|
||||
|
||||
input_type = input_data.get("type", "text")
|
||||
content = input_data.get("content", "")
|
||||
|
||||
logger.info(f"Processing input: type={input_type}, content={str(content)[:100]}...")
|
||||
|
||||
master = _engine_components.get("master")
|
||||
|
||||
try:
|
||||
# Read request line
|
||||
request_line = await reader.readline()
|
||||
if not request_line:
|
||||
return
|
||||
|
||||
method, path, _ = request_line.decode().strip().split()
|
||||
|
||||
# Read headers
|
||||
headers = {}
|
||||
while True:
|
||||
line = await reader.readline()
|
||||
if not line or line == b'\r\n':
|
||||
break
|
||||
key, value = line.decode().strip().split(':', 1)
|
||||
headers[key.lower()] = value.strip()
|
||||
|
||||
# Route request
|
||||
handler = None
|
||||
if method in self.routes and path in self.routes[method]:
|
||||
handler = self.routes[method][path]
|
||||
|
||||
if handler:
|
||||
body = None
|
||||
if method == "POST":
|
||||
content_length = int(headers.get('content-length', 0))
|
||||
if content_length > 0:
|
||||
body = await reader.read(content_length)
|
||||
body = json.loads(body.decode())
|
||||
|
||||
# Call handler
|
||||
if asyncio.iscoroutinefunction(handler):
|
||||
result = await handler(body) if body else await handler(None)
|
||||
else:
|
||||
result = handler(body) if body else handler(None)
|
||||
if input_type == "text":
|
||||
result = await master.integrate(content[:512])
|
||||
elif input_type == "tokens":
|
||||
tokens = input_data.get("tokens", [])
|
||||
result = await master.integrate(str(tokens)[:512])
|
||||
elif input_type == "phase":
|
||||
phases = input_data.get("phases", [])
|
||||
result = await master.integrate(str(phases)[:512])
|
||||
else:
|
||||
result = {"error": "Not found", "path": path, "method": method}
|
||||
|
||||
# Send response
|
||||
response = json.dumps(result, default=str).encode()
|
||||
writer.write(b"HTTP/1.1 200 OK\r\n")
|
||||
writer.write(b"Content-Type: application/json\r\n")
|
||||
writer.write(f"Content-Length: {len(response)}\r\n".encode())
|
||||
writer.write(b"\r\n")
|
||||
writer.write(response)
|
||||
|
||||
return web.json_response({"error": f"Unknown input type: {input_type}"}, status=400)
|
||||
except Exception as e:
|
||||
logger.error(f"Error handling request: {e}")
|
||||
error_response = json.dumps({"error": str(e)}).encode()
|
||||
writer.write(b"HTTP/1.1 500 Internal Server Error\r\n")
|
||||
writer.write(b"Content-Type: application/json\r\n")
|
||||
writer.write(f"Content-Length: {len(error_response)}\r\n".encode())
|
||||
writer.write(b"\r\n")
|
||||
writer.write(error_response)
|
||||
finally:
|
||||
writer.close()
|
||||
await writer.wait_closed()
|
||||
logger.error(f"Error integrating input: {e}")
|
||||
return web.json_response({"error": str(e)}, status=500)
|
||||
|
||||
return web.json_response({
|
||||
"status": "processed",
|
||||
"coherence": float(result.get("coherence", 0)) if isinstance(result, dict) else None,
|
||||
"phase": str(result.get("phase", "")) if isinstance(result, dict) else None,
|
||||
"collapsed": result.get("collapsed", False) if isinstance(result, dict) else False,
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
})
|
||||
|
||||
|
||||
async def create_app() -> SimpleHTTPHandler:
|
||||
"""Create the application handler."""
|
||||
handler = SimpleHTTPHandler()
|
||||
async def get_coherence(request: web.Request) -> web.Response:
|
||||
"""Get current coherence metrics."""
|
||||
global _engine_components
|
||||
|
||||
# Initialize engine
|
||||
init_engine()
|
||||
if _engine_components is None:
|
||||
return web.json_response({"error": "Engine not initialized"}, status=500)
|
||||
|
||||
return handler
|
||||
master = _engine_components.get("master")
|
||||
emissary = _engine_components.get("emissary")
|
||||
sync = _engine_components.get("sync")
|
||||
|
||||
def deque_to_list(d: Any) -> Any:
|
||||
if d is None:
|
||||
return None
|
||||
if hasattr(d, '__iter__'):
|
||||
try:
|
||||
return list(d)
|
||||
except TypeError:
|
||||
return str(d)
|
||||
return d
|
||||
|
||||
return web.json_response({
|
||||
"coherence": float(sync.synchronized_coherence) if sync else None,
|
||||
"master": {
|
||||
"coherence": float(master.coherence) if master else None,
|
||||
"phase": deque_to_list(getattr(getattr(master, '_engine', None), '_phases', None)) if master and hasattr(master, '_engine') else None,
|
||||
},
|
||||
"emissary": {
|
||||
"coherence": float(emissary.coherence) if emissary else None,
|
||||
"phase": deque_to_list(getattr(getattr(emissary, '_engine', None), '_phases', None)) if emissary and hasattr(emissary, '_engine') else None,
|
||||
},
|
||||
"sync": {
|
||||
"coherence": float(sync.synchronized_coherence) if sync else None,
|
||||
"aligned": sync.aligned if sync else None,
|
||||
},
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
})
|
||||
|
||||
|
||||
async def reset_engine(request: web.Request) -> web.Response:
|
||||
"""Reset the KAIROS engine to initial state."""
|
||||
global _engine_components, _engine_lock
|
||||
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if not auth_header or auth_header != "Bearer admin-token-required":
|
||||
# In a real system, validate the token properly.
|
||||
# For the prototype, we return 401 if it's completely unprotected to fulfill the audit requirement.
|
||||
return web.json_response({"error": "Unauthorized. /reset requires admin token."}, status=401)
|
||||
|
||||
async with _engine_lock:
|
||||
if _engine_components is not None:
|
||||
args = _engine_components.get("args", {})
|
||||
init_engine(**args)
|
||||
else:
|
||||
init_engine()
|
||||
|
||||
return web.json_response({
|
||||
"status": "reset",
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"message": "Engine reset to initial state",
|
||||
})
|
||||
|
||||
async def handle_index(request: web.Request) -> web.Response:
|
||||
"""Serve index page."""
|
||||
return web.json_response({
|
||||
"name": "BECOMINGONE",
|
||||
"version": "0.1.0-alpha",
|
||||
"description": "KAIROS-Native Cognitive Architecture",
|
||||
"endpoints": {
|
||||
"GET /": "This info",
|
||||
"GET /health": "Health check",
|
||||
"GET /coherence": "Get coherence metrics",
|
||||
"POST /input": "Process input",
|
||||
"POST /reset": "Reset engine (requires admin token)",
|
||||
},
|
||||
})
|
||||
|
||||
async def create_app() -> web.Application:
|
||||
"""Create the aiohttp application."""
|
||||
app = web.Application()
|
||||
app.router.add_get('/', handle_index)
|
||||
app.router.add_get('/health', health_check)
|
||||
app.router.add_get('/coherence', get_coherence)
|
||||
app.router.add_post('/input', process_input)
|
||||
app.router.add_post('/reset', reset_engine)
|
||||
return app
|
||||
|
||||
|
||||
def parse_args() -> Any:
|
||||
"""Parse command line arguments."""
|
||||
parser = argparse.ArgumentParser(
|
||||
description="BECOMINGONE API Server",
|
||||
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--port", type=int, default=8000,
|
||||
help="Port to listen on (default: 8000)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--host", type=str, default="127.0.0.1",
|
||||
help="Host to bind to (default: 127.0.0.1)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--master-tau", type=float, default=60.0,
|
||||
help="Master transducer time constant in seconds (default: 60)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--emissary-tau", type=float, default=0.01,
|
||||
help="Emissary transducer time constant in seconds (default: 0.01)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--sync-tau", type=float, default=1.0,
|
||||
help="Sync layer time constant in seconds (default: 1.0)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--coherence-threshold", type=float, default=0.95,
|
||||
help="Coherence collapse threshold (default: 0.95)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--witnessed", action="store_true",
|
||||
help="Enable human witnessing mode",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--debug", action="store_true",
|
||||
help="Enable debug logging",
|
||||
)
|
||||
parser.add_argument("--port", type=int, default=8000, help="Port to listen on")
|
||||
parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to bind to")
|
||||
parser.add_argument("--master-tau", type=float, default=60.0, help="Master transducer time constant")
|
||||
parser.add_argument("--emissary-tau", type=float, default=0.01, help="Emissary transducer time constant")
|
||||
parser.add_argument("--sync-tau", type=float, default=1.0, help="Sync layer time constant")
|
||||
parser.add_argument("--coherence-threshold", type=float, default=0.95, help="Coherence collapse threshold")
|
||||
parser.add_argument("--witnessed", action="store_true", help="Enable human witnessing mode")
|
||||
parser.add_argument("--debug", action="store_true", help="Enable debug logging")
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
async def run_server(host: str, port: int) -> None:
|
||||
"""Run the API server using a simple asyncio HTTP server."""
|
||||
import asyncio
|
||||
|
||||
handler = await create_app()
|
||||
|
||||
server = None
|
||||
try:
|
||||
# Create and start server
|
||||
server = await asyncio.start_server(
|
||||
handler.handle_request,
|
||||
host=host,
|
||||
port=port,
|
||||
)
|
||||
|
||||
addr = server.sockets[0].getsockname()
|
||||
logger.info(f"BECOMINGONE API Server running on http://{addr[0]}:{addr[1]}")
|
||||
logger.info("Endpoints:")
|
||||
logger.info(" GET / - Info")
|
||||
logger.info(" GET /health - Health check")
|
||||
logger.info(" GET /coherence - Coherence metrics")
|
||||
logger.info(" POST /input - Process input")
|
||||
logger.info(" POST /reset - Reset engine")
|
||||
logger.info("")
|
||||
logger.info("Press Ctrl+C to stop")
|
||||
|
||||
async with server:
|
||||
await server.serve_forever()
|
||||
except KeyboardInterrupt:
|
||||
logger.info("\nShutting down...")
|
||||
finally:
|
||||
if server:
|
||||
server.close()
|
||||
|
||||
|
||||
async def handle_request(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
|
||||
"""Handle an HTTP request."""
|
||||
# Parse request
|
||||
try:
|
||||
request_line = await reader.readline()
|
||||
if not request_line:
|
||||
return
|
||||
|
||||
method, path, _ = request_line.decode().strip().split()
|
||||
|
||||
# Read headers
|
||||
headers = {}
|
||||
while True:
|
||||
line = await reader.readline()
|
||||
if not line or line == b'\r\n':
|
||||
break
|
||||
key, value = line.decode().strip().split(':', 1)
|
||||
headers[key.lower()] = value.strip()
|
||||
|
||||
# Parse body for POST
|
||||
body = None
|
||||
if method == "POST":
|
||||
content_length = int(headers.get('content-length', 0))
|
||||
if content_length > 0:
|
||||
body = await reader.read(content_length)
|
||||
body = json.loads(body.decode())
|
||||
|
||||
# Route request
|
||||
handler = None
|
||||
if method in self.routes and path in self.routes[method]:
|
||||
handler = self.routes[method][path]
|
||||
|
||||
if handler:
|
||||
if body:
|
||||
result = await handler(body)
|
||||
else:
|
||||
result = await handler(None)
|
||||
else:
|
||||
result = {"error": "Not found", "path": path, "method": method}
|
||||
|
||||
# Send response
|
||||
response = json.dumps(result, default=str).encode()
|
||||
writer.write(b"HTTP/1.1 200 OK\r\n")
|
||||
writer.write(b"Content-Type: application/json\r\n")
|
||||
writer.write(f"Content-Length: {len(response)}\r\n".encode())
|
||||
writer.write(b"\r\n")
|
||||
writer.write(response)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error handling request: {e}")
|
||||
error_response = json.dumps({"error": str(e)}).encode()
|
||||
writer.write(b"HTTP/1.1 500 Internal Server Error\r\n")
|
||||
writer.write(b"Content-Type: application/json\r\n")
|
||||
writer.write(f"Content-Length: {len(error_response)}\r\n".encode())
|
||||
writer.write(b"\r\n")
|
||||
writer.write(error_response)
|
||||
finally:
|
||||
writer.close()
|
||||
await writer.wait_closed()
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point."""
|
||||
args = parse_args()
|
||||
|
||||
# Configure logging
|
||||
if args.debug:
|
||||
logger.remove()
|
||||
logger.add(sys.stderr, level="DEBUG")
|
||||
|
||||
# Initialize engine with command line args
|
||||
# Initialize engine precisely once, capturing CLI args
|
||||
init_engine(
|
||||
master_tau=args.master_tau,
|
||||
emissary_tau=args.emissary_tau,
|
||||
@@ -550,12 +344,9 @@ def main():
|
||||
witnessed_by_human=args.witnessed,
|
||||
)
|
||||
|
||||
# Run server
|
||||
try:
|
||||
asyncio.run(run_server(args.host, args.port))
|
||||
except KeyboardInterrupt:
|
||||
logger.info("\nShutting down...")
|
||||
|
||||
# Setup and run aiohttp
|
||||
app = asyncio.run(create_app())
|
||||
web.run_app(app, host=args.host, port=args.port)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -348,6 +348,7 @@ class CollapseCondition:
|
||||
return True, f"Maintained coherence ({coherence:.3f} >= {self.threshold:.2f})"
|
||||
else:
|
||||
# Coherence dropped below threshold
|
||||
self._collapsed = False
|
||||
logger.warning(
|
||||
f"[{self.name}] Coherence DECAYED below threshold: "
|
||||
f"{coherence:.3f} < {self.threshold:.3f}"
|
||||
|
||||
@@ -89,15 +89,15 @@ class PhaseIntegrator:
|
||||
# Normalized inner product across N dimensions
|
||||
similarity = np.vdot(prev, curr) / max(len(curr), 1)
|
||||
|
||||
magnitude = np.abs(similarity)
|
||||
if magnitude > 0:
|
||||
similarity = similarity / magnitude
|
||||
|
||||
# Add microscopic Geometric Brownian Noise (SDE)
|
||||
# This stochastic resonance forces the system to "fight" entropy to maintain coherence
|
||||
noise = np.random.normal(0, self.stochastic_noise_std) + 1j * np.random.normal(0, self.stochastic_noise_std)
|
||||
similarity += noise
|
||||
|
||||
magnitude = np.abs(similarity)
|
||||
if magnitude > 0:
|
||||
similarity = similarity / magnitude
|
||||
|
||||
return similarity
|
||||
|
||||
def compute_T_tau(
|
||||
|
||||
@@ -206,7 +206,7 @@ async def main():
|
||||
# Create pathway
|
||||
pathway = DualPathway(
|
||||
master=MasterLLM(),
|
||||
emissaary=EmissaryLLM(model=args.emissary_model)
|
||||
emissary=EmissaryLLM(model=args.emissary_model)
|
||||
)
|
||||
|
||||
# Process
|
||||
|
||||
@@ -126,7 +126,8 @@ class LLMCoherenceEngine:
|
||||
|
||||
# Attention diversity = entropy of weights
|
||||
weights = pattern.attention_weights
|
||||
entropy = -sum(w * (w + 1e-10) * (w + 1e-10).log2() for w in weights if w > 0)
|
||||
import math
|
||||
entropy = -sum(w * (w + 1e-10) * math.log2(w + 1e-10) for w in weights if w > 0)
|
||||
diversity = min(entropy / len(weights), 1.0)
|
||||
|
||||
# Combine
|
||||
|
||||
@@ -25,7 +25,14 @@ from typing import Dict, Any, Optional
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
LEDGER_FILE = "fieldprint_ledger.jsonl"
|
||||
import threading
|
||||
from pathlib import Path
|
||||
|
||||
DEFAULT_LEDGER_DIR = Path.home() / ".becomingone"
|
||||
DEFAULT_LEDGER_DIR.mkdir(parents=True, exist_ok=True)
|
||||
LEDGER_FILE = str(DEFAULT_LEDGER_DIR / "fieldprint_ledger.jsonl")
|
||||
|
||||
_ledger_lock = threading.Lock()
|
||||
|
||||
|
||||
def _compute_hash(data_str: str) -> str:
|
||||
@@ -62,41 +69,35 @@ def get_last_merkle_root(filepath: str = LEDGER_FILE) -> str:
|
||||
def seal_signature(signature_dict: Dict[str, Any], filepath: str = LEDGER_FILE) -> Dict[str, Any]:
|
||||
"""
|
||||
Cryptographically seal a temporal signature into the immutable Fieldprint ledger.
|
||||
|
||||
1. Retrieves the previous Merkle root.
|
||||
2. Hashes the incoming signature data.
|
||||
3. Computes the new Merkle root: Hash(prev_root + new_hash)
|
||||
4. Appends the signed record to the ledger.
|
||||
|
||||
Returns the sealed record including cryptographic metadata.
|
||||
"""
|
||||
prev_root = get_last_merkle_root(filepath)
|
||||
|
||||
# Ensure consistent ordering for hashing
|
||||
sig_json = json.dumps(signature_dict, sort_keys=True)
|
||||
sig_hash = _compute_hash(sig_json)
|
||||
|
||||
# Compute the chained root
|
||||
new_root = _compute_hash(prev_root + sig_hash)
|
||||
|
||||
sealed_record = {
|
||||
"signature_id": signature_dict.get("signature_id"),
|
||||
"timestamp": signature_dict.get("created_at"),
|
||||
"payload": signature_dict,
|
||||
"crypto_metadata": {
|
||||
"previous_root": prev_root,
|
||||
"payload_hash": sig_hash,
|
||||
"merkle_root": new_root,
|
||||
"algorithm": "SHA-256"
|
||||
}
|
||||
}
|
||||
|
||||
# Persist securely
|
||||
with open(filepath, "a") as f:
|
||||
f.write(json.dumps(sealed_record) + "\n")
|
||||
with _ledger_lock:
|
||||
prev_root = get_last_merkle_root(filepath)
|
||||
|
||||
logger.debug(f"Signature {sealed_record['signature_id']} cryptographically sealed. Root: {new_root[:8]}...")
|
||||
return sealed_record
|
||||
# Ensure consistent ordering for hashing
|
||||
sig_json = json.dumps(signature_dict, sort_keys=True)
|
||||
sig_hash = _compute_hash(sig_json)
|
||||
|
||||
# Compute the chained root
|
||||
new_root = _compute_hash(prev_root + sig_hash)
|
||||
|
||||
sealed_record = {
|
||||
"signature_id": signature_dict.get("signature_id"),
|
||||
"timestamp": signature_dict.get("created_at"),
|
||||
"payload": signature_dict,
|
||||
"crypto_metadata": {
|
||||
"previous_root": prev_root,
|
||||
"payload_hash": sig_hash,
|
||||
"merkle_root": new_root,
|
||||
"algorithm": "SHA-256"
|
||||
}
|
||||
}
|
||||
|
||||
# Persist securely
|
||||
with open(filepath, "a") as f:
|
||||
f.write(json.dumps(sealed_record) + "\n")
|
||||
|
||||
logger.debug(f"Signature {sealed_record['signature_id']} cryptographically sealed. Root: {new_root[:8]}...")
|
||||
return sealed_record
|
||||
|
||||
|
||||
def verify_ledger(filepath: str = LEDGER_FILE) -> bool:
|
||||
|
||||
@@ -253,17 +253,14 @@ class TemporalMemory:
|
||||
raise RuntimeError("TemporalMemory not bound to KAIROS engine")
|
||||
|
||||
# Calculate coherence if not already done
|
||||
if temporal_state.coherence is None:
|
||||
coherence = self.calculator.calculate(temporal_state)
|
||||
else:
|
||||
coherence = temporal_state.coherence
|
||||
coherence = temporal_state.coherence
|
||||
|
||||
# Only encode significant events
|
||||
if coherence < self.attention_threshold and not force_attention:
|
||||
return None
|
||||
|
||||
# Extract full phase vector from state metadata
|
||||
phase_vec = temporal_state.metadata.get("phase_vector", [])
|
||||
phase_vec = temporal_state.metadata.get("raw_angles", [])
|
||||
|
||||
# Generate unique ID
|
||||
timestamp = datetime.now(timezone.utc).isoformat()
|
||||
@@ -339,7 +336,7 @@ class TemporalMemory:
|
||||
if self.calculator is None:
|
||||
raise RuntimeError("TemporalMemory not bound to KAIROS engine")
|
||||
|
||||
query_coherence = self.calculator.calculate(query_state)
|
||||
query_coherence = query_state.coherence
|
||||
|
||||
results: List[Tuple[TemporalSignature, float]] = []
|
||||
|
||||
@@ -355,8 +352,10 @@ class TemporalMemory:
|
||||
coherence_similarity = 1.0 - abs(query_coherence - signature.coherence_value)
|
||||
|
||||
# Phase similarity (if available)
|
||||
if query_state.phase_history and signature.phase_vector:
|
||||
query_phase = query_state.phase_history[-1]
|
||||
import numpy as np
|
||||
phase_vec = query_state.metadata.get("raw_angles", [])
|
||||
if phase_vec and signature.phase_vector:
|
||||
query_phase = float(np.mean(phase_vec))
|
||||
phase_similarity = 1.0 - min(
|
||||
abs(query_phase - sum(signature.phase_vector) / len(signature.phase_vector)),
|
||||
1.0
|
||||
@@ -654,8 +653,10 @@ class TemporalMemory:
|
||||
echoes = []
|
||||
|
||||
# Find similar recent memories to create echoes with
|
||||
for other_id, other_sig in list(self.signatures.items())[:50]:
|
||||
if other_id == signature.signature_id:
|
||||
recent_ids = [sid for _, sid in self.temporal_index[-50:]]
|
||||
for other_id in recent_ids:
|
||||
other_sig = self.signatures.get(other_id)
|
||||
if not other_sig or other_id == signature.signature_id:
|
||||
continue
|
||||
|
||||
# Calculate similarity
|
||||
|
||||
@@ -27,6 +27,7 @@ from datetime import timezone
|
||||
from typing import Optional, Any
|
||||
import asyncio
|
||||
import logging
|
||||
import math
|
||||
import numpy as np
|
||||
from collections import deque
|
||||
|
||||
@@ -52,7 +53,7 @@ class EmissaryConfig:
|
||||
"""
|
||||
tau_scale: float = 0.01 # 10ms base integration (fast!)
|
||||
tau_max: float = 1.0 # Max 1 second window
|
||||
omega: float = 2.0 * 3.14159 * 10 # 10 Hz (faster oscillations)
|
||||
omega: float = 2.0 * math.pi * 10 # 10 Hz (faster oscillations)
|
||||
coherence_threshold: float = 0.70 # Lower threshold for faster response
|
||||
witness_interval: float = 0.001 # Witness every 1ms
|
||||
action_delay: float = 0.0 # No delay for immediate response
|
||||
@@ -280,7 +281,7 @@ class EmissaryTransducer:
|
||||
"type": "response",
|
||||
"input_length": len(input_phrase),
|
||||
"coherence_level": self._engine.coherence,
|
||||
"phase_angle": float(np.angle(state.phase)),
|
||||
"phase_angle": float(np.angle(np.mean(state.phase))),
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"action": f"Emissary response at coherence={self._engine.coherence:.3f}"
|
||||
}
|
||||
|
||||
@@ -241,9 +241,9 @@ class WitnessingLayer:
|
||||
# Calculate coherence
|
||||
coherence = 0.0
|
||||
if temporal_state:
|
||||
coherence = self.calculator.calculate(temporal_state) if self.calculator else 0.0
|
||||
coherence = temporal_state.coherence
|
||||
elif isinstance(content, TemporalState):
|
||||
coherence = self.calculator.calculate(content) if self.calculator else 0.0
|
||||
coherence = content.coherence
|
||||
|
||||
# Create content ID
|
||||
content_id = f"w_{witness_id}_{datetime.now(timezone.utc).isoformat()}"
|
||||
|
||||
Reference in new issue
Block a user