openmausbot 0.1.90 → 0.1.91

package/dist-server/server/model-context-window.js

@@ -6,10 +6,10 @@ export function modelContextWindow(model) {
     if (!model)
         return undefined;
     const id = model.toLowerCase();
-    // Opus 5.5 is 1M without a `[1m]` suffix. Only the exact slug, or that
-    // slug after a slash or a provider dot. A longer suffix such as
-    // `claude-opus-5-5-local` stays on the generic Claude rule, as does `host::`.
-    if (/(?:^|[/.])claude-opus-5(?:-5|\.5)$/.test(id))
+    // Opus 5.5 and Sonnet 5.5 are 1M without a `[1m]` suffix. Only the exact
+    // slug, or that slug after a slash or a provider dot. A longer suffix such
+    // as `claude-sonnet-5-5-local` stays on the generic Claude rule, as does `host::`.
+    if (/(?:^|[/.])claude-(?:opus|sonnet)-5(?:-5|\.5)$/.test(id))
         return 1_000_000;
     if (/claude/.test(id) || /^(opus|sonnet|haiku|fable)\b/.test(id))
         return /\[1m\]|-1m\b|1m-context/.test(id) ? 1_000_000 : 200_000;

package/dist-server/server/package-export.js

@@ -15,6 +15,21 @@ function portableKey(value, fallback, used) {
     used.add(key);
     return key;
 }
+/** A room's responder in package terms. An Auto room is written as its lead
+ * (its fallback, else its first exported member): that is how it behaves on
+ * any install without the decision model, and every older app can read it,
+ * where a new `auto` kind would make them refuse the whole package. */
+function packageRoomResponder(responder, keys, members) {
+    if (responder.kind === "member" && keys.has(responder.botId))
+        return { kind: "agent", agent: keys.get(responder.botId) };
+    if (responder.kind === "everyone")
+        return { kind: "everyone" };
+    if (responder.kind === "auto") {
+        const lead = responder.fallbackBotId ? keys.get(responder.fallbackBotId) : undefined;
+        return { kind: "agent", agent: lead ?? members[0] };
+    }
+    return { kind: "mentions" };
+}
 function samePlaybook(a, b) {
     return a.name === b.name && a.summary === b.summary && a.instructions === b.instructions &&
         a.triggers.join("\n") === b.triggers.join("\n");
@@ -122,11 +137,7 @@ export function createBotPackageExport(input) {
         const members = group.memberIds.flatMap((id) => idToKey.has(id) ? [idToKey.get(id)] : []);
         if (!members.length)
             continue;
-        const defaultResponder = group.defaultResponder.kind === "member" && idToKey.has(group.defaultResponder.botId)
-            ? { kind: "agent", agent: idToKey.get(group.defaultResponder.botId) }
-            : group.defaultResponder.kind === "everyone"
-                ? { kind: "everyone" }
-                : { kind: "mentions" };
+        const defaultResponder = packageRoomResponder(group.defaultResponder, idToKey, members);
         rooms.push({
             key: portableKey(group.name, `room-${index + 1}`, roomKeys),
             name: group.name,
@@ -587,11 +598,7 @@ export function createTeamPackageExport(input) {
         const members = group.memberIds.flatMap((id) => botKeys.has(id) ? [botKeys.get(id)] : []);
         if (!members.length)
             continue;
-        const defaultResponder = group.defaultResponder.kind === "member" && botKeys.has(group.defaultResponder.botId)
-            ? { kind: "agent", agent: botKeys.get(group.defaultResponder.botId) }
-            : group.defaultResponder.kind === "everyone"
-                ? { kind: "everyone" }
-                : { kind: "mentions" };
+        const defaultResponder = packageRoomResponder(group.defaultResponder, botKeys, members);
         const key = roomKeys.get(group.id);
         rooms.push({ key, name: group.name, members, ...(group.bulletin ? { bulletin: group.bulletin } : {}), defaultResponder });
         roomMembers.set(group.id, new Set(members));

package/dist-server/server/package-import.js

@@ -318,9 +318,12 @@ function runImport(source, options, deps) {
             const ids = room.members.map((key) => botIds.get(key));
             let created = store.createGroup(room.name, ids, false, section);
             createdGroups.push(created);
-            const defaultResponder = room.defaultResponder.kind === "agent"
-                ? { kind: "member", botId: botIds.get(room.defaultResponder.agent) }
-                : { kind: room.defaultResponder.kind };
+            const responder = room.defaultResponder;
+            const defaultResponder = responder.kind === "agent"
+                ? { kind: "member", botId: botIds.get(responder.agent) }
+                : responder.kind === "auto"
+                    ? { kind: "auto", ...(responder.agent ? { fallbackBotId: botIds.get(responder.agent) } : {}) }
+                    : { kind: responder.kind };
             created = store.patchGroup(created.id, {
                 bulletin: room.bulletin ?? "",
                 defaultResponder,

package/dist-server/server/package-parts.js

@@ -53,7 +53,9 @@ export const roomReleaseValues = (room) => ({
     members: [...room.members].sort(),
     defaultResponder: room.defaultResponder.kind === "agent"
         ? { kind: "agent", agent: room.defaultResponder.agent }
-        : { kind: room.defaultResponder.kind },
+        : room.defaultResponder.kind === "auto" && room.defaultResponder.agent
+            ? { kind: "auto", agent: room.defaultResponder.agent }
+            : { kind: room.defaultResponder.kind },
 });
 /** One normal form for a routine's timing on both sides, so an untouched
  * routine compares equal: absent cap → null, absent overlap → "skip". */

package/dist-server/server/request-auth.js

@@ -239,6 +239,8 @@ export const CLIENT_ALLOW = [
     // with the feature off these paths are as unlisted as any other, so a
     // client session is refused exactly the way an unknown route refuses it.
     { methods: ["POST"], path: /^\/api\/shared-computers\/(?:connect|[\w-]+\/(?:poll|lease|result|disconnect))$/, feature: "sharedComputers" },
+    // What this person has lent (owner-scoped status, no secrets). Same gate.
+    { methods: ["GET"], path: /^\/api\/shared-computers$/, feature: "sharedComputers" },
     // liveness, identity, the stream
     { methods: ["GET"], path: /^\/api\/health$/ },
     { methods: ["GET"], path: /^\/api\/edition$/ },

package/dist-server/server/routes/decider.js

@@ -0,0 +1,19 @@
+import { PASS } from "./table.js";
+const MAX_KEY_LENGTH = 512;
+export function createDeciderRoutes(deps) {
+    return async ({ req, res, path, method, json, readBody }) => {
+        if (path !== "/api/decider/test" || method !== "POST")
+            return PASS;
+        const body = await readBody(req, 8192);
+        if (body?.key !== undefined && typeof body.key !== "string")
+            return json(res, 400, { error: "key must be a string" });
+        const draft = typeof body?.key === "string" ? body.key.trim() : "";
+        if (draft.length > MAX_KEY_LENGTH)
+            return json(res, 400, { error: "That does not look like an API key." });
+        res.setHeader("cache-control", "no-store");
+        const result = await deps.decider.testKey(draft ? { key: draft } : {});
+        if (result.ok)
+            return json(res, 200, { ok: true, latencyMs: result.latencyMs });
+        return json(res, 200, { ok: false, reason: result.reason, ...(result.status ? { status: result.status } : {}) });
+    };
+}

package/dist-server/server/shared-computers.js

@@ -15,41 +15,120 @@ export const sharedComputerOperation = z.object({
     arguments: z.record(z.string(), z.unknown()).optional(),
 }).strict();
 const failure = (message, status = 409) => Object.assign(new Error(message), { status });
+/** Bounds memory, not anyone's share: a desktop session holds one entry. */
+const TOTAL = 100;
+/** How long a lent computer that stopped polling (asleep, app closed) stays
+ * known, so a status reader can tell "lent but offline" from "not lent". */
+const RETAIN_MS = 14 * 24 * 60 * 60_000;
+const OFFLINE = "This shared computer is offline. Keep its desktop app open; do not substitute files on the server.";
+/** The scopes the desktop registered, checked by the server as well. The
+ * desktop's own grant is the authority and checks every operation again;
+ * this only means the server never even queues work outside what the desktop
+ * said it lends. */
+export function sharedComputerScopeRefusal(registration, operation) {
+    switch (operation.action) {
+        case "run_command":
+            return registration.terminal ? null : "Terminal access is not lent to this server.";
+        case "computer_tools":
+        case "computer_call":
+            return registration.computer ? null : "Apps and screen are not lent to this server.";
+        case "list_files":
+        case "read_file":
+        case "write_file": {
+            const lent = registration.folders.find(entry => entry.id === operation.folder_id);
+            if (!lent)
+                return "This folder has not been shared with this server.";
+            return operation.action === "write_file" && !lent.write ? "This folder is read-only." : null;
+        }
+    }
+}
+/** The person a bot turn acts for, from the harness's own record of which
+ * message started it: that request must name this exact turn generation (a
+ * continuation of the same request adds its generation), must not have been
+ * stopped, and its message must come from a person. Anything else is nobody. */
+export function provenRequestPerson(request, generation, personOf) {
+    if (!request?.messageId || request.stopped || !request.generations.has(generation))
+        return null;
+    return personOf(request.messageId) ?? null;
+}
 /** In-memory rendezvous only. Authority over local resources stays on the
- * desktop. Restart/disconnect NEVER replays an operation with an unknown outcome. */
+ * desktop. Restart/disconnect NEVER replays an operation with an unknown outcome.
+ *
+ * Partitioned by owner: an entry is keyed by the registering session and the
+ * desktop's id, so another session can never take over an id, and a bot turn
+ * sees only the computers of the person it acts for. A turn that acts for
+ * nobody provable (principal null) sees none. */
 export class SharedComputers {
     computers = new Map();
     sessionLive;
     constructor(sessionLive) { this.sessionLive = sessionLive; }
+    static key(session, id) { return `${session}\n${id}`; }
     register(registration, owner, secret) {
         if (!/^[a-f0-9]{64}$/.test(secret))
             throw failure("Invalid computer credential", 400);
-        const old = this.computers.get(registration.id);
+        const key = SharedComputers.key(owner.session, registration.id);
+        const old = this.computers.get(key);
         if (old) {
-            this.authorize(registration.id, owner, secret);
+            this.authorize(registration.id, owner.session, secret);
             old.registration = registration;
             old.seen = Date.now();
+            return;
+        }
+        this.reap();
+        // A paired desktop runs one grant per server, so a new id from the same
+        // session is a new save: its earlier entry is stale and goes. No other
+        // session can reach, replace or squat this key.
+        for (const [stale, entry] of this.computers) {
+            if (entry.owner.session !== owner.session)
+                continue;
+            this.computers.delete(stale);
+            entry.wake?.();
+            for (const job of entry.jobs.values())
+                this.finish(entry, job, failure("This computer's access changed. An in-flight action may have completed; inspect before retrying."));
         }
-        else {
-            // Reap dead devices before applying the bounded registration limit.
-            for (const [id, entry] of this.computers)
-                if (!this.online(entry) && entry.jobs.size === 0)
-                    this.computers.delete(id);
-            if (this.computers.size >= 20)
-                throw failure("Too many shared computers");
-            this.computers.set(registration.id, { registration, owner, secret, seen: Date.now(), jobs: new Map() });
+        if (this.computers.size >= TOTAL)
+            throw failure("Too many shared computers");
+        this.computers.set(key, { registration, owner: { ...owner }, secret, seen: Date.now(), jobs: new Map() });
+    }
+    /** Forget entries whose session ended or that have been silent too long. */
+    reap() {
+        for (const [key, entry] of this.computers) {
+            if (entry.jobs.size === 0 && (!this.sessionLive(entry.owner.session) || Date.now() - entry.seen > RETAIN_MS))
+                this.computers.delete(key);
         }
     }
-    online(entry) { return this.sessionLive(entry.owner) && Date.now() - entry.seen < 40_000; }
-    authorize(id, owner, secret) {
-        const entry = this.computers.get(id);
-        if (!entry || entry.owner !== owner || !this.sessionLive(owner) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret)))
+    online(entry) { return this.sessionLive(entry.owner.session) && Date.now() - entry.seen < 40_000; }
+    authorize(id, session, secret) {
+        const entry = this.computers.get(SharedComputers.key(session, id));
+        if (!entry || !this.sessionLive(session) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret)))
             throw failure("Shared computer is disconnected or not authorized", 403);
         return entry;
     }
-    list() { return [...this.computers.values()].filter(entry => this.online(entry)).map(entry => entry.registration); }
-    async poll(id, owner, secret) {
-        const entry = this.authorize(id, owner, secret);
+    /** The online computers one person lent. */
+    list(principal) {
+        if (!principal)
+            return [];
+        return [...this.computers.values()].filter(entry => entry.owner.person === principal && this.online(entry)).map(entry => entry.registration);
+    }
+    /** What one person has lent, online or not: the documented status a
+     * reader (the Cloud UI, the next step's placement) uses to tell "your Mac
+     * is lent and awake" from "lent but asleep" and "not lent". No secret, no
+     * session. Resets when this server restarts; a lending desktop registers
+     * again within seconds of being online. */
+    status(principal) {
+        if (!principal)
+            return [];
+        this.reap();
+        return [...this.computers.values()].filter(entry => entry.owner.person === principal).map(entry => ({
+            id: entry.registration.id, name: entry.registration.name, online: this.online(entry), busy: entry.jobs.size > 0, lastSeenAt: entry.seen,
+            scopes: {
+                folders: entry.registration.folders.map(({ id, name, write }) => ({ id, name, write })),
+                terminal: entry.registration.terminal, screen: entry.registration.computer,
+            },
+        }));
+    }
+    async poll(id, session, secret) {
+        const entry = this.authorize(id, session, secret);
         if (entry.wake)
             throw failure("A computer poll is already running");
         entry.seen = Date.now();
@@ -73,34 +152,41 @@ export class SharedComputers {
             const timer = setTimeout(() => { entry.wake = undefined; resolve(); }, 20_000);
             entry.wake = () => { clearTimeout(timer); entry.wake = undefined; resolve(); };
         });
-        this.authorize(id, owner, secret);
+        this.authorize(id, session, secret);
         entry.seen = Date.now();
         return next();
     }
-    liveJob(id, owner, secret, jobId) {
-        const entry = this.authorize(id, owner, secret);
+    liveJob(id, session, secret, jobId) {
+        const entry = this.authorize(id, session, secret);
         entry.seen = Date.now();
         const job = entry.jobs.get(jobId);
         return job?.sent === true && job.active();
     }
-    complete(id, owner, secret, jobId, result) {
-        const entry = this.authorize(id, owner, secret);
+    complete(id, session, secret, jobId, result) {
+        const entry = this.authorize(id, session, secret);
         const job = entry.jobs.get(jobId);
         if (!job || !job.sent)
             throw failure("This computer operation expired; it will not be replayed");
         this.finish(entry, job, job.active() ? null : failure("The requesting turn ended"), result);
     }
-    disconnect(id, owner, secret) {
-        const entry = this.authorize(id, owner, secret);
-        this.computers.delete(id);
+    disconnect(id, session, secret) {
+        const entry = this.authorize(id, session, secret);
+        this.computers.delete(SharedComputers.key(session, id));
         entry.wake?.();
         for (const job of entry.jobs.values())
             this.finish(entry, job, failure("Computer disconnected. An in-flight action may have completed; inspect before retrying."));
     }
-    request(operation, active) {
-        const entry = this.computers.get(operation.computer_id);
-        if (!entry || !this.online(entry))
-            return Promise.reject(failure("This shared computer is offline. Keep its desktop app open; do not substitute files on the server."));
+    /** One bot operation for the person the turn acts for. Another person's
+     * computer answers exactly like one that does not exist. */
+    request(operation, principal, active) {
+        if (!principal)
+            return Promise.reject(failure("This conversation cannot use a shared computer: only a conversation started by the person who shared it can.", 403));
+        const entry = [...this.computers.values()].find(candidate => candidate.registration.id === operation.computer_id && candidate.owner.person === principal && this.online(candidate));
+        if (!entry)
+            return Promise.reject(failure(OFFLINE));
+        const refusal = sharedComputerScopeRefusal(entry.registration, operation);
+        if (refusal)
+            return Promise.reject(failure(refusal, 403));
         if (entry.jobs.size >= 1)
             return Promise.reject(failure("This shared computer is busy. Wait for its current action to finish."));
         if (!active())

package/dist-server/server/store.js

@@ -384,7 +384,8 @@ export function mentionedBots(text, peers) {
 }
 /** Normalize persisted or API-provided routing. Old rooms did not have this
  * field; giving them their first member as lead fixes the old silent-send
- * behavior without making every prompt fan out to every model. */
+ * behavior without making every prompt fan out to every model. A kind this
+ * build does not know degrades the same way. */
 export function normalizeGroupDefaultResponder(value, memberIds, dm = false) {
     if (dm)
         return { kind: "mentions" };
@@ -394,6 +395,12 @@ export function normalizeGroupDefaultResponder(value, memberIds, dm = false) {
             return { kind: "everyone" };
         if (candidate.kind === "mentions")
             return { kind: "mentions" };
+        if (candidate.kind === "auto") {
+            // A fallback who left the room reverts to "the first member".
+            return typeof candidate.fallbackBotId === "string" && memberIds.includes(candidate.fallbackBotId)
+                ? { kind: "auto", fallbackBotId: candidate.fallbackBotId }
+                : { kind: "auto" };
+        }
         if (candidate.kind === "member" &&
             typeof candidate.botId === "string" &&
             memberIds.includes(candidate.botId)) {
@@ -426,6 +433,13 @@ export function roomResponders(text, members, defaultResponder) {
         const lead = available.find((member) => member.id === defaultResponder.botId);
         return lead ? [lead] : [];
     }
+    // Auto without a decision (the decision model off, unsure or failing) is
+    // lead mode: its fallback member, else the first active member. The
+    // decision itself is asked asynchronously by the room turn.
+    if (defaultResponder.kind === "auto") {
+        const fallback = available.find((member) => member.id === defaultResponder.fallbackBotId) ?? available[0];
+        return fallback ? [fallback] : [];
+    }
     return [];
 }
 export class Store {
@@ -1465,7 +1479,7 @@ export class Store {
      * (same parent, new text) and becomes the active leaf. `sendId` is the
      * client's identity for this edit, so its instant bubble reconciles onto
      * the canonical message and a network retry cannot fork twice. */
-    branchMessage(threadId, sourceId, text, sendId) {
+    branchMessage(threadId, sourceId, text, sendId, sender) {
         const t = this.thread(threadId);
         const source = t.messages.find((m) => m.id === sourceId);
         if (!source)
@@ -1479,6 +1493,7 @@ export class Store {
             parentId: source.parentId ?? null,
             replyToId: source.replyToId,
             ...(sendId ? { sendId } : {}),
+            ...(sender ? { sender } : {}),
         };
         t.messages.push(full);
         t.activeLeafId = full.id;

package/dist-server/server/surface.js

@@ -86,6 +86,16 @@ export function surfaceLabel(surface) {
  * lands there. Same words as the panel and the composer chip. */
 const RESTATE_SENTENCE = " Before your first action on a screen or page in a task, say in one short sentence where you are working, using that same name.";
 const SURFACE_AUTHORITY = " For browser and computer tasks, use OpenMausBot's mounted browser/computer tools first: inspect the target, perform the action, and verify its result before claiming success. Discover deferred tools by their server/name when needed. Do not substitute the provider's own desktop, a shell-launched browser, or another automation path for the selected OpenMausBot surface. Ordinary code and file tasks may still use their normal tools. Announcing an action is not performing it. A request naming another place does not move these tools: this computer is the user's host, Local VM is an isolated desktop, the cloud computer is remote, and the built-in browser is a separate browser. If the requested place differs from the mounted one, explain the mismatch and ask the user to change the conversation's computer selector; never act on a different computer or describe a host window as a VM.";
+/** A Cloud home offers neither this computer nor a Local VM
+ * (server/cloud-home.ts), so its bots are told only about the places it has.
+ * Each pair rewrites one phrase of the desktop wording above. */
+const CLOUD_HOME_WORDING = [
+    ["this computer is the user's host, Local VM is an isolated desktop, the cloud computer is remote, and the built-in browser is a separate browser",
+        "the cloud computer is remote, the built-in browser is a separate browser, and the user's own computer cannot be reached from here"],
+    [" or describe a host window as a VM", ""],
+    ["select an available Local VM without asking", "select an available cloud computer without asking"],
+    [" Never silently replace an explicitly requested VM with the host desktop.", ""],
+];
 /** The one paragraph that says where this turn's work happens. Assembled
  * from what was actually mounted, never from the setting, so the model is
  * only ever told about tools it can call. */
@@ -122,6 +132,9 @@ export function surfacePrompt(mounted, opts = {}) {
         text += " No computer or browser tools are mounted yet; select_computer is the way to connect them before screen work, not a reason to claim you already performed it.";
     if (computer || mounted.browser)
         text += " For online research, use the selected OpenMausBot browser when a search service is unavailable. A failed tool proves only that this attempt failed, not that every browser is unavailable. Inspect the current page after navigation; report a sign-in page, redirect or error as such. A completed model turn is not proof that the user's task succeeded.";
+    if (opts.cloudHome)
+        for (const [desktop, cloudHome] of CLOUD_HOME_WORDING)
+            text = text.replace(desktop, cloudHome);
     return text + (opts.note ?? "");
 }
 /** Tool names that touch a screen, for engines that report bare names.

package/dist-server/server/system-prompt.js

@@ -68,6 +68,17 @@ export function computerPrompt(kind) {
         return "";
     return COMPUTER_PARAGRAPH[kind] + SIGN_IN_PROMPT;
 }
+/** Every turn on a Cloud home (server/cloud-home.ts). The bot runs in the
+ * cloud, so asked about the person's own computer it says what is true instead
+ * of sending them to set up places that cannot exist there. Their Mac is
+ * reachable only when they lend it (docs/cloud-pro.md), through the
+ * shared-computer tools, so only a turn that has those tools is told to use them. */
+export function cloudHomePrompt(sharedComputerTools) {
+    return " You run on the user's OMB Cloud, a server in the cloud, not on their own computer." + (sharedComputerTools
+        ? " If they ask for something on their own Mac or PC, check list_shared_computers: a Mac they lend to their Cloud is reachable through shared_computer, within the folders and apps it allows. If none is lent and online, say so in one sentence: they can turn on Let my Cloud use this Mac under Settings → OMB Cloud in the desktop app on that Mac."
+        : " You cannot see or use their Mac or PC, its screen or its files from here. If they ask for something on it, say so in one sentence.")
+        + " Offer what works here: the built-in browser and cloud computers. Never ask them to set up this computer or a Local VM; neither exists here.";
+}
 export const COMPOSIO_PROMPT = " The user's connected apps (Gmail, Calendar, Slack, Notion, and the rest) are reachable through the composio tools — find the right one with COMPOSIO_SEARCH_TOOLS, read its arguments with COMPOSIO_GET_TOOL_SCHEMAS, then run it with COMPOSIO_MULTI_EXECUTE_TOOL. Reach for them before telling the user you have no access to a service.";
 /** The connected-apps paragraph, personalized to the bot's grants (issue
  * #1737). A bot with no grants record keeps the legacy all-tools sentence;

package/dist-server/server/team-backup.js

@@ -94,7 +94,9 @@ export function createTeamBackup(store, routines, name) {
             key: group.id, name: group.name, section: group.section, dm: Boolean(group.dm) && memberIds.length === 2,
             bulletin: group.bulletin, memberIds,
             defaultResponder: group.defaultResponder.kind === "member" && !memberIds.includes(group.defaultResponder.botId)
-                ? { kind: "mentions" } : group.defaultResponder,
+                ? { kind: "mentions" }
+                : group.defaultResponder.kind === "auto" && group.defaultResponder.fallbackBotId && !memberIds.includes(group.defaultResponder.fallbackBotId)
+                    ? { kind: "auto" } : group.defaultResponder,
             activeTask: group.threadId, tasks: history(group),
         };
     });
@@ -226,7 +228,9 @@ export function importTeamBackup(store, routines, input, selection, options = {}
             groups.push(group);
             groupIds.set(source.key, group.id);
             const responder = source.defaultResponder;
-            store.patchGroup(group.id, { bulletin: source.bulletin, setupCompletedAt: Date.now(), defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) } : responder });
+            store.patchGroup(group.id, { bulletin: source.bulletin, setupCompletedAt: Date.now(), defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) }
+                    : responder.kind === "auto" ? { kind: "auto", ...(responder.fallbackBotId ? { fallbackBotId: botIds.get(responder.fallbackBotId) } : {}) }
+                        : responder });
             // Use the existing task APIs for rooms; direct-message rooms have one.
             const threads = source.tasks.map((task, i) => {
                 if (i === 0) {

package/dist-server/server/team-manifest.js

@@ -25,11 +25,18 @@ const optionalText = (max) => z
     .transform((value) => value?.trim() || undefined)
     .refine((value) => value === undefined || value.length <= max, { message: "is too long" })
     .optional();
-const responderSchema = z.discriminatedUnion("kind", [
+const RESPONDER_KINDS = new Set(["member", "everyone", "mentions", "auto"]);
+/** A responder kind from a newer release reads as "no responder": the room
+ * is created with the default lead, never refused. */
+const responderSchema = z.preprocess((value) => {
+    const kind = value && typeof value === "object" ? value.kind : undefined;
+    return typeof kind === "string" && !RESPONDER_KINDS.has(kind) ? { kind: "mentions" } : value;
+}, z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("member"), member: requiredText(64) }),
     z.object({ kind: z.literal("everyone") }),
     z.object({ kind: z.literal("mentions") }),
-]);
+    z.object({ kind: z.literal("auto"), member: requiredText(64).optional() }),
+]));
 const memberSchema = z.object({
     key: requiredText(64).regex(/^[a-z0-9][a-z0-9_-]*$/, {
         message: "may only contain lowercase letters, numbers, - and _",
@@ -117,7 +124,8 @@ export function parseTeamManifest(value) {
         result.team.description = parsed.data.team.description;
     if (parsed.data.version === LEGACY_TEAM_MANIFEST_VERSION) {
         const defaultResponder = parsed.data.team.room.defaultResponder;
-        if (defaultResponder.kind === "member" && !seenKeys.has(defaultResponder.member)) {
+        if ((defaultResponder.kind === "member" || defaultResponder.kind === "auto") && defaultResponder.member !== undefined &&
+            !seenKeys.has(defaultResponder.member)) {
             throw new Error(`Unknown default responder: ${defaultResponder.member}`);
         }
         result.team.room = {

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

@@ -10,7 +10,12 @@
 // client already splits text into utterances and fetches the next while the
 // current one plays, which gets the same perceived latency with far fewer
 // moving parts — and no socket to leak when a turn is interrupted.
-const API = process.env.OMB_ELEVENLABS_API || "https://api.elevenlabs.io/v1";
+//
+// The base URL is the caller's: ElevenLabs itself for the person's own key
+// (OMB_ELEVENLABS_API overrides it for dev and tests), Cloud Pro's relay for
+// its included token (included-services.ts). Only a key being saved is
+// verified, and that is always an own key.
+import { elevenLabsProviderApi } from "../included-services.js";
 const MODEL = "eleven_flash_v2_5";
 // 64kbps mono is indistinguishable for speech and a third of the bytes
 const FORMAT = "mp3_44100_64";
@@ -51,7 +56,7 @@ function message(status, what, body) {
  * picker needs next, so it tests exactly the capability that matters. */
 export async function verifyKey(key) {
     try {
-        const res = await fetch(`${API}/voices`, {
+        const res = await fetch(`${elevenLabsProviderApi()}/voices`, {
             headers: { "xi-api-key": key },
             signal: AbortSignal.timeout(20_000),
         });
@@ -63,8 +68,8 @@ export async function verifyKey(key) {
         return { ok: false, message: "Couldn't reach ElevenLabs to check that key — check your connection." };
     }
 }
-export async function listVoices(key) {
-    const res = await fetch(`${API}/voices`, {
+export async function listVoices(key, api) {
+    const res = await fetch(`${api}/voices`, {
         headers: { "xi-api-key": key },
         signal: AbortSignal.timeout(20_000),
     });
@@ -79,8 +84,8 @@ export async function listVoices(key) {
     }))
         .filter((v) => v.id);
 }
-export async function synthesize(text, voiceId, key) {
-    const res = await fetch(`${API}/text-to-speech/${encodeURIComponent(voiceId)}?output_format=${FORMAT}`, {
+export async function synthesize(text, voiceId, key, api) {
+    const res = await fetch(`${api}/text-to-speech/${encodeURIComponent(voiceId)}?output_format=${FORMAT}`, {
         method: "POST",
         headers: { "xi-api-key": key, "content-type": "application/json", accept: "audio/mpeg" },
         body: JSON.stringify({ text, model_id: MODEL }),

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

@@ -1,3 +1,4 @@
+import { voiceCredential } from "../included-services.js";
 import * as chatterbox from "./chatterbox.js";
 import * as elevenlabs from "./elevenlabs.js";
 import * as grok from "./grok.js";
@@ -16,6 +17,9 @@ export class NoVoiceConfigured extends Error {
         this.reason = reason;
     }
 }
+/** The ElevenLabs credential in use: the person's own key, else the one
+ * included with Cloud Pro. Settings' own-key flows read cfg.tts.key instead. */
+const elevenLabs = (cfg) => voiceCredential(cfg.tts?.key);
 export function voiceProvider(cfg) {
     const provider = cfg.tts?.provider;
     return provider === "xai" || provider === "fish" || provider === "system" || provider === "chatterbox" ? provider : "elevenlabs";
@@ -33,7 +37,7 @@ export function providerConfigured(cfg) {
         return Boolean(cfg.tts?.baseUrl?.trim());
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey);
-    return Boolean(cfg.tts?.key);
+    return Boolean(elevenLabs(cfg));
 }
 export function voiceConfigured(cfg) {
     const provider = voiceProvider(cfg);
@@ -46,7 +50,7 @@ export function voiceConfigured(cfg) {
         return Boolean(cfg.tts?.baseUrl?.trim() && cfg.tts?.voice);
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey && cfg.tts?.voice);
-    return Boolean(cfg.tts?.key && cfg.tts?.voice);
+    return Boolean(elevenLabs(cfg) && cfg.tts?.voice);
 }
 /** A per-bot voice is a complete choice too; it should not be blocked just
  * because the app-wide fallback has not been selected yet. */
@@ -61,13 +65,15 @@ export function voiceReady(cfg, voiceId) {
         return Boolean(cfg.tts?.baseUrl?.trim() && (voiceId || cfg.tts?.voice));
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey && (voiceId || cfg.tts?.voice));
-    return Boolean(cfg.tts?.key && (voiceId || cfg.tts?.voice));
+    return Boolean(elevenLabs(cfg) && (voiceId || cfg.tts?.voice));
 }
 /** 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. */
+ * settings, not credentials, so they come back in full. `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;
     return {
         configured: providerConfigured(cfg),
         ready: voiceConfigured(cfg),
@@ -75,6 +81,7 @@ export function describeVoice(cfg) {
         provider,
         baseUrl: provider === "chatterbox" ? (cfg.tts?.baseUrl ?? "") : "",
         model: provider === "chatterbox" ? (cfg.tts?.model ?? "") : "",
+        ...(included ? { included: true } : {}),
     };
 }
 export function verifyKey(provider, key) {
@@ -94,10 +101,10 @@ export async function listVoices(cfg, run) {
         const key = cfg.tts?.fishKey;
         return key ? fish.listVoices(key) : [];
     }
-    const key = cfg.tts?.key;
-    if (!key)
+    const credential = elevenLabs(cfg);
+    if (!credential)
         return [];
-    return elevenlabs.listVoices(key);
+    return elevenlabs.listVoices(credential.token, credential.api);
 }
 /** Synthesize one utterance. Throws NoVoiceConfigured when there is nothing
  * to speak with, which the route turns into a 409 the client can explain. */
@@ -142,11 +149,11 @@ export function speak(cfg, text, voiceId, run) {
             throw new NoVoiceConfigured("voice");
         return fish.synthesize(text, voice, key);
     }
-    const key = cfg.tts?.key;
-    if (!key)
+    const credential = elevenLabs(cfg);
+    if (!credential)
         throw new NoVoiceConfigured("key");
     const voice = voiceId || cfg.tts?.voice;
     if (!voice)
         throw new NoVoiceConfigured("voice");
-    return elevenlabs.synthesize(text, voice, key);
+    return elevenlabs.synthesize(text, voice, credential.token, credential.api);
 }