Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
/**
* Codex Responses-over-WebSocket prompt-compression parity (#8052).
*
* The HTTP/SSE chat pipeline (open-sse/handlers/chatCore.ts) runs every request through the
* modular compression pipeline (settings → strategy selection → applyCompressionAsync →
* compression_analytics/compression_engine_breakdown writes) before dispatching upstream. The
* Codex Responses WebSocket bridge (`prepare()` in ./route.ts) never called any of that — it
* authenticated, injected memory, applied reasoning-routing, then went straight to
* `executor.transformRequest()`.
*
* This module wires the same core pipeline (settings resolution, mode selection via
* `selectCompressionStrategy`, `applyCompressionAsync`, analytics persistence) into the WS
* bridge's per-turn `prepare()` call, using `adaptBodyForCompression`'s existing Responses-API
* (`input[]`) adapter so the same engines that already understand chat `messages[]` bodies work
* unmodified here too. Deliberately scoped to the core pipeline (settings → mode → engines →
* analytics) — combo/output-style/live-zone/adaptive-budget refinements stay chatCore-only for
* now; the WS bridge previously had *zero* compression coverage, so this closes the primary gap.
*/
import { logger } from "@omniroute/open-sse/utils/logger.ts";
import { estimateTokens } from "@omniroute/open-sse/services/contextManager.ts";
import { adaptBodyForCompression } from "@omniroute/open-sse/services/compression/bodyAdapter.ts";
import { resolveOmniGlyphTransport } from "@omniroute/open-sse/services/compression/imageTransportPolicy.ts";
import type {
CompressionConfig,
CompressionResult,
} from "@omniroute/open-sse/services/compression/types.ts";
import { resolveCompressionSettings } from "@omniroute/open-sse/handlers/chatCore/compressionSettings.ts";
import {
writeCompressionAnalytics,
writeCompressionSkip,
} from "@omniroute/open-sse/handlers/chatCore/compressionAnalyticsWrite.ts";
const log = logger("RESPONSES_WS_COMPRESSION");
type JsonRecord = Record<string, unknown>;
export type ResponsesWsCompressionContext = {
provider: string;
model: string;
/** Distinct per logical turn — feeds the compression_analytics.request_id column. */
requestId: string;
};
/**
* Runs the core compression pipeline against a Codex Responses `response` body and returns the
* (possibly rewritten) body. Best-effort: any resolution/engine failure logs and returns the
* original body untouched — a broken compression path must never break the WS turn.
*/
export async function applyResponsesWsCompression(
responseBody: JsonRecord,
ctx: ResponsesWsCompressionContext
): Promise<JsonRecord> {
try {
const { settings, enabled } = await resolveCompressionSettings(log);
if (!enabled || !settings) return responseBody;
const adapter = adaptBodyForCompression(responseBody);
if (
!adapter.adapted ||
!Array.isArray(adapter.body.messages) ||
adapter.body.messages.length === 0
) {
return responseBody;
}
const { selectCompressionStrategy, applyCompressionAsync } =
await import("@omniroute/open-sse/services/compression/strategySelector.ts");
const estimatedTokens = estimateTokens(adapter.body.messages);
const cachingContext = {
provider: ctx.provider,
targetFormat: "openai-responses",
model: ctx.model,
connectionCacheOverride: null,
};
const mode = selectCompressionStrategy(
settings,
null,
estimatedTokens,
adapter.body,
cachingContext,
{},
null
);
if (mode === "off") return responseBody;
const result = await applyCompressionAsync(adapter.body, mode, {
model: ctx.model,
...resolveOmniGlyphTransport(ctx.provider),
provider: ctx.provider,
config: settings as CompressionConfig,
cachingContext,
});
return await persistAndRestore(result, adapter, responseBody, mode, settings, ctx);
} catch (err) {
log.warn(
`[codex-responses-ws] compression skipped: ${err instanceof Error ? err.message : String(err)}`
);
return responseBody;
}
}
async function persistAndRestore(
result: CompressionResult,
adapter: ReturnType<typeof adaptBodyForCompression>,
responseBody: JsonRecord,
mode: string,
settings: CompressionConfig,
ctx: ResponsesWsCompressionContext
): Promise<JsonRecord> {
if (!result.stats) return responseBody;
const writeOpts = {
stats: result.stats,
provider: ctx.provider,
effectiveModel: ctx.model,
effectiveServiceTier: undefined,
comboName: null,
mode,
compressionComboId: settings.compressionComboId,
skillRequestId: ctx.requestId,
cavemanOutputModeApplied: false,
cavemanOutputModeIntensity: null,
log,
};
if (!result.compressed) {
void writeCompressionSkip(writeOpts, "no_savings");
return responseBody;
}
void writeCompressionAnalytics(writeOpts);
return adapter.restore(result.body) as JsonRecord;
}