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.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
fix(opencode): preserve custom OpenAI gateway paths (#1596)
Rod Boevc19347c31046
diff --git a/headroom/proxy/handlers/openai.py b/headroom/proxy/handlers/openai.pyindex 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 thediff --git a/plugins/opencode/src/transport.test.ts b/plugins/opencode/src/transport.test.tsindex 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.tsindex 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, upstreaheaders.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 | undereturn [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.pynew file mode 100644index 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")