openmausbot 0.1.86 → 0.1.88

package/dist-server/server/drivers/acp/opencode-go.js

@@ -6,6 +6,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
+import { titleCaseModelId } from "../../contracts.js";
 import { execCli } from "../../procs.js";
 const STATIC_MODELS = {
     default: "opencode/x-preview-f-free",
@@ -21,11 +22,7 @@ let lastSuccessfulCatalog = null;
 const MODEL_PROBE_TTL_MS = 30_000;
 const modelProbeCache = new Map();
 function labelForModel(id) {
-    return id
-        .split(/[-_.]+/g)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ");
+    return titleCaseModelId(id, /[-_.]+/);
 }
 function providerLabel(id) {
     if (id === "opencode")

package/dist-server/server/drivers/acp/qwen.js

@@ -3,30 +3,20 @@
 // Custom and are written into ~/.qwen/settings.json modelProviders.
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { qualifiedModelLabel } from "../../contracts.js";
+import { harnessHome } from "../../env-path.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
-function qwenHome(env) {
-    const home = process.platform === "win32"
-        ? env.USERPROFILE || env.HOME || homedir()
-        : env.HOME || env.USERPROFILE || homedir();
-    return join(home, ".qwen");
-}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function qwenModelLabel(id, name) {
-    if (!name || name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()))
-        return id;
-    return `${id} — ${name}`;
-}
 const PROTOCOLS = new Set(["openai", "anthropic", "gemini", "vertex-ai"]);
 function readQwenRoutes(env) {
     let settings;
     try {
-        settings = JSON.parse(readFileSync(join(qwenHome(env), "settings.json"), "utf8"));
+        settings = JSON.parse(readFileSync(join(harnessHome("qwen", env), "settings.json"), "utf8"));
     }
     catch {
         return [];
@@ -102,7 +92,11 @@ function readQwenRoutes(env) {
 /** Public metadata only. Use Qwen's provider-qualified ACP selectors, not raw model IDs. */
 export function readQwenModelCatalog(env = process.env) {
     const options = readQwenRoutes(env).map(({ id, model, label, provider }) => ({
-        id, label: qwenModelLabel(model, label), custom: true, provider,
+        id,
+        label: qualifiedModelLabel(model, label, {
+            redundantWhen: (id, name) => name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()),
+        }),
+        custom: true, provider,
     }));
     return { default: options[0]?.id ?? "", options };
 }
@@ -117,7 +111,7 @@ export function ensureQwenInjectModel(modelId, env = process.env) {
     const host = localHost(inject.host);
     if (!host)
         return modelId;
-    const dir = qwenHome(env);
+    const dir = harnessHome("qwen", env);
     mkdirSync(dir, { recursive: true });
     const path = join(dir, "settings.json");
     let settings = {};

package/dist-server/server/drivers/agents-call.js

@@ -7,8 +7,10 @@
 // Nothing here reads the environment or holds state of its own. The caller
 // passes a ToolCallContext, and the per-turn counters live on it.
 import { CREDENTIAL_TARGETS, isCredentialTargetId } from "../../shared/credential-request.js";
+import { parseOptionsCardInput, WATCHER_OPTIONS_CARD_BOT_ID } from "../../shared/options-card.js";
 import { normalizeCronSchedule } from "../../shared/routine-schedule.js";
 import { peerName } from "../peer-roster.js";
+import { renderPeerDeliveryReceipts } from "../peer-delivery.js";
 import { catalogProfileFromEnv, SHARED_COMPUTER_TOOL_NAMES, WEEKDAYS } from "./agents-catalog.js";
 import { harnessClientFromEnv } from "./agents-client.js";
 import { boundedAgentResult } from "./agents-result.js";
@@ -352,12 +354,95 @@ function recallSpeaker(hit) {
         return hit.from;
     return hit.role === "user" ? "user" : "you";
 }
+const isPeerDeliveryOutcome = (value) => value === "queued" || value === "injected" || value === "failed";
+/** The delivery receipt a peer-send answer carries, as one prose line.
+ * Unvalidated JSON stays out: a malformed receipt renders nothing rather
+ * than half a line of somebody else's text. */
+function deliveryNote(r) {
+    const receipt = r.receipt;
+    if (!receipt || typeof receipt !== "object")
+        return "";
+    const { botId, botName, outcome, detail, taskId, requestId } = receipt;
+    if (typeof botId !== "string" || !botId || typeof detail !== "string" || !detail)
+        return "";
+    if (!isPeerDeliveryOutcome(outcome))
+        return "";
+    const parsed = {
+        botId,
+        ...(typeof botName === "string" && botName ? { botName } : {}),
+        outcome,
+        detail,
+        ...(typeof taskId === "string" && taskId ? { taskId } : {}),
+        ...(typeof requestId === "string" && requestId ? { requestId } : {}),
+    };
+    return renderPeerDeliveryReceipts([parsed]);
+}
+/** When a recalled line was said, on the machine's own clock. `toISOString()`
+ * answers in UTC, which disagrees with every other day the bot is shown: a
+ * bare `since`/`until` date is read as local midnight (recent-work.ts
+ * parseSince), the recent-work brief's times are local (whenLabel), and the
+ * daily memory logs are named after the local day. East of UTC a message
+ * from this morning was being dated yesterday — so a search for today's work
+ * came back stamped with the wrong date. */
+function recallWhen(at, dateOnly) {
+    if (typeof at !== "number" || !Number.isFinite(at))
+        return "";
+    const said = new Date(at);
+    if (!Number.isFinite(said.getTime()))
+        return "";
+    const pad = (value) => String(value).padStart(2, "0");
+    const day = `${said.getFullYear()}-${pad(said.getMonth() + 1)}-${pad(said.getDate())}`;
+    return dateOnly ? day : `${day} ${pad(said.getHours())}:${pad(said.getMinutes())}`;
+}
 export async function callTool(name, args, context) {
     // The names this body has always used, so it reads (and diffs) as it did
     // when these were the proxy's module-level constants.
     const { botId: BOT_ID, threadId: THREAD_ID, depth: DEPTH, externalRuntime: EXTERNAL_RUNTIME, coordinating: COORDINATING, turn } = context;
     const { delegationTaskIdsThisTurn } = turn;
     const { api, apiResponse } = context.client;
+    if (name === "vm_exec") {
+        const { ok, body } = await apiResponse("/api/internal/vm-exec", {
+            method: "POST",
+            body: JSON.stringify({ command: args.command, ...(typeof args.timeout_seconds === "number" ? { timeout_seconds: args.timeout_seconds } : {}) }),
+        });
+        if (!ok)
+            return { text: String(body.error ?? "Could not run that command."), isError: true };
+        const exitCode = Number(body.exitCode ?? 0);
+        const stdout = String(body.stdout ?? "");
+        const stderr = String(body.stderr ?? "");
+        const lines = [body.timedOut ? "The command was stopped: it ran past its time limit." : `exit code ${exitCode}`];
+        if (stdout)
+            lines.push("--- stdout ---", stdout.replace(/\s+$/, ""));
+        if (stderr)
+            lines.push("--- stderr ---", stderr.replace(/\s+$/, ""));
+        if (!stdout && !stderr && !body.timedOut)
+            lines.push("(no output)");
+        return { text: lines.join("\n"), ...(exitCode !== 0 || body.timedOut ? { isError: true } : {}) };
+    }
+    if (name === "attach_file") {
+        const { ok, body } = await apiResponse("/api/internal/attach-file", {
+            method: "POST",
+            body: JSON.stringify({ path: args.path, ...(typeof args.name === "string" ? { name: args.name } : {}) }),
+        });
+        if (!ok)
+            return { text: String(body.error ?? "Could not attach that file."), isError: true };
+        return { text: `Attached ${String(body.name ?? "the file")} (${Number(body.bytes ?? 0)} bytes). It now appears in the chat with a preview.` };
+    }
+    if (name === "create_options_card") {
+        if (BOT_ID !== WATCHER_OPTIONS_CARD_BOT_ID) {
+            return { text: "create_options_card is not enabled for this bot.", isError: true };
+        }
+        const parsed = parseOptionsCardInput(args);
+        if (!parsed.ok)
+            return { text: parsed.error, isError: true };
+        const result = await api("/api/internal/options-card", {
+            method: "POST",
+            body: JSON.stringify(parsed.value),
+        });
+        return {
+            text: `Rendered the native options card in this Watcher thread (message ${String(result.messageId ?? "created")}). Wait for the person's click or custom response; the card itself authorizes no external action.`,
+        };
+    }
     // Second lock. With sharing off the tool is not in the catalog, so a front
     // end already refuses the call as an unknown tool — the same answer a build
     // without the feature gives. This keeps the handler itself refusing if that
@@ -467,6 +552,7 @@ export async function callTool(name, args, context) {
     if (name === "post_to_room") {
         const groupId = String(args.group_id ?? "").trim();
         const message = String(args.message ?? "").trim();
+        const attachVoiceNote = args.attach_voice_note === true;
         if (!groupId || !message) {
             return { text: "post_to_room needs group_id (from list_rooms) and message.", isError: true };
         }
@@ -478,13 +564,13 @@ export async function callTool(name, args, context) {
         }
         const r = await api("/api/internal/post-to-room", {
             method: "POST",
-            body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID, groupId, message }),
+            body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID, groupId, message, attachVoiceNote }),
         });
         if (r.error)
             return { text: String(r.error), isError: true };
         turn.roomPostsThisTurn += 1;
         return {
-            text: `Posted in ${r.roomName ?? "the room"}. Nobody's turn was started, so expect no reply — tell the user it is posted.`,
+            text: `Posted in ${r.roomName ?? "the room"}${r.attachedVoiceNote ? " with the voice note attached" : ""}. Nobody's turn was started, so expect no reply — tell the user it is posted.`,
         };
     }
     if (name === "ask_bot") {
@@ -496,6 +582,7 @@ export async function callTool(name, args, context) {
             method: "POST",
             body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID, toBotId, message, depth: DEPTH }),
         });
