@moxxy/plugin-telegram 0.41.2 → 0.42.0

package/src/channel/model.test.ts

@@ -0,0 +1,203 @@
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Context } from 'grammy';
+import { Session, autoAllowResolver, silentLogger } from '@moxxy/core';
+import { FakeProvider } from '@moxxy/testing';
+import { defineProvider, definePlugin } from '@moxxy/sdk';
+import { VaultStore, createStaticKeySource, deriveKey, generateSalt } from '@moxxy/plugin-vault';
+
+// A model picked for the bot must never become the desktop's/TUI's model.
+const setCategoryDefault = vi.fn(async () => undefined);
+const setProviderModel = vi.fn(async () => undefined);
+vi.mock('@moxxy/config', () => ({
+  setCategoryDefault: (...a: unknown[]) => setCategoryDefault(...a),
+  setProviderModel: (...a: unknown[]) => setProviderModel(...a),
+}));
+
+import { TELEGRAM_MODEL_KEY } from '../keys.js';
+import { telegramModel } from './model.js';
+import { runSlash } from './slash-handler.js';
+import { handleCallback } from './callback-handler.js';
+import { removeDir } from '@moxxy/vitest-preset/fs';
+
+let tmp: string;
+let vault: VaultStore;
+let session: Session;
+
+function providerDef(name: string, modelIds: ReadonlyArray<string>) {
+  const models = modelIds.map((id) => ({
+    id,
+    contextWindow: 100_000,
+    maxOutputTokens: 4_000,
+    supportsTools: true,
+    supportsStreaming: true,
+  }));
+  const instance = new FakeProvider({ name, models });
+  return defineProvider({ name, models, createClient: () => instance });
+}
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-tg-model-'));
+  vault = new VaultStore({
+    filePath: path.join(tmp, 'vault.json'),
+    keySource: createStaticKeySource(deriveKey('test', generateSalt())),
+  });
+  session = new Session({ cwd: tmp, logger: silentLogger, permissionResolver: autoAllowResolver });
+  session.pluginHost.registerStatic(
+    definePlugin({
+      name: 'telegram-model-test',
+      providers: [providerDef('alpha', ['a-small', 'a-large']), providerDef('beta', ['b-fast'])],
+    }),
+  );
+  session.providers.setActive('alpha');
+  session.readyProviders = new Set(['alpha']);
+  session.credentialResolver = async () => ({});
+  setCategoryDefault.mockClear();
+  setProviderModel.mockClear();
+});
+
+afterEach(async () => {
+  await removeDir(tmp);
+});
+
+interface Keyboard {
+  inline_keyboard: Array<Array<{ text: string; callback_data: string; style?: string }>>;
+}
+
+function chat() {
+  const replies: Array<{ text: string; keyboard?: Keyboard }> = [];
+  const ctx = {
+    reply: async (text: string, extra?: { reply_markup?: Keyboard }) => {
+      replies.push({ text, ...(extra?.reply_markup ? { keyboard: extra.reply_markup } : {}) });
+    },
+  } as unknown as Context;
+  return { ctx, replies };
+}
+
+function slash(text: string) {
+  const { ctx, replies } = chat();
+  const model = telegramModel({ session, vault });
+  return runSlash(
+    ctx,
+    text,
+    { session, voiceReplies: false },
+    {
+      toggleYolo: async () => false,
+      setVoiceReplies: async () => undefined,
+      model,
+      performSessionAction: async () => undefined,
+    },
+  ).then(() => replies);
+}
+
+function tap(data: string) {
+  const edits: Array<{ text: string; keyboard?: Keyboard }> = [];
+  const toasts: string[] = [];
+  const target = { id: 42 };
+  const ctx = {
+    chat: target,
+    callbackQuery: { data, message: { chat: target } },
+    answerCallbackQuery: async (arg?: { text?: string }) => void toasts.push(arg?.text ?? ''),
+    editMessageText: async (text: string, extra?: { reply_markup?: Keyboard }) =>
+      void edits.push({ text, ...(extra?.reply_markup ? { keyboard: extra.reply_markup } : {}) }),
+    editMessageReplyMarkup: async () => true,
+  } as unknown as Context;
+  const model = telegramModel({ session, vault });
+  return handleCallback(
+    ctx,
+    {
+      bot: null,
+      session,
+      chatId: 42,
+      permissionResolver: { resolvePending: vi.fn() } as never,
+      approvalResolver: { getPending: () => undefined, resolvePending: vi.fn() } as never,
+      pairing: { isAuthorized: () => true },
+    },
+    { setAwaitingApprovalText: () => undefined, model },
+  ).then(() => ({ edits, toasts }));
+}
+
+const buttons = (keyboard?: Keyboard) => (keyboard?.inline_keyboard ?? []).flat();
+
+describe('/model on Telegram (the bot keeps a model of its own, like the Discord bot)', () => {
+  it('without an argument offers the providers first, marking the one the bot runs', async () => {
+    await vault.set(TELEGRAM_MODEL_KEY, 'alpha::a-large');
+
+    const [picker] = await slash('/model');
+
+    expect(picker?.text).toContain('alpha::a-large');
+    expect(buttons(picker?.keyboard).map((b) => [b.text, b.callback_data, b.style])).toEqual([
+      ['Default model', 'model:default', undefined],
+      ['✓ alpha · 2 models', 'mprov:alpha', 'success'],
+      ['beta · not connected', 'mprov:beta', undefined],
+    ]);
+  });
+
+  it('marks the default model when the bot has none of its own', async () => {
+    const [picker] = await slash('/model');
+    expect(buttons(picker?.keyboard)[0]).toMatchObject({ text: '✓ Default model', style: 'success' });
+  });
+
+  it("tapping a provider shows its models, the bot's one marked, with a way back", async () => {
+    await vault.set(TELEGRAM_MODEL_KEY, 'alpha::a-large');
+
+    const { edits } = await tap('mprov:alpha');
+
+    expect(edits[0]?.text).toContain('alpha');
+    expect(buttons(edits[0]?.keyboard).map((b) => [b.text, b.callback_data, b.style])).toEqual([
+      ['a-small', 'model:alpha::a-small', undefined],
+      ['✓ a-large', 'model:alpha::a-large', 'success'],
+      ['‹ Providers', 'mprov:', undefined],
+    ]);
+  });
+
+  it('‹ Providers goes back to the providers', async () => {
+    const { edits } = await tap('mprov:');
+    expect(buttons(edits[0]?.keyboard).map((b) => b.callback_data)).toEqual([
+      'model:default',
+      'mprov:alpha',
+      'mprov:beta',
+    ]);
+  });
+
+  it('with an argument switches this bot to the model it names', async () => {
+    const [reply] = await slash('/model a-large');
+
+    expect(reply?.text).toMatch(/✓ switched to alpha::a-large/);
+    expect(await vault.get(TELEGRAM_MODEL_KEY)).toBe('alpha::a-large');
+  });
+
+  it('a tapped model is saved for this bot only — the global default stays', async () => {
+    const { edits } = await tap('model:alpha::a-large');
+
+    expect(edits.map((e) => e.text)).toEqual(['✓ switched to alpha::a-large for this bot.']);
+    expect(await vault.get(TELEGRAM_MODEL_KEY)).toBe('alpha::a-large');
+    expect(setCategoryDefault).not.toHaveBeenCalled();
+    expect(setProviderModel).not.toHaveBeenCalled();
+  });
+
+  it('tapping "default" goes back to the default model', async () => {
+    await vault.set(TELEGRAM_MODEL_KEY, 'alpha::a-large');
+
+    const { edits } = await tap('model:default');
+
+    expect(edits.map((e) => e.text)).toEqual(['✓ back to the default model.']);
+    expect(await vault.get(TELEGRAM_MODEL_KEY)).toBeNull();
+  });
+
+  it('a provider that is not connected is refused and nothing is saved', async () => {
+    const { edits } = await tap('model:beta::b-fast');
+
+    expect(edits[0]?.text).toMatch(/isn't connected/);
+    expect(await vault.get(TELEGRAM_MODEL_KEY)).toBeNull();
+  });
+});
+
+describe('the model for the next turn', () => {
+  it('is the one saved for the bot — also when it was changed from the desktop panel', async () => {
+    await vault.set(TELEGRAM_MODEL_KEY, 'alpha::a-large');
+    expect(await telegramModel({ session, vault }).resolve()).toEqual({ model: 'a-large' });
+  });
+});

package/src/channel/model.ts

@@ -0,0 +1,33 @@
+import {
+  listModelOptions,
+  resolveChannelModel,
+  runModelCommand,
+  savedChannelModel,
+  type ModelChoice,
+  type ModelCommandDeps,
+  type ModelOption,
+} from '@moxxy/channel-kit';
+import { TELEGRAM_MODEL_KEY } from '../keys.js';
+
+/**
+ * The Telegram bot's own model (`telegram_model` in the vault, the key the
+ * desktop panel writes too): `/model` and its buttons switch it, and it is read
+ * before every turn — never the global default the desktop/TUI run with.
+ */
+export interface TelegramModel {
+  /** `/model [name|default]` — switch or reset; returns the reply. */
+  run(arg: string): Promise<string>;
+  /** What the picker shows: the saved choice and every model. */
+  choices(): Promise<{ readonly current: ModelChoice | null; readonly options: ReadonlyArray<ModelOption> }>;
+  /** The model for the next turn, with a warning when the saved one can't be used. */
+  resolve(): Promise<{ readonly model?: string; readonly warning?: string }>;
+}
+
+export function telegramModel(deps: Omit<ModelCommandDeps, 'vaultKey'>): TelegramModel {
+  const scoped: ModelCommandDeps = { ...deps, vaultKey: TELEGRAM_MODEL_KEY };
+  return {
+    run: (arg) => runModelCommand(arg, scoped),
+    choices: async () => ({ current: await savedChannelModel(scoped), options: listModelOptions(deps.session) }),
+    resolve: () => resolveChannelModel(scoped),
+  };
+}

package/src/channel/pairing-handler.test.ts

@@ -0,0 +1,38 @@
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { VaultStore, createStaticKeySource, deriveKey, generateSalt } from '@moxxy/plugin-vault';
+import { TELEGRAM_AUTHORIZED_CHAT_KEY } from '../keys.js';
+import { PairingHandler } from './pairing-handler.js';
+import { removeDir } from '@moxxy/vitest-preset/fs';
+
+let tmp: string;
+let vault: VaultStore;
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-tg-pair-'));
+  vault = new VaultStore({
+    filePath: path.join(tmp, 'vault.json'),
+    keySource: createStaticKeySource(deriveKey('test', generateSalt())),
+  });
+});
+afterEach(async () => {
+  await removeDir(tmp);
+});
+
+describe('PairingHandler.authorizedChatId (where the bot reaches its owner)', () => {
+  it('is the paired chat restored from the vault', async () => {
+    await vault.set(TELEGRAM_AUTHORIZED_CHAT_KEY, '42');
+    const pairing = new PairingHandler({ vault });
+
+    await pairing.loadAuthorized();
+
+    expect(pairing.authorizedChatId()).toBe(42);
+  });
+
+  it('is null while no chat is paired', async () => {
+    const pairing = new PairingHandler({ vault });
+    await pairing.loadAuthorized();
+    expect(pairing.authorizedChatId()).toBeNull();
+  });
+});

