feat(acp): pre-warm session on connect and expose reasoning efforts

Author: jacobjmc

src-tauri/src/backend/app_server.rs

@@ -62,6 +62,9 @@ pub(crate) struct WorkspaceSession {
     pub(crate) translation_state: Mutex<SessionTranslationState>,
     /// Cached ACP model payload from `session/new`/`session/load`.
     pub(crate) models_cache: Mutex<Option<Value>>,
+    /// Pre-warmed ACP session ID created eagerly on workspace connect.
+    /// Consumed by the first `start_thread` call to avoid a duplicate `session/new`.
+    pub(crate) prewarmed_session_id: Mutex<Option<String>>,
     /// One in-flight `session/prompt` at a time per workspace session.
     pub(crate) prompt_lock: Mutex<()>,
     /// Capability state for best-effort model switching.
@@ -387,6 +390,7 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
         background_thread_callbacks: Mutex::new(HashMap::new()),
         translation_state: Mutex::new(SessionTranslationState::new(String::new())),
         models_cache: Mutex::new(None),
+        prewarmed_session_id: Mutex::new(None),
         prompt_lock: Mutex::new(()),
         model_set_capability: Mutex::new(ModelSetCapability::Unknown),
         model_set_warning_emitted: Mutex::new(false),
@@ -564,6 +568,59 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
     };
     event_sink.emit_app_server_event(payload);
 
+    // Eagerly create a session to pre-populate the models cache so the
+    // frontend model selector is populated before the user sends a prompt.
+    let prewarm_session = Arc::clone(&session);
+    let prewarm_sink = event_sink.clone();
+    let prewarm_workspace_id = entry.id.clone();
+    let prewarm_cwd = entry.path.clone();
+    tokio::spawn(async move {
+        let params = json!({
+            "cwd": prewarm_cwd,
+            "mcpServers": []
+        });
+        match prewarm_session.send_request("session/new", params).await {
+            Ok(response) => {
+                let session_id = response
+                    .get("result")
+                    .and_then(|r| r.get("sessionId"))
+                    .or_else(|| response.get("sessionId"))
+                    .and_then(|v| v.as_str())
+                    .unwrap_or_default()
+                    .to_string();
+
+                if let Some(models) = response
+                    .get("result")
+                    .unwrap_or(&response)
+                    .get("models")
+                    .cloned()
+                {
+                    *prewarm_session.models_cache.lock().await = Some(models);
+                }
+
+                if !session_id.is_empty() {
+                    *prewarm_session.prewarmed_session_id.lock().await =
+                        Some(session_id);
+                }
+
+                let payload = AppServerEvent {
+                    workspace_id: prewarm_workspace_id.clone(),
+                    message: json!({
+                        "method": "codex/modelsReady",
+                        "params": { "workspaceId": prewarm_workspace_id }
+                    }),
+                };
+                prewarm_sink.emit_app_server_event(payload);
+            }
+            Err(err) => {
+                eprintln!(
+                    "Pre-warm session/new failed for {}: {}",
+                    prewarm_workspace_id, err
+                );
+            }
+        }
+    });
+
     Ok(session)
 }
 

src-tauri/src/shared/codex_core.rs

