@bivy/bivy 0.17.2-staging.2 → 0.17.2-staging.4

package/dist/runtime/model-catalog.js

@@ -134,3 +134,16 @@ export function mergeProviderCatalog(base, catalog) {
     }
     return [...byId.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
+/**
+ * Reply to a models.list query. A catalog read failure must never answer with
+ * silence: the client (notably a Cloud launch validating its saved model) could
+ * only time out without a cause. Name the real reason on the session instead.
+ */
+export async function catalogReplyEvent(load, sessionId) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        return { type: "session.error", sessionId, error: `Couldn't read this machine's model catalog: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}

package/dist/server.js

@@ -3,6 +3,7 @@
 import fs from "node:fs";
 import { createNodeUpdateChecker, updateRegistryUrl } from "./node-update.js";
 import { createRemoteSessionAdmission, RemoteSessionAdmissionError } from "./session/remote-session-admission.js";
+import { requiresExistingSession, resolveTargetSession } from "./session/target-session.js";
 import path from "node:path";
 import os from "node:os";
 import { spawn, spawnSync } from "node:child_process";
@@ -33,7 +34,7 @@ import { AppService } from "./apps/service.js";
 import { createAppCommands } from "./controllers/app-commands.js";
 import { bindClientCommandRoutes } from "./http/client-command-routes.js";
 import { collectDiscoveredSessions, planNativeAdoption } from "./runtime/native-session-discovery.js";
-import { aggregateModelCatalog, mergeProviderCatalog } from "./runtime/model-catalog.js";
+import { aggregateModelCatalog, catalogReplyEvent, mergeProviderCatalog } from "./runtime/model-catalog.js";
 import { RuntimeHost, enforcementLevelFor, remoteRuntimeEnabled } from "./runtime/host.js";
 import { RemoteRuntime, RemoteRuntimeSession } from "./runtime/remote.js";
 import { InMemorySessionLocationRegistry } from "./runtime/session-location.js";
@@ -2453,18 +2454,8 @@ const RELAY_COMMANDS = {
         // this a models.list answered for one agent (e.g. Codex's models) could
         // linger on the composer/picker after the user switched to another agent
         // (e.g. Claude) — the "Claude shows Codex models" bug.
-        let event;
-        try {
-            event = await modelsListEventFor(record);
-        }
-        catch (error) {
-            // A catalog read failure must never answer with silence: the generic
-            // relay catch would swallow the rejection and the client (notably a
-            // Cloud launch waiting to validate its saved model) could only guess
-            // via timeout. Name the real reason on the session instead.
-            relay?.sendEvent({ type: "session.error", sessionId: requestedSessionId ?? record.id, error: `Couldn't read this machine's model catalog: ${error instanceof Error ? error.message : String(error)}` });
-            return;
-        }
+        // A catalog read failure answers with the real error, never silence.
+        const event = await catalogReplyEvent(() => modelsListEventFor(record), requestedSessionId ?? record.id);
         relay?.sendEvent(event);
     },
     "models.prefetch"(msg) {
@@ -4915,31 +4906,13 @@ function assertSessionAccounts(record, labels) {
     }
 }
 async function continueCorrelatedSession(item, prompt, report, opts) {
-    if (item.targetKind !== "existing_session" || !item.targetSessionId)
-        return false;
-    let record = openSessions.get(item.targetSessionId);
-    if (!record && opts?.resumeOnMissing) {
-        // Same-node resume: reopen a closed session from its durable metadata +
-        // transcript — exactly how a prompt to an old session from the app is
-        // handled (resolveOrResumeSession). Best-effort: an unresolvable session
-        // falls through to the snapshot restore / fail handling below.
-        record = await resolveOrResumeSession(item.targetSessionId).catch(() => undefined);
-    }
-    if (!record) {
-        const restored = await restoreSessionFromSnapshot(item.targetSessionId);
-        if (restored)
-            record = await resolveOrResumeSession(item.targetSessionId).catch(() => undefined);
-    }
-    if (!record) {
-        // Strict mode (a scheduled message to a specific session): the session must
-        // be resumed in place, so a genuinely-unavailable one is surfaced as a
-        // failed run rather than silently starting a new session. Everything else
-        // keeps the established best-effort fall-through to a fresh pickup.
-        if (opts?.resumeOnMissing) {
-            throw new Error(`This Run could not continue session ${item.targetSessionId}: the session is not available on this Machine`);
-        }
+    const record = await resolveTargetSession(item, {
+        open: (id) => openSessions.get(id),
+        resume: (id) => resolveOrResumeSession(id),
+        restoreSnapshot: async (id) => Boolean(await restoreSessionFromSnapshot(id)),
+    }, opts?.resumeOnMissing === true);
+    if (!record)
         return false;
-    }
     assertSessionAccounts(record, opts?.credentialLabels);
     const branch = record.worktree?.branch;
     if (opts?.resumeOnMissing) {
@@ -5189,7 +5162,7 @@ async function executeWorkItem(item, report, signal) {
     // Scheduled runs targeting an existing session are STRICT: the message must
     // land in that session (resumed from disk if needed), never silently in a new
     // one — so a session that can't be resumed fails the run instead.
-    if (await continueCorrelatedSession(item, request, report, { resumeOnMissing: item.source === "schedule" || item.targetKind === "existing_session", isMessage, signal, credentialLabels }))
+    if (await continueCorrelatedSession(item, request, report, { resumeOnMissing: requiresExistingSession(item), isMessage, signal, credentialLabels }))
         return;
     const requestedSandbox = normalizeSandboxTier(item.sandbox);
     // Prepare an explicit repository before resolving its policy. Otherwise a

package/dist/session/target-session.js

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Resolving the Session a durable Run targets. A Run aimed at an existing
+// Session (or any scheduled Run) is strict: it continues that Session, resumed
+// from disk or a snapshot if needed, or fails visibly. It never silently cold-
+// starts a new Session without the context the user pointed it at.
+/** Scheduled Runs and Runs aimed at an existing Session must land in that Session. */
+export function requiresExistingSession(item) {
+    return item.source === "schedule" || item.targetKind === "existing_session";
+}
+/**
+ * The targeted Session, or null when the item targets none or (non-strict) it is
+ * unavailable, in which case the caller falls through to a fresh pickup. Throws
+ * when a strict target cannot be continued.
+ */
+export async function resolveTargetSession(item, resolvers, strict) {
+    if (item.targetKind !== "existing_session" || !item.targetSessionId)
+        return null;
+    const id = item.targetSessionId;
+    let record = resolvers.open(id);
+    if (!record && strict)
+        record = await resolvers.resume(id).catch(() => undefined);
+    if (!record && await resolvers.restoreSnapshot(id))
+        record = await resolvers.resume(id).catch(() => undefined);
+    if (record)
+        return record;
+    if (strict)
+        throw new Error(`This Run could not continue session ${id}: the session is not available on this Machine`);
+    return null;
+}

package/package.json

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