package/src/channel/pairing-handler.ts

@@ -66,6 +66,11 @@ export class PairingHandler {
     return this.state.phase;
   }
 
+  /** The paired chat — where the bot reaches its owner — or null while unpaired. */
+  authorizedChatId(): number | null {
+    return this.state.authorizedChatId;
+  }
+
   /**
    * Open a host-issued pairing window and return the code to embed in the
    * `t.me/<bot>?start=<code>` deep link / QR the control surface renders. The

package/src/channel/send-rich.ts

@@ -0,0 +1,36 @@
+import { GrammyError } from 'grammy';
+import { markdownToTelegramHtml } from '../format.js';
+import { splitForTelegram } from '../render.js';
+import { stripHtml } from './html.js';
+
+/** The slice of grammy's `Api` a text message needs (the real client satisfies it). */
+export interface TelegramSender {
+  sendMessage(
+    chatId: number,
+    text: string,
+    opts?: {
+      parse_mode?: 'HTML' | 'MarkdownV2' | 'Markdown';
+      link_preview_options?: { is_disabled: boolean };
+    },
+  ): Promise<unknown>;
+}
+
+const PARSE_ERROR = /can't parse entities|Bad Request: can't parse/i;
+
+/**
+ * Send Markdown with the same rich look as interactive replies (bold, code,
+ * callouts, spoilers), split to Telegram's size cap. A part Telegram can't
+ * parse (rare) goes out as plain text instead. Returns how many messages went out.
+ */
+export async function sendMarkdown(api: TelegramSender, chatId: number, markdown: string): Promise<number> {
+  const parts = splitForTelegram(markdownToTelegramHtml(markdown));
+  for (const part of parts) {
+    try {
+      await api.sendMessage(chatId, part, { parse_mode: 'HTML', link_preview_options: { is_disabled: true } });
+    } catch (err) {
+      if (!(err instanceof GrammyError && PARSE_ERROR.test(err.description ?? ''))) throw err;
+      await api.sendMessage(chatId, stripHtml(part));
+    }
+  }
+  return parts.length;
+}

