@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/src/tts/wav.ts

@@ -0,0 +1,58 @@
+const WAV_HEADER_BYTES = 44;
+const PCM16_FORMAT = 1;
+const BITS_PER_SAMPLE = 16;
+const INT16_MAX = 32_767;
+const INT16_MIN = -32_768;
+
+/**
+ * Assemble a mono PCM16 WAV byte buffer from Float32 PCM samples (the shape
+ * transformers.js `RawAudio` emits: normalized [-1, 1] amplitudes plus a sample
+ * rate). No external encoder is involved — we write a canonical 44-byte RIFF/
+ * WAVE header followed by little-endian signed 16-bit samples. Samples are
+ * clamped before quantization so out-of-range float values do not wrap.
+ */
+export function encodeWav(samples: Float32Array, sampleRate: number): Uint8Array {
+	const channels = 1;
+	const byteRate = sampleRate * channels * (BITS_PER_SAMPLE / 8);
+	const blockAlign = channels * (BITS_PER_SAMPLE / 8);
+	const dataBytes = samples.length * (BITS_PER_SAMPLE / 8);
+	const buffer = new ArrayBuffer(WAV_HEADER_BYTES + dataBytes);
+	const view = new DataView(buffer);
+
+	// RIFF chunk descriptor
+	writeAscii(view, 0, "RIFF");
+	view.setUint32(4, WAV_HEADER_BYTES - 8 + dataBytes, true); // file size minus the first 8 bytes
+	writeAscii(view, 8, "WAVE");
+
+	// fmt sub-chunk
+	writeAscii(view, 12, "fmt ");
+	view.setUint32(16, 16, true); // PCM fmt chunk size
+	view.setUint16(20, PCM16_FORMAT, true);
+	view.setUint16(22, channels, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, byteRate, true);
+	view.setUint16(32, blockAlign, true);
+	view.setUint16(34, BITS_PER_SAMPLE, true);
+
+	// data sub-chunk
+	writeAscii(view, 36, "data");
+	view.setUint32(40, dataBytes, true);
+
+	let offset = WAV_HEADER_BYTES;
+	for (let i = 0; i < samples.length; i += 1) {
+		const sample = samples[i]!;
+		const clamped = sample > 1 ? 1 : sample < -1 ? -1 : sample;
+		const quantized =
+			clamped < 0
+				? Math.max(INT16_MIN, Math.round(clamped * -INT16_MIN))
+				: Math.min(INT16_MAX, Math.round(clamped * INT16_MAX));
+		view.setInt16(offset, quantized, true);
+		offset += 2;
+	}
+
+	return new Uint8Array(buffer);
+}
+
+function writeAscii(view: DataView, offset: number, text: string): void {
+	for (let i = 0; i < text.length; i += 1) view.setUint8(offset + i, text.charCodeAt(i));
+}

package/src/utils/clipboard.ts

@@ -66,9 +66,10 @@ export async function copyToClipboard(text: string): Promise<void> {
 	}
 }
 
