agentgui 1.0.654 → 1.0.658

package/lib/codec.js

@@ -0,0 +1,53 @@
+/**
+ * Binary codec for WebSocket messages.
+ * Wraps msgpackr for framing + GPT tokenizer BPE compression for large text fields.
+ *
+ * Wire format: msgpackr-packed object where string fields > THRESHOLD chars
+ * are replaced with { __tok: true, d: Uint32Array } — tokenized and decompressed
+ * transparently on both sides.
+ */
+
+import { pack, unpack } from 'msgpackr';
+import { encode as tokEncode, decode as tokDecode } from 'gpt-tokenizer';
+
+const THRESHOLD = 200; // bytes before compression is worthwhile
+const COMPRESSIBLE = new Set(['content', 'text', 'output', 'response', 'prompt', 'input', 'data']);
+
+function compressText(str) {
+  return { __tok: true, d: tokEncode(str) };
+}
+
+function decompressText(val) {
+  return tokDecode(val.d);
+}
+
+function encodeObj(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(encodeObj);
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    const v = obj[k];
+    if (COMPRESSIBLE.has(k) && typeof v === 'string' && v.length > THRESHOLD) {
+      out[k] = compressText(v);
+    } else if (v && typeof v === 'object' && !ArrayBuffer.isView(v)) {
+      out[k] = encodeObj(v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function decodeObj(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(decodeObj);
+  if (obj.__tok && obj.d) return decompressText(obj);
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k] = decodeObj(obj[k]);
+  }
+  return out;
+}
+
+export function encode(obj) { return pack(encodeObj(obj)); }
+export function decode(buf) { return decodeObj(unpack(buf instanceof Uint8Array ? buf : new Uint8Array(buf))); }

package/lib/ws-optimizer.js

@@ -1,4 +1,4 @@
-import { pack } from 'msgpackr';
+import { encode } from './codec.js';
 
 const MESSAGE_PRIORITY = {
   high: ['streaming_error', 'streaming_complete', 'rate_limit_hit', 'streaming_cancelled', 'run_cancelled', 'tool_install_complete', 'tool_update_complete', 'tool_install_failed', 'tool_update_failed'],
@@ -84,9 +84,8 @@ class ClientQueue {
       if (allowedCount <= 0) { this.scheduleFlush(); return; }
       batch.splice(allowedCount);
     }
-    // Pack as msgpackr binary — perMessageDeflate on the WS server handles gzip
     const envelope = batch.length === 1 ? batch[0] : batch;
-    const binary = pack(envelope);
+    const binary = encode(envelope);
     this.ws.send(binary);
     this.messageCount += batch.length;
     this.bytesSent += binary.length;

package/lib/ws-protocol.js

@@ -1,7 +1,7 @@
-import { pack, unpack } from 'msgpackr';
+import { encode, decode } from './codec.js';
 
 function sendBinary(ws, obj) {
-  if (ws.readyState === 1) ws.send(pack(obj));
+  if (ws.readyState === 1) ws.send(encode(obj));
 }
 
 class WsRouter {
@@ -33,7 +33,7 @@ class WsRouter {
   }
 
   broadcast(clients, type, data) {
-    const msg = pack({ t: type, d: data || {} });
+    const msg = encode({ t: type, d: data || {} });
     for (const ws of clients) {
       if (ws.readyState === 1) ws.send(msg);
     }
@@ -42,12 +42,7 @@ class WsRouter {
   async onMessage(ws, rawData) {
     let parsed;
     try {
-      // Accept binary (msgpackr) or text (JSON fallback / legacy hot-reload)
-      if (Buffer.isBuffer(rawData) || rawData instanceof Uint8Array) {
-        parsed = unpack(rawData);
-      } else {
-        parsed = JSON.parse(rawData.toString());
-      }
+      parsed = decode(rawData);
     } catch {
       sendBinary(ws, { r: null, e: { c: 400, m: 'Invalid message' } });
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.654",
+  "version": "1.0.658",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -16,9 +16,10 @@ import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
-import { SSEStreamManager } from './lib/sse-stream.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
+import { encode as wsEncode } from './lib/codec.js';
+const sendWs = (ws, obj) => { if (ws.readyState === 1) ws.send(wsEncode(obj)); };
 import { register as registerConvHandlers } from './lib/ws-handlers-conv.js';
 import { register as registerSessionHandlers } from './lib/ws-handlers-session.js';
 import { register as registerRunHandlers } from './lib/ws-handlers-run.js';
@@ -278,10 +279,8 @@ function pushTTSAudio(cacheKey, wav, conversationId, sessionId, voiceId) {
 }
 
 
-const VOICE_INSTRUCTIONS = `Plain text. Spoken aloud. Conversational. No markdown, formatting, bullets, or lists. Short sentences. Technical facts only.`;
-
 function buildSystemPrompt(agentId, model, subAgent) {
-  const parts = [VOICE_INSTRUCTIONS];
+  const parts = [];
   if (agentId && agentId !== 'claude-code') {
     const displayAgentId = agentId.split('-·-')[0];
     parts.push(`Use ${displayAgentId} subagent for all tasks.`);
@@ -1537,57 +1536,9 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    // POST /runs/stream - Create stateless run and stream output (MUST be before generic /runs/:id route)
+    // POST /runs/stream - SSE removed, use WebSocket
     if (pathOnly === '/api/runs/stream' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const { agent_id, input, config } = body;
-      if (!agent_id) {
-        sendJSON(req, res, 422, { error: 'agent_id is required' });
-        return;
-      }
-      const agent = discoveredAgents.find(a => a.id === agent_id);
-      if (!agent) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-      const run = queries.createRun(agent_id, null, input, config);
-      const sseManager = new SSEStreamManager(res, run.run_id);
-      sseManager.start();
-      sseManager.sendProgress({ type: 'run_created', run_id: run.run_id });
-
-      const eventHandler = (eventData) => {
-        if (eventData.sessionId === run.run_id || eventData.conversationId === run.thread_id) {
-          if (eventData.type === 'streaming_progress' && eventData.block) {
-            sseManager.sendProgress(eventData.block);
-          } else if (eventData.type === 'streaming_error') {
-            sseManager.sendError(eventData.error || 'Execution error');
-          } else if (eventData.type === 'streaming_complete') {
-            sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
-            sseManager.cleanup();
-          }
-        }
-      };
-
-      sseStreamHandlers.set(run.run_id, eventHandler);
-      req.on('close', () => {
-        sseStreamHandlers.delete(run.run_id);
-        sseManager.cleanup();
-      });
-
-      const statelessThreadId = queries.getRun(run.run_id)?.thread_id;
-      if (statelessThreadId) {
-        const conv = queries.getConversation(statelessThreadId);
-        if (conv && input?.content) {
-          const statelessSession = queries.createSession(statelessThreadId);
-          queries.updateRunStatus(run.run_id, 'active');
-          activeExecutions.set(statelessThreadId, { pid: null, startTime: Date.now(), sessionId: statelessSession.id, lastActivity: Date.now() });
-          activeProcessesByRunId.set(run.run_id, { threadId: statelessThreadId, sessionId: statelessSession.id });
-          queries.setIsStreaming(statelessThreadId, true);
-          processMessageWithStreaming(statelessThreadId, null, statelessSession.id, input.content, agent_id, config?.model || null)
-            .then(() => { queries.updateRunStatus(run.run_id, 'success'); activeProcessesByRunId.delete(run.run_id); })
-            .catch((err) => { queries.updateRunStatus(run.run_id, 'error'); activeProcessesByRunId.delete(run.run_id); sseManager.sendError(err.message); sseManager.cleanup(); });
-        }
-      }
+      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
       return;
     }
 
@@ -2346,35 +2297,7 @@ const server = http.createServer(async (req, res) => {
 
     const runStreamMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/stream$/);
     if (runStreamMatch && req.method === 'GET') {
-      const runId = runStreamMatch[1];
-      const run = queries.getRun(runId);
-      if (!run) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      const sseManager = new SSEStreamManager(res, runId);
-      sseManager.start();
-      sseManager.sendProgress({ type: 'joined', run_id: runId });
-
-      const eventHandler = (eventData) => {
-        if (eventData.sessionId === runId || eventData.conversationId === run.thread_id) {
-          if (eventData.type === 'streaming_progress' && eventData.block) {
-            sseManager.sendProgress(eventData.block);
-          } else if (eventData.type === 'streaming_error') {
-            sseManager.sendError(eventData.error || 'Execution error');
-          } else if (eventData.type === 'streaming_complete') {
-            sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
-            sseManager.cleanup();
-          }
-        }
-      };
-
-      sseStreamHandlers.set(runId, eventHandler);
-      req.on('close', () => {
-        sseStreamHandlers.delete(runId);
-        sseManager.cleanup();
-      });
+      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
       return;
     }
 
@@ -3220,112 +3143,17 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    // POST /threads/{thread_id}/runs/stream - Create run on thread and stream output
+    // POST /threads/{thread_id}/runs/stream - SSE removed, use WebSocket
     const threadRunsStreamMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/stream$/);
     if (threadRunsStreamMatch && req.method === 'POST') {
-      const threadId = threadRunsStreamMatch[1];
-      try {
-        const body = await parseBody(req);
-        const { agent_id, input, config } = body;
-
-        const thread = queries.getThread(threadId);
-        if (!thread) {
-          sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
-          return;
-        }
-
-        if (thread.status !== 'idle') {
-          sendJSON(req, res, 409, { error: 'Thread has pending runs', type: 'conflict' });
-          return;
-        }
-
-        const agent = discoveredAgents.find(a => a.id === agent_id);
-        if (!agent) {
-          sendJSON(req, res, 404, { error: 'Agent not found', type: 'not_found' });
-          return;
-        }
-
-        const run = queries.createRun(agent_id, threadId, input, config);
-        const sseManager = new SSEStreamManager(res, run.run_id);
-        sseManager.start();
-        sseManager.sendProgress({ type: 'run_created', run_id: run.run_id, thread_id: threadId });
-
-        const eventHandler = (eventData) => {
-          if (eventData.sessionId === run.run_id || eventData.conversationId === threadId) {
-            if (eventData.type === 'streaming_progress' && eventData.block) {
-              sseManager.sendProgress(eventData.block);
-            } else if (eventData.type === 'streaming_error') {
-              sseManager.sendError(eventData.error || 'Execution error');
-            } else if (eventData.type === 'streaming_complete') {
-              sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
-              sseManager.cleanup();
-            }
-          }
-        };
-
-        sseStreamHandlers.set(run.run_id, eventHandler);
-        req.on('close', () => {
-          sseStreamHandlers.delete(run.run_id);
-          sseManager.cleanup();
-        });
-
-        const conv = queries.getConversation(threadId);
-        if (conv && input?.content) {
-          const session = queries.createSession(threadId);
-          queries.updateRunStatus(run.run_id, 'active');
-          activeExecutions.set(threadId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-          activeProcessesByRunId.set(run.run_id, { threadId, sessionId: session.id });
-          queries.setIsStreaming(threadId, true);
-          processMessageWithStreaming(threadId, null, session.id, input.content, agent_id, config?.model || null)
-            .then(() => { queries.updateRunStatus(run.run_id, 'success'); activeProcessesByRunId.delete(run.run_id); })
-            .catch((err) => { queries.updateRunStatus(run.run_id, 'error'); activeProcessesByRunId.delete(run.run_id); sseManager.sendError(err.message); sseManager.cleanup(); });
-        }
-      } catch (err) {
-        sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-      }
+      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
       return;
     }
 
-    // GET /threads/{thread_id}/runs/{run_id}/stream - Stream output from run on thread
+    // GET /threads/{thread_id}/runs/{run_id}/stream - SSE removed, use WebSocket
     const threadRunStreamMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/stream$/);
     if (threadRunStreamMatch && req.method === 'GET') {
-      const threadId = threadRunStreamMatch[1];
-      const runId = threadRunStreamMatch[2];
-
-      const thread = queries.getThread(threadId);
-      if (!thread) {
-        sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
-        return;
-      }
-
-      const run = queries.getRun(runId);
-      if (!run || run.thread_id !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found on thread', type: 'not_found' });
-        return;
-      }
-
-      const sseManager = new SSEStreamManager(res, runId);
-      sseManager.start();
-      sseManager.sendProgress({ type: 'joined', run_id: runId, thread_id: threadId });
-
-      const eventHandler = (eventData) => {
-        if (eventData.sessionId === runId || eventData.conversationId === threadId) {
-          if (eventData.type === 'streaming_progress' && eventData.block) {
-            sseManager.sendProgress(eventData.block);
-          } else if (eventData.type === 'streaming_error') {
-            sseManager.sendError(eventData.error || 'Execution error');
-          } else if (eventData.type === 'streaming_complete') {
-            sseManager.sendComplete({ eventCount: eventData.eventCount }, { timestamp: eventData.timestamp });
-            sseManager.cleanup();
-          }
-        }
-      };
-
-      sseStreamHandlers.set(runId, eventHandler);
-      req.on('close', () => {
-        sseStreamHandlers.delete(runId);
-        sseManager.cleanup();
-      });
+      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
       return;
     }
 
@@ -4102,7 +3930,6 @@ wss.on('error', (err) => {
 const hotReloadClients = [];
 const syncClients = new Set();
 const subscriptionIndex = new Map();
-const sseStreamHandlers = new Map();
 const pm2Subscribers = new Set();
 
 wss.on('connection', (ws, req) => {
@@ -4117,7 +3944,7 @@ wss.on('connection', (ws, req) => {
     ws.subscriptions = new Set();
     ws.clientId = `client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
-    ws.send(JSON.stringify({
+    sendWs(ws, ({
       type: 'sync_connected',
       clientId: ws.clientId,
       timestamp: Date.now()
@@ -4187,11 +4014,6 @@ function broadcastSync(event) {
       }
     }
 
-    if (sseStreamHandlers.size > 0) {
-      for (const [runId, handler] of sseStreamHandlers.entries()) {
-        try { handler(event); } catch (e) {}
-      }
-    }
   } catch (err) {
     console.error('[BROADCAST] Error (contained):', err.message);
   }
@@ -4242,7 +4064,7 @@ wsRouter.onLegacy((data, ws) => {
     }
     const subTarget = data.sessionId || data.conversationId;
     debugLog(`[WebSocket] Client ${ws.clientId} subscribed to ${subTarget}`);
-    ws.send(JSON.stringify({
+    sendWs(ws, ({
       type: 'subscription_confirmed',
       sessionId: data.sessionId,
       conversationId: data.conversationId,
@@ -4253,7 +4075,7 @@ wsRouter.onLegacy((data, ws) => {
     if (data.conversationId && activeExecutions.has(data.conversationId)) {
       const execution = activeExecutions.get(data.conversationId);
       const conv = queries.getConversation(data.conversationId);
-      ws.send(JSON.stringify({
+      sendWs(ws, ({
         type: 'streaming_start',
         sessionId: execution.sessionId,
         conversationId: data.conversationId,
@@ -4271,7 +4093,7 @@ wsRouter.onLegacy((data, ws) => {
 
         const latestSession = queries.getLatestSession(data.conversationId);
         if (latestSession) {
-          ws.send(JSON.stringify({
+          sendWs(ws, ({
             type: 'streaming_resumed',
             sessionId: latestSession.id,
             conversationId: data.conversationId,
@@ -4282,7 +4104,7 @@ wsRouter.onLegacy((data, ws) => {
           }));
 
           checkpointManager.injectCheckpointEvents(latestSession.id, checkpoint, (evt) => {
-            ws.send(JSON.stringify({
+            sendWs(ws, ({
               ...evt,
               sessionId: latestSession.id,
               conversationId: data.conversationId
@@ -4305,7 +4127,7 @@ wsRouter.onLegacy((data, ws) => {
     }
     debugLog(`[WebSocket] Client ${ws.clientId} unsubscribed from ${data.sessionId || data.conversationId}`);
   } else if (data.type === 'get_subscriptions') {
-    ws.send(JSON.stringify({
+    sendWs(ws, ({
       type: 'subscriptions',
       subscriptions: Array.from(ws.subscriptions),
       timestamp: Date.now()
@@ -4317,7 +4139,7 @@ wsRouter.onLegacy((data, ws) => {
     ws.latencyAvg = data.avg || 0;
     ws.latencyTrend = data.trend || 'stable';
   } else if (data.type === 'ping') {
-    ws.send(JSON.stringify({
+    sendWs(ws, ({
       type: 'pong',
       requestId: data.requestId,
       timestamp: Date.now()
@@ -4340,18 +4162,18 @@ wsRouter.onLegacy((data, ws) => {
       ws.terminalProc = proc;
       ws.terminalPty = true;
       proc.on('data', (chunk) => {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_output', data: Buffer.from(chunk).toString('base64'), encoding: 'base64' }));
+        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: Buffer.from(chunk).toString('base64'), encoding: 'base64' }));
       });
       proc.on('exit', (code) => {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_exit', code }));
+        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code });
         ws.terminalProc = null;
       });
       proc.on('error', (err) => {
         console.error('[TERMINAL] PTY error (contained):', err.message);
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_exit', code: 1, error: err.message }));
+        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message });
         ws.terminalProc = null;
       });
-      ws.send(JSON.stringify({ type: 'terminal_started', timestamp: Date.now() }));
+      sendWs(ws, ({ type: 'terminal_started', timestamp: Date.now() }));
     } catch (e) {
       console.error('[TERMINAL] Failed to spawn PTY, falling back to pipes:', e.message);
       const { spawn } = require('child_process');
@@ -4361,24 +4183,24 @@ wsRouter.onLegacy((data, ws) => {
       ws.terminalProc = proc;
       ws.terminalPty = false;
       proc.stdout.on('data', (chunk) => {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
+        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
       });
       proc.stderr.on('data', (chunk) => {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
+        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
       });
       proc.on('exit', (code) => {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_exit', code }));
+        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code });
         ws.terminalProc = null;
       });
       proc.on('error', (err) => {
         console.error('[TERMINAL] Spawn error (contained):', err.message);
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'terminal_exit', code: 1, error: err.message }));
+        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message });
         ws.terminalProc = null;
       });
       proc.stdin.on('error', () => {});
       proc.stdout.on('error', () => {});
       proc.stderr.on('error', () => {});
-      ws.send(JSON.stringify({ type: 'terminal_started', timestamp: Date.now() }));
+      sendWs(ws, ({ type: 'terminal_started', timestamp: Date.now() }));
     }
   } else if (data.type === 'terminal_input') {
     if (ws.terminalProc) {
@@ -4407,56 +4229,56 @@ wsRouter.onLegacy((data, ws) => {
      }
     } else if (data.type === 'pm2_list') {
       if (!pm2Manager.connected) {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
+        if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
       } else {
         pm2Manager.listProcesses().then(processes => {
           if (ws.readyState === 1) {
             const hasActive = processes.some(p => ['online','launching','stopping','waiting restart'].includes(p.status));
-            ws.send(JSON.stringify({ type: 'pm2_list_response', processes, hasActive }));
+            sendWs(ws, { type: 'pm2_list_response', processes, hasActive });
           }
         }).catch(() => {
-          if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'pm2_unavailable', reason: 'list failed', timestamp: Date.now() }));
+          if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'list failed', timestamp: Date.now() }));
         });
       }
     } else if (data.type === 'pm2_start_monitoring') {
       pm2Subscribers.add(ws);
       ws.pm2Subscribed = true;
       if (!pm2Manager.connected) {
-        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
+        if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
       } else {
-        ws.send(JSON.stringify({ type: 'pm2_monitoring_started' }));
+        sendWs(ws, { type: 'pm2_monitoring_started' });
       }
     } else if (data.type === 'pm2_stop_monitoring') {
       pm2Subscribers.delete(ws);
       ws.pm2Subscribed = false;
-      ws.send(JSON.stringify({ type: 'pm2_monitoring_stopped' }));
+      sendWs(ws, { type: 'pm2_monitoring_stopped' });
     } else if (data.type === 'pm2_start') {
       pm2Manager.startProcess(data.name).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_start_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_start_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_stop') {
       pm2Manager.stopProcess(data.name).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_stop_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_stop_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_restart') {
       pm2Manager.restartProcess(data.name).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_restart_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_restart_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_delete') {
       pm2Manager.deleteProcess(data.name).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_delete_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_delete_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_logs') {
       pm2Manager.getLogs(data.name, { lines: data.lines || 100 }).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_logs_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_logs_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_flush_logs') {
       pm2Manager.flushLogs(data.name).then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_flush_logs_response', name: data.name, ...result }));
+        sendWs(ws, { type: 'pm2_flush_logs_response', name: data.name, ...result });
       });
     } else if (data.type === 'pm2_ping') {
       pm2Manager.ping().then(result => {
-        ws.send(JSON.stringify({ type: 'pm2_ping_response', ...result }));
+        sendWs(ws, { type: 'pm2_ping_response', ...result });
       });
     }
 

package/static/index.html

@@ -3250,7 +3250,6 @@
   <script defer src="/gm/js/streaming-renderer.js"></script>
   <script defer src="/gm/js/image-loader.js"></script>
   <script src="/gm/lib/msgpackr.min.js"></script>
-  <script defer src="/gm/js/event-consolidator.js"></script>
   <script defer src="/gm/js/websocket-manager.js"></script>
   <script defer src="/gm/js/ws-client.js"></script>
 <script defer src="/gm/js/syntax-highlighter.js"></script>

package/static/js/client.js

@@ -80,7 +80,6 @@ class AgentGUIClient {
     this._scrollAnimating = false;
     this._scrollLerpFactor = config.scrollAnimationSpeed || 0.15;
 
-    this._consolidator = typeof EventConsolidator !== 'undefined' ? new EventConsolidator() : null;
 
     this._serverProcessingEstimate = 2000;
     this._lastSendTime = 0;

package/static/js/codec.js

@@ -0,0 +1,47 @@
+/**
+ * Client-side codec — mirrors lib/codec.js exactly.
+ * msgpackr (global from msgpackr.min.js) + GPT tokenizer BPE compression.
+ */
+import { encode as tokEncode, decode as tokDecode } from 'https://esm.sh/gpt-tokenizer';
+
+const THRESHOLD = 200;
+const COMPRESSIBLE = new Set(['content', 'text', 'output', 'response', 'prompt', 'input', 'data']);
+
+function compressText(str) {
+  return { __tok: true, d: tokEncode(str) };
+}
+
+function decompressText(val) {
+  return tokDecode(val.d);
+}
+
+function encodeObj(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(encodeObj);
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    const v = obj[k];
+    if (COMPRESSIBLE.has(k) && typeof v === 'string' && v.length > THRESHOLD) {
+      out[k] = compressText(v);
+    } else if (v && typeof v === 'object' && !(v instanceof ArrayBuffer) && !ArrayBuffer.isView(v)) {
+      out[k] = encodeObj(v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function decodeObj(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(decodeObj);
+  if (obj.__tok && obj.d) return decompressText(obj);
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k] = decodeObj(obj[k]);
+  }
+  return out;
+}
+
+export function encode(obj) { return msgpackr.pack(encodeObj(obj)); }
+export function decode(buf) { return decodeObj(msgpackr.unpack(new Uint8Array(buf instanceof ArrayBuffer ? buf : buf))); }

package/static/js/websocket-manager.js

@@ -1,3 +1,6 @@
+// codec is loaded as ES module and exposed globally by ws-client.js
+// or inline: import('./codec.js').then(m => window._codec = m)
+
 class WebSocketManager {
   constructor(config = {}) {
     this.config = {
@@ -133,16 +136,8 @@ class WebSocketManager {
   async onMessage(event) {
     try {
       let parsed;
-      if (event.data instanceof Blob || event.data instanceof ArrayBuffer) {
-        // Binary frame: msgpackr-encoded (perMessageDeflate decompressed by browser)
-        const buf = event.data instanceof Blob
-          ? await event.data.arrayBuffer()
-          : event.data;
-        parsed = msgpackr.unpack(new Uint8Array(buf));
-      } else {
-        // Fallback: plain JSON (ping/pong control frames, legacy)
-        parsed = JSON.parse(event.data);
-      }
+      const buf = event.data instanceof Blob ? await event.data.arrayBuffer() : event.data;
+      parsed = window._codec ? window._codec.decode(buf) : msgpackr.unpack(new Uint8Array(buf));
       const messages = Array.isArray(parsed) ? parsed : [parsed];
       this.stats.totalMessagesReceived += messages.length;
 
@@ -443,7 +438,7 @@ class WebSocketManager {
     }
 
     try {
-      this.ws.send(msgpackr.pack(data));
+      this.ws.send(window._codec ? window._codec.encode(data) : msgpackr.pack(data));
       this.stats.totalMessagesSent++;
       return true;
     } catch (error) {
@@ -467,7 +462,7 @@ class WebSocketManager {
     this.messageBuffer = [];
     for (const message of messages) {
       try {
-        this.ws.send(msgpackr.pack(message));
+        this.ws.send(window._codec ? window._codec.encode(message) : msgpackr.pack(message));
         this.stats.totalMessagesSent++;
       } catch (error) {
         this.bufferMessage(message);
@@ -491,7 +486,7 @@ class WebSocketManager {
       if (type === 'session') msg.sessionId = id;
       else msg.conversationId = id;
       try {
-        this.ws.send(msgpackr.pack(msg));
+        this.ws.send(window._codec ? window._codec.encode(msg) : msgpackr.pack(msg));
         this.stats.totalMessagesSent++;
       } catch (_) {}
     }

package/static/js/ws-client.js

@@ -78,10 +78,12 @@ class WsClient {
 
 window.WsClient = WsClient;
 
-try {
+// Bootstrap: load codec (which pulls gpt-tokenizer from esm.sh), then connect
+import('./codec.js').then(codec => {
+  window._codec = codec;
   window.wsManager = new WebSocketManager();
   window.wsClient = new WsClient(window.wsManager);
   window.wsManager.connect().catch(function() {});
-} catch (e) {
-  console.error('[ws-client] Failed to initialize:', e);
-}
+}).catch(e => {
+  console.error('[ws-client] Failed to load codec:', e);
+});

package/lib/sse-stream.js

@@ -1,125 +0,0 @@
-import crypto from 'crypto';
-
-export function formatSSEEvent(eventType, data) {
-  const lines = [];
-  if (eventType) {
-    lines.push(`event: ${eventType}`);
-  }
-  if (data) {
-    const jsonData = typeof data === 'string' ? data : JSON.stringify(data);
-    lines.push(`data: ${jsonData}`);
-  }
-  lines.push('');
-  return lines.join('\n') + '\n';
-}
-
-export function convertToACPRunOutputStream(sessionId, block, runStatus = 'active') {
-  const eventId = crypto.randomUUID();
-  return {
-    id: eventId,
-    event: 'agent_event',
-    data: {
-      type: 'custom',
-      run_id: sessionId,
-      status: runStatus,
-      update: block
-    }
-  };
-}
-
-export function createErrorEvent(runId, errorMessage, errorCode = 'execution_error') {
-  const eventId = crypto.randomUUID();
-  return {
-    id: eventId,
-    event: 'agent_event',
-    data: {
-      type: 'error',
-      run_id: runId,
-      error: errorMessage,
-      code: errorCode,
-      status: 'error'
-    }
-  };
-}
-
-export function createCompletionEvent(runId, values = {}, metadata = {}) {
-  const eventId = crypto.randomUUID();
-  return {
-    id: eventId,
-    event: 'agent_event',
-    data: {
-      type: 'result',
-      run_id: runId,
-      status: 'completed',
-      values,
-      metadata
-    }
-  };
-}
-
-export function createKeepAlive() {
-  return ': ping\n\n';
-}
-
-export class SSEStreamManager {
-  constructor(res, runId) {
-    this.res = res;
-    this.runId = runId;
-    this.keepAliveInterval = null;
-    this.closed = false;
-  }
-
-  start() {
-    this.res.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-      'X-Accel-Buffering': 'no'
-    });
-
-    this.keepAliveInterval = setInterval(() => {
-      if (!this.closed) {
-        this.writeRaw(createKeepAlive());
-      }
-    }, 15000);
-
-    this.res.on('close', () => {
-      this.cleanup();
-    });
-  }
-
-  writeRaw(text) {
-    if (!this.closed) {
-      this.res.write(text);
-    }
-  }
-
-  sendProgress(block, runStatus = 'active') {
-    const acpEvent = convertToACPRunOutputStream(this.runId, block, runStatus);
-    const sse = formatSSEEvent('message', acpEvent.data);
-    this.writeRaw(sse);
-  }
-
-  sendError(errorMessage, errorCode = 'execution_error') {
-    const errorEvent = createErrorEvent(this.runId, errorMessage, errorCode);
-    const sse = formatSSEEvent('error', errorEvent.data);
-    this.writeRaw(sse);
-  }
-
-  sendComplete(values = {}, metadata = {}) {
-    const completionEvent = createCompletionEvent(this.runId, values, metadata);
-    const sse = formatSSEEvent('done', completionEvent.data);
-    this.writeRaw(sse);
-  }
-
-  cleanup() {
-    if (this.keepAliveInterval) {
-      clearInterval(this.keepAliveInterval);
-      this.keepAliveInterval = null;
-    }
-    this.closed = true;
-    if (!this.res.writableEnded) {
-      this.res.end();
-    }
-  }
-}

package/lib/ws-events.js

@@ -1,20 +0,0 @@
-const S2L = {
-  's.start': 'streaming_start', 's.prog': 'streaming_progress',
-  's.done': 'streaming_complete', 's.err': 'streaming_error',
-  's.cancel': 'streaming_cancelled', 'conv.new': 'conversation_created',
-  'conv.upd': 'conversation_updated', 'convs.upd': 'conversations_updated',
-  'conv.del': 'conversation_deleted', 'msg.new': 'message_created',
-  'q.stat': 'queue_status', 'q.upd': 'queue_updated',
-  'rl.hit': 'rate_limit_hit', 'rl.clr': 'rate_limit_clear',
-  'scr.start': 'script_started', 'scr.stop': 'script_stopped',
-  'scr.out': 'script_output', 'mdl.prog': 'model_download_progress',
-  'stt.prog': 'stt_progress', 'tts.prog': 'tts_setup_progress',
-  'voice.ls': 'voice_list', 'sub.ok': 'subscription_confirmed',
-  'term.out': 'terminal_output', 'term.exit': 'terminal_exit',
-  'term.start': 'terminal_started'
-};
-const L2S = Object.fromEntries(Object.entries(S2L).map(([k, v]) => [v, k]));
-const toLong = (s) => S2L[s] || s;
-const toShort = (l) => L2S[l] || l;
-if (typeof window !== 'undefined') window.wsEvents = { S2L, L2S, toLong, toShort };
-export { S2L, L2S, toLong, toShort };

package/static/js/event-consolidator.js

@@ -1,100 +0,0 @@
-class EventConsolidator {
-  consolidate(chunks) {
-    const stats = { original: chunks.length, deduplicated: 0, textMerged: 0, toolsCollapsed: 0, systemSuperseded: 0 };
-    if (chunks.length <= 1) return { consolidated: chunks, stats };
-
-    const sorted = chunks.slice().sort((a, b) => (a.sequence || 0) - (b.sequence || 0));
-
-    const seen = new Set();
-    const deduped = [];
-    for (const c of sorted) {
-      const key = c.sessionId + ':' + c.sequence;
-      if (c.sequence !== undefined && seen.has(key)) { stats.deduplicated++; continue; }
-      if (c.sequence !== undefined) seen.add(key);
-      deduped.push(c);
-    }
-
-    const bySession = {};
-    for (const c of deduped) {
-      const sid = c.sessionId || '_';
-      if (!bySession[sid]) bySession[sid] = [];
-      bySession[sid].push(c);
-    }
-
-    const result = [];
-    for (const sid of Object.keys(bySession)) {
-      const sessionChunks = bySession[sid];
-      const merged = this._mergeTextBlocks(sessionChunks, stats);
-      this._collapseToolPairs(merged, stats);
-      const superseded = this._supersedeSystemBlocks(merged, stats);
-      result.push(...superseded);
-    }
-
-    result.sort((a, b) => (a.sequence || 0) - (b.sequence || 0));
-    return { consolidated: result, stats };
-  }
-
-   _mergeTextBlocks(chunks, stats) {
-     const result = [];
-     let pending = null;
-     const MAX_MERGE = 50 * 1024;
-
-     for (const c of chunks) {
-       if (c.block?.type === 'text') {
-         if (pending) {
-           const pendingText = pending.block.text || '';
-           const newText = c.block.text || '';
-           const combined = pendingText + newText;
-           if (combined.length <= MAX_MERGE) {
-             pending = {
-               ...pending,
-               block: { ...pending.block, text: combined },
-               created_at: c.created_at,
-               _mergedSequences: [...(pending._mergedSequences || [pending.sequence]), c.sequence]
-             };
-             stats.textMerged++;
-             continue;
-           }
-         }
-         if (pending) result.push(pending);
-         pending = { ...c, _mergedSequences: [c.sequence] };
-       } else {
-         if (pending) { result.push(pending); pending = null; }
-         result.push(c);
-       }
-     }
-     if (pending) result.push(pending);
-     return result;
-   }
-
-  _collapseToolPairs(chunks, stats) {
-    const toolUseMap = {};
-    for (const c of chunks) {
-      if (c.block?.type === 'tool_use' && c.block.id) toolUseMap[c.block.id] = c;
-    }
-    for (const c of chunks) {
-      if (c.block?.type === 'tool_result' && c.block.tool_use_id) {
-        const match = toolUseMap[c.block.tool_use_id];
-        if (match) {
-          match.block._hasResult = true;
-          c.block._collapsed = true;
-          stats.toolsCollapsed++;
-        }
-      }
-    }
-  }
-
-  _supersedeSystemBlocks(chunks, stats) {
-    const systemIndices = [];
-    for (let i = 0; i < chunks.length; i++) {
-      if (chunks[i].block?.type === 'system') systemIndices.push(i);
-    }
-    if (systemIndices.length <= 1) return chunks;
-    const keep = new Set();
-    keep.add(systemIndices[systemIndices.length - 1]);
-    stats.systemSuperseded += systemIndices.length - 1;
-    return chunks.filter((_, i) => !systemIndices.includes(i) || keep.has(i));
-  }
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = EventConsolidator;