package/src/channel/slash-handler.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import type { Bot, Context } from 'grammy';
+import { Session, autoAllowResolver, silentLogger } from '@moxxy/core';
+import { publishBotCommands, runSlash, type SlashCallbacks } from './slash-handler.js';
+
+const session = () => new Session({ cwd: '/tmp', logger: silentLogger, permissionResolver: autoAllowResolver });
+
+async function send(text: string, over: Partial<SlashCallbacks> = {}) {
+  const replies: string[] = [];
+  const ctx = { reply: async (t: string) => void replies.push(t) } as unknown as Context;
+  await runSlash(ctx, text, { session: session(), voiceReplies: false }, {
+    toggleYolo: async () => true,
+    setVoiceReplies: async () => undefined,
+    model: { run: async () => '', choices: async () => ({ current: null, options: [] }) },
+    performSessionAction: async () => undefined,
+    ...over,
+  });
+  return replies;
+}
+
+describe('/auto-approve on Telegram', () => {
+  it.each(['/auto-approve', '/auto_approve', '/yolo'])('%s switches the shared auto-approve', async (command) => {
+    let toggled = 0;
+    const replies = await send(command, {
+      toggleYolo: async () => {
+        toggled += 1;
+        return true;
+      },
+    });
+
+    expect(toggled).toBe(1);
+    expect(replies[0]).toMatch(/auto-approve ON/);
+  });
+
+  it('says tool prompts resume when it is switched off', async () => {
+    const replies = await send('/auto-approve', { toggleYolo: async () => false });
+    expect(replies[0]).toMatch(/auto-approve OFF/);
+  });
+});
+
+describe('/call on Telegram', () => {
+  it('explains that Telegram bots cannot call, and offers a voice message instead', async () => {
+    const [reply] = await send('/call');
+    expect(reply).toMatch(/Telegram does not let bots/);
+    expect(reply).toMatch(/voice message/);
+  });
+});
+
+describe('the command menu Telegram shows', () => {
+  it('lists /auto_approve (Telegram command names take no hyphen) and /call, not the /yolo alias', async () => {
+    let published: Array<{ command: string }> = [];
+    const bot = {
+      api: {
+        setMyCommands: async (commands: Array<{ command: string }>) => {
+          published = commands;
+          return true;
+        },
+      },
+    } as unknown as Bot;
+
+    await publishBotCommands(bot, session());
+
+    const names = published.map((c) => c.command);
+    expect(names).toEqual(expect.arrayContaining(['auto_approve', 'call', 'model', 'voice']));
+    expect(names).not.toContain('yolo');
+    expect(names.every((n) => /^[a-z0-9_]{1,32}$/.test(n))).toBe(true);
+  });
+});

