@xynogen/pix-9router 0.2.6 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-9router",
-	"version": "0.2.6",
+	"version": "0.3.1",
 	"description": "Pi extension — 9Router provider + fetch/search tools via router API",
 	"type": "module",
 	"main": "src/index.ts",

package/src/provider.ts

@@ -122,9 +122,10 @@ export default async function registerProvider(
 		api: "openai-completions",
 		headers: { "User-Agent": "pi-coding-agent" },
 		models: models.map((model) => {
-			const devModel = lookupInIndex(model.id!, devIndex);
+			const id = model.id ?? "";
+			const devModel = lookupInIndex(id, devIndex);
 			return {
-				id: model.id!,
+				id,
 				name: getModelName(model, devModel),
 				reasoning: getReasoning(model, devModel),
 				input: getInputTypes(model, devModel),

package/src/transcribe.test.ts

@@ -1,37 +1,17 @@
 import { describe, expect, it } from "bun:test";
-import { extname } from "node:path";
-
-// ── Re-export internal helpers for testing via module augmentation ────────────
-// transcribe.ts exports only the default fn; we test the pure logic
-// inline here to avoid coupling tests to private internals.
-
-// ── mimeType (copied from transcribe.ts) ─────────────────────────────────────
-
-function mimeType(filePath: string): string {
-	const ext = extname(filePath).toLowerCase();
-	const types: Record<string, string> = {
-		".mp3": "audio/mpeg",
-		".wav": "audio/wav",
-		".flac": "audio/flac",
-		".ogg": "audio/ogg",
-		".m4a": "audio/mp4",
-		".webm": "audio/webm",
-		".mp4": "audio/mp4",
-		".mpga": "audio/mpeg",
-	};
-	return types[ext] ?? "application/octet-stream";
-}
-
-// ── parseTranscriptionResponse (extracted logic from execute) ─────────────────
-
-function parseTranscriptionResponse(raw: string): string {
-	try {
-		const parsed = JSON.parse(raw) as { text?: string };
-		return parsed.text ?? raw;
-	} catch {
-		return raw;
-	}
-}
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmod, readFile, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+	buildTranscriptionResult,
+	mimeType,
+	parseTranscriptionResponse,
+	resolveOutputPath,
+	validateOutputPath,
+	writeTranscriptionFile,
+} from "./transcribe.js";
 
 // ── mimeType ─────────────────────────────────────────────────────────────────
 
@@ -158,3 +138,295 @@ describe("parseTranscriptionResponse", () => {
 		expect(parseTranscriptionResponse("")).toBe("");
 	});
 });
+
+// ── resolveOutputPath ────────────────────────────────────────────────────────
+
+describe("resolveOutputPath", () => {
+	it("keeps absolute paths as-is", () => {
+		const abs = "/tmp/foo/bar.txt";
+		expect(resolveOutputPath(abs)).toBe(abs);
+	});
+
+	it("resolves relative paths against cwd", () => {
+		const rel = "transcripts/out.txt";
+		const result = resolveOutputPath(rel);
+		expect(result.endsWith("transcripts/out.txt")).toBe(true);
+		expect(result.startsWith(process.cwd())).toBe(true);
+	});
+});
+
+// ── writeTranscriptionFile ───────────────────────────────────────────────────
+
+describe("writeTranscriptionFile", () => {
+	const tmpRoot = mkdtempSync(join(tmpdir(), "pix-transcribe-test-"));
+
+	it("writes text to the given file path", async () => {
+		const file = join(tmpRoot, "simple.txt");
+		const abs = await writeTranscriptionFile(file, "hello world");
+		expect(abs).toBe(file);
+		expect(await readFile(file, "utf-8")).toBe("hello world");
+	});
+
+	it("creates parent directories recursively", async () => {
+		const file = join(tmpRoot, "deep", "nested", "dir", "out.txt");
+		const abs = await writeTranscriptionFile(file, "deep content");
+		expect(abs).toBe(file);
+		expect(await readFile(file, "utf-8")).toBe("deep content");
+	});
+
+	it("preserves full unicode without truncation", async () => {
+		const text = `日本語のテスト\n${"x".repeat(100_000)}`;
+		const file = join(tmpRoot, "huge.txt");
+		await writeTranscriptionFile(file, text);
+		const got = await readFile(file, "utf-8");
+		expect(got.length).toBe(text.length);
+		expect(got).toBe(text);
+	});
+
+	it("overwrites an existing file", async () => {
+		const file = join(tmpRoot, "overwrite.txt");
+		await writeTranscriptionFile(file, "first");
+		await writeTranscriptionFile(file, "second");
+		expect(await readFile(file, "utf-8")).toBe("second");
+	});
+
+	// cleanup tmp root
+	it("cleanup", async () => {
+		await rm(tmpRoot, { recursive: true, force: true });
+	});
+});
+
+// ── buildTranscriptionResult ─────────────────────────────────────────────────
+
+describe("buildTranscriptionResult", () => {
+	const tmpRoot = mkdtempSync(join(tmpdir(), "pix-transcribe-result-"));
+
+	it("returns inline text (truncated at 50_000) when no output_file is set", async () => {
+		const text = "a".repeat(60_000);
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			undefined,
+		);
+		expect(result.content).toHaveLength(1);
+		expect(result.content[0]?.type).toBe("text");
+		expect(result.content[0]?.text.length).toBe(50_000);
+		expect(result.details).toEqual({
+			source: "api",
+			model: "dg/nova-3",
+			chars: 60_000,
+		});
+	});
+
+	it("returns inline text (untruncated) when short and no output_file", async () => {
+		const text = "short transcript";
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			undefined,
+		);
+		expect(result.content[0]?.text).toBe("short transcript");
+		expect(result.details.chars).toBe(text.length);
+	});
+
+	it("writes full text to file and returns short path summary when output_file is set", async () => {
+		const text = "a".repeat(100_000); // way over 50k
+		const file = join(tmpRoot, "result-a.txt");
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			file,
+		);
+
+		// content is a short summary, not the full text
+		expect(result.content).toHaveLength(1);
+		const summary = result.content[0]?.text ?? "";
+		expect(summary.length).toBeLessThan(200);
+		expect(summary).toContain("100000");
+		expect(summary).toContain(file);
+
+		// full text was written verbatim
+		const onDisk = await readFile(file, "utf-8");
+		expect(onDisk.length).toBe(100_000);
+		expect(onDisk).toBe(text);
+
+		// details includes resolved absolute path
+		expect(result.details.output_path).toBe(file);
+		expect(result.details.chars).toBe(100_000);
+		expect(result.details.source).toBe("api");
+	});
+
+	it("passes through curl-fallback source label", async () => {
+		const text = "hi";
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"curl-fallback",
+			undefined,
+		);
+		expect(result.details.source).toBe("curl-fallback");
+	});
+
+	it("relative output_file is resolved against cwd and created", async () => {
+		const text = "relative path content";
+		const relDir = join(tmpRoot, "rel", "sub");
+		const relFile = join(relDir, "out.txt");
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			relFile,
+		);
+
+		expect(result.details.output_path).toBe(relFile);
+		expect(await readFile(relFile, "utf-8")).toBe("relative path content");
+	});
+
+	it("cleanup", async () => {
+		await rm(tmpRoot, { recursive: true, force: true });
+	});
+});
+
+// ── validateOutputPath ───────────────────────────────────────────────────────
+
+describe("validateOutputPath", () => {
+	const tmpRoot = mkdtempSync(join(tmpdir(), "pix-validate-"));
+
+	it("accepts a fresh path under a writable parent", async () => {
+		const result = await validateOutputPath(join(tmpRoot, "fresh.txt"));
+		expect(result.ok).toBe(true);
+		if (result.ok) expect(result.path).toBe(join(tmpRoot, "fresh.txt"));
+	});
+
+	it("accepts a fresh path several levels deep", async () => {
+		const result = await validateOutputPath(
+			join(tmpRoot, "a", "b", "c", "deep.txt"),
+		);
+		expect(result.ok).toBe(true);
+	});
+
+	it("rejects null bytes", async () => {
+		const result = await validateOutputPath(join(tmpRoot, "x\0y.txt"));
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toContain("null byte");
+	});
+
+	it.each([
+		"/etc",
+		"/etc/passwd",
+		"/etc/cron.daily/x",
+		"/proc/cpuinfo",
+		"/sys/kernel/x",
+		"/boot/efi/x",
+		`${homedir()}/.ssh/authorized_keys`,
+		`${homedir()}/.aws/credentials`,
+		`${homedir()}/.gnupg/gpg.conf`,
+		`${homedir()}/.config/gh/hosts.yml`,
+	])("rejects sensitive prefix %s", async (bad) => {
+		const result = await validateOutputPath(bad);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.reason).toMatch(/refusing to write/);
+		}
+	});
+
+	it("rejects when no ancestor directory exists at all", async () => {
+		// Deep path under a non-existent tree with no existing ancestor
+		const result = await validateOutputPath("/no-such-root-xyz/abc/def/x.txt");
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toMatch(/no existing ancestor/);
+	});
+
+	it("rejects when parent is not writable", async () => {
+		const readOnlyParent = join(tmpRoot, "ro");
+		mkdirSync(readOnlyParent);
+		await chmod(readOnlyParent, 0o555);
+		try {
+			const result = await validateOutputPath(join(readOnlyParent, "x.txt"));
+			expect(result.ok).toBe(false);
+			if (!result.ok) expect(result.reason).toMatch(/no writable ancestor/);
+		} finally {
+			// restore so cleanup can rm -rf
+			await chmod(readOnlyParent, 0o755);
+		}
+	});
+
+	it("rejects when target is a symlink", async () => {
+		const real = join(tmpRoot, "real.txt");
+		writeFileSync(real, "x");
+		const link = join(tmpRoot, "link.txt");
+		symlinkSync(real, link);
+		const result = await validateOutputPath(link);
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toMatch(/symlink/);
+	});
+
+	it("rejects when target is an existing directory", async () => {
+		const dir = join(tmpRoot, "isadir");
+		mkdirSync(dir);
+		const result = await validateOutputPath(dir);
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toMatch(/directory/);
+	});
+
+	it("rejects when a parent in the chain is a symlink", async () => {
+		const realSubdir = join(tmpRoot, "real-sub");
+		mkdirSync(realSubdir);
+		const symlinkedParent = join(tmpRoot, "fake-parent");
+		symlinkSync(realSubdir, symlinkedParent);
+		const result = await validateOutputPath(join(symlinkedParent, "x.txt"));
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toMatch(/parent is a symlink/);
+	});
+
+	it("accepts a path inside an existing file's parent (overwrite OK)", async () => {
+		const existing = join(tmpRoot, "exists.txt");
+		writeFileSync(existing, "old");
+		const result = await validateOutputPath(existing);
+		expect(result.ok).toBe(true);
+	});
+
+	it("cleanup", async () => {
+		await rm(tmpRoot, { recursive: true, force: true });
+	});
+});
+
+// ── writeTranscriptionFile — rejection propagation ───────────────────────────
+
+describe("writeTranscriptionFile — rejection propagation", () => {
+	it("throws on sensitive prefix", async () => {
+		await expect(writeTranscriptionFile("/etc/some-file", "x")).rejects.toThrow(
+			/refusing to write under \/etc/,
+		);
+	});
+
+	it("throws on null byte", async () => {
+		await expect(
+			writeTranscriptionFile("/tmp/pix-test-\0x.txt", "x"),
+		).rejects.toThrow(/null byte/);
+	});
+});
+
+// ── buildTranscriptionResult — write failure path ───────────────────────────
+
+describe("buildTranscriptionResult — write failure path", () => {
+	it("returns isError + inline fallback when output_file is rejected", async () => {
+		const text = "the actual transcription that was successfully produced";
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			"/etc/passwd",
+		);
+		expect(result.isError).toBe(true);
+		expect(result.details.write_error).toMatch(/refusing to write/);
+		expect(result.details.output_path).toBeUndefined();
+		// inline text is still included so the model doesn't lose the result
+		const joined = result.content.map((c) => c.text).join("\n");
+		expect(joined).toContain(text);
+		expect(joined).toContain("/etc/passwd");
+	});
+});

