@myrialabs/clopen 0.2.11 → 0.2.12

package/frontend/services/chat/chat.service.ts

@@ -482,11 +482,11 @@ class ChatService {
     // and global flags — cancel sets isCancelling=true to prevent presence re-enabling
     this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: true }, chatSessionId);
 
-    // Clean up stale stream_events from the cancelled stream.
-    // Without this, stale stream_events remain in the messages array and cause
-    // wrong insertion positions when a new stream starts (e.g., reasoning inserted
-    // before a stale non-reasoning stream_event instead of at the end).
-    this.cleanupStreamEvents();
+    // Convert stream_events to finalized assistant messages on cancel.
+    // This preserves partial reasoning/text that was visible to the user.
+    // Empty stream_events are removed. The backend saves partial text to DB
+    // independently, so on refresh the DB version takes over.
+    this.finalizeStreamEvents();
 
     // Safety timeout: if backend events (chat:cancelled + presence update) don't
     // arrive within 10 seconds, force-clear isCancelling to prevent infinite loader.
@@ -581,15 +581,32 @@ class ChatService {
         }
         // If no reasoning stream_event found, fall through to push at end
       } else {
-        // Remove ALL regular (non-reasoning) stream_events, not just the last one
-        // This prevents stale stream_events from remaining when message order varies
+        // Replace text stream_event IN PLACE to preserve message position
+        // (same approach as reasoning — prevents visual displacement)
         for (let i = sessionState.messages.length - 1; i >= 0; i--) {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && !msg.metadata?.reasoning) {
-            sessionState.messages.splice(i, 1);
-            break; // Only remove the most recent one
+            const messageFormatter = {
+              ...sdkMessage,
+              metadata: buildMetadataFromTransport(data)
+            };
+            sessionState.messages[i] = messageFormatter;
+
+            // Detect interactive tool_use blocks in the replaced message
+            if (sdkMessage.type === 'assistant' && sdkMessage.message?.content) {
+              const content = Array.isArray(sdkMessage.message.content) ? sdkMessage.message.content : [];
+              const hasInteractiveTool = content.some(
+                (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name)
+              );
+              if (hasInteractiveTool) {
+                this.setProcessState({ isWaitingInput: true });
+              }
+            }
+
+            return; // Replaced in-place, skip push below
           }
         }
+        // No stream_event found, fall through to push at end
       }
     }
 
@@ -723,7 +740,7 @@ class ChatService {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && msg.metadata?.reasoning) {
             msg.partialText = partialText || '';
-            break;
+            return;
           }
         }
       } else {
@@ -733,17 +750,42 @@ class ChatService {
           const msg = sessionState.messages[i] as any;
           if (msg.type === 'stream_event' && !msg.metadata?.reasoning) {
             msg.partialText = partialText || '';
-            break;
+            return;
           }
         }
       }
+
+      // Fallback: no matching stream_event found (start event was missed).
+      // Create one now so text doesn't get lost.
+      const fallbackMessage = {
+        type: 'stream_event' as const,
+        processId: data.processId,
+        partialText: partialText || '',
+        metadata: buildMetadataFromTransport({
+          timestamp: data.timestamp,
+          ...(isReasoning && { reasoning: true }),
+        })
+      };
+
+      if (isReasoning) {
+        const textStreamIdx = (sessionState.messages as any[]).findIndex(
+          (m: any) => m.type === 'stream_event' && !m.metadata?.reasoning
+        );
+        if (textStreamIdx >= 0) {
+          (sessionState.messages as any[]).splice(textStreamIdx, 0, fallbackMessage);
+        } else {
+          (sessionState.messages as any[]).push(fallbackMessage);
+        }
+      } else {
+        (sessionState.messages as any[]).push(fallbackMessage);
+      }
     }
     // Note: 'end' event is not needed - streaming message will be replaced by final message in handleMessageEvent
   }
 
   /**
    * Remove all stream_event messages from the messages array.
-   * Called on cancel and new message send to prevent stale streaming
+   * Called on new message send to prevent stale streaming
    * placeholders from causing wrong insertion positions.
    */
   private cleanupStreamEvents(): void {
@@ -754,6 +796,36 @@ class ChatService {
     }
   }
 
