@clawchatsai/connector 0.0.92 → 0.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",

package/server/gateway.js

@@ -23,6 +23,17 @@ export class GatewayClient {
     this.activityLogs = new Map();
     this._pendingTitleGens = new Map();
 
+    // On startup: mark any pending activity log messages from previous crashed/restarted sessions
+    // as interrupted. Without this, stale pending=true rows survive gateway restarts and cause
+    // phantom "thinking..." indicators in the browser on reconnect.
+    try {
+      const workspaces = this.getWorkspaces();
+      for (const wsName of Object.keys(workspaces.workspaces || {})) {
+        const db = this.getDb(wsName);
+        if (db) db.prepare(`UPDATE messages SET content = '[Response interrupted]', metadata = json_remove(metadata, '$.pending') WHERE content = '' AND json_extract(metadata, '$.pending') = 1`).run();
+      }
+    } catch (e) { console.log('[clawchats] startup pending cleanup skipped:', e.message); }
+
     // Periodically clean up stale activity logs (>10 min old)
     setInterval(() => {
       const cutoff = Date.now() - 10 * 60 * 1000;
@@ -70,12 +81,32 @@ export class GatewayClient {
 
   handleChatEvent(params, rawData) {
     const { sessionKey, state, message, seq } = params;
+    const bareSessionKey = sessionKey.replace(/^agent:[^:]+:/, '');
+
+    // --- Utility session routing (connector-side) ---
+    // Emits semantic utility-response events. Also forwards rawData for dual-emit compatibility
+    // during transition — browser handleChatEvent guards these and defers to utility-response handler.
+    const UTILITY_SESSIONS = { '__clawchats_summarizer': 'summarizer', '__clawchats_semantic': 'semantic', '__clawchats_intelligence': 'intelligence' };
+    const utilityName = UTILITY_SESSIONS[bareSessionKey];
+    if (utilityName) {
+      const content = extractContent(message);
+      if (state === 'delta' && content) {
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'utility-response', session: utilityName, state: 'delta', content }));
+      } else if (state === 'final' || state === 'aborted') {
+        if (content) this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'utility-response', session: utilityName, state: state === 'final' ? 'final' : 'aborted', content }));
+      } else if (state === 'error') {
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'utility-response', session: utilityName, state: 'error', errorMessage: message?.error || 'Unknown error' }));
+      }
+      this.broadcastToBrowsers(rawData); // dual-emit: browser guard skips raw handling for utility sessions
+      return;
+    }
 
+    // --- Delta path ---
     if (state === 'delta') {
       const parsed = parseSessionKey(sessionKey);
       if (parsed) {
         const existing = this.streamState.get(sessionKey) || { buffer: '', threadId: parsed.threadId, state: 'streaming', held: [] };
-        existing.buffer += extractContent(message);
+        existing.buffer = extractContent(message); // gateway sends full cumulative content per delta, not chunks
         if (isSilentReplyPrefix(existing.buffer, 'NO_REPLY') || isSilentReplyPrefix(existing.buffer, 'HEARTBEAT_OK')) {
           existing.held = existing.held || [];
           existing.held.push(rawData);
@@ -87,32 +118,76 @@ export class GatewayClient {
           existing.held = [];
         }
         this.streamState.set(sessionKey, existing);
+        this.broadcastToBrowsers(rawData); // dual-emit: raw chat event (old protocol)
+        // Broadcast only the final-answer portion (text after the last tool call offset).
+        // thoughtStartOffset is updated on each tool result; 0 means no tools yet → full buffer.
+        const visibleContent = existing.buffer.substring(existing.thoughtStartOffset || 0);
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-delta', threadId: parsed.threadId, workspace: parsed.workspace, content: visibleContent }));
+      } else {
+        this.broadcastToBrowsers(rawData); // non-clawchats session (discord, telegram, etc.)
       }
-      this.broadcastToBrowsers(rawData);
       return;
     }
 
+    // --- End states ---
     const streamEntry = this.streamState.get(sessionKey);
     if (state === 'final' || state === 'aborted' || state === 'error') this.streamState.delete(sessionKey);
 
+    // Title sessions are handled server-side — intercept and skip browser delivery
     if (sessionKey?.includes('__clawchats_title_')) {
       if (state === 'final') { const content = extractContent(message); if (content && this.handleTitleResponse(sessionKey, content)) return; }
       else if (state === 'error' || state === 'aborted') { for (const key of this._pendingTitleGens.keys()) { if (sessionKey === key || sessionKey.includes(key)) { this._pendingTitleGens.delete(key); break; } } return; }
+      return;
     }
 
     if (state === 'final') {
       const rawContent = extractContent(message);
-      if (isSilentReplyExact(rawContent, 'NO_REPLY') || isSilentReplyExact(rawContent, 'HEARTBEAT_OK')) return;
+      const parsed = parseSessionKey(sessionKey);
+      if (isSilentReplyExact(rawContent, 'NO_REPLY') || isSilentReplyExact(rawContent, 'HEARTBEAT_OK')) {
+        this._cleanupSilentPending(sessionKey);
+        if (parsed) this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-end', threadId: parsed.threadId, workspace: parsed.workspace, reason: 'silent' }));
+        return;
+      }
       if (streamEntry?.held?.length > 0) for (const h of streamEntry.held) this.broadcastToBrowsers(h);
-      this.broadcastToBrowsers(rawData);
-      this.saveAssistantMessage(sessionKey, message, seq);
+      this.saveAssistantMessage(sessionKey, message, seq, streamEntry?.thoughtStartOffset); // persist + broadcast message-saved first
+      this.broadcastToBrowsers(rawData);                   // dual-emit: raw final event
+      if (parsed) {
+        const activity = this._popActivityLogForSession(sessionKey);
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-end', threadId: parsed.threadId, workspace: parsed.workspace, reason: 'complete', ...(activity || {}) }));
+      }
       return;
     }
-    if (state === 'aborted' || state === 'error') this.broadcastToBrowsers(rawData);
-    if (state === 'error') this.saveErrorMarker(sessionKey, message);
+    if (state === 'aborted') {
+      const parsed = parseSessionKey(sessionKey);
+      this.broadcastToBrowsers(rawData); // dual-emit
+      if (parsed) {
+        const activity = this._popActivityLogForSession(sessionKey);
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-end', threadId: parsed.threadId, workspace: parsed.workspace, reason: 'aborted', ...(activity || {}) }));
+      }
+    } else if (state === 'error') {
+      const parsed = parseSessionKey(sessionKey);
+      this.saveErrorMarker(sessionKey, message);
+      this.broadcastToBrowsers(rawData); // dual-emit
+      if (parsed) {
+        const activity = this._popActivityLogForSession(sessionKey);
+        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-end', threadId: parsed.threadId, workspace: parsed.workspace, reason: 'error', errorMessage: message?.error || 'Unknown error', ...(activity || {}) }));
+      }
+    }
   }
 