@@ -110,13 +110,24 @@ pub(crate) async fn start_thread_core(
     workspace_id: String,
 ) -> Result<Value, String> {
     let session = get_session_clone(sessions, &workspace_id).await?;
+
+    // Reuse the pre-warmed session if available (created eagerly on workspace
+    // connect to populate the models cache ahead of the first prompt).
+    if let Some(session_id) = session.prewarmed_session_id.lock().await.take() {
+        let mut ts = session.translation_state.lock().await;
+        ts.session_id = session_id.clone();
+        return Ok(json!({
+            "result": {
+                "thread": { "id": session_id }
+            }
+        }));
+    }
+
     let params = json!({
         "cwd": session.entry.path,
         "mcpServers": []
     });
     let response = session.send_request("session/new", params).await?;
-    // ACP returns { sessionId, models, modes, ... }.
-    // Frontend expects { result: { thread: { id: "..." } } }.
     let session_id = response
         .get("result")
         .and_then(|r| r.get("sessionId"))
@@ -1045,6 +1056,34 @@ pub(crate) async fn start_review_core(
     Err("review is not supported by OpenCode ACP".to_string())
 }
 
+const THINKING_LEVELS: &[&str] = &["low", "medium", "high", "max"];
+
+/// Returns `Some((base_name, level))` when `name` ends with ` (<known_level>)`.
+fn strip_thinking_suffix(name: &str) -> Option<(&str, &str)> {
+    let name = name.trim();
+    let rest = name.strip_suffix(')')?;
+    let paren_start = rest.rfind(" (")?;
+    let level = &rest[paren_start + 2..];
+    if THINKING_LEVELS
+        .iter()
+        .any(|tl| tl.eq_ignore_ascii_case(level))
+    {
+        Some((name[..paren_start].trim(), level))
+    } else {
+        None
+    }
+}
+
+fn thinking_level_order(level: &str) -> usize {
+    match level.to_ascii_lowercase().as_str() {
+        "low" => 0,
+        "medium" => 1,
+        "high" => 2,
+        "max" => 3,
+        _ => 99,
+    }
+}
+
 pub(crate) async fn model_list_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,
@@ -1065,6 +1104,31 @@ pub(crate) async fn model_list_core(
         .cloned()
         .unwrap_or_default();
 
+    // Pass 1 — collect thinking-variant effort levels keyed by base display
+    // name, and record which modelIds are variants so they can be skipped.
+    let mut variant_levels: HashMap<String, Vec<String>> = HashMap::new();
+    let mut variant_model_ids: HashSet<String> = HashSet::new();
+
+    for entry in &available_models {
+        let display_name = entry
+            .get("name")
+            .and_then(|v| v.as_str())
+            .unwrap_or_default();
+        if let Some((base_name, level)) = strip_thinking_suffix(display_name) {
+            variant_levels
+                .entry(base_name.to_string())
+                .or_default()
+                .push(level.to_string());
+            if let Some(mid) = entry.get("modelId").and_then(|v| v.as_str()) {
+                variant_model_ids.insert(mid.trim().to_string());
+            }
+        }
+    }
+    for levels in variant_levels.values_mut() {
+        levels.sort_by_key(|l| thinking_level_order(l));
+    }
+
+    // Pass 2 — emit base models only, with effort levels attached.
     let data: Vec<Value> = available_models
         .into_iter()
         .filter_map(|entry| {
@@ -1074,7 +1138,7 @@ pub(crate) async fn model_list_core(
                 .unwrap_or_default()
                 .trim()
                 .to_string();
-            if model_id.is_empty() {
+            if model_id.is_empty() || variant_model_ids.contains(&model_id) {
                 return None;
             }
             let display_name = entry
@@ -1084,13 +1148,47 @@ pub(crate) async fn model_list_core(
                 .trim()
                 .to_string();
 
+            // Prefer explicit ACP field; fall back to levels scraped from
+            // variant entries whose base name matches this model.
+            let acp_efforts = entry
+                .get("supportedReasoningEfforts")
+                .and_then(|v| v.as_array())
+                .filter(|a| !a.is_empty());
+
+            let efforts: Vec<Value> = if let Some(acp) = acp_efforts {
+                acp.iter()
+                    .map(|e| {
+                        if e.is_object() {
+                            e.clone()
+                        } else {
+                            let label = e.as_str().unwrap_or_default();
+                            json!({ "reasoningEffort": label, "description": "" })
+                        }
+                    })
+                    .collect()
+            } else {
+                variant_levels
+                    .get(&display_name)
+                    .into_iter()
+                    .flatten()
+                    .map(|level| json!({ "reasoningEffort": level, "description": "" }))
+                    .collect()
+            };
+
+            let default_effort = entry
+                .get("defaultReasoningEffort")
+                .and_then(|v| v.as_str())
+                .filter(|s| !s.trim().is_empty())
+                .map(|s| Value::String(s.trim().to_string()))
+                .unwrap_or(Value::Null);
+
             Some(json!({
                 "id": model_id.clone(),
                 "model": model_id.clone(),
                 "displayName": display_name,
                 "description": "",
-                "supportedReasoningEfforts": [],
-                "defaultReasoningEffort": null,
+                "supportedReasoningEfforts": efforts,
+                "defaultReasoningEffort": default_effort,
                 "isDefault": model_id == current_model,
             }))
         })

src/features/app/hooks/useAppServerEvents.ts

@@ -31,6 +31,7 @@ type AgentCompleted = {
 type AppServerEventHandlers = {
   onWorkspaceConnected?: (workspaceId: string) => void;
   onWorkspaceDisconnected?: (workspaceId: string) => void;
+  onModelsReady?: (workspaceId: string) => void;
   onThreadStarted?: (workspaceId: string, thread: Record<string, unknown>) => void;
   onThreadNameUpdated?: (
     workspaceId: string,
@@ -98,6 +99,7 @@ export const METHODS_ROUTED_IN_USE_APP_SERVER_EVENTS = [
   "codex/backgroundThread",
   "codex/connected",
   "codex/disconnected",
+  "codex/modelsReady",
   "error",
   "item/agentMessage/delta",
   "item/commandExecution/outputDelta",
@@ -150,6 +152,11 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
         return;
       }
 
+      if (method === "codex/modelsReady") {
+        currentHandlers.onModelsReady?.(workspace_id);
+        return;
+      }
+
       const requestId = getAppServerRequestId(payload);
       const hasRequestId = requestId !== null;
 

src/features/composer/components/Composer.tsx

@@ -50,6 +50,7 @@ type ComposerProps = {
   onStop: () => void;
   canStop: boolean;
   disabled?: boolean;
+  isConnected?: boolean;
   appsEnabled: boolean;
   isProcessing: boolean;
   steerEnabled: boolean;
@@ -153,6 +154,7 @@ export const Composer = memo(function Composer({
   onStop,
   canStop,
   disabled = false,
+  isConnected = false,
   appsEnabled,
   isProcessing,
   steerEnabled,
@@ -815,6 +817,7 @@ export const Composer = memo(function Composer({
       />
       <ComposerMetaBar
         disabled={disabled}
+        isConnected={isConnected}
         collaborationModes={collaborationModes}
         selectedCollaborationModeId={selectedCollaborationModeId}
         onSelectCollaborationMode={onSelectCollaborationMode}

src/features/composer/components/ComposerMetaBar.tsx

@@ -4,6 +4,7 @@ import type { AccessMode, ThreadTokenUsage } from "../../../types";
 
 type ComposerMetaBarProps = {
   disabled: boolean;
+  isConnected?: boolean;
   collaborationModes: { id: string; label: string }[];
   selectedCollaborationModeId: string | null;
   onSelectCollaborationMode: (id: string | null) => void;
@@ -21,6 +22,7 @@ type ComposerMetaBarProps = {
 
 export function ComposerMetaBar({
   disabled,
+  isConnected = false,
   collaborationModes,
   selectedCollaborationModeId,
   onSelectCollaborationMode,
@@ -167,7 +169,9 @@ export function ComposerMetaBar({
             onChange={(event) => onSelectModel(event.target.value)}
             disabled={disabled}
           >
-            {models.length === 0 && <option value="">No models</option>}
+            {models.length === 0 && (
+              <option value="">{isConnected ? "Loading models..." : "No models"}</option>
+            )}
             {models.map((model) => (
               <option key={model.id} value={model.id}>
                 {model.displayName || model.model}

src/features/layout/hooks/layoutNodes/buildPrimaryNodes.tsx

@@ -123,6 +123,7 @@ export function buildPrimaryNodes(options: LayoutNodesOptions): PrimaryLayoutNod
       onStop={options.onStop}
       canStop={options.canStop}
       disabled={options.isReviewing}
+      isConnected={options.activeWorkspace?.connected ?? false}
       onFileAutocompleteActiveChange={options.onFileAutocompleteActiveChange}
       contextUsage={options.activeTokenUsage}
       queuedMessages={options.activeQueue}

src/features/models/hooks/useModels.ts

@@ -1,6 +1,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { DebugEntry, ModelOption, WorkspaceInfo } from "../../../types";
 import { getConfigModel, getModelList } from "../../../services/tauri";
+import { subscribeAppServerEvents } from "../../../services/events";
+import { getAppServerRawMethod } from "../../../utils/appServerEvents";
 import {
   normalizeEffortValue,
   parseModelListResponse,
@@ -287,6 +289,29 @@ export function useModels({
     refreshModels();
   }, [isConnected, models.length, refreshModels, selectionKey, workspaceId]);
 
+  useEffect(() => {
+    if (!workspaceId || !isConnected) {
+      return;
+    }
+    const unsub = subscribeAppServerEvents((event) => {
+      const method = getAppServerRawMethod(event);
+      if (method !== "codex/modelsReady") {
+        return;
+      }
+      const wsId =
+        event &&
+        typeof event === "object" &&
+        "workspace_id" in event &&
+        typeof (event as Record<string, unknown>).workspace_id === "string"
+          ? (event as Record<string, unknown>).workspace_id
+          : null;
+      if (wsId === workspaceId) {
+        refreshModels();
+      }
+    });
+    return unsub;
+  }, [isConnected, refreshModels, workspaceId]);
+
   useEffect(() => {
     if (!selectedModel) {
       return;

src/utils/appServerEvents.ts

@@ -8,6 +8,7 @@ export const SUPPORTED_APP_SERVER_METHODS = [
   "codex/backgroundThread",
   "codex/connected",
   "codex/disconnected",
+  "codex/modelsReady",
   "codex/event/skills_update_available",
   "error",
   "item/agentMessage/delta",