-// PowerShell one-liner that emits the clipboard image as base64-encoded PNG on
-// stdout, or nothing when the clipboard does not hold image data. Used as the
-// WSL bridge — arboard cannot read the Windows clipboard through WSLg.
+// PowerShell one-liner that emits the Windows clipboard image as base64-encoded
+// PNG on stdout, or nothing when the clipboard does not hold image data. Used
+// for native Windows fallback and WSL interop because arboard can miss host
+// clipboard image payloads in those terminal paths.
 const POWERSHELL_IMAGE_SCRIPT = `
 $ErrorActionPreference = 'Stop'
 Add-Type -AssemblyName System.Windows.Forms
@@ -84,31 +85,36 @@ if ($img -ne $null) {
 const POWERSHELL_TIMEOUT_MS = 8000;
 
 /**
- * Read a clipboard image through the Windows host's PowerShell.
+ * Read an image through the Windows host's PowerShell.
  *
- * WSLg exposes a Wayland socket but no native clipboard image transport, so
- * `arboard` returns `ContentNotAvailable`. PowerShell, reached via WSL interop,
- * can read the Windows clipboard directly and round-trip the bitmap as PNG.
+ * Native Windows uses this as a fallback when arboard reports no image or
+ * cannot access the clipboard. WSLg exposes a Wayland socket but no native
+ * clipboard image transport, so arboard returns `ContentNotAvailable` there;
+ * PowerShell, reached via WSL interop, can read the Windows clipboard directly
+ * and round-trip the bitmap as PNG.
  *
  * Returns null when no image is on the clipboard, the host PowerShell is
  * missing, or the bridge times out.
  */
 async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
 	try {
-		const proc = Bun.spawn(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_IMAGE_SCRIPT], {
-			stdout: "pipe",
-			stderr: "ignore",
-			stdin: "ignore",
-		});
+		const proc = Bun.spawn(
+			["powershell.exe", "-NoProfile", "-NonInteractive", "-Sta", "-Command", POWERSHELL_IMAGE_SCRIPT],
+			{
+				stdout: "pipe",
+				stderr: "ignore",
+				stdin: "ignore",
+			},
+		);
 		const timer = setTimeout(() => proc.kill(), POWERSHELL_TIMEOUT_MS);
 		let stdout = "";
 		try {
 			stdout = await new Response(proc.stdout).text();
 			await proc.exited;
 		} catch (err) {
-			// powershell.exe is a Windows process reached over WSL interop; if it
-			// doesn't reap cleanly, swallow the error so the dispatcher can fall
-			// through to the native bridge instead of throwing.
+			// powershell.exe can be a Windows process reached either natively or
+			// over WSL interop; if it doesn't reap cleanly, report no image instead
+			// of surfacing an opaque bridge failure to the prompt.
 			logger.warn("clipboard: powershell read failed", { error: String(err) });
 			return null;
 		} finally {
@@ -179,9 +185,10 @@ async function readTextViaPowerShell(): Promise<string | null> {
  * Read an image from the system clipboard.
  *
  * Returns null on Termux (no image clipboard support) or when no display
- * server is available (headless/SSH without forwarding). Under WSL the
- * Windows clipboard is reached through `powershell.exe`, since WSLg's
- * Wayland clipboard does not carry image payloads through to `arboard`.
+ * server is available (headless/SSH without forwarding). Under native Windows
+ * and WSL, the Windows clipboard is also reached through `powershell.exe`
+ * because terminal clipboard paths can leave image payloads invisible to the
+ * native bridge.
  *
  * @returns PNG payload or null when no image is available.
  */
@@ -198,6 +205,16 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 		// no display, so arboard would reject anyway.
 	}
 
+	if (process.platform === "win32") {
+		try {
+			const image = await native.readImageFromClipboard();
+			if (image) return image;
+		} catch (err) {
+			logger.warn("clipboard: native Windows image read failed", { error: String(err) });
+		}
+		return await readImageViaPowerShell();
+	}
+
 	if (!hasDisplay()) {
 		return null;
 	}

package/src/utils/image-loading.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs/promises";
-import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
 import { resolveReadPath } from "../tools/path-utils";
 import { formatDimensionNote, type ImageResizeOptions, resizeImage } from "./image-resize";
@@ -7,6 +7,26 @@ import { formatDimensionNote, type ImageResizeOptions, resizeImage } from "./ima
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
 export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
 
+/**
+ * Ollama and its local-backend family decode image input through llama.cpp /
+ * `stb_image`, which is compiled without WebP support, so a WebP upload fails
+ * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
+ * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
+ */
+export function modelLacksWebpSupport(model: Pick<Model, "provider" | "api"> | undefined): boolean {
+	if (!model) return false;
+	return model.provider === "ollama" || model.provider === "ollama-cloud" || model.api === "ollama-chat";
+}
+
+/**
+ * `true` when `model` cannot decode WebP, otherwise `undefined` so the
+ * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight
+ * into {@link ImageResizeOptions.excludeWebP}.
+ */
+export function webpExclusionForModel(model: Pick<Model, "provider" | "api"> | undefined): true | undefined {
+	return modelLacksWebpSupport(model) ? true : undefined;
+}
+
 export interface LoadImageInputOptions {
 	path: string;
 	cwd: string;
@@ -14,6 +34,8 @@ export interface LoadImageInputOptions {
 	maxBytes?: number;
 	resolvedPath?: string;
 	detectedMimeType?: string;
+	/** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
+	excludeWebP?: boolean;
 }
 
 export interface LoadedImageInput {
@@ -51,6 +73,8 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 }
 
 export interface NormalizeModelContextImagesOptions {
+	/** Model the images are bound for; used to derive encoder constraints (WebP exclusion for Ollama). */
+	model?: Model;
 	resize?: ImageResizeOptions;
 }
 
@@ -66,10 +90,13 @@ export async function normalizeModelContextImages(
 	options?: NormalizeModelContextImagesOptions,
 ): Promise<ImageContent[] | undefined> {
 	if (!images || images.length === 0) return undefined;
+	const resize: ImageResizeOptions | undefined = modelLacksWebpSupport(options?.model)
+		? { ...options?.resize, excludeWebP: true }
+		: options?.resize;
 	const normalized: ImageContent[] = [];
 	for (const image of images) {
 		try {
-			const resized = await resizeImage(image, options?.resize);
+			const resized = await resizeImage(image, resize);
 			normalized.push({ type: "image", data: resized.data, mimeType: resized.mimeType });
 		} catch {
 			// Preserve existing caller behavior for decode/resize failures: keep the
@@ -104,9 +131,13 @@ export async function loadImageInput(options: LoadImageInputOptions): Promise<Lo
 	let outputBytes = inputBuffer.byteLength;
 	let dimensionNote: string | undefined;
 
-	if (options.autoResize) {
+	const shouldReencodeWebP = options.excludeWebP === true && mimeType === "image/webp";
+	if (options.autoResize || shouldReencodeWebP) {
 		try {
-			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
+			const resized = await resizeImage(
+				{ type: "image", data: outputData, mimeType },
+				{ excludeWebP: options.excludeWebP },
+			);
 			outputData = resized.data;
 			outputMimeType = resized.mimeType;
 			outputBytes = resized.buffer.byteLength;

package/src/utils/thinking-display.ts

@@ -0,0 +1,37 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+
+type AssistantContentBlock = AssistantMessage["content"][number];
+type ThinkingBlock = Extract<AssistantContentBlock, { type: "thinking" }>;
+
+function isDotOnlyThinking(text: string): boolean {
+	let sawDot = false;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code === 0x2e || code === 0x2026) {
+			sawDot = true;
+			continue;
+		}
+		if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) continue;
+		return false;
+	}
+	return sawDot;
+}
+
+/**
+ * Returns the operator-visible thinking text for a block.
+ *
+ * Some OpenAI-compatible reasoning gateways require a non-empty
+ * `reasoning_content` field on historical assistant tool-call turns even when
+ * the model did not emit any reasoning. The provider adapter uses a single dot
+ * as the wire-only placeholder those gateways accept; if that value is later
+ * replayed or echoed as a thinking block, it should not render as model thought.
+ */
+export function getVisibleThinkingText(block: ThinkingBlock): string {
+	const text = block.thinking.trim();
+	if (text.length === 0) return "";
+	return isDotOnlyThinking(text) ? "" : text;
+}
+
+export function hasVisibleThinking(block: ThinkingBlock): boolean {
+	return getVisibleThinkingText(block).length > 0;
+}

package/src/utils/title-generator.ts

@@ -9,12 +9,16 @@ import type { ModelRegistry } from "../config/model-registry";
 
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
+import titleMarkerInstruction from "../prompts/system/title-marker-instruction.md" with { type: "text" };
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import titleMarkerSystemPrompt from "../prompts/system/title-system-marker.md" with { type: "text" };
 import { ONLINE_TINY_TITLE_MODEL_KEY } from "../tiny/models";
 import { formatTitleUserMessage, isLowSignalTitleInput, normalizeGeneratedTitle } from "../tiny/text";
 import { tinyTitleClient } from "../tiny/title-client";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
+const TITLE_MARKER_SYSTEM_PROMPT = prompt.render(titleMarkerSystemPrompt);
+const TITLE_MARKER_INSTRUCTION = prompt.render(titleMarkerInstruction);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
@@ -41,6 +45,30 @@ const setTitleTool: Tool = {
 	},
 };
 
+/** Matches the title a tool-choice-less model wraps in `<title>...</title>`. */
+const TITLE_MARKER_RE = /<title>([\s\S]*?)<\/title>/i;
+
+/**
+ * Whether the model honors a forced `tool_choice` so the `set_title` tool can be
+ * required. Providers/models that reject forced tool calls (chat-completions
+ * hosts without `tool_choice` support, Claude Fable/Mythos) can't be made to
+ * emit a structured call, so the caller falls back to marker-wrapped text.
+ */
+function modelSupportsForcedToolChoice(model: Model<Api>): boolean {
+	// `compat` is a union across APIs and `supportsToolChoice` lives only on the
+	// OpenAI-completions variant, so read both flags through a structural view.
+	const compat = model.compat as { supportsToolChoice?: boolean; supportsForcedToolChoice?: boolean } | undefined;
+	if (!compat) return true;
+	// A forced tool call first requires sending `tool_choice` at all. Hosts that
+	// drop the parameter entirely (`supportsToolChoice: false`, e.g. direct
+	// DeepSeek reasoning) can never be forced even when they otherwise accept
+	// forced values, so this veto wins over `supportsForcedToolChoice`.
+	if (compat.supportsToolChoice === false) return false;
+	if (typeof compat.supportsForcedToolChoice === "boolean") return compat.supportsForcedToolChoice;
+	if (typeof compat.supportsToolChoice === "boolean") return compat.supportsToolChoice;
+	return true;
+}
+
 function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
@@ -221,7 +249,16 @@ export async function generateTitleOnline(
 	}
 
 	const titleSystemPrompt = customSystemPrompt?.trim() || undefined;
-	const systemPrompt = titleSystemPrompt ?? TITLE_SYSTEM_PROMPT;
+	// Some providers can't be forced to call a tool — chat-completions hosts
+	// without `tool_choice` support, Claude Fable/Mythos — so a required
+	// `set_title` call never arrives. For those, ask the model to wrap the title
+	// in `<title>...</title>` markers and parse it from text instead.
+	const useForcedTool = modelSupportsForcedToolChoice(model);
+	const systemPrompt = useForcedTool
+		? [titleSystemPrompt ?? TITLE_SYSTEM_PROMPT]
+		: titleSystemPrompt
+			? [titleSystemPrompt, TITLE_MARKER_INSTRUCTION]
+			: [TITLE_MARKER_SYSTEM_PROMPT];
 	const userMessage = formatTitleUserMessage(firstMessage);
 	const modelName = `${model.provider}/${model.id}`;
 	const modelContext = {
@@ -253,15 +290,15 @@ export async function generateTitleOnline(
 		const response = await completeSimple(
 			model,
 			{
-				systemPrompt: [systemPrompt],
+				systemPrompt,
 				messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
-				tools: [setTitleTool],
+				tools: useForcedTool ? [setTitleTool] : undefined,
 			},
 			{
 				apiKey: registry.resolver(model, sessionId),
 				maxTokens,
 				disableReasoning: true,
-				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
+				toolChoice: useForcedTool ? { type: "tool", name: SET_TITLE_TOOL_NAME } : undefined,
 				metadata,
 				signal,
 			},
@@ -319,7 +356,13 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 			textTitle += content.text;
 		}
 	}
-	return textTitle.trim();
+	// Tool-choice-less models are asked to wrap the title in <title>...</title>,
+	// but stay lenient: prefer the marker when the model closed it, otherwise
+	// accept a plain sentence after stripping any stray/unclosed tag fragment
+	// (e.g. output truncated before the closing tag).
+	const marker = TITLE_MARKER_RE.exec(textTitle);
+	if (marker) return marker[1].trim();
+	return textTitle.replace(/<\/?title>/gi, "").trim();
 }
 
 /**

package/src/utils/tool-choice.ts

@@ -31,3 +31,19 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 
 	return undefined;
 }
+
+/**
+ * Whether the given tool choice can be satisfied by the active tool set for the
+ * upcoming turn. Non-named choices (`"none"`, `"required"`, etc.) do not name a
+ * specific tool and are therefore always active.
+ */
+export function isToolChoiceActive(toolChoice: ToolChoice | undefined, tools: readonly { name: string }[]): boolean {
+	if (!toolChoice || typeof toolChoice === "string") return true;
+	const name =
+		toolChoice.type === "tool"
+			? toolChoice.name
+			: "function" in toolChoice
+				? toolChoice.function.name
+				: toolChoice.name;
+	return tools.some(tool => tool.name === name);
+}

package/src/utils/tools-manager.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test";
+import { ffmpegAssetName } from "./tools-manager";
+
+describe("ffmpegAssetName", () => {
+	it("maps supported platform/arch pairs to direct-binary asset names", () => {
+		expect(ffmpegAssetName("b6.1.1", "darwin", "arm64")).toBe("ffmpeg-darwin-arm64");
+		expect(ffmpegAssetName("b6.1.1", "darwin", "x64")).toBe("ffmpeg-darwin-x64");
+		expect(ffmpegAssetName("b6.1.1", "linux", "arm64")).toBe("ffmpeg-linux-arm64");
+		expect(ffmpegAssetName("b6.1.1", "linux", "x64")).toBe("ffmpeg-linux-x64");
+		expect(ffmpegAssetName("b6.1.1", "win32", "x64")).toBe("ffmpeg-win32-x64");
+	});
+
+	it("returns null for win32 on arm64 (no static asset published)", () => {
+		expect(ffmpegAssetName("b6.1.1", "win32", "arm64")).toBeNull();
+	});
+
+	it("returns null for unsupported arch", () => {
+		expect(ffmpegAssetName("b6.1.1", "darwin", "ia32")).toBeNull();
+		expect(ffmpegAssetName("b6.1.1", "linux", "ppc64")).toBeNull();
+	});
+
+	it("returns null for unsupported platform", () => {
+		expect(ffmpegAssetName("b6.1.1", "freebsd", "x64")).toBeNull();
+	});
+});

package/src/utils/tools-manager.ts

@@ -16,6 +16,16 @@ interface ToolConfig {
 	getAssetName: (version: string, plat: string, architecture: string) => string | null;
 }
 
+// ffmpeg static-binary asset names (eugeneware/ffmpeg-static direct binaries).
+// Maps node arch (arm64|x64) only; everything else is unsupported.
+export function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null {
+	if (architecture !== "arm64" && architecture !== "x64") return null;
+	if (plat === "darwin") return `ffmpeg-darwin-${architecture}`;
+	if (plat === "linux") return `ffmpeg-linux-${architecture}`;
+	if (plat === "win32") return architecture === "x64" ? "ffmpeg-win32-x64" : null;
+	return null;
+}
+
 const TOOLS: Record<string, ToolConfig> = {
 	sd: {
 		name: "sd",
@@ -72,6 +82,14 @@ const TOOLS: Record<string, ToolConfig> = {
 			return null;
 		},
 	},
+	ffmpeg: {
+		name: "ffmpeg",
+		repo: "eugeneware/ffmpeg-static",
+		binaryName: "ffmpeg",
+		tagPrefix: "",
+		isDirectBinary: true,
+		getAssetName: ffmpegAssetName,
+	},
 };
 
 // CLI packages installed via uv/pip
@@ -89,7 +107,7 @@ const PYTHON_TOOLS: Record<string, PythonPackageToolConfig> = {
 	},
 };
 
-export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export function getToolPath(tool: ToolName): string | null {

package/src/web/scrapers/github.ts

@@ -7,6 +7,7 @@ interface GitHubUrl {
 		| "blob"
 		| "tree"
 		| "repo"
+		| "commit"
 		| "issue"
 		| "issues"
 		| "pull"
@@ -56,6 +57,11 @@ export function parseGitHubUrl(url: string): GitHubUrl | null {
 				const [ref, ...pathParts] = subParts;
 				return { type: section, owner, repo, ref, path: pathParts.join("/") };
 			}
+			case "commit":
+				if (subParts.length > 0 && subParts[0]) {
+					return { type: "commit", owner, repo, ref: subParts[0] };
+				}
+				return { type: "other", owner, repo };
 			case "issues":
 				if (subParts.length > 0 && /^\d+$/.test(subParts[0])) {
 					return { type: "issue", owner, repo, number: parseInt(subParts[0], 10) };
@@ -233,6 +239,87 @@ async function renderGitHubIssue(
 	return { content: md, ok: true };
 }
 
+interface GitHubCommitFile {
+	filename: string;
+	status: string;
+	additions: number;
+	deletions: number;
+	changes: number;
+	patch?: string;
+	previous_filename?: string;
+}
+
+/**
+ * Render a GitHub commit (metadata, message, and per-file diff) to markdown.
+ *
+ * The commits API (`/repos/{owner}/{repo}/commits/{ref}`) returns the full
+ * unified diff inline via `files[].patch`, so a single request yields both the
+ * summary and the diff. Binary files have no `patch` and are flagged instead.
+ */
+async function renderGitHubCommit(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
+	const result = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/commits/${gh.ref}`, timeout, signal);
+	if (!result.ok || !result.data) return { content: "", ok: false };
+
+	const commit = result.data as {
+		sha: string;
+		html_url: string;
+		commit: {
+			author?: { name?: string; date?: string } | null;
+			committer?: { name?: string; date?: string } | null;
+			message: string;
+		};
+		author?: { login: string } | null;
+		committer?: { login: string } | null;
+		parents?: Array<{ sha: string }>;
+		stats?: { total?: number; additions?: number; deletions?: number };
+		files?: GitHubCommitFile[];
+	};
+
+	const message = commit.commit.message ?? "";
+	const [subject, ...bodyLines] = message.split("\n");
+	const authorName = commit.author?.login ? `@${commit.author.login}` : (commit.commit.author?.name ?? "unknown");
+	const authoredAt = commit.commit.author?.date ?? "";
+
+	let md = `# ${subject || commit.sha.slice(0, 7)}\n\n`;
+	md += `**${commit.sha.slice(0, 12)}** · authored by ${authorName}`;
+	if (authoredAt) md += ` · ${authoredAt}`;
+	md += `\n`;
+	if (commit.stats) {
+		const { additions = 0, deletions = 0 } = commit.stats;
+		const fileCount = commit.files?.length ?? 0;
+		md += `${fileCount} file${fileCount === 1 ? "" : "s"} changed · +${additions} −${deletions}\n`;
+	}
+	if (commit.parents && commit.parents.length > 0) {
+		md += `Parents: ${commit.parents.map(p => p.sha.slice(0, 12)).join(", ")}\n`;
+	}
+
+	const body = bodyLines.join("\n").trim();
+	if (body) {
+		md += `\n${body}\n`;
+	}
+
+	const files = commit.files ?? [];
+	if (files.length > 0) {
+		md += `\n---\n\n## Files (${files.length})\n\n`;
+		for (const file of files) {
+			const name = file.previous_filename ? `${file.previous_filename} → ${file.filename}` : file.filename;
+			md += `### ${name}\n\n`;
+			md += `${file.status} · +${file.additions} −${file.deletions}\n\n`;
+			if (file.patch) {
+				md += `\`\`\`diff\n${file.patch}\n\`\`\`\n\n`;
+			} else {
+				md += `*No textual diff (binary or too large).*\n\n`;
+			}
+		}
+	}
+
+	return { content: md, ok: true };
+}
+
 /**
  * Render GitHub issues list to markdown
  */
