feat(server): proxy auxiliary OpenAI endpoints

Signed-off-by: nachiketb <nachiketb@nvidia.com>

Author: nachiketb-nvidia

Cargo.lock

@@ -268,6 +268,11 @@ impl Backend {
         format!("{}/count_tokens", anthropic_url(base_url))
     }
 
+    // Resolves an OpenAI endpoint from the same configured base URL as Responses calls.
+    pub(crate) fn openai_endpoint_url(&self, suffix: &str) -> String {
+        openai_url(self.config().base_url.trim_end_matches('/'), suffix)
+    }
+
     /// Whether an upstream 400 `body` looks like a context-window overflow for
     /// this backend's provider.
     pub(crate) fn is_context_overflow(&self, body: &str) -> bool {

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

@@ -11,7 +11,7 @@ use async_trait::async_trait;
 use futures_util::StreamExt;
 use http::StatusCode;
 use reqwest::RequestBuilder;
-use reqwest::header::{HeaderMap, RETRY_AFTER};
+use reqwest::header::{CONTENT_TYPE, HeaderMap, HeaderValue, RETRY_AFTER};
 use serde_json::{Map, Value};
 use switchyard_protocol::{
     LlmRequest, LlmResponse, Metadata, ModelId, Request, Response, RoutedLlmClient,
@@ -94,6 +94,31 @@ pub struct TranslatingLlmClient {
     forward_auth_client: reqwest::Client,
 }
 
+/// Provider-native OpenAI request proxied without translation.
+pub enum OpenAiPassthroughRequest {
+    /// Count input tokens using `POST /v1/responses/input_tokens`.
+    ResponsesInputTokens(Value),
+    /// Compact conversation input using `POST /v1/responses/compact`.
+    ResponsesCompact(Value),
+    /// Upload multipart form data using `POST /v1/files`.
+    File {
+        /// Uninspected multipart request body.
+        body: reqwest::Body,
+        /// Multipart content type, including its boundary.
+        content_type: HeaderValue,
+    },
+}
+
+impl OpenAiPassthroughRequest {
+    const fn suffix(&self) -> &'static str {
+        match self {
+            Self::ResponsesInputTokens(_) => "/responses/input_tokens",
+            Self::ResponsesCompact(_) => "/responses/compact",
+            Self::File { .. } => "/files",
+        }
+    }
+}
+
 impl TranslatingLlmClient {
     /// Builds a client over the given [`ModelConfig`]s, with a fresh shared HTTP
     /// client and the built-in translation codecs.
@@ -150,6 +175,62 @@ impl TranslatingLlmClient {
             .is_some()
     }
 
+    /// Proxies an auxiliary OpenAI request through `model`'s Responses backend.
+    ///
+    /// Responses JSON remains provider-native except that `model` is replaced with
+    /// the configured upstream model id. File bodies and all responses remain uninspected.
+    pub async fn passthrough_openai(
+        &self,
+        model: &ModelId,
+        request: OpenAiPassthroughRequest,
+        metadata: Option<&Metadata>,
+    ) -> Result<reqwest::Response> {
+        let backend = self
+            .backend_for(model, WireFormat::OpenAiResponses)
+            .ok_or_else(|| LlmClientError::Configuration {
+                message: format!("model {model} has no OpenAI Responses backend"),
+            })?;
+        let url = backend.openai_endpoint_url(request.suffix());
+        let builder = match request {
+            OpenAiPassthroughRequest::ResponsesInputTokens(mut body)
+            | OpenAiPassthroughRequest::ResponsesCompact(mut body) => {
+                if !body.is_object() {
+                    return Err(LlmClientError::InvalidRequest {
+                        message: "request body must be a JSON object".to_string(),
+                    });
+                }
+                set_json_model(&mut body, model);
+                self.http_client(backend).post(url).json(&body)
+            }
+            OpenAiPassthroughRequest::File { body, content_type } => self
+                .http_client(backend)
+                .post(url)
+                .header(CONTENT_TYPE, content_type)
+                .body(body),
+        };
+        let builder = forward_metadata_headers(builder, metadata);
+        let builder = backend.apply_forwarded_auth(builder, metadata);
+        let builder = apply_extra_headers(builder, backend);
+        let builder = backend.apply_auth(builder);
+        let response = match builder.send().await {
+            Ok(response) => response,
+            Err(error) => {
+                metrics::record_upstream_attempt(None);
+                return Err(convert_reqwest_error(error));
+            }
+        };
+        metrics::record_upstream_attempt(Some(response.status().as_u16()));
+        Ok(response)
+    }
+
+    fn http_client(&self, backend: &Backend) -> &reqwest::Client {
+        if backend.is_forwarding_auth() {
+            &self.forward_auth_client
+        } else {
+            &self.client
+        }
+    }
+
     /// Counts input tokens with `model`'s Anthropic backend.
     ///
     /// Returns an error when the model has no Anthropic backend or the upstream
@@ -298,11 +379,7 @@ impl TranslatingLlmClient {
         model: &ModelId,
         streaming: bool,
     ) -> std::result::Result<EncodedResponse, AttemptFailure> {
-        let client = if backend.is_forwarding_auth() {
-            &self.forward_auth_client
-        } else {
-            &self.client
-        };
+        let client = self.http_client(backend);
         let builder = client.post(url).json(body);
         let builder = forward_metadata_headers(builder, metadata);
         let builder = backend.apply_forwarded_auth(builder, metadata);

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

@@ -26,7 +26,7 @@ pub mod raw;
 pub mod run;
 
 pub use backend::{Backend, DEFAULT_MAX_RETRIES, HttpBackendConfig};
-pub use client::{ModelConfig, TranslatingLlmClient};
+pub use client::{ModelConfig, OpenAiPassthroughRequest, TranslatingLlmClient};
 pub use error::{LlmClientError, Result};
 pub use observation::{LlmCallObservation, RunObservation, RunObserver};
 pub use raw::RawResponse;

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

@@ -17,6 +17,7 @@ use switchyard_llm_client::{
 };
 use switchyard_protocol::{ModelId, RoutedLlmClient, WireFormat};
 
+use crate::route::ResponsesTarget;
 use crate::{
     AlgorithmSpec, CallerAuthKind, CountTokensTarget, DecisionTarget, ModelCapabilities, Route,
     Runner, RunnerError,
@@ -189,6 +190,7 @@ impl DeploymentConfig {
             let (route_clients, caller_auth) =
                 self.build_route_clients(route_name, config, &clients)?;
             let count_tokens_target = self.build_count_tokens_target(config, &clients);
+            let responses_target = self.build_responses_target(config, &clients);
             let decision_targets = config
                 .routing_target_names()
                 .into_iter()
@@ -201,7 +203,8 @@ impl DeploymentConfig {
                 capabilities,
                 count_tokens_target,
                 decision_targets,
-            );
+            )
+            .with_responses_target(responses_target);
             routes.push((config.id.clone(), route));
         }
         Ok(Runner::new(routes))
@@ -316,6 +319,24 @@ impl DeploymentConfig {
                 client: client.clone(),
             })
     }
+
+    fn build_responses_target(
+        &self,
+        route: &RouteConfig,
+        clients: &BTreeMap<String, Arc<TranslatingLlmClient>>,
+    ) -> Option<ResponsesTarget> {
+        route.routing_target_names().into_iter().find_map(|name| {
+            let target = self.targets.get(name)?;
+            let client = clients.get(&target.llm_client)?;
+            client
+                .backend_for(&target.id, WireFormat::OpenAiResponses)
+                .is_some()
+                .then(|| ResponsesTarget {
+                    model: target.id.clone(),
+                    client: client.clone(),
+                })
+        })
+    }
 }
 
 fn count_tokens_priority(target_name: &str, model_id: &ModelId) -> usize {

crates/switchyard-runner/src/config.rs

@@ -100,7 +100,8 @@ impl RunnerError {
             ),
             Self::UnknownRouteModel(_)
             | Self::IncompatibleCallerFormat(_)
-            | Self::CountTokensUnsupported => summary(
+            | Self::CountTokensUnsupported
+            | Self::ResponsesPassthroughUnsupported => summary(
                 RouteErrorKind::InvalidRequest,
                 RouteErrorPhase::BeforeResponse,
                 None,

crates/switchyard-runner/src/failure.rs

@@ -8,8 +8,10 @@ use std::sync::Arc;
 
 use libsy::{Algorithm, CallModel, LibsyError, RoutingOutcome, drive};
 use serde_json::Value;
-use switchyard_llm_client::{ClientRouter, RunObserver, TranslatingLlmClient};
-use switchyard_protocol::{LlmClientError, ModelId, Request, Response, WireFormat};
+use switchyard_llm_client::{
+    ClientRouter, OpenAiPassthroughRequest, RunObserver, TranslatingLlmClient,
+};
+use switchyard_protocol::{LlmClientError, Metadata, ModelId, Request, Response, WireFormat};
 use thiserror::Error;
 
 use crate::DecisionTarget;
@@ -63,6 +65,11 @@ pub struct CountTokensTarget {
     pub client: Arc<TranslatingLlmClient>,
 }
 
+pub(crate) struct ResponsesTarget {
+    pub(crate) model: ModelId,
+    pub(crate) client: Arc<TranslatingLlmClient>,
+}
+
 /// Error returned while loading or executing configured routes.
 #[derive(Debug, Error)]
 pub enum RunnerError {
@@ -78,6 +85,8 @@ pub enum RunnerError {
     IncompatibleCallerFormat(CallerAuthKind),
     #[error("route has no Anthropic target for token counting")]
     CountTokensUnsupported,
+    #[error("no OpenAI Responses target is available for auxiliary endpoints")]
+    ResponsesPassthroughUnsupported,
     #[error(transparent)]
     Algorithm(#[from] LibsyError),
     #[error(transparent)]
@@ -113,6 +122,7 @@ pub struct Route {
     caller_auth: Option<CallerAuthKind>,
     capabilities: ModelCapabilities,
     count_tokens_target: Option<CountTokensTarget>,
+    responses_target: Option<ResponsesTarget>,
     decision_targets: Vec<DecisionTarget>,
 }
 
@@ -138,10 +148,20 @@ impl Route {
             caller_auth,
             capabilities,
             count_tokens_target,
+            responses_target: None,
             decision_targets,
         }
     }
 
+    pub(crate) fn with_responses_target(mut self, target: Option<ResponsesTarget>) -> Self {
+        self.responses_target = target;
+        self
+    }
+
+    pub(crate) fn supports_responses_passthrough(&self) -> bool {
+        self.responses_target.is_some()
+    }
+
     /// Returns the configured libsy algorithm name.
     pub fn algorithm_name(&self) -> &str {
         self.algorithm.name()
@@ -215,6 +235,23 @@ impl Route {
             .await
             .map_err(Into::into)
     }
+
+    /// Proxies an auxiliary OpenAI request through this route's Responses-capable target.
+    pub async fn passthrough_openai(
+        &self,
+        request: OpenAiPassthroughRequest,
+        metadata: Metadata,
+    ) -> Result<reqwest::Response, RunnerError> {
+        let target = self
+            .responses_target
+            .as_ref()
+            .ok_or(RunnerError::ResponsesPassthroughUnsupported)?;
+        target
+            .client
+            .passthrough_openai(&target.model, request, Some(&metadata))
+            .await
+            .map_err(Into::into)
+    }
 }
 
 async fn serve_decision_dependency(clients: ClientRouter, call: CallModel) -> libsy::Result<()> {

crates/switchyard-runner/src/route.rs

@@ -8,7 +8,8 @@ use std::path::Path;
 
 use libsy::RoutingOutcome;
 use serde_json::Value;
-use switchyard_protocol::{ModelId, WireFormat};
+use switchyard_llm_client::OpenAiPassthroughRequest;
+use switchyard_protocol::{Metadata, ModelId, WireFormat};
 
 use crate::config;
 use crate::{ModelCapabilities, Route, RunnerError};
@@ -77,6 +78,21 @@ impl Runner {
         })
     }
 
+    /// Proxies an auxiliary OpenAI request through the first Responses-capable route.
+    pub async fn passthrough_openai(
+        &self,
+        request: OpenAiPassthroughRequest,
+        metadata: Metadata,
+    ) -> Result<reqwest::Response, RunnerError> {
+        let route = self
+            .routes
+            .iter()
+            .map(|(_, route)| route)
+            .find(|route| route.supports_responses_passthrough())
+            .ok_or(RunnerError::ResponsesPassthroughUnsupported)?;
+        route.passthrough_openai(request, metadata).await
+    }
+
     /// Resolves an outcome to configured target names and non-secret client settings.
     pub fn describe_decision(
         &self,

crates/switchyard-runner/src/runner.rs

@@ -32,6 +32,7 @@ opentelemetry-prometheus = "0.32"
 opentelemetry_sdk = { version = "0.32", default-features = false, features = ["metrics", "trace"] }
 parking_lot.workspace = true
 prometheus = "0.14"
+reqwest.workspace = true
 serde.workspace = true
 switchyard-llm-client.workspace = true
 switchyard-protocol.workspace = true