pi-voicekit 0.3.0 → 0.3.1

package/extensions/voice/local.ts

@@ -1103,14 +1103,8 @@ async function transcribeInProcess(
 	config: VoiceConfig,
 	onSegment?: (text: string, index: number) => void
 ): Promise<string> {
-	const {
-		initSherpa,
-		isSherpaAvailable,
-		getSherpaError,
-		getOrCreateRecognizer,
-		transcribeBuffer,
-		transcribeBufferSegmented,
-	} = await import("./sherpa-engine");
+	const { initSherpa, isSherpaAvailable, getSherpaError, getOrCreateRecognizer, transcribeBufferSegmented } =
+		await import("./sherpa-engine");
 	const { ensureModelDownloaded } = await import("./model-download");
 
 	// Initialize sherpa if needed
@@ -1131,21 +1125,10 @@ async function transcribeInProcess(
 
 	// Create/reuse recognizer and transcribe
 	const recognizer = getOrCreateRecognizer(model, modelDir, config.language || "en");
-	// Qwen3-ASR caps context at 512 tokens (~18s); segment long audio via VAD before decode.
-	if (model.sherpaModel.type === "qwen3_asr") {
-		return transcribeBufferSegmented(pcmData, recognizer, undefined, onSegment);
-	}
-	const text = await transcribeBuffer(pcmData, recognizer);
-	// Every other in-process model decodes the whole buffer as a single segment. Report it so
-	// a pipelining caller sees one segment for any in-process dictation (a short qwen3
-	// dictation takes the same single-segment fast path). Observational, like the recogniser's
-	// callback: a throwing observer must not cost the transcript.
-	if (onSegment) {
-		try {
-			onSegment(text, 0);
-		} catch {}
-	}
-	return text;
+	// Every in-process model decodes long audio in VAD-sized pieces, so a pipelining caller can
+	// polish one piece while the rest still decodes; audio at or below the segment threshold takes
+	// the same single-decode fast path as before and the concatenation is unchanged.
+	return transcribeBufferSegmented(pcmData, recognizer, undefined, onSegment);
 }
 
 /** Check if a local transcription server is reachable. */

package/extensions/voice/post-process-queue.ts

@@ -393,7 +393,7 @@ export function createPolishQueue(options: PolishQueueOptions): PolishQueue {
 		const call: LiveCall = { settled: false, orphaned: false };
 		let issued = false;
 		try {
-			const sampling = polishSamplingOptions(options.model, job.raw.length, forceOff);
+			const sampling = polishSamplingOptions(options.model);
 			const result = await polishTranscript({
 				raw: job.raw,
 				entries: entriesForSegment(job.index),

package/extensions/voice/post-process.ts

@@ -331,36 +331,23 @@ export function buildPolishAudit(input: {
 }
 
 /**
- * Extra request fields for the polish call, or nothing when the model has no thinking to turn
- * off.
+ * Extra request fields for the polish call, or nothing when the model has no thinking to turn off.
  *
- * Short transcripts keep thinking on: it is cheap there and the wording comes out better.
- * Measured 2026-09-26 on the acceptance corpus, thinking on won exactly the samples this pass
- * exists for — a self-correction merged for +1.71 CER with it on against 0 with it off, and two
- * zh-en term samples +0.08/+0.10 against 0 — while a 161-character transcript spent only 66
- * reasoning tokens in 0.47 s.
- *
- * Long transcripts turn it off: there thinking grows far past the token budget (309 characters
- * needed ~1700 reasoning tokens, 471 characters ~2800-4400, against a budget of 1130-1454), so the
- * answer was truncated and the pass fell back to the raw transcript — intermittently, which is
- * what made a long dictation look unpolished. With thinking off the same input finished in ~1.2 s
- * and spent no reasoning tokens at all.
+ * Thinking is off for every polish call on a reasoning model. It buys quality on short samples
+ * (measured 2026-09-26: a self-correction merged for +1.71 CER with thinking on against 0 with it
+ * off, two zh-en term samples +0.08/+0.10) but it spends a budget nobody can predict: the same
+ * spend that truncated long transcripts also hit short ones - a 76-character dictation burned
+ * ~1,200 reasoning tokens against a 664-1,024 budget and came back truncated after 7.6 s, and
+ * every real-corpus failure recorded on 2026-09-26 was `stop-reason:length` on a transcript of
+ * under 200 characters. On the real corpus the measured correction gain was ~0 either way, so
+ * the pass keeps the wording it can improve and gives up the truncation class entirely.
  *
  * `samplingParams` is applied by OpenAI-compatible adapters only, and the `reasoning` gate keeps
  * the field away from models with no thinking at all.
- *
- * `forceOff` is the segmented queue's retry: the attempt already burned its deadline, so it runs
- * small and cheap regardless of length. It overrides the length gate only - a model with no
- * thinking still gets no sampling fields at all.
  */
-export const THINKING_MAX_CHARS = 200;
-
-export function polishSamplingOptions(
-	model: { reasoning?: boolean } | undefined | null,
-	rawLength: number,
-	forceOff = false
-): { samplingParams?: { reasoning_effort: string } } {
+export function polishSamplingOptions(model: { reasoning?: boolean } | undefined | null): {
+	samplingParams?: { reasoning_effort: string };
+} {
 	if (!model || model.reasoning !== true) return {};
-	if (!forceOff && Number.isFinite(rawLength) && rawLength <= THINKING_MAX_CHARS) return {};
 	return { samplingParams: { reasoning_effort: "none" } };
 }

package/extensions/voice.ts

@@ -1029,10 +1029,9 @@ export default function (pi: ExtensionAPI) {
 						{
 							signal,
 							maxTokens: request.maxTokens,
-							// Measured 2026-09-26: without this a reasoning model spends the whole budget thinking
-							// about a long dictation and the pass falls back to the raw text — see
-							// polishSamplingOptions.
-							...polishSamplingOptions(model as { reasoning?: boolean }, raw.length),
+							// Measured 2026-09-26: without this a reasoning model can spend the whole budget thinking,
+							// truncating the answer on any dictation — see polishSamplingOptions.
+							...polishSamplingOptions(model as { reasoning?: boolean }),
 						}
 					),
 				debug: (reason, data) => voiceDebug(`polish ${reason}`, data),
@@ -1042,7 +1041,7 @@ export default function (pi: ExtensionAPI) {
 				configured: choice.ref,
 				// Pure and cheap, so computing it twice (here and in the call options) is fine, and it
 				// keeps the audit entry honest about what the pass decided.
-				thinkingOff: Boolean(polishSamplingOptions(model as { reasoning?: boolean }, raw.length).samplingParams),
+				thinkingOff: Boolean(polishSamplingOptions(model as { reasoning?: boolean }).samplingParams),
 				maxTokens: polishMaxTokens(raw.length),
 				status: result.status,
 				ms: Date.now() - started,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-voicekit",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Voice in + voice out for Pi CLI — hold-to-talk STT (Deepgram streaming or 21 offline models) plus TTS (Kitten Nano, Piper, Kokoro, or Deepgram Aura)",
   "type": "module",
   "keywords": [