@oh-my-pi/pi-coding-agent 13.10.1 → 13.11.0

package/src/tools/path-utils.ts

@@ -4,6 +4,14 @@ import * as path from "node:path";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const NARROW_NO_BREAK_SPACE = "\u202F";
+const TOP_LEVEL_INTERNAL_URL_PREFIXES = [
+	"agent://",
+	"artifact://",
+	"skill://",
+	"rule://",
+	"local://",
+	"mcp://",
+] as const;
 
 function normalizeUnicodeSpaces(str: string): string {
 	return str.replace(UNICODE_SPACES, " ");
@@ -38,6 +46,15 @@ function fileExists(filePath: string): boolean {
 	}
 }
 
+async function pathExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.promises.access(filePath, fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 function normalizeAtPrefix(filePath: string): string {
 	if (!filePath.startsWith("@")) return filePath;
 
@@ -105,6 +122,24 @@ export interface ParsedSearchPath {
 	glob?: string;
 }
 
+export interface ParsedFindPattern {
+	basePath: string;
+	globPattern: string;
+	hasGlob: boolean;
+}
+
+export interface ResolvedMultiSearchPath {
+	basePath: string;
+	glob?: string;
+	scopePath: string;
+}
+
+export interface ResolvedMultiFindPattern {
+	basePath: string;
+	globPattern: string;
+	scopePath: string;
+}
+
 /**
  * Split a user path into a base path + glob pattern for tools that delegate to
  * APIs accepting separate `path` and `glob` arguments.
@@ -128,6 +163,44 @@ export function parseSearchPath(filePath: string): ParsedSearchPath {
 	};
 }
 
+// Parse a find pattern into a base directory path and a glob pattern.
+// Examples:
+//   src/app/**/\*.tsx -> { basePath: "src/app", globPattern: "**/*.tsx", hasGlob: true }
+//   src/app/\*.tsx -> { basePath: "src/app", globPattern: "*.tsx", hasGlob: true }
+//   \*.ts -> { basePath: ".", globPattern: "**/*.ts", hasGlob: true }
+//   **/\*.json -> { basePath: ".", globPattern: "**/*.json", hasGlob: true }
+//   /abs/path/**/\*.ts -> { basePath: "/abs/path", globPattern: "**/*.ts", hasGlob: true }
+//   src/app -> { basePath: "src/app", globPattern: "**/*", hasGlob: false }
+export function parseFindPattern(pattern: string): ParsedFindPattern {
+	const segments = pattern.split("/");
+	let firstGlobIndex = -1;
+	for (let i = 0; i < segments.length; i++) {
+		if (hasGlobPathChars(segments[i])) {
+			firstGlobIndex = i;
+			break;
+		}
+	}
+
+	if (firstGlobIndex === -1) {
+		return { basePath: pattern, globPattern: "**/*", hasGlob: false };
+	}
+
+	if (firstGlobIndex === 0) {
+		const needsRecursive = !pattern.startsWith("**/");
+		return {
+			basePath: ".",
+			globPattern: needsRecursive ? `**/${pattern}` : pattern,
+			hasGlob: true,
+		};
+	}
+
+	return {
+		basePath: segments.slice(0, firstGlobIndex).join("/"),
+		globPattern: segments.slice(firstGlobIndex).join("/"),
+		hasGlob: true,
+	};
+}
+
 export function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): string | undefined {
 	if (!prefixGlob) return suffixGlob;
 	if (!suffixGlob) return prefixGlob;
@@ -138,6 +211,281 @@ export function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): st
 	return `${normalizedPrefix}/${normalizedSuffix}`;
 }
 
