openmausbot 0.1.91 → 0.1.93

package/dist-server/server/store.js

@@ -442,6 +442,10 @@ export function roomResponders(text, members, defaultResponder) {
     }
     return [];
 }
+/** A hidden routine execution is not a conversation the person can open. */
+function taskCountsAsBotUnread(task) {
+    return Boolean(task.unread) && !task.routineRunId;
+}
 export class Store {
     bots = [];
     groups = [];
@@ -463,8 +467,13 @@ export class Store {
         mkdirSync(DATA_DIR, { recursive: true });
         for (const file of [BOTS_FILE, GROUPS_FILE])
             tightenRegistryFile(file);
+        // Whether the bot list is the real one. Room repair below trusts it to
+        // say which members no longer exist; an unreadable file must never read
+        // as "every member was deleted".
+        let botsLoaded = false;
         try {
             this.bots = JSON.parse(readFileSync(BOTS_FILE, "utf8"));
+            botsLoaded = Array.isArray(this.bots);
         }
         catch {
             this.bots = [];
@@ -633,9 +642,17 @@ export class Store {
                 botsMigrated = true;
             }
         }
+        const botIds = new Set(this.bots.map((b) => b.id));
         for (const g of this.groups) {
             g.busyBotId = null;
             delete g.turnStartedAt;
+            // A deleted bot used to stay a member for good: counted on the room's
+            // Save button and refused by the roster check on every save (MOCA-264).
+            // Bot-to-bot channels keep their pair; they are not edited as rooms.
+            if (botsLoaded && !g.dm && g.memberIds.some((id) => !botIds.has(id))) {
+                g.memberIds = g.memberIds.filter((id) => botIds.has(id));
+                groupsMigrated = true;
+            }
             const normalized = normalizeGroupDefaultResponder(g.defaultResponder, g.memberIds, Boolean(g.dm));
             if (JSON.stringify(normalized) !== JSON.stringify(g.defaultResponder))
                 groupsMigrated = true;
@@ -721,6 +738,13 @@ export class Store {
                     task.unread = task === active && b.unread;
                     botsMigrated = true;
                 }
+                // Older builds left a failed hidden run unread, which kept the bot
+                // dot on after every visible chat was read. Clear it before the
+                // recompute below so the saved roster heals.
+                if (task.routineRunId && task.unread) {
+                    task.unread = false;
+                    botsMigrated = true;
+                }
                 if (task === active) {
                     if (task.rewound === undefined && b.rewound !== undefined) {
                         task.rewound = b.rewound;
@@ -742,7 +766,7 @@ export class Store {
                 task.turnStartedAt = undefined;
             }
             this.mirrorActiveTask(b, active);
-            b.unread = b.tasks.some((task) => task.unread);
+            b.unread = b.tasks.some(taskCountsAsBotUnread);
         }
         if (botsMigrated)
             this.saveBots();
@@ -819,13 +843,20 @@ export class Store {
         if (groupsDirty)
             this.saveGroups();
     }
+    /** Resolve the identity of a historical pair row, including a sender
+     * recreated with the same unique name. */
+    openerIdentity(openedBy) {
+        if (this.bot(openedBy.botId))
+            return openedBy.botId;
+        const named = this.bots.filter((bot) => bot.name === openedBy.name);
+        return named.length === 1 ? named[0].id : openedBy.botId;
+    }
     /** At most one live pair row per (recipient, sender identity). Servers
      * before identity-stable matching minted a second live pair row for a
      * deleted-and-recreated sender while the predecessor's row dangled live
-     * forever; collapse those on load by keeping the row the resolver favors
-     * (first in the task list — the newest, actively used one) and demoting
-     * the rest to closed plain threads. History is kept, never deleted, and
-     * a demoted row is never re-adopted: adoption skips closed rows. Runs on
+     * forever; collapse those on load by keeping the first row in the task
+     * list (the newest, actively used one) and demoting
+     * the rest to closed plain threads. History is kept, never deleted. Runs on
      * every load and touches nothing in a store that already holds the
      * invariant. */
     repairDuplicatePairConversations() {
@@ -840,8 +871,7 @@ export class Store {
                 pairs.set(identity, [...(pairs.get(identity) ?? []), task]);
             }
             for (const rows of pairs.values()) {
-                // rows are in task-list order, the same order the resolver's
-                // find() favors: the first is the one it keeps using.
+                // Rows are in task-list order; keep the newest.
                 for (const duplicate of rows.slice(1)) {
                     const by = duplicate.openedBy;
                     const identity = this.openerIdentity(by);
@@ -856,8 +886,7 @@ export class Store {
                 }
             }
         };
-        // Pair rows only ever live on bots: the resolver requires a bot
-        // recipient, and group tasks carry no peer stamps.
+        // Historical pair rows lived only on bots; group tasks have no peer stamps.
         for (const bot of this.bots)
             sweep(bot.tasks, () => { botsDirty = true; });
         if (botsDirty)
@@ -1748,6 +1777,27 @@ export class Store {
         this.saveBots(nextBots);
         this.bots = nextBots;
         this.legacyActivities.delete(id);
+        // A deleted bot leaves every room it was in, and a room it led falls back
+        // to its next member. Bot-to-bot channels keep their pair.
+        const rooms = this.groups.filter((g) => !g.dm && g.memberIds.includes(id));
+        for (const g of rooms) {
+            g.memberIds = g.memberIds.filter((member) => member !== id);
+            if (g.busyBotId === id) {
+                g.busyBotId = null;
+                delete g.turnStartedAt;
+            }
+            g.defaultResponder = normalizeGroupDefaultResponder(g.defaultResponder, g.memberIds, false);
+        }
+        if (rooms.length) {
+            // Bot removal is already durable. Finish erasing its data even if this
+            // write fails; startup repair removes these stale memberships later.
+            try {
+                this.saveGroups();
+            }
+            catch (error) {
+                console.warn("store: room cleanup will retry on restart", error);
+            }
+        }
         // every task's transcript goes with the bot, not just the open one
         for (const threadId of new Set([bot.threadId, ...(bot.tasks ?? []).map((t) => t.threadId)])) {
             this.deleteThreadRecord(threadId);
@@ -1770,6 +1820,8 @@ export class Store {
         // The bot folder (SOUL.md mirror) is the bot's too.
         removeBotFolder(id);
         this.emit({ type: "bot.deleted", botId: id });
+        for (const g of rooms)
+            this.emit({ type: "group", groupId: g.id });
         return true;
     }
     patchBot(id, patch) {
@@ -1796,7 +1848,7 @@ export class Store {
                     Object.assign(task, { [key]: structuredClone(patch[key]) });
                 }
             }
-            bot.unread = bot.tasks.some((candidate) => candidate.unread);
+            bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         }
         this.saveBots();
         this.emit({ type: "bot", botId: id });
@@ -2146,11 +2198,34 @@ export class Store {
      * current folder — unless the task already has a session (a thread from
      * before folders existed), which pins to the default so the folder can't
      * move under it. Returns the pinned value: a path, or null for default. */
+    /** Forget where a conversation works: its next turn pins it again
+     * (pinTaskCwd). For a Cloud home's conversation a revoked session opened,
+     * whose next turn must work in its own folder (server/cloud-owner.ts). */
+    unpinTaskCwd(threadId) {
+        const bot = this.botByThread(threadId);
+        const task = bot ? this.taskByThread(bot.id, threadId) : undefined;
+        if (!bot || !task || task.cwd === undefined)
+            return false;
+        delete task.cwd;
+        this.saveBots();
+        this.emit({ type: "bot", botId: bot.id });
+        return true;
+    }
     pinTaskCwd(botId, threadId, fallbackCwd, opts = {}) {
         const bot = this.bot(botId);
         const task = bot ? this.taskByThread(botId, threadId) : undefined;
         if (!bot || !task)
             return null;
+        // Its own folder, never the bot's project folder (a Cloud home's guest
+        // conversation), pinned when it first runs. A conversation that already
+        // ran elsewhere keeps its pin: it was not opened that way, and moving it
+        // would lose its work and its session.
+        if (opts.privateOnly && task.cwd === undefined) {
+            task.cwd = fallbackCwd ?? null;
+            this.saveBots();
+            this.emit({ type: "bot", botId });
+            return task.cwd;
+        }
         if (opts.none) {
             if (task.cwd !== null) {
                 task.cwd = null;
@@ -2318,9 +2393,13 @@ export class Store {
             task.title = patch.title.trim().slice(0, 80) || UNTITLED_THREAD;
         if (Object.prototype.hasOwnProperty.call(patch, "pinned") && task.pinned !== true)
             delete task.pinned;
+        // Still hidden: attention belongs on the source conversation. A same-call
+        // clear of routineRunId (no-source promotion) may keep unread.
+        if (task.routineRunId)
+            task.unread = false;
         if (bot.threadId === threadId)
             this.mirrorActiveTask(bot, task);
-        bot.unread = bot.tasks.some((candidate) => candidate.unread);
+        bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         this.saveBots();
         this.emit({ type: "bot", botId });
         return task;
@@ -2392,6 +2471,24 @@ export class Store {
         this.emit({ type: "bot", botId });
         return bot;
     }
+    /** Copy this bot's saved approval level and standing approvals onto one
+     * thread. A new thread already gets them; this is how an existing
+     * conversation catches up. Other threads, the transcript, and the bot
+     * default stay put. A grant that has not committed yet is ignored, so a
+     * refresh cannot copy the temporary Ask mask. */
+    refreshTaskPermissions(botId, threadId) {
+        const bot = this.bot(botId);
+        const task = this.taskByThread(botId, threadId);
+        if (!bot || !task)
+            return null;
+        const mode = approvalModeFor({ ...bot, approvalGrant: undefined });
+        const alwaysAllow = structuredClone(bot.alwaysAllow ?? []);
+        const autoApprove = mode === "auto";
+        const sameAllow = JSON.stringify(task.alwaysAllow ?? []) === JSON.stringify(alwaysAllow);
+        if (task.approvalMode === mode && task.autoApprove === autoApprove && sameAllow)
+            return task;
+        return this.patchTask(botId, threadId, { approvalMode: mode, autoApprove, alwaysAllow });
+    }
     mirrorActiveTask(bot, task) {
         bot.threadId = task.threadId;
         bot.resumeCursors = structuredClone(task.resumeCursors);
@@ -2399,8 +2496,10 @@ export class Store {
         bot.pinnedMessageId = task.pinnedMessageId;
     }
     /** A fresh context on the same bot: new thread, new session, same
-     * persona/tools/computer. Becomes the active task. */
-    createTask(botId, title, activate = true, projectId, openedBy, approvalMode) {
+     * persona/tools/computer. Becomes the active task. It runs on the bot's
+     * default model unless the caller hands it one (a thread opened from
+     * another of this bot's threads keeps that thread's model). */
+    createTask(botId, title, activate = true, projectId, openedBy, approvalMode, modelSelection) {
         const bot = this.bot(botId);
         if (!bot)
             return null;
@@ -2415,7 +2514,7 @@ export class Store {
             ...(projectId ? { projectId } : {}),
             ...(openedBy ? { openedBy: structuredClone(openedBy) } : {}),
             resumeCursors: {},
-            modelSelection: structuredClone(bot.modelSelection),
+            modelSelection: structuredClone(modelSelection ?? bot.modelSelection),
             approvalMode: approvalMode ?? approvalModeFor(bot),
             autoApprove: approvalMode ? false : Boolean(bot.autoApprove),
             alwaysAllow: approvalMode ? [] : [...(bot.alwaysAllow ?? [])],
@@ -2463,112 +2562,6 @@ export class Store {
         this.emit({ type: "bot", botId });
         return task;
     }
-    /** Where a bot-to-bot send outside a room lands: the PAIR CONVERSATION
-     * for (sender, recipient) — the recipient's task stamped `openedBy` this
-     * sender with kind "pair".
-     *
-     * Its scope is global for those two bots: deliberately not per source
-     * thread and not per assignment, so a teammate you work with all day is
-     * one readable row in the recipient's sidebar that remembers what was
-     * asked last time, instead of one row per message. Nothing about the
-     * caller's current turn takes part in choosing it — no dispatch
-     * generation, no request key — and never the recipient's selected
-     * thread, which belongs to the person.
-     *
-     * Two things bend that rule, both deliberately:
-     *
-     *   adoption — a recipient still carrying threads this sender opened
-     *   before pair conversations existed (one per assignment, each titled
-     *   with a sliced brief) has its most recently active one stamped as the
-     *   pair conversation instead of gaining yet another row, so the sprawl
-     *   stops on upgrade day. Nothing is deleted or closed. A start_thread
-     *   handoff is left alone: the sender named that job itself and tracks
-     *   it by its own delegation id.
-     *
-     *   concurrency — a second assignment arriving while the pair
-     *   conversation is still working (`working`, which the caller answers
-     *   from live turn state) gets its own work thread, so two jobs never
-     *   interleave in one transcript. `label` names that thread; the caller
-     *   closes it once its result has been reported. A pair conversation
-     *   never auto-closes. */
-    /** The identity a peer-opened row belongs to: its opener's id while that
-     * bot lives, else the one live bot the stamp's name still points at —
-     * what a deleted-and-recreated same-name bot inherits — else the dead id
-     * itself. A name two live bots share resolves to nobody's twin:
-     * ambiguous means unmatched, never a wrong merge. */
-    openerIdentity(openedBy) {
-        if (this.bot(openedBy.botId))
-            return openedBy.botId;
-        const named = this.bots.filter((bot) => bot.name === openedBy.name);
-        return named.length === 1 ? named[0].id : openedBy.botId;
-    }
-    resolvePairConversation(sender, recipientId, options) {
-        if (!this.bot(recipientId))
-            return null;
-        const title = `@${sender.name}`;
-        const opener = (kind, at = Date.now()) => ({ botId: sender.id, name: sender.name, kind, at });
-        // Identity-stable: the sender's own rows, plus ones a deleted
-        // predecessor opened when the stamp's name still points at exactly
-        // this bot — a same-name recreation inherits the conversation instead
-        // of minting a twin while the old row dangles live. A name two live
-        // bots share matches nobody's inheritance: refusing the fallback can
-        // cost a new row, never merge two bots' histories.
-        const fromSender = this.tasks(recipientId).filter((task) => task.openedBy && this.openerIdentity(task.openedBy) === sender.id);
-        let pair = fromSender.find((task) => task.openedBy?.kind === "pair");
-        if (!pair) {
-            const lastActivity = (task) => this.messagesTail(task.threadId, 1).messages.at(-1)?.at ?? task.openedBy?.at ?? task.createdAt;
-            const adopted = fromSender
-                .filter((task) => !task.openedBy?.kind && !task.openedBy?.delegationId && !task.closedBy)
-                .sort((a, b) => lastActivity(b) - lastActivity(a))[0];
-            if (adopted) {
-                // Keep the hour it was really opened: list_threads and the sidebar
-                // order by it, and adoption is not a new conversation.
-                this.setTaskOpenedBy(recipientId, adopted.threadId, opener("pair", adopted.openedBy?.at ?? adopted.createdAt));
-                // The title changes only when nobody typed it. The rule: rename it
-                // when it still equals what createTask made of the assignment that
-                // opened the thread — and that assignment is still the thread's
-                // first message, "@Recipient <brief>" — so the comparison is
-                // threadTitleFrom(that brief). Anything else is a name a person
-                // chose, and a thread with no request to read (its handoff never
-                // ran) cannot be checked, so both keep the title they have.
-                if (adopted.title === this.openingRequestTitle(recipientId, adopted.threadId)) {
-                    this.renameTask(recipientId, adopted.threadId, title);
-                }
-                pair = adopted;
-            }
-        }
-        if (pair && !options.working(pair.threadId)) {
-            // A conversation the sender closed after reading a result is picked
-            // back up, never replaced: closing is only the sidebar's idle state.
-            if (pair.closedBy)
-                this.setTaskClosedBy(recipientId, pair.threadId, null);
-            // An inherited row carries the predecessor's id; rebind it to the
-            // live bot so the name fallback is needed only once — a namesake
-            // appearing later cannot claim the row. The hour it was opened
-            // stays: inheritance is not a new conversation.
-            const inherited = pair.openedBy;
-            if (inherited && inherited.botId !== sender.id) {
-                this.setTaskOpenedBy(recipientId, pair.threadId, { ...inherited, botId: sender.id, name: sender.name });
-            }
-            return { task: pair, created: false };
-        }
-        // The brief is never a title. An 80-character slice of an assignment
-        // is the row nobody can read, and a durable conversation outlives the
-        // one brief that opened it.
-        const task = this.createTask(recipientId, pair ? `${title} · ${options.label || "parallel work"}` : title, false, undefined, opener(pair ? "work" : "pair"));
-        return task ? { task, created: true } : null;
-    }
-    /** The title a peer-opened thread was born with: what createTask made of
-     * the request that opened it, which is still the first message in it,
-     * addressed "@Recipient <brief>". null when there is no such message to
-     * read — an unrun handoff proves nothing about who named the row. */
-    openingRequestTitle(recipientId, threadId) {
-        const first = this.messagesFor(threadId)[0]?.text?.trim();
-        if (!first)
-            return null;
-        const addressed = `@${this.bot(recipientId)?.name ?? ""} `;
-        return threadTitleFrom(first.startsWith(addressed) ? first.slice(addressed.length) : first);
-    }
     switchTask(botId, threadId) {
         const bot = this.bot(botId);
         const task = bot?.tasks?.find((t) => t.threadId === threadId);
@@ -2598,7 +2591,8 @@ export class Store {
     /** Swap a machine-made first-message title for a generated one, once.
      * Equality against the snippet is the whole contract: a rename by the
      * person, by pair adoption, or by an earlier generated title each break
-     * it, so this never overwrites a name anyone chose. */
+     * it, so this never overwrites a name anyone chose. Regenerate title passes
+     * the title it started from, so a rename made while it ran stands. */
     retitleTask(botId, threadId, machineTitle, title) {
         const task = this.taskByThread(botId, threadId);
         if (!task || task.title !== machineTitle)
@@ -2620,7 +2614,7 @@ export class Store {
             this.mirrorActiveTask(bot, visible);
         }
         this.deleteThreadRecord(threadId);
-        bot.unread = bot.tasks.some((task) => task.unread);
+        bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         this.refreshBotActivity(bot);
         this.saveBots();
         this.emit({ type: "bot", botId });

package/dist-server/server/thread-events.js

@@ -215,6 +215,8 @@ function isRuntimeEvent(value) {
                     value.source === "peer"));
         case "thread.token-usage.updated":
             return typeof value.input === "number" && typeof value.output === "number";
+        case "runtime.notice":
+            return typeof value.message === "string";
         case "runtime.error":
             return typeof value.message === "string" &&
                 (value.setup === undefined || typeof value.setup === "boolean") &&

package/dist-server/server/thread-starters.js

@@ -35,6 +35,39 @@ export class ThreadStarters {
     get(threadId) {
         return this.starters.get(threadId);
     }
+    /** The threads opened for one person, newest first, at most `limit`. */
+    threadsOf(person, limit) {
+        const threads = [];
+        for (const [threadId, starter] of [...this.starters].reverse()) {
+            if (starter !== person)
+                continue;
+            threads.push(threadId);
+            if (threads.length >= limit)
+                break;
+        }
+        return threads;
+    }
+    /** Everyone a thread here was opened for. */
+    people() {
+        return new Set(this.starters.values());
+    }
+    /** Name `to` for every thread whose person `move` accepts: a one-time
+     * migration (server/cloud-owner.ts), not an ordinary record. The threads
+     * that changed. */
+    reassign(move, to) {
+        if (!KEY.test(to))
+            return [];
+        const moved = [];
+        for (const [threadId, person] of this.starters) {
+            if (person === to || !move(person))
+                continue;
+            this.starters.set(threadId, to);
+            moved.push(threadId);
+        }
+        if (moved.length)
+            writeFileAtomic(this.file, JSON.stringify(Object.fromEntries(this.starters)) + "\n", { mode: 0o600 });
+        return moved;
+    }
     /** Record once; a thread keeps the person it was first opened for. */
     set(threadId, person) {
         if (!person || !KEY.test(person) || !THREAD.test(threadId) || this.starters.has(threadId))

package/dist-server/server/thread-title.js

@@ -0,0 +1,46 @@
+// What a generated thread title is asked from.
+//
+// A fresh thread is named from its first message. "Regenerate title" (#1858)
+// names it again from the conversation as it is now: the newest user and bot
+// lines, never tool output, cards or screen frames, and bounded so the
+// one-shot stays as cheap as the first-message one.
+import { redactSecretsInText } from "./redact.js";
+/** The most text either kind of title one-shot ever sees. */
+export const TITLE_INPUT_MAX_CHARS = 1_500;
+const EXCERPT_MAX_MESSAGES = 12;
+const EXCERPT_LINE_MAX_CHARS = 300;
+const ATTACHMENT_TAG = /<attached-(?:image|file)\b[^>]*\/>/g;
+export function threadTitlePrompt(text, source = "first-message") {
+    return [
+        source === "conversation"
+            ? "Name the conversation below by what it is about now."
+            : "Name the conversation that begins with the message below.",
+        "Reply with only a short title: 3 to 6 words, plain text, no quotes, no trailing period.",
+        source === "conversation" ? "Conversation:" : "Message:",
+        text.trim().slice(0, TITLE_INPUT_MAX_CHARS),
+    ].join("\n");
+}
+/** The newest user and bot text lines, oldest first, one per line and each
+ * clipped, until the next line would pass the input cap. Attachment markup
+ * and secrets are scrubbed before anything leaves this machine. Empty when
+ * the thread has nothing a title could be drawn from. */
+export function titleConversationExcerpt(messages) {
+    const lines = [];
+    let length = 0;
+    for (let index = messages.length - 1; index >= 0 && lines.length < EXCERPT_MAX_MESSAGES; index--) {
+        const message = messages[index];
+        // peer asides and still-queued lines are not the conversation yet
+        if (message.kind !== "text" || !message.text || message.aside || message.queued)
+            continue;
+        const text = redactSecretsInText(message.text.replace(ATTACHMENT_TAG, " ")).replace(/\s+/g, " ").trim();
+        if (!text)
+            continue;
+        const clipped = text.length > EXCERPT_LINE_MAX_CHARS ? `${text.slice(0, EXCERPT_LINE_MAX_CHARS - 1)}…` : text;
+        const line = `${message.role === "user" ? "User" : "Bot"}: ${clipped}`;
+        if (length + line.length + 1 > TITLE_INPUT_MAX_CHARS)
+            break;
+        lines.push(line);
+        length += line.length + 1;
+    }
+    return lines.reverse().join("\n");
+}

package/dist-server/server/tts/fish.js

@@ -1,7 +1,6 @@
-// Fish Audio text to speech. The API key stays on the harness: the renderer
-// receives only voice metadata and synthesized audio bytes.
 const API = (process.env.OMB_FISH_AUDIO_API || "https://api.fish.audio").replace(/\/+$/, "");
-const MODEL = "s2.1-pro";
+/** Used when no model is saved, so existing setups keep their behavior. */
+export const DEFAULT_FISH_MODEL = "s2.1-pro";
 const MAX_ERROR_LENGTH = 240;
 const PAGE_SIZE = 100;
 const MAX_OWNED_PAGES = 100;
@@ -124,7 +123,7 @@ export async function listVoices(key) {
     });
     return [...new Map(voices.map((voice) => [voice.id, voice])).values()];
 }
-export async function synthesize(text, voiceId, key) {
+export async function synthesize(text, voiceId, key, model = DEFAULT_FISH_MODEL) {
     let res;
     try {
         res = await fetch(`${API}/v1/tts`, {
@@ -133,7 +132,7 @@ export async function synthesize(text, voiceId, key) {
                 authorization: `Bearer ${key}`,
                 "content-type": "application/json",
                 accept: "audio/mpeg",
-                model: MODEL,
+                model,
             },
             body: JSON.stringify({
                 text,

package/dist-server/server/tts/index.js

@@ -69,8 +69,9 @@ export function voiceReady(cfg, voiceId) {
 }
 /** What the settings panel needs. Never includes the key — same write-only
  * rule as every other credential. baseUrl and model are Chatterbox
- * settings, not credentials, so they come back in full. `included` says the
- * voice is Cloud Pro's, not a saved key. */
+ * settings, not credentials, so they come back in full; `fishModel` is the
+ * Fish Audio speech model, resolved to its default when unset. `included`
+ * says the voice is Cloud Pro's, not a saved key. */
 export function describeVoice(cfg) {
     const provider = voiceProvider(cfg);
     const included = provider === "elevenlabs" && elevenLabs(cfg)?.included === true;
@@ -81,6 +82,7 @@ export function describeVoice(cfg) {
         provider,
         baseUrl: provider === "chatterbox" ? (cfg.tts?.baseUrl ?? "") : "",
         model: provider === "chatterbox" ? (cfg.tts?.model ?? "") : "",
+        ...(provider === "fish" ? { fishModel: cfg.tts?.fishModel ?? fish.DEFAULT_FISH_MODEL } : {}),
         ...(included ? { included: true } : {}),
     };
 }
@@ -147,7 +149,7 @@ export function speak(cfg, text, voiceId, run) {
         const voice = voiceId || cfg.tts?.voice;
         if (!voice)
             throw new NoVoiceConfigured("voice");
-        return fish.synthesize(text, voice, key);
+        return fish.synthesize(text, voice, key, cfg.tts?.fishModel);
     }
     const credential = elevenLabs(cfg);
     if (!credential)