Pasting images over 2000px mid-turn breaks later image reads in Claude #13647

#!/usr/bin/env node
// Reproduces "(media removed — rejected by API)" in Claude Code sessions driven like T3 Code does.
//
// T3 sends a pasted image to Claude Code over stream-json input, byte for byte. Claude Code scales
// images in a turn's first message down to 2000px, but not one sent while a turn is running, which
// it queues. When that image is over 2000px and the conversation later holds more than 20 images,
// the API rejects every request ("many-image requests: 2000 pixels") and Claude Code keeps dropping
// the newest image instead.
//
// Usage:
//   node repro.mjs              paste a 1080x2424 image mid-turn, like the Android app (expected: bug)
//   node repro.mjs --control    the same, scaled to fit 2000px (expected: no bug)
//   node repro.mjs --first      paste it with the first message instead (expected: no bug, as
//                               Claude Code scales that one down)
//
// The API only rejects on some routes: on Opus 5.5 and Fable 5.1 when talking to Anthropic
// directly, and on every model tested when going through CLIProxyAPI.
//
// Options: --model <alias> (default opus), --effort <level>, --reads <n> (default 20),
// --claude <path> (default claude).
// Needs a logged-in `claude` CLI. Writes images and logs under ./runs/<mode>-<timestamp>/.

import { spawn } from "node:child_process";
import { randomUUID } from "node:crypto";
import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
import { homedir } from "node:os";
import { join, resolve } from "node:path";
import { deflateSync } from "node:zlib";

const args = process.argv.slice(2);
const option = (name, fallback) => {
  const index = args.indexOf(name);
  return index === -1 ? fallback : args[index + 1];
};
const control = args.includes("--control");
const first = args.includes("--first");
const model = option("--model", "opus");
const effort = option("--effort", undefined);
const reads = Number(option("--reads", "20"));
const claude = option("--claude", "claude");

// --- Minimal PNG encoder, so the script has no dependencies. ---

const crcTable = Array.from({ length: 256 }, (_, n) => {
  let c = n;
  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
  return c >>> 0;
});
const crc32 = (buffer) => {
  let c = 0xffffffff;
  for (const byte of buffer) c = crcTable[(c ^ byte) & 0xff] ^ (c >>> 8);
  return (c ^ 0xffffffff) >>> 0;
};
const chunk = (type, data) => {
  const length = Buffer.alloc(4);
  length.writeUInt32BE(data.length);
  const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
  const crc = Buffer.alloc(4);
  crc.writeUInt32BE(crc32(body));
  return Buffer.concat([length, body, crc]);
};

/** An RGB PNG; `paint(x, y)` returns [r, g, b]. */
function png(width, height, paint) {
  const header = Buffer.alloc(13);
  header.writeUInt32BE(width, 0);
  header.writeUInt32BE(height, 4);
  header.set([8, 2, 0, 0, 0], 8);

  const rows = Buffer.alloc((width * 3 + 1) * height);
  for (let y = 0; y < height; y++) {
    const offset = y * (width * 3 + 1);
    for (let x = 0; x < width; x++) rows.set(paint(x, y), offset + 1 + x * 3);
  }

  return Buffer.concat([
    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
    chunk("IHDR", header),
    chunk("IDAT", deflateSync(rows)),
    chunk("IEND", Buffer.alloc(0)),
  ]);
}

// --- Test images. ---

const mode = control ? "control" : first ? "first-message" : "mid-turn";
const runDir = resolve("runs", `${mode}-${new Date().toISOString().replace(/[:.]/g, "-")}`);
mkdirSync(runDir, { recursive: true });

// A phone screenshot's shape: 1080x2424, or scaled to 891x2000 for the control run.
const [tallWidth, tallHeight] = control ? [891, 2000] : [1080, 2424];
const tall = png(tallWidth, tallHeight, (x, y) =>
  Math.floor(y / 200) % 2 === 0 ? [240, 238, 234] : [52, 58, 64],
);
writeFileSync(join(runDir, "pasted-screenshot.png"), tall);

/* Read in a second turn, to show the thread stays broken once the first rejection happened. */
const FOLLOW_UP_READS = 3;

const COLORS = {
  red: [220, 40, 40],
  green: [40, 170, 60],
  blue: [40, 80, 220],
  yellow: [240, 210, 40],
  purple: [140, 50, 180],
};
const colorNames = Object.keys(COLORS);
const smallFiles = Array.from({ length: reads + FOLLOW_UP_READS }, (_, index) => {
  // Random, so a right answer means the image was seen rather than the pattern guessed.
  const color = colorNames[Math.floor(Math.random() * colorNames.length)];
  const file = join(runDir, `image-${String(index + 1).padStart(2, "0")}.png`);
  writeFileSync(file, png(96, 96, () => COLORS[color]));
  return { file, color };
});

// --- Drive Claude Code the way T3's ClaudeAdapter does: stream-json in and out. ---

const sessionId = randomUUID();
const prompt = [
  `Read each of these ${reads} files with the Read tool, strictly one at a time: one Read call`,
  `per message, and wait for its result before the next. Never batch or parallelize reads.`,
  `Use no other tool. After each read, write one line: "<file number>: <main color or UNSEEN>".`,
  `Write UNSEEN when the tool result contains no image.`,
  `If a screenshot shows up along the way, do not describe it; just carry on with the reads.`,
  ...smallFiles.slice(0, reads).map(({ file }, index) => `${index + 1}. ${file}`),
].join("\n");
const followUp = [
  `Read these ${FOLLOW_UP_READS} files the same way: one Read call per message, never batched,`,
  `same one-line answers.`,
  ...smallFiles.slice(reads).map(({ file }, index) => `${reads + index + 1}. ${file}`),
].join("\n");

