@myrialabs/clopen 0.0.8 → 0.1.2

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

@@ -11,7 +11,8 @@
  * - Proper presence synchronization
  */
 
-import { appState } from '$frontend/lib/stores/core/app.svelte';
+import { appState, updateSessionProcessState } from '$frontend/lib/stores/core/app.svelte';
+import type { SessionProcessState } from '$frontend/lib/stores/core/app.svelte';
 import { chatModelState } from '$frontend/lib/stores/ui/chat-model.svelte';
 import { projectState } from '$frontend/lib/stores/core/projects.svelte';
 import { sessionState, setCurrentSession, createSession, updateSession } from '$frontend/lib/stores/core/sessions.svelte';
@@ -23,6 +24,14 @@ import { buildMetadataFromTransport } from '$shared/utils/message-formatter';
 import { debug } from '$shared/utils/logger';
 import ws from '$frontend/lib/utils/ws';
 
+/**
+ * Tools that block the SDK waiting for user interaction.
+ * When these tools appear in an assistant message without a result,
+ * and the stream is active, the chat status switches to "waiting for input".
+ * Extend this list for future interactive tools.
+ */
+const INTERACTIVE_TOOLS = new Set(['AskUserQuestion']);
+
 class ChatService {
   private activeProcessId: string | null = null;
   private streamCompleted: boolean = false;
@@ -58,6 +67,30 @@ class ChatService {
     this.setupWebSocketHandlers();
   }
 
+  /**
+   * Update process state for a session.
+   * Writes to both the per-session map (for multi-session support)
+   * and global convenience flags (for backward-compatible single-session components).
+   *
+   * @param update - Partial state to merge
+   * @param sessionId - Override session ID (defaults to this.currentSessionId or current session)
+   */
+  private setProcessState(
+    update: Partial<SessionProcessState>,
+    sessionId?: string | null
+  ): void {
+    const resolvedId = sessionId ?? this.currentSessionId ?? sessionState.currentSession?.id;
+    if (resolvedId) {
+      updateSessionProcessState(resolvedId, update);
+    }
+    // Always sync to global convenience flags
+    if ('isLoading' in update) appState.isLoading = update.isLoading!;
+    if ('isWaitingInput' in update) appState.isWaitingInput = update.isWaitingInput!;
+    if ('isCancelling' in update) appState.isCancelling = update.isCancelling!;
+    if ('isRestoring' in update) appState.isRestoring = update.isRestoring!;
+    if ('error' in update && update.error !== undefined) appState.error = update.error;
+  }
+
   /**
    * Check if event should be skipped (sequence-based deduplication)
    */
@@ -137,8 +170,10 @@ class ChatService {
 
       this.streamCompleted = true;
       this.reconnected = false;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Stream completed successfully — all old cancelled streams' events
       // have definitely been delivered by now, so clear the blacklist.
@@ -161,8 +196,10 @@ class ChatService {
       this.streamCompleted = true;
       this.reconnected = false;
       this.activeProcessId = null;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Notifications handled by GlobalStreamMonitor via chat:stream-finished
     });
@@ -178,8 +215,10 @@ class ChatService {
       // (e.g. from multiple subscriptions or late-arriving events with different processId/seq)
       this.streamCompleted = true;
       this.reconnected = false;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Don't show notification for cancel-triggered errors
       if (data.error === 'Stream cancelled') return;
@@ -277,11 +316,10 @@ class ChatService {
     }
 
     // Set loading state
-    appState.isLoading = true;
-    appState.isCancelling = false;
     this.streamCompleted = false;
     this.reconnected = false;
     this.currentSessionId = sessionState.currentSession.id;
+    this.setProcessState({ isLoading: true, isWaitingInput: false, isCancelling: false });
     // DON'T clear cancelledProcessIds — late events from previously cancelled
     // streams must still be blocked. The set is cleared on stream complete.
     // Clear sequence tracking for new stream
@@ -432,9 +470,9 @@ class ChatService {
     this.currentSessionId = null;
     this.streamCompleted = true;
     this.reconnected = false;
-    appState.isLoading = false;
-    // Prevent presence effect from re-enabling loading before server confirms cancel
-    appState.isCancelling = true;
+    // Update per-session map with captured ID (before it was nulled above)
+    // 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
@@ -465,6 +503,7 @@ class ChatService {
     this.reconnected = false;
     this.lastEventSeq.clear();
     appState.isLoading = false;
+    appState.isWaitingInput = false;
     appState.isCancelling = false;
   }
 
@@ -549,6 +588,27 @@ class ChatService {
       })
     };
 
+    // Detect interactive tool_use blocks (e.g., AskUserQuestion) and set waiting status.
+    // When the SDK is blocked on canUseTool, partial events stop and the user must interact.
+    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 });
+      }
+    }
+
+    // When a user message with tool_result arrives, the SDK is unblocked — clear waiting status
+    if (sdkMessage.type === 'user' && sdkMessage.message?.content) {
+      const content = Array.isArray(sdkMessage.message.content) ? sdkMessage.message.content : [];
+      const hasToolResult = content.some((item: any) => item.type === 'tool_result');
+      if (hasToolResult && appState.isWaitingInput) {
+        this.setProcessState({ isWaitingInput: false });
+      }
+    }
+
     // For reasoning messages that couldn't find a matching stream_event,
     // insert BEFORE trailing non-reasoning assistant messages (tools/text)
     // to preserve reasoning-before-tool ordering within the same turn.
