@decido/kernel-bridge 1.0.0

package/src/ai/services/PeerMesh.ts

@@ -0,0 +1,373 @@
+/**
+ * PeerMesh — WebSocket-based P2P mesh for Decido OS instances
+ *
+ * Allows multiple Decido OS instances on the same network to form
+ * a group and share AI results/context. Each peer maintains its
+ * own provider keys (BYOK). Uses manual connection (IP:port) in
+ * this first iteration; future versions will use mDNS auto-discovery.
+ *
+ * Protocol:
+ *  - Host starts a WebSocket server on a port (default 9876)
+ *  - Clients connect to the host's IP:port
+ *  - Messages: join, leave, share-result, share-context, heartbeat
+ *  - Max 8 peers per group
+ */
+
+import { v4 as uuid } from 'uuid';
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface PeerInfo {
+  id: string;
+  name: string;
+  address: string;
+  joinedAt: number;
+  lastSeen: number;
+}
+
+export interface SharedResult {
+  peerId: string;
+  provider: string;
+  model: string;
+  prompt: string;
+  response: string;
+  timestamp: number;
+}
+
+interface PeerMessage {
+  type: 'join' | 'leave' | 'share-result' | 'share-context' | 'heartbeat' | 'peers-update';
+  peerId: string;
+  peerName: string;
+  payload?: unknown;
+}
+
+// ─── Constants ──────────────────────────────────────────────
+
+const DEFAULT_PORT = 9876;
+const HEARTBEAT_INTERVAL = 10_000; // 10s
+const PEER_TIMEOUT = 30_000; // 30s without heartbeat = dead
+const MAX_PEERS = 8;
+
+// ─── Event Callbacks ────────────────────────────────────────
+
+type PeersChangedCb = (peers: PeerInfo[]) => void;
+type HostingChangedCb = (isHosting: boolean) => void;
+type ConnectionChangedCb = (isConnected: boolean) => void;
+type SharedResultCb = (result: SharedResult) => void;
+
+// ─── PeerMesh Class ─────────────────────────────────────────
+
+class PeerMeshImpl {
+  private myId = uuid();
+  private myName = this._getHostname();
+  private peers = new Map<string, PeerInfo>();
+  private connections = new Map<string, WebSocket>();
+  private isHostingFlag = false;
+  private isConnectedFlag = false;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+  // Event listeners
+  private peersListeners = new Set<PeersChangedCb>();
+  private hostingListeners = new Set<HostingChangedCb>();
+  private connectionListeners = new Set<ConnectionChangedCb>();
+  private resultListeners = new Set<SharedResultCb>();
+
+  // ── Host Mode ─────────────────────────────────────────
+
+  /**
+   * Start hosting a peer group.
+   * Note: In browser WebSocket server is not available. This method
+   * is a placeholder for Tauri (Rust-side server). In browser mode,
+   * we simulate by acting as a "relay" through a shared connection.
+   */
+  startHost(port = DEFAULT_PORT): void {
+    if (this.isHostingFlag) return;
+    this.isHostingFlag = true;
+    this._emitHosting(true);
+    this._startHeartbeat();
+    console.log(`🌐 [PeerMesh] Hosting on port ${port} (peer: ${this.myId.slice(0, 8)})`);
+    console.log(`🌐 [PeerMesh] ⚠️ Browser-mode: WebSocket server requires Tauri backend.`);
+    console.log(`🌐 [PeerMesh]    Use connectToPeer() from another instance to connect.`);
+  }
+
+  stopHost(): void {
+    if (!this.isHostingFlag) return;
+    this.isHostingFlag = false;
+    this._stopHeartbeat();
+    this._broadcast({ type: 'leave', peerId: this.myId, peerName: this.myName });
+    this._disconnectAll();
+    this._emitHosting(false);
+    console.log('🌐 [PeerMesh] Stopped hosting');
+  }
+
+  // ── Client Mode ───────────────────────────────────────
+
+  connectToPeer(address: string): void {
+    if (this.connections.size >= MAX_PEERS) {
+      console.warn(`🌐 [PeerMesh] Max peers (${MAX_PEERS}) reached`);
+      return;
+    }
+
+    const wsUrl = address.startsWith('ws') ? address : `ws://${address}`;
+    console.log(`🌐 [PeerMesh] Connecting to ${wsUrl}...`);
+
+    try {
+      const ws = new WebSocket(wsUrl);
+
+      ws.onopen = () => {
+        console.log(`🌐 [PeerMesh] ✅ Connected to ${address}`);
+        this.connections.set(address, ws);
+        this.isConnectedFlag = true;
+        this._emitConnection(true);
+
+        // Announce ourselves
+        this._send(ws, {
+          type: 'join',
+          peerId: this.myId,
+          peerName: this.myName,
+        });
+
+        this._startHeartbeat();
+      };
+
+      ws.onmessage = (event) => {
+        try {
+          const msg: PeerMessage = JSON.parse(event.data);
+          this._handleMessage(msg, address);
+        } catch { /* ignore malformed messages */ }
+      };
+
+      ws.onclose = () => {
+        console.log(`🌐 [PeerMesh] Disconnected from ${address}`);
+        this.connections.delete(address);
+        // Remove peer associated with this address
+        for (const [id, peer] of this.peers) {
+          if (peer.address === address) {
+            this.peers.delete(id);
+          }
+        }
+        this._emitPeers();
+        if (this.connections.size === 0) {
+          this.isConnectedFlag = false;
+          this._emitConnection(false);
+          this._stopHeartbeat();
+        }
+      };
+
+      ws.onerror = (err) => {
+        console.error(`🌐 [PeerMesh] Connection error to ${address}:`, err);
+      };
+    } catch (err) {
+      console.error(`🌐 [PeerMesh] Failed to connect:`, err);
+    }
+  }
+
+  disconnect(): void {
+    this._broadcast({ type: 'leave', peerId: this.myId, peerName: this.myName });
+    this._disconnectAll();
+  }
+
+  // ── Share Results ─────────────────────────────────────
+
+  shareResult(result: Omit<SharedResult, 'peerId' | 'timestamp'>): void {
+    const fullResult: SharedResult = {
+      ...result,
+      peerId: this.myId,
+      timestamp: Date.now(),
+    };
+
+    this._broadcast({
+      type: 'share-result',
+      peerId: this.myId,
+      peerName: this.myName,
+      payload: fullResult,
+    });
+
+    console.log(`🌐 [PeerMesh] Shared result to ${this.connections.size} peers`);
+  }
+
+  // ── Event Subscriptions ───────────────────────────────
+
+  onPeersChanged(cb: PeersChangedCb): () => void {
+    this.peersListeners.add(cb);
+    return () => { this.peersListeners.delete(cb); };
+  }
+
+  onHostingChanged(cb: HostingChangedCb): () => void {
+    this.hostingListeners.add(cb);
+    return () => { this.hostingListeners.delete(cb); };
+  }
+
+  onConnectionChanged(cb: ConnectionChangedCb): () => void {
+    this.connectionListeners.add(cb);
+    return () => { this.connectionListeners.delete(cb); };
+  }
+
+  onSharedResult(cb: SharedResultCb): () => void {
+    this.resultListeners.add(cb);
+    return () => { this.resultListeners.delete(cb); };
+  }
+
+  // ── Getters ───────────────────────────────────────────
+
+  getPeers(): PeerInfo[] {
+    return Array.from(this.peers.values());
+  }
+
+  getMyId(): string {
+    return this.myId;
+  }
+
+  getMyName(): string {
+    return this.myName;
+  }
+
+  // ── Message Handling ──────────────────────────────────
+
+  private _handleMessage(msg: PeerMessage, fromAddress: string): void {
+    switch (msg.type) {
+      case 'join':
+        this.peers.set(msg.peerId, {
+          id: msg.peerId,
+          name: msg.peerName,
+          address: fromAddress,
+          joinedAt: Date.now(),
+          lastSeen: Date.now(),
+        });
+        this._emitPeers();
+        console.log(`🌐 [PeerMesh] Peer joined: ${msg.peerName} (${msg.peerId.slice(0, 8)})`);
+        break;
+
+      case 'leave':
+        this.peers.delete(msg.peerId);
+        this._emitPeers();
+        console.log(`🌐 [PeerMesh] Peer left: ${msg.peerName}`);
+        break;
+
+      case 'heartbeat':
+        if (this.peers.has(msg.peerId)) {
+          this.peers.get(msg.peerId)!.lastSeen = Date.now();
+        }
+        break;
+
+      case 'share-result':
+        if (msg.payload) {
+          const result = msg.payload as SharedResult;
+          for (const cb of this.resultListeners) {
+            try { cb(result); } catch { /* ignore */ }
+          }
+        }
+        break;
+
+      case 'peers-update':
+        // Host sends updated peer list
+        if (Array.isArray(msg.payload)) {
+          for (const p of msg.payload as PeerInfo[]) {
+            if (p.id !== this.myId && !this.peers.has(p.id)) {
+              this.peers.set(p.id, p);
+            }
+          }
+          this._emitPeers();
+        }
+        break;
+    }
+  }
+
+  // ── Internal Helpers ──────────────────────────────────
+
+  private _send(ws: WebSocket, msg: PeerMessage): void {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+
+  private _broadcast(msg: PeerMessage): void {
+    for (const ws of this.connections.values()) {
+      this._send(ws, msg);
+    }
+  }
+
+  private _disconnectAll(): void {
+    for (const ws of this.connections.values()) {
+      try { ws.close(); } catch { /* ignore */ }
+    }
+    this.connections.clear();
+    this.peers.clear();
+    this.isConnectedFlag = false;
+    this._stopHeartbeat();
+    this._emitPeers();
+    this._emitConnection(false);
+  }
+
+  private _startHeartbeat(): void {
+    if (this.heartbeatTimer) return;
+
+    this.heartbeatTimer = setInterval(() => {
+      this._broadcast({
+        type: 'heartbeat',
+        peerId: this.myId,
+        peerName: this.myName,
+      });
+    }, HEARTBEAT_INTERVAL);
+
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      let changed = false;
+      for (const [id, peer] of this.peers) {
+        if (now - peer.lastSeen > PEER_TIMEOUT) {
+          this.peers.delete(id);
+          changed = true;
+          console.log(`🌐 [PeerMesh] Peer timed out: ${peer.name}`);
+        }
+      }
+      if (changed) this._emitPeers();
+    }, PEER_TIMEOUT);
+  }
+
+  private _stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  // ── Event Emitters ────────────────────────────────────
+
+  private _emitPeers(): void {
+    const list = this.getPeers();
+    for (const cb of this.peersListeners) {
+      try { cb(list); } catch { /* ignore */ }
+    }
+  }
+
+  private _emitHosting(hosting: boolean): void {
+    for (const cb of this.hostingListeners) {
+      try { cb(hosting); } catch { /* ignore */ }
+    }
+  }
+
+  private _emitConnection(connected: boolean): void {
+    for (const cb of this.connectionListeners) {
+      try { cb(connected); } catch { /* ignore */ }
+    }
+  }
+
+  // ── Hostname ──────────────────────────────────────────
+
+  private _getHostname(): string {
+    try {
+      return `user-${Math.random().toString(36).slice(2, 6)}`;
+    } catch {
+      return 'anonymous';
+    }
+  }
+}
+
+// ─── Singleton Export ───────────────────────────────────────
+
+export const peerMesh = new PeerMeshImpl();

