@bivy/bivy 0.16.15 → 0.16.16-staging.2

package/dist/agents/profiles.js

@@ -370,10 +370,13 @@ export const AGENT_PROFILES = {
         // TUI uses the same store via `grok --resume <id>`. Model ids match
         // `grok models` for the official CLI (override with BIVY_GROK_MODELS).
         args: ["-p"],
-        // The current CLI's streaming-json mode is ACP's standard NDJSON envelope.
-        // The shared tolerant parser unwraps session/update notifications, including
-        // tool calls/results and sub-agent activity, so Grok gets faithful transcripts
-        // without a Grok-specific adapter. Keep the plain args as the explicit
+        // The current CLI's `--output-format streaming-json` emits newline-delimited
+        // JSON keyed off `type`: {type:"text",data} for the answer, {type:"thought",
+        // data} for reasoning, {type:"end"} to close the turn (plus tool frames). The
+        // shared tolerant generic-stream-json parser understands this shape (and the
+        // ACP session/update envelope other CLIs use), so Grok gets faithful
+        // transcripts — answer prose, a thinking sidecar, and tool cards — without a
+        // Grok-specific adapter. Keep the plain args as the explicit
         // BIVY_AGENT_STRUCTURED=0 fallback.
         jsonArgs: ["--output-format", "streaming-json", "-p"],
         parserId: "generic-stream-json",
@@ -384,12 +387,12 @@ export const AGENT_PROFILES = {
         model: {
             flag: "-m",
             models: [
-                // Official Grok CLI (1.x) currently advertises grok-4.5 as the default
-                // subscription model. Older curated ids (grok-4-latest, grok-code-fast-1,
-                // …) return "unknown model id" against current CLIs — keep the list
+                // Official Grok CLI (1.x) advertises grok-4.6 as the default subscription
+                // model (verified against `grok models`); the older grok-4.5 / grok-4-latest
+                // / grok-code-fast-1 ids now return "unknown model id". Keep the list
                 // honest; operators can override with BIVY_GROK_MODELS if their install
                 // exposes more.
-                { id: "grok-4.5", name: "Grok 4.5", provider: "xai" },
+                { id: "grok-4.6", name: "Grok 4.6", provider: "xai" },
             ],
         },
         promptMode: "argv",

package/dist/runtime/cli-parsers.js

@@ -607,7 +607,12 @@ function acpToolUpdate(msg) {
     return undefined;
 }
 // Event `type` values that mean "the turn is finished" across the various CLIs.
-const STREAM_TERMINALS = new Set(["result", "done", "complete", "completed", "turn.completed", "session.done", "session_end", "session/ended", "message_stop", "response.completed", "final"]);
+const STREAM_TERMINALS = new Set(["result", "done", "complete", "completed", "turn.completed", "session.done", "session_end", "session/ended", "message_stop", "response.completed", "final", "end"]);
+// Event `type` values whose chunk (in a `data` field) is assistant answer prose
+// vs. reasoning/thinking. Used by the generic streaming parser to support CLIs
+// (e.g. Grok) that key the content off `type` with the text under `data`.
+const STREAM_TEXT_TYPES = new Set(["text", "assistant", "answer", "agent_message", "assistant_message", "output_text", "response_text"]);
+const STREAM_REASONING_TYPES = new Set(["thought", "thinking", "reasoning"]);
 /**
  * A TOLERANT line-delimited JSON parser for CLIs whose `--stream-json` /
  * `--format json` streaming vocabularies we haven't pinned exactly (Amp, Cursor,
@@ -645,7 +650,8 @@ export function genericStreamJsonParser() {
             // (a suffix match, no per-agent branch) so the message is surfaced as a
             // real turn error instead of leaking into the transcript as assistant
             // prose via the broad `message` text fallback in textFromStreamEvent.
-            const isErrorFrame = /(^|[._:/])error$/.test(type.toLowerCase());
+            const lowerType = type.toLowerCase();
+            const isErrorFrame = /(^|[._:/])error$/.test(lowerType);
             const tool = acpToolUpdate(msg);
             if (tool?.kind === "call")
                 acc.addToolUse(tool.id, tool.name ?? "tool", tool.input, events);
@@ -660,7 +666,21 @@ export function genericStreamJsonParser() {
                 if (typeof m === "string" && m.trim())
                     events.push({ type: "session.error", error: m.trim() });
             }
-            const text = isErrorFrame ? "" : textFromStreamEvent(msg);
+            // Reasoning/thinking stream carried as a typed chunk keyed by `type` with
+            // the content in a `data` field (Grok's streaming-json: {type:"thought",
+            // data}). Surface it as the same display-only thinking sidecar every agent
+            // uses, never as answer prose — a generic shape, not a per-agent branch.
+            if (!isErrorFrame && STREAM_REASONING_TYPES.has(lowerType) && typeof msg.data === "string") {
+                acc.appendReasoning(msg.data, events);
+                return events;
+            }
+            // Assistant answer text. Most CLIs expose it via one of the fields
+            // textFromStreamEvent covers; some (Grok) put it in `data` keyed by an
+            // assistant-text `type`. Fall back to `data` only for those types so an
+            // unrelated control frame's `data` never leaks into the transcript.
+            let text = isErrorFrame ? "" : textFromStreamEvent(msg);
+            if (!text && !isErrorFrame && typeof msg.data === "string" && STREAM_TEXT_TYPES.has(lowerType))
+                text = msg.data;
             if (text && !STREAM_TERMINALS.has(type)) {
                 acc.appendText(text, events);
                 sawText = true;

package/dist/runtime/grok-auth.js

@@ -40,6 +40,60 @@ export function grokAuthEntryKey(clientId) {
     const id = clientId?.trim() || getModelOAuthProvider("xai")?.clientId || "";
     return `${GROK_OIDC_ISSUER}::${id}`;
 }
+/** Decode a JWT payload without verifying its signature (best-effort). */
+function decodeJwtClaims(token) {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1])
+        return undefined;
+    try {
+        const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
+        return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The xAI user id the Grok CLI records as `user_id` in each auth.json entry —
+ * the OIDC subject (`sub`) of the access token (falling back to `principal_id`).
+ * The current Grok CLI (1.x) rejects an auth.json entry that is *missing* this
+ * field (serde: "missing field `user_id`"), so a minted file without it cannot
+ * be parsed — Grok then can't authenticate or self-refresh and silently
+ * produces empty turns. Bivy's `xai` vault record only stores {access, refresh,
+ * expires}, so we recover the id from the access token's own claims.
+ */
+export function grokUserIdFromAccessToken(access) {
+    const claims = decodeJwtClaims(access);
+    if (!claims)
+        return undefined;
+    const sub = typeof claims.sub === "string" ? claims.sub.trim() : "";
+    if (sub)
+        return sub;
+    const principal = typeof claims.principal_id === "string" ? claims.principal_id.trim() : "";
+    return principal || undefined;
+}
+/**
+ * Whether an existing auth.json entry for our scope is parseable by the current
+ * Grok CLI. An entry written by an older Bivy (or hand-rolled) that lacks a
+ * non-empty `user_id` cannot be loaded — leaving it in place guarantees a
+ * broken, unauthenticated session, so those are re-minted rather than kept.
+ */
+function grokEntryIsHealthy(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const userId = entry.user_id;
+    return typeof userId === "string" && userId.trim().length > 0;
+}
+function readGrokAuthJson(authFile) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(authFile, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Ensure the Grok CLI has a usable credential file, minting one from Bivy's
  * vault when needed. Returns the resolved `GROK_HOME` (so the caller can pin it
@@ -47,24 +101,32 @@ export function grokAuthEntryKey(clientId) {
  * credential — in which case the caller's preflight surfaces the actionable
  * "no credential" error unchanged.
  *
- * Idempotent and low-churn: if an `auth.json` already exists (a native
- * `grok login` or a prior materialization) it is left untouched — Grok owns and
- * self-refreshes it — so we mint at most once. We write to the *default* Grok
- * home (never a throwaway dir) so sessions stay where the CLI already looks.
+ * Idempotent and low-churn: a *parseable* existing entry for our scope (a native
+ * `grok login` or a prior materialization) is left untouched — Grok owns and
+ * self-refreshes it. The one exception is a legacy entry that the current Grok
+ * CLI can no longer parse (missing `user_id`): leaving that in place guarantees
+ * a silently-unauthenticated session, so it is re-minted from the vault (other
+ * scopes in the file are preserved). We write to the *default* Grok home (never
+ * a throwaway dir) so sessions stay where the CLI already looks.
  */
 export async function ensureGrokAuth(credsDir) {
     const grokHome = resolveGrokHome();
     const authFile = path.join(grokHome, "auth.json");
-    // Never clobber an existing login (native or previously materialized); Grok
-    // owns and refreshes it. An API key, if present, is handled by preflight /
-    // env projection — no auth.json needed.
-    if (fs.existsSync(authFile))
-        return grokHome;
-    if (process.env.XAI_API_KEY?.trim() || process.env.GROK_API_KEY?.trim())
-        return undefined;
     const provider = getModelOAuthProvider("xai");
     if (!provider)
-        return undefined;
+        return fs.existsSync(authFile) ? grokHome : undefined;
+    const entryKey = grokAuthEntryKey(provider.clientId);
+    // A parseable entry for our scope is Grok's to own and refresh — never clobber
+    // it. Only an absent file or a legacy entry the current CLI can't load (no
+    // `user_id`) falls through to (re)minting below.
+    const existingJson = fs.existsSync(authFile) ? readGrokAuthJson(authFile) : undefined;
+    if (existingJson && grokEntryIsHealthy(existingJson[entryKey]))
+        return grokHome;
+    // An API key authenticates Grok directly (preflight / env projection) — no
+    // auth.json needed. Only skip minting when we have no OAuth entry to heal.
+    if (process.env.XAI_API_KEY?.trim() || process.env.GROK_API_KEY?.trim()) {
+        return fs.existsSync(authFile) ? grokHome : undefined;
+    }
     // Ensure the vault access token is still live before we project it. No-op when
     // fresh; refreshes under the store lock when expired. Failure leaves the vault
     // alone and we fall through to the (likely still-stale) read below.
@@ -77,10 +139,17 @@ export async function ensureGrokAuth(credsDir) {
     const refresh = typeof cred.refresh === "string" ? cred.refresh : "";
     if (!access || !refresh)
         return undefined;
+    // The current Grok CLI requires `user_id` on every entry; recover it from the
+    // access token's OIDC claims. Without it the file is unparseable and useless,
+    // so surface the honest "no credential" state (undefined) rather than writing
+    // a file Grok will silently reject.
+    const userId = grokUserIdFromAccessToken(access);
+    if (!userId)
+        return fs.existsSync(authFile) ? grokHome : undefined;
     const expiresMs = Number(cred.expires) || 0;
-    const entryKey = grokAuthEntryKey(provider.clientId);
     const entry = {
         key: access,
+        user_id: userId,
         auth_mode: "oidc",
         create_time: new Date().toISOString(),
         refresh_token: refresh,
@@ -89,7 +158,9 @@ export async function ensureGrokAuth(credsDir) {
     };
     if (expiresMs > 0)
         entry.expires_at = new Date(expiresMs).toISOString();
-    const authJson = { [entryKey]: entry };
+    // Preserve any other scopes already present (e.g. a native login for a
+    // different client id) — replace only our own entry.
+    const authJson = { ...(existingJson ?? {}), [entryKey]: entry };
     try {
         fs.mkdirSync(grokHome, { recursive: true, mode: 0o700 });
         const tmp = `${authFile}.tmp`;

package/package.json

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