feat: Backend cancellation support for interrupting model responses

Merged from feature/interrupt-on-type branch.

Backend cancellation infrastructure:
- Added tokio watch channel to SessionState for cancellation signaling
- Implemented cancel_chat command
- Modified chat command to use tokio::select! for racing requests vs cancellation
- When cancelled, HTTP request to Ollama is dropped and returns early
- Added tokio dependency with sync feature

Story updates:
- Story 13: Updated to use Stop button pattern (industry standard)
- Story 18: Created placeholder for streaming responses
- Stories 15-17: Placeholders for future features

Frontend changes:
- Removed auto-interrupt on typing behavior (too confusing)
- Backend infrastructure ready for Stop button implementation

Note: Story 13 UI (Stop button) not yet implemented - backend ready

src-tauri/Cargo.lock

@@ -2067,6 +2067,7 @@ dependencies = [
  "tauri-plugin-dialog",
  "tauri-plugin-opener",
  "tauri-plugin-store",
+ "tokio",
  "uuid",
  "walkdir",
 ]

src-tauri/Cargo.toml

@@ -30,4 +30,5 @@ uuid = { version = "1.19.0", features = ["v4", "serde"] }
 chrono = { version = "0.4.42", features = ["serde"] }
 async-trait = "0.1.89"
 tauri-plugin-store = "2.4.1"
+tokio = { version = "1.48.0", features = ["sync"] }
 

src-tauri/src/commands/chat.rs

@@ -8,6 +8,7 @@ use crate::state::SessionState;
 use serde::Deserialize;
 use serde_json::json;
 use tauri::{AppHandle, Emitter, State};
+use tokio::select;
 
 #[derive(Deserialize)]
 pub struct ProviderConfig {
@@ -25,6 +26,12 @@ pub async fn get_ollama_models(base_url: Option<String>) -> Result<Vec<String>,
     OllamaProvider::get_models(&url).await
 }
 
+#[tauri::command]
+pub async fn cancel_chat(state: State<'_, SessionState>) -> Result<(), String> {
+    state.cancel_tx.send(true).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn chat(
     app: AppHandle,
@@ -32,6 +39,9 @@ pub async fn chat(
     config: ProviderConfig,
     state: State<'_, SessionState>,
 ) -> Result<Vec<Message>, String> {
+    // Reset cancellation flag at start
+    let _ = state.cancel_tx.send(false);
+    let mut cancel_rx = state.cancel_rx.clone();
     // 1. Setup Provider
     let provider: Box<dyn ModelProvider> = match config.provider.as_str() {
         "ollama" => Box::new(OllamaProvider::new(
@@ -84,11 +94,23 @@ pub async fn chat(
         }
         turn_count += 1;
 
-        // Call LLM
-        let response = provider
-            .chat(&config.model, &current_history, tools)
-            .await
-            .map_err(|e| format!("LLM Error: {}", e))?;
+        // Call LLM with cancellation support
+        let chat_future = provider.chat(&config.model, &current_history, tools);
+
+        let response = select! {
+            result = chat_future => {
+                result.map_err(|e| format!("LLM Error: {}", e))?
+            }
+            _ = cancel_rx.changed() => {
+                if *cancel_rx.borrow() {
+                    return Err("Chat cancelled by user".to_string());
+                }
+                // False alarm, continue
+                provider.chat(&config.model, &current_history, tools)
+                    .await
+                    .map_err(|e| format!("LLM Error: {}", e))?
+            }
+        };
 
         // Process Response
         if let Some(tool_calls) = response.tool_calls {

src-tauri/src/lib.rs

@@ -23,6 +23,7 @@ pub fn run() {
             commands::search::search_files,
             commands::shell::exec_shell,
             commands::chat::chat,
+            commands::chat::cancel_chat,
             commands::chat::get_ollama_models
         ])
         .run(tauri::generate_context!())

src-tauri/src/state.rs

@@ -1,7 +1,20 @@
 use std::path::PathBuf;
 use std::sync::Mutex;
+use tokio::sync::watch;
 
-#[derive(Default)]
 pub struct SessionState {
     pub project_root: Mutex<Option<PathBuf>>,
+    pub cancel_tx: watch::Sender<bool>,
+    pub cancel_rx: watch::Receiver<bool>,
+}
+
+impl Default for SessionState {
+    fn default() -> Self {
+        let (cancel_tx, cancel_rx) = watch::channel(false);
+        Self {
+            project_root: Mutex::new(None),
+            cancel_tx,
+            cancel_rx,
+        }
+    }
 }