@xynogen/pix-9router 0.3.4 → 0.3.6

package/src/transcribe.test.ts

@@ -4,7 +4,7 @@ import { chmod, readFile, rm } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 
-import {
+import registerTranscribe, {
 	buildTranscriptionResult,
 	mimeType,
 	parseTranscriptionResponse,
@@ -205,10 +205,13 @@ describe("buildTranscriptionResult", () => {
 		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",
+		expect(result.details).toMatchObject({
+			_type: "transcribeResult",
+			outcome: "success",
 			model: "dg/nova-3",
+			source: "api",
 			chars: 60_000,
+			truncated: true,
 		});
 	});
 
@@ -384,13 +387,131 @@ describe("writeTranscriptionFile — rejection propagation", () => {
 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");
+		const result = await buildTranscriptionResult(
+			text,
+			"dg/nova-3",
+			"api",
+			"/etc/passwd",
+			"meeting.mp3",
+		);
 		expect(result.isError).toBe(true);
-		expect(result.details.write_error).toMatch(/refusing to write/);
+		expect(result.details).toMatchObject({
+			_type: "transcribeResult",
+			outcome: "error",
+			file: "meeting.mp3",
+			write_error: expect.stringMatching(/refusing to write/),
+		});
 		expect(result.details.output_path).toBeUndefined();
-		// inline text is still included so the model doesn't lose the result
+		// both blocks, including the recovered transcript, remain available to the model
+		expect(result.content).toHaveLength(2);
 		const joined = result.content.map((c) => c.text).join("\n");
 		expect(joined).toContain(text);
 		expect(joined).toContain("/etc/passwd");
 	});
 });
+
+const theme = {
+	fg: (token: string, text: string) => `[${token}]${text}`,
+	bold: (text: string) => `*${text}*`,
+} as never;
+
+function captureTranscribeRenderer() {
+	let tool: Record<string, unknown> | undefined;
+	registerTranscribe({
+		registerTool(value: Record<string, unknown>) {
+			tool = value;
+		},
+	} as never);
+	if (!tool) throw new Error("transcribe tool was not registered");
+	return tool;
+}
+
+function renderTranscribe(
+	result: Record<string, unknown>,
+	expanded = false,
+	isError = false,
+): string {
+	let text = "";
+	const component = {
+		setText(value: string) {
+			text = value;
+		},
+		render: () => [],
+		invalidate: () => {},
+	};
+	const tool = captureTranscribeRenderer();
+	const renderResult = tool.renderResult as ((...args: never[]) => unknown) | undefined;
+	renderResult?.(result as never, { expanded, isPartial: false } as never, theme, {
+		lastComponent: component,
+		isError,
+		state: { collapsed: true },
+		expanded,
+		invalidate: () => {},
+	} as never);
+	return text;
+}
+
+describe("transcribe compact renderer", () => {
+	it("uses the self-rendered shell so the status mark has no leading box padding", () => {
+		expect(captureTranscribeRenderer().renderShell).toBe("self");
+	});
+
+	it("summarizes inline and written transcripts", () => {
+		const inline = renderTranscribe({
+			content: [{ type: "text", text: "full transcript" }],
+			details: {
+				_type: "transcribeResult",
+				outcome: "success",
+				file: "/recordings/meeting.mp3",
+				model: "dg/nova-3",
+				source: "api",
+				chars: 12_400,
+				truncated: false,
+			},
+		});
+		expect(inline).toContain("✓");
+		expect(inline).toContain("meeting.mp3");
+		expect(inline).toContain("12.4K chars · dg/nova-3");
+
+		const written = renderTranscribe({
+			content: [{ type: "text", text: "Transcribed 12400 chars → /tmp/notes.md" }],
+			details: {
+				_type: "transcribeResult",
+				outcome: "success",
+				file: "/recordings/meeting.mp3",
+				model: "dg/nova-3",
+				source: "api",
+				chars: 12_400,
+				truncated: false,
+				output_path: "/tmp/notes.md",
+			},
+		});
+		expect(written).toContain("12.4K chars · wrote notes.md");
+	});
+
+	it("summarizes write failure and restores both exact blocks when expanded", () => {
+		const result = {
+			content: [
+				{ type: "text", text: "Writing failed: permission denied" },
+				{ type: "text", text: "recovered transcript" },
+			],
+			details: {
+				_type: "transcribeResult",
+				outcome: "error",
+				file: "/recordings/meeting.mp3",
+				model: "dg/nova-3",
+				source: "api",
+				chars: 20,
+				truncated: false,
+				write_error: "permission denied",
+			},
+		};
+		const compact = renderTranscribe(result, false, true);
+		expect(compact).toContain("✗");
+		expect(compact).toContain("write failed · transcript preserved inline");
+
+		const expanded = renderTranscribe(result, true, true);
+		expect(expanded).toContain("Writing failed: permission denied");
+		expect(expanded).toContain("recovered transcript");
+	});
+});

