@agentprojectcontext/apx 1.42.1 → 1.43.0

package/src/host/daemon/plugins/telegram/index.js

@@ -28,22 +28,14 @@
 //   }
 
 // This poller is intentionally thin: per-update logic lives in core/channels/
-// telegram/ (dispatch + reply + ask + inbound). It keeps only what the *running
-// process* needs — lifecycle, the poll loop, offset state and the inline-keyboard
-// callbacks. The earlier dispatch extraction left a pile of now-dead imports
-// here; only what's actually referenced below remains.
-import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "#core/stores/messages.js";
+// telegram/ — dispatch (inbound routing), reply (the super-agent turn),
+// ask-callbacks (the ask_questions flow), inbound/ (media), and the raw Bot API
+// in api.js + media.js. The poller keeps only what the *running process* needs:
+// lifecycle, the poll loop, offset state, and the thin I/O surface (self._send
+// etc.) that the extracted core logic calls back into through `self`.
+import { appendGlobalMessage } from "#core/stores/messages.js";
 import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
-import { getConfirmationStore as getConfirmStore } from "#core/confirmation/pending-store.js";
 import { CHANNELS } from "#core/constants/channels.js";
-import { createTelegramConfirmAdapter } from "#core/confirmation/adapters/telegram.js";
-import * as askFlow from "#core/channels/telegram/ask.js";
-
-// API_BASE re-imported from #core/channels/telegram/media.js below
-const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-
-// All non-class-bound channel logic lives in core/channels/telegram/ — this
-// file stays focused on the poller class + plugin lifecycle wiring.
 import {
   loadState,
   saveState,
@@ -54,12 +46,13 @@ import {
   sleep,
 } from "#core/channels/telegram/helpers.js";
 import { handleUpdate } from "#core/channels/telegram/dispatch.js";
-import { buildStreamHandler, runTelegramSuperAgent, telegramErrorText, sendFinalReply } from "#core/channels/telegram/reply.js";
-
-// ---------- media sending helpers (re-exports) ------------------------------
-import { sendPhoto, sendVoice, sendDocument, sendAudio, API_BASE } from "#core/channels/telegram/media.js";
+import { handleCallbackQuery, startAskFlow, maybeConsumeAskTextAnswer } from "#core/channels/telegram/ask-callbacks.js";
+import { sendMessage, sendChatAction, editMessageReplyMarkup, answerCallbackQuery, getUpdates } from "#core/channels/telegram/api.js";
+import { sendPhoto, sendVoice, sendDocument, sendAudio } from "#core/channels/telegram/media.js";
 export { sendPhoto, sendVoice, sendDocument, sendAudio };
 
+const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+
 // ---------- per-channel poller ----------------------------------------------
 
 class ChannelPoller {
@@ -157,13 +150,7 @@ class ChannelPoller {
   }
 
   async _getUpdates() {
-    const token = resolveBotToken(this.channel);
-    const url = `${API_BASE}/bot${token}/getUpdates?timeout=25&offset=${this.offset}`;
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`getUpdates ${res.status}`);
-    const json = await res.json();
-    if (!json.ok) throw new Error(json.description || "telegram error");
-    return json.result || [];
+    return getUpdates(resolveBotToken(this.channel), { offset: this.offset });
   }
 
   // Method body lives in ./dispatch.js as `handleUpdate(self, u)` so this file
@@ -173,270 +160,42 @@ class ChannelPoller {
     return handleUpdate(this, u);
   }
 
+  // ── ask_questions flow ──────────────────────────────────────────────────
+  // Orchestration lives in ./ask-callbacks.js (state machine in ./ask.js). These
+  // are thin delegates: dispatch.js reaches _startAskFlow / _maybeConsumeAsk...
+  // through `self`, and inbound callback_query routes through _handleCallbackQuery.
+  // The core functions call back into this poller's I/O surface (_send etc.).
   async _handleCallbackQuery(callbackQuery) {
-    // Route ask_questions button presses before the confirmation adapter —
-    // both use `apx:<verb>:...` namespacing but ask owns its own state.
-    const data = callbackQuery.data || "";
-    if (data.startsWith("apx:ask:")) {
-      await this._handleAskCallback(callbackQuery);
-      return;
-    }
-
-    const adapter = createTelegramConfirmAdapter({
-      token: resolveBotToken(this.channel),
-      chatId: callbackQuery.message?.chat?.id,
-      pendingStore: getConfirmStore(),
-    });
-    const handled = await adapter.handleCallbackQuery(callbackQuery);
-    if (!handled) {
-      this.log(`telegram[${this.channel.name}] unhandled callback_query: ${callbackQuery.data}`);
-    }
-  }
-
-  // ── ask_questions: state-machine helpers ───────────────────────────────
-  // The flow lives in telegram-ask.js; this class owns the I/O (sending
-  // messages, editing keyboards, re-entering the super-agent loop with the
-  // compiled answer once the flow finishes).
-
-  async _renderQuestion(state) {
-    const text = askFlow.formatQuestionText(state);
-    const reply_markup = askFlow.buildKeyboard(state);
-    // If we already have a message for the previous question, leave its
-    // keyboard wiped — we draw a fresh message per question for clearer
-    // history in the chat (the question text stays as a record).
-    if (state.messageId) {
-      try {
-        await this._editKeyboard({
-          chat_id: state.chatId,
-          message_id: state.messageId,
-          reply_markup: { inline_keyboard: [] },
-        });
-      } catch { /* best-effort */ }
-    }
-    const sent = await this._send({
-      chat_id: state.chatId,
-      text,
-      reply_markup,
-      parse_mode: "Markdown",
-    });
-    state.messageId = sent?.message_id || null;
-    askFlow.saveState(state.chatId, state);
+    return handleCallbackQuery(this, callbackQuery);
   }
 
-  // Kick off a brand-new ask flow after the super-agent called ask_questions.
-  // The flow's `resume` callback captures the per-turn context (sender,
-  // relationship, project) so when the compiled answer arrives we can run
-  // another super-agent turn without retyping all the inputs.
   async _startAskFlow(ctx) {
-    const state = askFlow.startFlow({
-      chatId: ctx.chat_id,
-      projectId: ctx.projectId,
-      authorId: ctx.authorId,
-      questions: ctx.questions,
-      resume: async (compiled) => {
-        await this._runResumedTurn({ ...ctx, compiled });
-      },
-    });
-    await this._renderQuestion(state);
+    return startAskFlow(this, ctx);
   }
 
-  // Apply an inline-keyboard press, then react: redraw, advance, or finish.
-  async _handleAskCallback(callbackQuery) {
-    const chatId = callbackQuery.message?.chat?.id;
-    if (!chatId) return;
-    const result = askFlow.applyCallback(chatId, callbackQuery.data || "");
-    // Ack the press regardless — keeps the spinner from hanging client-side.
-    await this._answerCallback({ callback_query_id: callbackQuery.id });
-    if (!result) return; // stale or unknown — adapter already ack'd.
-
-    if (result.action === "redraw") {
-      // Multi-select toggle: just refresh the keyboard on the SAME message.
-      try {
-        await this._editKeyboard({
-          chat_id: chatId,
-          message_id: callbackQuery.message?.message_id,
-          reply_markup: askFlow.buildKeyboard(result.state),
-        });
-      } catch (e) {
-        this.log(`telegram[${this.channel.name}] redraw failed: ${e.message}`);
-      }
-      return;
-    }
-    if (result.action === "advance") {
-      await this._renderQuestion(result.state);
-      return;
-    }
-    if (result.action === "cancel") {
-      try {
-        await this._editKeyboard({
-          chat_id: chatId,
-          message_id: callbackQuery.message?.message_id,
-          reply_markup: { inline_keyboard: [] },
-        });
-        await this._send({ chat_id: chatId, text: "Pregunta cancelada." });
-      } catch { /* best-effort */ }
-      return;
-    }
-    if (result.action === "done") {
-      try {
-        await this._editKeyboard({
-          chat_id: chatId,
-          message_id: callbackQuery.message?.message_id,
-          reply_markup: { inline_keyboard: [] },
-        });
-      } catch { /* best-effort */ }
-      // Feed the compiled answer back as a synthetic user turn.
-      if (typeof result.state.resume === "function") {
-        await result.state.resume(result.compiled);
-      }
-    }
-  }
-
-  // Apply a free-text user reply when there's a pending free-text question.
-  // Returns true iff the message was consumed by the ask flow (so the normal
-  // super-agent path should be skipped for this update).
-  async _maybeConsumeAskTextAnswer({ chat_id, text }) {
-    if (!chat_id || !text) return false;
-    if (!askFlow.hasPendingFreeText(chat_id)) return false;
-    const state = askFlow.applyTextAnswer(chat_id, text);
-    if (!state) return false;
-    // Advance: emit a synthetic "next" to move past this question.
-    const next = askFlow.applyCallback(
-      chat_id,
-      `apx:ask:${state.correlationId}:next`,
-    );
-    if (!next) return true;
-    if (next.action === "advance") {
-      await this._renderQuestion(next.state);
-      return true;
-    }
-    if (next.action === "done") {
-      if (typeof next.state.resume === "function") {
-        await next.state.resume(next.compiled);
-      }
-      return true;
-    }
-    return true;
+  async _maybeConsumeAskTextAnswer(args) {
+    return maybeConsumeAskTextAnswer(this, args);
   }
 
-  // Run a follow-up super-agent turn with the compiled answers as the user
-  // prompt. Shares the exact reply path as a normal inbound turn (core/channels/
-  // telegram/reply.js) — only the photo/audio/reset preamble is skipped.
-  // Re-enters the ask flow if the model decides to ask again.
-  async _runResumedTurn(ctx) {
-    const { chat_id, compiled, target, relationshipBlock, allowedTools, author, agentDisplay, update_id, sender, authorId } = ctx;
-    if (!chat_id) return;
-    // Log the synthetic user message so getRecentTelegramTurnsFromFs picks
-    // it up on the NEXT inbound. Mirrors how a normal text reply would be
-    // recorded.
-    appendGlobalMessage({
-      channel: CHANNELS.TELEGRAM,
-      direction: "in",
-      type: "user",
-      actor_id: authorId ? String(authorId) : (author || "ask_flow"),
-      external_id: `ask-${Date.now()}`,
-      author: author || "user",
-      body: compiled,
-      meta: {
-        chat_id,
-        user_id: authorId || null,
-        tg_channel: this.channel.name,
-        ask_flow: true,
-      },
-    });
-
-    const previousMessages = getRecentTelegramTurnsFromFs({
-      chat_id,
-      keepRecent: 40,
-      max_age_hours: 24,
-    });
-
-    // Drive the resume through the SAME shared reply path as a normal inbound
-    // turn (see core/channels/telegram/reply.js): streaming, the autonomy budget
-    // (maxIters), the never-silent floor, localized errors and rich channelMeta.
-    // This used to be a hand-rolled copy that silently lagged behind the main
-    // path — now there's one source of truth.
-    const { onEvent, state } = buildStreamHandler(this, { chat_id, update_id, agentDisplay });
-    const stopTyping = this._startTyping(chat_id);
-    let replyText;
-    let replyAuthor;
-    let saUsage = null;
-    try {
-      const sa = await runTelegramSuperAgent(this, {
-        chat_id,
-        prompt: compiled,
-        previousMessages,
-        target,
-        author,
-        relationshipBlock,
-        allowedTools,
-        onEvent,
-      });
-
-      // Did the model ask again? Restart the flow instead of replying.
-      const followupAsk = askFlow.extractAskQuestionsFromTrace(sa.trace);
-      if (followupAsk) {
-        stopTyping();
-        await this._startAskFlow({
-          chat_id,
-          projectId: target?.id,
-          authorId,
-          questions: followupAsk,
-          author,
-          agentDisplay,
-          relationshipBlock,
-          allowedTools,
-          target,
-          sender,
-          update_id,
-        });
-        return;
-      }
-      replyText = sa.text;
-      replyAuthor = sa.name || agentDisplay;
-      saUsage = sa.usage;
-    } catch (e) {
-      this.log(`telegram[${this.channel.name}] ask resume failed: ${e.message}`);
-      replyText = telegramErrorText(this, e);
-      replyAuthor = agentDisplay;
-    }
-
-    stopTyping();
-    await sendFinalReply(this, {
-      chat_id,
-      update_id,
-      replyText,
-      replyAuthor,
-      replyActorId: SUPERAGENT_ACTOR_ID,
-      replyKind: "superagent",
-      saUsage,
-      streamedCount: state.streamedCount,
-      lastStreamedText: state.lastStreamedText,
-      agentDisplay,
-      extraMeta: { ask_resume: true },
-    });
+  // Resolve the bot token + outbound chat for this channel — the single place
+  // the "no token / no chat" guards live, shared by every send method.
+  _resolve(chat_id) {
+    const token = resolveBotToken(this.channel);
+    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
+    const target = chat_id || resolveChatId(this.channel);
+    if (!target) throw new Error(`channel ${this.channel.name}: no chat_id`);
+    return { token, target };
   }
 
-  // Show "typing..." indicator in the chat. Telegram clears it automatically
-  // after 5 seconds, so call this every ~4s while a long operation is going.
+  // Show "typing..." indicator. Telegram clears it after ~5s; _startTyping
+  // re-pings every 4s. Best-effort — failures aren't worth surfacing.
   async _typing(chat_id) {
-    try {
-      const token = resolveBotToken(this.channel);
-      if (!token || !chat_id) return;
-      const url = `${API_BASE}/bot${token}/sendChatAction`;
-      await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ chat_id, action: "typing" }),
-      });
-    } catch {
-      // best-effort; failures here aren't worth surfacing
-    }
+    const token = resolveBotToken(this.channel);
+    if (!token || !chat_id) return;
+    try { await sendChatAction(token, chat_id); } catch { /* best-effort */ }
   }
 