-  saveAssistantMessage(sessionKey, message, seq) {
+  _cleanupSilentPending(sessionKey) {
+    const parsed = parseSessionKey(sessionKey);
+    if (!parsed) return;
+    const ws = this.getWorkspaces();
+    if (!ws.workspaces[parsed.workspace]) return;
+    const db = this.getDb(parsed.workspace);
+    if (!db) return;
+    const result = db.prepare(`DELETE FROM messages WHERE thread_id = ? AND role = 'assistant' AND json_extract(metadata, '$.pending') = 1`).run(parsed.threadId);
+    if (result.changes > 0) console.log(`[clawchats] silent-reply cleanup: removed ${result.changes} pending message(s) for ${parsed.threadId}`);
+    // Caller broadcasts streaming-end { reason: 'silent' } — no event emitted here.
+  }
+
+  saveAssistantMessage(sessionKey, message, seq, thoughtStartOffset = 0) {
     const parsed = parseSessionKey(sessionKey);
     if (!parsed) return;
     const ws = this.getWorkspaces();
@@ -120,7 +195,10 @@ export class GatewayClient {
     const db = this.getDb(parsed.workspace);
     if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId)) { console.log(`Ignoring response for deleted thread: ${parsed.threadId}`); return; }
 
-    let content = sanitizeAssistantContent(extractContent(message));
+    // Trim to final-answer portion: only text after the last tool call offset.
+    // thoughtStartOffset is passed in from handleChatEvent (captured before streamState.delete).
+    // Intermediate narration lives in activityLog steps; message.content is the clean final answer.
+    let content = sanitizeAssistantContent(extractContent(message).substring(thoughtStartOffset));
 
     // Attach media (MEDIA: lines from exec stdout captured by after_tool_call hook).
     // Stash is read before the empty-content guard — media-only responses (no text) must not be dropped.
@@ -229,17 +307,21 @@ export class GatewayClient {
     const log = this.activityLogs.get(runId);
 
     if (stream === 'assistant') {
-      const text = data?.text || '';
-      if (text) {
-        const offset = log._assistantTextOffset || 0;
-        let seg = log._currentAssistantSegment;
-        if (!seg || seg._sealed) {
-          seg = { type: 'assistant', timestamp: Date.now(), text: text.substring(offset), _sealed: false };
-          log._currentAssistantSegment = seg;
-          log.steps.push(seg);
-        } else {
-          seg.text = text.substring(offset);
-        }
+      // Derive narration text from streamState.buffer (same source as thoughtStartOffset).
+      // This eliminates the _assistantTextOffset race: no longer depends on cumulative
+      // stream:assistant text which can arrive out of order relative to stream:tool start.
+      const streamEntry = this.streamState.get(sessionKey);
+      if (!streamEntry) return;
+      const narrationStart = log._lastNarrationStart ?? 0;
+      const narrationText = streamEntry.buffer.substring(narrationStart);
+      if (!narrationText) return;
+      let seg = log._currentAssistantSegment;
+      if (!seg || seg._sealed) {
+        seg = { type: 'assistant', timestamp: Date.now(), text: narrationText, _sealed: false };
+        log._currentAssistantSegment = seg;
+        log.steps.push(seg);
+      } else {
+        seg.text = narrationText;
       }
       return;
     }
@@ -253,9 +335,7 @@ export class GatewayClient {
     }
     if (stream === 'tool') {
       if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
-        const seg = log._currentAssistantSegment;
-        seg._sealed = true;
-        log._assistantTextOffset = (log._assistantTextOffset || 0) + seg.text.length;
+        log._currentAssistantSegment._sealed = true;
       }
       const argsMeta = data?.args ? (data.args.command || data.args.path || data.args.query || data.args.url || Object.values(data.args).find(v => typeof v === 'string') || '') : '';
       const step = { type: 'tool', timestamp: Date.now(), name: data?.name || 'unknown', phase: data?.phase || 'start', toolCallId: data?.toolCallId, meta: data?.meta || (argsMeta ? String(argsMeta) : undefined), isError: data?.isError || false };
@@ -263,6 +343,18 @@ export class GatewayClient {
         const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
         if (existing) { existing.phase = 'done'; existing.resultMeta = data?.meta; existing.isError = data?.isError || false; existing.durationMs = Date.now() - existing.timestamp; }
         else { step.phase = 'done'; log.steps.push(step); }
+        // Advance the visible content offset to the current buffer end.
+        // Future streaming-delta broadcasts and the saved message content start from here,
+        // so the response area always shows only the most recent thought / final answer.
+        const streamEntry = this.streamState.get(sessionKey);
+        if (streamEntry && log._parsed) {
+          streamEntry.thoughtStartOffset = streamEntry.buffer.length;
+          log._lastNarrationStart = streamEntry.buffer.length; // align activity log segments with buffer
+          // Signal the frontend to clear the response area — new thought is starting.
+          // streaming-reset fires before activity-updated so the typing-indicator is visible
+          // when startIndicatorTimer attaches to it in the allToolsDone handler.
+          this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'streaming-reset', threadId: log._parsed.threadId, workspace: log._parsed.workspace }));
+        }
       } else if (data?.phase === 'update') {
         const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId);
         if (existing) { if (data?.meta) existing.resultMeta = data.meta; if (data?.isError) existing.isError = true; existing.phase = 'running'; }