package/src/channel/slash-handler.ts

@@ -2,6 +2,8 @@ import { type Bot, type Context, InlineKeyboard } from 'grammy';
 import { assertDefined, isSelectableMode } from '@moxxy/sdk';
 import type { ClientSession as Session } from '@moxxy/sdk';
 import { resolveVoiceToggle } from '@moxxy/channel-kit';
+import { providerScreen } from './model-picker.js';
+import type { TelegramModel } from './model.js';
 
 /**
  * Install guidance shown when enabling `/voice` with no active synthesizer —
@@ -13,18 +15,17 @@ export const VOICE_NO_SYNTH_HINT =
 
 export interface SlashState {
   readonly session: Session | null;
-  readonly model: string | undefined;
-  readonly activeModelOverride: string | null;
-  readonly yolo: boolean;
   /** Whether voice replies are currently enabled (backs `/voice status`). */
   readonly voiceReplies: boolean;
 }
 
 export interface SlashCallbacks {
-  /** Toggle yolo and return its new value (so we can echo the right message). */
-  toggleYolo(): boolean;
+  /** Switch the conversation's shared auto-approve; returns its new value. */
+  toggleYolo(): Promise<boolean>;
   /** Persist + apply the voice-replies preference (backs `/voice on|off`). */
   setVoiceReplies(on: boolean): Promise<void>;
+  /** This bot's own model (`/model`). */
+  readonly model: Pick<TelegramModel, 'run' | 'choices'>;
   /** Apply a `session-action` result emitted from a registered command. */
   performSessionAction(
     ctx: Context,
@@ -33,6 +34,10 @@ export interface SlashCallbacks {
   ): Promise<void>;
 }
 
+/** Telegram bots have no calls; a voice message is the way to talk. */
+export const NO_CALLS_REPLY =
+  'Telegram does not let bots take or place calls. Send me a voice message instead — I will answer with one.';
+
 /**
  * Slash-command dispatcher for the Telegram channel.
  *
@@ -42,7 +47,7 @@ export interface SlashCallbacks {
  * commands without needing a switch case here.
  *
  * Falls through to channel-local cases for Telegram-specific UI
- * (model/loop pickers as inline keyboards, /yolo toggle, /tools and
+ * (model/mode pickers as inline keyboards, /auto-approve, /tools and
  * /skills as text dumps).
  */
 export async function runSlash(
@@ -86,20 +91,26 @@ export async function runSlash(
   // 2) Channel-local cases.
   switch (head) {
     case '/model':
-      await renderModelPicker(ctx, session, state, args);
+      if (args.trim()) await ctx.reply(await cb.model.run(args));
+      else await renderModelPicker(ctx, cb.model);
       return;
     case '/mode':
       await renderModePicker(ctx, session);
       return;
+    case '/auto-approve':
+    case '/auto_approve':
     case '/yolo': {
-      const enabled = cb.toggleYolo();
+      const enabled = await cb.toggleYolo();
       await ctx.reply(
         enabled
-          ? '⚠ yolo mode ON — tool calls auto-approved for the rest of this session'
-          : 'yolo mode OFF — tool prompts will resume',
+          ? '⚠ auto-approve ON — tool calls run without asking for the rest of this session'
+          : 'auto-approve OFF — tool prompts will resume',
       );
       return;
     }
+    case '/call':
+      await ctx.reply(NO_CALLS_REPLY);
+      return;
     case '/voice': {
       const result = resolveVoiceToggle({
         arg: args,
@@ -139,60 +150,11 @@ export async function runSlash(
   }
 }
 
-/** Telegram inline keyboards get unwieldy past this many rows; cap the picker. */
-const MODEL_PICKER_CAP = 30;
-
-async function renderModelPicker(
-  ctx: Context,
-  session: Session,
-  state: SlashState,
-  filter = '',
-): Promise<void> {
-  const providers = session.providers.list();
-  if (providers.length === 0) {
-    await ctx.reply('no providers registered');
-    return;
-  }
-  const keyboard = new InlineKeyboard();
-  const providerName = session.providers.getActiveName() ?? '';
-  const activeModel = state.activeModelOverride ?? state.model ?? '';
-  // Same boot-time readiness set the TUI uses to flag unconfigured
-  // providers — set by `@moxxy/cli` at setup time. Providers that
-  // failed credential resolution get a "(not connected)" suffix
-  // and a tap on them surfaces the right setup command instead of
-  // a no-op switch.
-  const ready = session.readyProviders ?? new Set<string>();
-  // `/model <substring>` narrows the list so a model that sorts past the
-  // keyboard cap is still reachable from chat (the cap below would otherwise
-  // silently hide it with no fallback).
-  const needle = filter.trim().toLowerCase();
-  // Flatten so we can both apply the substring filter and report how many the
-  // cap hides (vs. how many the filter excluded).
-  const all = providers.flatMap((p) =>
-    p.models.map((m) => ({ provider: p.name, model: m.id })),
-  );
-  const matched = needle
-    ? all.filter((e) => `${e.provider}::${e.model}`.toLowerCase().includes(needle))
-    : all;
-  if (matched.length === 0) {
-    await ctx.reply(`no model matches "${filter.trim()}" — try /model with no argument.`);
-    return;
-  }
-  const shown = matched.slice(0, MODEL_PICKER_CAP);
-  for (const e of shown) {
-    const isCurrent = providerName === e.provider && activeModel === e.model;
-    const connected = ready.has(e.provider);
-    const label =
-      `${isCurrent ? '• ' : ''}${e.provider}: ${e.model}` +
-      (connected ? '' : ' (not connected)');
-    keyboard.text(label, `model:${e.provider}::${e.model}`).row();
-  }
-  const hidden = matched.length - shown.length;
-  const prompt =
-    hidden > 0
-      ? `Pick a model (${hidden} more not shown — narrow with /model <text>):`
-      : 'Pick a model:';
-  await ctx.reply(prompt, { reply_markup: keyboard });
+/** `/model` without an argument: the providers first (see model-picker). */
+async function renderModelPicker(ctx: Context, model: Pick<TelegramModel, 'choices'>): Promise<void> {
+  const { current, options } = await model.choices();
+  const screen = providerScreen(current, options);
+  await ctx.reply(screen.text, { parse_mode: 'HTML', reply_markup: screen.keyboard });
 }
 
 async function renderModePicker(ctx: Context, session: Session): Promise<void> {
@@ -218,6 +180,9 @@ async function renderModePicker(ctx: Context, session: Session): Promise<void> {
   await ctx.reply('Pick a mode:', { reply_markup: keyboard });
 }
 
+/** Telegram's bot-command name constraint (no hyphens). */
+const BOT_COMMAND_RE = /^[a-z0-9_]{1,32}$/;
+
 /**
  * Push the union of registry commands + Telegram-local commands to
  * Telegram so they appear in the chat's command menu (the "/" picker
@@ -231,9 +196,10 @@ export async function publishBotCommands(
 ): Promise<void> {
   if (!session || !bot) return;
   const LOCAL: Array<{ command: string; description: string }> = [
-    { command: 'model', description: 'Switch provider + model (inline keyboard)' },
+    { command: 'model', description: 'Show or switch the model this bot uses' },
     { command: 'mode', description: 'Switch mode' },
-    { command: 'yolo', description: 'Toggle auto-approve mode' },
+    { command: 'auto_approve', description: 'Toggle auto-approve: tool calls run without asking' },
+    { command: 'call', description: 'Talk by voice (Telegram bots cannot call — send a voice message)' },
     { command: 'voice', description: 'Toggle spoken voice replies' },
     { command: 'tools', description: 'List the tools the active session can call' },
     { command: 'skills', description: 'List the discovered skills' },
@@ -244,6 +210,9 @@ export async function publishBotCommands(
     .map((c) => ({ command: c.name, description: c.description }));
   const seen = new Set(shared.map((c) => c.command));
   const merged = [...shared, ...LOCAL.filter((c) => !seen.has(c.command))]
+    // Telegram rejects the whole list over one name outside [a-z0-9_]; such
+    // commands still work typed out.
+    .filter((c) => BOT_COMMAND_RE.test(c.command))
     .sort((a, b) => a.command.localeCompare(b.command))
     // Telegram caps descriptions at 256 chars and rejects empties.
     .map((c) => ({

package/src/channel/text-handler.test.ts

@@ -57,9 +57,7 @@ const makeHarness = (over: Partial<TextHandlerState> = {}): Harness => {
   const setAwaitingApprovalText = vi.fn();
   const state: TextHandlerState = {
     session: makeSession(),
-    model: undefined,
-    activeModelOverride: null,
-    yolo: false,
+    voiceReplies: false,
     busy: false,
     turnController: null,
     awaitingApprovalText: null,
@@ -78,8 +76,10 @@ const makeHarness = (over: Partial<TextHandlerState> = {}): Harness => {
   const tryHostPair = vi.fn(async () => false);
   const cb: TextHandlerCallbacks = {
     setAwaitingApprovalText,
-    toggleYolo: () => false,
+    toggleYolo: async () => false,
     setYolo: () => undefined,
+    setVoiceReplies: async () => undefined,
+    model: { run: async () => '', choices: async () => ({ current: null, options: [] }) },
     runUserTurn,
     tryHostPair,
   };
@@ -216,7 +216,8 @@ describe('handleTextMessage — /exit teardown', () => {
     const { ctx, replies } = fakeCtx({ text: '/exit' });
     const h = makeHarness({ session, handle });
     await handleTextMessage(ctx, h.state, h.deps, h.cb);
-    expect(stop).toHaveBeenCalledTimes(1);
+    // The reply goes out first; the channel stops right after it.
     expect(replies.some((r) => /bye/i.test(r))).toBe(true);
+    await vi.waitFor(() => expect(stop).toHaveBeenCalledTimes(1));
   });
 });