@bivy/bivy 0.5.1-staging.76 → 0.5.1-staging.78

package/dist/runtime/anthropic-preflight.js

@@ -15,6 +15,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { isModelAuthError } from "./auth-errors.js";
 /** Candidate paths for the `claude` CLI's own stored login (`.credentials.json`). */
 export function claudeCredentialFiles(deps = {}) {
     const home = deps.home ?? os.homedir();
@@ -68,7 +69,7 @@ export function anthropicCredentialPreflight(env, deps = {}) {
 }
 /** True when a raw error string looks like an Anthropic auth failure (401 etc.). */
 export function isAnthropicAuthError(raw) {
-    return /\b401\b|unauthorized|authentication|invalid x-api-key|(missing|invalid).*(bearer|api[\s_-]?key|token)/i.test(raw);
+    return isModelAuthError(raw);
 }
 /**
  * Phrase an SDK error for the user: an auth failure gets the sign-in guidance

package/dist/runtime/auth-errors.js

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Classify model auth failures and map a failing session to the provider the
+// user needs to (re)authenticate.
+//
+// When a runtime has no usable model credential — or a present-but-expired one —
+// its first upstream request fails with a 401. Codex surfaces this as
+// `failed to connect to websocket: HTTP error: 401 Unauthorized, url:
+// wss://api.openai.com/v1/responses`; Anthropic as `401 Unauthorized`; others
+// similarly. Rather than let that stream past as a raw error, the daemon runs
+// `isModelAuthError` over surfaced errors and, when one matches, broadcasts a
+// `session.auth_required` targeted at `authProviderForSession(...)` so the client
+// can pop the "Sign in to your model" sheet for the right provider.
+import { MODEL_OAUTH_PROVIDERS } from "./oauth/model-oauth-providers.js";
+/**
+ * True when a raw error string looks like a model auth failure (401 / missing
+ * bearer / invalid key). Covers both the generic SDK phrasing and Codex's
+ * websocket-connect form.
+ */
+export function isModelAuthError(raw) {
+    const text = String(raw || "");
+    // Generic: an explicit 401, "unauthorized"/"authentication", or a
+    // missing/invalid bearer/api-key/token phrase.
+    if (/\b401\b|unauthorized|authentication|invalid x-api-key|(missing|invalid)[\s\S]*(bearer|api[\s_-]?key|token)/i.test(text))
+        return true;
+    // Codex app-server: websocket connect rejected with an HTTP 401/403.
+    if (/failed to connect to websocket[\s\S]*http error:\s*40[13]/i.test(text))
+        return true;
+    return false;
+}
+// Provider ids the app knows how to authenticate (OAuth subscription providers
+// plus any provider that has a conventional API-key env var). Used to validate
+// a model provider before signalling the client to sign in for it.
+const KNOWN_KEY_PROVIDERS = new Set([
+    "anthropic",
+    "openai",
+    "openrouter",
+    "google",
+    "gemini",
+    "groq",
+    "mistral",
+    "deepseek",
+    "xai",
+    "together",
+    "fireworks",
+    "cohere",
+    "perplexity",
+]);
+/**
+ * Resolve which credential provider the user should sign in for, given the
+ * failing runtime id and (optionally) its active model provider. Returns
+ * undefined when we can't confidently name a provider — in that case the caller
+ * should not raise the sign-in sheet.
+ *
+ * Codex runtimes (`codex`, `codex-approvals`) are served by the ChatGPT
+ * subscription, whose vault/provider id is `openai-codex`; that's the id the
+ * "Sign in with OpenAI" OAuth button targets.
+ */
+export function authProviderForSession(runtimeId, modelProvider) {
+    const id = String(runtimeId || "").trim().toLowerCase();
+    if (id.startsWith("codex"))
+        return "openai-codex";
+    const provider = String(modelProvider || "").trim().toLowerCase();
+    if (!provider)
+        return undefined;
+    if (Object.prototype.hasOwnProperty.call(MODEL_OAUTH_PROVIDERS, provider))
+        return provider;
+    if (KNOWN_KEY_PROVIDERS.has(provider))
+        return provider;
+    return undefined;
+}

package/dist/runtime/index.js

@@ -1071,6 +1071,16 @@ function codexAppServerRuntime(credsDir, tier) {
         args: [shim],
         ...(policy ? { env: { BIVY_CODEX_SANDBOX: policy.sandbox, BIVY_CODEX_APPROVAL_POLICY: policy.approvalPolicy } } : {}),
         credentials: createCredentialStore(credsDir),
+        // Mint ~/.codex/auth.json from the vault before the app-server spawns, then
+        // preflight — mirroring the `codex` exec path (see below). Without this the
+        // shim would launch uncredentialed and 401 on its first /responses call with
+        // no actionable message. `prepare` runs pre-spawn (the shim reads auth.json at
+        // launch); `preflight` backstops the genuinely uncredentialed case.
+        prepare: async () => {
+            const home = await ensureCodexAuth(credsDir);
+            return home ? { CODEX_HOME: home } : {};
+        },
+        preflight: (env) => codexCredentialPreflight(env),
         // Session-less catalog contribution: Codex runs OpenAI models under a ChatGPT
         // subscription (provider id "openai-codex"). The authoritative per-session
         // list comes from the app-server; this is the picker preview.

package/dist/runtime/oauth/model-oauth-providers.js

@@ -43,7 +43,9 @@ export const MODEL_OAUTH_PROVIDERS = {
             codex_cli_simplified_flow: "true",
             originator: "pi",
         },
-        refreshSkewMs: 0,
+        // Refresh a little early (like Anthropic/xAI) so Codex never bakes an
+        // already-expired access token into ~/.codex/auth.json and 401s mid-turn.
+        refreshSkewMs: 5 * 60 * 1000,
         refreshRotates: true,
         accountIdClaim: { path: "https://api.openai.com/auth", field: "chatgpt_account_id" },
     },

package/dist/runtime/protocol.js

@@ -212,6 +212,9 @@ class ProtocolSession {
     currentModelId;
     /** Provider of the selected model — scopes custom base-URL env injection. */
     currentModelProvider;
+    /** Env patch from the last `prepare` run (e.g. Codex's minted CODEX_HOME),
+     *  applied to the spawned child and reused by the per-turn preflight. */
+    prepareEnv = {};
     getModels() { return this.models; }
     getCurrentModel() {
         if (!this.currentModelId)
@@ -257,12 +260,19 @@ class ProtocolSession {
         const credentialEnv = this.runtimeOptions.credentials
             ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider).catch(() => ({}))
             : {};
+        // Optional prepare step, run before the child spawns because a shim reads its
+        // credential at launch (e.g. Codex mints ~/.codex/auth.json from the vault and
+        // pins CODEX_HOME). Stored so the per-turn preflight sees the same env. Best-
+        // effort: a throw is swallowed and treated as no patch.
+        this.prepareEnv = this.runtimeOptions.prepare
+            ? (await Promise.resolve(this.runtimeOptions.prepare({ ...process.env, ...this.runtimeOptions.env, ...credentialEnv })).catch(() => undefined)) ?? {}
+            : {};
         const child = spawn(this.runtimeOptions.command, this.runtimeOptions.args ?? [], {
             cwd: this.cwd,
             // bivySessionEnv() lets the agent's own shell resolve its session for
             // `bivy attach <path>` (see session-env.ts); spread last so it can never
             // be shadowed by an operator-configured env var of the same name.
-            env: { ...process.env, ...this.runtimeOptions.env, ...credentialEnv, ...bivySessionEnv(this.id) },
+            env: { ...process.env, ...this.runtimeOptions.env, ...credentialEnv, ...this.prepareEnv, ...bivySessionEnv(this.id) },
             stdio: "pipe",
         });
         this.child = child;
@@ -503,6 +513,38 @@ class ProtocolSession {
     async prompt(text, options) {
         const wasStarted = this.started;
         await this.open();
+        // Per-turn prepare + credential preflight, mirroring ProcessRuntime. Unlike a
+        // fresh-process runtime, the protocol child is long-lived, so a credential
+        // connected AFTER it spawned (a mid-session sign-in from the "Sign in to your
+        // model" sheet) would never be materialized by start()'s one-shot prepare.
+        // Re-run prepare here so e.g. Codex mints ~/.codex/auth.json from the just-
+        // completed sign-in before this turn — the app-server reads the default auth
+        // file, so it recovers on the next prompt instead of staying stuck on the
+        // initial 401. Then preflight backstops the genuinely uncredentialed case with
+        // an actionable error instead of an opaque upstream 401. ensureCodexAuth is
+        // idempotent (it no-ops once auth.json exists), so the repeat is cheap.
+        if (this.runtimeOptions.prepare || this.runtimeOptions.preflight) {
+            const credentialEnv = this.runtimeOptions.credentials
+                ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider).catch(() => ({}))
+                : {};
+            if (this.runtimeOptions.prepare) {
+                this.prepareEnv =
+                    (await Promise.resolve(this.runtimeOptions.prepare({ ...process.env, ...this.runtimeOptions.env, ...credentialEnv })).catch(() => undefined)) ??
+                        this.prepareEnv;
+            }
+            const preflightError = this.runtimeOptions.preflight?.({ ...process.env, ...this.runtimeOptions.env, ...credentialEnv, ...this.prepareEnv }, { provider: this.currentModelProvider });
+            if (preflightError) {
+                this.streaming = false;
+                const message = { role: "assistant", content: "", errorMessage: preflightError };
+                this.messages.push(message);
+                this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
+                this.emit({ type: "session.error", error: preflightError });
+                this.emit({ type: "message_end", message });
+                this.emit({ type: "turn_end" });
+                this.emit({ type: "agent_end", code: 1, signal: null });
+                return;
+            }
+        }
         if (!wasStarted)
             this.emit({ type: "agent_start" });
         const prompt = text.trim();

package/dist/server.js

@@ -22,6 +22,7 @@ import { InMemoryLocationRegistry } from "./runtime/location-registry.js";
 import { ControlPlaneSessionLocationRegistry, LayeredSessionLocationRegistry } from "./runtime/control-plane-location.js";
 import { attachAdoptedSessions, classifyAttachFailure } from "./runtime/adoption.js";
 import { createCredentialStore } from "./runtime/credentials.js";
+import { isModelAuthError, authProviderForSession } from "./runtime/auth-errors.js";
 import { createCredentialVault, migrateVaultDir } from "./runtime/credential-store.js";
 import { provisionAgentRun } from "./runtime/credential-provisioning.js";
 import { ingestAgentCredentials } from "./runtime/credential-ingest.js";
@@ -6794,6 +6795,24 @@ function terminalTurnError(event) {
     }
     return undefined;
 }
+/**
+ * When a surfaced error looks like a model auth failure (no credential, or an
+ * expired/invalid one that 401'd upstream), tell the client which provider to
+ * (re)authenticate so it can pop the "Sign in to your model" sheet instead of
+ * leaving a bare error bubble. Fires at most once per turn (reset on turn_start)
+ * so a retry storm — e.g. Codex's repeated websocket 401s — raises the sheet once.
+ */
+function maybeSignalAuthRequired(record, errorText) {
+    if (record.authRequiredSignaled)
+        return;
+    if (!isModelAuthError(errorText))
+        return;
+    const provider = authProviderForSession(record.runtimeId, record.session.getCurrentModel()?.provider);
+    if (!provider)
+        return;
+    record.authRequiredSignaled = true;
+    broadcast({ type: "session.auth_required", sessionId: record.id, provider, reason: errorText.slice(0, 400) });
+}
 function attachSessionListeners(record) {
     record.unsubscribe?.();
     // In-session model reroute controller (inert unless BIVY_SESSION_MODEL_FALLBACK
@@ -6843,6 +6862,10 @@ function attachSessionListeners(record) {
         ].includes(event.type)) {
             markSessionWorking(record, event);
         }
+        // A fresh turn re-arms the once-per-turn auth-required signal, so a credential
+        // that was fixed (or newly broke) is re-evaluated on the next prompt.
+        if (event.type === "turn_start")
+            record.authRequiredSignaled = false;
         if (event.type === "message_update" && event.message && (event.message?.role === "assistant")) {
             persistIntermediateFromEvent(record, event, false);
         }
@@ -6882,6 +6905,12 @@ function attachSessionListeners(record) {
             const e = event;
             broadcast({ type: "session.notice", sessionId: record.id, level: e.level ?? "info", message: String(e.message ?? ""), ...(e.action ? { action: e.action } : {}) });
         }
+        if (event.type === "session.error") {
+            // A runtime-emitted auth failure (Codex's app-server websocket 401, or a
+            // ProcessRuntime/ProtocolRuntime credential preflight) — raise the sign-in
+            // sheet for the right provider alongside the inline error bubble.
+            maybeSignalAuthRequired(record, String(event.error ?? ""));
+        }
         if (event.type === "runtime.commands") {
             // The agent learned its own slash commands mid-session (e.g. Claude Code's
             // system/init reports slash_commands only after the first turn starts).
@@ -6930,6 +6959,9 @@ function attachSessionListeners(record) {
                 metadata.touchSession(record.id, "failed");
                 scheduleAdvertise();
                 broadcast({ type: "session.error", sessionId: record.id, error: turnError });
+                // If the terminal error is an auth failure (expired key/token → 4xx),
+                // also raise the sign-in sheet for the failing provider.
+                maybeSignalAuthRequired(record, turnError);
                 void sendNotificationHint({
                     kind: "session_error",
                     sessionId: record.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.5.1-staging.76",
+  "version": "0.5.1-staging.78",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",