@gajae-code/coding-agent 0.11.3 → 0.11.4

package/src/tools/path-utils.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
-import { isEnoent } from "@gajae-code/utils";
+import { isEnoent } from "@gajae-code/utils/fs-error";
 import { InternalUrlRouter } from "../internal-urls";
 import { ToolError } from "./tool-errors";
 
@@ -10,13 +10,9 @@ const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*|raw|conflicts)$/i;
 const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*$/i;
 const FILE_RAW_ONLY_RE = /^raw$/i;
-// Permissive selector chunk for internal URLs — accepts well-formed selectors
-// plus common malformed shapes (e.g. `:-N`) so the read tool peels the entire
-// selector chain off before dispatching to a protocol handler.
-const INTERNAL_URL_SELECTOR_PART_RE =
-	/^(?:raw|conflicts|L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*|-\d+(?:[-+]\d+)?)$/i;
-// Schemes whose host grammar is identifier-shaped, so any trailing
-// `:<selector-chunk>` is unambiguously a read-tool selector.
+// Schemes whose authority grammar is identifier-shaped and may therefore carry
+// a read selector immediately after the authority. Colons in a path, query, or
+// fragment remain part of the URL and are never considered selectors.
 const INTERNAL_SCHEMES_WITH_SELECTORS: Record<string, true> = {
 	agent: true,
 	artifact: true,
@@ -148,39 +144,50 @@ export function splitPathAndSel(rawPath: string): { path: string; sel?: string }
 /**
  * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
  *
- * The filesystem-path splitter is intentionally conservative: it refuses to
- * peel a trailing `:<chunk>` unless that chunk matches the strict selector
- * grammar. That rule is right for filesystem paths (a file named `a:1-50` is
- * legal) but wrong for internal URLs, where any trailing `:<chunk>` after the
- * scheme is unambiguously a read-tool selector — even if malformed (e.g.
- * `artifact://3:raw:-100`).
- *
- * This function iteratively peels selector-shaped chunks (well-formed plus
- * common malformed shapes like `:-N`) so the rest of the read tool can pass a
- * clean URL to the protocol handler and surface selector errors via parseSel
- * instead of as misleading "host invalid" errors from the handler.
- *
- * Falls back to the input unchanged when nothing matches.
+ * Artifact authorities are generated identifiers, so their complete tail is
+ * unambiguously a selector and malformed selectors can be rejected before
+ * resolving the artifact. Other resources may legitimately use colons in
+ * their identities, so they only lose strict, recognized selector suffixes.
+ * Skill authorities additionally use the active registry to distinguish a
+ * skill name from its selector without making path-utils depend on skills.
  */
-export function splitInternalUrlSel(rawPath: string): { path: string; sel?: string } {
+export function splitInternalUrlSel(
+	rawPath: string,
+	options: { activeSkillNames?: readonly string[] } = {},
+): { path: string; sel?: string } {
 	const schemeMatch = rawPath.match(INTERNAL_URL_SCHEME_RE);
 	if (!schemeMatch) return { path: rawPath };
-	if (!INTERNAL_SCHEMES_WITH_SELECTORS[schemeMatch[1].toLowerCase()]) return { path: rawPath };
+	const scheme = schemeMatch[1].toLowerCase();
+	if (!INTERNAL_SCHEMES_WITH_SELECTORS[scheme]) return { path: rawPath };
 
 	const schemeEnd = schemeMatch[0].length;
-	let path = rawPath;
-	const chunks: string[] = [];
-	while (true) {
-		const colon = path.lastIndexOf(":");
-		// Stop before crossing into the scheme separator `://`.
-		if (colon < schemeEnd) break;
-		const tail = path.slice(colon + 1);
-		if (!INTERNAL_URL_SELECTOR_PART_RE.test(tail)) break;
-		chunks.unshift(tail);
-		path = path.slice(0, colon);
+	const authorityTerminator = rawPath.slice(schemeEnd).search(/[/?#]/);
+	if (authorityTerminator !== -1) return { path: rawPath };
+	const authority = rawPath.slice(schemeEnd);
+	const firstColon = authority.indexOf(":");
+	if (firstColon === -1) return { path: rawPath };
+
+	if (scheme === "artifact") {
+		return { path: rawPath.slice(0, schemeEnd + firstColon), sel: authority.slice(firstColon + 1) };
+	}
+
+	if (scheme === "skill") {
+		const activeSkillNames = options.activeSkillNames ?? [];
+		if (activeSkillNames.includes(authority)) return { path: rawPath };
+		const skillName = activeSkillNames
+			.filter(name => authority.startsWith(`${name}:`))
+			.sort((a, b) => b.length - a.length)[0];
+		if (skillName) {
+			return {
+				path: `${rawPath.slice(0, schemeEnd)}${skillName}`,
+				sel: authority.slice(skillName.length + 1),
+			};
+		}
 	}
-	if (chunks.length === 0) return { path: rawPath };
-	return { path, sel: chunks.join(":") };
+
+	const strict = splitPathAndSel(authority);
+	if (strict.sel === undefined) return { path: rawPath };
+	return { path: `${rawPath.slice(0, schemeEnd)}${strict.path}`, sel: strict.sel };
 }
 
 function assertNotInternalUrl(expanded: string, original: string): void {

package/src/tools/read.ts

@@ -11,6 +11,7 @@ import * as z from "zod/v4";
 import { getFileReadCache } from "../edit/file-read-cache";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { getActiveSkills } from "../extensibility/skills";
 import { formatHashLine, formatHashLines, formatLineHash, HL_BODY_SEP } from "../hashline/hash";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
@@ -1585,8 +1586,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		// off the URL and surfaced via parseSel rather than confusing handlers.
 		const internalRouter = InternalUrlRouter.instance();
 		if (internalRouter.canHandle(readPath)) {
-			const internalTarget = splitInternalUrlSel(readPath);
+			const internalTarget = splitInternalUrlSel(readPath, {
+				activeSkillNames: getActiveSkills().map(skill => skill.name),
+			});
 			const parsed = parseSel(internalTarget.sel);
+			if (internalTarget.sel !== undefined && parsed.kind === "none") {
+				throw new ToolError(`Invalid internal URL selector "${internalTarget.sel}".`);
+			}
 			return this.#handleInternalUrl(internalTarget.path, parsed, signal);
 		}
 

package/src/tools/render-utils.ts

@@ -15,10 +15,10 @@ import { pluralize } from "@gajae-code/utils";
 import { settings } from "../config/settings";
 import type { Theme } from "../modes/theme/theme";
 import { Hasher } from "../tui/utils";
-import { formatDimensionNote, type ResizedImage } from "../utils/image-resize";
 
 export { Ellipsis } from "@gajae-code/natives";
 export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@gajae-code/tui";
+export { formatScreenshot } from "./browser/screenshot-format";
 
 // =============================================================================
 // Standardized Display Constants
@@ -591,32 +591,6 @@ export function formatToolWorkingDirectory(workdir: string | undefined, projectD
 	return replaceTabs(displayWorkdir);
 }
 
-export function formatScreenshot(opts: {
-	saveFullRes: boolean;
-	savedMimeType: string;
-	savedByteLength: number;
-	dest: string;
-	resized: ResizedImage;
-}): string[] {
-	const lines = ["Screenshot captured"];
-	if (opts.saveFullRes) {
-		lines.push(
-			`Saved: ${opts.savedMimeType} (${(opts.savedByteLength / 1024).toFixed(2)} KB) to ${shortenPath(opts.dest)}`,
-		);
-		lines.push(
-			`Model: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB, ${opts.resized.width}x${opts.resized.height})`,
-		);
-	} else {
-		lines.push(`Format: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB)`);
-		lines.push(`Dimensions: ${opts.resized.width}x${opts.resized.height}`);
-	}
-	const dimensionNote = formatDimensionNote(opts.resized);
-	if (dimensionNote) {
-		lines.push(dimensionNote);
-	}
-	return lines;
-}
-
 export function wrapBrackets(text: string, theme: Theme): string {
 	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
 }

package/src/tools/resource-gc.ts

@@ -75,12 +75,31 @@ const defaultDeps: ResourceGcDeps = {
 
 // ── Controller state (process-global; tabs/browsers are module-global too) ──────────────────
 const activeSessions = new Map<string, Settings>();
-let timer: ReturnType<typeof setTimeout> | null = null;
+
+interface ScheduleOwner {
+	generation: number;
+	token: number;
+}
+
+interface DeferredSchedule {
+	generation: number;
+	deadline: number;
+}
+
+interface WorkOwner {
+	generation: number;
+	source: "timer" | "external";
+}
+
+let pendingTimer: NodeJS.Timeout | null = null;
+let pendingDeadline: number | null = null;
+let pendingOwner: ScheduleOwner | null = null;
+let deferredSchedule: DeferredSchedule | null = null;
+let inProgressOwner: WorkOwner | null = null;
 let stopped = false;
-// Bumped on every stop so an in-flight tick from a previous schedule cannot reschedule after a
-// stop+re-register and leak a duplicate timer.
 let timerGeneration = 0;
-let inProgress = false;
+let nextTimerToken = 0;
+let schedulerNow = (): number => performance.now();
 let rssWarningActive = false;
 let lastScreenshotScanAt = 0;
 let deps: ResourceGcDeps = defaultDeps;
@@ -96,8 +115,20 @@ export interface ResourceGcRegistration {
  * session unregisters.
  */
 export function registerResourceGcSession(reg: ResourceGcRegistration): () => void {
+	const isNewSession = !activeSessions.has(reg.sessionId);
 	activeSessions.set(reg.sessionId, reg.settings);
-	ensureTimerStarted();
+	stopped = false;
+	if (isNewSession) {
+		const deadline = schedulerNow() + resolveSweepIntervalMs(reg.settings);
+		if (
+			inProgressOwner?.generation === timerGeneration &&
+			(pendingDeadline === null || pendingDeadline <= deadline)
+		) {
+			deferSchedule(timerGeneration, deadline);
+		} else {
+			requestSchedule(deadline);
+		}
+	}
 	let unregistered = false;
 	return () => {
 		if (unregistered) return;
@@ -113,51 +144,78 @@ function currentSweepIntervalMs(): number {
 	return Number.isFinite(min) ? min : DEFAULT_SWEEP_INTERVAL_MS;
 }
 
-function ensureTimerStarted(): void {
-	if (timer) return;
-	stopped = false;
-	scheduleNextSweep();
+function clearPendingSchedule(): void {
+	if (pendingTimer) clearTimeout(pendingTimer);
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
 }
 
-// Recursive setTimeout (not setInterval) so the cadence is recomputed every cycle and later
-// session register/unregister changes to resourceGc.sweepIntervalMs are honored live.
-function scheduleNextSweep(): void {
-	if (stopped || activeSessions.size === 0) {
-		timer = null;
+function requestSchedule(deadline: number): void {
+	if (stopped || activeSessions.size === 0) return;
+	if (pendingDeadline !== null && pendingDeadline <= deadline) return;
+	clearPendingSchedule();
+	const owner = { generation: timerGeneration, token: ++nextTimerToken };
+	pendingDeadline = deadline;
+	pendingOwner = owner;
+	pendingTimer = setTimeout(
+		() => {
+			void handleTimerCallback(owner, deadline);
+		},
+		Math.max(0, deadline - schedulerNow()),
+	);
+	pendingTimer.unref?.();
+}
+
+function deferSchedule(generation: number, deadline: number): void {
+	if (generation !== timerGeneration) return;
+	if (deferredSchedule?.generation === generation) {
+		deferredSchedule.deadline = Math.min(deferredSchedule.deadline, deadline);
 		return;
 	}
-	const generation = timerGeneration;
-	timer = setTimeout(() => {
-		void tickAndReschedule(generation);
-	}, currentSweepIntervalMs());
-	timer.unref?.();
+	deferredSchedule = { generation, deadline };
 }
 
-async function tickAndReschedule(generation: number): Promise<void> {
-	await runTick();
-	// A stop (and possible re-register) happened during the tick: a newer cycle owns the timer now.
-	if (generation !== timerGeneration) return;
-	scheduleNextSweep();
+async function handleTimerCallback(owner: ScheduleOwner, deadline: number): Promise<void> {
+	if (pendingOwner?.generation !== owner.generation || pendingOwner.token !== owner.token) return;
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
+	if (inProgressOwner) {
+		deferSchedule(owner.generation, deadline);
+		return;
+	}
+	await runTick(owner.generation, "timer");
+}
+
+function reconcileCurrentSchedule(): void {
+	if (stopped || activeSessions.size === 0 || inProgressOwner) return;
+	const normalDeadline = schedulerNow() + currentSweepIntervalMs();
+	const deferredDeadline = deferredSchedule?.generation === timerGeneration ? deferredSchedule.deadline : null;
+	if (deferredDeadline !== null) deferredSchedule = null;
+	requestSchedule(deferredDeadline === null ? normalDeadline : Math.min(deferredDeadline, normalDeadline));
 }
 
 function stopTimer(): void {
 	stopped = true;
 	timerGeneration++;
-	if (timer) {
-		clearTimeout(timer);
-		timer = null;
-	}
+	clearPendingSchedule();
+	deferredSchedule = null;
 }
 
-async function runTick(): Promise<void> {
-	if (inProgress) return;
-	inProgress = true;
+async function runTick(generation = timerGeneration, source: WorkOwner["source"] = "external"): Promise<void> {
+	if (inProgressOwner || activeSessions.size === 0) return;
+	const owner: WorkOwner = { generation, source };
+	inProgressOwner = owner;
 	try {
 		await sweepOnce(deps);
 	} catch (err) {
 		logger.debug("resource GC sweep failed", { error: (err as Error).message });
 	} finally {
-		inProgress = false;
+		if (inProgressOwner === owner) inProgressOwner = null;
+		// A stale completion only releases its own work lock. Once that lock is released, current
+		// generation demand (which may have deferred behind it) can be reconciled independently.
+		reconcileCurrentSchedule();
 	}
 }
 
@@ -268,24 +326,55 @@ export function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>):
 	deps = { ...defaultDeps, ...overrides };
 }
 
+export function __setResourceGcSchedulerNowForTest(now: () => number): void {
+	schedulerNow = now;
+}
+
 export async function __runResourceGcTickForTest(): Promise<void> {
 	await runTick();
 }
 
+export async function __runResourceGcTimerCallbackForTest(
+	owner: { generation: number; token: number },
+	deadline: number,
+): Promise<void> {
+	await handleTimerCallback(owner, deadline);
+}
+
 export function __getResourceGcStateForTest(): {
 	timerActive: boolean;
 	sessionCount: number;
 	rssWarningActive: boolean;
 	inProgress: boolean;
+	generation: number;
+	pendingDeadline: number | null;
+	pendingOwner: { generation: number; token: number } | null;
+	deferredDeadline: number | null;
+	deferredGeneration: number | null;
+	activeGeneration: number | null;
 } {
-	return { timerActive: timer !== null, sessionCount: activeSessions.size, rssWarningActive, inProgress };
+	return {
+		timerActive: pendingTimer !== null,
+		sessionCount: activeSessions.size,
+		rssWarningActive,
+		inProgress: inProgressOwner !== null,
+		generation: timerGeneration,
+		pendingDeadline,
+		pendingOwner: pendingOwner ? { ...pendingOwner } : null,
+		deferredDeadline: deferredSchedule?.deadline ?? null,
+		deferredGeneration: deferredSchedule?.generation ?? null,
+		activeGeneration: inProgressOwner?.generation ?? null,
+	};
 }
 
 export function __resetResourceGcForTest(): void {
 	stopTimer();
 	activeSessions.clear();
-	inProgress = false;
+	inProgressOwner = null;
+	deferredSchedule = null;
 	rssWarningActive = false;
 	lastScreenshotScanAt = 0;
+	nextTimerToken = 0;
+	schedulerNow = (): number => performance.now();
 	deps = defaultDeps;
 }

package/src/utils/image-loading.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import type { ImageContent } from "@gajae-code/ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@gajae-code/utils";
 import { resolveReadPath } from "../tools/path-utils";
-import { formatDimensionNote, resizeImage } from "./image-resize";
+import { formatDimensionNote, resizeImageBuffer } from "./image-resize";
 
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
 export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
@@ -14,6 +14,26 @@ export interface LoadImageInputOptions {
 	maxBytes?: number;
 	resolvedPath?: string;
 	detectedMimeType?: string;
+	signal?: AbortSignal;
+}
+
+export interface LoadImageInputBytesOptions {
+	inputBuffer: Buffer;
+	resolvedPath: string;
+	mimeType: string;
+	autoResize: boolean;
+	maxBytes?: number;
+	maxOutputBytes?: number;
+	signal?: AbortSignal;
+}
+
+export interface TransformedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	buffer: Uint8Array;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: number;
 }
 
 export interface LoadedImageInput {
@@ -38,9 +58,7 @@ export class ImageInputTooLargeError extends Error {
 }
 
 export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
-	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
-		return image;
-	}
+	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) return image;
 	try {
 		const bytes = Buffer.from(image.data, "base64");
 		const data = await new Bun.Image(bytes).png().toBase64();
@@ -50,53 +68,86 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 	}
 }
 
-export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+/** Transform trusted source bytes without materializing a base64 payload. */
+export async function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput> {
 	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
-	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
-	const metadata = options.detectedMimeType
-		? { mimeType: options.detectedMimeType }
-		: await readImageMetadata(resolvedPath);
-	const mimeType = metadata?.mimeType;
-	if (!mimeType) return null;
-
-	const stat = await Bun.file(resolvedPath).stat();
-	if (stat.size > maxBytes) {
-		throw new ImageInputTooLargeError(stat.size, maxBytes);
-	}
-
-	const inputBuffer = await fs.readFile(resolvedPath);
-	if (inputBuffer.byteLength > maxBytes) {
-		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
+	options.signal?.throwIfAborted();
+	if (options.inputBuffer.byteLength > maxBytes) {
+		throw new ImageInputTooLargeError(options.inputBuffer.byteLength, maxBytes);
 	}
 
-	let outputData = Buffer.from(inputBuffer).toBase64();
-	let outputMimeType = mimeType;
-	let outputBytes = inputBuffer.byteLength;
+	let outputBuffer: Uint8Array = options.inputBuffer;
+	let outputMimeType = options.mimeType;
 	let dimensionNote: string | undefined;
 
 	if (options.autoResize) {
+		options.signal?.throwIfAborted();
 		try {
-			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
-			outputData = resized.data;
+			const resized = await resizeImageBuffer(
+				options.inputBuffer,
+				options.mimeType,
+				options.maxOutputBytes === undefined ? undefined : { maxBytes: options.maxOutputBytes },
+			);
+			options.signal?.throwIfAborted();
+			outputBuffer = resized.buffer;
 			outputMimeType = resized.mimeType;
-			outputBytes = resized.buffer.byteLength;
 			dimensionNote = formatDimensionNote(resized);
 		} catch {
-			// keep original image when resize fails
+			options.signal?.throwIfAborted();
+			// Keep the original image when optional resize fails.
 		}
 	}
 
+	options.signal?.throwIfAborted();
 	let textNote = `Read image file [${outputMimeType}]`;
-	if (dimensionNote) {
-		textNote += `\n${dimensionNote}`;
-	}
-
+	if (dimensionNote) textNote += `\n${dimensionNote}`;
 	return {
-		resolvedPath,
+		resolvedPath: options.resolvedPath,
 		mimeType: outputMimeType,
-		data: outputData,
+		buffer: outputBuffer,
 		textNote,
 		dimensionNote,
-		bytes: outputBytes,
+		bytes: outputBuffer.byteLength,
+	};
+}
+
+export function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput {
+	return {
+		resolvedPath: transformed.resolvedPath,
+		mimeType: transformed.mimeType,
+		data: Buffer.from(transformed.buffer).toBase64(),
+		textNote: transformed.textNote,
+		dimensionNote: transformed.dimensionNote,
+		bytes: transformed.bytes,
 	};
 }
+
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export async function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput> {
+	return materializeImageInput(await transformImageInputBytes(options));
+}
+
+export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
+	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
+	options.signal?.throwIfAborted();
+	const metadata = options.detectedMimeType
+		? { mimeType: options.detectedMimeType }
+		: await readImageMetadata(resolvedPath);
+	const mimeType = metadata?.mimeType;
+	if (!mimeType) return null;
+
+	options.signal?.throwIfAborted();
+	const stat = await Bun.file(resolvedPath).stat();
+	if (stat.size > maxBytes) throw new ImageInputTooLargeError(stat.size, maxBytes);
+
+	const inputBuffer = await fs.readFile(resolvedPath, { signal: options.signal });
+	return loadImageInputBytes({
+		inputBuffer,
+		resolvedPath,
+		mimeType,
+		autoResize: options.autoResize,
+		maxBytes,
+		signal: options.signal,
+	});
+}

package/src/utils/image-resize.ts

@@ -21,14 +21,14 @@ export interface ResizedImage {
 
 // 500KB target — aggressive compression; Anthropic's 5MB per-image cap is rarely the
 // binding constraint once images are downsized to 1568px (Anthropic's internal threshold).
-const DEFAULT_MAX_BYTES = 500 * 1024;
+export const DEFAULT_IMAGE_RESIZE_MAX_BYTES = 500 * 1024;
 
 const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	// Anthropic's "internal recommended size" — Anthropic model internally caps images at
 	// 1568px on the longest edge before vision processing.
 	maxWidth: 1568,
 	maxHeight: 1568,
-	maxBytes: DEFAULT_MAX_BYTES,
+	maxBytes: DEFAULT_IMAGE_RESIZE_MAX_BYTES,
 	jpegQuality: 80,
 };
 
@@ -72,14 +72,17 @@ Buffer.prototype.toBase64 = function (this: Buffer) {
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
-export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+export async function resizeImageBuffer(
+	inputBuffer: Buffer,
+	inputMimeType: string,
+	options?: ImageResizeOptions,
+): Promise<ResizedImage> {
 	const excludeWebP = options?.excludeWebP ?? isWebPExcluded();
 	const opts = { ...DEFAULT_OPTIONS, ...options, excludeWebP };
-	const inputBuffer = Buffer.from(img.data, "base64");
 
 	try {
 		const { width: originalWidth, height: originalHeight, format } = await new Bun.Image(inputBuffer).metadata();
-		const sourceMime = img.mimeType ?? `image/${format}`;
+		const sourceMime = inputMimeType ?? `image/${format}`;
 
 		// Fast path: already within dimensions AND well under budget.
 		// Threshold is 1/4 of budget — if already that compact, don't re-encode.
@@ -102,7 +105,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 				height: originalHeight,
 				wasResized: false,
 				get data() {
-					return img.data;
+					return inputBuffer.toBase64();
 				},
 			};
 		}
@@ -272,24 +275,28 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		// When the caller demanded WebP exclusion AND the original is WebP,
 		// returning the original buffer would silently violate that contract,
 		// so surface an explicit error instead.
-		if (excludeWebP && (img.mimeType === "image/webp" || !img.mimeType)) {
+		if (excludeWebP && (inputMimeType === "image/webp" || !inputMimeType)) {
 			throw new Error("resizeImage: failed to decode image and cannot honor excludeWebP for a WebP source");
 		}
 		return {
 			buffer: inputBuffer,
-			mimeType: img.mimeType,
+			mimeType: inputMimeType,
 			originalWidth: 0,
 			originalHeight: 0,
 			width: 0,
 			height: 0,
 			wasResized: false,
 			get data() {
-				return img.data;
+				return inputBuffer.toBase64();
 			},
 		};
 	}
 }
 
+export function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+	return resizeImageBuffer(Buffer.from(img.data, "base64"), img.mimeType, options);
+}
+
 /**
  * Format a dimension note for resized images.
  * This helps the model understand the coordinate mapping.