+        const note = deliveryNote(r);
         if (r.timeout) {
             // The peer's turn outlived the synchronous wait, so the harness
             // converted the ask into a delegation — the reply is not lost.
@@ -506,10 +593,25 @@ export async function callTool(name, args, context) {
             const amount = waitedSeconds < 60 ? waitedSeconds : Math.round(waitedSeconds / 60);
             const unit = waitedSeconds < 60 ? "second" : "minute";
             return {
-                text: `${r.toBotName ?? "That bot"} is still working after ${amount} ${unit}${amount === 1 ? "" : "s"} — the ask was converted to a delegation so the reply is not lost. Task id: ${taskId}. ${EXTERNAL_RUNTIME ? EXTERNAL_STATUS_GUIDANCE : "Finish your turn now; the result will be delivered to this conversation automatically. Use check_delegation in a later turn only if the user asks for status."}`,
+                text: `${r.toBotName ?? "That bot"} is still working after ${amount} ${unit}${amount === 1 ? "" : "s"} — the ask was converted to a delegation so the reply is not lost. Task id: ${taskId}. ${EXTERNAL_RUNTIME ? EXTERNAL_STATUS_GUIDANCE : "Finish your turn now; the result will be delivered to this conversation automatically. Use check_delegation in a later turn only if the user asks for status."}${note ? `\n\n${note}` : ""}`,
             };
         }
         if (r.busy) {
+            // Aside lane: the teammate was mid-turn on a seam-capable engine, so
+            // the harness folded the message into their running work as peer
+            // context. No new turn started and no reply is coming back through
+            // this call — the receipt says whether the words are already in the
+            // live turn or waiting for it to settle.
+            if (r.aside === "injected") {
+                return {
+                    text: `${r.toBotName ?? "That bot"} is mid-turn; your message was handed to them as an aside — peer context folded into their current work, not a request that interrupts or replies. Finish your turn and treat their eventual output as possibly informed by it.`,
+                };
+            }
+            if (r.aside === "queued") {
+                return {
+                    text: `${r.toBotName ?? "That bot"} is mid-turn; your aside is queued and will reach them as context when the turn settles. No reply is expected — finish your turn.`,
+                };
+            }
             // The harness queues the message as a delegation when it can; the
             // task id is the asker's claim ticket for the eventual reply.
             const taskId = String(r.taskId ?? "").trim();
@@ -517,14 +619,14 @@ export async function callTool(name, args, context) {
                 if (!EXTERNAL_RUNTIME)
                     delegationTaskIdsThisTurn.add(taskId);
                 return {
-                    text: `${r.toBotName ?? "That bot"} is busy right now, so your message was queued as a delegation instead — ${EXTERNAL_RUNTIME ? "it waits for the peer and any required approval" : "it runs after your current turn ends"}. Task id: ${taskId}. ${EXTERNAL_RUNTIME ? EXTERNAL_STATUS_GUIDANCE : "Finish your turn now; the result will be delivered to this conversation automatically. Use check_delegation in a later turn only if the user asks for status."}`,
+                    text: `${r.toBotName ?? "That bot"} is busy right now, so your message was queued as a delegation instead — ${EXTERNAL_RUNTIME ? "it waits for the peer and any required approval" : "it runs after your current turn ends"}. Task id: ${taskId}. ${EXTERNAL_RUNTIME ? EXTERNAL_STATUS_GUIDANCE : "Finish your turn now; the result will be delivered to this conversation automatically. Use check_delegation in a later turn only if the user asks for status."}${note ? `\n\n${note}` : ""}`,
                 };
             }
-            return { text: `That bot is busy right now — try again after it finishes.` };
+            return { text: `That bot is busy right now — try again after it finishes.${note ? `\n\n${note}` : ""}` };
         }
         if (r.error)
-            return { text: `Couldn't reach that bot: ${r.error}`, isError: true };
-        return { text: `${r.botName ?? "Bot"} replied:\n${r.text ?? "(no reply)"}` };
+            return { text: `Couldn't reach that bot: ${r.error}${note ? `\n\n${note}` : ""}`, isError: true };
+        return { text: `${r.botName ?? "Bot"} replied:\n${r.text ?? "(no reply)"}${note ? `\n\n${note}` : ""}` };
     }
     if (name === "delegate_bot") {
         const toBotId = String(args.bot_id ?? "").trim();
@@ -542,8 +644,9 @@ export async function callTool(name, args, context) {
         if (reason)
             body.reason = reason;
         const r = await api(`/api/internal/delegate-bot`, { method: "POST", body: JSON.stringify(body) });
+        const delivery = deliveryNote(r);
         if (r.error)
-            return { text: `Couldn't queue the delegation: ${r.error}`, isError: true };
+            return { text: `Couldn't queue the delegation: ${r.error}${delivery ? `\n\n${delivery}` : ""}`, isError: true };
         // Fire-and-forget by contract: the harness returns immediately, the
         // peer turn runs after our current turn finishes. The task id is the
         // bot's claim ticket for the outcome.
@@ -554,7 +657,7 @@ export async function callTool(name, args, context) {
         const suffix = taskId
             ? ` Task id: ${taskId}. ${EXTERNAL_RUNTIME ? EXTERNAL_STATUS_GUIDANCE : "Acknowledge the assignment and finish your turn; the result will be delivered to this conversation automatically. Do not check or wait for it in this turn."}`
             : "";
-        return { text: `${note}${suffix}` };
+        return { text: `${note}${suffix}${delivery ? `\n\n${delivery}` : ""}` };
     }
     if (name === "check_delegation" || name === "wait_delegation") {
         const taskId = String(args.task_id ?? "").trim();
@@ -727,11 +830,13 @@ export async function callTool(name, args, context) {
                 name: botName,
                 role,
                 instructions,
+                ...(args.modelSelection !== undefined ? { modelSelection: args.modelSelection } : {}),
+                ...(typeof args.cwd === "string" ? { cwd: args.cwd.trim() } : {}),
             }),
         });
         turn.createdThisTurn += 1;
         return {
-            text: `Created @${r.name ?? botName} in ${r.section ?? "General"} [id: ${r.id}]. Assign work with ${COORDINATING ? "coordinate_bots" : "delegate_bot"}.`,
+            text: `Created @${r.name ?? botName} in ${r.section ?? "General"} [id: ${r.id}].${r.modelSelection ? ` Model: ${JSON.stringify(r.modelSelection)}.` : ""} Assign work with ${COORDINATING ? "coordinate_bots" : "delegate_bot"}.`,
         };
     }
     if (name === "create_room") {
@@ -816,6 +921,27 @@ export async function callTool(name, args, context) {
             text: `A secure ${r.label ?? CREDENTIAL_TARGETS[credentialId].label} request is ready. The desktop app and a freshly QR-paired mobile app show its secure entry card; older mobile pairings explain how to pair again or finish on the computer. End this turn; OpenMausBot will resume the task after the user saves or declines. Never ask them to paste the key into chat.`,
         };
     }