@@ -647,6 +734,15 @@ export const handleGitHub: SpecialHandler = async (
 			break;
 		}
 
+		case "commit": {
+			notes.push(`Fetched via GitHub API`);
+			const result = await renderGitHubCommit(gh, timeout, signal);
+			if (result.ok) {
+				return buildResult(result.content, { url, method: "github-commit", fetchedAt, notes });
+			}
+			break;
+		}
+
 		case "issue":
 		case "pull": {
 			notes.push(`Fetched via GitHub API`);

package/src/web/search/index.ts

@@ -7,7 +7,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -115,6 +115,15 @@ function formatForLLM(response: SearchResponse): string {
 	return parts.join("\n");
 }
 
+function hasRenderableSearchContent(response: SearchResponse): boolean {
+	if (response.answer?.trim()) return true;
+	if (response.sources.length > 0) return true;
+	if (response.citations?.length) return true;
+	if (response.relatedQuestions?.some(question => question.trim())) return true;
+	if (response.searchQueries?.some(query => query.trim())) return true;
+	return false;
+}
+
 interface ExecuteSearchOptions {
 	authStorage: AuthStorage;
 	sessionId?: string;
@@ -162,6 +171,10 @@ async function executeSearch(
 				sessionId,
 			});
 
+			if (!hasRenderableSearchContent(response)) {
+				throw new SearchProviderError(provider.id, `${provider.label} returned no renderable search content.`, 204);
+			}
+
 			const text = formatForLLM(response);
 
 			return {

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

@@ -281,9 +281,21 @@ export async function searchSearXNG(params: {
 		});
 	}
 
+	const limitedSources = sources.slice(0, numResults);
+	if (limitedSources.length === 0 && response.unresponsive_engines?.length) {
+		const upstreamFailures = response.unresponsive_engines
+			.map(([engine, reason]) => `${engine}: ${reason}`)
+			.join("; ");
+		throw new SearchProviderError(
+			"searxng",
+			`SearXNG returned no usable results; upstream engines failed: ${upstreamFailures}`,
+			503,
+		);
+	}
+
 	return {
 		provider: "searxng",
-		sources: sources.slice(0, numResults),
+		sources: limitedSources,
 		relatedQuestions: response.suggestions?.length ? response.suggestions : undefined,
 	};
 }

