Add the LithosAI provider

README.md

@@ -118,13 +118,18 @@ See the full history in [CHANGELOG.md](CHANGELOG.md).
 | Raycast | Cookies (Chrome auto or manual) | Monthly AI credits, plan, renewal |
 | Replicate | Cookies / token accounts | Monthly spend, credit balance |
 | Aixy | API Key / token accounts | Applicable budget balances, 7-day key usage |
+| ClawRouter | API Key | Monthly budget, requests, tokens, routed-provider spend |
 | ElevenLabs | API Key | Subscription Credits, Voice Slots |
 | Deepgram | API Key | Project Usage |
 | Groq | API Key | Enterprise Metrics |
 | LLM Proxy | API Key | Quota Stats |
 | llmman | Local daemon / optional API Key | Memory in use, loaded and stored models |
 | DevPass | API Key | Plan credits, Premium weekly, API-key spend |
+| IBM Bob | API Key / token accounts | Monthly Bobcoins, per-team budgets |
 | xKiro | API Key | Daily free tokens |
+| Synthetic | API Key | Five-hour quota, Weekly tokens, Hourly search, Plan |
+| Langdock | Browser cookies / manual Cookie header | Session (5h), Weekly |
+| LithosAI | Browser cookies / manual Cookie header | Prepaid balance, UTC spend today and this month |
 
 </details>
 

apps/desktop-tauri/src-tauri/src/commands/provider_settings.rs

@@ -251,6 +251,8 @@ fn cookie_source_provider(provider_id: &str) -> Option<codexbar::core::ProviderI
         "typesafe" => ProviderId::TypeSafe,
         "hyper" => ProviderId::Hyper,
         "groq" => ProviderId::Groq,
+        "lithosai" => ProviderId::LithosAI,
+        "langdock" => ProviderId::Langdock,
         _ => return None,
     })
 }
@@ -453,6 +455,7 @@ mod tests {
             (ProviderId::Wayfinder, "http://localhost:8787"),
             (ProviderId::Bifrost, "https://bifrost.example.com"),
             (ProviderId::Aixy, "https://aixy.example.com/prefix"),
+            (ProviderId::ClawRouter, "https://router.example.com/v1"),
         ] {
             settings.set_gateway_url(id, url);
             let ctx = super::super::providers::build_fetch_context(
@@ -485,6 +488,7 @@ mod tests {
         assert_eq!(gateway_provider("wayfinder"), Some(ProviderId::Wayfinder));
         assert_eq!(gateway_provider("bifrost"), Some(ProviderId::Bifrost));
         assert_eq!(gateway_provider("aixy"), Some(ProviderId::Aixy));
+        assert_eq!(gateway_provider("clawrouter"), Some(ProviderId::ClawRouter));
         assert_eq!(gateway_provider("codex"), None);
     }
 
@@ -548,6 +552,7 @@ fn gateway_provider(provider_id: &str) -> Option<codexbar::core::ProviderId> {
         "wayfinder" => Some(codexbar::core::ProviderId::Wayfinder),
         "bifrost" => Some(codexbar::core::ProviderId::Bifrost),
         "aixy" => Some(codexbar::core::ProviderId::Aixy),
+        "clawrouter" => Some(codexbar::core::ProviderId::ClawRouter),
         _ => None,
     }
 }
@@ -577,6 +582,10 @@ pub fn set_provider_gateway_url(provider_id: String, gateway_url: String) -> Res
             codexbar::providers::aixy::validate_gateway_url(gateway_url)
                 .map_err(|error| error.to_string())?;
         }
+        codexbar::core::ProviderId::ClawRouter => {
+            codexbar::providers::clawrouter::validate_gateway_url(gateway_url)
+                .map_err(|error| error.to_string())?;
+        }
         _ => unreachable!("gateway_provider only returns gateway providers"),
     }
 
@@ -853,6 +862,20 @@ pub fn cookie_source_options_for(provider_id: &str, lang: Language) -> Vec<Cooki
             cookie_option(lang, "manual", None),
             cookie_option(lang, "off", None),
         ],
