Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

warn about codex context risks

Raine Virta438eba87712d
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index 820c1fe..3b206f3 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -14,7 +14,7 @@ import { accumulateResponse, UpstreamStreamError } from "./translate/accumulate.
import { mapUsageToAnthropic } from "./translate/reducer.ts";
import { CodexError, postCodex } from "./client.ts";
import { countTokens, countTranslatedTokens } from "./count-tokens.ts";
-import { summarizeCodexRequestSize } from "./request-summary.ts";
+import { summarizeCodexRequestSize, type CodexRequestSizeSummary } from "./request-summary.ts";
import { runBrowserLogin } from "./auth/pkce.ts";
import { runDeviceLogin } from "./auth/device.ts";
import { persistInitialTokens } from "./auth/manager.ts";
@@ -112,6 +112,20 @@ function upstreamHeaderSnapshot(headers: Headers): {
};
}
+function warnForHeavyImages(
+ log: ReturnType<RequestContext["childLogger"]>,
+ requestSize: CodexRequestSizeSummary,
+): void {
+ if (requestSize.inputImageDataUrlBytes < 1_000_000) return;
+ log.warn("large inline images in codex request", {
+ inputImagePartCount: requestSize.inputImagePartCount,
+ inputImageDataUrlBytes: requestSize.inputImageDataUrlBytes,
+ bodyJsonBytes: requestSize.bodyJsonBytes,
+ inputJsonBytes: requestSize.inputJsonBytes,
+ largestInputImages: requestSize.largestInputImages,
+ });
+}
+
function jsonError(status: number, type: string, message: string): Response {
return new Response(JSON.stringify({ type: "error", error: { type, message } }), {
status,
@@ -222,6 +236,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
throw err;
}
const requestSize = summarizeCodexRequestSize(translated);
+ warnForHeavyImages(log, requestSize);
const localInputTokens = logVerbose() ? countTokens(body) : undefined;
const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined;
if (state) {
diff --git a/src/providers/codex/request-summary.test.ts b/src/providers/codex/request-summary.test.ts
new file mode 100644
index 0000000..d1cb5c1
--- /dev/null
+++ b/src/providers/codex/request-summary.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test";
+import { summarizeCodexRequestSize } from "./request-summary.ts";
+import type { ResponsesRequest } from "./translate/request.ts";
+
+describe("summarizeCodexRequestSize", () => {
+ it("reports inline image byte weight separately", () => {
+ const req: ResponsesRequest = {
+ model: "gpt-5.5",
+ input: [
+ {
+ type: "message",
+ role: "user",
+ content: [
+ { type: "input_text", text: "look" },
+ { type: "input_image", image_url: `data:image/png;base64,${"a".repeat(20)}` },
+ ],
+ },
+ {
+ type: "message",
+ role: "user",
+ content: [
+ { type: "input_image", image_url: "https://example.invalid/image.png" },
+ { type: "input_image", image_url: `data:image/png;base64,${"b".repeat(40)}` },
+ ],
+ },
+ ],
+ store: false,
+ stream: true,
+ };
+
+ const summary = summarizeCodexRequestSize(req);
+
+ expect(summary.inputImagePartCount).toBe(3);
+ expect(summary.inputImageDataUrlBytes).toBe("data:image/png;base64,".length * 2 + 20 + 40);
+ expect(summary.largestInputImages).toEqual([
+ expect.objectContaining({ itemIndex: 1, partIndex: 1, dataUrl: true }),
+ expect.objectContaining({ itemIndex: 0, partIndex: 1, dataUrl: true }),
+ expect.objectContaining({ itemIndex: 1, partIndex: 0, dataUrl: false }),
+ ]);
+ });
+});
diff --git a/src/providers/codex/request-summary.ts b/src/providers/codex/request-summary.ts
index 960fdb3..332961a 100644
--- a/src/providers/codex/request-summary.ts
+++ b/src/providers/codex/request-summary.ts
@@ -13,9 +13,18 @@ export interface CodexRequestSizeSummary {
clientMetadataJsonBytes: number;
inputItemCount: number;
toolCount: number;
+ inputImagePartCount: number;
+ inputImageDataUrlBytes: number;
inputTypeCounts: Record<string, number>;
roleCounts: Record<string, number>;
largestInputItems: Array<{ index: number; type: string; role?: string; jsonBytes: number }>;
+ largestInputImages: Array<{
+ itemIndex: number;
+ partIndex: number;
+ jsonBytes: number;
+ imageUrlBytes: number;
+ dataUrl: boolean;
+ }>;
largestTools: Array<{ index: number; name: string; jsonBytes: number }>;
}
@@ -23,6 +32,7 @@ export function summarizeCodexRequestSize(
body: ResponsesRequest,
bodyJson = JSON.stringify(body),
): CodexRequestSizeSummary {
+ const imageParts = inputImageParts(body.input);
return {
bodyJsonBytes: byteLength(bodyJson),
instructionsBytes: stringBytes(body.instructions),
@@ -34,9 +44,14 @@ export function summarizeCodexRequestSize(
clientMetadataJsonBytes: jsonBytes(body.client_metadata),
inputItemCount: body.input.length,
toolCount: body.tools?.length ?? 0,
+ inputImagePartCount: imageParts.length,
+ inputImageDataUrlBytes: imageParts
+ .filter((part) => part.image_url.startsWith("data:"))
+ .reduce((sum, part) => sum + byteLength(part.image_url), 0),
inputTypeCounts: countBy(body.input, (item) => item.type),
roleCounts: countBy(body.input, (item) => ("role" in item ? item.role : undefined)),
largestInputItems: largestInputItems(body.input),
+ largestInputImages: largestInputImages(imageParts),
largestTools: largestTools(body.tools),
};
}
@@ -53,6 +68,28 @@ function largestInputItems(input: ResponsesInputItem[]) {
.slice(0, 5);
}
+function largestInputImages(imageParts: ReturnType<typeof inputImageParts>) {
+ return imageParts
+ .map(({ itemIndex, partIndex, image_url }) => ({
+ itemIndex,
+ partIndex,
+ jsonBytes: jsonBytes({ type: "input_image", image_url }),
+ imageUrlBytes: byteLength(image_url),
+ dataUrl: image_url.startsWith("data:"),
+ }))
+ .sort((a, b) => b.imageUrlBytes - a.imageUrlBytes)
+ .slice(0, 5);
+}
+
+function inputImageParts(input: ResponsesInputItem[]) {
+ return input.flatMap((item, itemIndex) => {
+ if (item.type !== "message") return [];
+ return item.content.flatMap((part, partIndex) =>
+ part.type === "input_image" ? [{ itemIndex, partIndex, image_url: part.image_url }] : [],
+ );
+ });
+}
+
function largestTools(tools: ResponsesRequest["tools"]) {
return (tools ?? [])
.map((tool, index) => ({ index, name: tool.name, jsonBytes: jsonBytes(tool) }))
diff --git a/src/server.test.ts b/src/server.test.ts
index 8f99621..a1dd99b 100644
--- a/src/server.test.ts
+++ b/src/server.test.ts
@@ -1,6 +1,6 @@
import { afterEach, describe, expect, it } from "bun:test";
import { loadConfig } from "./config.ts";
-import { startServer } from "./server.ts";
+import { startServer, normalizeIncomingModel } from "./server.ts";
const servers: Array<{ stop: () => void }> = [];
@@ -20,6 +20,14 @@ function countTokens(port: number, model: string, sessionId?: string): Promise<R
});
}
+describe("normalizeIncomingModel", () => {
+ it("removes Claude Code local context hints without changing the model id otherwise", () => {
+ expect(normalizeIncomingModel("gpt-5.5[1m]")).toBe("gpt-5.5");
+ expect(normalizeIncomingModel("gpt-5.4-fast[1m]")).toBe("gpt-5.4-fast");
+ expect(normalizeIncomingModel("kimi-for-coding")).toBe("kimi-for-coding");
+ });
+});
+
describe("server session-aware alias routing", () => {
it("routes aliases to the concrete provider used earlier in the session", async () => {
loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true });