+  /**
+   * Convert stream_event messages with text to finalized assistant messages.
+   * Called on cancel to preserve partial reasoning/text that was visible.
+   * Empty stream_events (no text) are removed.
+   * The backend saves these to DB independently, so on refresh the DB version takes over.
+   */
+  private finalizeStreamEvents(): void {
+    for (let i = sessionState.messages.length - 1; i >= 0; i--) {
+      const msg = sessionState.messages[i] as any;
+      if (msg.type !== 'stream_event') continue;
+
+      if (msg.partialText) {
+        const isReasoning = msg.metadata?.reasoning === true;
+        sessionState.messages[i] = {
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [{ type: 'text', text: msg.partialText }]
+          },
+          metadata: {
+            ...msg.metadata,
+            ...(isReasoning && { reasoning: true }),
+          }
+        } as any;
+      } else {
+        sessionState.messages.splice(i, 1);
+      }
+    }
+  }
+
   /**
    * Detect whether any interactive tool (e.g. AskUserQuestion) is pending in the current messages.
    * Used after browser refresh / catchup to restore the isWaitingInput state.
@@ -774,10 +846,11 @@ class ChatService {
       }
     }
 
-    // Check if any interactive tool is unanswered
+    // Check if any interactive tool is unanswered (skip interrupted/cancelled messages)
     for (const msg of sessionState.messages) {
       const msgAny = msg as any;
       if (msgAny.type !== 'assistant' || !msgAny.message?.content) continue;
+      if (msgAny.metadata?.interrupted) continue;
       const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
       const hasPendingInteractive = content.some(
         (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name) && item.id && !answeredToolIds.has(item.id)

package/frontend/services/notification/global-stream-monitor.ts

@@ -35,13 +35,16 @@ class GlobalStreamMonitor {
 
     // Stream finished — notify on completion
     ws.on('chat:stream-finished', async (data) => {
-      const { projectId, status, chatSessionId } = data;
+      const { projectId, status, chatSessionId, reason } = data;
 
-      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status });
+      debug.log('notification', 'GlobalStreamMonitor: Stream finished', { projectId, status, reason });
 
       // Clean up notified IDs for this session (stream is done)
       this.clearSessionNotifications(chatSessionId);
 
+      // Skip notifications when stream was cancelled due to session deletion
+      if (reason === 'session-deleted') return;
+
       // Play sound notification
       try {
         await soundNotification.play();

package/frontend/stores/core/app.svelte.ts

@@ -129,10 +129,18 @@ export function syncGlobalStateFromSession(sessionId: string): void {
 }
 
 /**
- * Remove a session's process state entry (e.g. when deleting a session).
+ * Remove all app-level state for a deleted session
+ * (process state, unread status, etc.)
  */
-export function clearSessionProcessState(sessionId: string): void {
+export function clearSessionState(sessionId: string): void {
 	delete appState.sessionStates[sessionId];
+
+	if (appState.unreadSessions.has(sessionId)) {
+		const next = new Map(appState.unreadSessions);
+		next.delete(sessionId);
+		appState.unreadSessions = next;
+		persistUnreadSessions();
+	}
 }
 
 // ========================================

package/frontend/stores/core/sessions.svelte.ts

@@ -13,7 +13,7 @@ import { buildMetadataFromTransport } from '$shared/utils/message-formatter';
 import ws, { onWsReconnect } from '$frontend/utils/ws';
 import { projectState } from './projects.svelte';
 import { setupEditModeListener, restoreEditMode } from '$frontend/stores/ui/edit-mode.svelte';
-import { markSessionUnread, markSessionRead, appState } from '$frontend/stores/core/app.svelte';
+import { markSessionUnread, markSessionRead, clearSessionState, appState } from '$frontend/stores/core/app.svelte';
 import { debug } from '$shared/utils/logger';
 
 interface SessionState {
@@ -164,6 +164,9 @@ export function removeSession(sessionId: string) {
 		sessionState.sessions.splice(index, 1);
 	}
 
+	// Clear all app-level state for this session (unread, process state)
+	clearSessionState(sessionId);
+
 	// Clear current session if it's the one being removed
 	if (sessionState.currentSession?.id === sessionId) {
 		sessionState.currentSession = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myrialabs/clopen",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "All-in-one web workspace for Claude Code & OpenCode — chat, terminal, git, browser preview, checkpoints, and real-time collaboration",
   "author": "Myria Labs",
   "license": "MIT",