fix(codex): adjustable reasoning levels (low/medium/high/xhigh) in picker --patch

The model picker only showed the ←/→ effort selector for Claude models, so
Codex/GPT-5 users had no way to pick a thinking level. Enable it for the GPT-5
reasoning family (gpt-5.5/5.4/5.4-mini/codex), excluding the non-reasoning
-chat/-pro snapshots.

The four tiers map to OpenAI reasoning_effort low/medium/high, and on Codex the
top "Max" tier becomes xhigh ("extra high") to match opencode's gpt-5 ladder —
scoped to Codex so other OpenAI-compatible providers (which may reject xhigh)
keep "high". Also set reasoningSummary=auto + reasoning.encrypted_content
include for Codex, matching opencode's gpt-5 defaults.

Ships as a patch to v0.1.6.

Author: Kuberwastaken

src-rust/crates/query/src/lib.rs

@@ -363,11 +363,34 @@ fn build_provider_options(
         let reasoning_effort = effort_level
             .map(reasoning_effort_for_level)
             .unwrap_or("medium");
+        // Codex (ChatGPT) accepts the full gpt-5 effort ladder including
+        // `xhigh`, so surface the top "Max" tier as "extra high" there —
+        // matching opencode — without changing the value sent to other
+        // OpenAI-compatible providers that may not accept it.
+        let reasoning_effort = if matches!(provider_id, "codex" | "openai-codex")
+            && effort_level == Some(claurst_core::effort::EffortLevel::Max)
+        {
+            "xhigh"
+        } else {
+            reasoning_effort
+        };
         options.insert(
             "reasoningEffort".to_string(),
             serde_json::json!(reasoning_effort),
         );
 
+        // Match opencode's gpt-5 defaults for the Codex (ChatGPT) endpoint:
+        // request an auto reasoning summary and carry encrypted reasoning state
+        // across stateless turns. Scoped to Codex so other OpenAI-compatible
+        // providers that ignore these fields are unaffected.
+        if matches!(provider_id, "codex" | "openai-codex") {
+            options.insert("reasoningSummary".to_string(), serde_json::json!("auto"));
+            options.insert(
+                "include".to_string(),
+                serde_json::json!(["reasoning.encrypted_content"]),
+            );
+        }
+
         if model_id.starts_with("gpt-5")
             && model_id.contains("gpt-5.")
             && !model_id.contains("codex")
@@ -2446,6 +2469,37 @@ mod tests {
         assert_eq!(options["usage"]["include"], serde_json::json!(true));
     }
 
+    #[test]
+    fn test_build_provider_options_codex_effort_ladder() {
+        // Codex maps the lower tiers like any OpenAI reasoning model...
+        for (level, expected) in [
+            (claurst_core::effort::EffortLevel::Low, "low"),
+            (claurst_core::effort::EffortLevel::Medium, "medium"),
+            (claurst_core::effort::EffortLevel::High, "high"),
+        ] {
+            let options = build_provider_options("openai-codex", "gpt-5.5", Some(level), None);
+            assert_eq!(options["reasoningEffort"], serde_json::json!(expected));
+        }
+        // ...but the top "Max" tier becomes "xhigh" (extra high) on Codex.
+        let options = build_provider_options(
+            "openai-codex",
+            "gpt-5.5",
+            Some(claurst_core::effort::EffortLevel::Max),
+            None,
+        );
+        assert_eq!(options["reasoningEffort"], serde_json::json!("xhigh"));
+        assert_eq!(options["reasoningSummary"], serde_json::json!("auto"));
+
+        // Other OpenAI-compatible providers keep "high" for Max (no xhigh).
+        let other = build_provider_options(
+            "openrouter",
+            "gpt-5.4",
+            Some(claurst_core::effort::EffortLevel::Max),
+            None,
+        );
+        assert_eq!(other["reasoningEffort"], serde_json::json!("high"));
+    }
+
     #[test]
     fn test_build_provider_options_for_bedrock_anthropic() {
         let options = build_provider_options(

src-rust/crates/tui/src/model_picker.rs

@@ -90,15 +90,31 @@ impl Default for EffortLevel {
 // ---------------------------------------------------------------------------
 
 /// Returns `true` for models that support extended thinking / effort levels.
+///
+/// Covers Claude's extended-thinking models and the GPT-5 reasoning family
+/// (incl. Codex / ChatGPT models like `gpt-5.5`, `gpt-5.4`, `gpt-5.4-mini`),
+/// which honour OpenAI's `reasoning_effort` ladder. Lets the picker surface the
+/// ←/→ thinking-level selector for Codex the way opencode does.
 pub fn model_supports_effort(id: &str) -> bool {
     id.starts_with("claude-3-7")
         || id.starts_with("claude-opus-4")
         || id.starts_with("claude-sonnet-4")
+        || is_gpt5_reasoning_model(id)
 }
 
 /// Returns `true` for models that support the maximum effort tier.
+///
+/// For Claude this is Opus-only; for the GPT-5 family the top tier maps to
+/// OpenAI's `xhigh` ("extra high") reasoning effort on the Codex endpoint.
 pub fn model_supports_max_effort(id: &str) -> bool {
-    id.starts_with("claude-opus-4")
+    id.starts_with("claude-opus-4") || is_gpt5_reasoning_model(id)
+}
+
+/// Whether `id` is a GPT-5 reasoning model (`gpt-5*`), excluding the
+/// non-reasoning chat / pro snapshots that ignore `reasoning_effort`.
+fn is_gpt5_reasoning_model(id: &str) -> bool {
+    let id = id.to_ascii_lowercase();
+    id.starts_with("gpt-5") && !id.contains("-chat") && !id.contains("-pro")
 }
 
 /// Returns a short description string based on the model family inferred from
@@ -1162,6 +1178,20 @@ mod tests {
         assert!(!model_supports_max_effort("claude-haiku-4-5"));
     }
 
+    // 12b. GPT-5 codex/reasoning models expose the effort selector (incl. max).
+    #[test]
+    fn gpt5_codex_models_support_effort() {
+        for id in ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"] {
+            assert!(model_supports_effort(id), "{id} should support effort");
+            assert!(model_supports_max_effort(id), "{id} should support max/xhigh");
+        }
+        // Non-reasoning chat / pro snapshots are excluded.
+        assert!(!model_supports_effort("gpt-5-chat-latest"));
+        assert!(!model_supports_effort("gpt-5.5-pro"));
+        // Non-gpt5 stays unaffected.
+        assert!(!model_supports_effort("gpt-4o"));
+    }
+
     // 13. Non-effort models return None from effective_effort.
     #[test]
     fn haiku_has_no_effort() {