+type TopLevelSeparator = "comma" | "whitespace";
+
+function splitTopLevel(value: string, separator: TopLevelSeparator): string[] {
+	const parts: string[] = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let quote: '"' | "'" | undefined;
+	let escaped = false;
+
+	const pushCurrent = () => {
+		const normalized = current.trim();
+		if (normalized.length > 0) {
+			parts.push(normalized);
+		}
+		current = "";
+	};
+
+	for (const char of value) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+
+		if (quote) {
+			current += char;
+			if (char === quote) {
+				quote = undefined;
+			}
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			quote = char;
+			current += char;
+			continue;
+		}
+
+		if (char === "{") braceDepth += 1;
+		else if (char === "}" && braceDepth > 0) braceDepth -= 1;
+		else if (char === "[") bracketDepth += 1;
+		else if (char === "]" && bracketDepth > 0) bracketDepth -= 1;
+		else if (char === "(") parenDepth += 1;
+		else if (char === ")" && parenDepth > 0) parenDepth -= 1;
+
+		const topLevel = braceDepth === 0 && bracketDepth === 0 && parenDepth === 0;
+		const isWhitespace = /\s/.test(char);
+		if (topLevel && separator === "comma" && char === ",") {
+			pushCurrent();
+			continue;
+		}
+		if (topLevel && separator === "whitespace" && isWhitespace) {
+			pushCurrent();
+			continue;
+		}
+
+		current += char;
+	}
+
+	pushCurrent();
+	return parts.length > 1 ? parts : [value.trim()];
+}
+
+function normalizePosixPath(filePath: string): string {
+	return filePath.replace(/\\/g, "/");
+}
+
+function joinRelativeGlob(basePath: string | undefined, globPattern: string): string {
+	if (!basePath || basePath === ".") return normalizePosixPath(globPattern).replace(/^\/+/, "");
+	const normalizedBase = normalizePosixPath(basePath).replace(/\/+$/, "");
+	const normalizedGlob = normalizePosixPath(globPattern).replace(/^\/+/, "");
+	return `${normalizedBase}/${normalizedGlob}`;
+}
+
+function buildBraceUnion(patterns: string[]): string | undefined {
+	const uniquePatterns = [...new Set(patterns.map(pattern => normalizePosixPath(pattern).trim()).filter(Boolean))];
+	if (uniquePatterns.length === 0) return undefined;
+	if (uniquePatterns.length === 1) return uniquePatterns[0];
+	return `{${uniquePatterns.join(",")}}`;
+}
+
+function findCommonBasePath(paths: string[]): string {
+	if (paths.length === 0) return ".";
+	let commonParts = path.resolve(paths[0]).split(path.sep);
+	for (const candidatePath of paths.slice(1)) {
+		const candidateParts = path.resolve(candidatePath).split(path.sep);
+		let sharedCount = 0;
+		const maxShared = Math.min(commonParts.length, candidateParts.length);
+		while (sharedCount < maxShared && commonParts[sharedCount] === candidateParts[sharedCount]) {
+			sharedCount += 1;
+		}
+		commonParts = commonParts.slice(0, sharedCount);
+	}
+	if (commonParts.length === 0) {
+		return path.parse(path.resolve(paths[0])).root;
+	}
+	const joined = commonParts.join(path.sep);
+	return joined || path.parse(path.resolve(paths[0])).root;
+}
+
+function toScopeDisplay(items: string[]): string {
+	return items.map(item => normalizePosixPath(item)).join(", ");
+}
+
+function looksLikeDelimitedPathToken(token: string): boolean {
+	return (
+		TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix)) ||
+		token.startsWith(".") ||
+		token.startsWith("/") ||
+		token.startsWith("~") ||
+		token.startsWith("@") ||
+		token.includes("/") ||
+		token.includes("\\") ||
+		hasGlobPathChars(token) ||
+		/\.[^./\\]+$/.test(token)
+	);
+}
+
+async function areDelimitedTokensResolvable(
+	tokens: string[],
+	cwd: string,
+	parseBasePath: (value: string) => string,
+	allowBareExistingTokens: boolean,
+): Promise<boolean> {
+	for (const token of tokens) {
+		if (TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix))) {
+			return false;
+		}
+
+		if (!allowBareExistingTokens && !looksLikeDelimitedPathToken(token)) {
+			// Bare names like "packages" don't look like path tokens syntactically,
+			// but may still be valid directory names. Check existence before rejecting.
+			const resolvedExactPath = resolveToCwd(token, cwd);
+			if (!(await pathExists(resolvedExactPath))) {
+				return false;
+			}
+			continue;
+		}
+
+		const basePath = parseBasePath(token);
+		const resolvedBasePath = resolveToCwd(basePath, cwd);
+		if (await pathExists(resolvedBasePath)) {
+			continue;
+		}
+
+		if (!allowBareExistingTokens) {
+			return false;
+		}
+
+		const resolvedExactPath = resolveToCwd(token, cwd);
+		if (!(await pathExists(resolvedExactPath))) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+async function splitDelimitedSearchInput(
+	rawInput: string,
+	cwd: string,
+	parseBasePath: (value: string) => string,
+): Promise<string[] | undefined> {
+	const trimmed = rawInput.trim();
+	if (!trimmed) return undefined;
+
+	const resolvedExactPath = resolveToCwd(trimmed, cwd);
+	if (await pathExists(resolvedExactPath)) {
+		return undefined;
+	}
+
+	const commaSeparated = splitTopLevel(trimmed, "comma");
+	if (commaSeparated.length > 1 && (await areDelimitedTokensResolvable(commaSeparated, cwd, parseBasePath, true))) {
+		return [...new Set(commaSeparated)];
+	}
+
+	const whitespaceSeparated = splitTopLevel(trimmed, "whitespace");
+	if (
+		whitespaceSeparated.length > 1 &&
+		(await areDelimitedTokensResolvable(whitespaceSeparated, cwd, parseBasePath, false))
+	) {
+		return [...new Set(whitespaceSeparated)];
+	}
+
+	return undefined;
+}
+
+export async function resolveMultiSearchPath(
+	rawPath: string,
+	cwd: string,
+	suffixGlob?: string,
+): Promise<ResolvedMultiSearchPath | undefined> {
+	const pathItems = await splitDelimitedSearchInput(rawPath, cwd, value => parseSearchPath(value).basePath);
+	if (!pathItems || pathItems.length <= 1) {
+		return undefined;
+	}
+
+	const parsedItems = await Promise.all(
+		pathItems.map(async item => {
+			const parsedPath = parseSearchPath(item);
+			const absoluteBasePath = resolveToCwd(parsedPath.basePath, cwd);
+			const stat = await fs.promises.stat(absoluteBasePath);
+			return { raw: item, parsedPath, absoluteBasePath, stat };
+		}),
+	);
+
+	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
+	const combinedPatterns = parsedItems.map(item => {
+		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
+		if (item.parsedPath.glob) {
+			const pathGlob = joinRelativeGlob(relativeBasePath, item.parsedPath.glob);
+			return combineSearchGlobs(pathGlob, suffixGlob) ?? pathGlob;
+		}
+		if (suffixGlob) {
+			const pathPrefix = relativeBasePath === "." ? undefined : relativeBasePath;
+			return combineSearchGlobs(pathPrefix, suffixGlob) ?? suffixGlob;
+		}
+		if (item.stat.isDirectory()) {
+			return joinRelativeGlob(relativeBasePath, "**/*");
+		}
+		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
+	});
+
+	return {
+		basePath: commonBasePath,
+		glob: buildBraceUnion(combinedPatterns),
+		scopePath: toScopeDisplay(pathItems),
+	};
+}
+
+export async function resolveMultiFindPattern(
+	rawPattern: string,
+	cwd: string,
+): Promise<ResolvedMultiFindPattern | undefined> {
+	const patternItems = await splitDelimitedSearchInput(rawPattern, cwd, value => parseFindPattern(value).basePath);
+	if (!patternItems || patternItems.length <= 1) {
+		return undefined;
+	}
+
+	const parsedItems = await Promise.all(
+		patternItems.map(async item => {
+			const parsedPattern = parseFindPattern(item);
+			const absoluteBasePath = resolveToCwd(parsedPattern.basePath, cwd);
+			const stat = await fs.promises.stat(absoluteBasePath);
+			return { raw: item, parsedPattern, absoluteBasePath, stat };
+		}),
+	);
+
+	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
+	const combinedPatterns = parsedItems.map(item => {
+		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
+		if (item.parsedPattern.hasGlob) {
+			return joinRelativeGlob(relativeBasePath, item.parsedPattern.globPattern);
+		}
+		if (item.stat.isDirectory()) {
+			return joinRelativeGlob(relativeBasePath, "**/*");
+		}
+		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
+	});
+
+	return {
+		basePath: commonBasePath,
+		globPattern: buildBraceUnion(combinedPatterns) ?? "**/*",
+		scopePath: toScopeDisplay(patternItems),
+	};
+}
+
 export function resolveReadPath(filePath: string, cwd: string): string {
 	const resolved = resolveToCwd(filePath, cwd);
 	const shellEscapedVariant = tryShellEscapedPath(resolved);

package/src/tools/todo-write.ts

@@ -24,6 +24,7 @@ export interface TodoItem {
 	content: string;
 	status: TodoStatus;
 	notes?: string;
+	details?: string;
 }
 
 export interface TodoPhase {
@@ -49,6 +50,9 @@ const InputTask = Type.Object({
 	content: Type.String({ description: "Task description" }),
 	status: Type.Optional(StatusEnum),
 	notes: Type.Optional(Type.String({ description: "Additional context or notes" })),
+	details: Type.Optional(
+		Type.String({ description: "Implementation details, file paths, and specifics (shown only when active)" }),
+	),
 });
 
 const InputPhase = Type.Object({
@@ -73,6 +77,7 @@ const todoWriteSchema = Type.Object({
 				phase: Type.String({ description: "Phase ID, e.g. phase-1" }),
 				content: Type.String({ description: "Task description" }),
 				notes: Type.Optional(Type.String({ description: "Additional context or notes" })),
+				details: Type.Optional(Type.String({ description: "Implementation details, file paths, and specifics" })),
 			}),
 			Type.Object({
 				op: Type.Literal("update"),
@@ -80,6 +85,7 @@ const todoWriteSchema = Type.Object({
 				status: Type.Optional(StatusEnum),
 				content: Type.Optional(Type.String({ description: "Updated task description" })),
 				notes: Type.Optional(Type.String({ description: "Additional context or notes" })),
+				details: Type.Optional(Type.String({ description: "Updated details" })),
 			}),
 			Type.Object({
 				op: Type.Literal("remove_task"),
@@ -118,14 +124,20 @@ function findTask(phases: TodoPhase[], id: string): TodoItem | undefined {
 }
 
 function buildPhaseFromInput(
-	input: { name: string; tasks?: Array<{ content: string; status?: TodoStatus; notes?: string }> },
+	input: { name: string; tasks?: Array<{ content: string; status?: TodoStatus; notes?: string; details?: string }> },
 	phaseId: string,
 	nextTaskId: number,
 ): { phase: TodoPhase; nextTaskId: number } {
 	const tasks: TodoItem[] = [];
 	let tid = nextTaskId;
 	for (const t of input.tasks ?? []) {
-		tasks.push({ id: `task-${tid++}`, content: t.content, status: t.status ?? "pending", notes: t.notes });
+		tasks.push({
+			id: `task-${tid++}`,
+			content: t.content,
+			status: t.status ?? "pending",
+			notes: t.notes,
+			details: t.details,
+		});
 	}
 	return { phase: { id: phaseId, name: input.name, tasks }, nextTaskId: tid };
 }
@@ -231,6 +243,7 @@ function applyOps(file: TodoFile, ops: TodoWriteParams["ops"]): { file: TodoFile
 					content: op.content,
 					status: "pending",
 					notes: op.notes,
+					details: op.details,
 				});
 				break;
 			}
@@ -244,6 +257,7 @@ function applyOps(file: TodoFile, ops: TodoWriteParams["ops"]): { file: TodoFile
 				if (op.status !== undefined) task.status = op.status;
 				if (op.content !== undefined) task.content = op.content;
 				if (op.notes !== undefined) task.notes = op.notes;
+				if (op.details !== undefined) task.details = op.details;
 				break;
 			}
 
@@ -293,6 +307,11 @@ function formatSummary(phases: TodoPhase[], errors: string[]): string {
 		lines.push(`Remaining items (${remainingTasks.length}):`);
 		for (const task of remainingTasks) {
 			lines.push(`  - ${task.id} ${task.content} [${task.status}] (${task.phase})`);
+			if (task.status === "in_progress" && task.details) {
+				for (const line of task.details.split("\n")) {
+					lines.push(`      ${line}`);
+				}
+			}
 		}
 	}
 	lines.push(
@@ -364,8 +383,12 @@ function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string
 	switch (item.status) {
 		case "completed":
 			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
-		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
+		case "in_progress": {
+			const main = uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
+			if (!item.details) return main;
+			const detailLines = item.details.split("\n").map(l => uiTheme.fg("dim", `${prefix}  ${l}`));
+			return [main, ...detailLines].join("\n");
+		}
 		case "abandoned":
 			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`);
 		default:

package/src/utils/commit-message-generator.ts

@@ -2,14 +2,17 @@
  * Generate commit messages from diffs using a smol, fast model.
  * Follows the same pattern as title-generator.ts.
  */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
-import { parseModelString } from "../config/model-resolver";
+import { resolveModelRoleValue } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
+import type { Settings } from "../config/settings";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
+import { toReasoningEffort } from "../thinking";
 
 const COMMIT_SYSTEM_PROMPT = renderPromptTemplate(commitSystemPrompt);
 const MAX_DIFF_CHARS = 4000;
@@ -32,24 +35,26 @@ function filterDiffNoise(diff: string): string {
 	return filtered.join("\n");
 }
 
-function getSmolModelCandidates(registry: ModelRegistry, savedSmolModel?: string): Model<Api>[] {
+function getSmolModelCandidates(
+	registry: ModelRegistry,
+	settings: Settings,
+): Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> {
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return [];
 
-	const candidates: Model<Api>[] = [];
-	const addCandidate = (model?: Model<Api>): void => {
+	const candidates: Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> = [];
+	const addCandidate = (model?: Model<Api>, thinkingLevel?: ThinkingLevel): void => {
 		if (!model) return;
-		if (candidates.some(c => c.provider === model.provider && c.id === model.id)) return;
-		candidates.push(model);
+		if (candidates.some(c => c.model.provider === model.provider && c.model.id === model.id)) return;
+		candidates.push({ model, thinkingLevel });
 	};
 
-	if (savedSmolModel) {
-		const parsed = parseModelString(savedSmolModel);
-		if (parsed) {
-			const match = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-			addCandidate(match);
-		}
-	}
+	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
+		settings,
+		matchPreferences,
+	});
+	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
 
 	for (const pattern of MODEL_PRIO.smol) {
 		const needle = pattern.toLowerCase();
@@ -71,10 +76,10 @@ function getSmolModelCandidates(registry: ModelRegistry, savedSmolModel?: string
 export async function generateCommitMessage(
 	diff: string,
 	registry: ModelRegistry,
-	savedSmolModel?: string,
+	settings: Settings,
 	sessionId?: string,
 ): Promise<string | null> {
-	const candidates = getSmolModelCandidates(registry, savedSmolModel);
+	const candidates = getSmolModelCandidates(registry, settings);
 	if (candidates.length === 0) {
 		logger.debug("commit-msg-generator: no smol model found");
 		return null;
@@ -89,22 +94,22 @@ export async function generateCommitMessage(
 	}
 	const userMessage = `<diff>\n${truncatedDiff}\n</diff>`;
 
-	for (const model of candidates) {
-		const apiKey = await registry.getApiKey(model, sessionId);
+	for (const candidate of candidates) {
+		const apiKey = await registry.getApiKey(candidate.model, sessionId);
 		if (!apiKey) continue;
 
 		try {
 			const response = await completeSimple(
-				model,
+				candidate.model,
 				{
 					systemPrompt: COMMIT_SYSTEM_PROMPT,
 					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
 				},
-				{ apiKey, maxTokens: 60 },
+				{ apiKey, maxTokens: 60, reasoning: toReasoningEffort(candidate.thinkingLevel) },
 			);
 
 			if (response.stopReason === "error") {
-				logger.debug("commit-msg-generator: error", { model: model.id, error: response.errorMessage });
+				logger.debug("commit-msg-generator: error", { model: candidate.model.id, error: response.errorMessage });
 				continue;
 			}
 
@@ -118,11 +123,11 @@ export async function generateCommitMessage(
 			// Clean up: remove wrapping quotes, backticks, trailing period
 			msg = msg.replace(/^[`"']|[`"']$/g, "").replace(/\.$/, "");
 
-			logger.debug("commit-msg-generator: generated", { model: model.id, msg });
+			logger.debug("commit-msg-generator: generated", { model: candidate.model.id, msg });
 			return msg;
 		} catch (err) {
 			logger.debug("commit-msg-generator: error", {
-				model: model.id,
+				model: candidate.model.id,
 				error: err instanceof Error ? err.message : String(err),
 			});
 		}

package/src/utils/image-input.ts

@@ -231,7 +231,7 @@ export async function loadImageInput(options: LoadImageInputOptions): Promise<Lo
 		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
 	}
 
-	let outputData = new Uint8Array(inputBuffer).toBase64();
+	let outputData = Buffer.from(inputBuffer).toBase64();
 	let outputMimeType = mimeType;
 	let outputBytes = inputBuffer.byteLength;
 	let dimensionNote: string | undefined;

package/src/utils/image-resize.ts

@@ -136,7 +136,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 				height: finalHeight,
 				wasResized: true,
 				get data() {
-					return best.buffer.toBase64();
+					return Buffer.from(best.buffer).toBase64();
 				},
 			};
 		}
@@ -155,7 +155,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 					height: finalHeight,
 					wasResized: true,
 					get data() {
-						return best.buffer.toBase64();
+						return Buffer.from(best.buffer).toBase64();
 					},
 				};
 			}
@@ -183,7 +183,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 						height: finalHeight,
 						wasResized: true,
 						get data() {
-							return best.buffer.toBase64();
+							return Buffer.from(best.buffer).toBase64();
 						},
 					};
 				}
@@ -200,7 +200,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			height: finalHeight,
 			wasResized: true,
 			get data() {
-				return best.buffer.toBase64();
+				return Buffer.from(best.buffer).toBase64();
 			},
 		};
 	} catch {