@code-yeongyu/senpi-codemode 2026.10.1 → 2026.10.3

package/src/tool/image.ts

@@ -30,6 +30,28 @@ const MAX_DISPLAY_IMAGES_PER_CELL = 8;
 const MAX_DISPLAY_IMAGE_BYTES_PER_CELL = 24 * 1024 * 1024;
 const MAX_JSON_OUTPUTS_PER_CELL = 64;
 
+// Base64 of the signatures of the formats providers accept inline (PNG, JPEG except JPEG-LS, GIF,
+// "RIFF....WEBP"). Signatures start at byte 0, so their encodings are prefixes.
+const IMAGE_SIGNATURES: ReadonlyArray<readonly [string, RegExp]> = [
+	["image/png", /^iVBORw0KGg/],
+	["image/jpeg", /^[/]9j[/](?!9)/],
+	["image/gif", /^R0lGOD[dl]h/],
+	["image/webp", /^UklG.{8}RUJQ/],
+];
+
+// Providers reject the whole request on a bad image, and a kept image block is resent on every later turn,
+// so invalid data is dropped with a reason instead. The detected type wins over the declared one.
+function validateDisplayImage(dataBase64: string): { data: string; mimeType: string } | { reason: string } {
+	const data = dataBase64.replace(/\s+/g, "");
+	if (data.length === 0 || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
+		return { reason: "the image data is not valid base64 (truncated or corrupted?)" };
+	}
+	const head = data.slice(0, 16);
+	const signature = IMAGE_SIGNATURES.find(([, pattern]) => pattern.test(head));
+	if (signature === undefined) return { reason: "the image data is not a PNG, JPEG, GIF, or WebP image" };
+	return { data, mimeType: signature[0] };
+}
+
 export interface EvalOutputOptions {
 	readonly artifactPath?: string;
 	readonly headBytes: number;
@@ -98,6 +120,11 @@ export class EvalOutputCollector {
 
 	display(message: DisplayMessage): void {
 		if (message.mimeType.startsWith("image/")) {
+			const image = validateDisplayImage(message.dataBase64);
+			if ("reason" in image) {
+				this.#sink.push(`[display: image dropped \u2014 ${image.reason}]\n`);
+				return;
+			}
 			if (
 				this.#displayImages.length >= MAX_DISPLAY_IMAGES_PER_CELL ||
 				this.#displayImageBytes + message.dataBase64.length > MAX_DISPLAY_IMAGE_BYTES_PER_CELL
@@ -105,8 +132,8 @@ export class EvalOutputCollector {
 				this.#displayImagesElided++;
 				return;
 			}
-			this.#displayImages.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
-			this.#displayImageBytes += message.dataBase64.length;
+			this.#displayImages.push({ type: "image", mimeType: image.mimeType, data: image.data });
+			this.#displayImageBytes += image.data.length;
 			return;
 		}
 		const text = Buffer.from(message.dataBase64, "base64").toString("utf8");

package/src/tool/render.ts

@@ -73,9 +73,9 @@ const TOOL_CALL_PREVIEW_COUNT = 5;
 const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
 const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
 const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
-const LIVE_ELAPSED_TICK_MS = 1_000;
+const LIVE_RENDER_TICK_MS = 100;
 // A live row repaints on every tick, so this many ticks without a render means the row is gone.
-const LIVE_TICKER_MAX_IDLE_TICKS = 60;
+const LIVE_TICKER_MAX_IDLE_TICKS = 600;
 
 class PlainTextComponent implements EvalRenderComponent {
 	#blocks: readonly RenderBlock[] = [];
@@ -92,7 +92,7 @@ class PlainTextComponent implements EvalRenderComponent {
 	 * The host only animates tool rows for streaming args, `task`, and results carrying
 	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
 	 * update events. While a cell is non-terminal this drives the repaint itself so the
-	 * header's elapsed time advances, and it emits no tool updates or RPC traffic. Detached
+	 * header's spinner and elapsed time advance, with no tool updates or RPC traffic. Detached
 	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
 	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
 	 * the next render, so dropped rows cannot accumulate intervals.
@@ -115,7 +115,7 @@ class PlainTextComponent implements EvalRenderComponent {
 
 	#armTicker(): void {
 		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
-		this.#ticker = setInterval(() => this.#tick(), LIVE_ELAPSED_TICK_MS);
+		this.#ticker = setInterval(() => this.#tick(), LIVE_RENDER_TICK_MS);
 		this.#ticker.unref?.();
 	}
 
@@ -336,7 +336,10 @@ function cellElapsedMs(cell: EvalCellResult, environment: RenderEnvironment): nu
 }
 
 function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string {
-	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
+	const presentation = cellPresentation(
+		cell.status,
+		environment.spinnerFrame ?? Math.floor((cellElapsedMs(cell, environment) ?? 0) / LIVE_RENDER_TICK_MS),
+	);
 	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
 	let header = `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
 	if (cell.queuedBehind !== undefined && cell.queuedBehind.length > 0)

package/src/tool/run-eval-cell.ts

@@ -207,8 +207,8 @@ async function executeCell(
 	};
 	try {
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
-		// Computed before the handler so the cell's capability can be entered per host tool call from the
-		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
+		// Computed before the handler so its construction-time snapshot captures this cell's capability.
+		// Worker messages later restore that snapshot before calling host tools (#1754, #2512).
 		const kernelTools = jsKernelTools(kernel, invocation.input.language);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
 			const queue = kernel.queueSnapshot();

package/src/tool/types.ts

@@ -66,8 +66,7 @@ export type EvalControlInput =
 
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
-// Like `summary`, `language` and `code` stay optional in the wire schema because control
-// actions share it; the description teaches the requirement and parseEvalRequest enforces it.
+// Run fields are optional at the root for control calls, but required in the run branch.
 const LANGUAGE_FIELD_DESCRIPTION =
 	"REQUIRED for run. Kernel that runs the cell; each language keeps its own persistent state across eval calls.";
 const CODE_FIELD_DESCRIPTION = "REQUIRED for run. Cell body, verbatim.";
@@ -124,11 +123,20 @@ export function createEvalInputSchema(
 	const languages = enabledLanguageList(enabled);
 	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
 	const languageSchema = evalLanguageUnion(languages);
+	const properties = evalInputProperties(languageSchema, deadlines);
 	return Type.Unsafe<EvalToolRequest>(
-		Type.Object(evalInputProperties(languageSchema, deadlines), {
+		Type.Object(properties, {
+			// Keep branches self-contained for Mistral-hosted GLM (#2240).
 			anyOf: [
-				{ properties: { action: { enum: ["run", "list"] } } },
-				{ properties: { action: { enum: ["peek", "stop"] } }, required: ["action", "cell_id"] },
+				Type.Object(
+					{ ...properties, action: Type.Optional(Type.Literal("run")) },
+					{ required: ["language", "code", "summary"] },
+				),
+				Type.Object({ action: Type.Literal("list") }),
+				Type.Object(
+					{ action: Type.Union([Type.Literal("peek"), Type.Literal("stop")]), cell_id: properties.cell_id },
+					{ required: ["action", "cell_id"] },
+				),
 			],
 		}),
 	) as EvalInputSchema;