fix(image-generation): bound OpenAI-compatible image response reads

wangmiao0668000666 · wangmiao0668000666 · commit 2200e057486b · 2026-06-24T09:17:44.000+08:00
Route the success-path JSON body of `createOpenAiCompatibleImageGenerationProvider` through `readProviderJsonResponse` instead of `await response.json()` so a buggy or hostile image endpoint streaming an unbounded body cannot force the runtime to buffer the full payload before failing. Reuses the same 16 MiB capped reader as the binary and error paths in `provider-http-errors.ts`, matching the symmetric bound-stream work in #95218 (provider JSON), #95417 (Google prompt cache), #95418 (OpenRouter model scan), #95420 (OpenRouter model capabilities), and #95246 (live model catalog). Failure label is reused across `assertOkOrThrowHttpError` and `readProviderJsonResponse` so the bounded-reader overflow message and the HTTP error message stay aligned with the caller's `options.failureLabels`. Tests: route every mock through the bounded reader; new test asserts the overflow message format and that the release() path still runs.
diff --git a/scripts/repro/issue-96136-image-cap.mjs b/scripts/repro/issue-96136-image-cap.mjs
@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * Live repro for PR #96136 — proves the canonical 16 MiB provider-response
+ * cap on `readProviderJsonResponse` (a) accepts a valid 4-image
+ * OpenAI-compatible response under the cap and (b) rejects a hostile
+ * oversized response before OOM.
+ *
+ * Run: pnpm exec tsx scripts/repro/issue-96136-image-cap.mjs
+ *
+ * The script drives the production `readProviderJsonResponse` directly
+ * (no vitest mock) with two streaming bodies:
+ *   1. Valid: 4 PNG b64_json payloads at 1 MiB raw each, total ≈ 5.4 MiB
+ *      serialized → accepted, parsed payload returned.
+ *   2. Hostile: a 64 MiB streaming body → rejected with the canonical
+ *      "JSON response exceeds 16777216 bytes" error before the runtime
+ *      buffers the full body.
+ *
+ * A negative control shows the legacy raw `response.json()` on the
+ * same 64 MiB body buffers the full body and only fails on JSON parse,
+ * proving the bounded read is the right shape.
+ */
+import assert from "node:assert/strict";
+import { readProviderJsonResponse } from "../../src/agents/provider-http-errors.ts";
+
+const PROVIDER_JSON_RESPONSE_MAX_BYTES = 16 * 1024 * 1024; // 16 MiB
+
+function createStreamingJsonResponse({ totalBytes, chunkSize, contentType = "application/json" }) {
+  let written = 0;
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    pull(controller) {
+      if (written >= totalBytes) {
+        controller.close();
+        return;
+      }
+      const remaining = totalBytes - written;
+      const slice = Math.min(chunkSize, remaining);
+      controller.enqueue(encoder.encode("a".repeat(slice)));
+      written += slice;
+    },
+  });
+  return new Response(stream, { status: 200, headers: { "content-type": contentType } });
+}
+
+console.log("=== Reproduction for PR #96136 — image response cap policy ===");
+console.log(`PROVIDER_JSON_RESPONSE_MAX_BYTES = ${PROVIDER_JSON_RESPONSE_MAX_BYTES} bytes`);
+
+// 1. Valid 4-image response: 4 PNG b64_json at 1 MiB raw each.
+const ONE_PNG_B64_BYTES = Math.ceil((1024 * 1024) / 3) * 4; // ~1.4 MB
+const FOUR_PNG_B64_BYTES = ONE_PNG_B64_BYTES * 4;
+console.log(
+  `Valid envelope: 4 images x ${ONE_PNG_B64_BYTES} b64 bytes = ${FOUR_PNG_B64_BYTES} bytes (${(FOUR_PNG_B64_BYTES / 1024 / 1024).toFixed(2)} MiB)`,
+);
+assert.ok(
+  FOUR_PNG_B64_BYTES < PROVIDER_JSON_RESPONSE_MAX_BYTES,
+  `4-image envelope must fit under 16 MiB; got ${FOUR_PNG_B64_BYTES} bytes`,
+);
+const validBody = {
+  data: [
+    { b64_json: "a".repeat(ONE_PNG_B64_BYTES) },
+    { b64_json: "b".repeat(ONE_PNG_B64_BYTES) },
+    { b64_json: "c".repeat(ONE_PNG_B64_BYTES) },
+    { b64_json: "d".repeat(ONE_PNG_B64_BYTES) },
+  ],
+};
+const validJson = JSON.stringify(validBody);
+const validResponse = new Response(validJson, {
+  status: 200,
+  headers: { "content-type": "application/json" },
+});
+const validParsed = await readProviderJsonResponse(validResponse, "test image generation");
+assert.equal(
+  validParsed.data.length,
+  4,
+  `valid 4-image response must be accepted; got ${validParsed.data.length} images`,
+);
+console.log("PASS  valid 4-image response: accepted, 4 images parsed");
+
+// 2. Hostile oversized response: 64 MiB streaming body.
+const OVERSIZED_BYTES = 64 * 1024 * 1024;
+const oversized = createStreamingJsonResponse({
+  totalBytes: OVERSIZED_BYTES,
+  chunkSize: 1024 * 1024,
+});
+let hostileError = null;
+try {
+  await readProviderJsonResponse(oversized, "test image generation hostile");
+} catch (err) {
+  hostileError = err;
+}
+assert.ok(hostileError, "hostile response must throw");
+assert.match(
+  hostileError.message,
+  /JSON response exceeds 16777216 bytes/,
+  `hostile response must surface canonical overflow error; got: ${hostileError.message}`,
+);
+console.log(`PASS  hostile 64 MiB response: rejected with "${hostileError.message}"`);
+
+// 3. Negative control: raw `response.json()` on the same 64 MiB body
+//    buffers the full body before failing on JSON parse — proves the
+//    bounded read is the right shape (vs. an inert helper that
+//    silently truncates and then re-fails).
+const negativeBody = createStreamingJsonResponse({
+  totalBytes: OVERSIZED_BYTES,
+  chunkSize: 1024 * 1024,
+});
+let negativeError = null;
+try {
+  await negativeBody.json();
+} catch (err) {
+  negativeError = err;
+}
+assert.ok(negativeError, "raw json() must also throw on 64 MiB non-JSON body");
+assert.doesNotMatch(
+  negativeError.message,
+  /JSON response exceeds 16777216 bytes/,
+  "raw json() must NOT surface the bounded-reader error (it doesn't go through the helper)",
+);
+console.log(
+  `PASS  negative control: raw response.json() on 64 MiB body failed with "${negativeError.constructor.name}" (no bounded-reader wrapping)`,
+);
+
+console.log("=== All repro assertions passed ===");
diff --git a/src/image-generation/openai-compatible-image-provider.test.ts b/src/image-generation/openai-compatible-image-provider.test.ts
@@ -11,6 +11,7 @@ const {
   isProviderApiKeyConfiguredMock,
   postJsonRequestMock,
   postMultipartRequestMock,
+  readProviderJsonResponseMock,
   resolveApiKeyForProviderMock,
   resolveProviderHttpRequestConfigMock,
   resolveProviderOperationTimeoutMsMock,
@@ -24,6 +25,7 @@ const {
   isProviderApiKeyConfiguredMock: vi.fn(() => true),
   postJsonRequestMock: vi.fn(),
   postMultipartRequestMock: vi.fn(),
+  readProviderJsonResponseMock: vi.fn(),
   resolveApiKeyForProviderMock: vi.fn(async () => ({ apiKey: "provider-key" })),
   resolveProviderHttpRequestConfigMock: vi.fn((params: Record<string, unknown>) => {
     const request =
@@ -56,6 +58,7 @@ vi.mock("openclaw/plugin-sdk/provider-http", () => ({
   createProviderOperationDeadline: createProviderOperationDeadlineMock,
   postJsonRequest: postJsonRequestMock,
   postMultipartRequest: postMultipartRequestMock,
+  readProviderJsonResponse: readProviderJsonResponseMock,
   resolveProviderHttpRequestConfig: resolveProviderHttpRequestConfigMock,
   resolveProviderOperationTimeoutMs: resolveProviderOperationTimeoutMsMock,
   sanitizeConfiguredModelProviderRequest: sanitizeConfiguredModelProviderRequestMock,
@@ -138,8 +141,10 @@ function mockGeneratedResponse() {
       },
     ],
   };
-  postJsonRequestMock.mockResolvedValue({ response: { json: async () => payload }, release });
-  postMultipartRequestMock.mockResolvedValue({ response: { json: async () => payload }, release });
+  const response = {} as Response;
+  postJsonRequestMock.mockResolvedValue({ response, release });
+  postMultipartRequestMock.mockResolvedValue({ response, release });
+  readProviderJsonResponseMock.mockResolvedValue(payload);
   return release;
 }
 
@@ -150,6 +155,7 @@ describe("OpenAI-compatible image provider helper", () => {
     isProviderApiKeyConfiguredMock.mockClear();
     postJsonRequestMock.mockReset();
     postMultipartRequestMock.mockReset();
+    readProviderJsonResponseMock.mockReset();
     resolveApiKeyForProviderMock.mockReset();
     resolveApiKeyForProviderMock.mockResolvedValue({ apiKey: "provider-key" });
     resolveProviderHttpRequestConfigMock.mockClear();
@@ -250,9 +256,10 @@ describe("OpenAI-compatible image provider helper", () => {
 
   it("honors default operation timeouts and empty-response errors", async () => {
     postJsonRequestMock.mockResolvedValue({
-      response: { json: async () => ({ data: [] }) },
+      response: {} as Response,
       release: vi.fn(async () => {}),
     });
+    readProviderJsonResponseMock.mockResolvedValueOnce({ data: [] });
     const provider = createProvider({
       defaultTimeoutMs: 60_000,
       emptyResponseError: "Sample response missing image data",
@@ -282,9 +289,10 @@ describe("OpenAI-compatible image provider helper", () => {
 
   it("wraps malformed successful image responses with provider-owned errors", async () => {
     postJsonRequestMock.mockResolvedValue({
-      response: { json: async () => ({ data: { b64_json: "not-an-array" } }) },
+      response: {} as Response,
       release: vi.fn(async () => {}),
     });
+    readProviderJsonResponseMock.mockResolvedValueOnce({ data: { b64_json: "not-an-array" } });
     const provider = createProvider();
 
     await expect(
@@ -296,4 +304,90 @@ describe("OpenAI-compatible image provider helper", () => {
       }),
     ).rejects.toThrow("Sample image generation response malformed");
   });
+
+  it("routes the success body through the bounded provider-json reader", async () => {
+    const release = mockGeneratedResponse();
+    const provider = createProvider();
+
+    await provider.generateImage({
+      provider: "sample",
+      model: "sample-image",
+      prompt: "draw a square",
+      cfg: {} as never,
+    } as never);
+
+    expect(readProviderJsonResponseMock).toHaveBeenCalledTimes(1);
+    const [responseArg, labelArg] = readProviderJsonResponseMock.mock.calls[0] as [
+      Response,
+      string,
+    ];
+    expect(responseArg).toBeDefined();
+    expect(labelArg).toBe("Sample image generation failed");
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("surfaces the bounded-reader error verbatim when the body exceeds the cap", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {} as Response,
+      release,
+    });
+    readProviderJsonResponseMock.mockRejectedValueOnce(
+      new Error("Sample image generation failed: JSON response exceeds 16777216 bytes"),
+    );
+    const provider = createProvider();
+
+    await expect(
+      provider.generateImage({
+        provider: "sample",
+        model: "sample-image",
+        prompt: "oversized",
+        cfg: {} as never,
+      } as never),
+    ).rejects.toThrow(/JSON response exceeds 16777216 bytes/);
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("accepts a valid multi-image response under the cap (4x 1024x1024 b64_json ≈ 5.5 MB)", async () => {
+    // Lock the contract: the canonical 16 MiB cap is the generic OpenClaw
+    // provider-response cap (same as #95218). For the supported
+    // OpenAI-compatible image response envelope (maxCount: 4 at 1024x1024
+    // PNG b64_json), the serialized JSON body is well under the cap, so
+    // the bounded reader accepts it and the runtime returns the images.
+    //
+    // PNG raw ~ 1 MB per 1024x1024 image (compressed); b64 inflates by
+    // 4/3, so 4 images ≈ 5.4 MB serialized b64. Wrapped in the OpenAI
+    // response envelope ({"data":[...]} + per-image metadata), the total
+    // is comfortably under 16 MiB. See scripts/repro/issue-96136-image-cap
+    // .mjs for the end-to-end proof with a real streaming harness.
+    const ONE_1024_PNG_B64_BYTES = Math.ceil((1024 * 1024) / 3) * 4;
+    const FOUR_1024_PNG_B64_BYTES = ONE_1024_PNG_B64_BYTES * 4;
+    expect(FOUR_1024_PNG_B64_BYTES).toBeLessThan(16 * 1024 * 1024);
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {} as Response,
+      release,
+    });
+    readProviderJsonResponseMock.mockResolvedValueOnce({
+      data: [
+        { b64_json: "a".repeat(ONE_1024_PNG_B64_BYTES) },
+        { b64_json: "b".repeat(ONE_1024_PNG_B64_BYTES) },
+        { b64_json: "c".repeat(ONE_1024_PNG_B64_BYTES) },
+        { b64_json: "d".repeat(ONE_1024_PNG_B64_BYTES) },
+      ],
+    });
+    const provider = createProvider();
+
+    const result = await provider.generateImage({
+      provider: "sample",
+      model: "sample-image",
+      prompt: "draw a square",
+      count: 4,
+      size: "1024x1024",
+      cfg: {} as never,
+    } as never);
+
+    expect(result.images).toHaveLength(4);
+    expect(release).toHaveBeenCalledOnce();
+  });
 });
diff --git a/src/image-generation/openai-compatible-image-provider.ts b/src/image-generation/openai-compatible-image-provider.ts
@@ -7,6 +7,7 @@ import {
   createProviderOperationDeadline,
   postJsonRequest,
   postMultipartRequest,
+  readProviderJsonResponse,
   resolveProviderHttpRequestConfig,
   resolveProviderOperationTimeoutMs,
   sanitizeConfiguredModelProviderRequest,
@@ -263,19 +264,21 @@ export function createOpenAiCompatibleImageGenerationProvider(
 
       const { response, release } = await request;
       try {
-        await assertOkOrThrowHttpError(
-          response,
+        const failureLabel =
           mode === "edit"
             ? (options.failureLabels?.edit ?? `${options.label} image edit failed`)
-            : (options.failureLabels?.generate ?? `${options.label} image generation failed`),
+            : (options.failureLabels?.generate ?? `${options.label} image generation failed`);
+        await assertOkOrThrowHttpError(response, failureLabel);
+        const images = parseOpenAiCompatibleImageResponse(
+          await readProviderJsonResponse<unknown>(response, failureLabel),
+          {
+            ...options.response,
+            malformedResponseError:
+              mode === "edit"
+                ? `${options.label} image edit response malformed`
+                : `${options.label} image generation response malformed`,
+          },
         );
-        const images = parseOpenAiCompatibleImageResponse(await response.json(), {
-          ...options.response,
-          malformedResponseError:
-            mode === "edit"
-              ? `${options.label} image edit response malformed`
-              : `${options.label} image generation response malformed`,
-        });
         if (images.length === 0) {
           throw new Error(
             options.emptyResponseError ??
