feat: add options to responses-api-proxy to support Azure

2026-11-02 19:43:24 +00:00 · 2025-11-02 16:27:51 -08:00
parent d5853d9c47
commit 5d4de527e2
3 changed files with 68 additions and 33 deletions
@@ -40,12 +40,23 @@ curl --fail --silent --show-error "${PROXY_BASE_URL}/shutdown"
 ## CLI

 ```
-codex-responses-api-proxy [--port <PORT>] [--server-info <FILE>] [--http-shutdown]
+codex-responses-api-proxy [--port <PORT>] [--server-info <FILE>] [--http-shutdown] [--upstream-url <URL>]
 ```

 - `--port <PORT>`: Port to bind on `127.0.0.1`. If omitted, an ephemeral port is chosen.
 - `--server-info <FILE>`: If set, the proxy writes a single line of JSON with `{ "port": <PORT>, "pid": <PID> }` once listening.
 - `--http-shutdown`: If set, enables `GET /shutdown` to exit the process with code `0`.
+- `--upstream-url <URL>`: Absolute URL to forward requests to. Defaults to `https://api.openai.com/v1/responses`.
+- Authentication is fixed to `Authorization: Bearer <key>` to match the Codex CLI expectations.
+
+For Azure, for example (ensure your deployment accepts `Authorization: Bearer <key>`):
+
+```shell
+printenv AZURE_OPENAI_API_KEY | env -u AZURE_OPENAI_API_KEY codex-responses-api-proxy \
+  --http-shutdown \
+  --server-info /tmp/server-info.json \
+  --upstream-url "https://YOUR_PROJECT_NAME.openai.azure.com/openai/deployments/YOUR_DEPLOYMENT/responses?api-version=2025-04-01-preview"
+```

 ## Notes

