feat(acp): add in-session mode/model/agent controls with ACP preference persistence

apps/tauri/src-tauri/src/acp/commands.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
+use tauri::{AppHandle, Emitter, State};
 use tokio::sync::Mutex;
-use tauri::{AppHandle, State, Emitter};
 
 use super::connection::AcpConnection;
 use super::types::*;
@@ -34,7 +34,11 @@ pub async fn acp_connect(
     };
     if let Some(existing) = existing {
         if existing.is_alive().await {
-            state.connections.lock().await.insert(workspace_id.clone(), existing);
+            state
+                .connections
+                .lock()
+                .await
+                .insert(workspace_id.clone(), existing);
             return Ok(());
         }
         existing.shutdown().await;
@@ -51,11 +55,14 @@ pub async fn acp_connect(
         gh_token: gh_token.clone(),
     };
 
-    let _ = app_handle.emit("acp:connection-status", &ConnectionStatusEvent {
-        workspace_id: workspace_id.clone(),
-        status: "connecting".to_string(),
-        attempt: None,
-    });
+    let _ = app_handle.emit(
+        "acp:connection-status",
+        &ConnectionStatusEvent {
+            workspace_id: workspace_id.clone(),
+            status: "connecting".to_string(),
+            attempt: None,
+        },
+    );
 
     let conn = AcpConnection::spawn(
         &binary,
@@ -82,7 +89,11 @@ pub async fn acp_connect(
     conn.emit_status("connected", None);
     conn.emit_log("info", "connect", &format!("Connected via {}", binary));
 
-    state.configs.lock().await.insert(workspace_id.clone(), config);
+    state
+        .configs
+        .lock()
+        .await
+        .insert(workspace_id.clone(), config);
     state.connections.lock().await.insert(workspace_id, conn);
     Ok(())
 }
@@ -108,9 +119,7 @@ pub async fn acp_new_session(
     state: State<'_, AcpState>,
 ) -> Result<SessionInfo, String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = NewSessionParams {
         cwd,
@@ -136,9 +145,7 @@ pub async fn acp_list_sessions(
     state: State<'_, AcpState>,
 ) -> Result<Vec<SessionSummary>, String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = ListSessionsParams { cwd };
 
@@ -166,9 +173,7 @@ pub async fn acp_load_session(
     state: State<'_, AcpState>,
 ) -> Result<SessionInfo, String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = LoadSessionParams {
         session_id: session_id.clone(),
@@ -200,9 +205,7 @@ pub async fn acp_send_prompt(
     state: State<'_, AcpState>,
 ) -> Result<(), String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = PromptParams {
         session_id,
@@ -230,9 +233,7 @@ pub async fn acp_set_mode(
     state: State<'_, AcpState>,
 ) -> Result<(), String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = SetSessionModeParams {
         session_id,
@@ -248,16 +249,50 @@ pub async fn acp_set_mode(
     Ok(())
 }
 
+#[tauri::command]
+pub async fn acp_set_config_option(
+    workspace_id: String,
+    session_id: String,
+    config_id: String,
+    option_id: String,
+    state: State<'_, AcpState>,
+) -> Result<(), String> {
+    acp_set_config_option_inner(&state, &workspace_id, &session_id, &config_id, &option_id).await
+}
+
+async fn acp_set_config_option_inner(
+    state: &AcpState,
+    workspace_id: &str,
+    session_id: &str,
+    config_id: &str,
+    option_id: &str,
+) -> Result<(), String> {
+    let connections = state.connections.lock().await;
+    let conn = connections.get(workspace_id).ok_or("Not connected")?;
+
+    let params = SetConfigOptionParams {
+        session_id: session_id.to_string(),
+        config_id: config_id.to_string(),
+        value: option_id.to_string(),
+    };
+
+    conn.send_request(
+        "session/set_config_option",
+        Some(serde_json::to_value(&params).map_err(|e| e.to_string())?),
+    )
+    .await?;
+
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn acp_cancel(
     workspace_id: String,
     session_id: String,
     state: State<'_, AcpState>,
 ) -> Result<(), String> {
     let connections = state.connections.lock().await;
-    let conn = connections
-        .get(&workspace_id)
-        .ok_or("Not connected")?;
+    let conn = connections.get(&workspace_id).ok_or("Not connected")?;
 
     let params = CancelParams { session_id };
 
@@ -283,7 +318,11 @@ pub async fn acp_check_health(
     let status = if let Some(conn) = existing {
         if conn.is_alive().await {
             conn.emit_status("connected", None);
-            state.connections.lock().await.insert(workspace_id.clone(), conn);
+            state
+                .connections
+                .lock()
+                .await
+                .insert(workspace_id.clone(), conn);
             "connected"
         } else {
             conn.emit_status("disconnected", None);
@@ -311,3 +350,17 @@ pub async fn disconnect_all(state: &AcpState) {
         conn.shutdown().await;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn set_config_option_returns_not_connected_when_workspace_missing() {
+        let state = AcpState::default();
+        let result = tauri::async_runtime::block_on(async {
+            acp_set_config_option_inner(&state, "ws-1", "s-1", "model", "sonnet").await
+        });
+        assert_eq!(result.unwrap_err(), "Not connected");
+    }
+}

apps/tauri/src-tauri/src/acp/types.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 #[derive(Debug, Serialize)]
 pub struct JsonRpcRequest {
@@ -84,6 +85,14 @@ pub struct SetSessionModeParams {
     pub mode_id: String,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SetConfigOptionParams {
+    pub session_id: String,
+    pub config_id: String,
+    pub value: String,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListSessionsParams {
@@ -102,6 +111,7 @@ pub struct SessionInfo {
     #[serde(default)]
     pub session_id: String,
     pub modes: Option<SessionModeState>,
+    pub config_options: Option<SessionConfigOptionsState>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -120,6 +130,38 @@ pub struct SessionMode {
     pub description: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionConfigOptionsState {
+    #[serde(default)]
+    pub available_config_options: Vec<SessionConfigOption>,
+    #[serde(default)]
+    pub selected_config_options: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionConfigOption {
+    pub id: String,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub category: Option<String>,
+    #[serde(rename = "type")]
+    pub option_type: Option<String>,
+    #[serde(default)]
+    pub options: Vec<SessionConfigOptionValue>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionConfigOptionValue {
+    pub id: Option<String>,
+    pub value: Option<String>,
+    pub name: Option<String>,
+    pub label: Option<String>,
+    pub description: Option<String>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct SessionSummary {
@@ -173,3 +215,22 @@ pub struct ConnectionConfig {
     pub cwd: String,
     pub gh_token: Option<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn set_config_option_params_serializes_option_id_as_value() {
+        let params = SetConfigOptionParams {
+            session_id: "s-1".to_string(),
+            config_id: "model".to_string(),
+            value: "claude-sonnet".to_string(),
+        };
+
+        let value = serde_json::to_value(params).expect("serialize SetConfigOptionParams");
+        assert_eq!(value["sessionId"], "s-1");
+        assert_eq!(value["configId"], "model");
+        assert_eq!(value["value"], "claude-sonnet");
+    }
+}