feat(composer): add /fast command and service-tier forwarding

Author: Dimillian

docs/app-server-events.md

@@ -166,6 +166,9 @@ These are v2 request methods CodexMonitor currently sends to Codex app-server:
 - `skills/list`
 - `app/list`
 
+Notes:
+- `turn/start` now forwards the optional `serviceTier` override (`"fast"` for `/fast`, `null` for default/off) alongside `model`, `effort`, and `collaborationMode`.
+
 ## Missing Client Requests (Codex v2 ClientRequest Methods)
 
 Compared against Codex v2 request methods, CodexMonitor currently does not send:

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -802,6 +802,7 @@ impl DaemonState {
         text: String,
         model: Option<String>,
         effort: Option<String>,
+        service_tier: Option<Option<String>>,
         access_mode: Option<String>,
         images: Option<Vec<String>>,
         app_mentions: Option<Vec<Value>>,
@@ -815,6 +816,7 @@ impl DaemonState {
             text,
             model,
             effort,
+            service_tier,
             access_mode,
             images,
             app_mentions,

src-tauri/src/bin/codex_monitor_daemon/rpc.rs

@@ -85,6 +85,21 @@ pub(super) fn parse_optional_string(value: &Value, key: &str) -> Option<String>
     }
 }
 
+pub(super) fn parse_optional_nullable_string(
+    value: &Value,
+    key: &str,
+) -> Option<Option<String>> {
+    match value {
+        Value::Object(map) => match map.get(key) {
+            Some(Value::Null) => Some(None),
+            Some(Value::String(value)) => Some(Some(value.to_string())),
+            Some(_) => None,
+            None => None,
+        },
+        _ => None,
+    }
+}
+
 pub(super) fn parse_optional_u32(value: &Value, key: &str) -> Option<u32> {
     match value {
         Value::Object(map) => map.get(key).and_then(|value| value.as_u64()).and_then(|v| {

src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs

@@ -160,6 +160,7 @@ pub(super) async fn try_handle(
             };
             let model = parse_optional_string(params, "model");
             let effort = parse_optional_string(params, "effort");
+            let service_tier = parse_optional_nullable_string(params, "serviceTier");
             let access_mode = parse_optional_string(params, "accessMode");
             let images = parse_optional_string_array(params, "images");
             let app_mentions = parse_optional_value(params, "appMentions")
@@ -173,6 +174,7 @@ pub(super) async fn try_handle(
                         text,
                         model,
                         effort,
+                        service_tier,
                         access_mode,
                         images,
                         app_mentions,

src-tauri/src/codex/mod.rs

@@ -14,7 +14,7 @@ use crate::backend::events::AppServerEvent;
 use crate::event_sink::TauriEventSink;
 use crate::remote_backend;
 use crate::shared::agents_config_core;
-use crate::shared::codex_core;
+use crate::shared::codex_core::{self, insert_optional_nullable_string};
 use crate::state::AppState;
 use crate::types::WorkspaceEntry;
 
@@ -322,6 +322,7 @@ pub(crate) async fn send_user_message(
     text: String,
     model: Option<String>,
     effort: Option<String>,
+    service_tier: Option<Option<String>>,
     access_mode: Option<String>,
     images: Option<Vec<String>>,
     app_mentions: Option<Vec<Value>>,
@@ -342,6 +343,7 @@ pub(crate) async fn send_user_message(
         payload.insert("text".to_string(), json!(text));
         payload.insert("model".to_string(), json!(model));
         payload.insert("effort".to_string(), json!(effort));
+        insert_optional_nullable_string(&mut payload, "serviceTier", service_tier);
         payload.insert("accessMode".to_string(), json!(access_mode));
         payload.insert("images".to_string(), json!(images));
         payload.insert("appMentions".to_string(), json!(app_mentions));
@@ -367,6 +369,7 @@ pub(crate) async fn send_user_message(
         text,
         model,
         effort,
+        service_tier,
         access_mode,
         images,
         app_mentions,
@@ -485,7 +488,14 @@ pub(crate) async fn start_review(
         .await;
     }
 
-    codex_core::start_review_core(&state.sessions, workspace_id, thread_id, target, delivery).await
+    codex_core::start_review_core(
+        &state.sessions,
+        workspace_id,
+        thread_id,
+        target,
+        delivery,
+    )
+    .await
 }
 
 #[tauri::command]

src-tauri/src/shared/codex_core.rs

@@ -365,23 +365,34 @@ fn build_turn_input_items(
             input.push(json!({ "type": "mention", "name": name, "path": path }));
         }
     }
-    if input.is_empty() {
-        return Err("empty user message".to_string());
-    }
-    Ok(input)
-}
-
-pub(crate) async fn send_user_message_core(
-    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
-    workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
-    workspace_id: String,
-    thread_id: String,
-    text: String,
-    model: Option<String>,
-    effort: Option<String>,
-    access_mode: Option<String>,
-    images: Option<Vec<String>>,
-    app_mentions: Option<Vec<Value>>,
+    if input.is_empty() {
+        return Err("empty user message".to_string());
+    }
+    Ok(input)
+}
+
+pub(crate) fn insert_optional_nullable_string(
+    params: &mut Map<String, Value>,
+    key: &str,
+    value: Option<Option<String>>,
+) {
+    if let Some(value) = value {
+        params.insert(key.to_string(), json!(value));
+    }
+}
+
+pub(crate) async fn send_user_message_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
+    workspace_id: String,
+    thread_id: String,
+    text: String,
+    model: Option<String>,
+    effort: Option<String>,
+    service_tier: Option<Option<String>>,
+    access_mode: Option<String>,
+    images: Option<Vec<String>>,
+    app_mentions: Option<Vec<Value>>,
     collaboration_mode: Option<Value>,
 ) -> Result<Value, String> {
     let session = get_session_clone(sessions, &workspace_id).await?;
@@ -408,14 +419,15 @@ pub(crate) async fn send_user_message_core(
     let mut params = Map::new();
     params.insert("threadId".to_string(), json!(thread_id));
     params.insert("input".to_string(), json!(input));
-    params.insert("cwd".to_string(), json!(workspace_path));
-    params.insert("approvalPolicy".to_string(), json!(approval_policy));
-    params.insert("sandboxPolicy".to_string(), json!(sandbox_policy));
-    params.insert("model".to_string(), json!(model));
-    params.insert("effort".to_string(), json!(effort));
-    if let Some(mode) = collaboration_mode {
-        if !mode.is_null() {
-            params.insert("collaborationMode".to_string(), mode);
+    params.insert("cwd".to_string(), json!(workspace_path));
+    params.insert("approvalPolicy".to_string(), json!(approval_policy));
+    params.insert("sandboxPolicy".to_string(), json!(sandbox_policy));
+    params.insert("model".to_string(), json!(model));
+    params.insert("effort".to_string(), json!(effort));
+    insert_optional_nullable_string(&mut params, "serviceTier", service_tier);
+    if let Some(mode) = collaboration_mode {
+        if !mode.is_null() {
+            params.insert("collaborationMode".to_string(), mode);
         }
     }
     session
@@ -470,24 +482,24 @@ pub(crate) async fn turn_interrupt_core(
         .await
 }
 
-pub(crate) async fn start_review_core(
-    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
-    workspace_id: String,
-    thread_id: String,
-    target: Value,
-    delivery: Option<String>,
-) -> Result<Value, String> {
-    let session = get_session_clone(sessions, &workspace_id).await?;
-    let mut params = Map::new();
-    params.insert("threadId".to_string(), json!(thread_id));
-    params.insert("target".to_string(), target);
-    if let Some(delivery) = delivery {
-        params.insert("delivery".to_string(), json!(delivery));
-    }
-    session
-        .send_request_for_workspace(&workspace_id, "review/start", Value::Object(params))
-        .await
-}
+pub(crate) async fn start_review_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_id: String,
+    thread_id: String,
+    target: Value,
+    delivery: Option<String>,
+) -> Result<Value, String> {
+    let session = get_session_clone(sessions, &workspace_id).await?;
+    let mut params = Map::new();
+    params.insert("threadId".to_string(), json!(thread_id));
+    params.insert("target".to_string(), target);
+    if let Some(delivery) = delivery {
+        params.insert("delivery".to_string(), json!(delivery));
+    }
+    session
+        .send_request_for_workspace(&workspace_id, "review/start", Value::Object(params))
+        .await
+}
 
 pub(crate) async fn model_list_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
@@ -786,9 +798,10 @@ pub(crate) async fn get_config_model_core(
     Ok(json!({ "model": model }))
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::Value;
 
     #[test]
     fn normalize_strips_file_uri_prefix() {
@@ -851,7 +864,7 @@ mod tests {
     }
 
     #[test]
-    fn read_image_data_url_core_succeeds_with_file_uri_for_real_file() {
+    fn read_image_data_url_core_succeeds_with_file_uri_for_real_file() {
         let dir = std::env::temp_dir().join("codex_monitor_test");
         std::fs::create_dir_all(&dir).unwrap();
         let img_path = dir.join("test_photo.png");
@@ -902,7 +915,25 @@ mod tests {
             "plain filesystem paths with percent sequences should not be decoded, got: {:?}",
             result3.err()
         );
-
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-}
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn insert_optional_nullable_string_omits_missing_and_preserves_null() {
+        let mut params = Map::new();
+
+        insert_optional_nullable_string(&mut params, "serviceTier", None);
+        assert!(!params.contains_key("serviceTier"));
+
+        insert_optional_nullable_string(&mut params, "serviceTier", Some(None));
+        assert_eq!(params.get("serviceTier"), Some(&Value::Null));
+
+        insert_optional_nullable_string(
+            &mut params,
+            "serviceTier",
+            Some(Some("fast".to_string())),
+        );
+        assert_eq!(params.get("serviceTier"), Some(&json!("fast")));
+    }
+}