const screenshot = {
  type: "image",
  source: { type: "base64", media_type: "image/png", data: tall.toString("base64") },
};
const userMessage = (content) => ({
  type: "user",
  session_id: "",
  parent_tool_use_id: null,
  message: { role: "user", content },
});
const opening = userMessage(
  first ? [screenshot, { type: "text", text: prompt }] : [{ type: "text", text: prompt }],
);
/* What the Android app sends when a screenshot is pasted while the agent works. */
const pastedMidTurn = userMessage([
  screenshot,
  { type: "text", text: "Here is a screenshot, no need to look at it. Carry on with the reads." },
]);
let pasted = first;
let turns = 0;
const answers = [];

console.log(
  `mode: ${mode} | pasted image: ${tallWidth}x${tallHeight} | reads: ${reads} | model: ${model}` +
    (effort ? ` | effort: ${effort}` : ""),
);
console.log(`run dir: ${runDir}`);
console.log(`session: ${sessionId}\n`);

const child = spawn(
  claude,
  [
    "-p",
    "--input-format", "stream-json",
    "--output-format", "stream-json",
    "--verbose",
    "--model", model,
    "--session-id", sessionId,
    "--allowedTools", "Read",
    "--setting-sources", "",
    ...(effort ? ["--effort", effort] : []),
  ],
  { cwd: runDir, stdio: ["pipe", "pipe", "pipe"] },
);

const streamLog = [];
let buffer = "";
let stderr = "";
child.stderr.on("data", (data) => (stderr += data));
child.stdout.on("data", (data) => {
  buffer += data;
  let newline;
  while ((newline = buffer.indexOf("\n")) !== -1) {
    const line = buffer.slice(0, newline).trim();
    buffer = buffer.slice(newline + 1);
    if (!line) continue;
    streamLog.push(line);

    const event = JSON.parse(line);
    if (event.type === "assistant") {
      for (const block of event.message?.content ?? []) {
        if (block.type === "text" && block.text.trim()) {
          answers.push(block.text);
          console.log(`assistant: ${block.text.trim()}`);
        }
        if (block.type === "tool_use") {
          process.stdout.write(".");
          if (!pasted) {
            pasted = true;
            child.stdin.write(`${JSON.stringify(pastedMidTurn)}\n`);
            console.log(`\n[pasted the ${tallWidth}x${tallHeight} screenshot mid-turn]`);
          }
        }
      }
      if (event.error) console.log(`\n[api error in stream] ${event.error}`);
    }
    if (event.type === "result") {
      turns++;
      if (turns === 1) {
        child.stdin.write(`${JSON.stringify(userMessage([{ type: "text", text: followUp }]))}\n`);
        console.log(`\n[second turn: ${FOLLOW_UP_READS} more reads]`);
      } else {
        child.stdin.end();
      }
    }
  }
});

child.stdin.write(`${JSON.stringify(opening)}\n`);

const code = await new Promise((done) => child.on("close", done));
writeFileSync(join(runDir, "stream.ndjson"), `${streamLog.join("\n")}\n`);
if (stderr) writeFileSync(join(runDir, "stderr.log"), stderr);

// --- Verdict, from the session transcript Claude Code keeps on disk. ---

/** The first stored image taller than the 96px test images: the pasted screenshot. */
function storedScreenshotSize(ndjson) {
  for (const match of ndjson.matchAll(/"data":"(iVBORw0KGgo[A-Za-z0-9+/]{20,40})/g)) {
    const head = Buffer.from(match[1].slice(0, 32), "base64");
    const [width, height] = [head.readUInt32BE(16), head.readUInt32BE(20)];
    if (height > 96) return `${width}x${height}`;
  }
  return "not found";
}

const projectsDir = join(homedir(), ".claude", "projects");
const transcript = [
  join(projectsDir, runDir.replace(/[^a-zA-Z0-9]/g, "-"), `${sessionId}.jsonl`),
].find(existsSync);

const text = transcript ? readFileSync(transcript, "utf8") : streamLog.join("\n");
const apiErrors = text.split("\n").filter((line) => line.includes("many-image requests: 2000 pixels"));
const unseen = answers.join("\n").match(/\d+: UNSEEN/g) ?? [];

console.log(`\n\nexit code: ${code}`);
console.log(`transcript: ${transcript ?? "not found, verdict from the stream only"}`);
console.log(`pasted image as stored by Claude Code: ${storedScreenshotSize(text)}`);
console.log(`API rejections ("many-image requests: 2000 pixels"): ${apiErrors.length}`);
console.log(`reads the model reported as UNSEEN: ${unseen.length ? unseen.join(", ") : "none"}`);

/* Answers checked against the real colors; a wrong one means the model did not see that image. */
const reported = new Map(
  [...answers.join("\n").matchAll(/(\d+): (\w+)/g)].map(([, n, answer]) => [Number(n), answer.toLowerCase()]),
);
const wrong = smallFiles
  .map(({ color }, index) => ({ n: index + 1, color, said: reported.get(index + 1) ?? "no answer" }))
  .filter(({ color, said }) => said !== color);
console.log(
  `answers matching the real color: ${smallFiles.length - wrong.length}/${smallFiles.length}` +
    (wrong.length ? ` (wrong: ${wrong.map(({ n, color, said }) => `${n} was ${color}, said ${said}`).join("; ")})` : ""),
);

if (apiErrors.length > 0) {
  const detail = JSON.parse(apiErrors[0]).errorDetails ?? apiErrors[0].slice(0, 300);
  console.log(`first rejection: ${detail}`);
}
console.log(apiErrors.length > 0 ? "\nREPRODUCED" : "\nNOT REPRODUCED");