cartethyia 2.5.3 → 2.5.4

package/src/persistence/stores/telemetry-store.ts

@@ -1,214 +1,237 @@
-import { appendFile, mkdir, readdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { sql } from "drizzle-orm";
-import { affectedRows, currentTimestamp, laterOf } from "../dialect";
-import type { CartethyiaDatabase } from "../db-handle";
-import {
-  telemetryEvents,
-  telemetryPayloads,
-  telemetryUsageTotals,
-  type TelemetryUsageIdentityType,
-} from "../schema";
-import { isGatewayError } from "../../observability/telemetry-status";
-
-interface UsageTotalDelta {
-  readonly tenantId: string;
-  readonly identityType: TelemetryUsageIdentityType;
-  readonly entityId: string;
-  requests: number;
-  errors: number;
-  inputTokens: number;
-  outputTokens: number;
-}
-
-function addUsageDelta(
-  deltas: Map<string, UsageTotalDelta>,
-  row: typeof telemetryEvents.$inferInsert,
-  identityType: TelemetryUsageIdentityType,
-  entityId: string | null | undefined,
-): void {
-  if (entityId == null) return;
-  const key = `${row.tenantId}\0${identityType}\0${entityId}`;
-  let delta = deltas.get(key);
-  if (!delta) {
-    delta = {
-      tenantId: row.tenantId,
-      identityType,
-      entityId,
-      requests: 0,
-      errors: 0,
-      inputTokens: 0,
-      outputTokens: 0,
-    };
-    deltas.set(key, delta);
-  }
-  delta.requests += 1;
-  // Same definition as every read-side error count, including the HTTP-status
-  // exclusions (404/499/503/504): this rollup is durable, so a request counted here
-  // stays counted after its raw row is pruned and cannot be corrected later.
-  if (isGatewayError(row.status, row.httpStatus)) delta.errors += 1;
-  delta.inputTokens += row.inputTokens ?? 0;
-  delta.outputTokens += row.outputTokens ?? 0;
-}
-
-function aggregateUsage(rows: readonly (typeof telemetryEvents.$inferInsert)[]) {
-  const deltas = new Map<string, UsageTotalDelta>();
-  for (const row of rows) {
-    addUsageDelta(deltas, row, "account", row.accountId);
-    addUsageDelta(deltas, row, "api_key", row.apiKeyId);
-  }
-  return [...deltas.values()];
-}
-
-/**
- * Database boundary for durable telemetry writes and bounded retention cleanup.
- * The observability buffer owns queueing and retry policy; this store owns table
- * operations, lifetime aggregates, and retention.
- */
-
-const EVENT_DIR = "./data/telemetry-events";
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-/**
- * Deletes hourly event files whose whole hour is older than the retention
- * cutoff. The current hour's file is never touched: it is still being appended.
- */
-async function pruneEventFiles(before: Date): Promise<void> {
-  const files = await readdir(EVENT_DIR).catch(() => [] as string[]);
-  const cutoff = before.toISOString().slice(0, 13).replaceAll(":", "-");
-  for (const file of files) {
-    if (!file.endsWith(".jsonl")) continue;
-    const hour = file.slice(0, 13);
-    if (hour < cutoff) await rm(join(EVENT_DIR, file), { force: true });
-  }
-}
-
-/** Appends one JSON line per event. One file per hour, so retention is a file delete. */
-async function appendEvents(rows: readonly (typeof telemetryEvents.$inferInsert)[]): Promise<void> {
-  await mkdir(EVENT_DIR, { recursive: true });
-  const file = join(EVENT_DIR, new Date().toISOString().slice(0, 13).replaceAll(":", "-") + ".jsonl");
-  const newline = String.fromCharCode(10);
-  const body = rows.map((row) => JSON.stringify(row)).join(newline) + newline;
-  await appendFile(file, body, "utf8");
-}
-
-export class DrizzleTelemetryStore {
-  constructor(private readonly db: CartethyiaDatabase) {}
-
-  /** Inserts events and their durable identity aggregates atomically. */
-  async insertEvents(rows: Array<typeof telemetryEvents.$inferInsert>): Promise<void> {
-    if (rows.length === 0) return;
-    // The file accepts anything, so a malformed row would be written and then
-    // retried forever without ever failing. Rejecting it here keeps the buffer's
-    // drop-and-count contract: one bad row fails the batch, once.
-    for (const row of rows) {
-      if (!UUID_RE.test(row.tenantId)) {
-        throw new Error("telemetry event rejected: tenantId is not a uuid");
-      }
-    }
-    const deltas = aggregateUsage(rows);
-    // The per-request row goes to an append-only file, not to Postgres. The
-    // database keeps only the durable aggregate below, so a request never
-    // adds a row to the largest table. Readers of recent requests read the
-    // file; readers of long-term totals read the aggregate.
-    await this.db.transaction(async (tx) => {
-      if (deltas.length === 0) return;
-      const now = new Date();
-      await tx
-        .insert(telemetryUsageTotals)
-        .values(deltas.map((delta) => ({ ...delta, lastUsedAt: now })))
-        .onConflictDoUpdate({
-          target: [
-            telemetryUsageTotals.tenantId,
-            telemetryUsageTotals.identityType,
-            telemetryUsageTotals.entityId,
-          ],
-          set: {
-            requests: sql`${telemetryUsageTotals.requests} + excluded.requests`,
-            errors: sql`${telemetryUsageTotals.errors} + excluded.errors`,
-            inputTokens: sql`${telemetryUsageTotals.inputTokens} + excluded.input_tokens`,
-            outputTokens: sql`${telemetryUsageTotals.outputTokens} + excluded.output_tokens`,
-            lastUsedAt: laterOf(sql`${telemetryUsageTotals.lastUsedAt}`, sql`excluded.last_used_at`),
-            updatedAt: currentTimestamp(),
-          },
-        });
-    });
-    // After the aggregate commits, so a rejected batch is retried once, not
-    // appended once per attempt. The file is the record of requests whose
-    // totals were actually counted.
-    await appendEvents(rows);
-  }
-
-  /** Inserts one redacted payload and returns its generated identity. */
-  async insertPayload(
-    row: typeof telemetryPayloads.$inferInsert,
-  ): Promise<{ id: string; expiresAt: Date }> {
-    const [inserted] = await this.db
-      .insert(telemetryPayloads)
-      .values(row)
-      .returning({ id: telemetryPayloads.id, expiresAt: telemetryPayloads.expiresAt });
-    if (!inserted) throw new Error("payload capture insert returned no row");
-    return inserted;
-  }
-
-  /**
-   * Deletes at most one bounded batch of expired payloads in a single
-   * statement, so concurrent sweeps atomically claim disjoint rows and the
-   * returned count matches the rows actually deleted.
-   */
-  async deleteExpiredPayloads(batchSize = 5000, before = new Date()): Promise<number> {
-    const result = await this.db.execute(sql`
-      DELETE FROM ${telemetryPayloads}
-      WHERE ${telemetryPayloads.id} IN (
-        SELECT ${telemetryPayloads.id} FROM ${telemetryPayloads}
-        WHERE ${telemetryPayloads.expiresAt} < ${before}
-        ORDER BY ${telemetryPayloads.expiresAt}
-        LIMIT ${batchSize}
-      )
-    `);
-    return affectedRows(result);
-  }
-
-  /**
-   * Deletes at most one bounded batch of aged events in a single statement, so
-   * concurrent sweeps atomically claim disjoint rows and the returned count
-   * matches the rows actually deleted. Ordered by `created_at`, which
-   * `idx_telemetry_created_at` backs.
-   */
-  async deleteExpiredEvents(batchSize = 5000, before: Date): Promise<number> {
-    const result = await this.db.execute(sql`
-      DELETE FROM ${telemetryEvents}
-      WHERE ${telemetryEvents.id} IN (
-        SELECT ${telemetryEvents.id} FROM ${telemetryEvents}
-        WHERE ${telemetryEvents.createdAt} < ${before}
-        ORDER BY ${telemetryEvents.createdAt}
-        LIMIT ${batchSize}
-      )
-    `);
-    return affectedRows(result);
-  }
-
-  /**
-   * Deletes telemetry older than the supplied cutoff. Payloads follow their
-   * `expires_at` contract (15 minutes per row) rather than capture time.
-   *
-   * Events are pruned in bounded batches rather than one `DELETE`, because
-   * `telemetry_events` is the highest-volume table and a single statement
-   * covering every aged row grows without limit: it holds locks and WAL for the
-   * whole sweep, and on a deployment that has run for months it can exceed the
-   * pool's `statement_timeout` and be cancelled, so the sweep never converges
-   * and retention silently stops working. Each batch commits independently, so
-   * progress survives a cancel or a restart. The loop is bounded so one pass
-   * cannot run unbounded — a backlog drains over successive sweeps — mirroring
-   * the payload sweeper's `cleanupExpired`.
-   */
-  async pruneTelemetry(before: Date): Promise<void> {
-    await pruneEventFiles(before);
-    const MAX_BATCHES_PER_SWEEP = 40;
-    for (let batch = 0; batch < MAX_BATCHES_PER_SWEEP; batch += 1) {
-      const deleted = await this.deleteExpiredEvents(5000, before);
-      if (deleted < 5000) break;
-    }
-    await this.deleteExpiredPayloads(5000, before);
-  }
-}
+import { appendFile, mkdir, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { sql } from "drizzle-orm";
+import { affectedRows, currentTimestamp, laterOf } from "../dialect";
+import type { CartethyiaDatabase } from "../db-handle";
+import {
+  telemetryEvents,
+  telemetryPayloads,
+  telemetryUsageTotals,
+  type TelemetryUsageIdentityType,
+} from "../schema";
+import { isGatewayError } from "../../observability/telemetry-status";
+import { TELEMETRY_EVENT_DIR } from "../../observability/event-log";
+import { dayEventFileName, utcDay } from "../../observability/event-day-index";
+
+interface UsageTotalDelta {
+  readonly tenantId: string;
+  readonly identityType: TelemetryUsageIdentityType;
+  readonly entityId: string;
+  requests: number;
+  errors: number;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+function addUsageDelta(
+  deltas: Map<string, UsageTotalDelta>,
+  row: typeof telemetryEvents.$inferInsert,
+  identityType: TelemetryUsageIdentityType,
+  entityId: string | null | undefined,
+): void {
+  if (entityId == null) return;
+  const key = `${row.tenantId}\0${identityType}\0${entityId}`;
+  let delta = deltas.get(key);
+  if (!delta) {
+    delta = {
+      tenantId: row.tenantId,
+      identityType,
+      entityId,
+      requests: 0,
+      errors: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+    };
+    deltas.set(key, delta);
+  }
+  delta.requests += 1;
+  // Same definition as every read-side error count, including the HTTP-status
+  // exclusions (404/499/503/504): this rollup is durable, so a request counted here
+  // stays counted after its raw row is pruned and cannot be corrected later.
+  if (isGatewayError(row.status, row.httpStatus)) delta.errors += 1;
+  delta.inputTokens += row.inputTokens ?? 0;
+  delta.outputTokens += row.outputTokens ?? 0;
+}
+
+function aggregateUsage(rows: readonly (typeof telemetryEvents.$inferInsert)[]) {
+  const deltas = new Map<string, UsageTotalDelta>();
+  for (const row of rows) {
+    addUsageDelta(deltas, row, "account", row.accountId);
+    addUsageDelta(deltas, row, "api_key", row.apiKeyId);
+  }
+  return [...deltas.values()];
+}
+
+/**
+ * Database boundary for durable telemetry writes and bounded retention cleanup.
+ * The observability buffer owns queueing and retry policy; this store owns table
+ * operations, lifetime aggregates, and retention.
+ */
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Deletes whole days past the retention cutoff: the event file and its index
+ * together.
+ *
+ * The day is the retention unit now, so both go at once. Removing one without
+ * the other is the failure this avoids — an index with no events reports totals
+ * for requests that no longer exist, and events with no index are invisible to
+ * every usage read.
+ *
+ * The cutoff is a whole day, so today's file — still being appended to — is
+ * never a candidate. It used to compare filenames hour by hour, which for a day
+ * file compared the `.events` suffix against an hour stamp and could drop the
+ * open file.
+ */
+async function pruneEventFiles(before: Date): Promise<void> {
+  const files = await readdir(TELEMETRY_EVENT_DIR).catch(() => [] as string[]);
+  const cutoffDay = before.toISOString().slice(0, 10);
+  for (const file of files) {
+    const day = file.slice(0, 10);
+    if (day.length !== 10 || day >= cutoffDay) continue;
+    if (!file.endsWith(".events.jsonl") && !file.endsWith(".index.json")) continue;
+    await rm(join(TELEMETRY_EVENT_DIR, file), { force: true });
+  }
+}
+
+/**
+ * Appends one JSON line per event to the day's event file.
+ *
+ * One file per UTC day, appended to and never rewritten while the day is open.
+ * It used to be one file per `windowMinutes` window — 96 a day at the default —
+ * which the reader then had to find, open and parse one by one on every usage
+ * query. Which of those files was still being written had to be inferred from
+ * the name, and that inference is what let the open one be deleted mid-write.
+ *
+ * A single growing file has no such ambiguity, and the day index tracks how much
+ * of it has been counted by byte offset.
+ */
+async function appendEvents(rows: readonly (typeof telemetryEvents.$inferInsert)[]): Promise<void> {
+  await mkdir(TELEMETRY_EVENT_DIR, { recursive: true });
+  const file = join(TELEMETRY_EVENT_DIR, dayEventFileName(utcDay(new Date())));
+  const newline = String.fromCharCode(10);
+  const body = rows.map((row) => JSON.stringify(row)).join(newline) + newline;
+  await appendFile(file, body, "utf8");
+}
+
+export class DrizzleTelemetryStore {
+  constructor(private readonly db: CartethyiaDatabase) {}
+
+  /** Inserts events and their durable identity aggregates atomically. */
+  async insertEvents(rows: Array<typeof telemetryEvents.$inferInsert>): Promise<void> {
+    if (rows.length === 0) return;
+    // The file accepts anything, so a malformed row would be written and then
+    // retried forever without ever failing. Rejecting it here keeps the buffer's
+    // drop-and-count contract: one bad row fails the batch, once.
+    for (const row of rows) {
+      if (!UUID_RE.test(row.tenantId)) {
+        throw new Error("telemetry event rejected: tenantId is not a uuid");
+      }
+    }
+    const deltas = aggregateUsage(rows);
+    // The per-request row goes to an append-only file, not to Postgres. The
+    // database keeps only the durable aggregate below, so a request never
+    // adds a row to the largest table. Readers of recent requests read the
+    // file; readers of long-term totals read the aggregate.
+    await this.db.transaction(async (tx) => {
+      if (deltas.length === 0) return;
+      const now = new Date();
+      await tx
+        .insert(telemetryUsageTotals)
+        .values(deltas.map((delta) => ({ ...delta, lastUsedAt: now })))
+        .onConflictDoUpdate({
+          target: [
+            telemetryUsageTotals.tenantId,
+            telemetryUsageTotals.identityType,
+            telemetryUsageTotals.entityId,
+          ],
+          set: {
+            requests: sql`${telemetryUsageTotals.requests} + excluded.requests`,
+            errors: sql`${telemetryUsageTotals.errors} + excluded.errors`,
+            inputTokens: sql`${telemetryUsageTotals.inputTokens} + excluded.input_tokens`,
+            outputTokens: sql`${telemetryUsageTotals.outputTokens} + excluded.output_tokens`,
+            lastUsedAt: laterOf(sql`${telemetryUsageTotals.lastUsedAt}`, sql`excluded.last_used_at`),
+            updatedAt: currentTimestamp(),
+          },
+        });
+    });
+    // After the aggregate commits, so a rejected batch is retried once, not
+    // appended once per attempt. The file is the record of requests whose
+    // totals were actually counted.
+    await appendEvents(rows);
+  }
+
+  /** Inserts one redacted payload and returns its generated identity. */
+  async insertPayload(
+    row: typeof telemetryPayloads.$inferInsert,
+  ): Promise<{ id: string; expiresAt: Date }> {
+    const [inserted] = await this.db
+      .insert(telemetryPayloads)
+      .values(row)
+      .returning({ id: telemetryPayloads.id, expiresAt: telemetryPayloads.expiresAt });
+    if (!inserted) throw new Error("payload capture insert returned no row");
+    return inserted;
+  }
+
+  /**
+   * Deletes at most one bounded batch of expired payloads in a single
+   * statement, so concurrent sweeps atomically claim disjoint rows and the
+   * returned count matches the rows actually deleted.
+   */
+  async deleteExpiredPayloads(batchSize = 5000, before = new Date()): Promise<number> {
+    const result = await this.db.execute(sql`
+      DELETE FROM ${telemetryPayloads}
+      WHERE ${telemetryPayloads.id} IN (
+        SELECT ${telemetryPayloads.id} FROM ${telemetryPayloads}
+        WHERE ${telemetryPayloads.expiresAt} < ${before}
+        ORDER BY ${telemetryPayloads.expiresAt}
+        LIMIT ${batchSize}
+      )
+    `);
+    return affectedRows(result);
+  }
+
+  /**
+   * Deletes at most one bounded batch of aged events in a single statement, so
+   * concurrent sweeps atomically claim disjoint rows and the returned count
+   * matches the rows actually deleted. Ordered by `created_at`, which
+   * `idx_telemetry_created_at` backs.
+   */
+  async deleteExpiredEvents(batchSize = 5000, before: Date): Promise<number> {
+    const result = await this.db.execute(sql`
+      DELETE FROM ${telemetryEvents}
+      WHERE ${telemetryEvents.id} IN (
+        SELECT ${telemetryEvents.id} FROM ${telemetryEvents}
+        WHERE ${telemetryEvents.createdAt} < ${before}
+        ORDER BY ${telemetryEvents.createdAt}
+        LIMIT ${batchSize}
+      )
+    `);
+    return affectedRows(result);
+  }
+
+  /**
+   * Deletes telemetry older than the supplied cutoff. Payloads follow their
+   * `expires_at` contract (15 minutes per row) rather than capture time.
+   *
+   * Events are pruned in bounded batches rather than one `DELETE`, because
+   * `telemetry_events` is the highest-volume table and a single statement
+   * covering every aged row grows without limit: it holds locks and WAL for the
+   * whole sweep, and on a deployment that has run for months it can exceed the
+   * pool's `statement_timeout` and be cancelled, so the sweep never converges
+   * and retention silently stops working. Each batch commits independently, so
+   * progress survives a cancel or a restart. The loop is bounded so one pass
+   * cannot run unbounded — a backlog drains over successive sweeps — mirroring
+   * the payload sweeper's `cleanupExpired`.
+   */
+  async pruneTelemetry(before: Date): Promise<void> {
+    await pruneEventFiles(before);
+    const MAX_BATCHES_PER_SWEEP = 40;
+    for (let batch = 0; batch < MAX_BATCHES_PER_SWEEP; batch += 1) {
+      const deleted = await this.deleteExpiredEvents(5000, before);
+      if (deleted < 5000) break;
+    }
+    await this.deleteExpiredPayloads(5000, before);
+  }
+}

package/src/protocol/codecs.ts

@@ -485,13 +485,12 @@ export function endpointUrl(
   return url;
 }
 
-/** Session-scoped state (turn-state / models-etag / session identity). */
+/** Session-scoped state (turn-state / session identity). */
 export interface CodexSessionState {
   sessionId: string;
   threadId: string;
   windowId: string;
   turnState?: string;
-  modelsEtag?: string;
   turnStartedAtUnixMs?: number;
 }
 

package/src/protocol/image-clamp.ts

@@ -56,6 +56,17 @@ export interface ImageClampInput {
   readonly height?: number;
   /** Images in the whole request, including this one. Defaults to this one alone. */
   readonly imageCount?: number;
+  /**
+   * Per-tenant byte ceiling override, in bytes.
+   *
+   * Absent means the deployment default (`IMAGE_CLAMP_MAX_BYTES`). A tenant
+   * raising this asserts that its upstreams accept larger attachments: the
+   * clamp exists so an oversized block cannot poison every retry and every
+   * replayed turn with a request the upstream rejects whole. An override
+   * promising more than the provider accepts turns that protection back off,
+   * which is why it is a deliberate per-tenant choice and not a global knob.
+   */
+  readonly maxBytesOverride?: number;
 }
 
 export interface ImageClampDecision {
@@ -108,7 +119,14 @@ export function imageClampMaxDimensionPx(imageCount: number): number {
 export function clampImage(input: ImageClampInput): ImageClampDecision {
   const imageCount = input.imageCount ?? 1;
   const maxDimensionPx = imageClampMaxDimensionPx(imageCount);
-  const maxBytes = IMAGE_CLAMP_MAX_BYTES;
+  // A non-finite or non-positive override is not a ceiling, it is a mistake:
+  // falling back to the default keeps a malformed preference from silently
+  // admitting (or rejecting) every image.
+  const override = input.maxBytesOverride;
+  const maxBytes =
+    typeof override === "number" && Number.isFinite(override) && override > 0
+      ? Math.floor(override)
+      : IMAGE_CLAMP_MAX_BYTES;
   const longestEdge = Math.max(input.width ?? 0, input.height ?? 0);
   if (longestEdge > maxDimensionPx) {
     return {

package/src/protocol/registry.ts

@@ -8,6 +8,11 @@ export interface CodecContext {
   readonly maxOutputTokens?: number;
   readonly promptCacheKey?: string;
   readonly signal?: AbortSignal;
+  /**
+   * Per-tenant ceiling for one inline attachment, in bytes. Absent means the
+   * deployment default; only wire encoders that clamp images read it.
+   */
+  readonly maxBytesOverride?: number;
 }
 
 /**
@@ -138,6 +143,9 @@ export async function encodeWireRequest(
   if (codec.family === "messages") {
     return codec.encodeWireRequest(request, {
       ...(context?.isOAuth === undefined ? {} : { isOAuth: context.isOAuth }),
+      ...(context?.maxBytesOverride === undefined
+        ? {}
+        : { maxBytesOverride: context.maxBytesOverride }),
     });
   }
   if (codec.family === "chat") {

package/src/protocol/request/gemini.ts

@@ -147,6 +147,7 @@ function geminiMediaPart(part: {
 function toGeminiPart(
   part: CanonicalRequest["messages"][number]["content"][number],
   toolNames: ReadonlyMap<string, string>,
+  maxBytesOverride?: number,
 ): Record<string, unknown>[] {
   if (part.kind === "text") return [{ text: part.text }];
   if (part.kind === "reasoning") {
@@ -173,6 +174,7 @@ function toGeminiPart(
         // whose attachment silently vanished.
         const decision = clampImage({
           bytes: base64DecodedByteLength(split.data),
+          ...(maxBytesOverride === undefined ? {} : { maxBytesOverride }),
         });
         if (decision.action === "reject") {
           // Only the byte ceiling refuses a block. A `downscale` decision is
@@ -255,7 +257,10 @@ function parseJsonObject(value: string): Record<string, unknown> {
   }
 }
 
-export function buildGeminiPayload(request: CanonicalRequest): Record<string, unknown> {
+export function buildGeminiPayload(
+  request: CanonicalRequest,
+  options: { maxBytesOverride?: number } = {},
+): Record<string, unknown> {
   const systemParts: Array<{ text: string }> = [];
   const pushSystemText = (text: string): void => {
     if (!isClaudeBillingHeaderText(text)) systemParts.push({ text });
@@ -275,7 +280,9 @@ export function buildGeminiPayload(request: CanonicalRequest): Record<string, un
     .map((message) => {
       // Gemini roles: user or model (assistant -> model)
       const role = message.role === "assistant" ? "model" : message.role === "tool" ? "user" : "user";
-      const parts = message.content.flatMap((block) => toGeminiPart(block, toolNames));
+      const parts = message.content.flatMap((block) =>
+        toGeminiPart(block, toolNames, options.maxBytesOverride),
+      );
       return { role, parts: parts.length ? parts : [{ text: "" }] };
     });
   const payload: Record<string, unknown> = { contents };

package/src/protocol/request/messages.ts

@@ -121,6 +121,7 @@ function applyImageClamp(
   block: ClaudeWireObject,
   imageCount: number,
   payload: unknown,
+  maxBytesOverride?: number,
 ): ClaudeWireObject {
   const source = block["source"];
   const data = isRecord(source) ? source["data"] : undefined;
@@ -131,6 +132,7 @@ function applyImageClamp(
     ...(width === undefined ? {} : { width }),
     ...(height === undefined ? {} : { height }),
     imageCount,
+    ...(maxBytesOverride === undefined ? {} : { maxBytesOverride }),
   });
   if (decision.action === "pass") return block;
   log.warn(
@@ -281,6 +283,7 @@ function partToClaudeBlock(
     idMap: Map<string, string>;
     isOAuth: boolean;
     imageCount: number;
+    maxBytesOverride?: number;
   },
 ): ClaudeWireObject | undefined {
   switch (part.kind) {
@@ -291,6 +294,7 @@ function partToClaudeBlock(
         normalizeImageBlock(part.payload),
         ctx?.imageCount ?? 1,
         part.payload,
+        ctx?.maxBytesOverride,
       );
     case "file":
       return {
@@ -553,14 +557,22 @@ export function claudeFallbacksChain(
 
 export function canonicalToClaudeMessagesPayload(
   request: CanonicalRequest,
-  options: { isOAuth?: boolean } = {},
+  options: { isOAuth?: boolean; maxBytesOverride?: number } = {},
 ): ClaudeWireObject {
   const seen = new Map<string, number>();
   const idMap = new Map<string, string>();
   // The clamp's per-image ceiling depends on how many images the whole request
   // carries, so it is counted once over every part rather than per message.
   const imageCount = allParts(request).filter((part) => part.kind === "image").length;
-  const ctx = { seen, idMap, isOAuth: options.isOAuth ?? false, imageCount };
+  const ctx = {
+    seen,
+    idMap,
+    isOAuth: options.isOAuth ?? false,
+    imageCount,
+    ...(options.maxBytesOverride === undefined
+      ? {}
+      : { maxBytesOverride: options.maxBytesOverride }),
+  };
   const messages: ClaudeWireObject[] = [];
   // Anthropic accepts system content only at the top level. Chat `developer`
   // turns and Responses `instructions` have no `developer` role upstream, and

package/src/providers/adapters/compatible-adapter.ts

@@ -207,6 +207,9 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       ...(this.config.chat_token_limit_field === undefined
         ? {}
         : { chatTokenLimitField: this.config.chat_token_limit_field }),
+      ...(context.image_clamp_max_bytes === undefined
+        ? {}
+        : { maxBytesOverride: context.image_clamp_max_bytes }),
     });
     if (
       wireFamily !== "messages" &&