Restore built-in command options

Author: jacobjmc

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -677,6 +677,10 @@ impl DaemonState {
         codex_core::list_mcp_server_status_core(&self.sessions, workspace_id, cursor, limit).await
     }
 
+    async fn list_slash_commands(&self, workspace_id: String) -> Result<Value, String> {
+        codex_core::list_slash_commands_core(&self.sessions, workspace_id).await
+    }
+
     async fn archive_thread(
         &self,
         workspace_id: String,
@@ -689,8 +693,26 @@ impl DaemonState {
         &self,
         workspace_id: String,
         thread_id: String,
+        model: Option<String>,
+    ) -> Result<Value, String> {
+        codex_core::compact_thread_core(&self.sessions, workspace_id, thread_id, model).await
+    }
+
+    async fn execute_slash_command(
+        &self,
+        workspace_id: String,
+        thread_id: String,
+        command: String,
+        arguments: Option<String>,
     ) -> Result<Value, String> {
-        codex_core::compact_thread_core(&self.sessions, workspace_id, thread_id).await
+        codex_core::execute_slash_command_core(
+            &self.sessions,
+            workspace_id,
+            thread_id,
+            command,
+            arguments,
+        )
+        .await
     }
 
     async fn set_thread_name(

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

@@ -76,6 +76,13 @@ pub(super) async fn try_handle(
                     .await,
             )
         }
+        "list_slash_commands" => {
+            let workspace_id = match parse_string(params, "workspaceId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            Some(state.list_slash_commands(workspace_id).await)
+        }
         "archive_thread" => {
             let workspace_id = match parse_string(params, "workspaceId") {
                 Ok(value) => value,
@@ -96,7 +103,28 @@ pub(super) async fn try_handle(
                 Ok(value) => value,
                 Err(err) => return Some(Err(err)),
             };
-            Some(state.compact_thread(workspace_id, thread_id).await)
+            let model = parse_optional_string(params, "model");
+            Some(state.compact_thread(workspace_id, thread_id, model).await)
+        }
+        "execute_slash_command" => {
+            let workspace_id = match parse_string(params, "workspaceId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let thread_id = match parse_string(params, "threadId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let command = match parse_string(params, "command") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let arguments = parse_optional_string(params, "arguments");
+            Some(
+                state
+                    .execute_slash_command(workspace_id, thread_id, command, arguments)
+                    .await,
+            )
         }
         "set_thread_name" => {
             let workspace_id = match parse_string(params, "workspaceId") {

src-tauri/src/codex/mod.rs

@@ -173,6 +173,25 @@ pub(crate) async fn list_mcp_server_status(
     codex_core::list_mcp_server_status_core(&state.sessions, workspace_id, cursor, limit).await
 }
 
+#[tauri::command]
+pub(crate) async fn list_slash_commands(
+    workspace_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "list_slash_commands",
+            json!({ "workspaceId": workspace_id }),
+        )
+        .await;
+    }
+
+    codex_core::list_slash_commands_core(&state.sessions, workspace_id).await
+}
+
 #[tauri::command]
 pub(crate) async fn archive_thread(
     workspace_id: String,
@@ -197,6 +216,7 @@ pub(crate) async fn archive_thread(
 pub(crate) async fn compact_thread(
     workspace_id: String,
     thread_id: String,
+    model: Option<String>,
     state: State<'_, AppState>,
     app: AppHandle,
 ) -> Result<Value, String> {
@@ -205,12 +225,46 @@ pub(crate) async fn compact_thread(
             &*state,
             app,
             "compact_thread",
-            json!({ "workspaceId": workspace_id, "threadId": thread_id }),
+            json!({ "workspaceId": workspace_id, "threadId": thread_id, "model": model }),
         )
         .await;
     }
 
-    codex_core::compact_thread_core(&state.sessions, workspace_id, thread_id).await
+    codex_core::compact_thread_core(&state.sessions, workspace_id, thread_id, model).await
+}
+
+#[tauri::command]
+pub(crate) async fn execute_slash_command(
+    workspace_id: String,
+    thread_id: String,
+    command: String,
+    arguments: Option<String>,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "execute_slash_command",
+            json!({
+                "workspaceId": workspace_id,
+                "threadId": thread_id,
+                "command": command,
+                "arguments": arguments,
+            }),
+        )
+        .await;
+    }
+
+    codex_core::execute_slash_command_core(
+        &state.sessions,
+        workspace_id,
+        thread_id,
+        command,
+        arguments,
+    )
+    .await
 }
 
 #[tauri::command]

src-tauri/src/lib.rs

@@ -240,8 +240,10 @@ pub fn run() {
             codex::fork_thread,
             codex::list_threads,
             codex::list_mcp_server_status,
+            codex::list_slash_commands,
             codex::archive_thread,
             codex::compact_thread,
+            codex::execute_slash_command,
             codex::set_thread_name,
             codex::collaboration_mode_list,
             workspaces::connect_workspace,

src-tauri/src/shared/codex_core.rs

@@ -805,6 +805,16 @@ pub(crate) async fn list_mcp_server_status_core(
     Ok(json!({ "result": { "data": data, "nextCursor": null } }))
 }
 
+pub(crate) async fn list_slash_commands_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_id: String,
+) -> Result<Value, String> {
+    let session = get_session_clone(sessions, &workspace_id).await?;
+    let response = session.rest_get("/command").await?;
+    let data = response.as_array().cloned().unwrap_or_default();
+    Ok(json!({ "result": { "data": data } }))
+}
+
 pub(crate) async fn archive_thread_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,
@@ -822,12 +832,58 @@ pub(crate) async fn compact_thread_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,
     thread_id: String,
+    model: Option<String>,
 ) -> Result<Value, String> {
     let session = get_session_clone(sessions, &workspace_id).await?;
-    // Send /compact as a message via POST /session/:id/message.
-    let path = format!("/session/{thread_id}/message");
+    let requested_model = normalize_optional_string(model);
+    let model_override = if let Some(ref model_id) = requested_model {
+        resolve_prompt_model_override(session.as_ref(), model_id)
+            .await
+            .ok_or_else(|| format!("Failed to resolve model `{model_id}` for context compaction."))?
+    } else {
+        return Err(
+            "No model selected for context compaction. Select a model (or connect a provider) and try again."
+                .to_string(),
+        );
+    };
+
+    let provider_id = model_override
+        .get("providerID")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| "Compaction model resolution missing providerID.".to_string())?;
+    let model_id = model_override
+        .get("modelID")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| "Compaction model resolution missing modelID.".to_string())?;
+
+    let path = format!("/session/{thread_id}/summarize");
+    session
+        .rest_post(
+            &path,
+            json!({
+                "providerID": provider_id,
+                "modelID": model_id,
+            }),
+        )
+        .await
+}
+
+pub(crate) async fn execute_slash_command_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_id: String,
+    thread_id: String,
+    command: String,
+    arguments: Option<String>,
+) -> Result<Value, String> {
+    let command = command.trim().trim_start_matches('/').to_string();
+    if command.is_empty() {
+        return Err("empty slash command".to_string());
+    }
+    let session = get_session_clone(sessions, &workspace_id).await?;
+    let path = format!("/session/{thread_id}/command");
     let body = json!({
-        "parts": [{ "type": "text", "text": "/compact" }]
+        "command": command,
+        "arguments": arguments.unwrap_or_default().trim().to_string()
     });
     session.rest_post(&path, body).await
 }