package/src/transcribe.ts

@@ -19,11 +19,33 @@ 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";
+import { makeRenderCall, makeRenderResult } from "./render.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";
 
+type TranscribeOutcome = "running" | "success" | "cancelled" | "error";
+
+export interface TranscribeResultDetails {
+	_type: "transcribeResult";
+	outcome: TranscribeOutcome;
+	file: string;
+	model: string;
+	language?: string;
+	source?: "api" | "curl-fallback" | "failed";
+	chars?: number;
+	truncated?: boolean;
+	output_path?: string;
+	write_error?: string;
+}
+
+interface TranscribeResult {
+	content: { type: "text"; text: string }[];
+	details: TranscribeResultDetails;
+	isError?: boolean;
+}
+
 function auth(): string | undefined {
 	return process.env.ROUTER_API_KEY;
 }
@@ -253,15 +275,18 @@ export async function buildTranscriptionResult(
 	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,
+	file = "audio",
+	language?: string,
+): Promise<TranscribeResult> {
+	const details: TranscribeResultDetails = {
+		_type: "transcribeResult",
+		outcome: "success",
+		file,
 		model,
+		...(language ? { language } : {}),
+		source,
 		chars: text.length,
+		truncated: !outputFile && text.length > CHAT_TRUNCATE_LIMIT,
 	};
 
 	if (outputFile) {
@@ -279,6 +304,8 @@ export async function buildTranscriptionResult(
 			};
 		} catch (writeErr) {
 			const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+			details.outcome = "error";
+			details.truncated = text.length > CHAT_TRUNCATE_LIMIT;
 			details.write_error = msg;
 			return {
 				content: [
@@ -300,14 +327,50 @@ export async function buildTranscriptionResult(
 	};
 }
 
+function compactChars(chars: number | undefined): string {
+	const value = chars ?? 0;
+	if (value < 1_000) return String(value);
+	if (value < 1_000_000) return `${(value / 1_000).toFixed(1)}K`;
+	return `${(value / 1_000_000).toFixed(1)}M`;
+}
+
 export default function registerTranscribe(pi: ExtensionAPI): void {
+	const renderTerminal = makeRenderResult<TranscribeResultDetails>({
+		tool: "transcribe",
+		target: (details) => basename(details.file),
+		meta: (details) => {
+			if (details.write_error) return "write failed · transcript preserved inline";
+			if (details.outcome === "error") return "failed";
+			if (details.outcome === "cancelled") return "cancelled";
+			const chars = `${compactChars(details.chars)} chars`;
+			return details.output_path
+				? `${chars} · wrote ${basename(details.output_path)}`
+				: `${chars} · ${details.model}`;
+		},
+		status: (details) =>
+			details.outcome === "error"
+				? "error"
+				: details.outcome === "cancelled"
+					? "warning"
+					: "success",
+	});
+
 	pi.registerTool({
 		name: "transcribe",
 		label: "Transcribe",
+		renderShell: "self",
 		description:
 			"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, 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.",
+		renderCall: makeRenderCall("transcribe", (args) => basename(String(args.file ?? ""))),
+		renderResult: (result, options, theme, context) =>
+			renderTerminal(result, options, theme, {
+				...context,
+				// Structured transcription failures have safe metadata for a compact
+				// terminal row; expansion still restores the exact returned blocks.
+				isError: context.isError && options.expanded,
+			}),
 		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.",
@@ -348,7 +411,14 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 			let apiMsg = "";
 
 			const run = async (source: "api" | "curl-fallback", raw: string) =>
-				buildTranscriptionResult(parseTranscriptionResponse(raw), model, source, outputFile);
+				buildTranscriptionResult(
+					parseTranscriptionResponse(raw),
+					model,
+					source,
+					outputFile,
+					filePath,
+					params.language,
+				);
 
 			try {
 				onUpdate?.({
@@ -358,7 +428,13 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 							text: `Transcribing: ${filePath} (model: ${model})...`,
 						},
 					],
-					details: undefined,
+					details: {
+						_type: "transcribeResult",
+						outcome: "running",
+						file: filePath,
+						model,
+						...(params.language ? { language: params.language } : {}),
+					},
 				});
 
 				const raw = await apiMultipart(
@@ -408,7 +484,14 @@ export default function registerTranscribe(pi: ExtensionAPI): void {
 							text: `Transcription failed (both API and curl).\nAPI: ${apiMsg}\nCurl: ${curlMsg}`,
 						},
 					],
-					details: { source: "failed" },
+					details: {
+						_type: "transcribeResult",
+						outcome: signal?.aborted ? "cancelled" : "error",
+						file: filePath,
+						model,
+						...(params.language ? { language: params.language } : {}),
+						source: "failed",
+					},
 					isError: true,
 				};
 			}