@tychenjiajun/pi-voice 0.3.0 → 0.5.0

package/README.md

@@ -4,7 +4,7 @@ Speech-to-text for Pi — on-device model or OpenAI-compatible remote ASR, with
 
 Press a keyboard shortcut, talk, and the resulting transcript will be put directly into your chat.
 
-> **Fork notice.** `@tychenjiajun/pi-voice` is a fork of [`@earendil-works/pi-voice`](https://github.com/earendil-works/pi-voice) that adds a remote ASR backend (any OpenAI-compatible `input_audio` chat-completions endpoint) with the local model kept as a fallback, plus compaction-style post-processing that refines a transcript with Pi's own model. It is published independently under a personal npm scope. See the [changelog](#changelog) for what changed.
+> **Fork notice.** `@tychenjiajun/pi-voice` is a fork of [`@earendil-works/pi-voice`](https://github.com/earendil-works/pi-voice) that adds a remote ASR backend (any OpenAI-compatible `input_audio` chat-completions endpoint) in an exclusive local-only or remote-only setup, plus compaction-style post-processing that refines a transcript with Pi's own model. It is published independently under a personal npm scope. See the [changelog](#changelog) for what changed.
 
 ## Install
 
@@ -27,7 +27,7 @@ The extension registers:
 - a configurable terminal shortcut (`Ctrl+Alt+Z` by default) to start and stop recording;
 - `/voice`, which does the same as the shortcut. While recording, `Space` also stops and transcribes, and `Escape` discards;
 - a `transcribe_file` tool that the agent can use to transcribe local audio or video files;
-- `/voice-settings` for preferred languages, model, transcription language, post-processing, microphone, and shortcut settings.
+- `/voice-settings` for preferred languages, model, transcription backend, transcription language, post-processing, microphone, and shortcut settings.
 
 `/transcribe` remains available as a compatibility alias for `/voice-settings`.
 
@@ -35,7 +35,7 @@ The extension registers:
 
 Pi Voice can send audio to a remote ASR service instead of transcribing with the local model. It speaks the OpenAI chat-completions `input_audio` dialect: the recording is uploaded as a base64 WAV data URL and the transcript is read from `choices[0].message.content`. Any endpoint that accepts that shape works.
 
-Set it up in `/voice-settings` → **Transcription backend** → **Remote ASR (OpenAI-compatible)**. You are asked for:
+Set it up either during first-run setup — `/voice-settings` starts by asking **Local model** or **Remote ASR (OpenAI-compatible)** — or later in `/voice-settings` → **Transcription backend** → **Remote ASR (OpenAI-compatible)**. You are asked for:
 
 1. **Base URL** — endpoint root, without `/chat/completions`;
 2. **Model** — the model name your endpoint expects;
@@ -49,12 +49,13 @@ export OPENAI_API_KEY=sk-...
 
 Behavior:
 
-- **Local model stays as fallback.** If a remote request fails (network, quota, HTTP error, or the API key is unset), the full recording is transcribed with the configured local model instead; the failure is logged to `~/.pi/agent/pi-voice.log`. Aborted/cancelled transcriptions are never retried locally.
+- **Remote-only mode.** Remote settings store no local model: setup skips the model download step, and a failed remote request (network, quota, HTTP error, or an unset API key) surfaces as an error instead of being retried offline. Failures are logged to `~/.pi/agent/pi-voice.log`.
 - **Batch-only.** Remote transcription happens when recording stops (the ASR request carries the whole clip), so there is no streaming preview.
-- **16 kHz mono WAV** is uploaded as a base64 data URL.
-- Switching back to **Local model** restores the original behavior; the local model is still required either way (it is the fallback and file transcription still needs it).
+- **16 kHz mono WAV** is uploaded as a base64 WAV data URL.
+- **Exclusive modes.** Switching **Transcription backend** to **Local model** asks you to pick a model first; switching to **Remote ASR** drops the local model from settings. The **Model** and **Transcription language** settings rows appear only in local mode.
+- `transcribe_file` uses whichever mode is configured — in remote mode the file audio is sent to the endpoint instead of a local model.
 
-Transcripts still go through the **Chinese output** script conversion preference.
+Transcripts still go through the **Chinese output** script conversion preference; because a remote response carries no detected language, Han characters in the transcript are what trigger the conversion when the language is set to automatic. The **Chinese output** row stays reachable in remote mode, since the endpoint can always produce Chinese.
 
 ## Post-processing (compaction-style refinement)
 
@@ -111,10 +112,40 @@ export PI_VOICE_FFMPEG_PATH=/path/to/ffmpeg
 
 The legacy `PI_TRANSCRIBE_FFMPEG_PATH` variable remains supported when `PI_VOICE_FFMPEG_PATH` is not set.
 
-When FFmpeg is unavailable, `transcribe_file` reports platform-specific guidance to the agent. The agent should ask before running a package-manager command. Model setup is still explicit: run `/voice-settings` once in the interactive TUI to choose and, after confirmation, download a local model.
+When FFmpeg is unavailable, `transcribe_file` reports platform-specific guidance to the agent. The agent should ask before running a package-manager command. Model setup is still explicit: run `/voice-settings` once in the interactive TUI to choose a mode and, in local mode, confirm the download of a local model.
 
 ## Changelog
 
+### 0.5.0
+
+**Changed — Exclusive local / remote modes (no fallback)**
+
+- Local and remote transcription are now mutually exclusive: remote settings store no local model, and selecting a local model drops any remote configuration. Settings files with both are normalized to remote-only on read.
+- First-run setup in remote mode skips the model step entirely; no local model is downloaded (onboarding jumps from step 2 to step 4, the Try it pane).
+- Removed the local fallback for remote ASR. Network, quota, HTTP, and unset-API-key failures now surface directly and are logged to `~/.pi/agent/pi-voice.log`.
+- The settings menu hides the **Model** and **Transcription language** rows in remote mode and always shows **Chinese output** there; switching the backend to local asks you to pick a model first, and switching to remote clears the local model.
+- Try it shows a **Local model** row in remote mode; choosing a model from it switches setup to local mode.
+- `transcribe_file` works in either mode and reports the remote model name in its details when remote.
+
+### 0.4.0
+
+**Added — Backend choice in first-run setup**
+
+- `/voice-settings` (and the first shortcut press) now starts by asking **Local model** or **Remote ASR (OpenAI-compatible)**, so the remote backend no longer requires finishing local setup first. A local model is still downloaded as the fallback.
+- The remote endpoint prompts (base URL, model, API-key env var name) are shared by first-run setup and the settings menu.
+
+**Fixed — Settings reachability and remote consistency**
+
+- `/voice-settings` opens the settings menu after recovering a missing model file, instead of returning and making you run the command a second time.
+- **Chinese output** is shown for detecting models that support Chinese, so it is reachable when the transcription language is automatic.
+- Remote transcripts apply the Chinese output preference when the transcript contains Han characters, not only when the configured language is Chinese.
+- Settings and errors no longer assume local-only transcription: the **Transcription language** row explains that a remote endpoint detects the language itself, and the transcription error, `transcribe_file` setup guidance, and Try-it model row describe the remote backend.
+
+**Changed**
+
+- Onboarding progress counts the backend step (1 backend → 2 languages → 3 model → 4 Try it).
+- Try it's **change model** keeps the configured transcription language for the new model.
+
 ### 0.3.0
 
 **Added — Post-processing (compaction-style refinement)**
@@ -133,7 +164,7 @@ First release of `@tychenjiajun/pi-voice` — a fork of [`@earendil-works/pi-voi
 **Added — Remote ASR backend**
 
 - Recordings can be transcribed by any OpenAI-compatible chat-completions ASR endpoint via the `input_audio` content block.
-- Configure in `/voice-settings` → **Transcription backend** → **Remote ASR (OpenAI-compatible)**: base URL, model, and the *name* of an env var holding the API key (the key itself is never stored in settings).
+- Configure in `/voice-settings` → **Transcription backend** → **Remote ASR (OpenAI-compatible)**: base URL, model, and the *name* of an env var holding the API key (the key itself is never stored in settings). First-run setup also offers the remote backend directly.
 - Audio is uploaded as a 16 kHz mono WAV base64 data URL. Remote transcription is batch-only (no streaming preview).
 - **Local model fallback:** if a remote request fails (network, quota, HTTP error, or the API key is unset), the full recording is transcribed with the configured local model; the failure is logged to `~/.pi/agent/pi-voice.log`. Aborted/cancelled transcriptions are never retried locally.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tychenjiajun/pi-voice",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Speech-to-text for Pi (local model or OpenAI-compatible remote ASR, compaction-style post-processing)",
   "type": "module",
   "license": "MIT",

package/src/chinese.ts

@@ -33,6 +33,21 @@ export function isChineseLanguage(language: string): boolean {
   return base === "zh" || base === "yue";
 }
 
+/**
+ * CJK ranges worth converting: Ext A, the main block, compatibility ideographs,
+ * and Ext B+ (surrogate pairs are matched by their lead code unit).
+ */
+const HAN_CHARACTERS = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\ud840-\ud87f]/;
+
+/**
+ * Remote ASR reports no detected language, so Chinese output is decided by
+ * looking at the transcript: OpenCC is only worth loading when there is Han
+ * text (or the configured language is Chinese) to convert.
+ */
+export function containsChineseCharacters(text: string): boolean {
+  return HAN_CHARACTERS.test(text);
+}
+
 export async function convertChineseOutput(
   text: string,
   output: ChineseOutput,

package/src/dictation-controller.ts

@@ -1,7 +1,11 @@
 import { CAPTURE_SAMPLE_RATE } from "./audio-constants.js";
 import { describeError, log, logStep, sinceKeyPress } from "./log.js";
 import { PcmChunker } from "./pcm-chunker.js";
-import type { MicrophoneSetting, TranscribeSettings } from "./settings.js";
+import {
+  transcriptionModelLabel,
+  type MicrophoneSetting,
+  type TranscribeSettings,
+} from "./settings.js";
 import type { DictationReservation, TranscriptionService } from "./transcription-service.js";
 
 /** What a recording captured. `interruption` is why it ended early, if it did. */
@@ -90,7 +94,7 @@ export class DictationController {
   /** Reserves the model for a take; on failure the state says why. */
   private reserve(settings: TranscribeSettings): Take | undefined {
     this.readiness = "loading";
-    logStep("reserving model", settings.model.id);
+    logStep("reserving model", transcriptionModelLabel(settings));
     const reservedAt = this.now();
     let reservation: DictationReservation;
     try {

package/src/file-transcription.ts

@@ -12,7 +12,7 @@ import { basename, join, resolve } from "node:path";
 import { Type } from "typebox";
 import { AsyncLimiter } from "./async-limiter.js";
 import { polishTranscript } from "./polish.js";
-import type { TranscribeSettings } from "./settings.js";
+import { transcriptionModelLabel, type TranscribeSettings } from "./settings.js";
 import type { TranscriptionService } from "./transcription-service.js";
 
 const CONTEXT_LINE_LENGTH = 1_000;
@@ -84,7 +84,7 @@ export function registerFileTranscriptionTool(
   pi.registerTool({
     name: "transcribe_file",
     label: "Transcribe File",
-    description: `Transcribe speech from a local audio or video file using Pi Voice's configured transcription backend (local model, or the configured remote ASR endpoint with the local model as fallback), then applies Pi Voice's compaction-style post-processing when it is enabled. Requires the ffmpeg executable on PATH (or PI_VOICE_FFMPEG_PATH). Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)}; a complete transcript is saved to a temporary file when needed.`,
+    description: `Transcribe speech from a local audio or video file using Pi Voice's configured transcription backend (local model or remote ASR endpoint), then applies Pi Voice's compaction-style post-processing when it is enabled. Requires the ffmpeg executable on PATH (or PI_VOICE_FFMPEG_PATH). Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)}; a complete transcript is saved to a temporary file when needed.`,
     promptSnippet: "Transcribe speech from local audio or video files",
     promptGuidelines: [
       "Use transcribe_file when speech in a local audio or video file needs to be read, analyzed, or transcribed.",
@@ -118,10 +118,11 @@ export function registerFileTranscriptionTool(
 
           const configured = await options.getSettings();
           const service = await options.getService();
+          const modelLabel = transcriptionModelLabel(configured);
           if (fileOperations.saturated) {
             onUpdate?.({
               content: [{ type: "text", text: "Waiting for file transcription capacity…" }],
-              details: { inputPath, modelId: configured.model.id, seconds: 0 },
+              details: { inputPath, modelId: modelLabel, seconds: 0 },
             });
           }
 
@@ -129,13 +130,13 @@ export function registerFileTranscriptionTool(
             if (fileDecoders.saturated) {
               onUpdate?.({
                 content: [{ type: "text", text: `Waiting to decode ${basename(inputPath)}…` }],
-                details: { inputPath, modelId: configured.model.id, seconds: 0 },
+                details: { inputPath, modelId: modelLabel, seconds: 0 },
               });
             }
             const audio = await fileDecoders.run(async () => {
               onUpdate?.({
                 content: [{ type: "text", text: `Decoding ${basename(inputPath)} with FFmpeg…` }],
-                details: { inputPath, modelId: configured.model.id, seconds: 0 },
+                details: { inputPath, modelId: modelLabel, seconds: 0 },
               });
               const { decodeFileAudio } = await import("./file-audio.js");
               return decodeFileAudio(inputPath, operationSignal);
@@ -145,12 +146,12 @@ export function registerFileTranscriptionTool(
               content: [
                 {
                   type: "text",
-                  text: `Queued ${audio.seconds.toFixed(1)}s from ${basename(inputPath)} for local transcription…`,
+                  text: `Queued ${audio.seconds.toFixed(1)}s from ${basename(inputPath)} for transcription…`,
                 },
               ],
               details: {
                 inputPath,
-                modelId: configured.model.id,
+                modelId: modelLabel,
                 seconds: audio.seconds,
               },
             });
@@ -170,7 +171,7 @@ export function registerFileTranscriptionTool(
               : rawTranscript;
             const details: FileTranscriptionDetails = {
               inputPath,
-              modelId: configured.model.id,
+              modelId: modelLabel,
               seconds: audio.seconds,
             };
 

package/src/onboarding.ts

@@ -14,11 +14,13 @@ import {
 } from "./recommendation-picker.js";
 import { CATALOG_MODELS } from "./catalog.js";
 import { recommendModels } from "./recommendations.js";
+import { promptRemoteBackend, warnMissingApiKey } from "./remote-asr.js";
 import { createShortcutPicker } from "./shortcuts.js";
 import { tryVoice } from "./try-it.js";
 import {
   DEFAULT_MICROPHONE,
   settingsForModel,
+  settingsRemoteOnly,
   writeSettings,
   type BackendSettings,
   type ChineseOutput,
@@ -28,6 +30,10 @@ import {
   type TranscriptionLanguage,
 } from "./settings.js";
 import { DEFAULT_SHORTCUT } from "./shortcut-core.js";
+import {
+  SingleSelectPicker,
+  type SingleSelectChoice,
+} from "./ui-components.js";
 
 function requireTui(ctx: ExtensionContext): boolean {
   if (ctx.mode === "tui") return true;
@@ -91,7 +97,7 @@ export async function runModelSelection(
     }),
     (settings) => {
       configured = settings;
-      currentModelId = settings.model.id;
+      currentModelId = settings.model?.id;
     },
   );
 
@@ -213,6 +219,7 @@ export async function changeOnboardingModel(
     () => ({
       shortcut: current.shortcut,
       preferredLanguages: languages,
+      transcriptionLanguage: current.transcriptionLanguage,
       microphone: current.microphone,
       chineseOutput: current.chineseOutput,
       backend: current.backend,
@@ -231,7 +238,7 @@ export async function changeOnboardingModel(
           expanded: true,
           onboardingStep: 3,
         })
-      : await chooseCatalogModel(ctx, languages, chosen?.model.id ?? current.model.id, {
+      : await chooseCatalogModel(ctx, languages, chosen?.model?.id ?? current.model?.id, {
           postActivation: "advance",
           onActivate: activation.activate,
           cancelLabel: "back",
@@ -264,12 +271,60 @@ export async function changeOnboardingModel(
   }
 }
 
+export type SetupMode = "local" | "remote";
+
+/**
+ * First screen of first-run setup: on-device model, or a remote ASR endpoint.
+ * The modes are exclusive: remote setup downloads no local model.
+ */
+async function chooseSetupMode(ctx: ExtensionContext): Promise<SetupMode | undefined> {
+  const choices: SingleSelectChoice<SetupMode>[] = [
+    {
+      value: "local",
+      label: "Local model",
+      description: "Transcribe fully on-device; no audio leaves this machine",
+    },
+    {
+      value: "remote",
+      label: "Remote ASR (OpenAI-compatible)",
+      description:
+        "Send audio to an OpenAI-compatible ASR endpoint; no local model is downloaded",
+    },
+  ];
+  return ctx.ui.custom<SetupMode | undefined>((tui, theme, keybindings, done) =>
+    new SingleSelectPicker(
+      tui,
+      theme,
+      keybindings,
+      choices,
+      undefined,
+      {
+        title: "Pi Voice setup",
+        subtitle: "How should Pi Voice transcribe your speech?",
+        cancelLabel: "cancel",
+        onboardingStep: 1,
+      },
+      done,
+    ),
+  );
+}
+
 export async function runOnboarding(
   ctx: ExtensionContext,
   shortcut = DEFAULT_SHORTCUT,
 ): Promise<TranscribeSettings | undefined> {
   if (!requireTui(ctx)) return undefined;
 
+  const mode = await chooseSetupMode(ctx);
+  if (!mode) return undefined;
+
+  let backend: BackendSettings | undefined;
+  if (mode === "remote") {
+    backend = await promptRemoteBackend(ctx);
+    if (!backend) return undefined;
+    warnMissingApiKey(ctx, backend.apiKeyEnv);
+  }
+
   let languages = defaultSpokenLanguages();
   // Navigation cannot undo a completed settings commit. Keep it across a
   // return to languages, even if the user then exits without another choice.
@@ -277,15 +332,27 @@ export async function runOnboarding(
   while (true) {
     const chosen = await chooseLanguages(ctx, languages, {
       cancelLabel: "exit",
-      onboardingStep: 1,
+      onboardingStep: 2,
     });
     if (!chosen?.confirmed) return configured;
     languages = chosen.languages;
+
+    // Remote mode is remote-only: no model step, settings are complete once
+    // the endpoint and languages are chosen.
+    if (backend?.type === "openai-asr") {
+      const settings = settingsRemoteOnly({ backend, shortcut, preferredLanguages: languages });
+      if (!(await saveOnboardingSettings(ctx, settings))) return configured;
+      configured = settings;
+      return finishOnboarding(ctx, configured, (current) =>
+        changeOnboardingModel(ctx, current),
+      );
+    }
+
     // The picks are judged on the benchmark rig; the Try it step measures
     // the real wait on this machine.
     const picks = recommendModels(CATALOG_MODELS, languages);
     const { activate, waitForCommits } = createSettingsActivation(
-      () => ({ shortcut, preferredLanguages: languages }),
+      () => ({ shortcut, preferredLanguages: languages, backend }),
       (settings) => {
         configured = settings;
       },
@@ -298,7 +365,9 @@ export async function runOnboarding(
         languages,
         picks,
         activate,
-        { onboardingStep: 2 },
+        {
+          onboardingStep: 3,
+        },
       );
       await waitForCommits();
       if (!recommendation) return configured;
@@ -310,11 +379,11 @@ export async function runOnboarding(
         continue;
       }
 
-      const selection = await chooseCatalogModel(ctx, languages, configured?.model.id, {
+      const selection = await chooseCatalogModel(ctx, languages, configured?.model?.id, {
         postActivation: "advance",
         onActivate: activate,
         cancelLabel: "back",
-        onboardingStep: 2,
+        onboardingStep: 3,
         title: "Browse all models",
       });
       await waitForCommits();

package/src/openai-asr.ts

@@ -1,22 +1,15 @@
 import OpenAI from "openai";
 import { CAPTURE_SAMPLE_RATE } from "./audio-constants.js";
-import { convertChineseOutput, isChineseLanguage } from "./chinese.js";
+import { containsChineseCharacters, convertChineseOutput, isChineseLanguage } from "./chinese.js";
 import { describeError, writeLog } from "./log.js";
 import type { BackendSettings, ChineseOutput } from "./settings.js";
 import type {
   DictationStream,
-  TranscribeCppBackend,
   TranscriptionOptions,
 } from "./transcription.js";
 
 type OpenAIAsrSettings = Extract<BackendSettings, { type: "openai-asr" }>;
 
-/** The slice of the local backend this module needs for offline fallback. */
-export type LocalFallback = Pick<
-  TranscribeCppBackend,
-  "prepare" | "transcribe" | "dispose"
->;
-
 export type AsrRequest = {
   /** `data:audio/wav;base64,…` of the whole recording. */
   dataUrl: string;
@@ -122,22 +115,20 @@ function createOpenAITransport(config: OpenAIAsrSettings): {
 /**
  * Trims, then applies the Chinese script preference exactly like the local
  * backend. The chat-completions response carries no detected language, so
- * this mirrors the local `finishTranscript` with detectedLanguage = "" —
- * conversion runs only when the configured language is Chinese.
+ * Chinese is inferred from the text itself: Han characters mean the transcript
+ * is Chinese and the preference applies, matching local models that detect it.
  */
 export async function finishRemoteTranscript(
   text: string,
   options: TranscriptionOptions,
 ): Promise<string> {
   const trimmed = text.trim();
-  return isChineseLanguage(options.language ?? "")
+  return isChineseLanguage(options.language ?? "") || containsChineseCharacters(trimmed)
     ? convertChineseOutput(trimmed, options.chineseOutput ?? "simplified")
     : trimmed;
 }
 
 export type OpenAIAsrBackendDeps = {
-  /** Creates the local model used when a remote call fails. */
-  createFallback?: () => Promise<LocalFallback>;
   /** Overrides the network transport (tests). */
   transport?: AsrTransport;
 };
@@ -145,12 +136,11 @@ export type OpenAIAsrBackendDeps = {
 /**
  * Batch-only remote backend: `startStream` resolves to undefined so the
  * service records the whole clip and transcribes it after stop, exactly like
- * a non-streaming local model. Remote failures fall back to the local model;
- * aborts are never retried locally.
+ * a non-streaming local model. Remote failures surface to the caller; there
+ * is no local fallback.
  */
 export class OpenAIAsrBackend {
   private client: { transport: AsrTransport; dispose: () => void } | undefined;
-  private fallback: Promise<LocalFallback> | undefined;
   private disposed = false;
   private readonly injected: AsrTransport | undefined;
 
@@ -164,8 +154,8 @@ export class OpenAIAsrBackend {
   async prepare(): Promise<void> {
     if (this.disposed) throw new Error("Remote ASR backend has been disposed");
     // The transport is created lazily in transcribe() so that a missing API
-    // key (or any construction failure) falls back to the local model instead
-    // of failing prepare() and blocking every subsequent transcription.
+    // key surfaces per recording instead of failing prepare() and blocking
+    // every subsequent transcription.
   }
 
   /** Batch-only: the dictation service drops live chunks and transcribes on stop. */
@@ -184,9 +174,9 @@ export class OpenAIAsrBackend {
       if (!transport) {
         if (this.disposed) throw new Error("Remote ASR backend has been disposed");
         // Lazily build the transport inside the try so a missing API key or
-        // any construction failure falls back to the local model. Success is
-        // cached; a failure is not, so a later call retries once the env is
-        // fixed.
+        // any construction failure is reported like a request failure.
+        // Success is cached; a failure is not, so a later call retries once
+        // the env is fixed.
         const client = this.client ?? createOpenAITransport(this.config);
         this.client = client;
         transport = client.transport;
@@ -205,20 +195,12 @@ export class OpenAIAsrBackend {
       return await finishRemoteTranscript(text, options);
     } catch (error) {
       if (signal?.aborted || this.disposed) throw error;
-      if (!this.deps.createFallback) throw error;
       writeLog(
         "warn",
         "voice",
-        `remote ASR failed (${describeError(error)}); falling back to the local model`,
+        `remote ASR failed (${describeError(error)})`,
       );
-      try {
-        const local = await this.fallbackBackend();
-        return await local.transcribe(pcm, options);
-      } catch (fallbackError) {
-        throw new Error(
-          `Remote ASR failed (${describeError(error)}) and the local fallback failed (${describeError(fallbackError)})`,
-        );
-      }
+      throw error;
     }
   }
 
@@ -227,21 +209,5 @@ export class OpenAIAsrBackend {
     this.disposed = true;
     this.client?.dispose();
     this.client = undefined;
-    if (this.fallback) {
-      const local = await this.fallback.catch(() => undefined);
-      await local?.dispose().catch(() => undefined);
-    }
-  }
-
-  private fallbackBackend(): Promise<LocalFallback> {
-    if (!this.fallback) {
-      // A rejected fallback is not cached: a later attempt can re-create the
-      // local model instead of re-throwing a stale failure.
-      this.fallback = this.deps.createFallback!().catch((error) => {
-        this.fallback = undefined;
-        throw error;
-      });
-    }
-    return this.fallback;
   }
 }