Support model and effort selection for external agents

crates/config/src/schema.rs

@@ -374,6 +374,10 @@ pub struct ExternalAgentConfig {
     #[serde(default)]
     pub args: Vec<String>,
     #[serde(default)]
+    pub models: Vec<String>,
+    #[serde(default)]
+    pub efforts: Vec<String>,
+    #[serde(default)]
     pub env: HashMap<String, String>,
     pub working_dir: Option<String>,
     pub timeout_secs: Option<u64>,

crates/config/src/schema/tests.rs

@@ -971,6 +971,23 @@ enabled = true
     assert_eq!(entry.wire_api, WireApi::ChatCompletions);
 }
 
+#[test]
+fn external_agent_models_from_toml() {
+    let toml_str = r#"
+[external_agents]
+enabled = true
+
+[external_agents.agents.claude-code]
+binary = "claude"
+models = ["claude-opus-4-8", "claude-sonnet-4-6"]
+efforts = ["high", "xhigh"]
+"#;
+    let config: MoltisConfig = toml::from_str(toml_str).unwrap();
+    let entry = config.external_agents.agents.get("claude-code").unwrap();
+    assert_eq!(entry.models, vec!["claude-opus-4-8", "claude-sonnet-4-6"]);
+    assert_eq!(entry.efforts, vec!["high", "xhigh"]);
+}
+
 #[test]
 fn provider_entry_wire_api_skip_serializing_default() {
     let entry = ProviderEntry::default();

crates/config/src/template.rs

@@ -693,6 +693,8 @@ port = {port}                           # Port number (auto-generated for this i
 # [external_agents.agents.claude-code]
 # binary = "claude"                 # Override binary path (default: look up on $PATH)
 # args = ["-p", "--output-format", "json"]
+# models = ["claude-opus-4-8", "claude-sonnet-4-6"] # Optional model choices shown in /model
+# efforts = ["high", "xhigh"]       # Optional effort choices shown in /model
 # working_dir = "."                 # Override working directory
 # timeout_secs = 300                # Session timeout
 # use_tmux = false                  # Force tmux backend (vs direct PTY)
@@ -702,6 +704,8 @@ port = {port}                           # Port number (auto-generated for this i
 # [external_agents.agents.codex]
 # binary = "codex"
 # args = ["app-server"]
+# models = ["gpt-5.5", "gpt-5.4"]
+# efforts = ["medium", "high", "xhigh"]
 
 # [external_agents.agents.acp]
 # binary = "/path/to/acp-agent"

crates/config/src/validate/schema_map.rs

@@ -57,6 +57,8 @@ pub(super) fn build_schema_map() -> KnownKeys {
         Struct(HashMap::from([
             ("binary", Leaf),
             ("args", Array(Box::new(Leaf))),
+            ("models", Array(Box::new(Leaf))),
+            ("efforts", Array(Box::new(Leaf))),
             ("env", Map(Box::new(Leaf))),
             ("working_dir", Leaf),
             ("timeout_secs", Leaf),

crates/config/src/validate/tests/agents.rs

@@ -347,9 +347,13 @@ enabled = true
 
 [external_agents.agents.claude-code]
 binary = "claude"
+models = ["claude-opus-4-8", "claude-sonnet-4-6"]
+efforts = ["high", "xhigh"]
 
 [external_agents.agents.codex]
 binary = "codex"
+models = ["gpt-5.5", "gpt-5.4"]
+efforts = ["medium", "high", "xhigh"]
 "#;
     let result = validate_toml_str(toml);
     let warning = result

crates/external-agents/src/runtimes/claude_code.rs

@@ -74,6 +74,8 @@ impl ExternalAgentTransport for ClaudeCodeTransport {
             spec.working_dir.clone(),
             spec.timeout_secs,
             spec.external_session_id.clone(),
+            spec.model.clone(),
+            spec.effort.clone(),
         )))
     }
 }
@@ -85,6 +87,8 @@ struct ClaudeCodeSession {
     working_dir: Option<PathBuf>,
     timeout: Duration,
     session_id: Option<String>,
+    model: Option<String>,
+    effort: Option<String>,
     status: ExternalAgentStatus,
 }
 
@@ -96,6 +100,8 @@ impl ClaudeCodeSession {
         working_dir: Option<PathBuf>,
         timeout_secs: Option<u64>,
         session_id: Option<String>,
+        model: Option<String>,
+        effort: Option<String>,
     ) -> Self {
         Self {
             binary,
@@ -104,12 +110,26 @@ impl ClaudeCodeSession {
             working_dir,
             timeout: Duration::from_secs(timeout_secs.unwrap_or(300)),
             session_id,
+            model,
+            effort,
             status: ExternalAgentStatus::Idle,
         }
     }
 
     fn args_for_turn(&self) -> Vec<String> {
         let mut args = self.base_args.clone();
+        if let Some(model) = &self.model
+            && !has_model_arg(&args)
+        {
+            args.push("--model".to_string());
+            args.push(model.clone());
+        }
+        if let Some(effort) = &self.effort
+            && !has_effort_arg(&args)
+        {
+            args.push("--effort".to_string());
+            args.push(effort.clone());
+        }
         if let Some(session_id) = &self.session_id
             && !has_resume_arg(&args)
         {
@@ -221,6 +241,15 @@ fn has_resume_arg(args: &[String]) -> bool {
         .any(|arg| matches!(arg.as_str(), "--resume" | "-r" | "--continue" | "-c"))
 }
 
+fn has_model_arg(args: &[String]) -> bool {
+    args.iter()
+        .any(|arg| matches!(arg.as_str(), "--model" | "-m"))
+}
+
+fn has_effort_arg(args: &[String]) -> bool {
+    args.iter().any(|arg| arg == "--effort")
+}
+
 #[cfg(test)]
 mod tests {
     use {
@@ -256,6 +285,8 @@ mod tests {
             None,
             None,
             None,
+            None,
+            None,
         );
         assert!(!session.args_for_turn().iter().any(|arg| arg == "--resume"));
         session.session_id = Some("sid".to_string());
@@ -277,6 +308,8 @@ mod tests {
             None,
             None,
             Some("persisted".to_string()),
+            None,
+            None,
         );
 
         assert_eq!(session.external_session_id(), Some("persisted"));
@@ -314,6 +347,8 @@ printf '%s\n' '{"result":"ok","session_id":"sid-1"}'
             None,
             Some(5),
             None,
+            None,
+            None,
         );
 
         let first = session
@@ -338,4 +373,34 @@ printf '%s\n' '{"result":"ok","session_id":"sid-1"}'
         fs::remove_dir_all(dir)?;
         Ok(())
     }
+
+    #[test]
+    fn adds_model_arg_when_model_is_selected() {
+        let session = ClaudeCodeSession::new(
+            "claude".to_string(),
+            vec![
+                "-p".to_string(),
+                "--output-format".to_string(),
+                "json".to_string(),
+            ],
+            HashMap::new(),
+            None,
+            None,
+            Some("sid".to_string()),
+            Some("opus".to_string()),
+            Some("xhigh".to_string()),
+        );
+
+        assert_eq!(session.args_for_turn(), vec![
+            "-p",
+            "--output-format",
+            "json",
+            "--model",
+            "opus",
+            "--effort",
+            "xhigh",
+            "--resume",
+            "sid"
+        ]);
+    }
 }

crates/external-agents/src/runtimes/codex.rs

@@ -70,6 +70,7 @@ impl ExternalAgentTransport for CodexTransport {
         } else {
             spec.args.clone()
         };
+        let args = args_with_model_and_effort(args, spec.model.as_deref(), spec.effort.as_deref());
         Ok(Box::new(
             CodexAppServerSession::start(
                 binary,
@@ -382,6 +383,75 @@ fn extract_usage(value: &Value) -> Option<crate::types::TokenUsage> {
     })
 }
 
+fn args_with_model_and_effort(
+    mut args: Vec<String>,
+    model: Option<&str>,
+    effort: Option<&str>,
+) -> Vec<String> {
+    let insert_at = args.iter().position(|arg| arg == "app-server").unwrap_or(0);
+    let mut inserts = Vec::new();
+    if let Some(model) = model
+        && !has_model_arg(&args)
+    {
+        inserts.extend(["--model".to_string(), model.to_string()]);
+    }
+    if let Some(effort) = effort
+        && !has_effort_arg(&args)
+    {
+        inserts.extend([
+            "-c".to_string(),
+            format!("model_reasoning_effort=\"{effort}\""),
+        ]);
+    }
+    for (offset, arg) in inserts.into_iter().enumerate() {
+        args.insert(insert_at + offset, arg);
+    }
+    args
+}
+
+fn has_model_arg(args: &[String]) -> bool {
+    let mut iter = args.iter().peekable();
+    while let Some(arg) = iter.next() {
+        if matches!(arg.as_str(), "--model" | "-m") {
+            return true;
+        }
+        if matches!(arg.as_str(), "--config" | "-c")
+            && iter
+                .peek()
+                .is_some_and(|next| next.trim_start().starts_with("model="))
+        {
+            return true;
+        }
+        if arg
+            .strip_prefix("--config=")
+            .is_some_and(|value| value.trim_start().starts_with("model="))
+        {
+            return true;
+        }
+    }
+    false
+}
+
+fn has_effort_arg(args: &[String]) -> bool {
+    let mut iter = args.iter().peekable();
+    while let Some(arg) = iter.next() {
+        if matches!(arg.as_str(), "--config" | "-c")
+            && iter
+                .peek()
+                .is_some_and(|next| next.trim_start().starts_with("model_reasoning_effort="))
+        {
+            return true;
+        }
+        if arg
+            .strip_prefix("--config=")
+            .is_some_and(|value| value.trim_start().starts_with("model_reasoning_effort="))
+        {
+            return true;
+        }
+    }
+    false
+}
+
 fn token_count_field(value: &Value, fields: &[&str]) -> Option<u32> {
     fields.iter().find_map(|field| {
         value
@@ -443,6 +513,44 @@ mod tests {
         assert_eq!(camel.output_tokens, 55);
     }
 
+    #[test]
+    fn inserts_model_and_effort_before_app_server_command() {
+        assert_eq!(
+            args_with_model_and_effort(
+                vec!["app-server".to_string()],
+                Some("gpt-5.5"),
+                Some("xhigh")
+            ),
+            vec![
+                "--model",
+                "gpt-5.5",
+                "-c",
+                "model_reasoning_effort=\"xhigh\"",
+                "app-server"
+            ]
+        );
+        assert_eq!(
+            args_with_model_and_effort(
+                vec![
+                    "--model".to_string(),
+                    "configured".to_string(),
+                    "-c".to_string(),
+                    "model_reasoning_effort=\"high\"".to_string(),
+                    "app-server".to_string()
+                ],
+                Some("ignored"),
+                Some("ignored"),
+            ),
+            vec![
+                "--model",
+                "configured",
+                "-c",
+                "model_reasoning_effort=\"high\"",
+                "app-server"
+            ]
+        );
+    }
+
     #[tokio::test]
     async fn codex_session_reuses_thread_for_multiple_prompts() -> anyhow::Result<()> {
         let unique = SystemTime::now()

crates/external-agents/src/types.rs

@@ -74,6 +74,8 @@ pub struct ExternalAgentSpec {
     pub kind: AgentTransportKind,
     pub session_key: Option<String>,
     pub external_session_id: Option<String>,
+    pub model: Option<String>,
+    pub effort: Option<String>,
     pub binary: Option<String>,
     pub args: Vec<String>,
     pub env: HashMap<String, String>,
@@ -90,6 +92,8 @@ impl ExternalAgentSpec {
             kind,
             session_key: None,
             external_session_id: None,
+            model: None,
+            effort: None,
             binary: None,
             args: Vec::new(),
             env: HashMap::new(),