@@ -671,6 +731,80 @@ class ChatService {
     }
   }
 
+  /**
+   * Detect whether any interactive tool (e.g. AskUserQuestion) is pending in the current messages.
+   * Used after browser refresh / catchup to restore the isWaitingInput state.
+   */
+  detectPendingInteractiveTools(): void {
+    if (!appState.isLoading) return;
+
+    // Collect all tool_use IDs that have a matching tool_result
+    const answeredToolIds = new Set<string>();
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'user' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+      for (const item of content) {
+        if (item.type === 'tool_result' && item.tool_use_id) {
+          answeredToolIds.add(item.tool_use_id);
+        }
+      }
+    }
+
+    // Check if any interactive tool is unanswered
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'assistant' || !msgAny.message?.content) 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)
+      );
+      if (hasPendingInteractive) {
+        this.setProcessState({ isWaitingInput: true });
+        return;
+      }
+    }
+  }
+
+  /**
+   * Mark assistant messages with unanswered tool_use blocks as interrupted.
+   * Sets metadata.interrupted at the MESSAGE level (not tool_use content level).
+   * Called when stream ends (complete/error/cancel) for immediate in-memory update.
+   * The backend persists this to DB via stream:lifecycle for durability.
+   */
+  private markInterruptedTools(): void {
+    // Collect all tool_use IDs that have a matching tool_result
+    const answeredToolIds = new Set<string>();
+
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'user' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+
+      for (const item of content) {
+        if (item.type === 'tool_result' && item.tool_use_id) {
+          answeredToolIds.add(item.tool_use_id);
+        }
+      }
+    }
+
+    // Mark messages with unanswered tool_use blocks as interrupted (message-level metadata)
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'assistant' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+
+      const hasUnansweredTool = content.some(
+        (item: any) => item.type === 'tool_use' && item.id && !answeredToolIds.has(item.id)
+      );
+
+      if (hasUnansweredTool && !msgAny.metadata?.interrupted) {
+        if (!msgAny.metadata) msgAny.metadata = {};
+        msgAny.metadata.interrupted = true;
+      }
+    }
+  }
+
   /**
    * Handle general errors
    */

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

@@ -15,14 +15,41 @@ interface PageInfo {
 	actions?: import('svelte').Snippet;
 }
 