package/dist/types/cli/list-models.d.ts

@@ -1,30 +0,0 @@
-import type { ModelRegistry } from "../config/model-registry";
-/**
- * List available models, optionally filtered by search pattern
- */
-export declare function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void>;
-/**
- * Options for the `--list-models` command entry point.
- */
-export interface RunListModelsOptions {
-    modelRegistry: ModelRegistry;
-    cwd: string;
-    /** CLI-supplied extension paths (e.g. from `-e <path>`). */
-    additionalExtensionPaths?: string[];
-    /** Extension paths configured under `extensions:` in user settings. */
-    settingsExtensions?: string[];
-    /** Disabled extension ids from settings (`disabledExtensions`). */
-    disabledExtensionIds?: string[];
-    /** When true, skip discovery and only load `additionalExtensionPaths`. */
-    disableExtensionDiscovery?: boolean;
-    searchPattern?: string;
-}
-/**
- * Loads extensions (CLI `-e` paths and `settings.extensions`) and surfaces
- * any provider/model registrations on the supplied `modelRegistry` before
- * delegating to {@link listModels}. This is the single entry point used by
- * `--list-models` and exists to ensure extension-contributed providers are
- * visible in the listing (issue #905). The load is intentionally narrow:
- * no agent loop, no MCP servers, no custom-tool registration.
- */
-export declare function runListModelsCommand(options: RunListModelsOptions): Promise<void>;