@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
104 lines (89 loc) • 5.18 kB
text/typescript
import { Buffer } from "node:buffer";
import { constants, zstdCompressSync } from "node:zlib";
import type { OcxConfig } from "../../types";
/**
* Opt-in compression of outbound native ChatGPT Responses HTTP request bodies (#7247).
*
* Codex re-sends the whole conversation on every turn. When that turn travels over HTTP the body
* reaches `chatgpt.com` identity-encoded, which on a metered egress is the dominant cost of
* running Codex through the proxy. The backend already accepts coded request bodies: Codex CLI
* itself sends `content-encoding: zstd` there (see `src/server/request-decompress.ts`).
*
* Applied only at the final HTTP send (`sendWithConnectionPolicy`), after the WebSocket decision
* and plugin rewrites, so WebSocket frames and every other destination are untouched.
*
* Compression is synchronous on purpose. An await at the physical-send boundary would open a gap
* between dispatch admission (credential selection, attempt receipts, live reserve policy) and the
* send itself. The cost is bounded instead: bodies above {@link MAX_COMPRESSIBLE_BODY_BYTES} are sent
* as they are, which keeps the event-loop block to tens of milliseconds on ordinary hardware.
*/
export type UpstreamRequestCompression = "off" | "gzip" | "zstd";
/** Below this the header overhead outweighs any saving. */
export const MIN_COMPRESSIBLE_BODY_BYTES = 1024;
/** Above this the synchronous compression block is no longer negligible; send identity. */
export const MAX_COMPRESSIBLE_BODY_BYTES = 16 * 1024 * 1024;
const CANONICAL_CODEX_RESPONSES = /^https:\/\/chatgpt\.com\/backend-api\/codex\/responses(?:\/compact)?$/;
/** True for the native ChatGPT Responses and compact endpoints, the only compressed destinations. */
export function isCanonicalCodexResponsesUrl(url: string): boolean {
return CANONICAL_CODEX_RESPONSES.test(url);
}
/** Anything other than an explicit codec, including a malformed hand edit, means off. */
export function resolveUpstreamRequestCompression(value: unknown): UpstreamRequestCompression {
return value === "gzip" || value === "zstd" ? value : "off";
}
// The live server config object, installed once at startup by `setLiveStateStoreConfig`. Live
// reconciliation mutates that object in place, so the field is read per send rather than copied.
let boundConfig: Pick<OcxConfig, "upstreamRequestCompression"> | null = null;
export function bindUpstreamRequestCompressionConfig(config: Pick<OcxConfig, "upstreamRequestCompression"> | null): void {
boundConfig = config;
}
export function currentUpstreamRequestCompression(): UpstreamRequestCompression {
return resolveUpstreamRequestCompression(boundConfig?.upstreamRequestCompression);
}
// ArrayBuffer-backed bytes, accepted by fetch without another input conversion.
type CodedBytes = Buffer<ArrayBuffer>;
type Compressor = (mode: Exclude<UpstreamRequestCompression, "off">, body: string) => CodedBytes;
const defaultCompressor: Compressor = (mode, body) => {
if (mode === "gzip") {
// Native string input avoids a full-body UTF-8 Buffer; only view the coded output as a Buffer.
const bytes = Bun.gzipSync(body, { level: 1 });
return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
}
return zstdCompressSync(Buffer.from(body, "utf8"), { params: { [constants.ZSTD_c_compressionLevel]: 3 } }) as CodedBytes;
};
let compressor: Compressor = defaultCompressor;
let maxBodyBytes = MAX_COMPRESSIBLE_BODY_BYTES;
/** Test seam: replace the codec (failure injection) and the size ceiling; null restores defaults. */
export function setUpstreamRequestCompressionForTests(next: { compressor?: Compressor | null; maxBodyBytes?: number | null }): void {
if (next.compressor !== undefined) compressor = next.compressor ?? defaultCompressor;
if (next.maxBodyBytes !== undefined) maxBodyBytes = next.maxBodyBytes ?? MAX_COMPRESSIBLE_BODY_BYTES;
}
export interface CompressedUpstreamBody {
body: CodedBytes;
encoding: Exclude<UpstreamRequestCompression, "off">;
}
/**
* Compress one final HTTP send body when the operator opted in and the send is eligible.
*
* Returns null — send unchanged — for any other destination, a non-string body (an already coded
* buffer or a stream, which also makes nested passes idempotent), a request that already declares
* a `content-encoding`, a body outside the size window, or a codec failure. A failure never fails
* the request: identity is what the proxy sent before this option existed.
*/
export function compressUpstreamRequestBody(
target: string,
body: unknown,
headers: Headers,
mode: UpstreamRequestCompression = currentUpstreamRequestCompression(),
): CompressedUpstreamBody | null {
if (mode === "off" || typeof body !== "string" || !isCanonicalCodexResponsesUrl(target)) return null;
if (headers.has("content-encoding")) return null;
const size = Buffer.byteLength(body, "utf8");
if (size < MIN_COMPRESSIBLE_BODY_BYTES || size > maxBodyBytes) return null;
try {
return { body: compressor(mode, body), encoding: mode };
} catch {
// Deliberately silent: the error could only describe the body, and identity is still correct.
return null;
}
}