+    if (name === "send_voice_note") {
+        if (typeof args.text !== "string" || !args.text.trim()) {
+            return { text: "send_voice_note needs text: the short speakable note, at most 1000 characters.", isError: true };
+        }
+        const text = args.text.trim();
+        if (text.length > 1000) {
+            return { text: `send_voice_note is limited to 1000 characters; this one is ${text.length}. Shorten the note.`, isError: true };
+        }
+        try {
+            await api("/api/internal/voice-note", {
+                method: "POST",
+                body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID, text }),
+            });
+            return { text: "Voice note recorded. It will be attached to this turn's reply when the turn ends; the note text is also the visible caption." };
+        }
+        catch (error) {
+            // A missing voice setup is the user's to fix, not a failed turn: hand
+            // the harness's setup guidance straight to the model.
+            return { text: `Voice note not sent: ${error instanceof Error ? error.message : String(error)}`, isError: true };
+        }
+    }
     if (name === "list_routines") {
         const query = new URLSearchParams({ fromBotId: BOT_ID, fromThreadId: THREAD_ID });
         const r = await api(`/api/internal/routines?${query.toString()}`);
@@ -884,6 +1010,13 @@ export async function callTool(name, args, context) {
         return confirmationResult(r, `${action.replace("_", " ")} on routine ${routineId}`);
     }
     if (name === "propose_profile") {
+        // A non-boolean toggle would be dropped silently while any valid half of
+        // the request went through, applying a partial proposal the model never
+        // described. Reject the whole call instead.
+        if ((args.notifications !== undefined && typeof args.notifications !== "boolean")
+            || (args.speakReplies !== undefined && typeof args.speakReplies !== "boolean")) {
+            return { text: "propose_profile notifications and speakReplies must be true or false.", isError: true };
+        }
         const changes = {};
         if (typeof args.name === "string")
             changes.name = args.name.trim();
@@ -895,8 +1028,12 @@ export async function callTool(name, args, context) {
             changes.soul = args.soul;
         if (typeof args.cwd === "string")
             changes.cwd = args.cwd.trim();
+        if (typeof args.notifications === "boolean")
+            changes.notifications = args.notifications;
+        if (typeof args.speakReplies === "boolean")
+            changes.speakReplies = args.speakReplies;
         if (!Object.keys(changes).length) {
-            return { text: "propose_profile needs at least one of name, title, description, soul, or cwd.", isError: true };
+            return { text: "propose_profile needs at least one of name, title, description, soul, cwd, notifications, or speakReplies.", isError: true };
         }
         const forBotId = String(args.for_bot_id ?? "").trim();
         const r = await api("/api/internal/profile-requests", {
@@ -912,6 +1049,35 @@ export async function callTool(name, args, context) {
         });
         return confirmationResult(r, "the profile change", "profile");
     }
+    if (name === "propose_model") {
+        const raw = args.model_selection;
+        const fields = typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : null;
+        if (!fields || typeof fields.instanceId !== "string" || !fields.instanceId.trim() || typeof fields.model !== "string" || !fields.model.trim()) {
+            return { text: "propose_model needs model_selection with instanceId and model.", isError: true };
+        }
+        if ((fields.effort !== undefined && (typeof fields.effort !== "string" || !fields.effort.trim()))
+            || (fields.variant !== undefined && (typeof fields.variant !== "string" || !fields.variant.trim()))) {
+            return { text: "propose_model effort and variant must be non-empty strings when supplied.", isError: true };
+        }
+        const selection = { instanceId: fields.instanceId.trim(), model: fields.model.trim() };
+        if (typeof fields.effort === "string" && fields.effort.trim())
+            selection.effort = fields.effort.trim();
+        if (typeof fields.variant === "string" && fields.variant.trim())
+            selection.variant = fields.variant.trim();
+        const forBotId = String(args.for_bot_id ?? "").trim();
+        const r = await api("/api/internal/model-requests", {
+            method: "POST",
+            body: JSON.stringify({
+                fromBotId: BOT_ID,
+                fromThreadId: THREAD_ID,
+                modelSelection: selection,
+                reason: args.reason,
+                // JSON.stringify drops the key entirely when no target was named
+                forBotId: forBotId || undefined,
+            }),
+        });
+        return confirmationResult(r, "the default model change", "model");
+    }
     if (name === "memory_update") {
         if (!["append", "replace", "remove", "supersede"].includes(String(args.action))
             || (args.action !== "remove" && (typeof args.text !== "string" || !args.text.trim()))
@@ -1008,7 +1174,7 @@ export async function callTool(name, args, context) {
         }
         const lines = hits.map((hit) => {
             // a listing by time shows the time; a search by words keeps the date
-            const when = typeof hit.at === "number" ? new Date(hit.at).toISOString().slice(0, q ? 10 : 16).replace("T", " ") : "";
+            const when = recallWhen(hit.at, Boolean(q));
             const task = typeof hit.task === "string" && hit.task ? `task "${hit.task}"` : "an earlier task";
             const where = hit.current
                 ? "this conversation"
@@ -1040,7 +1206,7 @@ export async function callTool(name, args, context) {
         catch (error) {
             return { text: `Couldn't read that message: ${error instanceof Error ? error.message : String(error)}. Use ids from a session_search hit.`, isError: true };
         }
-        const when = typeof r.at === "number" ? new Date(r.at).toISOString().slice(0, 10) : "";
+        const when = recallWhen(r.at, true);
         const readTask = typeof r.task === "string" && r.task ? `task "${r.task}"` : "an earlier task";
         const where = threadId === THREAD_ID ? "this conversation" : r.crossed ? `${readTask}, private to this user` : readTask;
         const note = r.crossed