@oh-my-pi/pi-coding-agent 11.4.0 → 11.5.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [11.5.0] - 2026-02-06
+
+### Added
+
+- Added terminal breadcrumb tracking to remember the last session per terminal, enabling `--continue` to work correctly with concurrent sessions in different terminals
+
+### Changed
+
+- Changed screenshot format to always use PNG instead of supporting JPEG with quality parameter
+- Changed default extract_readable format from text to markdown
+- Changed screenshot storage to use temporary directory with Snowflake IDs instead of artifacts directory
+- Changed ResizedImage interface to return buffer as Uint8Array with lazy-loaded base64 data getter for improved memory efficiency
+
+### Removed
+
+- Removed JPEG quality parameter from screenshot options
+- Removed format selection for screenshots (now PNG only)
+- Removed ability to save screenshots to custom paths or artifacts directory
+
+## [11.4.1] - 2026-02-06
+### Fixed
+
+- Fixed tab character display in error messages and bash tool output by properly replacing tabs with spaces
+
 ## [11.4.0] - 2026-02-06
 
 ### Added
@@ -3971,4 +3995,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "11.4.0",
+	"version": "11.5.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -90,12 +90,12 @@
 		"@mozilla/readability": "0.6.0",
 		"@oclif/core": "^4.8.0",
 		"@oclif/plugin-autocomplete": "^3.2.40",
-		"@oh-my-pi/omp-stats": "11.4.0",
-		"@oh-my-pi/pi-agent-core": "11.4.0",
-		"@oh-my-pi/pi-ai": "11.4.0",
-		"@oh-my-pi/pi-natives": "11.4.0",
-		"@oh-my-pi/pi-tui": "11.4.0",
-		"@oh-my-pi/pi-utils": "11.4.0",
+		"@oh-my-pi/omp-stats": "11.5.0",
+		"@oh-my-pi/pi-agent-core": "11.5.0",
+		"@oh-my-pi/pi-ai": "11.5.0",
+		"@oh-my-pi/pi-natives": "11.5.0",
+		"@oh-my-pi/pi-tui": "11.5.0",
+		"@oh-my-pi/pi-utils": "11.5.0",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",

package/src/patch/shared.ts