-  // Returns a function that pings sendChatAction every 4s until called as
-  // stop(). Used to wrap the engine round-trip in a "typing" loop so the
-  // user sees feedback while qwen thinks.
+  // Returns a stop() fn; pings the typing indicator every 4s until called.
   _startTyping(chat_id) {
     if (!chat_id) return () => {};
     let stopped = false;
@@ -450,58 +209,27 @@ class ChannelPoller {
   }
 
   async _send({ chat_id, text, reply_markup, parse_mode }) {
-    const token = resolveBotToken(this.channel);
-    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
-    const target = chat_id || resolveChatId(this.channel);
-    if (!target) throw new Error(`channel ${this.channel.name}: no chat_id`);
-    const url = `${API_BASE}/bot${token}/sendMessage`;
-    const body = { chat_id: target, text };
-    if (reply_markup) body.reply_markup = reply_markup;
-    if (parse_mode) body.parse_mode = parse_mode;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (!json.ok) throw new Error(json.description || `send failed (${res.status})`);
-    return json.result;
+    const { token, target } = this._resolve(chat_id);
+    return sendMessage(token, target, { text, reply_markup, parse_mode });
   }
 
-  // Replace just the inline keyboard on a previously-sent message (used to
-  // refresh after a multi-select toggle, or to wipe buttons once the flow
-  // has moved on). Best-effort: failures are logged but don't break the flow.
+  // Replace/clear the inline keyboard on a sent message. Best-effort: logged.
   async _editKeyboard({ chat_id, message_id, reply_markup }) {
     const token = resolveBotToken(this.channel);
     if (!token) return;
     try {
-      const url = `${API_BASE}/bot${token}/editMessageReplyMarkup`;
-      const body = { chat_id, message_id };
-      if (reply_markup) body.reply_markup = reply_markup;
-      await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(body),
-      });
+      await editMessageReplyMarkup(token, chat_id, message_id, reply_markup);
     } catch (e) {
       this.log(`telegram[${this.channel.name}] editMessageReplyMarkup failed: ${e.message}`);
     }
   }
 
