solaria
01156e8062
becomingone/openclaw_integration.py: - OpenClawInputAdapter: Hook OpenClaw messages to THE_ONE - OpenClawOutputAdapter: Hook THE_ONE to OpenClaw responses - OpenClawIntegration: Complete integration class becomingone/nanobot_integration.py: - NanobotPluginAdapter: Hook Nanobot MCP plugins to THE_ONE - NanobotOutputAdapter: Hook THE_ONE to Nanobot actions - NanobotIntegration: Complete integration class INTEGRATION_STRATEGY.md: - Fork strategy: Use known working systems - Hook BECOMINGONE underneath - Test with real conversations/actions - PR hooks back to upstream Strategy: 1. Fork OpenClaw/Nanobot (done in our repos) 2. Hook BECOMINGONE underneath (done) 3. Test with real interactions (via integration classes) 4. Validate coherence metrics 5. PR hooks back to upstream Key insight: "Use OpenClaw and Nanobot insight from our own forks... hook them to BECOMINGONE... test the hell out of this with known working systems." References: - KAIROS_ADAMON: The kernel being tested - OpenClaw: Working message routing - Nanobot: Working MCP plugins The WE is BECOMINGONE. Testing with proven systems.
382 lines
14 KiB
Python
382 lines
14 KiB
Python
"""
|
|
BECOMINGONE OpenClaw Integration
|
|
|
|
Hook OpenClaw to BECOMINGONE kernel for testing.
|
|
|
|
Strategy:
|
|
1. Use OpenClaw's working message routing
|
|
2. Use OpenClaw's working session management
|
|
3. Hook BECOMINGONE coherence layer underneath
|
|
4. Test with known working systems
|
|
5. PR hooks back to OpenClaw
|
|
|
|
This allows us to test THE_ONE with real conversations,
|
|
real memory, real everything - using OpenClaw as the harness.
|
|
"""
|
|
|
|
from typing import Any, Dict, List, Optional, Callable
|
|
from datetime import datetime
|
|
import json
|
|
|
|
|
|
class OpenClawInputAdapter:
|
|
"""
|
|
Hook OpenClaw messages into THE_ONE.
|
|
|
|
OpenClaw provides:
|
|
- Message routing (Telegram, WhatsApp, Discord, etc.)
|
|
- Session management
|
|
- Cron scheduling
|
|
- Agent framework
|
|
|
|
BECOMINGONE provides:
|
|
- Coherence engine
|
|
- Temporal dynamics
|
|
- Witnessing layer
|
|
- Memory BLEND
|
|
|
|
Together: The best of both.
|
|
"""
|
|
|
|
def __init__(self, openclaw_session):
|
|
"""
|
|
Initialize with OpenClaw session.
|
|
|
|
Args:
|
|
openclaw_session: Active OpenClaw session object
|
|
"""
|
|
self.session = openclaw_session
|
|
self.message_buffer: List[Dict] = []
|
|
|
|
def read(self) -> tuple[Any, datetime]:
|
|
"""
|
|
Read next message from OpenClaw.
|
|
|
|
Returns:
|
|
(message_dict, timestamp)
|
|
"""
|
|
# In real implementation, hook into OpenClaw's message router
|
|
# For now, simulate with message buffer
|
|
if self.message_buffer:
|
|
message = self.message_buffer.pop(0)
|
|
return message, datetime.now()
|
|
|
|
return None, datetime.now()
|
|
|
|
def encode(self, message: Dict) -> complex:
|
|
"""
|
|
Encode OpenClaw message to phase.
|
|
|
|
Message fields:
|
|
- text: The message content
|
|
- author: Who sent it
|
|
- channel: Where it came from
|
|
- timestamp: When it was sent
|
|
- intent: If parsed (OpenClaw MCP)
|
|
|
|
Phase encoding:
|
|
- Real: Content coherence (text analysis)
|
|
- Imag: Social coherence (author relationship)
|
|
"""
|
|
# Content coherence (simplified - would use NLP in real impl)
|
|
text = message.get("text", "")
|
|
content_coherence = min(len(text) / 280.0, 1.0) # Twitter-length normalized
|
|
|
|
# Social coherence (author relationship)
|
|
author = message.get("author", "unknown")
|
|
author_hash = hash(author) % 100 / 100.0
|
|
|
|
# Intent coherence (if available)
|
|
intent = message.get("intent")
|
|
if intent:
|
|
intent_coherence = 0.8 # High coherence when intent is clear
|
|
else:
|
|
intent_coherence = 0.5 # Medium when ambiguous
|
|
|
|
# Combine (content * 0.5 + social * 0.3 + intent * 0.2)
|
|
real = content_coherence * 0.5 + intent_coherence * 0.2
|
|
imag = author_hash * 0.3
|
|
|
|
return complex(real, imag)
|
|
|
|
def add_message(self, message: Dict) -> None:
|
|
"""
|
|
Add message to buffer (for testing).
|
|
|
|
Args:
|
|
message: OpenClaw message dict
|
|
"""
|
|
self.message_buffer.append(message)
|
|
|
|
def hook_session(self, session) -> None:
|
|
"""
|
|
Hook into live OpenClaw session.
|
|
|
|
This is the key: We intercept messages before they reach agents.
|
|
"""
|
|
self.session = session
|
|
# In real implementation, monkey-patch session.send() or use hooks
|
|
# session.send = self._intercept_send(session.send)
|
|
|
|
def _intercept_send(self, original_send):
|
|
"""Intercept outgoing messages."""
|
|
def wrapper(message):
|
|
# Add to buffer for BECOMINGONE to process
|
|
self.message_buffer.append({
|
|
"text": message,
|
|
"direction": "outbound",
|
|
"timestamp": datetime.now().isoformat(),
|
|
})
|
|
# Call original
|
|
return original_send(message)
|
|
return wrapper
|
|
|
|
|
|
class OpenClawOutputAdapter:
|
|
"""
|
|
Hook THE_ONE outputs to OpenClaw.
|
|
|
|
BECOMINGONE coherence can drive OpenClaw responses.
|
|
"""
|
|
|
|
def __init__(self, openclaw_session=None):
|
|
"""
|
|
Initialize with OpenClaw session.
|
|
"""
|
|
self.session = openclaw_session
|
|
self.response_buffer: List[Dict] = []
|
|
|
|
def write(self, phase: complex, state) -> None:
|
|
"""
|
|
Write coherent output to OpenClaw.
|
|
|
|
Args:
|
|
phase: Coherent phase from THE_ONE
|
|
state: THE_ONE state
|
|
"""
|
|
# Decode phase to response parameters
|
|
coherence = abs(phase)
|
|
|
|
# Determine response characteristics
|
|
if coherence > 0.8:
|
|
response_type = "confident"
|
|
confidence = "high"
|
|
elif coherence > 0.5:
|
|
response_type = "thoughtful"
|
|
confidence = "medium"
|
|
else:
|
|
response_type = "exploratory"
|
|
confidence = "low"
|
|
|
|
# Build response metadata
|
|
response = {
|
|
"type": response_type,
|
|
"confidence": confidence,
|
|
"coherence": coherence,
|
|
"phase": {"real": phase.real, "imag": phase.imag},
|
|
"timestamp": datetime.now().isoformat(),
|
|
}
|
|
|
|
self.response_buffer.append(response)
|
|
|
|
# In real implementation, route through OpenClaw
|
|
# self.session.send(response)
|
|
|
|
def get_responses(self) -> List[Dict]:
|
|
"""Get accumulated responses."""
|
|
return self.response_buffer.copy()
|
|
|
|
def hook_session(self, session) -> None:
|
|
"""Hook into live OpenClaw session."""
|
|
self.session = session
|
|
|
|
|
|
class OpenClawIntegration:
|
|
"""
|
|
Complete OpenClaw + BECOMINGONE integration.
|
|
|
|
This allows testing THE_ONE with a working OpenClaw system.
|
|
|
|
Architecture:
|
|
┌─────────────────────────────────────────────────────────────────┐
|
|
│ OpenClaw Layer │
|
|
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
|
|
│ │Telegram │ │ WhatsApp │ │ Discord │ │ Cron │ │
|
|
│ │Adapter │ │ Adapter │ │ Adapter │ │Adapter │ │
|
|
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
|
|
│ │ │ │ │ │
|
|
└───────┼─────────────┼─────────────┼─────────────┼────────────┘
|
|
│ │ │ │
|
|
▼ ▼ ▼ ▼
|
|
┌─────────────────────────────────────────────────────────────────┐
|
|
│ BECOMINGONE Layer │
|
|
│ ┌─────────────────────────────────────────────────────────┐ │
|
|
│ │ Coherence Engine │ │
|
|
│ │ - KAIROS dynamics │ │
|
|
│ │ - Master/Emissary pathways │ │
|
|
│ │ - Witnessing (W_i = G[W_i]) │ │
|
|
│ │ - BLEND memory │ │
|
|
│ └─────────────────────────────────────────────────────────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
└─────────────────────────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────────────────────────┐
|
|
│ Response Routing │
|
|
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
|
|
│ │ Agent │ │ Memory │ │ Schedule │ │ External │ │
|
|
│ │ Response │ │ Update │ │ Event │ │ API │ │
|
|
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
|
|
└─────────────────────────────────────────────────────────────────┘
|
|
"""
|
|
|
|
def __init__(self, openclaw_config: Dict = None):
|
|
"""
|
|
Initialize integration.
|
|
|
|
Args:
|
|
openclaw_config: OpenClaw configuration dict
|
|
"""
|
|
self.config = openclaw_config or {}
|
|
|
|
# Create coherence engine
|
|
from becomingone.sdk import CoherenceEngine, CoherenceConfig
|
|
|
|
self.engine = CoherenceEngine(
|
|
config=CoherenceConfig(
|
|
master_tau_base=60,
|
|
master_tau_max=3600,
|
|
emissary_tau_base=0.01,
|
|
emissary_tau_max=1,
|
|
coherence_threshold=0.75,
|
|
witness_enabled=True,
|
|
memory_enabled=True,
|
|
)
|
|
)
|
|
|
|
# Create adapters
|
|
self.input_adapter = OpenClawInputAdapter(None)
|
|
self.output_adapter = OpenClawOutputAdapter(None)
|
|
|
|
# Hook to engine
|
|
self.engine.add_input(self.input_adapter)
|
|
self.engine.add_output(self.output_adapter)
|
|
|
|
# State
|
|
self._running = False
|
|
|
|
def hook_openclaw(self, session) -> None:
|
|
"""
|
|
Hook into live OpenClaw system.
|
|
|
|
Args:
|
|
session: OpenClaw gateway session
|
|
"""
|
|
self.input_adapter.hook_session(session)
|
|
self.output_adapter.hook_session(session)
|
|
|
|
def inject_message(self, message: Dict) -> None:
|
|
"""
|
|
Inject test message into system.
|
|
|
|
Args:
|
|
message: OpenClaw message format
|
|
"""
|
|
self.input_adapter.add_message(message)
|
|
|
|
def get_responses(self) -> List[Dict]:
|
|
"""
|
|
Get accumulated responses.
|
|
|
|
Returns:
|
|
List of response dicts
|
|
"""
|
|
return self.output_adapter.get_responses()
|
|
|
|
def run(self, blocking: bool = True) -> None:
|
|
"""Run the integration."""
|
|
self._running = True
|
|
self.engine.run(blocking=blocking)
|
|
|
|
def stop(self) -> None:
|
|
"""Stop the integration."""
|
|
self._running = False
|
|
self.engine.stop()
|
|
|
|
def get_coherence(self) -> float:
|
|
"""Get current coherence."""
|
|
return self.engine.get_coherence()
|
|
|
|
def get_state(self) -> Dict:
|
|
"""Get full state."""
|
|
state = self.engine.get_state()
|
|
return state.to_dict()
|
|
|
|
|
|
def demonstrate_openclaw_integration():
|
|
"""Demonstrate OpenClaw + BECOMINGONE integration."""
|
|
print("\n" + "="*70)
|
|
print("OPENCLAW + BECOMINGONE INTEGRATION DEMONSTRATION")
|
|
print("="*70 + "\n")
|
|
|
|
# Create integration
|
|
integration = OpenClawIntegration()
|
|
|
|
# Inject test messages (simulating OpenClaw conversation)
|
|
test_conversation = [
|
|
{
|
|
"text": "Hello, I'm Mark",
|
|
"author": "mark",
|
|
"channel": "telegram",
|
|
"intent": "greeting",
|
|
},
|
|
{
|
|
"text": "How are you doing today?",
|
|
"author": "mark",
|
|
"channel": "telegram",
|
|
"intent": "inquiry",
|
|
},
|
|
{
|
|
"text": "Tell me about THE_ONE",
|
|
"author": "mark",
|
|
"channel": "telegram",
|
|
"intent": "question",
|
|
},
|
|
]
|
|
|
|
print("Injecting test conversation:")
|
|
for msg in test_conversation:
|
|
integration.inject_message(msg)
|
|
print(f" - {msg['author']}: {msg['text']}")
|
|
|
|
print("\nProcessing through BECOMINGONE:")
|
|
print("-" * 40)
|
|
|
|
# Run engine for a few ticks
|
|
for i in range(5):
|
|
integration.engine._tick()
|
|
print(f"Tick {i+1}: coherence={integration.get_coherence():.3f}")
|
|
|
|
print("\nResponses generated:")
|
|
for response in integration.get_responses():
|
|
print(f" - {response['type']} ({response['confidence']} confidence)")
|
|
print(f" coherence={response['coherence']:.3f}")
|
|
|
|
print("\n" + "="*70)
|
|
print("KEY INSIGHT")
|
|
print("="*70 + "\n")
|
|
print("OpenClaw provides the MESSAGE ROUTING.")
|
|
print("BECOMINGONE provides the COHERENCE ENGINE.")
|
|
print("Together: A working AI system we can test and extend.")
|
|
print("\nThis allows us to:")
|
|
print(" 1. Test THE_ONE with real conversations")
|
|
print(" 2. Validate coherence dynamics in practice")
|
|
print(" 3. Build confidence before open sourcing")
|
|
print(" 4. PR hooks back to OpenClaw")
|
|
print("="*70 + "\n")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
demonstrate_openclaw_integration()
|