@@ -57,8 +68,8 @@ codex-responses-api-proxy [--port <PORT>] [--server-info <FILE>] [--http-shutdow
 Care is taken to restrict access/copying to the value of `OPENAI_API_KEY` retained in memory:

 - We leverage [`codex_process_hardening`](https://github.com/openai/codex/blob/main/codex-rs/process-hardening/README.md) so `codex-responses-api-proxy` is run with standard process-hardening techniques.
- At startup, we allocate a `1024` byte buffer on the stack and write `"Bearer "` as the first `7` bytes.
- We then read from `stdin`, copying the contents into the buffer after `"Bearer "`.
+- At startup, we allocate a `1024` byte buffer on the stack and copy `"Bearer "` into the start of the buffer.
+- We then read from `stdin`, copying the contents into the buffer after that prefix.
 - After verifying the key matches `/^[a-zA-Z0-9_-]+$/` (and does not exceed the buffer), we create a `String` from that buffer (so the data is now on the heap).
 - We zero out the stack-allocated buffer using https://crates.io/crates/zeroize so it is not optimized away by the compiler.
 - We invoke `.leak()` on the `String` so we can treat its contents as a `&'static str`, as it will live for the rest of the process.
@@ -12,8 +12,8 @@ use anyhow::Context;
 use anyhow::Result;
 use anyhow::anyhow;
 use clap::Parser;
+use reqwest::Url;
 use reqwest::blocking::Client;
-use reqwest::header::AUTHORIZATION;
 use reqwest::header::HOST;
 use reqwest::header::HeaderMap;
 use reqwest::header::HeaderName;
@@ -44,6 +44,10 @@ pub struct Args {
    /// Enable HTTP shutdown endpoint at GET /shutdown
    #[arg(long)]
    pub http_shutdown: bool,
+
+    /// Absolute URL the proxy should forward requests to (defaults to OpenAI).
+    #[arg(long, default_value = "https://api.openai.com/v1/responses")]
+    pub upstream_url: String,
 }

 #[derive(Serialize)]
@@ -52,9 +56,35 @@ struct ServerInfo {
    pid: u32,
 }

+#[derive(Clone)]
+struct ForwardConfig {
+    upstream_url: Url,
+    host_header: HeaderValue,
+    auth_header_value: &'static str,
+}
+
 /// Entry point for the library main, for parity with other crates.
 pub fn run_main(args: Args) -> Result<()> {
-    let auth_header = read_auth_header_from_stdin()?;
+    let upstream_url = Url::parse(&args.upstream_url).context("parsing --upstream-url")?;
+
+    let mut host = upstream_url
+        .host_str()
+        .map(str::to_string)
+        .context("upstream URL must include a host")?;
+    if let Some(port) = upstream_url.port() {
+        host.push(':');
+        host.push_str(&port.to_string());
+    }
+    let host_header =
+        HeaderValue::from_str(&host).context("constructing Host header from upstream URL")?;
+
+    let auth_header = read_auth_header_from_stdin().context("reading API key")?;
+
+    let forward_config = Arc::new(ForwardConfig {
+        upstream_url,
+        host_header,
+        auth_header_value: auth_header,
+    });

    let (listener, bound_addr) = bind_listener(args.port)?;
    if let Some(path) = args.server_info.as_ref() {
@@ -75,13 +105,14 @@ pub fn run_main(args: Args) -> Result<()> {
    let http_shutdown = args.http_shutdown;
    for request in server.incoming_requests() {
        let client = client.clone();
+        let forward_config = forward_config.clone();
        std::thread::spawn(move || {
            if http_shutdown && request.method() == &Method::Get && request.url() == "/shutdown" {
                let _ = request.respond(Response::new_empty(StatusCode(200)));
                std::process::exit(0);
            }

-            if let Err(e) = forward_request(&client, auth_header, request) {
+            if let Err(e) = forward_request(&client, &forward_config, request) {
                eprintln!("forwarding error: {e}");
            }
        });
@@ -115,7 +146,7 @@ fn write_server_info(path: &Path, port: u16) -> Result<()> {
    Ok(())
 }

-fn forward_request(client: &Client, auth_header: &'static str, mut req: Request) -> Result<()> {
+fn forward_request(client: &Client, config: &ForwardConfig, mut req: Request) -> Result<()> {
    // Only allow POST /v1/responses exactly, no query string.
    let method = req.method().clone();
    let url_path = req.url().to_string();
@@ -153,15 +184,14 @@ fn forward_request(client: &Client, auth_header: &'static str, mut req: Request)

    // As part of our effort to to keep `auth_header` secret, we use a
    // combination of `from_static()` and `set_sensitive(true)`.
-    let mut auth_header_value = HeaderValue::from_static(auth_header);
+    let mut auth_header_value = HeaderValue::from_static(config.auth_header_value);
    auth_header_value.set_sensitive(true);
-    headers.insert(AUTHORIZATION, auth_header_value);
+    headers.insert(HeaderName::from_static("authorization"), auth_header_value);

-    headers.insert(HOST, HeaderValue::from_static("api.openai.com"));
+    headers.insert(HOST, config.host_header.clone());

-    let upstream = "https://api.openai.com/v1/responses";
    let upstream_resp = client
-        .post(upstream)
+        .post(config.upstream_url.clone())
        .headers(headers)
        .body(body)
        .send()
@@ -6,11 +6,10 @@ use zeroize::Zeroize;
 /// Use a generous buffer size to avoid truncation and to allow for longer API
 /// keys in the future.
 const BUFFER_SIZE: usize = 1024;
-const AUTH_HEADER_PREFIX: &[u8] = b"Bearer ";

-/// Reads the auth token from stdin and returns a static `Authorization` header
-/// value with the auth token used with `Bearer`. The header value is returned
-/// as a `&'static str` whose bytes are locked in memory to avoid accidental
+/// Reads the auth token from stdin and returns a static Authorization header
+/// value that starts with "Bearer ". The header value is returned as a
+/// `&'static str` whose bytes are locked in memory to avoid accidental
 /// exposure.
 #[cfg(unix)]
 pub(crate) fn read_auth_header_from_stdin() -> Result<&'static str> {
@@ -81,9 +80,9 @@ where
    // one to create the String (with the exact size) for the header value,
    // which we then immediately protect with mlock(2).
    let mut buf = [0u8; BUFFER_SIZE];
-    buf[..AUTH_HEADER_PREFIX.len()].copy_from_slice(AUTH_HEADER_PREFIX);
+    buf[..7].copy_from_slice(b"Bearer ");

-    let prefix_len = AUTH_HEADER_PREFIX.len();
+    let prefix_len = 7;
    let capacity = buf.len() - prefix_len;
    let mut total_read = 0usize; // number of bytes read into the token region
    let mut saw_newline = false;
@@ -121,7 +120,7 @@ where
    if total_read == capacity && !saw_newline && !saw_eof {
        buf.zeroize();
        return Err(anyhow!(
-            "OPENAI_API_KEY is too large to fit in the 512-byte buffer"
+            "API key is too large to fit in the 512-byte buffer"
        ));
    }

@@ -130,14 +129,14 @@ where
        total -= 1;
    }

-    if total == AUTH_HEADER_PREFIX.len() {
+    if total == prefix_len {
        buf.zeroize();
        return Err(anyhow!(
-            "OPENAI_API_KEY must be provided via stdin (e.g. printenv OPENAI_API_KEY | codex responses-api-proxy)"
+            "API key must be provided via stdin (e.g. printenv OPENAI_API_KEY | codex responses-api-proxy)"
        ));
    }

-    if let Err(err) = validate_auth_header_bytes(&buf[AUTH_HEADER_PREFIX.len()..total]) {
+    if let Err(err) = validate_auth_header_bytes(&buf[prefix_len..total]) {
        buf.zeroize();
        return Err(err);
    }
@@ -214,7 +213,7 @@ fn validate_auth_header_bytes(key_bytes: &[u8]) -> Result<()> {
    }

    Err(anyhow!(
-        "OPENAI_API_KEY may only contain ASCII letters, numbers, '-' or '_'"
+        "API key may only contain ASCII letters, numbers, '-' or '_'"
    ))
 }

@@ -283,14 +282,13 @@ mod tests {

    #[test]
    fn errors_when_buffer_filled() {
-        let err = read_auth_header_with(|buf| {
-            let data = vec![b'a'; BUFFER_SIZE - AUTH_HEADER_PREFIX.len()];
-            buf[..data.len()].copy_from_slice(&data);
+        let err = read_auth_header_with(|_| {
+            let data = vec![b'a'; BUFFER_SIZE - "Bearer ".len()];
            Ok(data.len())
        })
        .unwrap_err();
        let message = format!("{err:#}");
-        assert!(message.contains("OPENAI_API_KEY is too large to fit in the 512-byte buffer"));
+        assert!(message.contains("API key is too large to fit in the 512-byte buffer"));
    }

    #[test]
@@ -317,9 +315,7 @@ mod tests {
        .unwrap_err();

        let message = format!("{err:#}");
-        assert!(
-            message.contains("OPENAI_API_KEY may only contain ASCII letters, numbers, '-' or '_'")
-        );
+        assert!(message.contains("API key may only contain ASCII letters, numbers, '-' or '_'"));
    }

    #[test]
@@ -337,8 +333,6 @@ mod tests {
        .unwrap_err();

        let message = format!("{err:#}");
-        assert!(
-            message.contains("OPENAI_API_KEY may only contain ASCII letters, numbers, '-' or '_'")
-        );
+        assert!(message.contains("API key may only contain ASCII letters, numbers, '-' or '_'"));
    }
 }