package/src/transcribe.ts

@@ -12,13 +12,16 @@
  */
 
 import { type ExecFileException, execFile } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { basename, extname } from "node:path";
+import { constants as fsConstants } from "node:fs";
+import { access, lstat, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, isAbsolute, resolve } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { routerBaseUrl } from "./data.js";
 
 const REQUEST_TIMEOUT_MS = 120_000; // audio transcription can take longer
+const CHAT_TRUNCATE_LIMIT = 50_000; // only when no output_file is provided
 const DEFAULT_MODEL = "dg/nova-3";
 
 function auth(): string | undefined {
@@ -26,7 +29,7 @@ function auth(): string | undefined {
 }
 
 /** Map file extension to MIME type for common audio formats. */
-function mimeType(filePath: string): string {
+export function mimeType(filePath: string): string {
 	const ext = extname(filePath).toLowerCase();
 	const types: Record<string, string> = {
 		".mp3": "audio/mpeg",
@@ -104,25 +107,239 @@ function curl(args: string[]): Promise<string> {
 	});
 }
 
+/** Extract the `text` field from a JSON envelope, or return the raw string. */
+export function parseTranscriptionResponse(raw: string): string {
+	try {
+		const parsed = JSON.parse(raw) as { text?: string };
+		return parsed.text ?? raw;
+	} catch {
+		return raw;
+	}
+}
+
+/** Resolve a possibly-relative `output_file` to an absolute path. */
+export function resolveOutputPath(outputFile: string): string {
+	return isAbsolute(outputFile)
+		? outputFile
+		: resolve(process.cwd(), outputFile);
+}
+
+/**
+ * Pre-flight safety check for `output_file`. Rejects paths that target sensitive
+ * system locations, null bytes, non-existent or non-writable parents, symlinks
+ * (at the target or anywhere in the parent chain), and existing-directory targets.
+ *
+ * Returns a discriminated result so the caller can surface a precise reason to
+ * the model without leaking OS internals.
+ */
+export type PathValidation =
+	| { ok: true; path: string }
+	| { ok: false; reason: string };
+
+/** Block-list of absolute prefixes that should never receive transcription output. */
+function sensitivePrefixes(): string[] {
+	const home = homedir();
+	return [
+		"/etc",
+		"/proc",
+		"/sys",
+		"/boot",
+		`${home}/.ssh`,
+		`${home}/.aws`,
+		`${home}/.gnupg`,
+		`${home}/.config/gh`,
+	];
+}
+
+export async function validateOutputPath(
+	absPath: string,
+): Promise<PathValidation> {
+	// 1. Null byte injection guard (defence in depth — Node already rejects, fail fast with clear msg)
+	if (absPath.includes("\0")) {
+		return { ok: false, reason: "path contains a null byte" };
+	}
+
+	// 2. Sensitive prefix block-list
+	for (const prefix of sensitivePrefixes()) {
+		if (absPath === prefix || absPath.startsWith(`${prefix}/`)) {
+			return { ok: false, reason: `refusing to write under ${prefix}` };
+		}
+	}
+
+	// 3. Target must not be a symlink and must not be an existing directory.
+	//    (lstat does NOT follow symlinks — that's the whole point of using it here.)
+	try {
+		const st = await lstat(absPath);
+		if (st.isSymbolicLink()) {
+			return { ok: false, reason: `target is a symlink: ${absPath}` };
+		}
+		if (st.isDirectory()) {
+			return {
+				ok: false,
+				reason: `target is an existing directory: ${absPath}`,
+			};
+		}
+	} catch (err) {
+		// ENOENT is fine — we'll create the file. Anything else is a hard fail.
+		if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+			return {
+				ok: false,
+				reason: `cannot stat target: ${(err as Error).message}`,
+			};
+		}
+	}
+
+	// 4. Walk up the parent chain. For every ancestor that EXISTS, it must
+	//    (a) not be a symlink (stops /tmp/safe-looking-dir → /etc redirect), and
+	//    (b) be writable so mkdir -p can create missing intermediates.
+	//    Ancestors that don't exist (ENOENT) are fine — mkdir -p will create them.
+	const parent = dirname(absPath);
+	let cursor = parent;
+	let nearestExisting: string | null = null;
+	while (cursor !== dirname(cursor)) {
+		let st: Awaited<ReturnType<typeof lstat>>;
+		try {
+			st = await lstat(cursor);
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+				// intermediate doesn't exist yet — keep walking up
+				cursor = dirname(cursor);
+				continue;
+			}
+			return {
+				ok: false,
+				reason: `cannot stat parent: ${(err as Error).message}`,
+			};
+		}
+		if (st.isSymbolicLink()) {
+			return { ok: false, reason: `parent is a symlink: ${cursor}` };
+		}
+		if (st.isDirectory() && nearestExisting === null) {
+			nearestExisting = cursor;
+		}
+		cursor = dirname(cursor);
+	}
+
+	if (nearestExisting === null) {
+		return {
+			ok: false,
+			reason: `no existing ancestor directory for ${parent}`,
+		};
+	}
+	try {
+		await access(nearestExisting, fsConstants.W_OK);
+	} catch {
+		return {
+			ok: false,
+			reason: `no writable ancestor directory: ${nearestExisting}`,
+		};
+	}
+
+	return { ok: true, path: absPath };
+}
+
+/** Write transcription text to disk, creating parent directories as needed.
+ *  Performs pre-flight safety checks; throws on rejection. */
+export async function writeTranscriptionFile(
+	outputFile: string,
+	text: string,
+): Promise<string> {
+	const abs = resolveOutputPath(outputFile);
+	const validation = await validateOutputPath(abs);
+	if (!validation.ok) {
+		throw new Error(`output_file rejected: ${validation.reason}`);
+	}
+	await mkdir(dirname(abs), { recursive: true });
+	await writeFile(abs, text, "utf-8");
+	return abs;
+}
+
+/**
+ * Build the tool return value from a successful transcription.
+ * - If `outputFile` is set: write the full text verbatim and return a short summary.
+ * - Otherwise: return the text inline, truncated to fit chat.
+ */
+export async function buildTranscriptionResult(
+	text: string,
+	model: string,
+	source: "api" | "curl-fallback",
+	outputFile: string | undefined,
+): Promise<{
+	content: { type: "text"; text: string }[];
+	details: Record<string, unknown>;
+	isError?: boolean;
+}> {
+	const details: Record<string, unknown> = {
+		source,
+		model,
+		chars: text.length,
+	};
+
+	if (outputFile) {
+		try {
+			const abs = await writeTranscriptionFile(outputFile, text);
+			details.output_path = abs;
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Transcribed ${text.length} chars → ${abs}`,
+					},
+				],
+				details,
+			};
+		} catch (writeErr) {
+			const msg =
+				writeErr instanceof Error ? writeErr.message : String(writeErr);
+			details.write_error = msg;
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Transcription succeeded but writing to ${outputFile} failed: ${msg}\nThe transcribed text is included below — consider writing it to a different path.`,
+					},
+					{ type: "text", text: text.slice(0, CHAT_TRUNCATE_LIMIT) },
+				],
+				details,
+				isError: true,
+			};
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: text.slice(0, CHAT_TRUNCATE_LIMIT) }],
+		details,
+	};
+}
+
 export default function registerTranscribe(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "transcribe",
 		label: "Transcribe",
 		description:
-			"Convert speech to text. Transcribes an audio file using the 9Router audio transcription API (Deepgram Nova 3).",
+			"Convert speech to text. Transcribes an audio file using the 9Router audio transcription API (Deepgram Nova 3). Optionally writes the full text to a file on disk.",
 		promptSnippet:
-			"transcribe(file, model?, language?) — Transcribe an audio file to text. Supports mp3, wav, flac, ogg, m4a, webm. Default model: dg/nova-3.",
+			"transcribe(file, output_file?, model?, language?) — Transcribe an audio file to text. Supports mp3, wav, flac, ogg, m4a, webm. Default model: dg/nova-3. If output_file is set, the full text is written to that path (parent dirs created) and only a short path summary is returned to the model.",
 		promptGuidelines: [
 			"Use transcribe when you need to convert speech/audio to text.",
 			"The file parameter should be an absolute or relative path to an audio file on disk.",
 			"Supports common audio formats: mp3, wav, flac, ogg, m4a, webm, mp4.",
 			"Default model is dg/nova-3 (Deepgram Nova 3). Override with model parameter if needed.",
 			"Optionally specify language as ISO 639-1 code (e.g. 'en', 'es', 'fr') for better accuracy.",
+			"Pass output_file to write the full transcription to disk — useful when the result is long, when it will be re-read or piped to another tool, or to keep chat context small. Relative paths are resolved against the current working directory.",
+			"output_file is pre-flight checked: paths under /etc, /proc, /sys, /boot, ~/.ssh, ~/.aws, ~/.gnupg, and ~/.config/gh are rejected; the target must not be a symlink or existing directory; the parent must exist and be writable; symlinks anywhere in the parent chain are rejected. On rejection, the transcription text is still returned inline so it is not lost.",
+			"Without output_file the transcribed text is returned inline (truncated to 50,000 chars).",
 		],
 		parameters: Type.Object({
 			file: Type.String({
 				description: "Path to the audio file to transcribe",
 			}),
+			output_file: Type.Optional(
+				Type.String({
+					description:
+						"Write the full transcription text to this path (parent dirs are created). Relative paths resolve against cwd. When set, content returned to the model is just a short path summary.",
+				}),
+			),
 			model: Type.Optional(
 				Type.String({
 					description: "Transcription model to use (default: dg/nova-3)",
@@ -140,8 +357,17 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 		async execute(_toolCallId, params, signal, onUpdate) {
 			const model = params.model ?? DEFAULT_MODEL;
 			const filePath = params.file;
+			const outputFile = params.output_file;
 			let apiMsg = "";
 
+			const run = async (source: "api" | "curl-fallback", raw: string) =>
+				buildTranscriptionResult(
+					parseTranscriptionResponse(raw),
+					model,
+					source,
+					outputFile,
+				);
+
 			try {
 				onUpdate?.({
 					content: [
@@ -161,23 +387,7 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 					signal,
 				);
 
-				// The API may return JSON {"text": "..."} or plain text
-				let text: string;
-				try {
-					const parsed = JSON.parse(raw) as { text?: string };
-					text = parsed.text ?? raw;
-				} catch {
-					text = raw;
-				}
-
-				return {
-					content: [{ type: "text", text: text.slice(0, 50_000) }],
-					details: {
-						source: "api",
-						model,
-						chars: text.length,
-					},
-				};
+				return await run("api", raw);
 			} catch (apiErr: unknown) {
 				apiMsg = apiErr instanceof Error ? apiErr.message : String(apiErr);
 				onUpdate?.({
@@ -206,24 +416,7 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 				];
 
 				const raw = await curl(curlArgs);
-
-				let text: string;
-				try {
-					const parsed = JSON.parse(raw) as { text?: string };
-					text = parsed.text ?? raw;
-				} catch {
-					text = raw;
-				}
-
-				return {
-					content: [
-						{
-							type: "text",
-							text: `[FALLBACK — curl] API called via curl instead of fetch.\n\n${text.slice(0, 49_500)}`,
-						},
-					],
-					details: { source: "curl-fallback", model },
-				};
+				return await run("curl-fallback", raw);
 			} catch (curlErr: unknown) {
 				const curlMsg =
 					curlErr instanceof Error ? curlErr.message : String(curlErr);