+/**
+ * Per-session process state.
+ * Tracks loading/waiting/cancelling state for each chat session independently,
+ * enabling correct multi-session and multi-project support.
+ */
+export interface SessionProcessState {
+	isLoading: boolean;
+	isWaitingInput: boolean;
+	isRestoring: boolean;
+	isCancelling: boolean;
+	error: string | null;
+}
+
+const DEFAULT_SESSION_STATE: SessionProcessState = {
+	isLoading: false,
+	isWaitingInput: false,
+	isRestoring: false,
+	isCancelling: false,
+	error: null,
+};
+
 interface AppState {
 	// UI Navigation
 	currentView: string;
+
+	// Current session process state (convenience — synced from sessionStates for the active session)
 	isLoading: boolean;
+	isWaitingInput: boolean;
 	isRestoring: boolean;
 	isCancelling: boolean;
 	error: string | null;
 
+	// Per-session process states (source of truth for multi-session support)
+	sessionStates: Record<string, SessionProcessState>;
+
 	// Page Information
 	pageInfo: PageInfo;
 
@@ -36,10 +63,14 @@ export const appState = $state<AppState>({
 	// UI Navigation
 	currentView: 'chat',
 	isLoading: false,
+	isWaitingInput: false,
 	isRestoring: false,
 	isCancelling: false,
 	error: null,
 
+	// Per-session process states
+	sessionStates: {},
+
 	// Page Information
 	pageInfo: {
 		title: 'Claude Code',
@@ -52,6 +83,52 @@ export const appState = $state<AppState>({
 	isAppInitialized: false
 });
 
+// ========================================
+// PER-SESSION PROCESS STATE MANAGEMENT
+// ========================================
+
+/**
+ * Get the process state for a specific session.
+ * Returns default (idle) state if the session has no entry.
+ */
+export function getSessionProcessState(sessionId: string): SessionProcessState {
+	return appState.sessionStates[sessionId] ?? DEFAULT_SESSION_STATE;
+}
+
+/**
+ * Update process state for a specific session in the per-session map.
+ * Does NOT touch global convenience flags — caller is responsible for that.
+ */
+export function updateSessionProcessState(
+	sessionId: string,
+	update: Partial<SessionProcessState>
+): void {
+	if (!appState.sessionStates[sessionId]) {
+		appState.sessionStates[sessionId] = { ...DEFAULT_SESSION_STATE };
+	}
+	Object.assign(appState.sessionStates[sessionId], update);
+}
+
+/**
+ * Sync global convenience flags from a session's per-session state.
+ * Call when switching sessions to derive global state from the new session.
+ */
+export function syncGlobalStateFromSession(sessionId: string): void {
+	const state = appState.sessionStates[sessionId] ?? DEFAULT_SESSION_STATE;
+	appState.isLoading = state.isLoading;
+	appState.isWaitingInput = state.isWaitingInput;
+	appState.isRestoring = state.isRestoring;
+	appState.isCancelling = state.isCancelling;
+	appState.error = state.error;
+}
+
+/**
+ * Remove a session's process state entry (e.g. when deleting a session).
+ */
+export function clearSessionProcessState(sessionId: string): void {
+	delete appState.sessionStates[sessionId];
+}
+
 // ========================================
 // UI STATE MANAGEMENT
 // ========================================

package/frontend/lib/utils/chat/message-grouper.ts

@@ -2,7 +2,9 @@ import type { SDKMessageFormatter } from '$shared/types/database/schema';
 import {
   shouldFilterMessage,
   extractToolUses,
-  extractToolResults
+  extractToolResults,
+  isCompactBoundaryMessage,
+  isSyntheticUserMessage
 } from './message-processor';
 import { processToolMessage } from './tool-handler';
 
@@ -21,13 +23,50 @@ export interface BackgroundBashData {
 // Processed message type
 export type ProcessedMessage = SDKMessageFormatter;
 
+// Module-level map for compact summary lookup (rebuilt each groupMessages call)
+let _compactSummaryMap = new WeakMap<SDKMessageFormatter, string>();
+
+// Lookup compact summary for a given compact_boundary message
+export function getCompactSummary(message: SDKMessageFormatter): string | undefined {
+  return _compactSummaryMap.get(message);
+}
+
+// Extract text content from a user message
+function extractUserTextContent(message: SDKMessageFormatter): string {
+  if (!('message' in message) || !message.message?.content) return '';
+  const content = message.message.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((item: any) => typeof item === 'object' && item?.type === 'text')
+      .map((item: any) => item.text)
+      .join('\n');
+  }
+  return '';
+}
+
+// Get parent_tool_use_id from any message type
+function getParentToolUseId(message: SDKMessageFormatter): string | null {
+  if ('parent_tool_use_id' in message) {
+    return (message as any).parent_tool_use_id ?? null;
+  }
+  return null;
+}
+
 // Group tool_use and tool_result messages together
 export function groupMessages(messages: SDKMessageFormatter[]): {
   groups: ProcessedMessage[],
-  toolUseMap: Map<string, ToolGroup>
+  toolUseMap: Map<string, ToolGroup>,
+  subAgentMap: Map<string, SDKMessageFormatter[]>
 } {
   const groups: ProcessedMessage[] = [];
   const toolUseMap = new Map<string, ToolGroup>();
+  const agentToolUseIds = new Set<string>();
+  const subAgentMap = new Map<string, SDKMessageFormatter[]>();
+  let lastCompactBoundaryIdx = -1;
+
+  // Rebuild compact summary map each call
+  _compactSummaryMap = new WeakMap<SDKMessageFormatter, string>();
 
   messages.forEach(message => {
     // Skip messages that should be filtered
@@ -35,8 +74,30 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
       return;
     }
 
+    // Intercept ALL sub-agent messages (any parent_tool_use_id !== null)
+    // before normal processing — these belong to Agent tool sub-conversations
+    const parentToolId = getParentToolUseId(message);
+    if (parentToolId) {
+      if (agentToolUseIds.has(parentToolId)) {
+        if (!subAgentMap.has(parentToolId)) {
+          subAgentMap.set(parentToolId, []);
+        }
+        subAgentMap.get(parentToolId)!.push(message);
+      }
+      // Don't add any sub-agent message to main groups
+      return;
+    }
+
+    // Handle compact boundary messages — track for synthetic user embedding
+    if (isCompactBoundaryMessage(message)) {
+      lastCompactBoundaryIdx = groups.length;
+      groups.push(message as ProcessedMessage);
+      return;
+    }
+
     // Handle assistant messages with tool_use
     if (message.type === 'assistant' && 'message' in message && message.message?.content) {
+      lastCompactBoundaryIdx = -1;
       const toolUses = extractToolUses(message.message.content);
 
       if (toolUses.length > 0) {
@@ -47,17 +108,35 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
               toolUseMessage: message,
               toolResultMessage: null
             });
+            // Track Agent tool IDs for sub-agent message collection
+            if (toolUse.name === 'Agent') {
+              agentToolUseIds.add(toolUse.id);
+            }
           }
         });
         groups.push(message as ProcessedMessage);
       } else {
         groups.push(message as ProcessedMessage);
       }
+      return;
     }
-    // Handle user messages with tool_result
-    else if (message.type === 'user' && 'message' in message && message.message?.content) {
-      const toolResults = extractToolResults(message.message.content);
 
+    // Handle user messages
+    if (message.type === 'user' && 'message' in message && message.message?.content) {
+      // Synthetic user messages (after compaction): store summary in WeakMap keyed by compact boundary message
+      if (isSyntheticUserMessage(message) && lastCompactBoundaryIdx >= 0) {
+        const compactMsg = groups[lastCompactBoundaryIdx];
+        const summaryText = extractUserTextContent(message);
+        if (summaryText) {
+          _compactSummaryMap.set(compactMsg, summaryText);
+        }
+        lastCompactBoundaryIdx = -1;
+        return;
+      }
+
+      lastCompactBoundaryIdx = -1;
+
+      const toolResults = extractToolResults(message.message.content);
       if (toolResults.length > 0) {
         // Group tool_result with corresponding tool_use
         toolResults.forEach((toolResult: any) => {
@@ -73,20 +152,22 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
         // Regular user message
         groups.push(message as ProcessedMessage);
       }
+      return;
     }
+
     // Include stream_event and other messages
-    else {
-      groups.push(message as ProcessedMessage);
-    }
+    lastCompactBoundaryIdx = -1;
+    groups.push(message as ProcessedMessage);
   });
 
-  return { groups, toolUseMap };
+  return { groups, toolUseMap, subAgentMap };
 }
 
 // Add tool results to messages
 export function embedToolResults(
   groups: ProcessedMessage[],
-  toolUseMap: Map<string, ToolGroup>
+  toolUseMap: Map<string, ToolGroup>,
+  subAgentMap: Map<string, SDKMessageFormatter[]>
 ): ProcessedMessage[] {
   // Track background bash sessions
   const backgroundBashMap = trackBackgroundBashSessions(groups, toolUseMap);
@@ -100,7 +181,8 @@ export function embedToolResults(
         const processedMessage = processToolMessage(
           message,
           toolUseMap,
-          backgroundBashMap
+          backgroundBashMap,
+          subAgentMap
         );
         return processedMessage;
       }
@@ -216,4 +298,4 @@ function trackBashOutput(
       bashData.bashOutputs.push(toolResult);
     }
   }
-}
+}

