@bivy/bivy 0.18.11-staging.12 → 0.18.11-staging.14

package/bin/bivy.mjs

@@ -2506,7 +2506,8 @@ async function cmdDelegate(args = []) {
     if (!res.ok) throw new Error(data?.error || `HTTP ${res.status}`);
     return data;
   };
-  const terminal = (run) => ["succeeded", "failed", "cancelled"].includes(run?.status);
+  // needs_attention = parked by the machine's policy; it won't move on its own.
+  const terminal = (run) => ["succeeded", "failed", "cancelled", "needs_attention"].includes(run?.status);
   // The node caps one wait at 300s; loop until the child ends or our budget does.
   const waitFor = async (runId, seconds) => {
     const deadline = Date.now() + seconds * 1000;

package/dist/run-tools.js

@@ -12,6 +12,9 @@ export const RUN_TOOL_LIMITS = {
     maxAnswer: 8_000,
 };
 const TERMINAL = new Set(["succeeded", "failed", "cancelled"]);
+// Parked by the node's policy (usage limit, missing credentials): it won't
+// progress without a person, so waiting ends there and the reason comes back.
+const SETTLED = new Set([...TERMINAL, "needs_attention"]);
 const STATUSES = new Set(["pending", "claimed", "running", "waiting", "needs_attention", "succeeded", "failed", "cancelled"]);
 const SOURCE_PREFIX = "agent-delegation:v1:";
 const bounded = (v, n) => typeof v === "string" && v ? v.slice(0, n) : undefined;
@@ -109,7 +112,7 @@ export class RunDelegationService {
         if (!raw || provenance?.parentSessionId !== sessionId)
             throw new Error("delegated Run not found");
         const value = safeRun(raw, provenance);
-        if (TERMINAL.has(value.status) && this.backend.answer) {
+        if (SETTLED.has(value.status) && this.backend.answer) {
             // Best-effort: an unreachable machine still leaves status + references.
             const answer = cached?.value.answer ?? await this.backend.answer(raw).catch(() => undefined);
             if (answer)
@@ -155,7 +158,7 @@ export class RunDelegationService {
             if (signal?.aborted)
                 throw signal.reason ?? new Error("wait cancelled; the child Run may still be running");
             const result = await this.authorized(sessionId, runId, true);
-            if (TERMINAL.has(result.status))
+            if (SETTLED.has(result.status))
                 return result;
             if (this.now() >= deadline)
                 return { ...result, timedOut: true, wait: { timedOut: true, childContinues: true } };

package/dist/server.js

@@ -545,7 +545,10 @@ const runDelegation = new RunDelegationService({
             method: "POST",
             body: JSON.stringify({
                 title: "Delegated Run",
-                body: `bivy-room-v1:${targetId}:${seal(pairingStore.roomKey(), input.instructions)}`,
+                // Only the target machine can open its Run body, so seal with ITS room
+                // key: this machine's own for local work, the sibling's (learned over
+                // the sealed pairing handshake) for another machine.
+                body: `bivy-room-v1:${targetId}:${seal(targetId === identity.nodeId ? pairingStore.roomKey() : await siblingRoomKey(targetId), input.instructions)}`,
                 repo: input.repo,
                 node: machine,
                 runtimeId: input.agent,
@@ -605,6 +608,19 @@ async function siblingRequest(nodeId, command, timeoutMs = 20_000) {
         client.close();
     }
 }
+/** Another machine's room key, from a sealed pairing with it. */
+async function siblingRoomKey(nodeId) {
+    if (!sessionAdvertiseTarget)
+        throw new Error("This machine is not signed in to an account.");
+    const client = new SiblingClient({ controlPlaneUrl: sessionAdvertiseTarget.controlPlaneUrl, enrollmentToken: sessionAdvertiseTarget.enrollmentToken, siblingNodeId: nodeId, label: "Bivy delegation" });
+    try {
+        await client.connect();
+        return client.roomKey();
+    }
+    finally {
+        client.close();
+    }
+}
 /** Agents this machine can run a delegated task with (installed ones). */
 function localAgents() {
     return runtimeList().filter((rt) => rt.status === "available").map((rt) => ({ id: rt.id, name: String(rt.displayName || rt.id) }));
@@ -4651,11 +4667,7 @@ async function runIssueTaskInner(cfg, issue, source, overrides = {}) {
     sessionNamer.setSessionName(record, issueSessionTitle(issue));
     // Best-effort model selection for runtimes that support it (e.g. claude-code, pi).
     if (directives.model && typeof record.session.setModel === "function") {
-        try {
-            assertSessionModel(record, directives.model);
-            await record.session.setModel("", directives.model);
-        }
-        catch { }
+        await applyRequestedModel(record, { provider: "", id: directives.model });
     }
     if (!record.worktree)
         throw new Error("worktree was not created for the issue session");
@@ -4850,8 +4862,16 @@ async function runSessionTurn(record, prompt, signal) {
     if (signal?.aborted)
         throw signal.reason ?? new Error("Run cancelled");
     let unsubscribe = () => { };
+    // A turn the agent failed (usage limit, auth, crash) still ends with
+    // agent_end; remember why so the Run fails instead of reporting success.
+    let turnError = "";
     const finished = new Promise((resolve) => {
         unsubscribe = record.session.subscribe((event) => {
+            const e = event;
+            if (e.type === "session.error" && typeof e.error === "string")
+                turnError ||= e.error;
+            if (e.type === "message_end" && e.message?.stopReason === "error" && typeof e.message.errorMessage === "string")
+                turnError ||= e.message.errorMessage;
             if (event.type === "agent_end")
                 resolve();
         });
@@ -4866,6 +4886,8 @@ async function runSessionTurn(record, prompt, signal) {
     try {
         await turnWatchdog.promptWithWatchdog(record, prompt);
         await (signal ? Promise.race([finished, cancelled]) : finished);
+        if (turnError)
+            throw new Error(turnError);
     }
     finally {
         signal?.removeEventListener("abort", onAbort);
@@ -5325,6 +5347,10 @@ async function delegationAnswer(sessionId) {
         const message = messages[i];
         if (message?.role !== "assistant")
             continue;
+        // A turn the agent failed (usage limit, auth) ends on an error marker, not
+        // prose: hand the parent the reason instead of an empty answer.
+        if (message.stopReason === "error" && typeof message.errorMessage === "string" && message.errorMessage.trim())
+            return `The delegated agent failed: ${message.errorMessage.trim()}`;
         const text = runtimeContentText(message.content).trim();
         if (text)
             return text;
@@ -5485,12 +5511,8 @@ async function executeWorkItem(item, report, signal) {
             approvalMode: safety.approval,
         });
         sessionNamer.setSessionName(record, `${issue.identifier}: ${issue.title}`);
-        if (item.model) {
-            try {
-                await record.session.setModel("", item.model);
-            }
-            catch { }
-        }
+        if (item.model)
+            await applyRequestedModel(record, { provider: "", id: item.model });
         await report({ output: { sessionId: record.id, branch }, events: [{ at: new Date().toISOString(), kind: "branch", summary: "Linear issue working branch and session created.", ref: branch, url: issue.url }] });
         await runSessionTurn(record, buildLinearTaskPrompt(issue, item.body), signal);
         if (signal.aborted)
@@ -5567,10 +5589,7 @@ async function executeWorkItem(item, report, signal) {
     sessionNamer.setSessionName(record, item.title);
     persistSessionMetadata(record);
     if (item.model) {
-        try {
-            await record.session.setModel("", item.model);
-        }
-        catch { }
+        await applyRequestedModel(record, { provider: "", id: item.model });
     }
     // Record the session id with the control plane BEFORE the (potentially long)
     // turn runs, not just after it completes. A machine restart mid-turn must leave

package/dist/session/sibling-client.js

@@ -30,6 +30,7 @@ export class SiblingClient {
     opts;
     ws;
     cipher;
+    siblingRoomKey;
     keypair = newDeviceKeypair();
     reassembler = new FrameReassembler({ onReject: () => this.ws?.close() });
     transfers = new EventTransferReceiver({
@@ -147,6 +148,7 @@ export class SiblingClient {
         if (k === "pair.welcome") {
             try {
                 const roomKey = acceptWelcome(this.keypair, { nodePublicKeyB64: String(p.nodePublicKeyB64 ?? ""), wrapped: String(p.wrapped ?? "") });
+                this.siblingRoomKey = roomKey;
                 this.cipher = new RoomCipher(roomKey);
                 this.resolvePaired?.();
             }
@@ -169,6 +171,13 @@ export class SiblingClient {
         }
         this.opts.onEvent?.(event);
     }
+    /** The sibling's room key, once paired: what seals content only it can read
+     *  (e.g. a delegated Run's instructions queued for that machine). */
+    roomKey() {
+        if (!this.siblingRoomKey)
+            throw new Error("sibling client not paired");
+        return this.siblingRoomKey;
+    }
     /** Send a command and await its correlated reply event (by requestId). */
     request(command, timeoutMs = 30_000) {
         const requestId = `repl-${++this.reqSeq}-${Date.now()}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.18.11-staging.12",
+  "version": "0.18.11-staging.14",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",