Support passing dynamic header from response api to mcp servers

crates/mcp/src/core/orchestrator.rs

@@ -461,6 +461,14 @@ impl McpOrchestrator {
 
     /// Apply tool configurations from server config (aliases, response formats, arg mappings).
     fn apply_tool_configs(&self, config: &McpServerConfig) {
+        self.apply_tool_configs_for_server_key(&config.name, config);
+    }
+
+    /// Apply tool configurations for a specific inventory server key.
+    ///
+    /// Static servers use `config.name` as the server key; dynamic servers use
+    /// URL-based server keys from the connection pool.
+    fn apply_tool_configs_for_server_key(&self, server_key: &str, config: &McpServerConfig) {
         let Some(tools) = &config.tools else {
             return;
         };
@@ -469,11 +477,11 @@ impl McpOrchestrator {
             // Check if the tool exists
             if !self
                 .tool_inventory
-                .has_tool_qualified(&config.name, tool_name)
+                .has_tool_qualified(server_key, tool_name)
             {
                 warn!(
                     "Tool config for '{}:{}' but tool not found on server",
-                    config.name, tool_name
+                    server_key, tool_name
                 );
                 continue;
             }
@@ -498,30 +506,30 @@ impl McpOrchestrator {
             if let Some(alias_name) = &tool_config.alias {
                 if let Err(e) = self.register_alias(
                     alias_name,
-                    &config.name,
+                    server_key,
                     tool_name,
                     arg_mapping,
                     response_format.clone(),
                 ) {
                     warn!(
                         "Failed to register alias '{}' for '{}:{}': {}",
-                        alias_name, config.name, tool_name, e
+                        alias_name, server_key, tool_name, e
                     );
                 } else {
                     info!(
                         "Registered alias '{}' → '{}:{}' with format {:?}",
-                        alias_name, config.name, tool_name, response_format
+                        alias_name, server_key, tool_name, response_format
                     );
                 }
             } else if response_format != ResponseFormat::Passthrough {
                 // No alias, but has custom response format - update the entry directly
-                if let Some(mut entry) = self.tool_inventory.get_entry(&config.name, tool_name) {
+                if let Some(mut entry) = self.tool_inventory.get_entry(server_key, tool_name) {
                     entry.response_format = response_format.clone();
                     entry.arg_mapping.clone_from(&arg_mapping);
                     self.tool_inventory.insert_entry(entry);
                     info!(
                         "Set response format {:?} for '{}:{}'",
-                        response_format, config.name, tool_name
+                        response_format, server_key, tool_name
                     );
                 }
             }
@@ -534,6 +542,14 @@ impl McpOrchestrator {
     /// corresponding tool should use the response format associated with the builtin type
     /// (e.g., WebSearchPreview -> WebSearchCall) unless explicitly overridden in the tools config.
     fn apply_builtin_response_format(&self, config: &McpServerConfig) {
+        self.apply_builtin_response_format_for_server_key(&config.name, config);
+    }
+
+    fn apply_builtin_response_format_for_server_key(
+        &self,
+        server_key: &str,
+        config: &McpServerConfig,
+    ) {
         let Some(builtin_type) = &config.builtin_type else {
             return;
         };
@@ -548,7 +564,7 @@ impl McpOrchestrator {
 
         if has_explicit_config {
             debug!(
-                server = %config.name,
+                server = %server_key,
                 tool = %tool_name,
                 "Builtin tool has explicit config, skipping auto-apply of response_format"
             );
@@ -559,10 +575,10 @@ impl McpOrchestrator {
 
         let updated = self
             .tool_inventory
-            .update_entry(&config.name, tool_name, |entry| {
+            .update_entry(server_key, tool_name, |entry| {
                 if entry.response_format != response_format {
                     info!(
-                        server = %config.name,
+                        server = %server_key,
                         tool = %tool_name,
                         builtin_type = %builtin_type,
                         format = ?response_format,
@@ -574,7 +590,7 @@ impl McpOrchestrator {
 
         if !updated {
             warn!(
-                server = %config.name,
+                server = %server_key,
                 tool = %tool_name,
                 builtin_type = %builtin_type,
                 "Builtin tool not found on server"
@@ -832,14 +848,15 @@ impl McpOrchestrator {
     /// - `server_key` - Internal identifier for the server (used for `call_tool`)
     /// - `tool_name` - The MCP tool to call on that server
     /// - `response_format` - The format to use for response transformation
+    /// - `server_config` - The matched MCP server config
     ///
     /// Returns `None` if no server is configured for this built-in type.
     ///
     /// # Example
     ///
     /// ```ignore
     /// // Check if web_search_preview is configured
-    /// if let Some((server_key, tool_name, format)) =
+    /// if let Some((server_key, tool_name, format, _server_cfg)) =
     ///     orchestrator.find_builtin_server(BuiltinToolType::WebSearchPreview)
     /// {
     ///     // Route to MCP server
@@ -857,7 +874,7 @@ impl McpOrchestrator {
     pub fn find_builtin_server(
         &self,
         builtin_type: BuiltinToolType,
-    ) -> Option<(String, String, ResponseFormat)> {
+    ) -> Option<(String, String, ResponseFormat, McpServerConfig)> {
         // Helper to extract builtin info from a server config
         let extract_builtin = |server_config: &McpServerConfig| {
             if let (Some(cfg_type), Some(tool_name)) = (
@@ -877,6 +894,7 @@ impl McpOrchestrator {
                         server_config.name.clone(),
                         tool_name.clone(),
                         response_format,
+                        server_config.clone(),
                     ));
                 }
             }
@@ -1585,6 +1603,9 @@ impl McpOrchestrator {
                         .with_category(ToolCategory::Dynamic);
                     inventory_clone.insert_entry(entry);
                 }
+
+                self.apply_tool_configs_for_server_key(&server_key, &config);
+                self.apply_builtin_response_format_for_server_key(&server_key, &config);
             }
             Err(e) => warn!("Failed to list tools from '{}': {}", server_key, e),
         }
@@ -2475,7 +2496,7 @@ mod tests {
         let result = orchestrator.find_builtin_server(BuiltinToolType::WebSearchPreview);
         assert!(result.is_some());
 
-        let (server_key, tool_name, response_format) = result.unwrap();
+        let (server_key, tool_name, response_format, _) = result.unwrap();
         assert_eq!(server_key, "brave");
         assert_eq!(tool_name, "brave_web_search");
         assert_eq!(response_format, ResponseFormat::WebSearchCall);
@@ -2543,7 +2564,7 @@ mod tests {
         let result = orchestrator.find_builtin_server(BuiltinToolType::WebSearchPreview);
         assert!(result.is_some());
 
-        let (server_key, tool_name, response_format) = result.unwrap();
+        let (server_key, tool_name, response_format, _) = result.unwrap();
         assert_eq!(server_key, "custom-search");
         assert_eq!(tool_name, "my_search");
         // Should use the custom Passthrough format, not the default WebSearchCall

model_gateway/src/routers/anthropic/router.rs

@@ -108,6 +108,8 @@ impl RouterTrait for AnthropicRouter {
                     url: Some(server.url.clone()),
                     authorization: server.authorization_token.clone(),
                     headers: HashMap::new(),
+                    builtin_type: None,
+                    builtin_tool_name: None,
                     allowed_tools: toolset_allowed.get(&server.name).and_then(|v| v.clone()),
                 })
                 .collect();

model_gateway/src/routers/grpc/common/responses/utils.rs

@@ -58,7 +58,7 @@ pub(crate) async fn ensure_mcp_connection(
     }
 
     if let Some(tools) = tools {
-        match ensure_request_mcp_client(mcp_orchestrator, tools).await {
+        match ensure_request_mcp_client(mcp_orchestrator, tools, None).await {
             Some(mcp_servers) => {
                 return Ok((true, mcp_servers));
             }