@cortexkit/pi-antigravity-auth 2.2.1 → 3.0.1

package/dist/index.js

@@ -1,10 +1,553 @@
 // src/index.ts
+import { join as join2 } from "node:path";
 import {
+  ANTIGRAVITY_PROVIDER_ID as ANTIGRAVITY_PROVIDER_ID2,
   authorizeAntigravity,
+  enrollmentAuthority as enrollmentAuthority3,
   exchangeAntigravity,
   getPublicModelDefinitions,
+  loadCommonAuthPiSlot,
   refreshAntigravityToken
 } from "@cortexkit/antigravity-auth-core";
+import {
+  getAgentDir,
+  readStoredCredential
+} from "@earendil-works/pi-coding-agent";
+
+// src/commands.ts
+import {
+  ANTIGRAVITY_MENU_COMMAND,
+  createAntigravityCommandMenu,
+  loadCommonAuthCommands
+} from "@cortexkit/antigravity-auth-core";
+
+// src/vault-setup.ts
+import { createHash, randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import {
+  ANTIGRAVITY_PROVIDER_ID,
+  enrollmentAuthority
+} from "@cortexkit/antigravity-auth-core";
+import { writeJsonAtomic } from "@cortexkit/antigravity-auth-core/atomic-write";
+var PI_ANTIGRAVITY_PROVIDER_ID = ANTIGRAVITY_PROVIDER_ID;
+var PI_ANTIGRAVITY_VAULT_HOST = "pi";
+var PI_ANTIGRAVITY_ENROLLMENT_NAME = "antigravity-auth-pi";
+var LOCAL_MODE = Object.freeze({
+  version: 1,
+  mode: "local"
+});
+function parseModeRecord(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    return void 0;
+  const record = raw;
+  for (const key of Object.keys(record))
+    if (key !== "version" && key !== "mode" && key !== "routeId")
+      return void 0;
+  if (record.version !== 1) return void 0;
+  if (record.mode !== "local" && record.mode !== "custody") return void 0;
+  if (record.routeId === void 0)
+    return Object.freeze({ version: 1, mode: record.mode });
+  if (typeof record.routeId !== "string" || record.routeId.trim() === "")
+    return void 0;
+  return Object.freeze({
+    version: 1,
+    mode: record.mode,
+    routeId: record.routeId
+  });
+}
+function readPiVaultMode(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return { ok: true, record: LOCAL_MODE };
+    return { ok: false, reason: "the vault mode file could not be read" };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "the vault mode file is not valid JSON" };
+  }
+  const record = parseModeRecord(raw);
+  return record ? { ok: true, record } : { ok: false, reason: "the vault mode file has an unknown shape" };
+}
+async function writePiVaultMode(path, record) {
+  const value = record.routeId === void 0 ? { version: 1, mode: record.mode } : { version: 1, mode: record.mode, routeId: record.routeId };
+  await writeJsonAtomic(path, value);
+}
+var PiVaultSetupError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PiVaultSetupError";
+  }
+};
+var PiVaultSetup = class {
+  #options;
+  paths;
+  constructor(options) {
+    this.#options = options;
+    this.paths = options.claustrum.hostEnrollmentPaths({
+      stateDir: options.stateDir,
+      host: PI_ANTIGRAVITY_VAULT_HOST
+    });
+  }
+  #hostSlot() {
+    return this.#options.claustrum.classifyHostSlot(
+      this.#options.readHostSlot(),
+      PI_ANTIGRAVITY_PROVIDER_ID
+    );
+  }
+  /** Read vault approval and local/vault settings without opening Pi's Google credentials. */
+  async sourceStatus() {
+    const mode = readPiVaultMode(this.#options.modeFile);
+    const enrollment = await this.#options.claustrum.readClaustrumEnrollmentStatus(this.paths, PI_ANTIGRAVITY_ENROLLMENT_NAME).catch(
+      () => ({
+        state: "blocked",
+        proposedName: PI_ANTIGRAVITY_ENROLLMENT_NAME,
+        code: "unreadable-state"
+      })
+    );
+    const authority = await enrollmentAuthority(
+      this.paths,
+      PI_ANTIGRAVITY_ENROLLMENT_NAME,
+      this.#options.claustrum
+    );
+    return {
+      ...authority !== "local" ? {
+        mode: authority === "vault" ? "custody" : "unreadable",
+        ...mode.ok && mode.record.routeId !== void 0 && {
+          selectedRouteId: mode.record.routeId
+        }
+      } : mode.ok ? {
+        mode: mode.record.mode,
+        ...mode.record.routeId !== void 0 && {
+          selectedRouteId: mode.record.routeId
+        }
+      } : { mode: "unreadable", modeProblem: mode.reason },
+      enrollment
+    };
+  }
+  /** Inspect the native login only when local accounts are selected. */
+  async status() {
+    const source = await this.sourceStatus();
+    return {
+      ...source,
+      hostSlot: source.mode === "local" ? this.#hostSlot() : "dormant"
+    };
+  }
+  /**
+   * Propose Pi to the vault or poll its recorded proposal. Clear a denied or
+   * blocked request before starting again. Only setup actions call this method.
+   */
+  async connectStep() {
+    const client = await this.#options.connectEnrollment();
+    try {
+      const manager = new this.#options.claustrum.ClaustrumEnrollmentManager({
+        client,
+        paths: this.paths,
+        proposedName: PI_ANTIGRAVITY_ENROLLMENT_NAME,
+        ...this.#options.now && { now: this.#options.now }
+      });
+      const current = await manager.status();
+      if (current.state === "denied" || current.state === "blocked")
+        await manager.resetTerminal();
+      const reconciled = await manager.reconcile();
+      if (reconciled.state === "approved") {
+        const saved = readPiVaultMode(this.#options.modeFile);
+        await this.useVault(
+          saved.ok && saved.record.mode === "custody" ? saved.record.routeId : void 0
+        );
+      }
+      return reconciled;
+    } finally {
+      client.close();
+    }
+  }
+  /**
+   * Select the vault account used for requests after the operator approves
+   * enrollment. Await the host's Google credential-slot transition before
+   * returning, so provider registration cannot race it.
+   */
+  async useVault(routeId) {
+    const enrollment = await this.#options.claustrum.readClaustrumEnrollmentStatus(
+      this.paths,
+      PI_ANTIGRAVITY_ENROLLMENT_NAME
+    );
+    if (enrollment.state !== "approved")
+      throw new PiVaultSetupError(
+        "Pi is not enrolled with the vault yet. Request access and wait for the operator to approve it first."
+      );
+    if (routeId !== void 0 && routeId.trim() === "")
+      throw new PiVaultSetupError("Choose a vault account to use.");
+    const record = routeId === void 0 ? { version: 1, mode: "custody" } : { version: 1, mode: "custody", routeId };
+    await writePiVaultMode(this.#options.modeFile, record);
+    await this.#options.onModeChanged?.(record);
+    return record;
+  }
+  /** Use Pi's local login only after vault enrollment has been disconnected. */
+  async useLocal() {
+    if (await enrollmentAuthority(
+      this.paths,
+      PI_ANTIGRAVITY_ENROLLMENT_NAME,
+      this.#options.claustrum
+    ) !== "local") {
+      throw new PiVaultSetupError(
+        "Disconnect vault enrollment before using local accounts."
+      );
+    }
+    await writePiVaultMode(this.#options.modeFile, LOCAL_MODE);
+    await this.#options.onModeChanged?.(LOCAL_MODE);
+    return LOCAL_MODE;
+  }
+  /**
+   * Forget this host's enrollment (token and ceremony state) and go back to
+   * local mode. The vault keeps the enrollment approved until the operator
+   * revokes it there.
+   */
+  async disconnect() {
+    const result = await this.#options.claustrum.disconnectClaustrumEnrollment(
+      this.paths,
+      PI_ANTIGRAVITY_ENROLLMENT_NAME
+    );
+    if (result === "busy")
+      throw new PiVaultSetupError(
+        "Vault enrollment is busy; disconnect did not change it."
+      );
+    await writePiVaultMode(this.#options.modeFile, LOCAL_MODE);
+    await this.#options.onModeChanged?.(LOCAL_MODE);
+  }
+};
+function describeEnrollment(status) {
+  switch (status.state) {
+    case "idle":
+      return "not requested";
+    case "pending":
+      return status.retryCode ? `waiting for operator approval (retrying: ${status.retryCode})` : "waiting for operator approval";
+    case "approved":
+      return `approved as ${status.approvedName ?? status.proposedName}`;
+    case "denied":
+      return "denied by the operator";
+    case "blocked":
+      return `blocked (${status.code})`;
+    case "unavailable":
+      return `vault unavailable (${status.code})`;
+    case "busy":
+      return "another setup step is running";
+  }
+}
+function describeHostSlot(slot) {
+  switch (slot) {
+    case "login":
+      return "signed in with a Pi login";
+    case "placeholder":
+      return "holds the vault placeholder";
+    case "empty":
+      return "empty";
+  }
+}
+function formatPiVaultSetupStatus(status) {
+  const lines = [
+    `Mode: ${status.mode === "custody" ? "vault (custody)" : status.mode === "local" ? "local Pi login" : `unreadable (${status.modeProblem ?? "unknown problem"})`}`,
+    `Enrollment (${PI_ANTIGRAVITY_ENROLLMENT_NAME}): ${describeEnrollment(status.enrollment)}`,
+    status.hostSlot === "dormant" ? "Pi auth slot: dormant (not read)" : `Pi auth slot: ${describeHostSlot(status.hostSlot)}`
+  ];
+  if (status.selectedRouteId !== void 0)
+    lines.push("Vault account: a specific account is chosen (marked below)");
+  if (status.mode === "local" && status.hostSlot === "placeholder")
+    lines.push(
+      "Conflict: local mode has no login to serve. Run /login or switch to the vault."
+    );
+  return lines;
+}
+var ITEM_ID_SALT = randomBytes(16);
+function vaultAccountName(listed, account) {
+  return `Vault account ${listed.indexOf(account) + 1}`;
+}
+function opaqueItemId(routeId) {
+  return `vault-${createHash("sha256").update(ITEM_ID_SALT).update(routeId).digest("hex").slice(0, 16)}`;
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function refused(error) {
+  if (error instanceof PiVaultSetupError)
+    return { ok: false, text: error.message, code: "vault-refused" };
+  throw error;
+}
+async function waitForApproval(setup, wait = {}) {
+  const sleep = wait.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = wait.pollIntervalMs ?? 2e3;
+  const deadline = Date.now() + (wait.timeoutMs ?? 10 * 6e4);
+  let status = await setup.connectStep();
+  while (status.state === "pending" || status.state === "busy") {
+    if (Date.now() >= deadline) return status;
+    await sleep(interval);
+    status = await setup.connectStep();
+  }
+  return status;
+}
+function createPiVaultSection(options) {
+  return {
+    id: "vault",
+    title: "Vault",
+    build: async () => {
+      const setup = await options.setup();
+      const status = await setup.status();
+      const approved = status.enrollment.state === "approved";
+      const lines = formatPiVaultSetupStatus(status);
+      const items = [];
+      const port = approved ? options.accounts?.() : void 0;
+      if (port) {
+        try {
+          const listed = await port.list();
+          for (const account of listed) {
+            const name = vaultAccountName(listed, account);
+            const serving = status.mode === "custody" && status.selectedRouteId === account.routeId;
+            items.push({
+              id: opaqueItemId(account.routeId),
+              label: name,
+              detail: account.declined ? "declined on this host" : serving ? "serving Pi" : "available",
+              actions: account.declined ? [
+                {
+                  id: "accept",
+                  label: "Accept on this host",
+                  run: async () => {
+                    await port.accept(account.routeId);
+                    return `${name} is accepted on this host.`;
+                  }
+                }
+              ] : [
+                {
+                  id: "use",
+                  label: "Serve Pi from this account",
+                  run: async () => {
+                    try {
+                      await setup.useVault(account.routeId);
+                    } catch (error) {
+                      return refused(error);
+                    }
+                    return `Pi now serves Antigravity from ${name}.`;
+                  }
+                },
+                {
+                  id: "decline",
+                  label: "Decline on this host",
+                  description: "It stays in the vault and in this list, and is never sent from this host until accepted again.",
+                  run: async () => {
+                    await port.decline(account.routeId);
+                    return `${name} is declined on this host.`;
+                  }
+                }
+              ]
+            });
+          }
+        } catch (error) {
+          lines.push(`Vault accounts unavailable: ${errorText(error)}`);
+        }
+      }
+      const actions = [];
+      if (!approved)
+        actions.push({
+          id: "request-access",
+          label: "Request vault access",
+          description: `Asks the vault to enroll Pi as ${PI_ANTIGRAVITY_ENROLLMENT_NAME}; the operator approves it in the vault.`,
+          run: async ({ invocation }) => {
+            const step = await setup.connectStep();
+            if (step.state !== "pending" && step.state !== "busy")
+              return {
+                ok: step.state === "approved",
+                text: `Enrollment: ${describeEnrollment(step)}`
+              };
+            void waitForApproval(setup, options.wait).then((final) => {
+              invocation.notify(
+                `Enrollment: ${describeEnrollment(final)}`,
+                final.state === "approved" ? "info" : "warning"
+              );
+            }).catch((error) => {
+              invocation.notify(
+                `Requesting vault access failed: ${errorText(error)}`,
+                "error"
+              );
+            });
+            return {
+              ok: true,
+              text: `Enrollment: ${describeEnrollment(step)}. You are told here when the operator decides.`
+            };
+          }
+        });
+      if (approved && status.mode !== "custody")
+        actions.push({
+          id: "use-vault",
+          label: "Serve Pi from the vault",
+          run: async () => {
+            try {
+              await setup.useVault(status.selectedRouteId);
+            } catch (error) {
+              return refused(error);
+            }
+            return "Pi now serves Antigravity from the vault.";
+          }
+        });
+      if (status.mode !== "local" && (status.enrollment.state === "idle" || status.enrollment.state === "pending" || status.enrollment.state === "denied"))
+        actions.push({
+          id: "use-local",
+          label: "Serve Pi from its own login",
+          run: async () => {
+            await setup.useLocal();
+            return "Pi now serves Antigravity from its own login. Run /login if it has none.";
+          }
+        });
+      if (status.enrollment.state !== "idle")
+        actions.push({
+          id: "forget",
+          label: "Forget vault enrollment",
+          description: "Deletes Pi's enrollment token and returns to the local login. The operator can still revoke the enrollment in the vault.",
+          irreversible: true,
+          confirm: `Forget the ${PI_ANTIGRAVITY_ENROLLMENT_NAME} enrollment? Using the vault again needs a new approval.`,
+          run: async () => {
+            await setup.disconnect();
+            return "Vault enrollment forgotten; Pi serves Antigravity from its own login.";
+          }
+        });
+      return { lines, items, actions };
+    }
+  };
+}
+
+// src/commands.ts
+function registerPiAntigravityCommand(pi, options) {
+  const loadCommands = options.loadCommands ?? loadCommonAuthCommands;
+  pi.registerCommand(ANTIGRAVITY_MENU_COMMAND, {
+    description: "Google Antigravity: the account Pi serves, and the Claustrum vault",
+    handler: async (_args, ctx) => {
+      const commands = await loadCommands();
+      const menu = createAntigravityCommandMenu({
+        commands,
+        source: "sections",
+        sections: options.sections,
+        extras: options.extras
+      });
+      await commands.runPiCommandMenu(menu, ctx.ui, {
+        sessionId: ctx.sessionManager.getSessionId()
+      });
+    }
+  });
+}
+function servingAccount(status, accounts) {
+  const available = accounts.filter((account) => !account.declined);
+  if (status.selectedRouteId !== void 0)
+    return available.find(
+      (account) => account.routeId === status.selectedRouteId
+    );
+  return available.length === 1 ? available[0] : void 0;
+}
+async function custodyAccounts(status, options) {
+  if (status.mode !== "custody" || status.enrollment.state !== "approved")
+    return { list: [] };
+  try {
+    return { list: await options.accounts().list() };
+  } catch (error) {
+    return {
+      list: [],
+      problem: `Vault accounts unavailable: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function localLoginLine(status) {
+  switch (status.hostSlot) {
+    case "dormant":
+      return "The native Pi login is dormant while vault enrollment controls serving.";
+    case "login":
+      return "Signed in with Pi's own login. Pi's /login replaces it and /logout removes it.";
+    case "placeholder":
+      return "Pi holds the vault placeholder, not a login. Run /login, or serve from the vault in the Vault section.";
+    case "empty":
+      return "Not signed in. Run Pi's /login to sign in.";
+  }
+}
+function createPiAntigravityAccountSections(options) {
+  return {
+    accounts: {
+      title: "Accounts",
+      build: async () => {
+        const status = await (await options.setup()).status();
+        if (status.mode === "unreadable")
+          return {
+            lines: [
+              `The vault mode file is unreadable (${status.modeProblem ?? "unknown problem"}); Pi serves nothing until a mode is chosen in the Vault section.`
+            ]
+          };
+        if (status.mode === "local")
+          return {
+            lines: [
+              "Pi serves Antigravity from its own login, one account, kept in Pi's auth store.",
+              localLoginLine(status)
+            ]
+          };
+        const { list, problem } = await custodyAccounts(status, options);
+        const serving = servingAccount(status, list);
+        const items = list.map((account) => ({
+          id: opaqueItemId(account.routeId),
+          label: vaultAccountName(list, account),
+          detail: account.declined ? "declined on this host" : account === serving ? "serving Pi" : "available"
+        }));
+        return {
+          lines: [
+            "Pi serves Antigravity from the vault, one account at a time. Choose, decline or accept accounts in the Vault section.",
+            ...status.hostSlot === "login" ? [
+              "Conflict: Pi also holds its own login. Requests are refused until /logout or a switch back to the local login."
+            ] : [],
+            ...problem ? [problem] : []
+          ],
+          items
+        };
+      }
+    },
+    quota: {
+      title: "Quota",
+      build: () => ({
+        lines: [
+          "Pi does not record Antigravity quota. A request Google refuses for quota fails with Google's own error."
+        ]
+      })
+    },
+    routing: {
+      title: "Routing",
+      build: async () => {
+        const status = await (await options.setup()).status();
+        if (status.mode === "unreadable")
+          return {
+            lines: [
+              "Vault enrollment authority is unreadable; requests are refused. Recover or Disconnect in the Vault section."
+            ]
+          };
+        if (status.mode !== "custody")
+          return {
+            lines: [
+              "Every request uses Pi's own login. There is no account rotation."
+            ]
+          };
+        const { list } = await custodyAccounts(status, options);
+        const serving = servingAccount(status, list);
+        return {
+          lines: [
+            serving ? `Every request uses ${vaultAccountName(list, serving)}, with a fresh token and project from the vault for each send. There is no account rotation.` : "No single vault account is chosen, so requests are refused. Choose one in the Vault section. There is no account rotation."
+          ]
+        };
+      }
+    },
+    limits: {
+      title: "Limits",
+      build: () => ({
+        lines: [
+          "Pi has no per-account limits for Antigravity: with one account there is nothing to fall back to."
+        ]
+      })
+    }
+  };
+}
 
 // src/credential-cache.ts
 var packedRefreshByAccessToken = /* @__PURE__ */ new Map();
@@ -23,15 +566,40 @@ function getPackedRefresh(accessToken) {
   return packedRefreshByAccessToken.get(accessToken);
 }
 
+// src/paths.ts
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getPiConfigDir() {
+  return process.env.PI_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+}
+function getPiAntigravityAuthFile() {
+  return process.env.PI_ANTIGRAVITY_AUTH_FILE?.trim() || join(getPiConfigDir(), "antigravity-accounts.json");
+}
+function getPiAntigravityVaultDir() {
+  return join(dirname(getPiAntigravityAuthFile()), "antigravity-auth-vault");
+}
+function getPiAntigravityVaultModeFile() {
+  return join(getPiAntigravityVaultDir(), "pi-mode.json");
+}
+function getPiAntigravityVaultRosterFile() {
+  return join(getPiAntigravityVaultDir(), "pi-roster.json");
+}
+
 // src/stream.ts
 import {
   AgyRequestSessionStore,
   ANTIGRAVITY_ENDPOINT,
+  applyAgyNativeGenerationConfig,
   buildAgyAgentRequestMetadata,
   buildAntigravityHarnessUserAgent,
   ensureProjectContext,
   fetchWithAgyCliTransport,
+  forwardAbort,
+  isRetiredAgyModel,
   orderAgyRequestPayloadInPlace,
+  RETIRED_AGY_MODEL_MESSAGE,
+  redactCredentialError,
+  redactCredentialText,
   resolveModelForHeaderStyle
 } from "@cortexkit/antigravity-auth-core";
 import {
@@ -41,6 +609,7 @@ import {
 
 // src/convert.ts
 import { toGeminiSchema } from "@cortexkit/antigravity-auth-core";
+import * as piAi from "@earendil-works/pi-ai";
 function sanitize(text) {
   return text.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
 }
@@ -109,6 +678,7 @@ function convertMessages(messages, options) {
   }
   for (const message of messages) {
     if (!message) continue;
+    if (message.role === "system") continue;
     if (message.role === "user") {
       const parts = typeof message.content === "string" ? message.content.trim() ? [{ text: sanitize(message.content) }] : [] : convertUserParts(
         message.content
@@ -158,15 +728,33 @@ function convertTools(tools) {
     }
   ];
 }
+function resolveInstructionState(context) {
+  if (!context.messages.some((message) => message?.role === "system")) {
+    return {
+      systemPrompt: context.systemPrompt ?? "",
+      tools: context.tools ?? []
+    };
+  }
+  if (typeof piAi.getCurrentSystemPrompt !== "function" || typeof piAi.getCurrentTools !== "function") {
+    throw new Error(
+      "Pi transcript contains system messages but the installed @earendil-works/pi-ai does not export getCurrentSystemPrompt/getCurrentTools (requires >= 0.86)"
+    );
+  }
+  return {
+    systemPrompt: piAi.getCurrentSystemPrompt(context.messages),
+    tools: piAi.getCurrentTools(context.messages)
+  };
+}
 function buildGeminiRequest(context, options) {
   const request = {
     contents: convertMessages(context.messages, options)
   };
-  const tools = convertTools(context.tools);
-  if (tools) request.tools = tools;
-  if (context.systemPrompt?.trim()) {
+  const { systemPrompt, tools } = resolveInstructionState(context);
+  const geminiTools = convertTools(tools);
+  if (geminiTools) request.tools = geminiTools;
+  if (systemPrompt.trim()) {
     request.systemInstruction = {
-      parts: [{ text: sanitize(context.systemPrompt) }]
+      parts: [{ text: sanitize(systemPrompt) }]
     };
   }
   return request;
@@ -327,7 +915,9 @@ function getRequestSessionKey(context, options) {
   if (options?.sessionId) {
     return options.sessionId;
   }
-  const firstTimestamp = context.messages[0]?.timestamp;
+  const firstTimestamp = context.messages.find(
+    (message) => message.role !== "system"
+  )?.timestamp;
   return firstTimestamp !== void 0 ? `message:${firstTimestamp}` : FALLBACK_SESSION_KEY;
 }
 function finalizePiAntigravityRequest(request, wireModel, scope) {
@@ -348,7 +938,7 @@ function finalizePiAntigravityRequest(request, wireModel, scope) {
 }
 function resolvePiAntigravityModel(model, reasoning) {
   const lower = model.id.toLowerCase();
-  const supportsAgyTiers = model.reasoning && (lower.includes("gemini-3") || lower.includes("claude") && lower.includes("thinking"));
+  const supportsAgyTiers = model.reasoning && (lower.includes("gemini-3") || lower.includes("claude") && (lower.includes("thinking") || /claude-(opus|sonnet)-5-5/.test(lower)));
   if (!supportsAgyTiers || !reasoning) {
     return resolveModelForHeaderStyle(model.id, "antigravity");
   }
@@ -356,23 +946,21 @@ function resolvePiAntigravityModel(model, reasoning) {
   const baseModel = model.id.replace(/-(minimal|low|medium|high|xhigh)$/i, "");
   return resolveModelForHeaderStyle(`${baseModel}-${tier}`, "antigravity");
 }
-async function sendAntigravityRequest(options) {
+function prepareAntigravityRequest(options) {
   const resolved = resolvePiAntigravityModel(
     options.model,
     options.streamOptions?.reasoning
   );
   const wireModel = resolved.actualModel;
-  const packedRefresh = getPackedRefresh(options.accessToken) ?? "";
-  const projectContext = await ensureProjectContext({
-    type: "oauth",
-    refresh: packedRefresh,
-    access: options.accessToken,
-    expires: Date.now() + 6e4
-  });
-  const request = buildGeminiRequest(options.context, {
-    provider: options.model.provider,
-    model: options.model.id
-  });
+  if (isRetiredAgyModel(options.model.id) || isRetiredAgyModel(wireModel)) {
+    throw new Error(RETIRED_AGY_MODEL_MESSAGE);
+  }
+  const request = {
+    ...buildGeminiRequest(options.context, {
+      provider: options.model.provider,
+      model: options.model.id
+    })
+  };
   const generationConfig = {};
   if (resolved.thinkingLevel) {
     generationConfig.thinkingConfig = {
@@ -389,6 +977,7 @@ async function sendAntigravityRequest(options) {
   if (typeof maxTokens === "number") {
     generationConfig.maxOutputTokens = maxTokens;
   }
+  applyAgyNativeGenerationConfig(wireModel, generationConfig);
   if (Object.keys(generationConfig).length > 0) {
     request.generationConfig = generationConfig;
   }
@@ -398,11 +987,14 @@ async function sendAntigravityRequest(options) {
     wireModel,
     requestScope
   );
+  return { wireModel, requestId, request };
+}
+function dispatchAntigravityRequest(prepared, credential, signal) {
   const envelope = {
-    project: projectContext.effectiveProjectId,
-    requestId,
-    request,
-    model: wireModel,
+    project: credential.projectId,
+    requestId: prepared.requestId,
+    request: prepared.request,
+    model: prepared.wireModel,
     userAgent: "antigravity",
     requestType: "agent"
   };
@@ -412,39 +1004,113 @@ async function sendAntigravityRequest(options) {
     {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${options.accessToken}`,
+        Authorization: `Bearer ${credential.accessToken}`,
         "Content-Type": "application/json",
         "User-Agent": buildAntigravityHarnessUserAgent(),
         "Accept-Encoding": "gzip"
       },
       body: JSON.stringify(envelope)
     },
-    { signal: options.signal ?? options.streamOptions?.signal ?? null }
+    { signal }
   );
 }
