@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/runtime/normalize.js

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Shared runtime normalization helpers (docs/dramatic-simplification-plan.md,
+// slice 3). Every runtime adapter has to turn its own model shape into the
+// runtime-neutral `ModelInfo`. Each used to reimplement that mapping (pi.ts,
+// claude-code.ts, …), so the same field had subtly different fallbacks per
+// runtime. This is the one home for that mapping; adapters pass their per-runtime
+// quirks (default provider, whether the model is `configured`) as options.
+//
+// Pure and defensive — a bare string, a `{model}` blob, or a rich record all map
+// without throwing — so it is unit-testable without a live agent (see
+// test/runtime-normalize.test.ts).
+/**
+ * Pull a usable string model id out of a loose record.
+ *
+ * A runtime (e.g. the Claude Agent SDK's `supportedModels()`) can hand us a
+ * record whose id lives under a field other than `id`/`model`, or whose `model`
+ * is itself a nested object (`{ model: { id, displayName } }`). The old
+ * `id ?? model ?? String(model)` chain coerced those objects with `String()`,
+ * yielding the literal string "[object Object]" — which then flowed all the way
+ * to the agent CLI as a model id and was rejected ("Model '[object Object]' is
+ * not a recognized model id"). Resolve defensively and never stringify an
+ * object into an id: try the known id-bearing fields, recurse into a nested
+ * `model` object, and only fall back to `String()` for a primitive.
+ */
+function resolveModelId(model) {
+    if (model == null)
+        return "";
+    if (typeof model === "string")
+        return model;
+    if (typeof model === "number")
+        return String(model);
+    if (typeof model === "object") {
+        for (const key of ["id", "model", "value", "slug", "name"]) {
+            const candidate = model[key];
+            if (typeof candidate === "string" && candidate)
+                return candidate;
+            // `model.model` (and friends) can be a nested record — dig in.
+            if (candidate && typeof candidate === "object") {
+                const nested = resolveModelId(candidate);
+                if (nested)
+                    return nested;
+            }
+        }
+        return "";
+    }
+    return String(model);
+}
+/**
+ * Map a runtime's loose model record into the neutral `ModelInfo`.
+ *
+ * Field resolution is the lenient superset of what the per-runtime versions did:
+ *   - id:            `id` → `model` → nested `model.*` id → `value`/`slug`/`name`
+ *   - name:          `displayName` → `name` → id
+ *   - reasoning:     `reasoning` || `supportsThinking`
+ *   - maxTokens:     `maxTokens` → `maxOutputTokens`
+ *   - input/configured: passed through only when present (key stays absent otherwise)
+ */
+export function toModelInfo(model, opts = {}) {
+    const id = resolveModelId(model);
+    const info = {
+        provider: model?.provider ?? opts.defaultProvider ?? "",
+        id,
+        name: model?.displayName ?? model?.name ?? id,
+        reasoning: Boolean(model?.reasoning ?? model?.supportsThinking),
+        contextWindow: model?.contextWindow,
+        maxTokens: model?.maxTokens ?? model?.maxOutputTokens,
+    };
+    if (model?.input !== undefined)
+        info.input = model.input;
+    if (opts.configured != null)
+        info.configured = opts.configured;
+    return info;
+}

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

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Verified OAuth configs for Bivy-owned subscription providers.
+//
+// Every value here is ported VERBATIM from the shipped @earendil-works/pi-ai
+// source (auth/oauth/*.js in 0.80.9) — real, verified client ids and endpoints,
+// not guesses. Owning these lets Bivy run the OAuth login + token refresh itself,
+// so no credential operation depends on Pi.
+//
+// Covered (fully Bivy-owned): Anthropic (Claude Pro/Max), OpenAI Codex (ChatGPT),
+// xAI (Grok). GitHub Copilot (two-stage token + dynamic base URL entangled with
+// Pi's request layer) and Radius (self-describing gateway) are intentionally not
+// reimplemented here — see docs/keystore-migration-plan.md.
+/** Anthropic uses a JSON token body; OpenAI/xAI use form-encoded. */
+export const MODEL_OAUTH_PROVIDERS = {
+    anthropic: {
+        id: "anthropic",
+        displayName: "Anthropic (Claude Pro/Max)",
+        clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+        scopes: "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload",
+        flow: "auth_code",
+        tokenEncoding: "json",
+        authorizeUrl: "https://claude.ai/oauth/authorize",
+        tokenUrl: "https://platform.claude.com/v1/oauth/token",
+        callback: { port: 53692, path: "/callback", redirectHost: "localhost" },
+        authorizeParams: { code: "true" },
+        stateIsVerifier: true,
+        refreshSkewMs: 5 * 60 * 1000,
+        refreshRotates: true,
+    },
+    "openai-codex": {
+        id: "openai-codex",
+        displayName: "OpenAI (ChatGPT Plus/Pro)",
+        clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+        scopes: "openid profile email offline_access",
+        flow: "auth_code",
+        tokenEncoding: "form",
+        authorizeUrl: "https://auth.openai.com/oauth/authorize",
+        tokenUrl: "https://auth.openai.com/oauth/token",
+        callback: { port: 1455, path: "/auth/callback", redirectHost: "localhost" },
+        authorizeParams: {
+            id_token_add_organizations: "true",
+            codex_cli_simplified_flow: "true",
+            originator: "pi",
+        },
+        refreshSkewMs: 0,
+        refreshRotates: true,
+        accountIdClaim: { path: "https://api.openai.com/auth", field: "chatgpt_account_id" },
+    },
+    xai: {
+        id: "xai",
+        displayName: "xAI (Grok / X subscription)",
+        clientId: "b1a00492-073a-47ea-816f-4c329264a828",
+        scopes: "openid profile email offline_access grok-cli:access api:access",
+        flow: "device_code",
+        tokenEncoding: "form",
+        tokenUrl: "https://auth.x.ai/oauth2/token",
+        deviceAuthUrl: "https://auth.x.ai/oauth2/device/code",
+        deviceParams: { referrer: "pi" },
+        deviceGrantType: "urn:ietf:params:oauth:grant-type:device_code",
+        refreshSkewMs: 5 * 60 * 1000,
+        refreshRotates: false,
+    },
+};
+/** Provider ids Bivy can natively drive an OAuth subscription login/refresh for. */
+export function nativeOAuthProviderIds() {
+    return Object.keys(MODEL_OAUTH_PROVIDERS);
+}
+/** Whether Bivy owns OAuth for this provider (vs. it being api-key or unsupported). */
+export function isNativeOAuthProvider(id) {
+    return Object.prototype.hasOwnProperty.call(MODEL_OAUTH_PROVIDERS, id.trim().toLowerCase());
+}
+export function getModelOAuthProvider(id) {
+    return MODEL_OAUTH_PROVIDERS[id.trim().toLowerCase()];
+}

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

@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Bivy-owned OAuth engine for subscription model providers.
+//
+// Login (authorization-code + PKCE with a local callback server and manual-paste
+// fallback, or RFC-8628 device-code) and token refresh are performed here,
+// natively, with no dependency on Pi. Verified provider configs live in
+// model-oauth-providers.ts. Credentials are persisted through Bivy's own store.
+//
+// The interaction contract (prompt/notify) is Bivy-owned here too, so the OAuth
+// UX layer (server.ts, bivy-login.ts) no longer imports any Pi type.
+import http from "node:http";
+import { randomBytes } from "node:crypto";
+import { createPkce } from "../../integrations/oauth.js";
+import { createCredentialVault } from "../credential-store.js";
+import { getModelOAuthProvider } from "./model-oauth-providers.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// --- HTTP helpers ------------------------------------------------------------
+async function postToken(url, encoding, body) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: encoding === "json"
+            ? { "content-type": "application/json", accept: "application/json" }
+            : { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
+        body: encoding === "json" ? JSON.stringify(body) : new URLSearchParams(body).toString(),
+    });
+    const text = await res.text();
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Token endpoint returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+    }
+    if (!res.ok) {
+        const err = (payload.error_description || payload.error || text.slice(0, 200));
+        throw new Error(`OAuth token request failed (${res.status}): ${err}`);
+    }
+    return payload;
+}
+/** Decode a JWT and read `claimPath` → `field` (used for OpenAI's chatgpt_account_id). */
+function jwtClaim(token, claimPath, field) {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1])
+        return undefined;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+        const claim = payload[claimPath];
+        if (claim && typeof claim === "object") {
+            const value = claim[field];
+            return typeof value === "string" ? value : undefined;
+        }
+    }
+    catch {
+        // malformed token — treat as no claim
+    }
+    return undefined;
+}
+function tokensFrom(provider, payload, prev) {
+    const access = typeof payload.access_token === "string" ? payload.access_token : "";
+    if (!access)
+        throw new Error("OAuth token response is missing access_token");
+    const rotated = typeof payload.refresh_token === "string" ? payload.refresh_token : "";
+    const refresh = rotated || prev?.refresh || "";
+    const expiresIn = Number(payload.expires_in) || 3600;
+    const expires = Date.now() + expiresIn * 1000 - provider.refreshSkewMs;
+    let accountId = prev?.accountId;
+    if (provider.accountIdClaim) {
+        accountId = jwtClaim(access, provider.accountIdClaim.path, provider.accountIdClaim.field) ?? accountId;
+        if (!accountId)
+            throw new Error(`Could not extract account id for "${provider.id}" from the OAuth token`);
+    }
+    return { access, refresh, expires, ...(accountId ? { accountId } : {}) };
+}
+// --- Authorization-code flow (browser + callback server + manual paste) ------
+function buildAuthorizeUrl(provider, opts) {
+    const url = new URL(provider.authorizeUrl);
+    for (const [k, v] of Object.entries(provider.authorizeParams ?? {}))
+        url.searchParams.set(k, v);
+    url.searchParams.set("client_id", provider.clientId);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("redirect_uri", opts.redirectUri);
+    url.searchParams.set("scope", provider.scopes);
+    url.searchParams.set("code_challenge", opts.challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("state", opts.state);
+    return url.toString();
+}
+/** Pull the bare authorization code out of a pasted redirect URL / `code#state` / raw code. */
+export function extractAuthCode(value) {
+    const v = value.trim();
+    if (!v)
+        throw new Error("No authorization code provided");
+    if (v.includes("://")) {
+        try {
+            const code = new URL(v).searchParams.get("code");
+            if (code)
+                return code;
+        }
+        catch {
+            // not a URL after all — fall through
+        }
+    }
+    const hash = v.indexOf("#");
+    return hash > 0 ? v.slice(0, hash) : v;
+}
+function respondHtml(res, status, title, body) {
+    res.statusCode = status;
+    res.setHeader("content-type", "text/html; charset=utf-8");
+    res.end(`<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font:16px system-ui;margin:3rem;max-width:32rem"><h2>${title}</h2><p>${body}</p><p>You can close this tab and return to Bivy.</p></body>`);
+}
+/** Local HTTP listener that resolves the authorization code from the provider redirect. */
+function startCallbackServer(host, port, pathName, expectedState, signal) {
+    let server;
+    let closed = false;
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        try {
+            server?.close();
+        }
+        catch { /* ignore */ }
+    };
+    const promise = new Promise((resolve, reject) => {
+        server = http.createServer((req, res) => {
+            let url;
+            try {
+                url = new URL(req.url ?? "", `http://${host}:${port}`);
+            }
+            catch {
+                res.statusCode = 400;
+                res.end("bad request");
+                return;
+            }
+            if (url.pathname !== pathName) {
+                res.statusCode = 404;
+                res.end("not found");
+                return;
+            }
+            const error = url.searchParams.get("error");
+            const code = url.searchParams.get("code");
+            const state = url.searchParams.get("state");
+            if (error) {
+                respondHtml(res, 400, "Sign-in failed", `The provider returned: ${error}`);
+                close();
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+            if (!code) {
+                respondHtml(res, 400, "Sign-in failed", "No authorization code in the callback.");
+                return;
+            }
+            if (expectedState && state && state !== expectedState) {
+                respondHtml(res, 400, "Sign-in failed", "Authorization state did not match.");
+                return;
+            }
+            respondHtml(res, 200, "Signed in", "Bivy received your authorization.");
+            close();
+            resolve(code);
+        });
+        server.on("error", (err) => {
+            // e.g. the callback port is busy — the manual-paste path still works.
+            close();
+            reject(err);
+        });
+        signal?.addEventListener("abort", () => { close(); reject(new Error("Login aborted")); }, { once: true });
+        server.listen(port, host);
+    });
+    return { promise, close };
+}
+async function loginAuthCode(provider, interaction) {
+    const { verifier, challenge } = createPkce();
+    const state = provider.stateIsVerifier ? verifier : randomBytes(16).toString("hex");
+    const redirectUri = `http://${provider.callback.redirectHost}:${provider.callback.port}${provider.callback.path}`;
+    const authorizeUrl = buildAuthorizeUrl(provider, { challenge, state, redirectUri });
+    interaction.notify({
+        type: "auth_url",
+        url: authorizeUrl,
+        instructions: "Sign in in your browser. If it doesn't return automatically, paste the redirect URL (or the code) back here.",
+    });
+    const bindHost = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
+    const sources = [];
+    const closers = [];
+    if (provider.callback) {
+        const server = startCallbackServer(bindHost, provider.callback.port, provider.callback.path, state, interaction.signal);
+        closers.push(server.close);
+        sources.push(server.promise);
+    }
+    sources.push(interaction.prompt({ type: "manual_code", message: "Paste the redirect URL or authorization code:", signal: interaction.signal }));
+    let raw;
+    try {
+        raw = await Promise.any(sources);
+    }
+    catch (error) {
+        // Every source failed (callback error + paste rejected/cancelled).
+        if (error instanceof AggregateError) {
+            const last = error.errors[error.errors.length - 1];
+            throw last instanceof Error ? last : new Error("Sign-in did not complete");
+        }
+        throw error;
+    }
+    finally {
+        for (const close of closers)
+            close();
+    }
+    const code = extractAuthCode(raw);
+    const body = {
+        grant_type: "authorization_code",
+        client_id: provider.clientId,
+        code,
+        code_verifier: verifier,
+        redirect_uri: redirectUri,
+    };
+    if (provider.tokenEncoding === "json")
+        body.state = state; // Anthropic includes state
+    const payload = await postToken(provider.tokenUrl, provider.tokenEncoding, body);
+    return tokensFrom(provider, payload);
+}
+// --- Device-code flow (RFC 8628) ---------------------------------------------
+async function loginDeviceCode(provider, interaction) {
+    const start = await postToken(provider.deviceAuthUrl, "form", {
+        client_id: provider.clientId,
+        scope: provider.scopes,
+        ...(provider.deviceParams ?? {}),
+    });
+    const deviceCode = String(start.device_code ?? "");
+    const userCode = String(start.user_code ?? "");
+    const verificationUri = String(start.verification_uri_complete ?? start.verification_uri ?? "");
+    let interval = (Number(start.interval) || 5) * 1000;
+    const deadline = Date.now() + (Number(start.expires_in) || 900) * 1000;
+    if (!deviceCode || !userCode)
+        throw new Error("Device authorization did not return a device/user code");
+    interaction.notify({
+        type: "device_code",
+        userCode,
+        verificationUri,
+        intervalSeconds: Number(start.interval) || 5,
+        expiresInSeconds: Number(start.expires_in) || undefined,
+    });
+    // Providers that use device-code sleep one interval before the first poll.
+    await sleep(interval);
+    for (;;) {
+        if (interaction.signal?.aborted)
+            throw new Error("Login aborted");
+        if (Date.now() > deadline)
+            throw new Error("Device login timed out. Please try again.");
+        let payload;
+        try {
+            payload = await postToken(provider.tokenUrl, "form", {
+                grant_type: provider.deviceGrantType ?? "urn:ietf:params:oauth:grant-type:device_code",
+                client_id: provider.clientId,
+                device_code: deviceCode,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (/authorization_pending/i.test(message)) {
+                await sleep(interval);
+                continue;
+            }
+            if (/slow_down/i.test(message)) {
+                interval += 5000;
+                await sleep(interval);
+                continue;
+            }
+            throw error; // access_denied / expired_token / other
+        }
+        return tokensFrom(provider, payload);
+    }
+}
+// --- Public API --------------------------------------------------------------
+/** Provider ids Bivy can natively drive a subscription login for. */
+export { isNativeOAuthProvider, nativeOAuthProviderIds } from "./model-oauth-providers.js";
+/**
+ * Run a provider's OAuth login natively and persist the credential into Bivy's
+ * store. The interaction (prompt/notify) is caller-supplied; the whole flow —
+ * PKCE, callback server, token exchange — is Bivy's.
+ */
+export async function loginModelOAuth(credsDir, providerId, interaction) {
+    const provider = getModelOAuthProvider(providerId);
+    if (!provider)
+        throw new Error(`Provider "${providerId}" does not support subscription login`);
+    const tokens = provider.flow === "device_code" ? await loginDeviceCode(provider, interaction) : await loginAuthCode(provider, interaction);
+    const credential = { type: "oauth", access: tokens.access, refresh: tokens.refresh, expires: tokens.expires, ...(tokens.accountId ? { accountId: tokens.accountId } : {}) };
+    await createCredentialVault(credsDir).modify(providerId, async () => credential);
+}
+/** Exchange the refresh token for a fresh credential (network call; throws on failure). */
+async function refreshTokens(provider, current) {
+    const refresh = typeof current.refresh === "string" ? current.refresh : "";
+    if (!refresh)
+        throw new Error(`No refresh token stored for "${provider.id}"`);
+    const payload = await postToken(provider.tokenUrl, provider.tokenEncoding, {
+        grant_type: "refresh_token",
+        client_id: provider.clientId,
+        refresh_token: refresh,
+    });
+    return tokensFrom(provider, payload, {
+        refresh: provider.refreshRotates ? undefined : refresh,
+        accountId: typeof current.accountId === "string" ? current.accountId : undefined,
+    });
+}
+/**
+ * Ensure a fresh OAuth access token for a provider and return it. The refresh
+ * runs inside the store's per-provider lock, and re-checks expiry there, so
+ * concurrent callers (and other processes) can't double-spend a rotating refresh
+ * token — the single-flight guarantee. Returns undefined if the provider has no
+ * stored OAuth credential or isn't natively supported.
+ */
+export async function refreshModelOAuth(credsDir, providerId) {
+    const provider = getModelOAuthProvider(providerId);
+    if (!provider)
+        return undefined;
+    const result = await createCredentialVault(credsDir).modify(providerId, async (current) => {
+        if (!current || current.type !== "oauth")
+            return current;
+        // Someone else already refreshed while we waited for the lock — use theirs.
+        if (Number(current.expires) > Date.now())
+            return current;
+        const fresh = await refreshTokens(provider, current);
+        return { type: "oauth", access: fresh.access, refresh: fresh.refresh, expires: fresh.expires, ...(fresh.accountId ? { accountId: fresh.accountId } : {}) };
+    });
+    return result?.type === "oauth" ? result.access : undefined;
+}

package/dist/runtime/opencode-preflight.js

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// OpenCode credential preflight.
+//
+// `opencode run` boots OpenCode's own internal server and calls the selected
+// provider through it. When that provider has no credential, OpenCode does NOT
+// surface a clean 401 — its server throws and prints its opaque `NamedError`
+// envelope to stdout:
+//
+//   Error: { "name": "UnknownError", "data": {
+//     "message": "Unexpected server error. Check server logs for details.",
+//     "ref": "err_25799b27" } }
+//
+// Bivy relays that verbatim into the agent output, and the `err_` ref points at
+// OpenCode's server log — which Bivy doesn't capture — so the user is stuck. Like
+// codex-preflight.ts, this backstop detects the missing credential up front (the
+// vault handoff in credentials.ts injects each provider's key into the env) and
+// returns a clear, actionable message instead of letting OpenCode 500.
+//
+// It's provider-aware: OpenCode models are `provider/model` ids, so the run's
+// selected provider tells us exactly which key var must be present.
+import { apiKeyEnvVar } from "./credentials.js";
+/** Actionable message shown when OpenCode's selected provider has no credential. */
+export function opencodeNoCredentialMessage(provider, envVar) {
+    const label = provider.charAt(0).toUpperCase() + provider.slice(1);
+    return [
+        `OpenCode has no ${label} credential on this node, so it can't start a turn — its server would fail with an opaque \`UnknownError: Unexpected server error\` (the \`err_…\` ref points at OpenCode's own server log, which Bivy can't read).`,
+        "",
+        "Fix it any of these ways:",
+        `• Add a ${label} API key under Keys & OAuth — Bivy passes it to OpenCode as ${envVar}, or`,
+        "• Pick a different model whose provider you've already connected, or",
+        `• Run \`opencode auth login\` on this node to sign in directly.`,
+    ].join("\n");
+}
+/**
+ * Returns a human-readable error when OpenCode's selected provider has no usable
+ * credential in the resolved environment, or undefined to proceed.
+ *
+ * Conservative by design: if the provider is unknown (no model selected, or a
+ * provider we don't map) we return undefined rather than block a run that might
+ * authenticate some other way (e.g. an on-disk `opencode auth` login). Anthropic
+ * is additionally satisfied by a Claude Code OAuth token.
+ */
+export function opencodeCredentialPreflight(env, ctx = {}) {
+    const provider = ctx.provider?.trim().toLowerCase();
+    if (!provider)
+        return undefined;
+    // Anthropic can authenticate via the Claude Code OAuth token, not just a key.
+    if (provider === "anthropic" && env.CLAUDE_CODE_OAUTH_TOKEN?.trim())
+        return undefined;
+    const envVar = apiKeyEnvVar(provider);
+    if (env[envVar]?.trim())
+        return undefined;
+    return opencodeNoCredentialMessage(provider, envVar);
+}

package/dist/runtime/pi-auth.js

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Model-provider auth surface for the daemon (the "Models & providers" screen).
+//
+// Storage is Bivy's own (credential-store.ts): set / remove / export / import all
+// operate directly on the encrypted vault with no Pi involvement. The one thing
+// that legitimately comes from Pi is the model-provider *catalog* — the list of
+// providers and their display names / OAuth capability — which the isolated
+// pi-oauth bridge supplies (Bivy has no model catalog of its own).
+import { createCredentialVault } from "./credential-store.js";
+import { listPiProviders } from "./pi-oauth.js";
+/**
+ * Enumerate model providers with their current auth status. The catalog + status
+ * come from Pi's provider list (joined with our injected store); the stored
+ * credential `kind` comes from Bivy's vault.
+ */
+export async function listProviders(credsDir, piDir) {
+    const [catalog, stored] = await Promise.all([listPiProviders(credsDir, piDir), createCredentialVault(credsDir).list()]);
+    const infoById = new Map(stored.map((info) => [info.providerId, info]));
+    return catalog.map((provider) => ({
+        id: provider.id,
+        name: provider.name,
+        oauth: provider.oauth,
+        configured: provider.configured,
+        kind: infoById.get(provider.id)?.type,
+        source: provider.source,
+        expiresAt: infoById.get(provider.id)?.expiresAt,
+    }));
+}
+/** Export configured model-provider credentials, keyed by provider id. */
+export async function exportProviderAuth(credsDir) {
+    return createCredentialVault(credsDir).exportAll();
+}
+/**
+ * Import a cross-node provider auth snapshot into the local vault.
+ *
+ * Merge, never destroy (see BivyCredentialStore.importAll): the account snapshot
+ * is applied on top of the local vault rather than replacing it, and a
+ * locally-fresher OAuth token is never overwritten by an older one in the
+ * snapshot (rotated refresh tokens are single-use). Provider removal propagates
+ * via removeProvider() re-pushing, not destructive imports.
+ */
+export async function importProviderAuth(credsDir, providers) {
+    await createCredentialVault(credsDir).importAll(providers);
+}
+/** Store an API key for a model provider (shared by every agent via the vault). */
+export async function setProviderApiKey(credsDir, provider, key) {
+    const id = provider.trim().toLowerCase();
+    if (!id)
+        throw new Error("Provider is required");
+    await createCredentialVault(credsDir).setApiKey(id, key);
+}
+/**
+ * Store an api-key credential together with provider-scoped `env` (e.g. a custom
+ * base URL). Used for user-provided endpoints: the base URL travels with the
+ * credential so it can be injected into non-Pi agents. A `key`/`env` left
+ * undefined preserves whatever the vault already holds; an empty-key credential
+ * is valid (a keyless local server that still needs its base URL).
+ */
+export async function setProviderCredential(credsDir, provider, opts) {
+    const id = provider.trim().toLowerCase();
+    if (!id)
+        throw new Error("Provider is required");
+    await createCredentialVault(credsDir).modify(id, async (prev) => {
+        const prevApiKey = prev && prev.type === "api_key" ? prev : undefined;
+        const key = (opts.key ?? prevApiKey?.key ?? "").toString();
+        const env = opts.env ?? prevApiKey?.env;
+        const cred = { type: "api_key" };
+        if (key)
+            cred.key = key;
+        if (env && Object.keys(env).length)
+            cred.env = env;
+        return cred;
+    });
+}
+/** Forget a provider's stored credential (API key or OAuth token). */
+export async function removeProvider(credsDir, provider) {
+    const id = provider.trim().toLowerCase();
+    if (!id)
+        throw new Error("Provider is required");
+    await createCredentialVault(credsDir).delete(id);
+}

package/dist/runtime/pi-oauth.js

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Pi model-catalog bridge.
+//
+// Bivy owns credentials end-to-end: storage (credential-store.ts) and OAuth
+// login/refresh (oauth/model-oauth.ts). The one thing that legitimately remains
+// Pi's is the model/provider CATALOG — the list of providers and their models —
+// because Bivy has no model catalog of its own. That is model metadata, not a
+// credential, and it is isolated here. Pi never performs a credential operation
+// for Bivy; it only enumerates models and (as an agent) reads through the store.
+import path from "node:path";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { createCredentialVault } from "./credential-store.js";
+import { isNativeOAuthProvider } from "./oauth/model-oauth-providers.js";
+/** Adapt Bivy's store to pi-ai's structurally-identical CredentialStore for injection. */
+export function piCredentialStore(store) {
+    return store;
+}
+/**
+ * Build a Pi ModelRuntime backed by Bivy's credential store. Credentials come
+ * from the node's shared vault (`credsDir`); the model catalog cache
+ * (`models.json`) lives in Pi's own dir (`piDir`). `allowModelNetwork` defaults
+ * to false for the catalog paths (fast, offline); the pi *session* runtime
+ * (pi.ts) allows network so dynamic model lists load.
+ */
+export function createPiModelRuntime(opts) {
+    const store = opts.store ?? createCredentialVault(opts.credsDir);
+    return ModelRuntime.create({
+        credentials: piCredentialStore(store),
+        modelsPath: path.join(opts.piDir, "models.json"),
+        allowModelNetwork: opts.allowModelNetwork ?? false,
+    });
+}
+/** Enumerate the model-provider catalog with each provider's current auth status. */
+export async function listPiProviders(credsDir, piDir) {
+    const runtime = await createPiModelRuntime({ credsDir, piDir });
+    return runtime
+        .getProviders()
+        .map((provider) => {
+        const status = runtime.getProviderAuthStatus(provider.id);
+        return {
+            id: provider.id,
+            name: provider.name,
+            // Whether we offer a subscription login is decided by Bivy's own OAuth
+            // registry, not Pi's provider metadata.
+            oauth: isNativeOAuthProvider(provider.id),
+            configured: status.configured,
+            source: status.source,
+        };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}