@oh-my-pi/pi-coding-agent 13.9.2 → 13.9.4

package/src/tools/fetch.ts

@@ -74,6 +74,13 @@ const CONVERTIBLE_EXTENSIONS = new Set([
 	".ogg",
 ]);
 
+const IMAGE_MIME_BY_EXTENSION = new Map<string, string>([
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".gif", "image/gif"],
+	[".webp", "image/webp"],
+]);
 const SUPPORTED_INLINE_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 const MAX_INLINE_IMAGE_SOURCE_BYTES = 20 * 1024 * 1024;
 const MAX_INLINE_IMAGE_OUTPUT_BYTES = 0.75 * 1024 * 1024;
@@ -151,8 +158,12 @@ function isConvertible(mime: string, extensionHint: string): boolean {
 	return false;
 }
 
-function resolveImageMimeType(mime: string): string | null {
-	return mime.startsWith("image/") ? mime : null;
+function resolveImageMimeType(mime: string, extensionHint: string): string | null {
+	if (mime.startsWith("image/")) return mime;
+	const shouldUseExtensionHint =
+		mime.length === 0 || mime === "application/octet-stream" || mime === "binary/octet-stream" || mime === "unknown";
+	if (!shouldUseExtensionHint) return null;
+	return IMAGE_MIME_BY_EXTENSION.get(extensionHint) ?? null;
 }
 
 function isInlineImageMimeTypeSupported(mimeType: string): boolean {
@@ -653,120 +664,127 @@ async function renderUrl(
 	const mime = normalizeMime(response.contentType);
 	const extHint = getExtensionHint(finalUrl);
 
-	const imageMimeType = resolveImageMimeType(mime);
-	const canInlineImage = Boolean(imageMimeType && isInlineImageMimeTypeSupported(imageMimeType));
+	const imageMimeType = resolveImageMimeType(mime, extHint);
 	let skipConvertibleBinaryRetry = false;
-	if (imageMimeType && !canInlineImage) {
-		notes.push(
-			`Image MIME type ${imageMimeType} is unsupported for inline model serialization; falling back to textual rendering`,
-		);
-	}
-	if (canInlineImage && imageMimeType) {
-		const binary = await fetchBinary(finalUrl, timeout, signal);
-		if (binary.ok) {
-			notes.push("Fetched image binary");
-			const conversionExtension = getExtensionHint(finalUrl, binary.contentDisposition) || extHint;
-			let convertedText: string | null = null;
-			const converted = await convertWithMarkitdown(binary.buffer, conversionExtension, timeout, signal);
-			if (converted.ok) {
-				if (converted.content.trim().length > 50) {
-					notes.push("Converted with markitdown");
-					convertedText = converted.content;
-				} else {
-					notes.push("markitdown conversion produced no usable output");
-				}
-			} else if (converted.error) {
-				notes.push(`markitdown conversion failed: ${converted.error}`);
+	if (imageMimeType) {
+		if (!isInlineImageMimeTypeSupported(imageMimeType)) {
+			notes.push(
+				`Image MIME type ${imageMimeType} is unsupported for inline model serialization; returning text metadata only`,
+			);
+			const shouldTryConvertibleFallback = isConvertible(mime, extHint);
+			if (shouldTryConvertibleFallback) {
+				notes.push("Attempting binary conversion fallback for unsupported image MIME type");
 			} else {
-				notes.push("markitdown conversion failed");
+				notes.push("Falling back to textual rendering from initial response");
 			}
+			skipConvertibleBinaryRetry = !shouldTryConvertibleFallback;
+		} else {
+			const binary = await fetchBinary(finalUrl, timeout, signal);
+			if (binary.ok) {
+				notes.push("Fetched image binary");
+				const conversionExtension = getExtensionHint(finalUrl, binary.contentDisposition) || extHint;
+				let convertedText: string | null = null;
+				const converted = await convertWithMarkitdown(binary.buffer, conversionExtension, timeout, signal);
+				if (converted.ok) {
+					if (converted.content.trim().length > 50) {
+						notes.push("Converted with markitdown");
+						convertedText = converted.content;
+					} else {
+						notes.push("markitdown conversion produced no usable output");
+					}
+				} else if (converted.error) {
+					notes.push(`markitdown conversion failed: ${converted.error}`);
+				} else {
+					notes.push("markitdown conversion failed");
+				}
 
-			if (binary.buffer.byteLength > MAX_INLINE_IMAGE_SOURCE_BYTES) {
-				notes.push(
-					`Image exceeds inline source limit (${binary.buffer.byteLength} bytes > ${MAX_INLINE_IMAGE_SOURCE_BYTES} bytes)`,
-				);
-				const output = finalizeOutput(
-					convertedText ?? `Fetched image content (${imageMimeType}), but it is too large to inline render.`,
-				);
-				return {
-					url,
-					finalUrl,
-					contentType: imageMimeType,
-					method: convertedText ? "markitdown" : "image-too-large",
-					content: output.content,
-					fetchedAt,
-					truncated: output.truncated,
-					notes,
-				};
-			}
+				if (binary.buffer.byteLength > MAX_INLINE_IMAGE_SOURCE_BYTES) {
+					notes.push(
+						`Image exceeds inline source limit (${binary.buffer.byteLength} bytes > ${MAX_INLINE_IMAGE_SOURCE_BYTES} bytes)`,
+					);
+					const output = finalizeOutput(
+						convertedText ?? `Fetched image content (${imageMimeType}), but it is too large to inline render.`,
+					);
+					return {
+						url,
+						finalUrl,
+						contentType: imageMimeType,
+						method: convertedText ? "markitdown" : "image-too-large",
+						content: output.content,
+						fetchedAt,
+						truncated: output.truncated,
+						notes,
+					};
+				}
 
-			const resized = await resizeImage(
-				{ type: "image", data: binary.buffer.toBase64(), mimeType: imageMimeType },
-				{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES },
-			);
-			const isDecodedImage =
-				resized.originalWidth > 0 && resized.originalHeight > 0 && resized.width > 0 && resized.height > 0;
-			if (!isDecodedImage) {
-				notes.push(`Fetched payload could not be decoded as ${imageMimeType}; returning text metadata only`);
-				const output = finalizeOutput(
-					convertedText ??
-						rawContent ??
-						`Fetched payload was labeled ${imageMimeType}, but bytes were not a valid image.`,
-				);
-				return {
-					url,
-					finalUrl,
-					contentType: imageMimeType,
-					method: convertedText ? "markitdown" : "image-invalid",
-					content: output.content,
-					fetchedAt,
-					truncated: output.truncated,
-					notes,
-				};
-			}
-			if (resized.buffer.length > MAX_INLINE_IMAGE_OUTPUT_BYTES) {
-				notes.push(
-					`Image exceeds inline output limit after resize (${resized.buffer.length} bytes > ${MAX_INLINE_IMAGE_OUTPUT_BYTES} bytes)`,
-				);
-				const output = finalizeOutput(
-					convertedText ?? `Fetched image content (${imageMimeType}), but it is too large to inline render.`,
+				const resized = await resizeImage(
+					{ type: "image", data: binary.buffer.toBase64(), mimeType: imageMimeType },
+					{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES },
 				);
+				const isDecodedImage =
+					resized.originalWidth > 0 && resized.originalHeight > 0 && resized.width > 0 && resized.height > 0;
+				if (!isDecodedImage) {
+					notes.push(`Fetched payload could not be decoded as ${imageMimeType}; returning text metadata only`);
+					const output = finalizeOutput(
+						convertedText ??
+							rawContent ??
+							`Fetched payload was labeled ${imageMimeType}, but bytes were not a valid image.`,
+					);
+					return {
+						url,
+						finalUrl,
+						contentType: imageMimeType,
+						method: convertedText ? "markitdown" : "image-invalid",
+						content: output.content,
+						fetchedAt,
+						truncated: output.truncated,
+						notes,
+					};
+				}
+				if (resized.buffer.length > MAX_INLINE_IMAGE_OUTPUT_BYTES) {
+					notes.push(
+						`Image exceeds inline output limit after resize (${resized.buffer.length} bytes > ${MAX_INLINE_IMAGE_OUTPUT_BYTES} bytes)`,
+					);
+					const output = finalizeOutput(
+						convertedText ?? `Fetched image content (${imageMimeType}), but it is too large to inline render.`,
+					);
+					return {
+						url,
+						finalUrl,
+						contentType: imageMimeType,
+						method: convertedText ? "markitdown" : "image-too-large",
+						content: output.content,
+						fetchedAt,
+						truncated: output.truncated,
+						notes,
+					};
+				}
+
+				const dimensionNote = formatDimensionNote(resized);
+				let imageSummary = convertedText ?? `Fetched image content (${resized.mimeType}).`;
+				if (dimensionNote) {
+					imageSummary += `\n${dimensionNote}`;
+				}
+				const output = finalizeOutput(imageSummary);
 				return {
 					url,
 					finalUrl,
-					contentType: imageMimeType,
-					method: convertedText ? "markitdown" : "image-too-large",
+					contentType: resized.mimeType,
+					method: "image",
 					content: output.content,
 					fetchedAt,
 					truncated: output.truncated,
 					notes,
+					image: {
+						data: resized.data,
+						mimeType: resized.mimeType,
+					},
 				};
 			}
-
-			const dimensionNote = formatDimensionNote(resized);
-			let imageSummary = convertedText ?? `Fetched image content (${resized.mimeType}).`;
-			if (dimensionNote) {
-				imageSummary += `\n${dimensionNote}`;
-			}
-			const output = finalizeOutput(imageSummary);
-			return {
-				url,
-				finalUrl,
-				contentType: resized.mimeType,
-				method: "image",
-				content: output.content,
-				fetchedAt,
-				truncated: output.truncated,
-				notes,
-				image: {
-					data: resized.data,
-					mimeType: resized.mimeType,
-				},
-			};
+			notes.push(binary.error ? `Binary fetch failed: ${binary.error}` : "Binary fetch failed");
+			notes.push("Falling back to textual rendering from initial response");
+			skipConvertibleBinaryRetry = true;
 		}
-		notes.push(binary.error ? `Binary fetch failed: ${binary.error}` : "Binary fetch failed");
-		notes.push("Falling back to textual rendering from initial response");
-		skipConvertibleBinaryRetry = true;
 	}
 
 	// Step 3: Handle convertible binary files (PDF, DOCX, etc.)

package/src/tools/index.ts

@@ -227,7 +227,8 @@ function getPythonModeFromEnv(): PythonToolMode | null {
 export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
 	const includeSubmitResult = session.requireSubmitResultTool === true;
 	const enableLsp = session.enableLsp ?? true;
-	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
+	const requestedTools =
+		toolNames && toolNames.length > 0 ? [...new Set(toolNames.map(name => name.toLowerCase()))] : undefined;
 	if (requestedTools && !requestedTools.includes("exit_plan_mode")) {
 		requestedTools.push("exit_plan_mode");
 	}

package/src/web/kagi.ts

@@ -28,15 +28,23 @@ interface KagiRelatedSearchesObject {
 
 type KagiSearchObject = KagiSearchResultObject | KagiRelatedSearchesObject;
 
+interface KagiErrorEntry {
+	code?: number;
+	msg?: string;
+}
+
 interface KagiSearchResponse {
 	meta: {
 		id: string;
 	};
 	data: KagiSearchObject[];
-	error?: Array<{
-		code: number;
-		msg: string;
-	}>;
+	error?: KagiErrorEntry[];
+}
+
+interface KagiErrorResponse {
+	error?: string | KagiErrorEntry[];
+	message?: string;
+	detail?: string;
 }
 
 export class KagiApiError extends Error {
@@ -49,6 +57,54 @@ export class KagiApiError extends Error {
 	}
 }
 
+function extractKagiErrorMessage(payload: unknown): string | null {
+	if (!payload || typeof payload !== "object") return null;
+	const record = payload as Record<string, unknown>;
+
+	for (const value of [record.message, record.detail]) {
+		if (typeof value === "string" && value.trim().length > 0) {
+			return value.trim();
+		}
+	}
+
+	if (typeof record.error === "string" && record.error.trim().length > 0) {
+		return record.error.trim();
+	}
+
+	if (Array.isArray(record.error)) {
+		for (const entry of record.error) {
+			if (!entry || typeof entry !== "object") continue;
+			const message = (entry as Record<string, unknown>).msg;
+			if (typeof message === "string" && message.trim().length > 0) {
+				return message.trim();
+			}
+		}
+	}
+
+	return null;
+}
+
+function createKagiApiError(statusCode: number, detail?: string): KagiApiError {
+	return new KagiApiError(
+		detail ? `Kagi API error (${statusCode}): ${detail}` : `Kagi API error (${statusCode})`,
+		statusCode,
+	);
+}
+
+function parseKagiErrorResponse(statusCode: number, responseText: string): KagiApiError {
+	const trimmedResponseText = responseText.trim();
+	if (trimmedResponseText.length === 0) {
+		return createKagiApiError(statusCode);
+	}
+
+	try {
+		const payload = JSON.parse(trimmedResponseText) as KagiErrorResponse;
+		return createKagiApiError(statusCode, extractKagiErrorMessage(payload) ?? trimmedResponseText);
+	} catch {
+		return createKagiApiError(statusCode, trimmedResponseText);
+	}
+}
+
 export interface KagiSummarizeOptions {
 	engine?: string;
 	summaryType?: string;
@@ -127,14 +183,13 @@ export async function searchWithKagi(query: string, options: KagiSearchOptions =
 		signal: options.signal,
 	});
 	if (!response.ok) {
-		const errorText = await response.text();
-		throw new KagiApiError(`Kagi API error (${response.status}): ${errorText}`, response.status);
+		throw parseKagiErrorResponse(response.status, await response.text());
 	}
 
 	const payload = (await response.json()) as KagiSearchResponse;
 	if (payload.error && payload.error.length > 0) {
 		const firstError = payload.error[0];
-		throw new KagiApiError(`Kagi API error: ${firstError.msg}`, firstError.code);
+		throw createKagiApiError(firstError.code ?? response.status, extractKagiErrorMessage(payload) ?? undefined);
 	}
 
 	const sources: KagiSearchSource[] = [];

package/src/web/search/providers/exa.ts

@@ -48,6 +48,72 @@ interface ExaSearchResponse {
 	searchTime?: number;
 }
 
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseOptionalField(section: string, label: string): string | null | undefined {
+	const regex = new RegExp(`(?:^|\\n)${label}:\\s*([^\\n]*)`);
+	const match = section.match(regex);
+	if (!match) return undefined;
+	const value = match[1].trim();
+	return value.length > 0 ? value : null;
+}
+
+function parseTextField(section: string): string | null | undefined {
+	const match = section.match(/(?:^|\n)Text:\s*([\s\S]*)$/);
+	if (!match) return undefined;
+	const value = match[1].trim();
+	return value.length > 0 ? value : null;
+}
+
+function parseExaMcpTextPayload(payload: unknown): ExaSearchResponse | null {
+	const root = asRecord(payload);
+	if (!root) return null;
+
+	const content = root.content;
+	if (!Array.isArray(content)) return null;
+
+	const textBlocks = content
+		.map(item => {
+			const part = asRecord(item);
+			const text = typeof part?.text === "string" ? part.text : "";
+			return text.replace(/\r\n?/g, "\n").trim();
+		})
+		.filter(text => text.length > 0);
+
+	if (textBlocks.length === 0) return null;
+
+	const sections = textBlocks
+		.join("\n\n")
+		.split(/\n{2,}(?=Title:\s*[^\n]*(?:\n(?:URL|Author|Published Date|Text):))/)
+		.map(section => section.trim())
+		.filter(section => section.startsWith("Title:"));
+
+	const results: ExaSearchResult[] = [];
+	for (const section of sections) {
+		const title = parseOptionalField(section, "Title");
+		const url = parseOptionalField(section, "URL");
+		const author = parseOptionalField(section, "Author");
+		const publishedDate = parseOptionalField(section, "Published Date");
+		const text = parseTextField(section);
+
+		if (!title && !url && !text) continue;
+
+		results.push({
+			title: title ?? undefined,
+			url: url ?? undefined,
+			author: author ?? undefined,
+			publishedDate: publishedDate ?? undefined,
+			text: text ?? undefined,
+		});
+	}
+
+	if (results.length === 0) return null;
+	return { results };
+}
+
 export function normalizeSearchType(type: ExaSearchParamType | undefined): ExaSearchType {
 	if (!type) return "auto";
 	if (type === "keyword") return "fast";
@@ -124,11 +190,16 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 
 async function callExaMcpSearch(params: ExaSearchParams): Promise<ExaSearchResponse> {
 	const response = await callExaTool("web_search_exa", { ...params }, findApiKey());
-	if (!isSearchResponse(response)) {
-		throw new Error("Exa MCP search returned unexpected response shape.");
+	if (isSearchResponse(response)) {
+		return response as ExaSearchResponse;
+	}
+
+	const parsed = parseExaMcpTextPayload(response);
+	if (parsed) {
+		return parsed;
 	}
 
-	return response as ExaSearchResponse;
+	throw new Error("Exa MCP search returned unexpected response shape.");
 }
 
 /** Execute Exa web search */