-function streamCortexKitAntigravity(model, context, options) {
+async function sendAntigravityRequest(options) {
+  if (isRetiredAgyModel(options.model.id)) {
+    throw new Error(RETIRED_AGY_MODEL_MESSAGE);
+  }
+  const packedRefresh = getPackedRefresh(options.accessToken) ?? "";
+  const projectContext = await ensureProjectContext({
+    type: "oauth",
+    refresh: packedRefresh,
+    access: options.accessToken,
+    expires: Date.now() + 6e4
+  });
+  const prepared = prepareAntigravityRequest(options);
+  await options.assertAdmission?.();
+  return dispatchAntigravityRequest(
+    prepared,
+    {
+      accessToken: options.accessToken,
+      projectId: projectContext.effectiveProjectId
+    },
+    options.signal ?? options.streamOptions?.signal ?? null
+  );
+}
+function streamCortexKitAntigravity(model, context, options, assertAdmission) {
+  return runAntigravityStream(
+    model,
+    context,
+    options,
+    async (sessionKey, signal) => {
+      await assertAdmission?.();
+      const accessToken = options?.apiKey ?? "";
+      if (!accessToken)
+        throw new Error("Missing Antigravity OAuth access token");
+      return sendAntigravityRequest({
+        model,
+        context,
+        streamOptions: options,
+        accessToken,
+        sessionKey,
+        signal,
+        assertAdmission
+      });
+    }
+  );
+}
+function createCortexKitAntigravityVaultStream(send, placeholderKey) {
+  return (model, context, options) => runAntigravityStream(
+    model,
+    context,
+    options,
+    (sessionKey, signal, selectedCredentials) => {
+      if (options?.apiKey !== placeholderKey)
+        throw new Error(
+          "The native Google credential slot is not synchronized for vault mode. No request was sent."
+        );
+      const prepared = prepareAntigravityRequest({
+        model,
+        context,
+        streamOptions: options,
+        sessionKey
+      });
+      return send(async (credential, sendSignal) => {
+        selectedCredentials.add(credential.accessToken);
+        try {
+          return await dispatchAntigravityRequest(
+            prepared,
+            credential,
+            sendSignal ?? signal
+          );
+        } catch (error) {
+          throw redactCredentialError(error, [...selectedCredentials]);
+        }
+      }, signal);
+    }
+  );
+}
+function runAntigravityStream(model, context, options, open) {
   const stream = createAssistantMessageEventStream();
   void (async () => {
     const output = createOutput(model);
+    const selectedCredentials = new Set(
+      options?.apiKey ? [options.apiKey] : []
+    );
     stream.push({ type: "start", partial: output });
     let response;
     let requestAbort;
     let chunkIterator;
+    let detachCaller = () => {
+    };
     try {
-      const accessToken = options?.apiKey ?? "";
-      if (!accessToken)
-        throw new Error("Missing Antigravity OAuth access token");
       const sessionKey = getRequestSessionKey(context, options);
       requestAbort = new AbortController();
-      const requestSignal = options?.signal ? AbortSignal.any([options.signal, requestAbort.signal]) : requestAbort.signal;
-      response = await sendAntigravityRequest({
-        model,
-        context,
-        streamOptions: options,
-        accessToken,
+      detachCaller = forwardAbort(options?.signal, requestAbort);
+      response = await open(
         sessionKey,
-        signal: requestSignal
-      });
+        requestAbort.signal,
+        selectedCredentials
+      );
       if (!response.ok) {
         throw new Error(
           `Antigravity request failed: HTTP ${response.status} ${await response.text()}`
@@ -641,16 +1307,221 @@ function streamCortexKitAntigravity(model, context, options) {
       await response?.body?.cancel().catch(() => {
       });
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-      output.errorMessage = error instanceof Error ? error.message : String(error);
+      output.errorMessage = redactCredentialText(
+        error instanceof Error ? error.message : String(error),
+        [...selectedCredentials]
+      );
       stream.push({ type: "error", reason: output.stopReason, error: output });
       stream.end();
+    } finally {
+      detachCaller();
     }
   })();
   return stream;
 }
 
+// src/vault-source.ts
+import { existsSync } from "node:fs";
+import {
+  createAntigravityVaultAccountSource,
+  enrollmentAuthority as enrollmentAuthority2,
+  loadCommonAuthClaustrum
+} from "@cortexkit/antigravity-auth-core";
+var PiVaultSendError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PiVaultSendError";
+  }
+};
+function requireCustody(read) {
+  if (!read.ok)
+    throw new PiVaultSendError(
+      `Antigravity vault mode is unclear (${read.reason}). Choose a mode in the Vault section of the Antigravity menu.`
+    );
+  if (read.record.mode !== "custody")
+    throw new PiVaultSendError(
+      "Antigravity is not served from the vault. Switch in the Vault section of the Antigravity menu."
+    );
+  return read.record;
+}
+function selectRoute(routes, routeId) {
+  if (routeId !== void 0) {
+    const selected = routes.find((route) => route.routeId === routeId);
+    if (!selected)
+      throw new PiVaultSendError(
+        "The chosen vault account is no longer available (declined, removed or changed). Choose another in the Vault section of the Antigravity menu."
+      );
+    return selected;
+  }
+  const [only, ...rest] = routes;
+  if (!only)
+    throw new PiVaultSendError(
+      "The vault serves Pi no Antigravity accounts yet."
+    );
+  if (rest.length > 0)
+    throw new PiVaultSendError(
+      "The vault serves Pi several Antigravity accounts. Choose one in the Vault section of the Antigravity menu."
+    );
+  return only;
+}
+async function openCustody(options) {
+  const record = requireCustody(await options.readMode());
+  const source = await options.source();
+  return { record, source };
+}
+function createPiVaultSend(options) {
+  return async (dispatch, signal) => {
+    const { record, source } = await openCustody(options);
+    signal.throwIfAborted();
+    let routes = source.routes();
+    if (routes.length === 0) {
+      await source.refresh();
+      signal.throwIfAborted();
+      routes = source.routes();
+    }
+    const ref = selectRoute(routes, record.routeId);
+    return source.send(ref, dispatch, { site: "model", signal });
+  };
+}
+function createPiVaultAccountsPort(options) {
+  let lastRows = /* @__PURE__ */ new Map();
+  const refFor = (routeId) => {
+    const ref = lastRows.get(routeId);
+    if (!ref)
+      throw new PiVaultSendError(
+        "That vault account is no longer listed. Open the Vault section again."
+      );
+    return ref;
+  };
+  return {
+    list: async () => {
+      const { source } = await openCustody(options);
+      const roster = await source.refresh();
+      const rows = /* @__PURE__ */ new Map();
+      const choices = [];
+      for (const row of roster?.rows ?? []) {
+        if (!row.accountIdentity) continue;
+        const ref = {
+          routeId: row.routeId,
+          credentialId: row.credentialId,
+          accountIdentity: row.accountIdentity,
+          label: row.label,
+          ...row.email !== void 0 && { email: row.email }
+        };
+        rows.set(row.routeId, ref);
+        const declined = (roster?.declined ?? []).some(
+          (entry) => entry.credentialId === row.credentialId && (entry.accountIdentity === void 0 || entry.accountIdentity === row.accountIdentity)
+        );
+        choices.push({
+          routeId: row.routeId,
+          label: row.label,
+          ...row.email !== void 0 && { email: row.email },
+          declined
+        });
+      }
+      lastRows = rows;
+      return choices;
+    },
+    decline: async (routeId) => {
+      const { source } = await openCustody(options);
+      await source.decline(refFor(routeId));
+    },
+    accept: async (routeId) => {
+      const { source } = await openCustody(options);
+      await source.accept(refFor(routeId));
+    }
+  };
+}
+async function claustrumConnectionFile() {
+  const { resolveClaustrumConnectionPath } = await import("@cortexkit/claustrum-client");
+  return resolveClaustrumConnectionPath();
+}
+function memoize(load) {
+  let pending;
+  return () => {
+    pending ??= load().catch((error) => {
+      pending = void 0;
+      throw error;
+    });
+    return pending;
+  };
+}
+function createPiVaultRuntime(readHostSlot, seams = {}, onModeChanged) {
+  const vaultDir = seams.vaultDir ?? getPiAntigravityVaultDir();
+  const modeFile = seams.modeFile ?? getPiAntigravityVaultModeFile();
+  const rosterFile = seams.rosterFile ?? getPiAntigravityVaultRosterFile();
+  const loadClaustrum = seams.loadClaustrum ?? loadCommonAuthClaustrum;
+  const readMode = () => readPiVaultMode(modeFile);
+  const source = memoize(async () => {
+    const claustrum = await loadClaustrum();
+    const { tokenPath } = claustrum.hostEnrollmentPaths({
+      stateDir: vaultDir,
+      host: PI_ANTIGRAVITY_VAULT_HOST
+    });
+    return createAntigravityVaultAccountSource({
+      claustrum,
+      host: PI_ANTIGRAVITY_VAULT_HOST,
+      rosterPath: rosterFile,
+      tokenPath,
+      connect: seams.connect ?? (async () => claustrum.connectClaustrumScopedClient({
+        connectionFile: await claustrumConnectionFile()
+      })),
+      // The vault serves this host only once setup has stored an approved
+      // enrollment token; Pi's own send path also requires custody mode.
+      isCustodyActive: () => existsSync(tokenPath),
+      // Pi reads the HTTP status of each send itself.
+      reporterSource: "direct"
+    });
+  });
+  const setup = memoize(async () => {
+    const claustrum = await loadClaustrum();
+    return new PiVaultSetup({
+      claustrum,
+      stateDir: vaultDir,
+      modeFile,
+      readHostSlot,
+      ...onModeChanged && { onModeChanged },
+      connectEnrollment: seams.connectEnrollment ?? (async () => claustrum.connectClaustrumEnrollmentClient({
+        connectionFile: await claustrumConnectionFile()
+      }))
+    });
+  });
+  return {
+    readMode,
+    setup,
+    requestPath: {
+      readMode: async () => {
+        const settings = await setup();
+        const status = await settings.sourceStatus();
+        const authority = await enrollmentAuthority2(
+          settings.paths,
+          PI_ANTIGRAVITY_ENROLLMENT_NAME
+        );
+        if (authority === "local" && status.mode === "custody")
+          throw new PiVaultSendError(
+            "Vault enrollment is not active. No request was sent."
+          );
+        if (status.mode === "unreadable")
+          throw new PiVaultSendError(
+            "Vault enrollment or source settings cannot be read."
+          );
+        return {
+          ok: true,
+          record: {
+            version: 1,
+            mode: status.mode,
+            ...status.selectedRouteId ? { routeId: status.selectedRouteId } : {}
+          }
+        };
+      },
+      source
+    }
+  };
+}
+
 // src/index.ts
-var ANTIGRAVITY_PROVIDER_ID = "google-antigravity";
+var CUSTODY_PLACEHOLDER_REFRESH_PREFIX = "claustrum-tombstone:v1:";
+var CUSTODY_PROVIDER_KEY_MARKER = "antigravity-vault-custody";
 function textImageInput() {
   return ["text", "image"];
 }
@@ -682,6 +1553,10 @@ async function loginAntigravity(callbacks) {
   };
 }
 async function refreshAntigravityCredentials(credentials) {
+  if (credentials.refresh.startsWith(CUSTODY_PLACEHOLDER_REFRESH_PREFIX))
+    throw new Error(
+      "Pi holds the Antigravity vault placeholder, not a login. Run /login, or serve Antigravity from the vault."
+    );
   const refreshToken = credentials.refresh.split("|")[0] ?? credentials.refresh;
   const refreshed = await refreshAntigravityToken(refreshToken);
   const projectSegments = credentials.refresh.includes("|") ? credentials.refresh.slice(credentials.refresh.indexOf("|")) : "";
@@ -691,8 +1566,8 @@ async function refreshAntigravityCredentials(credentials) {
     expires: refreshed.expires
   };
 }
-function cortexKitPiAntigravityAuth(pi) {
-  const models = Object.values(getPublicModelDefinitions()).filter((model) => !model.modalities.output.includes("image")).map((model) => ({
+function publicModels() {
+  return Object.values(getPublicModelDefinitions()).filter((model) => !model.modalities.output.includes("image")).map((model) => ({
     id: model.id,
     name: model.name,
     reasoning: model.reasoning,
@@ -701,24 +1576,187 @@ function cortexKitPiAntigravityAuth(pi) {
     contextWindow: model.limit.context,
     maxTokens: model.limit.output
   }));
-  pi.registerProvider(ANTIGRAVITY_PROVIDER_ID, {
+}
+function localProviderConfig(models, assertLocalAdmission) {
+  return {
     name: "Google Antigravity (CortexKit OAuth)",
     baseUrl: "https://cloudcode-pa.googleapis.com",
     api: "google-generative-ai",
     models,
     oauth: {
       name: "Google Antigravity (CortexKit)",
-      login: loginAntigravity,
-      refreshToken: refreshAntigravityCredentials,
+      login: async (callbacks) => {
+        await assertLocalAdmission();
+        return loginAntigravity(callbacks);
+      },
+      refreshToken: async (credentials) => {
+        await assertLocalAdmission();
+        return refreshAntigravityCredentials(credentials);
+      },
       getApiKey: (credentials) => {
         rememberPackedRefresh(credentials.access, credentials.refresh);
         return credentials.access;
       }
     },
-    streamSimple: streamCortexKitAntigravity
+    streamSimple: (model, context, options) => streamCortexKitAntigravity(model, context, options, assertLocalAdmission)
+  };
+}
+function custodyProviderConfig(models, send) {
+  return {
+    name: "Google Antigravity (CortexKit vault)",
+    baseUrl: "https://cloudcode-pa.googleapis.com",
+    api: "google-generative-ai",
+    models,
+    apiKey: CUSTODY_PROVIDER_KEY_MARKER,
+    streamSimple: createCortexKitAntigravityVaultStream(
+      send,
+      CUSTODY_PROVIDER_KEY_MARKER
+    )
+  };
+}
+function refusingProviderConfig(models, reason) {
+  return {
+    name: "Google Antigravity (CortexKit, unavailable)",
+    baseUrl: "https://cloudcode-pa.googleapis.com",
+    api: "google-generative-ai",
+    models,
+    apiKey: CUSTODY_PROVIDER_KEY_MARKER,
+    streamSimple: createCortexKitAntigravityVaultStream(async () => {
+      throw new PiVaultSetupError(
+        `${reason} Resolve it from /antigravity; Antigravity requests are refused until then. No request was sent.`
+      );
+    }, CUSTODY_PROVIDER_KEY_MARKER)
+  };
+}
+async function registerCortexKitPiAntigravity(pi, seams = {}) {
+  const models = publicModels();
+  const readHostSlot = seams.readHostSlot ?? (() => readStoredCredential(ANTIGRAVITY_PROVIDER_ID2));
+  let refreshRegistry;
+  const vault = createPiVaultRuntime(readHostSlot, seams, async () => {
+    try {
+      await synchronizeSlot();
+    } finally {
+      refreshRegistry?.();
+    }
   });
+  const send = createPiVaultSend(vault.requestPath);
+  const register = (mode) => {
+    const local = mode.ok && mode.record.mode === "local";
+    pi.registerProvider(
+      ANTIGRAVITY_PROVIDER_ID2,
+      local ? localProviderConfig(models, assertLocalAdmission) : custodyProviderConfig(models, send)
+    );
+  };
+  const currentMode = async () => {
+    const setup = await vault.setup();
+    const status = await setup.sourceStatus();
+    const authority = await enrollmentAuthority3(
+      setup.paths,
+      PI_ANTIGRAVITY_ENROLLMENT_NAME
+    );
+    if (authority === "unreadable" || status.mode === "unreadable") {
+      throw new PiVaultSetupError(
+        "Vault enrollment or source settings cannot be read. Local credentials remain unavailable."
+      );
+    }
+    if (authority === "vault")
+      return {
+        version: 1,
+        mode: "custody",
+        ...status.selectedRouteId ? { routeId: status.selectedRouteId } : {}
+      };
+    if (status.mode !== "local")
+      throw new PiVaultSetupError(
+        "Vault enrollment must be approved before activating vault credentials."
+      );
+    return { version: 1, mode: "local" };
+  };
+  const assertLocalAdmission = async () => {
+    if ((await currentMode()).mode !== "local")
+      throw new PiVaultSetupError(
+        "Vault enrollment excludes local login, refresh and request execution."
+      );
+  };
+  const synchronizeSlotOnce = async () => {
+    try {
+      await swapSlotForMode();
+    } catch (error) {
+      pi.registerProvider(
+        ANTIGRAVITY_PROVIDER_ID2,
+        refusingProviderConfig(
+          models,
+          error instanceof Error ? error.message : String(error)
+        )
+      );
+      throw error;
+    }
+  };
+  let synchronizing = Promise.resolve();
+  const synchronizeSlot = () => {
+    const run = synchronizing.then(synchronizeSlotOnce);
+    synchronizing = run.catch(() => {
+    });
+    return run;
+  };
+  const swapSlotForMode = async () => {
+    const mode = await currentMode();
+    const { openPiSlot } = await (seams.loadPiSlot ?? loadCommonAuthPiSlot)();
+    const slot = openPiSlot({
+      authPath: seams.nativeAuthPath ?? join2(getAgentDir(), "auth.json"),
+      stashPath: seams.nativeStashPath ?? join2(
+        seams.vaultDir ?? getPiAntigravityVaultDir(),
+        "google-login-stash.json"
+      ),
+      provider: ANTIGRAVITY_PROVIDER_ID2,
+      placeholderKey: CUSTODY_PROVIDER_KEY_MARKER
+    });
+    if (mode.mode === "custody") await slot.enterVault();
+    else if (await slot.exitVault() === "conflict")
+      throw new PiVaultSetupError(
+        "The native Google login changed. It was not overwritten; restore the saved login after resolving the conflict."
+      );
+    const after = await currentMode();
+    if (after.mode !== mode.mode)
+      throw new PiVaultSetupError(
+        "Vault enrollment changed while the credential slot was being synchronized. The account source was not activated."
+      );
+    register({ ok: true, record: after });
+  };
+  await synchronizeSlot().catch(() => {
+  });
+  pi.on?.("session_start", async (_event, context) => {
+    refreshRegistry = () => context.modelRegistry.refresh();
+    try {
+      await synchronizeSlot();
+    } finally {
+      refreshRegistry();
+    }
+  });
+  const accounts = createPiVaultAccountsPort(vault.requestPath);
+  const extension = {
+    accountSections: createPiAntigravityAccountSections({
+      setup: vault.setup,
+      accounts: () => accounts
+    }),
+    vaultSection: createPiVaultSection({
+      setup: vault.setup,
+      accounts: () => accounts
+    })
+  };
+  registerPiAntigravityCommand(pi, {
+    sections: extension.accountSections,
+    extras: [extension.vaultSection],
+    ...seams.loadCommands && { loadCommands: seams.loadCommands }
+  });
+  return extension;
+}
+async function cortexKitPiAntigravityAuth(pi) {
+  await registerCortexKitPiAntigravity(pi);
 }
 export {
-  cortexKitPiAntigravityAuth as default
+  CUSTODY_PLACEHOLDER_REFRESH_PREFIX,
+  CUSTODY_PROVIDER_KEY_MARKER,
+  cortexKitPiAntigravityAuth as default,
+  registerCortexKitPiAntigravity
 };
 //# sourceMappingURL=index.js.map