@oh-my-pi/pi-coding-agent 15.12.4 → 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/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

@@ -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/stt/setup.d.ts

@@ -1,18 +0,0 @@
-export interface STTDependencyStatus {
-    recorder: {
-        available: boolean;
-        tool: string | null;
-        installHint: string;
-    };
-    python: {
-        available: boolean;
-        path: string | null;
-        installHint: string;
-    };
-    whisper: {
-        available: boolean;
-        installHint: string;
-    };
-}
-export declare function checkDependencies(): Promise<STTDependencyStatus>;
-export declare function formatDependencyStatus(status: STTDependencyStatus): string;

package/src/stt/setup.ts

@@ -1,52 +0,0 @@
-import { detectRecordingTools } from "./recorder";
-import { resolvePython } from "./transcriber";
-
-const isWindows = process.platform === "win32";
-
-export interface STTDependencyStatus {
-	recorder: { available: boolean; tool: string | null; installHint: string };
-	python: { available: boolean; path: string | null; installHint: string };
-	whisper: { available: boolean; installHint: string };
-}
-
-export async function checkDependencies(): Promise<STTDependencyStatus> {
-	const recorderTools = detectRecordingTools();
-	const recorderHint = isWindows
-		? "PowerShell fallback available. For better quality: install SoX or FFmpeg."
-		: "Install SoX: sudo apt install sox, or FFmpeg: sudo apt install ffmpeg";
-
-	const pythonCmd = resolvePython();
-	const pythonHint = "Install Python 3.8+ from https://python.org";
-
-	let whisperAvailable = false;
-	if (pythonCmd) {
-		const check = Bun.spawnSync([pythonCmd, "-c", "import whisper"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		whisperAvailable = check.exitCode === 0;
-	}
-	const whisperHint = "Run 'omp setup stt' to auto-install, or: pip install openai-whisper";
-
-	return {
-		recorder: { available: recorderTools.length > 0, tool: recorderTools[0] ?? null, installHint: recorderHint },
-		python: { available: pythonCmd !== null, path: pythonCmd, installHint: pythonHint },
-		whisper: { available: whisperAvailable, installHint: whisperHint },
-	};
-}
-
-export function formatDependencyStatus(status: STTDependencyStatus): string {
-	const lines: string[] = ["STT Dependencies:"];
-	const check = (ok: boolean) => (ok ? "[ok]" : "[missing]");
-
-	lines.push(`  Recorder: ${check(status.recorder.available)} ${status.recorder.tool ?? "none"}`);
-	if (!status.recorder.available) lines.push(`    -> ${status.recorder.installHint}`);
-
-	lines.push(`  Python:   ${check(status.python.available)} ${status.python.path ?? "none"}`);
-	if (!status.python.available) lines.push(`    -> ${status.python.installHint}`);
-
-	lines.push(`  Whisper:  ${check(status.whisper.available)}`);
-	if (!status.whisper.available) lines.push(`    -> ${status.whisper.installHint}`);
-
-	return lines.join("\n");
-}

package/src/stt/transcribe.py

@@ -1,70 +0,0 @@
-"""Transcribe a WAV file using openai-whisper.
-
-Reads WAV directly via Python's wave module (no ffmpeg needed).
-Resamples to 16kHz mono float32 and passes to whisper as a numpy array.
-
-Usage: python transcribe.py <audio.wav> <model_name> <language>
-Prints transcribed text to stdout.
-"""
-
-import sys
-import wave
-import re
-
-
-import numpy as np
-import whisper
-
-
-def load_wav(path: str) -> np.ndarray:
-    with wave.open(path, "rb") as wf:
-        rate = wf.getframerate()
-        channels = wf.getnchannels()
-        width = wf.getsampwidth()
-        n_frames = wf.getnframes()
-        raw = wf.readframes(n_frames)
-
-    if width == 2:
-        audio = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
-    elif width == 1:
-        audio = (np.frombuffer(raw, dtype=np.uint8).astype(np.float32) - 128.0) / 128.0
-    elif width == 4:
-        audio = np.frombuffer(raw, dtype=np.int32).astype(np.float32) / 2147483648.0
-    else:
-        raise ValueError(f"Unsupported sample width: {width}")
-
-    # Mix to mono
-    if channels > 1:
-        audio = audio.reshape(-1, channels).mean(axis=1)
-
-    # Resample to 16 kHz
-    if rate != 16000:
-        target_len = int(len(audio) * 16000 / rate)
-        audio = np.interp(
-            np.linspace(0, len(audio) - 1, target_len),
-            np.arange(len(audio)),
-            audio,
-        ).astype(np.float32)
-
-    return audio
-
-
-def main() -> None:
-    if len(sys.argv) < 2:
-        print("Usage: python transcribe.py <audio.wav> <model_name> <language>", file=sys.stderr)
-        sys.exit(1)
-    audio_path = sys.argv[1]
-    model_name = sys.argv[2] if len(sys.argv) > 2 else "base.en"
-    language = sys.argv[3] if len(sys.argv) > 3 else "en"
-    if not re.fullmatch(r"[A-Za-z]{2,3}(-[A-Za-z]{2})?", language):
-        print(f"Invalid language code: {language}", file=sys.stderr)
-        sys.exit(1)
-
-    audio = load_wav(audio_path)
-    model = whisper.load_model(model_name)
-    result = model.transcribe(audio, language=language)
-    print(result["text"].strip())
-
-
-if __name__ == "__main__":
-    main()