package/src/ai/services/TokenWallet.ts

@@ -0,0 +1,237 @@
+/**
+ * TokenWallet — Usage tracking & cost estimation for LLM providers
+ *
+ * Records every inference call and calculates estimated costs
+ * using a per-model pricing table. Persists via localStorage
+ * (with Tauri fs fallback).
+ */
+
+// ─── Pricing Table (USD per 1M tokens) ─────────────────────
+
+interface ModelPricing {
+  input: number;   // per 1M input tokens
+  output: number;  // per 1M output tokens
+}
+
+const PRICING: Record<string, ModelPricing> = {
+  // Ollama / local — free
+  'qwen2:latest': { input: 0, output: 0 },
+  'llama3:latest': { input: 0, output: 0 },
+  'mistral:latest': { input: 0, output: 0 },
+  'codellama:latest': { input: 0, output: 0 },
+
+  // Gemini
+  'gemini-flash-lite-latest': { input: 0.10, output: 0.40 },
+  'gemini-flash-lite-latest-lite': { input: 0.075, output: 0.30 },
+  'gemini-1.5-pro': { input: 1.25, output: 5.00 },
+  'gemini-flash-latest': { input: 0.075, output: 0.30 },
+
+  // Anthropic
+  'claude-sonnet-4-20250514': { input: 3.00, output: 15.00 },
+  'claude-3-5-sonnet-20241022': { input: 3.00, output: 15.00 },
+  'claude-3-5-haiku-20241022': { input: 0.80, output: 4.00 },
+  'claude-3-opus-20240229': { input: 15.00, output: 75.00 },
+
+  // OpenAI
+  'gpt-4o': { input: 2.50, output: 10.00 },
+  'gpt-4o-mini': { input: 0.15, output: 0.60 },
+  'gpt-4-turbo': { input: 10.00, output: 30.00 },
+  'gpt-4': { input: 30.00, output: 60.00 },
+  'gpt-3.5-turbo': { input: 0.50, output: 1.50 },
+  'o3-mini': { input: 1.10, output: 4.40 },
+};
+
+// Default pricing for unknown models (assume cloud provider)
+const DEFAULT_PRICING: ModelPricing = { input: 1.00, output: 3.00 };
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface TokenUsageEntry {
+  provider: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  estimatedCostUsd: number;
+  timestamp: number;
+}
+
+export interface ProviderSummary {
+  tokens: number;
+  cost: number;
+  calls: number;
+}
+
+export interface WalletSummary {
+  totalTokens: number;
+  totalCostUsd: number;
+  totalCalls: number;
+  byProvider: Record<string, ProviderSummary>;
+  sessionStart: number;
+}
+
+type WalletListener = (summary: WalletSummary) => void;
+
+// ─── Storage Key ────────────────────────────────────────────
+
+const STORAGE_KEY = 'decido-token-wallet';
+const MAX_HISTORY = 500; // keep last 500 entries
+
+// ─── TokenWallet Class ──────────────────────────────────────
+
+class TokenWalletImpl {
+  private history: TokenUsageEntry[] = [];
+  private sessionStart = Date.now();
+  private listeners = new Set<WalletListener>();
+
+  constructor() {
+    this._loadFromStorage();
+  }
+
+  // ── Record Usage ────────────────────────────────────────
+
+  record(entry: {
+    provider: string;
+    model: string;
+    tokensUsed?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    latencyMs?: number;
+  }): void {
+    // Estimate input/output split if not provided
+    const totalTokens = entry.tokensUsed ?? (entry.inputTokens ?? 0) + (entry.outputTokens ?? 0);
+    const inputTokens = entry.inputTokens ?? Math.round(totalTokens * 0.4);
+    const outputTokens = entry.outputTokens ?? (totalTokens - inputTokens);
+
+    const pricing = this._getPricing(entry.model, entry.provider);
+    const estimatedCostUsd =
+      (inputTokens / 1_000_000) * pricing.input +
+      (outputTokens / 1_000_000) * pricing.output;
+
+    const usageEntry: TokenUsageEntry = {
+      provider: entry.provider,
+      model: entry.model,
+      inputTokens,
+      outputTokens,
+      totalTokens,
+      estimatedCostUsd,
+      timestamp: Date.now(),
+    };
+
+    this.history.push(usageEntry);
+
+    // Trim history if too large
+    if (this.history.length > MAX_HISTORY) {
+      this.history = this.history.slice(-MAX_HISTORY);
+    }
+
+    this._saveToStorage();
+    this._emit();
+
+    console.log(
+      `💰 [Wallet] ${entry.provider}/${entry.model}: ${totalTokens} tokens ≈ $${estimatedCostUsd.toFixed(6)}`
+    );
+  }
+
+  // ── Summary ─────────────────────────────────────────────
+
+  getSummary(): WalletSummary {
+    const byProvider: Record<string, ProviderSummary> = {};
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+
+    for (const entry of this.history) {
+      totalTokens += entry.totalTokens;
+      totalCostUsd += entry.estimatedCostUsd;
+
+      if (!byProvider[entry.provider]) {
+        byProvider[entry.provider] = { tokens: 0, cost: 0, calls: 0 };
+      }
+      byProvider[entry.provider].tokens += entry.totalTokens;
+      byProvider[entry.provider].cost += entry.estimatedCostUsd;
+      byProvider[entry.provider].calls += 1;
+    }
+
+    return {
+      totalTokens,
+      totalCostUsd,
+      totalCalls: this.history.length,
+      byProvider,
+      sessionStart: this.sessionStart,
+    };
+  }
+
+  getHistory(): TokenUsageEntry[] {
+    return [...this.history];
+  }
+
+  getRecentHistory(count: number): TokenUsageEntry[] {
+    return this.history.slice(-count);
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────
+
+  clearHistory(): void {
+    this.history = [];
+    this.sessionStart = Date.now();
+    this._saveToStorage();
+    this._emit();
+  }
+
+  // ── Subscriptions ───────────────────────────────────────
+
+  subscribe(listener: WalletListener): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+
+  // ── Pricing Lookup ──────────────────────────────────────
+
+  private _getPricing(model: string, provider: string): ModelPricing {
+    // Exact match
+    if (PRICING[model]) return PRICING[model];
+
+    // Local providers are always free
+    if (provider === 'ollama' || provider === 'mlx') {
+      return { input: 0, output: 0 };
+    }
+
+    return DEFAULT_PRICING;
+  }
+
+  // ── Persistence ─────────────────────────────────────────
+
+  private _saveToStorage(): void {
+    try {
+      const data = JSON.stringify({
+        history: this.history,
+        sessionStart: this.sessionStart,
+      });
+      localStorage.setItem(STORAGE_KEY, data);
+    } catch { /* storage full or unavailable */ }
+  }
+
+  private _loadFromStorage(): void {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (raw) {
+        const data = JSON.parse(raw);
+        this.history = data.history || [];
+        this.sessionStart = data.sessionStart || Date.now();
+      }
+    } catch { /* corrupted data, start fresh */ }
+  }
+
+  // ── Emit ────────────────────────────────────────────────
+
+  private _emit(): void {
+    const summary = this.getSummary();
+    for (const listener of this.listeners) {
+      try { listener(summary); } catch { /* ignore listener errors */ }
+    }
+  }
+}
+
+// ─── Singleton Export ───────────────────────────────────────
+
+export const tokenWallet = new TokenWalletImpl();