package/frontend/lib/utils/chat/message-processor.ts

@@ -42,7 +42,7 @@ export const TOOLS_WITH_RESULTS: ToolInput['name'][] = [
   'ExitPlanMode',
   'Glob',
   'Grep',
-  'KillShell',
+  'TaskStop',
   'ListMcpResources',
   'NotebookEdit',
   'ReadMcpResource',
@@ -51,7 +51,12 @@ export const TOOLS_WITH_RESULTS: ToolInput['name'][] = [
   'TodoWrite',
   'WebFetch',
   'WebSearch',
-  'Write'
+  'Write',
+  'AskUserQuestion',
+  'Config',
+  'EnterWorktree',
+  'Agent',
+  'EnterPlanMode'
 ];
 
 // Tools that should be hidden from display
@@ -60,10 +65,38 @@ export const HIDDEN_TOOLS: ToolInput['name'][] = [
   'TodoWrite'
 ];
 
+// Message types that represent actual conversation content and should be rendered.
+// All other types are transient/metadata and should be filtered out.
+const RENDERABLE_MESSAGE_TYPES = new Set(['assistant', 'user', 'stream_event']);
+
+// Check if this is a compact boundary message (system.compact_boundary)
+export function isCompactBoundaryMessage(message: SDKMessageFormatter): boolean {
+  return message.type === 'system' && (message as any).subtype === 'compact_boundary';
+}
+
+// Check if this is a synthetic user message (generated by system after compaction)
+export function isSyntheticUserMessage(message: SDKMessageFormatter): boolean {
+  return message.type === 'user' && (message as any).isSynthetic === true;
+}
+
+// Check if this is a sub-agent user message (prompt sent to a sub-agent)
+export function isSubAgentUserMessage(message: SDKMessageFormatter): boolean {
+  return message.type === 'user' &&
+    'parent_tool_use_id' in message &&
+    (message as any).parent_tool_use_id !== null;
+}
+
 // Check if a message should be filtered out
 export function shouldFilterMessage(message: SDKMessageFormatter): boolean {
-  // Skip system and result type messages
-  if (message.type === 'system' || message.type === 'result') {
+  // Allow compact boundary messages (displayed as separator in chat)
+  if (isCompactBoundaryMessage(message)) {
+    return false;
+  }
+
+  // Whitelist approach: only render conversation content types.
+  // Filters out: system, result, rate_limit_event, tool_progress,
+  // auth_status, tool_use_summary, prompt_suggestion, and any future unknown types.
+  if (!RENDERABLE_MESSAGE_TYPES.has(message.type)) {
     return true;
   }