-  // Acknowledge a callback button press so the user's Telegram client clears
-  // the spinner on the tapped button. Optional `text` shows a small toast.
+  // Ack a callback button press so the client clears the spinner (+ optional toast).
   async _answerCallback({ callback_query_id, text }) {
     const token = resolveBotToken(this.channel);
     if (!token) return;
     try {
-      const url = `${API_BASE}/bot${token}/answerCallbackQuery`;
-      const body = { callback_query_id };
-      if (text) body.text = text;
-      await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(body),
-      });
+      await answerCallbackQuery(token, callback_query_id, text);
     } catch (e) {
       this.log(`telegram[${this.channel.name}] answerCallbackQuery failed: ${e.message}`);
     }
@@ -509,40 +237,42 @@ class ChannelPoller {
 
   /** Send a photo via this channel */
   async _sendPhoto({ chat_id, photo, caption, parse_mode }) {
-    const token = resolveBotToken(this.channel);
-    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
-    const target = chat_id || resolveChatId(this.channel);
-    if (!target) throw new Error(`channel ${this.channel.name}: no chat_id`);
+    const { token, target } = this._resolve(chat_id);
     return sendPhoto(token, target, photo, { caption, parse_mode });
   }
 
   /** Send a voice message via this channel */
   async _sendVoice({ chat_id, audio, caption, duration }) {
-    const token = resolveBotToken(this.channel);
-    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
-    const target = chat_id || resolveChatId(this.channel);
+    const { token, target } = this._resolve(chat_id);
     return sendVoice(token, target, audio, { caption, duration });
   }
 
   /** Send a document (PDF, zip, etc) via this channel */
   async _sendDocument({ chat_id, document, caption, filename, mime_type }) {
-    const token = resolveBotToken(this.channel);
-    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
-    const target = chat_id || resolveChatId(this.channel);
+    const { token, target } = this._resolve(chat_id);
     return sendDocument(token, target, document, { caption, filename, mime_type });
   }
 
   /** Send an audio file via this channel */
   async _sendAudio({ chat_id, audio, caption, title, performer }) {
-    const token = resolveBotToken(this.channel);
-    if (!token) throw new Error(`channel ${this.channel.name}: no bot_token`);
-    const target = chat_id || resolveChatId(this.channel);
+    const { token, target } = this._resolve(chat_id);
     return sendAudio(token, target, audio, { caption, title, performer });
   }
 }
 
 // ---------- plugin export ---------------------------------------------------
 