+        // Upstream picks one Edge profile instead; Windows uses the shared
+        // cookie-source choices: automatic browser import, a pasted header, or off.
+        "langdock" => vec![
+            cookie_option(lang, "auto", None),
+            cookie_option(lang, "manual", None),
+            cookie_option(lang, "off", None),
+        ],
+        // Upstream's LithosAI cookie source: automatic browser import,
+        // a pasted header, or off.
+        "lithosai" => vec![
+            cookie_option(lang, "auto", None),
+            cookie_option(lang, "manual", None),
+            cookie_option(lang, "off", None),
+        ],
         _ => Vec::new(),
     }
 }

apps/desktop-tauri/src-tauri/src/commands/session_cookie_scope_tests.rs

@@ -160,3 +160,85 @@ fn groq_exposes_a_cookie_source_picker_defaulting_to_auto() {
         .collect();
     assert_eq!(values, vec!["auto", "manual", "off"]);
 }
+
+/// Langdock is web-only: the picker chooses the session, a stored header
+/// always wins, an empty manual source fails closed without reading a browser,
+/// and off reaches the provider as Cli (its "cookies are disabled" error).
+#[test]
+fn langdock_exposes_a_cookie_source_picker_and_routes_each_choice() {
+    let settings = Settings::default();
+    assert_eq!(
+        super::provider_cookie_source_lookup(&settings, "langdock").as_deref(),
+        Some("auto")
+    );
+    let values: Vec<_> = super::cookie_source_options_for("langdock", Language::English)
+        .into_iter()
+        .map(|option| option.value)
+        .collect();
+    assert_eq!(values, vec!["auto", "manual", "off"]);
+
+    let cookie = "auth_token=fixture";
+    for source in ["auto", "manual"] {
+        let ctx = session_context(ProviderId::Langdock, Some(source), "auto", Some(cookie));
+        assert!(
+            matches!(ctx.source_mode, SourceMode::Auto | SourceMode::Web),
+            "{source}"
+        );
+        assert_eq!(
+            ctx.manual_cookie_header.as_deref(),
+            Some(cookie),
+            "{source}"
+        );
+        assert!(!ctx.manual_cookie_missing, "{source}");
+    }
+
+    let ctx = session_context(ProviderId::Langdock, Some("manual"), "auto", None);
+    assert_eq!(ctx.source_mode, SourceMode::Web);
+    assert!(ctx.manual_cookie_header.is_none());
+    assert!(ctx.manual_cookie_missing);
+
+    let ctx = session_context(ProviderId::Langdock, Some("off"), "auto", Some(cookie));
+    assert_eq!(ctx.source_mode, SourceMode::Cli);
+    assert!(ctx.manual_cookie_header.is_none());
+}
+
+/// LithosAI is web-only: the picker chooses the session, a stored header
+/// always wins, an empty manual source fails closed without reading a browser,
+/// and off reaches the provider as Cli (its "cookies are disabled" error).
+#[test]
+fn lithosai_exposes_a_cookie_source_picker_and_routes_each_choice() {
+    let settings = Settings::default();
+    assert_eq!(
+        super::provider_cookie_source_lookup(&settings, "lithosai").as_deref(),
+        Some("auto")
+    );
+    let values: Vec<_> = super::cookie_source_options_for("lithosai", Language::English)
+        .into_iter()
+        .map(|option| option.value)
+        .collect();
+    assert_eq!(values, vec!["auto", "manual", "off"]);
+
+    let cookie = "__Host-console_session=fixture; __Host-console_csrf=fixture";
+    for source in ["auto", "manual"] {
+        let ctx = session_context(ProviderId::LithosAI, Some(source), "auto", Some(cookie));
+        assert!(
+            matches!(ctx.source_mode, SourceMode::Auto | SourceMode::Web),
+            "{source}"
+        );
+        assert_eq!(
+            ctx.manual_cookie_header.as_deref(),
+            Some(cookie),
+            "{source}"
+        );
+        assert!(!ctx.manual_cookie_missing, "{source}");
+    }
+
+    let ctx = session_context(ProviderId::LithosAI, Some("manual"), "auto", None);
+    assert_eq!(ctx.source_mode, SourceMode::Web);
+    assert!(ctx.manual_cookie_header.is_none());
+    assert!(ctx.manual_cookie_missing);
+
+    let ctx = session_context(ProviderId::LithosAI, Some("off"), "auto", Some(cookie));
+    assert_eq!(ctx.source_mode, SourceMode::Cli);
+    assert!(ctx.manual_cookie_header.is_none());
+}