@@ -272,20 +364,31 @@ export class GatewayClient {
     }
     if (stream === 'lifecycle' && (data?.phase === 'end' || data?.phase === 'error')) {
       if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
-        const seg = log._currentAssistantSegment;
-        seg._sealed = true;
-        log._assistantTextOffset = (log._assistantTextOffset || 0) + seg.text.length;
+        log._currentAssistantSegment._sealed = true;
       }
       const idx = log.steps.findLastIndex(s => s.type === 'assistant');
       if (idx >= 0) log.steps.splice(idx, 1);
       writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
-      // Broadcast final state so browser can clean up any in-flight timers (e.g. aborted runs)
-      if (log._parsed && log._messageId) {
-        const cleanSteps = log.steps.map(s => { const c = { ...s }; delete c._sealed; return c; });
-        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'activity-updated', workspace: log._parsed.workspace, threadId: log._parsed.threadId, messageId: log._messageId, activityLog: cleanSteps, activitySummary: generateActivitySummary(log.steps), final: true }));
+      // Store finalized state — streaming-end (handleChatEvent) will pick it up and carry it
+      // as one atomic payload. Do NOT broadcast activity-updated here anymore.
+      const cleanSteps = log.steps.map(s => { const c = { ...s }; delete c._sealed; return c; });
+      log.finalized = true;
+      log.finalSteps = cleanSteps;
+      log.finalSummary = generateActivitySummary(log.steps);
+      // Note: activityLogs entry is kept until _popActivityLogForSession cleans it up
+    }
+  }
+
+  // Returns and removes the finalized activity log for a given sessionKey, or null if none.
+  // Called by handleChatEvent so streaming-end carries the final activity state atomically.
+  _popActivityLogForSession(sessionKey) {
+    for (const [runId, log] of this.activityLogs) {
+      if (log.sessionKey === sessionKey && log.finalized) {
+        this.activityLogs.delete(runId);
+        return { activityLog: log.finalSteps, activitySummary: log.finalSummary };
       }
-      this.activityLogs.delete(runId);
     }
+    return null;
   }
 
   _broadcastActivityUpdate(runId, log) {
@@ -323,7 +426,11 @@ export class GatewayClient {
       ws.send(JSON.stringify({ type: 'clawchats', event: 'gateway-status', connected: this.connected }));
       const streams = [];
       for (const [sessionKey, state] of this.streamState.entries()) {
-        if (state.state === 'streaming' && !(state.held?.length > 0)) streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
+        if (state.state === 'streaming' && !(state.held?.length > 0)) {
+          const parsed = parseSessionKey(sessionKey);
+          // Include both old shape (sessionKey/buffer) and new shape (workspace/content) for dual-emit compat
+          streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer, ...(parsed ? { workspace: parsed.workspace, content: state.buffer } : {}) });
+        }
       }
       if (streams.length > 0) ws.send(JSON.stringify({ type: 'clawchats', event: 'stream-sync', streams }));
     }