Add Azure FW Kimi K3 support

gateway.yaml

@@ -80,6 +80,10 @@ models:
   sol:
     model: [azure/gpt-5.6-sol, openrouter/moonshotai/kimi-k2.7-code]
     display_name: "Azure GPT-5.6 Sol (fallback to OpenRouter Kimi K2.7 Code)"
+  fw-kimi-k3:
+    model: azure/FW-Kimi-K3
+    display_name: "Azure FW Kimi K3"
+    drop_message_params: [reasoning] # Azure accepts reasoning_content only
   kimi-k3:
     model: [openrouter/moonshotai/kimi-k3, openrouter/moonshotai/kimi-k2.7-code]
     display_name: "OpenRouter Kimi K3 Code"
@@ -101,6 +105,7 @@ models:
     # thinking: none                  # native | none (reasoning round-trip)
     # cache_control: none             # native | none
     # drop_params: [temperature]      # strip params the API rejects
+    # drop_message_params: [reasoning] # strip fields from chat messages
     # timeout_ms: 120000
     # expose: [claude_code, codex]    # which clients may select it (default: all)
 

src/config.rs

@@ -216,6 +216,10 @@ pub struct RouteConfig {
     /// that reject params they don't control, e.g. Kimi K2.7 fixes temperature).
     #[serde(default)]
     pub drop_params: Vec<String>,
+    /// Fields to strip from each Chat Completions message for strict providers
+    /// that accept only a subset of reasoning-history aliases.
+    #[serde(default)]
+    pub drop_message_params: Vec<String>,
     #[serde(default)]
     pub capabilities: RouteCapabilities,
 }

src/http.rs

@@ -213,6 +213,15 @@ fn build_upstream_body(client: ClientProtocol, route: &RouteConfig, body: &Value
         for p in &route.drop_params {
             map.remove(p);
         }
+        if let Some(messages) = map.get_mut("messages").and_then(Value::as_array_mut) {
+            for message in messages {
+                if let Some(message) = message.as_object_mut() {
+                    for p in &route.drop_message_params {
+                        message.remove(p);
+                    }
+                }
+            }
+        }
     }
     out
 }
@@ -687,3 +696,52 @@ async fn count_tokens(
     .await;
     result.unwrap_or_else(|e| e.into_response_for(client))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn drops_configured_chat_message_params() {
+        let mut route = crate::schema::load(
+            r#"
+providers:
+  strict:
+    base_url: https://strict.example/v1
+    api_key: test
+models:
+  kimi:
+    model: strict/kimi
+    drop_message_params: [reasoning]
+clients:
+  claude_code: { main: kimi }
+"#,
+        )
+        .unwrap()
+        .models["kimi"]
+            .routes[0]
+            .clone();
+        route.drop_params.push("temperature".into());
+
+        let body = json!({
+            "temperature": 0.5,
+            "messages": [{
+                "role": "assistant",
+                "content": [
+                    {"type": "thinking", "thinking": "keep me", "signature": ""},
+                    {
+                        "type": "tool_use",
+                        "id": "echo_0",
+                        "name": "echo",
+                        "input": {"text": "hello"}
+                    }
+                ]
+            }]
+        });
+        let out = build_upstream_body(ClientProtocol::AnthropicMessages, &route, &body);
+
+        assert!(out.get("temperature").is_none());
+        assert!(out["messages"][0].get("reasoning").is_none());
+        assert_eq!(out["messages"][0]["reasoning_content"], "keep me");
+    }
+}

src/schema.rs

@@ -108,6 +108,8 @@ pub struct ModelLong {
     #[serde(default)]
     pub drop_params: Option<Vec<String>>,
     #[serde(default)]
+    pub drop_message_params: Option<Vec<String>>,
+    #[serde(default)]
     pub timeout_ms: Option<u64>,
     /// Which clients may select this model directly (default: all configured).
     #[serde(default)]
@@ -399,6 +401,9 @@ impl FileConfig {
                 drop_params: long
                     .and_then(|l| l.drop_params.clone())
                     .unwrap_or(q.drop_params),
+                drop_message_params: long
+                    .and_then(|l| l.drop_message_params.clone())
+                    .unwrap_or_default(),
                 capabilities: RouteCapabilities {
                     text: true,
                     tools: long.and_then(|l| l.tools).unwrap_or(q.tools),