+// Pick the poller to send through: the named channel if given, else the first
+// channel with a usable bot token. Shared by every outbound helper below.
+function pickPoller(pollers, channelName) {
+  const p =
+    (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
+    pollers.find((pp) => resolveBotToken(pp.channel)) ||
+    null;
+  if (!p) throw new Error("no telegram channel available");
+  return p;
+}
+
 export default {
   id: "telegram",
 
@@ -582,11 +312,7 @@ export default {
       // the outbound on `messages` of the channel's target project so audit
       // trails are complete.
       async send({ channel: channelName, chat_id, text, author = resolveAgentName(config), project }) {
-        const p =
-          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
-          pollers.find((pp) => resolveBotToken(pp.channel)) ||
-          null;
-        if (!p) throw new Error("no telegram channel available");
+        const p = pickPoller(pollers, channelName);
         const result = await p._send({ chat_id, text });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
@@ -612,11 +338,7 @@ export default {
        * opts: { caption, parse_mode, channel, author }
        */
       async sendPhoto({ channel: channelName, chat_id, photo, caption, parse_mode, author = resolveAgentName(config) }) {
-        const p =
-          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
-          pollers.find((pp) => resolveBotToken(pp.channel)) ||
-          null;
-        if (!p) throw new Error("no telegram channel available");
+        const p = pickPoller(pollers, channelName);
         const result = await p._sendPhoto({ chat_id, photo, caption, parse_mode });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
@@ -636,11 +358,7 @@ export default {
        * audio: local file path or Buffer
        */
       async sendVoice({ channel: channelName, chat_id, audio, caption, duration, author = resolveAgentName(config) }) {
-        const p =
-          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
-          pollers.find((pp) => resolveBotToken(pp.channel)) ||
-          null;
-        if (!p) throw new Error("no telegram channel available");
+        const p = pickPoller(pollers, channelName);
         const result = await p._sendVoice({ chat_id, audio, caption, duration });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
@@ -660,11 +378,7 @@ export default {
        * document: local file path, Buffer, or public https URL.
        */
       async sendDocument({ channel: channelName, chat_id, document, caption, filename, mime_type, author = resolveAgentName(config) }) {
-        const p =
-          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
-          pollers.find((pp) => resolveBotToken(pp.channel)) ||
-          null;
-        if (!p) throw new Error("no telegram channel available");
+        const p = pickPoller(pollers, channelName);
         const result = await p._sendDocument({ chat_id, document, caption, filename, mime_type });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
@@ -684,11 +398,7 @@ export default {
        * audio: local file path or Buffer
        */
       async sendAudio({ channel: channelName, chat_id, audio, caption, title, performer, author = resolveAgentName(config) }) {
-        const p =
-          (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
-          pollers.find((pp) => resolveBotToken(pp.channel)) ||
-          null;
-        if (!p) throw new Error("no telegram channel available");
+        const p = pickPoller(pollers, channelName);
         const result = await p._sendAudio({ chat_id, audio, caption, title, performer });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,

package/src/host/daemon/whisper-server.js

@@ -23,6 +23,7 @@ const WHISPER_SERVER = path.join(__dirname, "whisper-server.py");
 
 let _serverProcess = null;
 let _serverModel = null;
+let _serverBackend = null;   // "faster" | "mlx" — restart when this changes too
 
 function _sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -39,14 +40,14 @@ async function _isServerHealthy() {
   }
 }
 
-async function _serverModelName() {
+async function _serverHealthInfo() {
   try {
     const res = await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/health`, {
       signal: AbortSignal.timeout(800),
     });
     if (!res.ok) return null;
     const j = await res.json();
-    return j?.model || null;
+    return { model: j?.model || null, backend: j?.backend || "faster" };
   } catch {
     return null;
   }
@@ -82,17 +83,20 @@ async function _killOrphanWhisper() {
 
 export async function ensureWhisperServer(opts) {
   const model = opts.model || DEFAULT_LOCAL.model;
+  const backend = opts.backend || "faster";
 
-  if (_serverProcess && _serverModel === model) {
+  if (_serverProcess && _serverModel === model && _serverBackend === backend) {
     if (await _isServerHealthy()) return;
     _serverProcess = null;
     _serverModel = null;
+    _serverBackend = null;
   }
 
   if (!_serverProcess) {
-    const existing = await _serverModelName();
-    if (existing === model) {
+    const existing = await _serverHealthInfo();
+    if (existing && existing.model === model && existing.backend === backend) {
       _serverModel = model;
+      _serverBackend = backend;
       return;
     }
     if (existing) {
@@ -104,16 +108,18 @@ export async function ensureWhisperServer(opts) {
     try { _serverProcess.kill(); } catch {}
     _serverProcess = null;
     _serverModel = null;
+    _serverBackend = null;
     await _sleep(300);
   }
 
-  await _spawnWhisper(opts, model, /* retried */ false);
+  await _spawnWhisper(opts, model, backend, /* retried */ false);
 }
 
-async function _spawnWhisper(opts, model, retried) {
+async function _spawnWhisper(opts, model, backend, retried) {
   const args = [
     WHISPER_SERVER,
     "--port", String(WHISPER_LOCAL_PORT),
+    "--backend", String(backend || "faster"),
     "--model", model,
     "--device", String(opts.device || DEFAULT_LOCAL.device),
     "--compute-type", String(opts.compute_type || DEFAULT_LOCAL.compute_type),
@@ -127,11 +133,13 @@ async function _spawnWhisper(opts, model, retried) {
 
   _serverProcess = proc;
   _serverModel = model;
+  _serverBackend = backend;
 
   proc.on("exit", () => {
     if (_serverProcess === proc) {
       _serverProcess = null;
       _serverModel = null;
+      _serverBackend = null;
     }
   });
 
@@ -167,8 +175,9 @@ async function _spawnWhisper(opts, model, retried) {
     if (!retried && /address already in use|errno 48|eaddrinuse/i.test(msg)) {
       _serverProcess = null;
       _serverModel = null;
+      _serverBackend = null;
       await _killOrphanWhisper();
-      return _spawnWhisper(opts, model, /* retried */ true);
+      return _spawnWhisper(opts, model, backend, /* retried */ true);
     }
     throw e;
   }
@@ -210,6 +219,7 @@ export async function shutdownWhisperServer() {
     try { _serverProcess.kill(); } catch {}
     _serverProcess = null;
     _serverModel = null;
+    _serverBackend = null;
   } else {
     try {
       await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/shutdown`, {