Reject blank full-page background captures

Author: esokullu

src/chrome/src/agent/agent.js

@@ -777,19 +777,42 @@ export class Agent extends LoopDetector {
     }
   }
 
+  async _captureFullPageWithBlankRetry(tabId, capturePolicy) {
+    const probe = await this._captureViewportProbe(tabId);
+    const captureOnce = async () => {
+      const capture = await this._withIndicatorsHidden(tabId, () =>
+        cdpClient.captureFullPageScreenshot(tabId, capturePolicy)
+      );
+      const imageData = typeof capture === 'string' ? capture : capture?.data;
+      if (!imageData) return null;
+      return {
+        dataUrl: `data:image/png;base64,${imageData}`,
+        capture,
+      };
+    };
+    return this._retryBlankScreenshotCapture(
+      await captureOnce(),
+      captureOnce,
+      { probe },
+    );
+  }
+
   async captureFullPageScreenshotForUser(tabId) {
     if (!tabId) return { ok: false, error: 'No tab ID' };
     try {
       const capturePolicy = await this._getFullPageCapturePolicy(tabId);
       await cdpClient.attach(tabId);
       await this._preparePageForCapture(tabId);
-      const capture = await this._withIndicatorsHidden(tabId, () =>
-        cdpClient.captureFullPageScreenshot(tabId, capturePolicy)
-      );
-      const imageData = typeof capture === 'string' ? capture : capture?.data;
+      const captured = await this._captureFullPageWithBlankRetry(tabId, capturePolicy);
+      const capture = captured?.capture;
       const warning = typeof capture === 'object' ? capture?.warning || null : null;
-      if (!imageData) return { ok: false, error: 'Full-page screenshot returned no image data' };
-      return { ok: true, dataUrl: `data:image/png;base64,${imageData}`, warning };
+      if (!captured?.dataUrl) {
+        return { ok: false, error: 'Full-page screenshot returned no image data' };
+      }
+      if (captured?.blankFrameRetry?.finalBlank) {
+        return { ok: false, error: 'Background full-page screenshot remained blank after retries' };
+      }
+      return { ok: true, dataUrl: captured.dataUrl, warning };
     } catch (e) {
       return { ok: false, error: e?.message || String(e) };
     }
@@ -15051,14 +15074,15 @@ Rules: no prose intro, no conclusion, no "this screenshot shows...", no layout d
         const capturePolicy = await this._getFullPageCapturePolicy(tabId);
         await cdpClient.attach(tabId);
         await this._preparePageForCapture(tabId);
-        const capture = await this._withIndicatorsHidden(tabId, () =>
-          cdpClient.captureFullPageScreenshot(tabId, capturePolicy)
-        );
-        const imageData = typeof capture === 'string' ? capture : capture?.data;
+        const captured = await this._captureFullPageWithBlankRetry(tabId, capturePolicy);
+        const capture = captured?.capture;
         const captureWarning = typeof capture === 'object' ? capture?.warning || null : null;
         const captureBounds = typeof capture === 'object' ? capture?.captureBounds || null : null;
-        if (!imageData) throw new Error('Full-page screenshot returned no image data');
-        const rawUrl = `data:image/png;base64,${imageData}`;
+        if (!captured?.dataUrl) throw new Error('Full-page screenshot returned no image data');
+        if (captured?.blankFrameRetry?.finalBlank) {
+          throw new Error('Background full-page screenshot remained blank after retries');
+        }
+        const rawUrl = captured.dataUrl;
         const warningNote = captureWarning ? `\nWarning: ${captureWarning}` : '';
 
         // If the caller asked to save, do it with the RAW (uncompressed,

test/run.js

@@ -25502,6 +25502,76 @@ test('user full-page screenshot responses preserve compositor fallback warnings'
   }
 });
 
+test('Chrome full-page screenshot paths reject blank background captures after retries', async () => {
+  const originalChrome = globalThis.chrome;
+  const originalAttach = cdpClientCh.attach;
+  const originalCapture = cdpClientCh.captureFullPageScreenshot;
+  const originalDelays = AgentCh.BLANK_SCREENSHOT_RETRY_DELAYS_MS;
+  let captureCalls = 0;
+  try {
+    globalThis.chrome = {
+      ...(originalChrome || {}),
+      tabs: {
+        ...(originalChrome?.tabs || {}),
+        get: async (tabId) => ({
+          id: tabId,
+          active: false,
+          url: 'https://example.test/background',
+        }),
+      },
+    };
+    cdpClientCh.attach = async () => ({ attached: true });
+    cdpClientCh.captureFullPageScreenshot = async () => {
+      captureCalls += 1;
+      return { data: 'Ymxhbms=' };
+    };
+    AgentCh.BLANK_SCREENSHOT_RETRY_DELAYS_MS = [0];
+
+    const agent = new AgentCh({
+      getActive: () => ({ supportsVision: true }),
+      getVisionProvider: async () => null,
+    });
+    agent._preparePageForCapture = async () => {};
+    agent._withIndicatorsHidden = async (_tabId, capture) => capture();
+    agent._captureViewportProbe = async () => ({
+      readyState: 'complete',
+      documentTextChars: 200,
+      visibleTextChars: 100,
+      domNodes: 50,
+      imageCount: 0,
+      scrollHeight: 1200,
+      innerHeight: 800,
+    });
+    agent._analyzeScreenshotBlankness = async () => ({
+      blank: true,
+      reason: 'near-all-white frame',
+      meanLuma: 255,
+      lumaStdDev: 0,
+      whiteRatio: 1,
+      blackRatio: 0,
+    });
+
+    const userResult = await agent.captureFullPageScreenshotForUser(42);
+    assert.deepEqual(userResult, {
+      ok: false,
+      error: 'Background full-page screenshot remained blank after retries',
+    });
+
+    const toolResult = await agent.executeTool(42, 'full_page_screenshot', {});
+    assert.deepEqual(toolResult, {
+      success: false,
+      error: 'Full page screenshot failed: Background full-page screenshot remained blank after retries',
+    });
+    assert.equal(captureCalls, 4, 'each full-page path should retry once before rejecting the blank frame');
+  } finally {
+    AgentCh.BLANK_SCREENSHOT_RETRY_DELAYS_MS = originalDelays;
+    cdpClientCh.attach = originalAttach;
+    cdpClientCh.captureFullPageScreenshot = originalCapture;
+    if (originalChrome === undefined) delete globalThis.chrome;
+    else globalThis.chrome = originalChrome;
+  }
+});
+
 test('user full-page screenshots apply adapter capture policy without LLM adapter injection', async () => {
   const originalChrome = globalThis.chrome;
   const originalAttach = cdpClientCh.attach;