openmausbot 0.1.93 → 0.1.94

package/dist-server/server/decision-log.js

@@ -65,9 +65,10 @@ export function decisionRetentionDays(configured, env = process.env) {
 }
 const actorScope = new AsyncLocalStorage();
 /** Run `work` as a person's card answer: every `source: "user"` row it
- * writes names `actor`, without each resolver having to thread it through. */
-export function withDecisionActor(actor, work) {
-    return actorScope.run(actor, work);
+ * writes names `actor` (and `via`, for an answer spoken on a Live call),
+ * without each resolver having to thread it through. */
+export function withDecisionActor(actor, work, via) {
+    return actorScope.run(via ? { actor, via } : { actor }, work);
 }
 function monthKey(at) {
     return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
@@ -88,10 +89,12 @@ async function writeDecision(dataDir, record) {
  * the fold that calls this is delivering approvals and cards, and a full
  * disk must not turn into denied tools. */
 export function appendDecision(dataDir, row) {
-    const actor = row.actor ?? (row.source === "user" ? actorScope.getStore() : undefined);
+    const scope = row.source === "user" ? actorScope.getStore() : undefined;
+    const actor = row.actor ?? scope?.actor;
+    const via = row.via ?? scope?.via;
     // Redact now, not when the queue drains: the row is what was true at the
     // moment of the decision.
-    const record = redactSecrets({ at: new Date().toISOString(), ...row, ...(actor ? { actor } : {}) });
+    const record = redactSecrets({ at: new Date().toISOString(), ...row, ...(actor ? { actor } : {}), ...(via ? { via } : {}) });
     const previous = writeQueues.get(dataDir) ?? Promise.resolve();
     // Serialize appends (and the occasional prune) per directory, so two
     // simultaneous approvals keep their decision order.
@@ -258,7 +261,7 @@ export function decisionsCsv(rows) {
             row.summary ?? "",
             row.rule ?? "",
             row.unattended ? "yes" : "",
-            actorLabel(row.actor),
+            row.via === "call" ? `${actorLabel(row.actor)} (by voice)` : actorLabel(row.actor),
             row.threadId,
             row.requestId ?? "",
         ].map(csvCell).join(","));

package/dist-server/server/delegations.js

@@ -192,6 +192,8 @@ export function _loadPending() {
                 if (typeof item.targetThreadId === "string" && item.targetThreadId) {
                     loaded.targetThreadId = item.targetThreadId;
                 }
+                if (item.oneWay === true)
+                    loaded.oneWay = true;
                 return [loaded];
             });
             if (items.length)
@@ -268,7 +270,7 @@ const MAX_QUEUED_PER_THREAD = 6;
 export function queueDelegation(bus, from, item, maxDepth, sourceThreadId = from.threadId) {
     if (item.toBotId === from.id)
         return { result: "self" };
-    if (item.depth >= maxDepth)
+    if (!item.oneWay && item.depth >= maxDepth)
         return { result: "too_deep" };
     const target = bus.store.bot(item.toBotId);
     if (!target)
@@ -347,6 +349,11 @@ onSettled) {
             const from = bus.store.botByThread(threadId) ??
                 bus.store.bot(item.sourceBotId);
             if (!from) {
+                appendDeliveryMessage(bus, threadId, item, {
+                    role: "bot",
+                    kind: "activity",
+                    tool: { name: "Send failed — the sending bot no longer exists", ok: false },
+                });
                 recordDelegationReceipt({
                     id: item.id,
                     sourceThreadId: threadId,
@@ -373,7 +380,7 @@ onSettled) {
                     result: why.slice(0, 200),
                 });
                 try {
-                    bus.store.appendMessage(threadId, {
+                    appendDeliveryMessage(bus, threadId, item, {
                         role: "bot",
                         kind: "activity",
                         tool: { name: `error: delegation failed — ${why.slice(0, 120)}`, ok: false },
@@ -393,7 +400,7 @@ onSettled) {
                 if (outcome === "settled" && stillQueued) {
                     const receipt = findDelegationReceipt(item.id);
                     try {
-                        if (receipt)
+                        if (receipt && !item.oneWay)
                             onSettled?.(receipt);
                     }
                     catch (error) {
@@ -428,6 +435,15 @@ function acknowledgeDelegation(threadId, itemId) {
         pendingDelegations.delete(threadId);
     savePending();
 }
+function appendDeliveryMessage(bus, sourceThreadId, item, message) {
+    const threadId = item.oneWay && item.targetThreadId && bus.store.taskByThread(item.toBotId, item.targetThreadId)
+        ? item.targetThreadId : sourceThreadId;
+    // A failed independent send needs a visible receipt, not a source wake.
+    // Never recreate a deleted conversation just to post that failure.
+    if (item.oneWay && threadId === sourceThreadId && !sourceThreadBelongsToBot(bus.store, item.sourceBotId, sourceThreadId))
+        return;
+    bus.store.appendMessage(threadId, message);
+}
 const isExpired = (item, now) => now - item.queuedAt >= DELEGATION_TTL_MS;
 /** Past the busy-hold cap — the tighter bound that fires while its target is
  * still busy, long before the 24-hour window. */
@@ -457,9 +473,9 @@ function expireDelegation(bus, sourceThreadId, item, ownerId) {
         status: "expired",
         result: busyHold ? `@${name} was still busy after ${busyHoldCapText()}` : `@${name} was not free to take this for 24 hours`,
     });
-    if (!sourceThreadBelongsToBot(bus.store, ownerId, sourceThreadId))
+    if (!item.oneWay && !sourceThreadBelongsToBot(bus.store, ownerId, sourceThreadId))
         return;
-    bus.store.appendMessage(sourceThreadId, {
+    appendDeliveryMessage(bus, sourceThreadId, item, {
         role: "bot",
         kind: "activity",
         tool: {
@@ -511,15 +527,16 @@ export function expireStaleDelegations(bus, now, onSettled) {
             expireDelegation(bus, threadId, item, ownerId ?? item.sourceBotId);
             const receipt = findDelegationReceipt(item.id);
             if (receipt)
-                expired.push(receipt);
+                expired.push({ receipt, oneWay: item.oneWay === true });
         }
     }
     if (!expired.length)
         return 0;
     savePending();
-    for (const receipt of expired) {
+    for (const { receipt, oneWay } of expired) {
         try {
-            onSettled?.(receipt);
+            if (!oneWay)
+                onSettled?.(receipt);
         }
         catch (error) {
             console.error("delegation expired but its source could not be resumed", error);
@@ -533,9 +550,14 @@ export function discardDelegations(bus, threadId) {
     const list = pendingDelegations.get(threadId);
     if (!list?.length)
         return;
-    pendingDelegations.delete(threadId);
+    const kept = list.filter(item => item.oneWay);
+    const dropped = list.filter(item => !item.oneWay);
+    if (kept.length)
+        pendingDelegations.set(threadId, kept);
+    else
+        pendingDelegations.delete(threadId);
     savePending();
-    for (const item of list) {
+    for (const item of dropped) {
         recordDelegationReceipt({
             id: item.id,
             sourceThreadId: threadId,
@@ -545,14 +567,16 @@ export function discardDelegations(bus, threadId) {
             result: "the delegating turn did not finish",
         });
     }
+    if (!dropped.length)
+        return;
     const from = bus.store.botByThread(threadId) ??
-        bus.store.bot(list.find((item) => bus.store.bot(item.sourceBotId))?.sourceBotId ?? list[0].sourceBotId);
+        bus.store.bot(dropped.find((item) => bus.store.bot(item.sourceBotId))?.sourceBotId ?? dropped[0].sourceBotId);
     if (!from)
         return;
     bus.store.appendMessage(threadId, {
         role: "bot",
         kind: "activity",
-        tool: { name: `${list.length} queued delegation${list.length > 1 ? "s" : ""} dropped — the turn did not finish`, ok: false },
+        tool: { name: `${dropped.length} queued delegation${dropped.length > 1 ? "s" : ""} dropped — the turn did not finish`, ok: false },
     });
 }
 async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarget) {
@@ -560,7 +584,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     let target = bus.store.bot(item.toBotId);
     // Retained approval authorizes the message, not a deleted conversation or
     // revoked room membership. Check every retry before writing to its source.
-    if (!sourceThreadBelongsToBot(bus.store, sender.id, sourceThreadId)) {
+    if (!item.oneWay && !sourceThreadBelongsToBot(bus.store, sender.id, sourceThreadId)) {
         recordDelegationReceipt({
             id: item.id,
             sourceThreadId,
@@ -580,7 +604,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
             status: "error",
             result: "no such bot",
         });
-        bus.store.appendMessage(sourceThreadId, {
+        appendDeliveryMessage(bus, sourceThreadId, item, {
             role: "bot",
             kind: "activity",
             tool: { name: `error: delegation to ${item.toBotId} failed — no such bot`, ok: false },
@@ -621,7 +645,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
         // a denial, which otherwise recreates a deleted source transcript.
         const current = bus.store.bot(item.toBotId);
         const currentSender = bus.store.bot(from.id);
-        if (!current || !currentSender || !sourceThreadBelongsToBot(bus.store, currentSender.id, sourceThreadId)) {
+        if (!current || !currentSender || (!item.oneWay && !sourceThreadBelongsToBot(bus.store, currentSender.id, sourceThreadId))) {
             recordDelegationReceipt({
                 id: item.id,
                 sourceThreadId,
@@ -644,7 +668,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
                 approvalOutcome: verdict,
                 result: verdict === "deny" ? "the user denied this handoff" : failure.error,
             });
-            bus.store.appendMessage(sourceThreadId, {
+            appendDeliveryMessage(bus, sourceThreadId, item, {
                 role: "bot",
                 kind: "activity",
                 tool: { name: verdict === "deny" ? `Delegation to @${target.name} denied by user`
@@ -682,8 +706,9 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     // members; otherwise the exchange falls back to the pair DM.
     const originatingGroup = (item.originatingGroupId ? bus.store.group(item.originatingGroupId) : undefined) ??
         (sourceThreadId ? bus.store.groupByThread(sourceThreadId) : undefined);
-    const channel = getOrCreateChannel(bus.store, sender, target, originatingGroup);
-    mirrorExchange(bus, sender, target, item.message, channel, sourceThreadId);
+    const channel = item.oneWay ? undefined : getOrCreateChannel(bus.store, sender, target, originatingGroup);
+    if (channel)
+        mirrorExchange(bus, sender, target, item.message, channel, sourceThreadId);
     const reasonLine = item.reason ? `\n\n[Reason: ${item.reason}]` : "";
     // A fresh thread's first line gets the shared peer-provenance note from
     // the harness (which knows whether the opener was unattended); the
@@ -691,7 +716,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     const prefixed = item.targetThreadId
         ? item.message
         : `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
-    await runTarget(item.toBotId, prefixed, item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId);
+    await runTarget(item.toBotId, prefixed, item.oneWay ? 0 : item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId, item.oneWay === true);
     return "dispatched";
 }
 /** "Is the target free to take this handoff right now?" Both shapes ask for
@@ -723,7 +748,7 @@ function holdWhileTargetBusy(bus, target, sourceThreadId, item, canTakeTurn = ta
     item.busySince = Date.now();
     if (!item.waitAnnounced) {
         item.waitAnnounced = true;
-        bus.store.appendMessage(sourceThreadId, {
+        appendDeliveryMessage(bus, sourceThreadId, item, {
             role: "bot",
             kind: "activity",
             tool: { name: waitingChipText(bus.store, target, item) },
@@ -757,7 +782,7 @@ function dropIfThreadGone(bus, target, sourceThreadId, item) {
         status: "dropped",
         result: `the thread opened on @${target.name} was deleted before it could start`,
     });
-    bus.store.appendMessage(sourceThreadId, {
+    appendDeliveryMessage(bus, sourceThreadId, item, {
         role: "bot",
         kind: "activity",
         tool: { name: `Thread on @${target.name} canceled — it was deleted before it could start`, ok: false },
@@ -795,7 +820,7 @@ function dropIfUnreachable(bus, sender, target, sourceThreadId, item) {
         status: "dropped",
         result,
     });
-    bus.store.appendMessage(sourceThreadId, {
+    appendDeliveryMessage(bus, sourceThreadId, item, {
         role: "bot",
         kind: "activity",
         tool: { name: `Delegation to @${target.name} canceled — ${reason}`, ok: false },

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

@@ -41,6 +41,12 @@ import { classifyQuiet, describeQuiet, lastSeenPhrase, LogTail, quietKey, sample
 export function skipSubscriptionAuthForLocalInject(model) {
     return Boolean(decodeInjectId(model));
 }
+/** A catalog can contain credential-bearing native configuration, including late replies. */
+export function acpNativeIncomingLogMessage(message, privateResponses) {
+    if (!privateResponses.has(message?.id))
+        return message;
+    return { jsonrpc: message.jsonrpc, id: message.id, ...(message.error !== undefined ? { error: "[MCP catalog error omitted]" } : { result: "[MCP catalog omitted]" }) };
+}
 import { newEventId, newId, TurnNotStartedError } from "../../contracts.js";
 import { augmentedPath } from "../../env-path.js";
 import { supportsApprovalMode } from "../../../shared/approval-mode.js";
@@ -53,6 +59,8 @@ import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { sessionIdlePolicy } from "../session-idle.js";
 import { classifyError } from "../retry.js";
+import { canUseMcpServer, narrowsNativeTools, parseToolScope } from "../../../shared/tool-scope.js";
+import { gateServer } from "../../mcp-gate-config.js";
 const ACCOUNT_ERROR_CODES = new Set([
     "invalid_credentials", "inactive_subscription", "insufficient_funds", "quota_or_region_restriction",
 ]);
@@ -133,6 +141,18 @@ function trackRunningTool(current, update, defaultStatus) {
     else if (status === "pending" || status === "in_progress")
         current.runningTools.add(update.toolCallId);
 }
+let unkeyedToolSeq = 0;
+/** Stamp an unkeyed `tool_call` with a synthetic id and queue it for the
+ * call's first terminal update, which carries no id of its own to match.
+ * FIFO is the best available pairing when the agent omits `toolCallId`:
+ * the ids exist to pair start with completion, not to order concurrent
+ * unkeyed calls, and the synthetic id deliberately stays out of
+ * `runningTools` so turn-settle semantics are unchanged. */
+function nextUnkeyedToolId(current) {
+    const id = `acp-tool-unkeyed-${++unkeyedToolSeq}`;
+    current.unkeyedToolIds.push(id);
+    return id;
+}
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 function acpVariantOption(result) {
     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.type === "select" && typeof entry.id === "string"
@@ -509,7 +529,18 @@ export function createAcpDriver(support) {
                     }
                     servers.push({ name, command: server.command, args: server.args, env: acpEnv(server.env) });
                 }
-                return servers;
+                if (turn.toolScope === undefined)
+                    return servers;
+                return servers.filter((server) => canUseMcpServer(turn.toolScope, server.name)).map((server) => {
+                    const original = "url" in server
+                        ? { type: server.type, url: server.url, headers: Object.fromEntries(server.headers.map(({ name, value }) => [name, value])) }
+                        : { command: server.command, args: server.args, env: Object.fromEntries(server.env.map(({ name, value }) => [name, value])) };
+                    const gated = gateServer({ name: server.name, server: original, threadId: turn.threadId, budget: 0,
+                        toolScope: turn.toolScope, nodeEnv: { ELECTRON_RUN_AS_NODE: "1" } });
+                    if (!gated)
+                        throw new Error("Tool selection requires an MCP gate.");
+                    return { name: server.name, command: gated.command, args: gated.args, env: acpEnv(gated.env) };
+                });
             };
             /** While a prompt runs, notice when the agent goes quiet and tell the
              *  person what it is doing: retrying, compressing, waiting on its
@@ -667,6 +698,7 @@ export function createAcpDriver(support) {
                     stdio: ["pipe", "pipe", "pipe"],
                 });
                 let nextId = 1;
+                const privateResponses = new Set();
                 const rpcPending = new Map();
                 const send = (obj) => {
                     // A permission/file response resumes an agent that was waiting on us.
@@ -683,6 +715,8 @@ export function createAcpDriver(support) {
                 };
                 const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => new Promise((resolve, reject) => {
                     const id = nextId++;
+                    if (method === "_x.ai/mcp/list")
+                        privateResponses.add(id);
                     let timer = null;
                     if (timeoutMs) {
                         timer = setTimeout(() => {
@@ -1007,7 +1041,7 @@ export function createAcpDriver(support) {
                                 ...base(threadId, current.turnId),
                                 type: "item.started",
                                 itemType: "tool",
-                                itemId: u.toolCallId,
+                                itemId: (typeof u.toolCallId === "string" && u.toolCallId) ? u.toolCallId : nextUnkeyedToolId(current),
                                 title: String(u.rawInput?.command ?? u.title ?? "tool").slice(0, 80),
                                 summary: commandSummary(u.rawInput),
                                 input: toolDetailPreview(u.rawInput),
@@ -1022,7 +1056,7 @@ export function createAcpDriver(support) {
                                     ...base(threadId, current.turnId),
                                     type: "item.completed",
                                     itemType: "tool",
-                                    itemId: u.toolCallId,
+                                    itemId: (typeof u.toolCallId === "string" && u.toolCallId) ? u.toolCallId : current.unkeyedToolIds.shift(),
                                     ok: u.status !== "failed",
                                     output: toolDetailPreview(u.rawOutput ?? u.content),
                                 });
@@ -1084,7 +1118,7 @@ export function createAcpDriver(support) {
                         catch {
                             continue;
                         }
-                        appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(msg) });
+                        appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(acpNativeIncomingLogMessage(msg, privateResponses)) });
                         // Inbound traffic proves the child is alive and making progress,
                         // so every idle deadline restarts; only total silence trips it.
                         lastInboundAt = Date.now();
@@ -1160,6 +1194,13 @@ export function createAcpDriver(support) {
                 return session;
             };
             const sendTurn = async (turn) => {
+                const parsedScope = parseToolScope(turn.toolScope);
+                if (!parsedScope.ok)
+                    throw new Error(parsedScope.error);
+                turn = { ...turn, toolScope: parsedScope.scope };
+                if (narrowsNativeTools(turn.toolScope) && !support.toolScopeSessionParams) {
+                    throw new Error(`${support.displayName}: native tool selection is not supported by this engine. Keep native:* in the selection or choose a supported engine.`);
+                }
                 const { threadId } = turn;
                 if (active.has(threadId))
                     throw new Error("a turn is already running on this thread");
@@ -1190,7 +1231,7 @@ export function createAcpDriver(support) {
                 }
                 const resolvedModel = support.resolveTurnModel?.(turn.model, env);
                 support.applyTurnEnv?.(env, {
-                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd,
+                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd, toolScope: turn.toolScope,
                 });
                 // Rebound once, before the prompt, when a fallbackModel support swaps
                 // a model this session does not offer for one it does.
@@ -1234,6 +1275,8 @@ export function createAcpDriver(support) {
                 // riding a child spawned under the old env. Hash it so secrets
                 // never sit in the key itself.
                 const envFingerprint = createHash("sha256").update(JSON.stringify(spawnEnv)).digest("hex").slice(0, 16);
+                const inheritedScopeFingerprint = narrowsNativeTools(turn.toolScope) && support.toolScopeCacheKey
+                    ? createHash("sha256").update(support.toolScopeCacheKey({ config: turnConfig, env, cwd })).digest("hex") : null;
                 // A support that applies the approval mode to the session on every
                 // turn gets the same process whatever the mode: an approval change
                 // is one RPC, not a cold start.
@@ -1241,6 +1284,8 @@ export function createAcpDriver(support) {
                     launch.command, launch.args ?? [], spawnArgs, cwd,
                     support.sessionScopedApproval ? null : turnConfig.fullAuto === true, envFingerprint,
                     support.spawnFingerprint?.(spawnEnv) ?? null,
+                    turn.toolScope ?? null,
+                    inheritedScopeFingerprint,
                 ]);
                 // The new-session default model rides the spawn env but stays out of
                 // the fingerprint above: only session/new reads it, and a pooled
@@ -1259,7 +1304,7 @@ export function createAcpDriver(support) {
                     launchedThisTurn = true;
                     return opened;
                 };
-                const sessionKey = JSON.stringify(mcpServers);
+                const sessionKey = JSON.stringify([mcpServers, turn.toolScope ?? null, inheritedScopeFingerprint]);
                 if (turn.sessionReset) {
                     closeSession(threadId, "reset");
                     sessionAllows.delete(threadId);
@@ -1357,6 +1402,7 @@ export function createAcpDriver(support) {
                     acknowledge,
                     asks,
                     runningTools: new Set(),
+                    unkeyedToolIds: [],
                     interruptTimer: null,
                     stopQuietWatch: null,
                     flushAssistantText,
@@ -1467,10 +1513,12 @@ export function createAcpDriver(support) {
                             // an agent that advertised its transport, so an agent without
                             // http/sse never sees an entry it would refuse the session over
                             const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
+                            const selectionParams = narrowsNativeTools(turn.toolScope)
+                                ? support.toolScopeSessionParams(turn, init, sessionServers.length > 0, { config: turnConfig, env, cwd }) : {};
                             let loaded = false;
                             if (cursor) {
                                 try {
-                                    await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers }, LOAD_SESSION_TIMEOUT, (result) => {
+                                    await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers, ...selectionParams }, LOAD_SESSION_TIMEOUT, (result) => {
                                         if (result) {
                                             loaded = true;
                                             session.sessionId = cursor;
@@ -1526,7 +1574,7 @@ export function createAcpDriver(support) {
                                 promptTurn = { ...turn, text: recovery.text };
                                 rebuiltFromReplay = recovery.replayed;
                             }
-                            sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result) => {
+                            sessionResult = await request("session/new", { cwd, mcpServers: sessionServers, ...selectionParams }, NEW_SESSION_TIMEOUT, (result) => {
                                 session.sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
                                 session.sessionKey = sessionKey;
                                 receiveModelVariants(result);
@@ -1612,6 +1660,7 @@ export function createAcpDriver(support) {
                                     sessionModels: Array.isArray(sessionResult?.models?.availableModels)
                                         ? sessionResult.models.availableModels
                                         : [],
+                                    currentModelId: session.sessionConfigResult?.models?.currentModelId,
                                 });
                                 approvalUnconfirmed = false;
                                 // initialize's currentModelId is the CLI default,