src/App.tsx

@@ -536,6 +536,8 @@ function MainApp() {
     startApps,
     startMcp,
     startStatus,
+    slashCommands,
+    executeSlashCommand,
     reviewPrompt,
     closeReviewPrompt,
     showPresetStep,
@@ -1191,6 +1193,8 @@ function MainApp() {
     startApps,
     startMcp,
     startStatus,
+    slashCommands,
+    executeSlashCommand,
   });
 
   const {
@@ -2089,6 +2093,7 @@ function MainApp() {
     onSelectAccessMode: handleSelectAccessMode,
     skills,
     appsEnabled: appsFeatureEnabled,
+    slashCommands,
     apps,
     prompts,
     files,
@@ -2189,6 +2194,7 @@ function MainApp() {
       onSelectInstance={handleSelectWorkspaceInstance}
       skills={skills}
       appsEnabled={appsFeatureEnabled}
+      slashCommands={slashCommands}
       apps={apps}
       prompts={prompts}
       files={files}

src/features/app/hooks/useComposerController.ts

@@ -1,5 +1,10 @@
 import { useCallback, useMemo, useState } from "react";
-import type { AppMention, QueuedMessage, WorkspaceInfo } from "../../../types";
+import type {
+  AppMention,
+  OpenCodeSlashCommand,
+  QueuedMessage,
+  WorkspaceInfo,
+} from "../../../types";
 import { useComposerImages } from "../../composer/hooks/useComposerImages";
 import { useQueuedSend } from "../../threads/hooks/useQueuedSend";
 
@@ -23,6 +28,8 @@ export function useComposerController({
   startApps,
   startMcp,
   startStatus,
+  slashCommands = [],
+  executeSlashCommand = async () => {},
 }: {
   activeThreadId: string | null;
   activeTurnId: string | null;
@@ -55,6 +62,8 @@ export function useComposerController({
   startApps: (text: string) => Promise<void>;
   startMcp: (text: string) => Promise<void>;
   startStatus: (text: string) => Promise<void>;
+  slashCommands?: OpenCodeSlashCommand[];
+  executeSlashCommand?: (text: string) => Promise<void>;
 }) {
   const [composerDraftsByThread, setComposerDraftsByThread] = useState<
     Record<string, string>
@@ -98,6 +107,8 @@ export function useComposerController({
     startApps,
     startMcp,
     startStatus,
+    slashCommands,
+    executeSlashCommand,
     clearActiveImages,
   });
 

src/features/composer/components/Composer.tsx

@@ -14,6 +14,7 @@ import type {
   ComposerEditorSettings,
   CustomPromptOption,
   DictationTranscript,
+  OpenCodeSlashCommand,
   QueuedMessage,
   ThreadTokenUsage,
 } from "../../../types";
@@ -52,6 +53,7 @@ type ComposerProps = {
   disabled?: boolean;
   isConnected?: boolean;
   appsEnabled: boolean;
+  slashCommands?: OpenCodeSlashCommand[];
   isProcessing: boolean;
   steerEnabled: boolean;
   collaborationModes: { id: string; label: string }[];
@@ -156,6 +158,7 @@ export const Composer = memo(function Composer({
   disabled = false,
   isConnected = false,
   appsEnabled,
+  slashCommands = [],
   isProcessing,
   steerEnabled,
   collaborationModes,
@@ -283,6 +286,7 @@ export const Composer = memo(function Composer({
     selectionStart,
     disabled,
     appsEnabled,
+    slashCommands,
     skills,
     apps,
     prompts,