Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

fix(opencode): preserve custom OpenAI gateway paths (#1596)

Rod Boevc19347c31046
diff --git a/headroom/proxy/handlers/openai.py b/headroom/proxy/handlers/openai.py
index caa8f9539..0857b4167 100644
--- a/headroom/proxy/handlers/openai.py
+++ b/headroom/proxy/handlers/openai.py
@@ -70,6 +70,10 @@ _OPENAI_RESPONSES_UNIT_EXECUTOR: ThreadPoolExecutor | None = None
_WS_ALLOWED_ORIGINS_ENV = "HEADROOM_WS_ORIGINS"
_CORS_ALLOWED_ORIGINS_ENV = "HEADROOM_CORS_ORIGINS"
_CODEX_RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite"
+_OPENAI_CHAT_COMPLETIONS_PATH = "/chat/completions"
+_OPENAI_RESPONSES_PATH = "/responses"
+_OPENAI_ORIGINAL_PATH_HEADER = "x-headroom-original-path"
+_OPENAI_BASE_URL_HEADER = "x-headroom-base-url"
def _header_get(headers: dict[str, str], name: str) -> str | None:
@@ -81,6 +85,51 @@ def _header_get(headers: dict[str, str], name: str) -> str | None:
return None
+def _resolve_openai_handler_path(
+ request_headers: dict[str, str],
+ *,
+ handler_path: str,
+) -> str:
+ raw_path = _header_get(request_headers, _OPENAI_ORIGINAL_PATH_HEADER)
+ upstream_path = raw_path.strip() if raw_path is not None else None
+
+ default_path = f"/v1{handler_path}"
+ if upstream_path is None:
+ return default_path
+
+ if not upstream_path.startswith("/") or upstream_path.startswith("//"):
+ return default_path
+
+ parsed = urlparse(upstream_path)
+ if parsed.scheme or parsed.netloc or parsed.query or parsed.fragment:
+ return default_path
+
+ if not parsed.path.endswith(handler_path):
+ return f"/v1{handler_path}"
+
+ return parsed.path
+
+
+def _resolve_openai_upstream_base(request_headers: dict[str, str]) -> str | None:
+ raw_base_url = _header_get(request_headers, _OPENAI_BASE_URL_HEADER)
+ if raw_base_url is None:
+ return None
+
+ normalized = _normalize_origin(raw_base_url)
+ if normalized is None:
+ return None
+ if urlparse(normalized).scheme not in {"http", "https"}:
+ return None
+ return normalized
+
+
+def _append_request_query(url: str, query: str) -> str:
+ if not query:
+ return url
+ separator = "&" if "?" in url else "?"
+ return f"{url}{separator}{query}"
+
+
def _normalize_origin(origin: str) -> str | None:
parsed = urlparse(origin.strip())
if not parsed.scheme or not parsed.hostname:
@@ -2486,7 +2535,19 @@ class OpenAIHandlerMixin:
)
# Direct OpenAI API (no backend configured)
- url = build_copilot_upstream_url(self.OPENAI_API_URL, "/v1/chat/completions")
+ upstream_base_url = _resolve_openai_upstream_base(request.headers)
+ handler_path = (
+ _resolve_openai_handler_path(
+ request.headers, handler_path=_OPENAI_CHAT_COMPLETIONS_PATH
+ )
+ if upstream_base_url is not None
+ else "/v1/chat/completions"
+ )
+ url = build_copilot_upstream_url(
+ upstream_base_url or self.OPENAI_API_URL,
+ handler_path,
+ )
+ url = _append_request_query(url, request.url.query)
try:
if stream:
@@ -3245,7 +3306,17 @@ class OpenAIHandlerMixin:
if is_chatgpt_auth:
url = "https://chatgpt.com/backend-api/codex/responses"
else:
- url = build_copilot_upstream_url(self.OPENAI_API_URL, "/v1/responses")
+ upstream_base_url = _resolve_openai_upstream_base(request.headers)
+ handler_path = (
+ _resolve_openai_handler_path(request.headers, handler_path=_OPENAI_RESPONSES_PATH)
+ if upstream_base_url is not None
+ else "/v1/responses"
+ )
+ url = build_copilot_upstream_url(
+ upstream_base_url or self.OPENAI_API_URL,
+ handler_path,
+ )
+ url = _append_request_query(url, request.url.query)
# The standalone Rust proxy has native /v1/responses item handling,
# but the default CLI runtime is this Python proxy. Compress the
diff --git a/plugins/opencode/src/transport.test.ts b/plugins/opencode/src/transport.test.ts
index 709f88a05..2e97e1fe5 100644
--- a/plugins/opencode/src/transport.test.ts
+++ b/plugins/opencode/src/transport.test.ts
@@ -20,7 +20,11 @@ type SeenRequest = {
body: string;
};
-function proxyServer(): Promise<{ url: string; seen: SeenRequest[]; close: () => Promise<void> }> {
+function proxyServer(pathPrefix: string = "/v1"): Promise<{
+ url: string;
+ seen: SeenRequest[];
+ close: () => Promise<void>;
+}> {
const seen: SeenRequest[] = [];
const server = http.createServer((req, res) => {
let body = "";
@@ -44,7 +48,7 @@ function proxyServer(): Promise<{ url: string; seen: SeenRequest[]; close: () =>
return;
}
resolve({
- url: `http://127.0.0.1:${address.port}/v1`,
+ url: `http://127.0.0.1:${address.port}${pathPrefix}`,
seen,
close: () => new Promise((done) => server.close(() => done())),
});
@@ -53,6 +57,54 @@ function proxyServer(): Promise<{ url: string; seen: SeenRequest[]; close: () =>
}
describe("Headroom OpenCode transport", () => {
+ it("routes fetch chat paths through /v1/chat/completions with proxy base and normalized-path header", async () => {
+ const proxyTargets = ["http://127.0.0.1:8787", "http://127.0.0.1:8787/v1"];
+ const upstreamPath = "/api/coding/paas/v4/chat/completions";
+ for (const proxyUrl of proxyTargets) {
+ const proxyOrigin = new URL(proxyUrl).origin;
+ const originalFetch = globalThis.fetch;
+ const fetchMock = vi.fn(async (..._args: FetchCall) => new Response("ok"));
+ globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+ installHeadroomTransport({ proxyUrl });
+
+ await fetch(`https://open.bigmodel.cn${upstreamPath}`, { method: "POST", headers: { "content-type": "application/json" } });
+
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ expect(fetchMock.mock.calls[0][0]).toEqual(new URL(`${proxyOrigin}/v1/chat/completions`));
+ const headers = new Headers(fetchMock.mock.calls[0][1]?.headers);
+ expect(headers.get("x-headroom-base-url")).toBe("https://open.bigmodel.cn");
+ expect(headers.get("x-headroom-original-path")).toBe(upstreamPath);
+
+ globalThis.fetch = originalFetch;
+ uninstallHeadroomTransport();
+ }
+ });
+
+ it("routes fetch responses paths through /v1/responses with proxy base and normalized-path header", async () => {
+ const proxyTargets = ["http://127.0.0.1:8787", "http://127.0.0.1:8787/v1"];
+ const upstreamPath = "/api/coding/paas/v4/responses";
+ for (const proxyUrl of proxyTargets) {
+ const proxyOrigin = new URL(proxyUrl).origin;
+ const originalFetch = globalThis.fetch;
+ const fetchMock = vi.fn(async (..._args: FetchCall) => new Response("ok"));
+ globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+ installHeadroomTransport({ proxyUrl });
+
+ await fetch(`https://open.bigmodel.cn${upstreamPath}`, { method: "POST", headers: { "content-type": "application/json" } });
+
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ expect(fetchMock.mock.calls[0][0]).toEqual(new URL(`${proxyOrigin}/v1/responses`));
+ const headers = new Headers(fetchMock.mock.calls[0][1]?.headers);
+ expect(headers.get("x-headroom-base-url")).toBe("https://open.bigmodel.cn");
+ expect(headers.get("x-headroom-original-path")).toBe(upstreamPath);
+
+ globalThis.fetch = originalFetch;
+ uninstallHeadroomTransport();
+ }
+ });
+
it("routes external fetch calls through the proxy without pre-registering providers", async () => {
const originalFetch = globalThis.fetch;
const fetchMock = vi.fn(async (..._args: FetchCall) => new Response("ok"));
@@ -82,6 +134,22 @@ describe("Headroom OpenCode transport", () => {
globalThis.fetch = originalFetch;
});
+ it("preserves non-prefix paths like /base/v1/messages", async () => {
+ const originalFetch = globalThis.fetch;
+ const fetchMock = vi.fn(async (..._args: FetchCall) => new Response("ok"));
+ globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+ installHeadroomTransport({ proxyUrl: "http://127.0.0.1:8787/v1" });
+
+ await fetch("https://example.test/base/v1/messages", { method: "POST" });
+
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ expect(fetchMock.mock.calls[0][0]).toEqual(new URL("http://127.0.0.1:8787/base/v1/messages"));
+ expect(new Headers(fetchMock.mock.calls[0][1]?.headers).get("x-headroom-original-path")).toBeNull();
+
+ globalThis.fetch = originalFetch;
+ });
+
it("bypasses local, OpenCode, and Headroom proxy fetch URLs", async () => {
const originalFetch = globalThis.fetch;
const fetchMock = vi.fn(async (..._args: FetchCall) => new Response("ok"));
@@ -124,6 +192,102 @@ describe("Headroom OpenCode transport", () => {
await proxy.close();
});
+ it("normalizes Node HTTP(S) requests for /chat/completions and /responses", async () => {
+ const proxy = await proxyServer("");
+ installHeadroomTransport({ proxyUrl: proxy.url });
+ const httpChatPath = "/api/coding/paas/v4/chat/completions";
+ const httpResponsesPath = "/api/coding/paas/v4/responses";
+ const httpsChatPath = "/v4/openai/chat/completions";
+ const httpsResponsesPath = "/v4/openai/responses";
+
+ await new Promise<void>((resolve, reject) => {
+ const req = http.request(
+ `http://open.bigmodel.cn${httpChatPath}`,
+ { method: "POST", headers: { authorization: "Bearer test" } },
+ (res) => {
+ res.resume();
+ res.on("end", resolve);
+ },
+ );
+ req.on("error", reject);
+ req.end("{\"model\":\"gpt-4\"}");
+ });
+
+ await new Promise<void>((resolve, reject) => {
+ const req = http.request(
+ `http://open.bigmodel.cn${httpResponsesPath}`,
+ { method: "POST", headers: { authorization: "Bearer test" } },
+ (res) => {
+ res.resume();
+ res.on("end", resolve);
+ },
+ );
+ req.on("error", reject);
+ req.end("{\"model\":\"gpt-4\"}");
+ });
+
+ await new Promise<void>((resolve, reject) => {
+ const req = https.request(
+ `https://api.deepseek.com${httpsChatPath}`,
+ { method: "POST", headers: { authorization: "Bearer test" } },
+ (res) => {
+ res.resume();
+ res.on("end", resolve);
+ },
+ );
+ req.on("error", reject);
+ req.end("{\"model\":\"gpt-4\"}");
+ });
+
+ await new Promise<void>((resolve, reject) => {
+ const req = https.request(
+ `https://api.deepseek.com${httpsResponsesPath}`,
+ { method: "POST", headers: { authorization: "Bearer test" } },
+ (res) => {
+ res.resume();
+ res.on("end", resolve);
+ },
+ );
+ req.on("error", reject);
+ req.end("{\"model\":\"gpt-4\"}");
+ });
+
+ expect(proxy.seen[0]).toMatchObject({
+ method: "POST",
+ url: "/v1/chat/completions",
+ headers: expect.objectContaining({
+ "x-headroom-base-url": "http://open.bigmodel.cn",
+ "x-headroom-original-path": httpChatPath,
+ }),
+ });
+ expect(proxy.seen[1]).toMatchObject({
+ method: "POST",
+ url: "/v1/responses",
+ headers: expect.objectContaining({
+ "x-headroom-base-url": "http://open.bigmodel.cn",
+ "x-headroom-original-path": httpResponsesPath,
+ }),
+ });
+ expect(proxy.seen[2]).toMatchObject({
+ method: "POST",
+ url: "/v1/chat/completions",
+ headers: expect.objectContaining({
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": httpsChatPath,
+ }),
+ });
+ expect(proxy.seen[3]).toMatchObject({
+ method: "POST",
+ url: "/v1/responses",
+ headers: expect.objectContaining({
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": httpsResponsesPath,
+ }),
+ });
+
+ await proxy.close();
+ });
+
it("blocks external http2 connections instead of leaking them", () => {
installHeadroomTransport({ proxyUrl: "http://127.0.0.1:8787/v1" });
diff --git a/plugins/opencode/src/transport.ts b/plugins/opencode/src/transport.ts
index 5ca012cb8..b7ced7912 100644
--- a/plugins/opencode/src/transport.ts
+++ b/plugins/opencode/src/transport.ts
@@ -7,6 +7,7 @@ const http2 = nodeRequire("node:http2") as typeof import("node:http2");
const childProcess = nodeRequire("node:child_process") as typeof import("node:child_process");
const BASE_URL_HEADER = "x-headroom-base-url";
+const ORIGINAL_PATH_HEADER = "x-headroom-original-path";
const PROXY_ENV = "HEADROOM_OPENCODE_TRANSPORT_PROXY_URL";
const STATE_KEY = Symbol.for("headroom.opencode.transport");
@@ -178,6 +179,31 @@ function routedUrl(upstream: URL, proxy: URL): URL {
return new URL(`${upstream.pathname}${upstream.search}`, proxy.origin);
}
+function normalizedOpenAiProxyPath(pathname: string): string | undefined {
+ if (pathname.endsWith("/chat/completions")) {
+ return "/v1/chat/completions";
+ }
+ if (pathname.endsWith("/responses")) {
+ return "/v1/responses";
+ }
+ return undefined;
+}
+
+function routedUrlForOpenCode(upstream: URL, proxy: URL): { url: URL; originalPath: string | undefined } {
+ const normalizedPath = normalizedOpenAiProxyPath(upstream.pathname);
+ if (!normalizedPath) {
+ return {
+ url: routedUrl(upstream, proxy),
+ originalPath: undefined,
+ };
+ }
+
+ return {
+ url: new URL(`${normalizedPath}${upstream.search}`, proxy.origin),
+ originalPath: upstream.pathname,
+ };
+}
+
function requestUrl(input: RequestInfo | URL): URL {
if (input instanceof Request) {
return new URL(input.url);
@@ -188,7 +214,12 @@ function requestUrl(input: RequestInfo | URL): URL {
return new URL(String(input));
}
-function mergeFetchHeaders(input: RequestInfo | URL, init?: RequestInit, upstream?: URL): Headers {
+function mergeFetchHeaders(
+ input: RequestInfo | URL,
+ init: RequestInit | undefined,
+ upstream: URL | undefined,
+ originalPath: string | undefined = undefined,
+): Headers {
const headers = new Headers(input instanceof Request ? input.headers : undefined);
if (init?.headers) {
new Headers(init.headers).forEach((value, key) => headers.set(key, value));
@@ -197,6 +228,9 @@ function mergeFetchHeaders(input: RequestInfo | URL, init?: RequestInit, upstrea
headers.set(BASE_URL_HEADER, upstream.origin);
headers.delete("host");
}
+ if (originalPath) {
+ headers.set(ORIGINAL_PATH_HEADER, originalPath);
+ }
return headers;
}
@@ -206,11 +240,11 @@ function withRoutedFetchInput(input: RequestInfo | URL, init: RequestInit | unde
return [input, init];
}
+ const { url: nextUrl, originalPath } = routedUrlForOpenCode(upstream, proxy);
const nextInit = {
...init,
- headers: mergeFetchHeaders(input, init, upstream),
+ headers: mergeFetchHeaders(input, init, upstream, originalPath),
};
- const nextUrl = routedUrl(upstream, proxy);
if (input instanceof Request) {
return [new Request(nextUrl, input), nextInit];
@@ -262,9 +296,16 @@ function urlFromRequestOptions(options: Record<string, unknown>): URL | undefine
}
}
-function headersForNodeRequest(options: Record<string, unknown>, upstream: URL): Record<string, string> {
+function headersForNodeRequest(
+ options: Record<string, unknown>,
+ upstream: URL,
+ originalPath: string | undefined,
+): Record<string, string> {
const headers = new Headers(options.headers as HeadersInit | undefined);
headers.set(BASE_URL_HEADER, upstream.origin);
+ if (originalPath) {
+ headers.set(ORIGINAL_PATH_HEADER, originalPath);
+ }
headers.delete("host");
const result: Record<string, string> = {};
@@ -279,7 +320,7 @@ function routedNodeOptions(parts: NodeRequestParts, proxy: URL): Record<string,
return undefined;
}
- const nextUrl = routedUrl(parts.url, proxy);
+ const { url: nextUrl, originalPath } = routedUrlForOpenCode(parts.url, proxy);
const {
agent: _agent,
auth: _auth,
@@ -307,7 +348,7 @@ function routedNodeOptions(parts: NodeRequestParts, proxy: URL): Record<string,
hostname: nextUrl.hostname,
port: nextUrl.port || undefined,
path: `${nextUrl.pathname}${nextUrl.search}`,
- headers: headersForNodeRequest(parts.options, parts.url),
+ headers: headersForNodeRequest(parts.options, parts.url, originalPath),
};
}
diff --git a/tests/test_proxy/test_openai_transport_path_prefix.py b/tests/test_proxy/test_openai_transport_path_prefix.py
new file mode 100644
index 000000000..3a4d7fab9
--- /dev/null
+++ b/tests/test_proxy/test_openai_transport_path_prefix.py
@@ -0,0 +1,281 @@
+"""Tests for OpenAI transport path-prefix reconstruction from upstream hints."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import httpx
+import pytest
+
+pytest.importorskip("fastapi")
+
+from fastapi.testclient import TestClient
+
+from headroom.proxy.server import ProxyConfig, create_app
+
+_OPENAI_CHAT_PATH = "/v1/chat/completions"
+_OPENAI_RESPONSES_PATH = "/v1/responses"
+
+
+def _build_openai_client():
+ config = ProxyConfig(
+ optimize=False,
+ cache_enabled=False,
+ rate_limit_enabled=False,
+ cost_tracking_enabled=False,
+ log_requests=False,
+ ccr_inject_tool=False,
+ ccr_handle_responses=False,
+ ccr_context_tracking=False,
+ image_optimize=False,
+ )
+
+ app = create_app(config)
+ proxy = app.state.proxy
+ captured: dict[str, object] = {}
+
+ async def _fake_retry(
+ method: str,
+ url: str,
+ headers: dict[str, str],
+ body: dict,
+ **_kwargs: object,
+ ) -> httpx.Response:
+ captured["method"] = method
+ captured["url"] = url
+ captured["headers"] = headers
+ captured["body"] = body
+ return httpx.Response(
+ 200,
+ json={
+ "id": "msg_1",
+ "object": "response",
+ "usage": {
+ "input_tokens": 10,
+ "output_tokens": 2,
+ "cache_read_input_tokens": 0,
+ "cache_creation_input_tokens": 0,
+ "total_tokens": 12,
+ },
+ },
+ )
+
+ proxy._retry_request = _fake_retry
+ proxy._record_request_outcome = AsyncMock()
+
+ return TestClient(app), captured
+
+
+def _assert_internal_header_absent(captured: dict[str, object], name: str) -> None:
+ assert isinstance(captured.get("headers"), dict)
+ headers = {k.lower() for k in captured["headers"].keys()} # type: ignore[union-attr]
+ assert name.lower() not in headers
+
+
+def _assert_path(captured: dict[str, object], path: str) -> None:
+ url = captured.get("url")
+ assert isinstance(url, str)
+ assert url.endswith(path)
+
+
+def _assert_origin(captured: dict[str, object], origin: str) -> None:
+ url = captured.get("url")
+ assert isinstance(url, str)
+ assert url.startswith(origin)
+
+
+def test_chat_upstream_reconstruction_base_fails_head_passes() -> None:
+ endpoint = _OPENAI_CHAT_PATH
+ body = {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]}
+ base_fail = "://bad-base"
+
+ for headers in [
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": base_fail,
+ "x-headroom-original-path": "/chat/completions",
+ },
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/chat/completions",
+ },
+ ]:
+ client, captured = _build_openai_client()
+ response = client.post(endpoint, headers=headers, json=body)
+ assert response.status_code == 200, response.text
+
+ assert captured["method"] == "POST"
+ if headers["x-headroom-base-url"] == base_fail:
+ _assert_path(captured, "/v1/chat/completions")
+ else:
+ _assert_origin(captured, "https://api.deepseek.com")
+ _assert_path(captured, "/chat/completions")
+
+
+def test_responses_upstream_reconstruction_base_fails_head_passes() -> None:
+ endpoint = _OPENAI_RESPONSES_PATH
+ body = {"model": "gpt-4o", "input": "hi"}
+ base_fail = "://bad-base"
+
+ for headers in [
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": base_fail,
+ "x-headroom-original-path": "/responses",
+ },
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/responses",
+ },
+ ]:
+ client, captured = _build_openai_client()
+ response = client.post(endpoint, headers=headers, json=body)
+ assert response.status_code == 200, response.text
+
+ assert captured["method"] == "POST"
+ if headers["x-headroom-base-url"] == base_fail:
+ _assert_path(captured, "/v1/responses")
+ else:
+ _assert_origin(captured, "https://api.deepseek.com")
+ _assert_path(captured, "/responses")
+
+
+def test_direct_v1_paths_are_preserved() -> None:
+ cases = [
+ (
+ _OPENAI_CHAT_PATH,
+ {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]},
+ "/v1/chat/completions",
+ ),
+ (
+ _OPENAI_RESPONSES_PATH,
+ {"model": "gpt-4o", "input": "hi"},
+ "/v1/responses",
+ ),
+ ]
+
+ for endpoint, body, expected_path in cases:
+ client, captured = _build_openai_client()
+ response = client.post(
+ endpoint,
+ headers={"Authorization": "Bearer sk-test"},
+ json=body,
+ )
+ assert response.status_code == 200, response.text
+ assert captured["method"] == "POST"
+ _assert_path(captured, expected_path)
+
+
+def test_query_string_is_preserved_for_reconstructed_upstream_paths() -> None:
+ cases = [
+ (
+ _OPENAI_CHAT_PATH,
+ {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/base/chat/completions",
+ },
+ "/base/chat/completions?foo=1",
+ ),
+ (
+ _OPENAI_RESPONSES_PATH,
+ {"model": "gpt-4o", "input": "hi"},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/base/responses",
+ },
+ "/base/responses?foo=1",
+ ),
+ ]
+
+ for endpoint, body, headers, expected_path in cases:
+ client, captured = _build_openai_client()
+ response = client.post(f"{endpoint}?foo=1", headers=headers, json=body)
+ assert response.status_code == 200, response.text
+ assert captured["method"] == "POST"
+ _assert_origin(captured, "https://api.deepseek.com")
+ _assert_path(captured, expected_path)
+
+
+def test_non_http_base_url_falls_back_to_v1() -> None:
+ cases = [
+ (
+ _OPENAI_CHAT_PATH,
+ {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "ws://api.deepseek.com",
+ "x-headroom-original-path": "/chat/completions",
+ },
+ "/v1/chat/completions",
+ ),
+ (
+ _OPENAI_RESPONSES_PATH,
+ {"model": "gpt-4o", "input": "hi"},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "wss://api.deepseek.com",
+ "x-headroom-original-path": "/responses",
+ },
+ "/v1/responses",
+ ),
+ ]
+
+ for endpoint, body, headers, expected_path in cases:
+ client, captured = _build_openai_client()
+ response = client.post(endpoint, headers=headers, json=body)
+ assert response.status_code == 200, response.text
+ assert captured["method"] == "POST"
+ _assert_path(captured, expected_path)
+
+
+def test_invalid_original_path_falls_back_to_v1() -> None:
+ cases = [
+ (
+ _OPENAI_CHAT_PATH,
+ {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "https://evil.example/chat/completions",
+ },
+ "/v1/chat/completions",
+ ),
+ (
+ _OPENAI_RESPONSES_PATH,
+ {"model": "gpt-4o", "input": "hi"},
+ {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/x/responses?bad",
+ },
+ "/v1/responses",
+ ),
+ ]
+
+ for endpoint, body, headers, expected_path in cases:
+ client, captured = _build_openai_client()
+ response = client.post(endpoint, headers=headers, json=body)
+ assert response.status_code == 200, response.text
+ assert captured["method"] == "POST"
+ _assert_path(captured, expected_path)
+
+
+def test_original_path_header_is_not_forwarded_upstream() -> None:
+ headers = {
+ "Authorization": "Bearer sk-test",
+ "x-headroom-base-url": "https://api.deepseek.com",
+ "x-headroom-original-path": "/chat/completions",
+ }
+ body = {"model": "gpt-4o", "messages": [{"role": "user", "content": "hi"}]}
+
+ client, captured = _build_openai_client()
+ response = client.post(_OPENAI_CHAT_PATH, headers=headers, json=body)
+ assert response.status_code == 200, response.text
+
+ _assert_internal_header_absent(captured, "x-headroom-original-path")
+ _assert_internal_header_absent(captured, "x-headroom-base-url")