fix(client): prevent duplicate authentication headers

Signed-off-by: Elyas Mehtabuddin <emehtabuddin@nvidia.com>

Author: elyasmnvidian

crates/libsy-llm-client/README.md

@@ -212,7 +212,11 @@ fn build_multi_format_client(
   `host`, `content-length`, `connection`, and the backend-owned
   `authorization` / `x-api-key` / `anthropic-version` / `content-type`. So a
   caller's placeholder credential never overrides the backend's real key.
-- Per-backend static headers go in `HttpBackendConfig::extra_headers`.
+- Per-backend custom headers go in `HttpBackendConfig::extra_headers`. Set credentials with
+  `api_key`. For OpenAI requests, the client ignores `Authorization` in `extra_headers`
+  and sends the key from `api_key` once. For Anthropic requests, it ignores `x-api-key`
+  and `anthropic-version` in `extra_headers`, then sends the key from `api_key` and the
+  required Anthropic version. Header names are matched without regard to letter case.
 - Per-target top-level request defaults go in `HttpBackendConfig::extra_body`.
   The merge is shallow and fields already present in the request take precedence.
 - `HttpBackendConfig::max_retries` controls additional attempts after retryable

crates/libsy-llm-client/src/backend.rs

@@ -42,7 +42,11 @@ pub struct HttpBackendConfig {
     pub base_url: String,
     /// API key for the provider, loaded by the caller. `None` sends no auth.
     pub api_key: Option<String>,
-    /// Static headers added to every outbound call to this backend.
+    /// Custom headers added to every outbound call to this backend.
+    ///
+    /// OpenAI requests ignore `Authorization` here. Anthropic requests ignore
+    /// `x-api-key` and `anthropic-version` here. Use `api_key` for credentials;
+    /// the client sets Anthropic's required version itself.
     pub extra_headers: BTreeMap<String, String>,
     /// Default top-level request fields, applied only when the request omits the key.
     pub extra_body: BTreeMap<String, Value>,
@@ -130,7 +134,20 @@ impl Backend {
         builder
     }
 
-    /// Static per-backend headers to forward on every call.
+    /// Whether this backend ignores `name` when reading `extra_headers`.
+    pub(crate) fn ignores_extra_header(&self, name: &str) -> bool {
+        match self {
+            Backend::OpenAiChat(_) | Backend::OpenAiResponses(_) => {
+                name.eq_ignore_ascii_case("authorization")
+            }
+            Backend::Anthropic(_) => {
+                name.eq_ignore_ascii_case("x-api-key")
+                    || name.eq_ignore_ascii_case("anthropic-version")
+            }
+        }
+    }
+
+    /// Custom per-backend headers to forward on every call.
     pub fn extra_headers(&self) -> &BTreeMap<String, String> {
         &self.config().extra_headers
     }

crates/libsy-llm-client/src/client.rs

@@ -281,8 +281,7 @@ impl TranslatingLlmClient {
     ) -> std::result::Result<EncodedResponse, AttemptFailure> {
         let builder = self.client.post(url).json(body);
         let builder = forward_metadata_headers(builder, metadata);
-        let builder = apply_extra_headers(builder, backend);
-        let builder = backend.apply_auth(builder);
+        let builder = apply_backend_headers(builder, backend);
 
         let response = match builder.send().await {
             Ok(response) => response,
@@ -643,14 +642,22 @@ fn forward_metadata_headers(
     builder
 }
 
-// Adds the backend's static per-call headers.
+// Adds custom headers but skips OpenAI auth and Anthropic auth/version headers.
 fn apply_extra_headers(mut builder: RequestBuilder, backend: &Backend) -> RequestBuilder {
     for (name, value) in backend.extra_headers() {
+        if backend.ignores_extra_header(name) {
+            continue;
+        }
         builder = builder.header(name, value);
     }
     builder
 }
 
+// Builds one header set without duplicating OpenAI or Anthropic authentication headers.
+fn apply_backend_headers(builder: RequestBuilder, backend: &Backend) -> RequestBuilder {
+    backend.apply_auth(apply_extra_headers(builder, backend))
+}
+
 // Overwrites the outbound body's `model` field with the resolved model id.
 fn set_json_model(body: &mut Value, model: &str) {
     if let Value::Object(object) = body {
@@ -819,6 +826,14 @@ mod tests {
         }
     }
 
+    fn header_values<'a>(headers: &'a HeaderMap, name: &str) -> Vec<&'a str> {
+        headers
+            .get_all(name)
+            .iter()
+            .map(|value| value.to_str().expect("header value should be text"))
+            .collect()
+    }
+
     fn config_with_retries(base_url: &str, max_retries: u32) -> HttpBackendConfig {
         HttpBackendConfig {
             max_retries,
@@ -1724,6 +1739,56 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn extra_headers_do_not_duplicate_auth_headers()
+    -> std::result::Result<(), Box<dyn Error + Sync + Send + 'static>> {
+        let extra_headers = BTreeMap::from([
+            ("AUTHORIZATION".to_string(), "Bearer injected".to_string()),
+            ("X-Api-Key".to_string(), "injected".to_string()),
+            ("ANTHROPIC-VERSION".to_string(), "injected".to_string()),
+            ("X-Inference-Priority".to_string(), "batch".to_string()),
+        ]);
+        let mut openai_config = config("https://example.test/v1");
+        openai_config.extra_headers = extra_headers.clone();
+        let openai = Backend::OpenAiChat(openai_config);
+        let request =
+            apply_backend_headers(reqwest::Client::new().post(openai.url()), &openai).build()?;
+        assert_eq!(
+            header_values(request.headers(), "authorization"),
+            ["Bearer secret"]
+        );
+        assert_eq!(header_values(request.headers(), "x-api-key"), ["injected"]);
+        assert_eq!(
+            header_values(request.headers(), "anthropic-version"),
+            ["injected"]
+        );
+        assert_eq!(
+            header_values(request.headers(), "x-inference-priority"),
+            ["batch"]
+        );
+
+        let mut anthropic_config = config("https://example.test");
+        anthropic_config.extra_headers = extra_headers;
+        let anthropic = Backend::Anthropic(anthropic_config);
+        let request =
+            apply_backend_headers(reqwest::Client::new().post(anthropic.url()), &anthropic)
+                .build()?;
+        assert_eq!(
+            header_values(request.headers(), "authorization"),
+            ["Bearer injected"]
+        );
+        assert_eq!(header_values(request.headers(), "x-api-key"), ["secret"]);
+        assert_eq!(
+            header_values(request.headers(), "anthropic-version"),
+            ["2023-06-01"]
+        );
+        assert_eq!(
+            header_values(request.headers(), "x-inference-priority"),
+            ["batch"]
+        );
+        Ok(())
+    }
+
     #[tokio::test]
     async fn forwards_metadata_headers_except_reserved()
     -> std::result::Result<(), Box<dyn Error + Sync + Send + 'static>> {

crates/switchyard-server/src/config.rs

@@ -1459,6 +1459,19 @@ target = "azure"
         Ok(())
     }
 
+    #[test]
+    fn auth_extra_headers_do_not_block_config_loading() -> ServerResult<()> {
+        let configured = VALID_CONFIG.replacen(
+            "base_url = \"https://example.test/v1\"",
+            "base_url = \"https://example.test/v1\"\n\
+             extra_headers = { Authorization = \"injected\", X-Inference-Priority = \"batch\" }",
+            1,
+        );
+
+        server_state_from_toml(&configured)?;
+        Ok(())
+    }
+
     #[test]
     fn retry_budget_defaults_and_accepts_an_override() -> ServerResult<()> {
         let default: ServerConfig = toml::from_str(VALID_CONFIG).map_err(|error| {

docs/reference/toml_schema.md

@@ -45,7 +45,7 @@ route reaches no upstream. A file without a `[targets]` table is rejected with
 | `format` | Yes | — | `openai_chat`, `openai_responses`, or `anthropic_messages`. |
 | `base_url` | Yes | — | Upstream base URL. |
 | `api_key_env` | No | unset | Name of the environment variable holding the key. Omit to send no authentication. |
-| `extra_headers` | No | `{}` | Extra HTTP headers sent upstream. |
+| `extra_headers` | No | `{}` | Custom HTTP headers sent to the model server. Set credentials with `api_key_env`. For OpenAI requests, the client ignores `Authorization` here and sends the configured key once. For Anthropic requests, it ignores `x-api-key` and `anthropic-version` here, then sends the configured key and required Anthropic version. Header names are matched without regard to letter case. |
 | `max_retries` | No | `2` | Retry budget, `0`–`10`. |
 
 The TOML never contains the secret itself. `api_key_env` names a variable that