feat: add streaming control with stop functionality

- Implement interrupt functionality for codex sessions
- Add pause_session command alongside existing stop_session
- Update ChatInput with stop button during streaming
- Add stop streaming handler in ChatInterface
- Improve session state management for loading states

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: milisp

src-tauri/src/codex_client.rs

@@ -273,7 +273,6 @@ impl CodexClient {
         self.send_submission(submission).await
     }
 
-    #[allow(dead_code)]
     pub async fn interrupt(&self) -> Result<()> {
         let submission = Submission {
             id: Uuid::new_v4().to_string(),
@@ -338,7 +337,8 @@ impl CodexClient {
         log::debug!("Session {} closed", self.session_id);
         Ok(())
     }
-
+    
+    #[allow(dead_code)]
     pub async fn shutdown(&mut self) -> Result<()> {
         self.close_session().await
     }

src-tauri/src/commands.rs

@@ -46,6 +46,11 @@ pub async fn stop_session(state: State<'_, CodexState>, session_id: String) -> R
     codex::stop_session(state, session_id).await
 }
 
+#[tauri::command]
+pub async fn pause_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
+    codex::pause_session(state, session_id).await
+}
+
 #[tauri::command]
 pub async fn close_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
     codex::close_session(state, session_id).await

src-tauri/src/lib.rs

@@ -9,7 +9,7 @@ mod utils;
 
 use commands::{
     approve_execution, check_codex_version, close_session, delete_session_file,
-    get_latest_session_id, get_running_sessions, load_sessions_from_disk, send_message,
+    get_latest_session_id, get_running_sessions, load_sessions_from_disk, pause_session, send_message,
     start_codex_session, stop_session,
 };
 use config::{
@@ -53,6 +53,7 @@ pub fn run() {
             send_message,
             approve_execution,
             stop_session,
+            pause_session,
             close_session,
             get_running_sessions,
             load_sessions_from_disk,

src-tauri/src/services/codex.rs

@@ -74,18 +74,38 @@ pub async fn approve_execution(
 }
 
 pub async fn stop_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
-    let mut sessions = state.sessions.lock().await;
+    let sessions = state.sessions.lock().await;
     let stored_sessions: Vec<String> = sessions.keys().cloned().collect();
 
-    log::debug!("Attempting to stop session: {}", session_id);
+    log::debug!("Attempting to interrupt session: {}", session_id);
     log::debug!("Currently stored sessions: {:?}", stored_sessions);
 
-    if let Some(mut client) = sessions.remove(&session_id) {
-        log::debug!("Found and removing session: {}", session_id);
+    if let Some(client) = sessions.get(&session_id) {
+        log::debug!("Found session, sending interrupt: {}", session_id);
+        client
+            .interrupt()
+            .await
+            .map_err(|e| format!("Failed to interrupt session: {}", e))?;
+        Ok(())
+    } else {
+        log::debug!("Session not found: {}", session_id);
+        Err("Session not found".to_string())
+    }
+}
+
+pub async fn pause_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
+    let sessions = state.sessions.lock().await;
+    let stored_sessions: Vec<String> = sessions.keys().cloned().collect();
+
+    log::debug!("Attempting to pause session: {}", session_id);
+    log::debug!("Currently stored sessions: {:?}", stored_sessions);
+
+    if let Some(client) = sessions.get(&session_id) {
+        log::debug!("Found session, sending interrupt (pause): {}", session_id);
         client
-            .shutdown()
+            .interrupt()
             .await
-            .map_err(|e| format!("Failed to shutdown session: {}", e))?;
+            .map_err(|e| format!("Failed to pause session: {}", e))?;
         Ok(())
     } else {
         log::debug!("Session not found: {}", session_id);

src/components/chat/ChatInput.tsx

@@ -2,7 +2,7 @@ import React, { useState, useEffect } from 'react';
 import { Button } from '../ui/button';
 import { Textarea } from '../ui/textarea';
 import { Badge } from '../ui/badge';
-import { Send, AtSign, X, ChevronUp, Cpu } from 'lucide-react';
+import { Send, AtSign, X, ChevronUp, Cpu, Square } from 'lucide-react';
 import {
   Tooltip,
   TooltipContent,
@@ -23,6 +23,7 @@ interface ChatInputProps {
   inputValue: string;
   onInputChange: (value: string) => void;
   onSendMessage: (message: string) => void;
+  onStopStreaming?: () => void;
   disabled?: boolean;
   isLoading?: boolean;
   placeholderOverride?: string;
@@ -32,6 +33,7 @@ export const ChatInput: React.FC<ChatInputProps> = ({
   inputValue,
   onInputChange,
   onSendMessage,
+  onStopStreaming,
   disabled = false,
   isLoading = false,
   placeholderOverride,
@@ -144,6 +146,12 @@ export const ChatInput: React.FC<ChatInputProps> = ({
     clearFileReferences();
   };
 
+  const handleStopStreaming = () => {
+    if (onStopStreaming) {
+      onStopStreaming();
+    }
+  };
+
   const handleKeyPress = (e: React.KeyboardEvent) => {
     if (e.key === 'Enter' && !e.shiftKey) {
       e.preventDefault();
@@ -201,14 +209,25 @@ export const ChatInput: React.FC<ChatInputProps> = ({
           className="flex-1 min-h-[40px] max-h-[120px]"
           disabled={false}
         />
-        <Button
-          onClick={handleSendMessage}
-          disabled={!inputValue.trim() || isLoading || disabled}
-          size="sm"
-          className="self-end"
-        >
-          <Send className="w-4 h-4" />
-        </Button>
+        {isLoading ? (
+          <Button
+            onClick={handleStopStreaming}
+            size="sm"
+            className="self-end bg-red-500 hover:bg-red-600 text-white"
+            variant="default"
+          >
+            <Square className="w-4 h-4" />
+          </Button>
+        ) : (
+          <Button
+            onClick={handleSendMessage}
+            disabled={!inputValue.trim() || disabled}
+            size="sm"
+            className="self-end"
+          >
+            <Send className="w-4 h-4" />
+          </Button>
+        )}
       </div>
 
       {/* Model Selection Bar */}

src/components/chat/ChatInterface.tsx

@@ -314,6 +314,27 @@ export const ChatInterface: React.FC<ChatInterfaceProps> = ({
     }
   };
 
+  const handleStopStreaming = async () => {
+    try {
+      // Extract raw session ID for backend communication
+      const rawSessionId = sessionId.startsWith('codex-event-') 
+        ? sessionId.replace('codex-event-', '') 
+        : sessionId;
+
+      await invoke("pause_session", {
+        sessionId: rawSessionId,
+      });
+      
+      // Immediately set loading to false after successful pause
+      setSessionLoading(sessionId, false);
+      
+    } catch (error) {
+      console.error("Failed to pause streaming:", error);
+      // On error, also set loading to false
+      setSessionLoading(sessionId, false);
+    }
+  };
+
   return (
     <div className="flex h-full min-h-0">
       {/* Session Manager - conditionally visible */}
@@ -349,6 +370,7 @@ export const ChatInterface: React.FC<ChatInterfaceProps> = ({
           inputValue={inputValue}
           onInputChange={setInputValue}
           onSendMessage={handleSendMessage}
+          onStopStreaming={handleStopStreaming}
           disabled={!!selectedConversation}
           isLoading={isLoading}
         />

src/hooks/useCodexEvents.ts

@@ -88,6 +88,7 @@ export const useCodexEvents = ({
         break;
 
       case 'task_complete':
+        console.log('🔄 Task complete event received, setting loading to false');
         setSessionLoading(sessionId, false);
         // Finalize any ongoing stream
         if (currentStreamingMessageId.current) {