Improve / simplify interruption

Author: ammario

src/components/AIView.tsx

@@ -407,6 +407,9 @@ const AIViewInner: React.FC<AIViewProps> = ({ workspaceId, projectName, branch,
     [aggregator, displayVersion] // displayVersion is needed to detect internal state changes
   );
 
+  // Check if we can interrupt (streaming is active)
+  const canInterrupt = aggregator.getActiveStreams().length > 0;
+
   if (loading) {
     return (
       <ViewContainer className={className}>
@@ -523,6 +526,7 @@ const AIViewInner: React.FC<AIViewProps> = ({ workspaceId, projectName, branch,
             isCompacting={isCompacting}
             editingMessage={editingMessage}
             onCancelEdit={handleCancelEdit}
+            canInterrupt={canInterrupt}
           />
         </ChatArea>
 

src/components/ChatInput.tsx

@@ -27,10 +27,16 @@ const InputControls = styled.div`
   align-items: flex-end;
 `;
 
-const InputField = styled.textarea<{ isEditing?: boolean }>`
+const InputField = styled.textarea<{ isEditing?: boolean; canInterrupt?: boolean }>`
   flex: 1;
   background: ${(props) => (props.isEditing ? "var(--color-editing-mode-alpha)" : "#1e1e1e")};
-  border: 1px solid ${(props) => (props.isEditing ? "var(--color-editing-mode)" : "#3e3e42")};
+  border: 1px solid
+    ${(props) =>
+      props.isEditing
+        ? "var(--color-editing-mode)"
+        : props.canInterrupt
+          ? "var(--color-interrupted)"
+          : "#3e3e42"};
   color: #d4d4d4;
   padding: 8px 12px;
   border-radius: 4px;
@@ -44,7 +50,12 @@ const InputField = styled.textarea<{ isEditing?: boolean }>`
 
   &:focus {
     outline: none;
-    border-color: ${(props) => (props.isEditing ? "var(--color-editing-mode)" : "#569cd6")};
+    border-color: ${(props) =>
+      props.isEditing
+        ? "var(--color-editing-mode)"
+        : props.canInterrupt
+          ? "var(--color-interrupted)"
+          : "#569cd6"};
   }
 
   &::placeholder {
@@ -101,6 +112,7 @@ export interface ChatInputProps {
   isCompacting?: boolean;
   editingMessage?: { id: string; content: string };
   onCancelEdit?: () => void;
+  canInterrupt?: boolean; // Whether Esc can be used to interrupt streaming
 }
 
 // Helper function to convert parsed command to display toast
@@ -245,6 +257,7 @@ export const ChatInput: React.FC<ChatInputProps> = ({
   isCompacting = false,
   editingMessage,
   onCancelEdit,
+  canInterrupt = false,
 }) => {
   const [input, setInput] = usePersistedState("input:" + workspaceId, "");
   const [isSending, setIsSending] = useState(false);
@@ -373,12 +386,10 @@ export const ChatInput: React.FC<ChatInputProps> = ({
       setIsSending(true);
 
       try {
-        const result = await window.api.workspace.sendMessage(
-          workspaceId,
-          messageText,
-          editingMessage?.id,
-          thinkingLevel
-        );
+        const result = await window.api.workspace.sendMessage(workspaceId, messageText, {
+          editMessageId: editingMessage?.id,
+          thinkingLevel,
+        });
 
         if (!result.success) {
           // Log error for debugging
@@ -422,10 +433,23 @@ export const ChatInput: React.FC<ChatInputProps> = ({
   };
 
   const handleKeyDown = (e: React.KeyboardEvent) => {
-    // Handle Escape key to cancel editing
-    if (e.key === "Escape" && editingMessage && onCancelEdit) {
+    // Handle Escape key
+    if (e.key === "Escape") {
       e.preventDefault();
-      onCancelEdit();
+
+      // Priority 1: Cancel editing if in edit mode
+      if (editingMessage && onCancelEdit) {
+        onCancelEdit();
+        return;
+      }
+
+      // Priority 2: Interrupt streaming if active
+      if (canInterrupt) {
+        // Send empty message to trigger interrupt
+        void window.api.workspace.sendMessage(workspaceId, "");
+        return;
+      }
+
       return;
     }
 
@@ -479,9 +503,12 @@ export const ChatInput: React.FC<ChatInputProps> = ({
               ? "Edit your message... (Esc to cancel, Enter to send)"
               : isCompacting
                 ? "Compacting conversation..."
-                : "Type a message... (Enter to send, Shift+Enter for newline)"
+                : canInterrupt
+                  ? "Type a message... (Esc to interrupt, Enter to send, Shift+Enter for newline)"
+                  : "Type a message... (Enter to send, Shift+Enter for newline)"
           }
           disabled={disabled || isSending || isCompacting}
+          canInterrupt={canInterrupt}
         />
       </InputControls>
       <ModeToggles>

src/components/Messages/InterruptedBarrier.tsx

@@ -16,8 +16,8 @@ const BarrierLine = styled.div`
   background: linear-gradient(
     to right,
     transparent,
-    var(--color-warning, #f59e0b) 20%,
-    var(--color-warning, #f59e0b) 80%,
+    var(--color-interrupted) 20%,
+    var(--color-interrupted) 80%,
     transparent
   );
   opacity: 0.3;
@@ -26,7 +26,7 @@ const BarrierLine = styled.div`
 const BarrierText = styled.div`
   font-family: var(--font-monospace);
   font-size: 10px;
-  color: var(--color-warning, #f59e0b);
+  color: var(--color-interrupted);
   text-transform: uppercase;
   letter-spacing: 1px;
   white-space: nowrap;

src/main.ts

@@ -17,11 +17,10 @@ import type {
   ToolCallStartEvent,
   ToolCallDeltaEvent,
   ToolCallEndEvent,
-} from "./types/aiEvents";
+} from "./types/stream";
 import { IPC_CHANNELS, getChatChannel } from "./constants/ipc-constants";
 import type { SendMessageError } from "./types/errors";
-import type { StreamErrorMessage } from "./types/ipc";
-import type { ThinkingLevel } from "./types/thinking";
+import type { StreamErrorMessage, SendMessageOptions } from "./types/ipc";
 
 const config = new Config();
 const historyService = new HistoryService(config);
@@ -205,20 +204,30 @@ ipcMain.handle(IPC_CHANNELS.WORKSPACE_GET_INFO, async (_event, workspaceId: stri
 
 ipcMain.handle(
   IPC_CHANNELS.WORKSPACE_SEND_MESSAGE,
-  async (
-    _event,
-    workspaceId: string,
-    message: string,
-    editMessageId?: string,
-    thinkingLevel?: ThinkingLevel
-  ) => {
+  async (_event, workspaceId: string, message: string, options?: SendMessageOptions) => {
+    const { editMessageId, thinkingLevel } = options ?? {};
     log.debug("sendMessage handler: Received", {
       workspaceId,
       messagePreview: message.substring(0, 50),
       editMessageId,
       thinkingLevel,
     });
     try {
+      // Early exit: empty message during streaming = interrupt
+      // This allows Esc key to interrupt without creating empty user messages
+      if (!message.trim() && aiService.isStreaming(workspaceId)) {
+        log.debug("sendMessage handler: Empty message during streaming, interrupting");
+        const stopResult = await aiService.stopStream(workspaceId);
+        if (!stopResult.success) {
+          log.error("Failed to stop stream:", stopResult.error);
+          return {
+            success: false,
+            error: createUnknownSendMessageError(stopResult.error),
+          };
+        }
+        return { success: true };
+      }
+
       // If editing, truncate history after the message being edited
       if (editMessageId) {
         const truncateResult = await historyService.truncateAfterMessage(

src/preload.ts

@@ -42,14 +42,8 @@ const api: IPCApi = {
     create: (projectPath, branchName) =>
       ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CREATE, projectPath, branchName),
     remove: (workspaceId: string) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_REMOVE, workspaceId),
-    sendMessage: (workspaceId, message, editMessageId, thinkingLevel) =>
-      ipcRenderer.invoke(
-        IPC_CHANNELS.WORKSPACE_SEND_MESSAGE,
-        workspaceId,
-        message,
-        editMessageId,
-        thinkingLevel
-      ),
+    sendMessage: (workspaceId, message, options) =>
+      ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_SEND_MESSAGE, workspaceId, message, options),
     clearHistory: (workspaceId) =>
       ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CLEAR_HISTORY, workspaceId),
     getInfo: (workspaceId) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_GET_INFO, workspaceId),

src/services/aiService.ts

@@ -18,6 +18,7 @@ import {
   transformModelMessages,
   validateAnthropicCompliance,
   addInterruptedSentinel,
+  filterEmptyAssistantMessages,
 } from "../utils/modelMessageTransform";
 import { applyCacheControl } from "../utils/cacheStrategy";
 import type { HistoryService } from "./historyService";
@@ -195,6 +196,12 @@ export class AIService extends EventEmitter {
     abortSignal?: AbortSignal
   ): Promise<Result<void, SendMessageError>> {
     try {
+      // DEBUG: Log streamMessage call
+      const lastMessage = messages[messages.length - 1];
+      log.debug(
+        `[STREAM MESSAGE] workspaceId=${workspaceId} messageCount=${messages.length} lastRole=${lastMessage?.role}`
+      );
+
       // Before starting a new stream, commit any existing partial to history
       // This is idempotent - won't double-commit if already in chat.jsonl
       await this.partialService.commitToHistory(workspaceId);
@@ -208,8 +215,13 @@ export class AIService extends EventEmitter {
       // Dump original messages for debugging
       log.debug_obj(`${workspaceId}/1_original_messages.json`, messages);
 
+      // Filter out assistant messages with only reasoning (no text/tools)
+      const filteredMessages = filterEmptyAssistantMessages(messages);
+      log.debug(`Filtered ${messages.length - filteredMessages.length} empty assistant messages`);
+      log.debug_obj(`${workspaceId}/1a_filtered_messages.json`, filteredMessages);
+
       // Add [INTERRUPTED] sentinel to partial messages (for model context)
-      const messagesWithSentinel = addInterruptedSentinel(messages);
+      const messagesWithSentinel = addInterruptedSentinel(filteredMessages);
 
       // Convert CmuxMessage to ModelMessage format using Vercel AI SDK utility
       // Type assertion needed because CmuxMessage has custom tool parts for interrupted tools

src/services/historyService.ts

@@ -5,6 +5,7 @@ import { Ok, Err } from "../types/result";
 import type { CmuxMessage } from "../types/message";
 import type { Config } from "../config";
 import { MutexMap } from "../utils/mutexMap";
+import { log } from "./log";
 
 /**
  * HistoryService - Manages chat history persistence and sequence numbering
@@ -122,6 +123,13 @@ export class HistoryService {
       await fs.mkdir(workspaceDir, { recursive: true });
       const historyPath = this.getChatHistoryPath(workspaceId);
 
+      // DEBUG: Log message append with caller stack trace
+      const stack = new Error().stack?.split("\n").slice(2, 6).join("\n") ?? "no stack";
+      log.debug(
+        `[HISTORY APPEND] workspaceId=${workspaceId} role=${message.role} id=${message.id}`
+      );
+      log.debug(`[HISTORY APPEND] Call stack:\n${stack}`);
+
       // Ensure message has a history sequence number
       if (!message.metadata) {
         // Create metadata with history sequence
@@ -156,6 +164,11 @@ export class HistoryService {
         workspaceId,
       };
 
+      // DEBUG: Log assigned sequence number
+      log.debug(
+        `[HISTORY APPEND] Assigned historySequence=${message.metadata.historySequence} role=${message.role}`
+      );
+
       await fs.appendFile(historyPath, JSON.stringify(historyEntry) + "\n");
       return Ok(undefined);
     } catch (error) {