fix(deepseek): use provider-native transport (#198)

Author: EricSanchezok

.repo-seed/manifest.json

@@ -77,7 +77,7 @@
     },
     {
       "path": "docs/architecture.md",
-      "sha256": "135e9e3812edafbc1af5c849660ea1416aab0bbb51aeedd1cebea72d0d6aca19",
+      "sha256": "8aff1a006b838161fb55274c8f192719f37a93fd04c2752b68a4cc26ec123c9d",
       "category": "docs",
       "capability": "baseline"
     },
@@ -258,7 +258,7 @@
     },
     {
       "path": "docs/postmortems/README.md",
-      "sha256": "d5ddcfd1ad66efd11f1d4ad4d183c2d6c72100b48ed83a982d2addda2d391de9",
+      "sha256": "f6b4879a58d15e90f9c899073554673d616be160795cfa2004c0c2145e859a87",
       "category": "docs",
       "capability": "postmortems"
     },

Cargo.lock

@@ -42,7 +42,7 @@ pub const PROVIDERS: &[Provider] = &[
     },
     Provider {
         key: "deepseek",
-        protocol: Protocol::OpenAI,
+        protocol: Protocol::DeepSeek,
         endpoint: "https://api.deepseek.com",
         env_var: "DEEPSEEK_API_KEY",
         default_model: "deepseek-v4-flash",

crates/accelerator/src/provider.rs

@@ -1,6 +1,7 @@
 //! Tests for the provider table and `resolve_model`.
 
 use accelerator::provider::{self, ResolveError};
+use machine::Protocol;
 use std::sync::Mutex;
 
 /// Tests in this file all mutate process-wide environment variables. Cargo
@@ -87,6 +88,7 @@ fn resolves_provider_only_to_default_model() {
     let model = provider::resolve_model(Some("deepseek")).expect("resolve");
     assert_eq!(model.name, "deepseek/deepseek-v4-flash");
     assert_eq!(model.endpoint.as_deref(), Some("https://api.deepseek.com"));
+    assert_eq!(model.protocol, Protocol::DeepSeek);
 }
 
 #[test]

crates/accelerator/tests/provider.rs

@@ -1,6 +1,6 @@
 [package]
 name = "cli"
-version = "0.2.23"
+version = "0.2.24"
 edition = "2024"
 publish = false
 

crates/cli/Cargo.toml

@@ -356,8 +356,8 @@ fn build_models(defs: &[ast::ModelDef]) -> Result<Vec<Model>, String> {
             thinking: def.thinking,
             ..Default::default()
         };
-        if def.thinking_configured && protocol == Protocol::OpenAI {
-            model.set_openai_thinking_mode(def.thinking);
+        if def.thinking_configured && matches!(protocol, Protocol::OpenAI | Protocol::DeepSeek) {
+            model.set_thinking_mode(def.thinking);
         }
         if let Some(timeout) = def.timeout {
             model.timeout = timeout;
@@ -373,6 +373,7 @@ fn build_models(defs: &[ast::ModelDef]) -> Result<Vec<Model>, String> {
 fn parse_protocol(name: &str) -> Result<Protocol, String> {
     match name {
         "openai" => Ok(Protocol::OpenAI),
+        "deepseek" => Ok(Protocol::DeepSeek),
         "anthropic" => Ok(Protocol::Anthropic),
         "gemini" => Ok(Protocol::Gemini),
         _ => Err(format!("unknown protocol: {}", name)),

crates/cli/src/rcm/compile.rs

@@ -149,7 +149,7 @@ fn compile_selects_resource_pools_without_initial_activation() {
 }
 
 #[test]
-fn compile_preserves_explicit_openai_thinking_modes() {
+fn compile_preserves_explicit_thinking_modes_for_supported_protocols() {
     let source = r#"
         name = "thinking modes"
         model enabled {
@@ -172,8 +172,15 @@ fn compile_preserves_explicit_openai_thinking_modes() {
             limit = { context = "1000", output = "100" }
             modalities = { input = ["text"], output = ["text"] }
         }
+        model deepseek {
+            protocol = "deepseek"
+            credentials = { key = "REDACTED" }
+            limit = { context = "1000", output = "100" }
+            modalities = { input = ["text"], output = ["text"] }
+            thinking = "true"
+        }
         accelerator {
-            models = ["enabled", "disabled", "implicit"]
+            models = ["enabled", "disabled", "implicit", "deepseek"]
         }
     "#;
 
@@ -183,6 +190,8 @@ fn compile_preserves_explicit_openai_thinking_modes() {
     assert_eq!(models["enabled"].openai_thinking_mode(), Some(true));
     assert_eq!(models["disabled"].openai_thinking_mode(), Some(false));
     assert_eq!(models["implicit"].openai_thinking_mode(), None);
+    assert_eq!(models["deepseek"].protocol, machine::Protocol::DeepSeek);
+    assert_eq!(models["deepseek"].thinking_mode(), Some(true));
 }
 
 #[test]

crates/cli/tests/compile.rs

@@ -172,6 +172,26 @@ pub async fn complete_with_diagnostics(
                 .completion_model(wire_name);
             send(&endpoint, model, request).await
         }
+        Protocol::DeepSeek => {
+            // DeepSeek documents assistant `content` as string-or-null and
+            // requires the complete prior reasoning/tool-call response to be
+            // replayed. Its native Rig adapter owns that exact conversion.
+            // Sources:
+            // https://api-docs.deepseek.com/api/create-chat-completion/
+            // https://api-docs.deepseek.com/guides/thinking_mode/
+            let mut builder = rig::providers::deepseek::Client::builder()
+                .api_key(api_key)
+                .http_client(openai_http_client());
+            if let Some(endpoint) = endpoint_url {
+                builder = builder.base_url(endpoint);
+            }
+            builder = apply_headers(builder, &model.headers);
+            let endpoint = builder
+                .build()
+                .expect("failed to build deepseek client")
+                .completion_model(wire_name);
+            send(&endpoint, model, request).await
+        }
         Protocol::Anthropic => {
             let mut builder = rig::providers::anthropic::Client::builder().api_key(api_key);
             if let Some(endpoint) = endpoint_url {
@@ -684,16 +704,33 @@ pub fn build_request(
         )
     })?;
 
-    let additional_params = if model.protocol == Protocol::OpenAI {
-        model.openai_thinking_mode().map(|enabled| {
+    let additional_params = match model.protocol {
+        Protocol::OpenAI => model.thinking_mode().map(|enabled| {
             serde_json::json!({
                 "thinking": {
                     "type": if enabled { "enabled" } else { "disabled" },
                 }
             })
-        })
-    } else {
-        None
+        }),
+        Protocol::DeepSeek => {
+            let mut params = serde_json::Map::new();
+            if let Some(enabled) = model.thinking_mode() {
+                params.insert(
+                    "thinking".into(),
+                    serde_json::json!({
+                        "type": if enabled { "enabled" } else { "disabled" },
+                    }),
+                );
+            }
+            // Rig 0.36's native DeepSeek adapter does not project the generic
+            // CompletionRequest max_tokens field, so preserve the declared
+            // model limit through its flattened provider parameters.
+            if let Some(limit) = &model.limit {
+                params.insert("max_tokens".into(), limit.output.into());
+            }
+            (!params.is_empty()).then_some(serde_json::Value::Object(params))
+        }
+        Protocol::Anthropic | Protocol::Gemini => None,
     };
 
     Ok(CompletionRequest {

crates/machine/src/completion.rs

@@ -3,7 +3,7 @@ use serde_json::Value;
 use std::collections::HashMap;
 
 pub const DEFAULT_MODEL_TIMEOUT_SECS: u64 = 1_800;
-const OPENAI_THINKING_MODE_EXTRA: &str = "openai_thinking_mode";
+const THINKING_MODE_EXTRA: &str = "openai_thinking_mode";
 
 /// LLM configuration.
 ///
@@ -62,41 +62,66 @@ impl Default for Model {
 }
 
 impl Model {
+    /// Configure an explicit provider thinking mode.
+    ///
+    /// The stored key retains its historical spelling for serialized-model
+    /// compatibility. Request construction applies it only to protocols that
+    /// support the `thinking.type` extension.
+    pub fn set_thinking_mode(&mut self, enabled: bool) {
+        self.extra
+            .insert(THINKING_MODE_EXTRA.to_string(), Value::Bool(enabled));
+    }
+
+    /// Return an explicitly configured provider thinking mode.
+    pub fn thinking_mode(&self) -> Option<bool> {
+        self.extra.get(THINKING_MODE_EXTRA).and_then(Value::as_bool)
+    }
+
     /// Configure the OpenAI-compatible `thinking.type` request parameter.
     ///
     /// This is opt-in so generic OpenAI-compatible providers that do not
     /// recognize the extension keep receiving the historical request shape.
     pub fn set_openai_thinking_mode(&mut self, enabled: bool) {
-        self.extra
-            .insert(OPENAI_THINKING_MODE_EXTRA.to_string(), Value::Bool(enabled));
+        self.set_thinking_mode(enabled);
     }
 
     /// Return an explicitly configured OpenAI-compatible thinking mode.
     pub fn openai_thinking_mode(&self) -> Option<bool> {
-        self.extra
-            .get(OPENAI_THINKING_MODE_EXTRA)
-            .and_then(Value::as_bool)
+        self.thinking_mode()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::Model;
+    use super::{Model, Protocol};
 
     #[test]
     fn model_default_timeout_allows_thirty_minute_requests() {
         assert_eq!(Model::default().timeout, 1_800);
     }
+
+    #[test]
+    fn deepseek_protocol_round_trips_through_serde() {
+        let serialized = serde_json::to_string(&Protocol::DeepSeek).expect("serializes");
+        assert_eq!(serialized, "\"deepseek\"");
+        assert_eq!(
+            serde_json::from_str::<Protocol>(&serialized).expect("deserializes"),
+            Protocol::DeepSeek
+        );
+    }
 }
 
 /// Wire protocol.
 ///
-/// Three protocols are supported. Most providers are OpenAI-compatible;
-/// use the `OpenAI` variant with a custom `endpoint`.
+/// Four protocols are supported. Most providers are OpenAI-compatible;
+/// use the `OpenAI` variant with a custom `endpoint`. DeepSeek has an
+/// explicit variant because its assistant-message schema differs at the
+/// thinking/tool-history boundary.
 ///
 /// | Protocol | Examples |
 /// |----------|---------|
-/// | `OpenAI` | OpenAI, DeepSeek, Groq, Mistral, xAI, Ollama, OpenRouter ... |
+/// | `OpenAI` | OpenAI, Groq, Mistral, xAI, Ollama, OpenRouter ... |
+/// | `DeepSeek` | DeepSeek Chat Completions API |
 /// | `Anthropic` | Anthropic Claude |
 /// | `Gemini` | Google Gemini |
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -105,6 +130,8 @@ pub enum Protocol {
     /// OpenAI Chat Completions API.
     #[default]
     OpenAI,
+    /// DeepSeek Chat Completions API.
+    DeepSeek,
     /// Anthropic Messages API.
     Anthropic,
     /// Google Gemini API.