@@ -265,13 +265,13 @@ export const editToolRenderer = {
 
 				if (result.isError) {
 					if (errorText) {
-						text += `\n\n${uiTheme.fg("error", errorText)}`;
+						text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
 					}
 				} else if (result.details?.diff) {
 					text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
 				} else if (editDiffPreview) {
 					if ("error" in editDiffPreview) {
-						text += `\n\n${uiTheme.fg("error", editDiffPreview.error)}`;
+						text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
 					} else if (editDiffPreview.diff) {
 						text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
 					}

package/src/prompts/tools/browser.md

@@ -16,7 +16,7 @@ Use this tool to navigate, click, type, scroll, drag, query DOM content, and cap
 - Use `action: "get_text"`, `"get_html"`, or `"get_attribute"` for DOM queries
   - For batch queries, pass `args: [{ selector, attribute? }]` to get an array of results (attribute required for `get_attribute`)
 - Use `action: "extract_readable"` to return reader-mode content (title/byline/excerpt/text or markdown)
-  - Set `format` to `"text"` (default) or `"markdown"`
+  - Set `format` to `"markdown"` (default) or `"text"`
 - Use `action: "screenshot"` to capture images (optionally with `selector` to capture a single element)
 - Use `action: "close"` to release the browser when done
 </instruction>

package/src/session/blob-store.ts

@@ -4,6 +4,12 @@ import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 
 const BLOB_PREFIX = "blob:sha256:";
 
+export interface BlobPutResult {
+	hash: string;
+	path: string;
+	get ref(): string;
+}
+
 /**
  * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
  *
@@ -18,22 +24,19 @@ export class BlobStore {
 	 * Write binary data to the blob store.
 	 * @returns SHA-256 hex hash of the data
 	 */
-	async put(data: Buffer): Promise<string> {
-		const hasher = new Bun.CryptoHasher("sha256");
-		hasher.update(data);
-		const hash = hasher.digest("hex");
+	async put(data: Buffer): Promise<BlobPutResult> {
+		const hash = new Bun.CryptoHasher("sha256").update(data).digest("hex");
 		const blobPath = path.join(this.dir, hash);
-
-		// Content-addressed: skip write if blob already exists
-		try {
-			await fs.access(blobPath);
-			return hash;
-		} catch {
-			// Does not exist, write it
-		}
+		const result = {
+			hash,
+			path: blobPath,
+			get ref() {
+				return `${BLOB_PREFIX}${hash}`;
+			},
+		};
 
 		await Bun.write(blobPath, data);
-		return hash;
+		return result;
 	}
 
 	/** Read blob by hash, returns Buffer or null if not found. */
@@ -71,11 +74,6 @@ export function parseBlobRef(data: string): string | null {
 	return data.slice(BLOB_PREFIX.length);
 }
 
-/** Create a blob reference string from a SHA-256 hash. */
-export function makeBlobRef(hash: string): string {
-	return `${BLOB_PREFIX}${hash}`;
-}
-
 /**
  * Externalize an image's base64 data to the blob store, returning a blob reference.
  * If the data is already a blob reference, returns it unchanged.
@@ -83,8 +81,8 @@ export function makeBlobRef(hash: string): string {
 export async function externalizeImageData(blobStore: BlobStore, base64Data: string): Promise<string> {
 	if (isBlobRef(base64Data)) return base64Data;
 	const buffer = Buffer.from(base64Data, "base64");
-	const hash = await blobStore.put(buffer);
-	return makeBlobRef(hash);
+	const { ref } = await blobStore.put(buffer);
+	return ref;
 }
 
 /**

package/src/session/session-manager.ts

@@ -1,9 +1,10 @@
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent, Usage } from "@oh-my-pi/pi-ai";
 import { isEnoent, logger, parseJsonlLenient, Snowflake } from "@oh-my-pi/pi-utils";
 import { getBlobsDir, getAgentDir as getDefaultAgentDir } from "../config";
-import { BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store";
+import { type BlobPutResult, BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -222,6 +223,7 @@ export type ReadonlySessionManager = Pick<
 	| "getEntries"
 	| "getTree"
 	| "getUsageStatistics"
+	| "putBlob"
 >;
 
 /** Generate a unique short ID (8 hex chars, collision-checked) */
@@ -468,6 +470,96 @@ function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
 	return sessionDir;
 }
 
+// =============================================================================
+// Terminal breadcrumbs: maps terminal (TTY) -> last session file for --continue
+// =============================================================================
+
+const TERMINAL_SESSIONS_DIR = "terminal-sessions";
+
+/**
+ * Get a stable identifier for the current terminal.
+ * Uses the TTY device path (e.g., /dev/pts/3), falling back to environment
+ * variables for terminal multiplexers or terminal emulators.
+ * Returns null if no terminal can be identified (e.g., piped input).
+ */
+function getTerminalId(): string | null {
+	// TTY device path — most reliable, unique per terminal tab
+	if (process.stdin.isTTY) {
+		try {
+			// On Linux/macOS, /proc/self/fd/0 -> /dev/pts/N
+			const ttyPath = fs.readlinkSync("/proc/self/fd/0");
+			if (ttyPath.startsWith("/dev/")) {
+				return ttyPath.slice(5).replace(/\//g, "-"); // /dev/pts/3 -> pts-3
+			}
+		} catch {}
+	}
+
+	// Fallback to terminal-specific env vars
+	const kittyId = process.env.KITTY_WINDOW_ID;
+	if (kittyId) return `kitty-${kittyId}`;
+
+	const tmuxPane = process.env.TMUX_PANE;
+	if (tmuxPane) return `tmux-${tmuxPane}`;
+
+	const terminalSessionId = process.env.TERM_SESSION_ID; // macOS Terminal.app
+	if (terminalSessionId) return `apple-${terminalSessionId}`;
+
+	const wtSession = process.env.WT_SESSION; // Windows Terminal
+	if (wtSession) return `wt-${wtSession}`;
+
+	return null;
+}
+
+/**
+ * Write a breadcrumb linking the current terminal to a session file.
+ * The breadcrumb contains the cwd and session path so --continue can
+ * find "this terminal's last session" even when running concurrent instances.
+ */
+function writeTerminalBreadcrumb(cwd: string, sessionFile: string): void {
+	const terminalId = getTerminalId();
+	if (!terminalId) return;
+
+	try {
+		const breadcrumbDir = path.join(getDefaultAgentDir(), TERMINAL_SESSIONS_DIR);
+		const breadcrumbFile = path.join(breadcrumbDir, terminalId);
+		const content = `${cwd}\n${sessionFile}\n`;
+		// Bun.write auto-creates parent dirs
+		void Bun.write(breadcrumbFile, content);
+	} catch {
+		// Best-effort — don't break session creation if breadcrumb fails
+	}
+}
+
+/**
+ * Read the terminal breadcrumb for the current terminal, scoped to a cwd.
+ * Returns the session file path if it exists and matches the cwd, null otherwise.
+ */
+async function readTerminalBreadcrumb(cwd: string): Promise<string | null> {
+	const terminalId = getTerminalId();
+	if (!terminalId) return null;
+
+	try {
+		const breadcrumbFile = path.join(getDefaultAgentDir(), TERMINAL_SESSIONS_DIR, terminalId);
+		const content = await Bun.file(breadcrumbFile).text();
+		const lines = content.trim().split("\n");
+		if (lines.length < 2) return null;
+
+		const breadcrumbCwd = lines[0];
+		const sessionFile = lines[1];
+
+		// Only return if cwd matches (user might have cd'd)
+		if (path.resolve(breadcrumbCwd) !== path.resolve(cwd)) return null;
+
+		// Verify the session file still exists
+		const stat = fs.statSync(sessionFile, { throwIfNoEntry: false });
+		if (stat?.isFile()) return sessionFile;
+	} catch (err) {
+		if (!isEnoent(err)) logger.debug("Terminal breadcrumb read failed", { err });
+		// Breadcrumb doesn't exist or is corrupt — fall through
+	}
+	return null;
+}
+
 /** Exported for testing */
 export async function loadEntriesFromFile(
 	filePath: string,
@@ -1013,6 +1105,11 @@ export class SessionManager {
 		// Note: call _initSession() or _initSessionFile() after construction
 	}
 
+	/** Puts a binary blob into the blob store and returns the blob reference */
+	async putBlob(data: Buffer): Promise<BlobPutResult> {
+		return this.blobStore.put(data);
+	}
+
 	/** Initialize with a specific session file (used by factory methods) */
 	private async _initSessionFile(sessionFile: string): Promise<void> {
 		await this.setSessionFile(sessionFile);
@@ -1029,6 +1126,7 @@ export class SessionManager {
 		this.persistError = undefined;
 		this.persistErrorReported = false;
 		this.sessionFile = path.resolve(sessionFile);
+		writeTerminalBreadcrumb(this.cwd, this.sessionFile);
 		this.fileEntries = await loadEntriesFromFile(this.sessionFile, this.storage);
 		if (this.fileEntries.length > 0) {
 			const header = this.fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
@@ -1134,6 +1232,7 @@ export class SessionManager {
 		if (this.persist) {
 			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 			this.sessionFile = path.join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
+			writeTerminalBreadcrumb(this.cwd, this.sessionFile);
 		}
 		return this.sessionFile;
 	}
@@ -1992,7 +2091,9 @@ export class SessionManager {
 		storage: SessionStorage = new FileSessionStorage(),
 	): Promise<SessionManager> {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
-		const mostRecent = await findMostRecentSession(dir, storage);
+		// Prefer terminal-scoped breadcrumb (handles concurrent sessions correctly)
+		const terminalSession = await readTerminalBreadcrumb(cwd);
+		const mostRecent = terminalSession ?? (await findMostRecentSession(dir, storage));
 		const manager = new SessionManager(cwd, dir, true, storage);
 		if (mostRecent) {
 			await manager._initSessionFile(mostRecent);

package/src/tools/bash.ts

@@ -17,7 +17,7 @@ import { applyHeadTail, normalizeBashCommand } from "./bash-normalize";
 import type { OutputMeta } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
 import { resolveToCwd } from "./path-utils";
-import { formatBytes, wrapBrackets } from "./render-utils";
+import { formatBytes, replaceTabs, wrapBrackets } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { DEFAULT_MAX_BYTES } from "./truncate";
@@ -271,11 +271,13 @@ export const bashToolRenderer = {
 				const hasOutput = displayOutput.trim().length > 0;
 				if (hasOutput) {
 					if (expanded) {
-						outputLines.push(...displayOutput.split("\n").map(line => uiTheme.fg("toolOutput", line)));
+						outputLines.push(
+							...displayOutput.split("\n").map(line => uiTheme.fg("toolOutput", replaceTabs(line))),
+						);
 					} else {
 						const styledOutput = displayOutput
 							.split("\n")
-							.map(line => uiTheme.fg("toolOutput", line))
+							.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
 							.join("\n");
 						const textContent = styledOutput;
 						const result = truncateToVisualLines(textContent, previewLines, width);

package/src/tools/browser.ts

@@ -1,8 +1,9 @@
+import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { Readability } from "@mozilla/readability";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { JSDOM, VirtualConsole } from "jsdom";
 import type { Browser, CDPSession, ElementHandle, KeyInput, Page, SerializedAXNode } from "puppeteer";
@@ -13,7 +14,6 @@ import type { ToolSession } from "../sdk";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { htmlToBasicMarkdown } from "../web/scrapers/types";
 import type { OutputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
 import stealthTamperingScript from "./puppeteer/00_stealth_tampering.txt" with { type: "text" };
 import stealthActivityScript from "./puppeteer/01_stealth_activity.txt" with { type: "text" };
 import stealthHairlineScript from "./puppeteer/02_stealth_hairline.txt" with { type: "text" };
@@ -319,11 +319,10 @@ const browserSchema = Type.Object({
 	),
 	full_page: Type.Optional(Type.Boolean({ description: "Capture full page screenshot (screenshot)" })),
 	format: Type.Optional(
-		StringEnum(["png", "jpeg", "text", "markdown"], {
-			description: "Output format (screenshot: png/jpeg, extract_readable: text/markdown)",
+		StringEnum(["text", "markdown"], {
+			description: "Output format for extract_readable (text/markdown)",
 		}),
 	),
-	quality: Type.Optional(Type.Number({ description: "JPEG quality 0-100 (screenshot)" })),
 	path: Type.Optional(Type.String({ description: "Optional path to save screenshot (relative to cwd)" })),
 	viewport: Type.Optional(
 		Type.Object({
@@ -407,11 +406,6 @@ function clampTimeout(timeoutSeconds?: number): number {
 	return Math.min(Math.max(timeoutSeconds, 1), MAX_TIMEOUT_SECONDS);
 }
 
-function clampQuality(quality?: number): number | undefined {
-	if (quality === undefined) return undefined;
-	return Math.min(Math.max(quality, 0), 100);
-}
-
 function ensureParam<T>(value: T | undefined, name: string, action: string): T {
 	if (value === undefined || value === null || value === "") {
 		throw new ToolError(`Missing required parameter '${name}' for action '${action}'.`);
@@ -419,10 +413,6 @@ function ensureParam<T>(value: T | undefined, name: string, action: string): T {
 	return value;
 }
 
-function resolveArtifactsDir(session: ToolSession): string | null {
-	return session.getArtifactsDir?.() ?? session.getSessionFile()?.slice(0, -6) ?? null;
-}
-
 function formatEvaluateResult(value: unknown): string {
 	if (typeof value === "string") return value;
 	if (value === undefined) return "undefined";
@@ -895,7 +885,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		params: BrowserParams,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<BrowserToolDetails>,
-		_context?: AgentToolContext,
+		_ctx?: AgentToolContext,
 	): Promise<AgentToolResult<BrowserToolDetails>> {
 		try {
 			throwIfAborted(signal);
@@ -1237,10 +1227,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 				}
 				case "extract_readable": {
 					const page = await this.ensurePage(params);
-					const format = params.format ?? "text";
-					if (format !== "text" && format !== "markdown") {
-						throw new ToolError("extract_readable format must be text or markdown");
-					}
+					const format = params.format ?? "markdown";
 					const html = (await untilAborted(signal, () => page.content())) as string;
 					const url = page.url();
 					const virtualConsole = new VirtualConsole();
@@ -1277,13 +1264,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 				}
 				case "screenshot": {
 					const page = await this.ensurePage(params);
-					const format = params.format ?? "png";
-					if (format !== "png" && format !== "jpeg") {
-						throw new ToolError("Screenshot format must be png or jpeg");
-					}
-					const imageFormat = format;
 					const fullPage = params.selector ? false : (params.full_page ?? false);
-					const quality = imageFormat === "jpeg" ? clampQuality(params.quality ?? 80) : undefined;
 					let buffer: Buffer;
 
 					if (params.selector) {
@@ -1292,47 +1273,34 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 						if (!handle) {
 							throw new ToolError("Screenshot selector did not resolve to an element");
 						}
-						buffer = (await untilAborted(signal, () =>
-							handle.screenshot({ type: imageFormat, quality }),
-						)) as Buffer;
+						buffer = (await untilAborted(signal, () => handle.screenshot({ type: "png" }))) as Buffer;
 						await handle.dispose();
 						details.selector = params.selector;
 					} else {
-						buffer = (await untilAborted(signal, () =>
-							page.screenshot({ type: imageFormat, quality, fullPage }),
-						)) as Buffer;
+						buffer = (await untilAborted(signal, () => page.screenshot({ type: "png", fullPage }))) as Buffer;
 					}
 
-					const mimeType = imageFormat === "png" ? "image/png" : "image/jpeg";
-					const base64 = buffer.toBase64();
-					let savedPath: string | undefined;
-					if (params.path) {
-						const resolved = resolveToCwd(params.path, this.session.cwd);
-						const ext = path.extname(resolved);
-						savedPath = ext ? resolved : `${resolved}.${imageFormat}`;
-						await Bun.write(savedPath, buffer);
-					} else {
-						const artifactsDir = resolveArtifactsDir(this.session);
-						if (artifactsDir) {
-							savedPath = path.join(artifactsDir, `puppeteer-${Date.now()}.${imageFormat}`);
-							await Bun.write(savedPath, buffer);
-						}
-					}
-					details.screenshotPath = savedPath;
-					details.mimeType = mimeType;
-					details.bytes = buffer.length;
-
 					// Compress for API content (same as pasted images)
-					const resized = await resizeImage({ type: "image", data: base64, mimeType });
+					// NOTE: screenshots can be deceptively large (especially PNG) even at modest resolutions,
+					// and tool results are immediately embedded in the next LLM request.
+					// Use a tighter budget than the global per-image limit to avoid 413 request_too_large.
+					const resized = await resizeImage(
+						{ type: "image", data: buffer.toBase64(), mimeType: "image/png" },
+						{ maxBytes: 0.75 * 1024 * 1024 },
+					);
 					const dimensionNote = formatDimensionNote(resized);
-
-					const lines = ["Screenshot captured", `Format: ${format}`, `Bytes: ${buffer.length}`];
-					if (resized.wasResized) {
-						lines.push(`Compressed: ${resized.width}x${resized.height} (${resized.mimeType})`);
-					}
-					if (savedPath) {
-						lines.push(`Saved: ${savedPath}`);
-					}
+					const tempFile = path.join(tmpdir(), `omp-sshots-${Snowflake.next()}.png`);
+					await Bun.write(tempFile, resized.buffer);
+					details.screenshotPath = tempFile;
+					details.mimeType = resized.mimeType;
+					details.bytes = resized.buffer.length;
+
+					// Show both raw bytes (saved to disk) and compressed bytes (sent to model).
+					const lines = [
+						"Screenshot captured",
+						`Format: ${resized.mimeType} (${(resized.buffer.length / 1024).toFixed(2)} KB)`,
+						`Dimensions: ${resized.width}x${resized.height}`,
+					];
 					if (dimensionNote) {
 						lines.push(dimensionNote);
 					}

package/src/utils/image-resize.ts

@@ -9,13 +9,14 @@ export interface ImageResizeOptions {
 }
 
 export interface ResizedImage {
-	data: string; // base64
+	buffer: Uint8Array;
 	mimeType: string;
 	originalWidth: number;
 	originalHeight: number;
 	width: number;
 	height: number;
 	wasResized: boolean;
+	get data(): string;
 }
 
 // 4.5MB - provides headroom below Anthropic's 5MB limit
@@ -64,13 +65,16 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		const originalSize = inputBuffer.length;
 		if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= opts.maxBytes) {
 			return {
-				data: img.data,
+				buffer: inputBuffer,
 				mimeType: img.mimeType ?? `image/${format}`,
 				originalWidth,
 				originalHeight,
 				width: originalWidth,
 				height: originalHeight,
 				wasResized: false,
+				get data() {
+					return img.data;
+				},
 			};
 		}
 
@@ -119,13 +123,16 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 		if (best.buffer.length <= opts.maxBytes) {
 			return {
-				data: best.buffer.toBase64(),
+				buffer: best.buffer,
 				mimeType: best.mimeType,
 				originalWidth,
 				originalHeight,
 				width: finalWidth,
 				height: finalHeight,
 				wasResized: true,
+				get data() {
+					return best.buffer.toBase64();
+				},
 			};
 		}
 
@@ -135,13 +142,16 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 			if (best.buffer.length <= opts.maxBytes) {
 				return {
-					data: best.buffer.toBase64(),
+					buffer: best.buffer,
 					mimeType: best.mimeType,
 					originalWidth,
 					originalHeight,
 					width: finalWidth,
 					height: finalHeight,
 					wasResized: true,
+					get data() {
+						return best.buffer.toBase64();
+					},
 				};
 			}
 		}
@@ -160,13 +170,16 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 				if (best.buffer.length <= opts.maxBytes) {
 					return {
-						data: best.buffer.toBase64(),
+						buffer: best.buffer,
 						mimeType: best.mimeType,
 						originalWidth,
 						originalHeight,
 						width: finalWidth,
 						height: finalHeight,
 						wasResized: true,
+						get data() {
+							return best.buffer.toBase64();
+						},
 					};
 				}
 			}
@@ -174,24 +187,30 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 		// Last resort: return smallest version we produced
 		return {
-			data: best.buffer.toBase64(),
+			buffer: best.buffer,
 			mimeType: best.mimeType,
 			originalWidth,
 			originalHeight,
 			width: finalWidth,
 			height: finalHeight,
 			wasResized: true,
+			get data() {
+				return best.buffer.toBase64();
+			},
 		};
 	} catch {
 		// Failed to load image
 		return {
-			data: img.data,
+			buffer: inputBuffer,
 			mimeType: img.mimeType,
 			originalWidth: 0,
 			originalHeight: 0,
 			width: 0,
 			height: 0,
 			wasResized: false,
+			get data() {
+				return img.data;
+			},
 		};
 	}
 }