Port Venice web subscription credits

apps/desktop-tauri/src/surfaces/settings/providers/sections/UsageSourceSection.test.tsx

@@ -27,6 +27,11 @@ describe("usage source policy", () => {
       "auto",
       "cli",
     ]);
+    expect(usageSourcePolicy("venice")?.options.map((option) => option.value)).toEqual([
+      "auto",
+      "oauth",
+      "web",
+    ]);
     expect(usageSourcePolicy("antigravity")?.options[0].description).toContain(
       "skips agy reports without account identity",
     );

apps/desktop-tauri/src/surfaces/settings/providers/sections/usageSourcePolicy.ts

@@ -46,6 +46,25 @@ const POLICIES: Readonly<Record<string, UsageSourcePolicy>> = {
       { value: "oauth", label: "Muse Code login", description: "Uses the local Muse Code device-code login only." },
     ],
   },
+  venice: {
+    options: [
+      {
+        value: "auto",
+        label: "Auto",
+        description: "Uses the Venice API key or token account; browser sessions are used only when Web is selected.",
+      },
+      {
+        value: "oauth",
+        label: "API",
+        description: "Uses the Venice API key or token account only.",
+      },
+      {
+        value: "web",
+        label: "Browser session",
+        description: "Reads Venice subscription credits from the selected browser session or manual cookie header.",
+      },
+    ],
+  },
 };
 
 export function usageSourcePolicy(providerId: string): UsageSourcePolicy | null {

rust/src/cli/serve/tests.rs

@@ -474,24 +474,38 @@ async fn over_cap_connection_closes_immediately_without_response() {
     );
 
     // Ending the tricklers releases their permits via EOF; a normal client
-    // must then be served (strict outer timeout).
+    // must then be served (strict outer timeout). Permit release races the
+    // server's graceful close-drain window, so a single fixed wait can see a
+    // connection reset; retry within a bounded budget instead.
     for task in &tricklers {
         task.abort();
     }
-    tokio::time::sleep(Duration::from_millis(400)).await;
-    let mut good = TcpStream::connect(addr).await.unwrap();
-    good.write_all(b"GET /health HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n")
-        .await
-        .unwrap();
-    let mut response = Vec::new();
-    tokio::time::timeout(Duration::from_secs(5), good.read_to_end(&mut response))
-        .await
-        .expect("no connection slot freed after trickling clients ended")
-        .unwrap();
+    let request = b"GET /health HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n";
+    let mut served: Option<String> = None;
+    let retry = tokio::time::Instant::now();
+    while retry.elapsed() < Duration::from_secs(2) {
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        let Ok(mut good) = TcpStream::connect(addr).await else {
+            continue;
+        };
+        if good.write_all(request).await.is_err() {
+            continue;
+        }
+        let mut response = Vec::new();
+        match tokio::time::timeout(Duration::from_secs(5), good.read_to_end(&mut response)).await {
+            // A reset mid-handshake is the drain race; retry.
+            Ok(Err(_)) | Err(_) => continue,
+            Ok(Ok(_)) => {}
+        }
+        if String::from_utf8_lossy(&response).starts_with("HTTP/1.1 200") {
+            served = Some(String::from_utf8_lossy(&response).into_owned());
+            break;
+        }
+    }
+    let served = served.expect("no freed slot served a normal request within retry budget");
     assert!(
-        String::from_utf8_lossy(&response).starts_with("HTTP/1.1 200"),
-        "freed slot must serve a normal request, got: {}",
-        String::from_utf8_lossy(&response)
+        served.starts_with("HTTP/1.1 200"),
+        "freed slot must serve a normal request, got: {served}"
     );
     server_task.abort();
 }

rust/src/core/provider.rs

@@ -364,6 +364,7 @@ impl ProviderId {
             ProviderId::MiMo => Some("platform.xiaomimimo.com"),
             ProviderId::CommandCode => Some("commandcode.ai"),
             ProviderId::Grok => Some("grok.com"),
+            ProviderId::Venice => Some("venice.ai"),
             ProviderId::Qoder => Some("qoder.com"),
             ProviderId::CodeBuddy => Some("codebuddy.cn"),
             ProviderId::Sakana => Some("console.sakana.ai"),
@@ -392,7 +393,6 @@ impl ProviderId {
             ProviderId::Doubao => None,
             ProviderId::Crof => None,
             ProviderId::StepFun => None,
-            ProviderId::Venice => None,
             ProviderId::OpenAIApi => None,
             ProviderId::ElevenLabs => None,
             ProviderId::Deepgram => None,
@@ -1248,6 +1248,7 @@ mod tests {
         assert_eq!(ProviderId::Kiro.cookie_domain(), Some("kiro.dev"));
         assert_eq!(ProviderId::Kimi.cookie_domain(), Some("kimi.moonshot.cn"));
         assert_eq!(ProviderId::OpenCode.cookie_domain(), Some("opencode.ai"));
+        assert_eq!(ProviderId::Venice.cookie_domain(), Some("venice.ai"));
 
         // Token-based providers (no cookies)
         assert_eq!(ProviderId::Copilot.cookie_domain(), None);