@cortexkit/opencode-antigravity-auth 3.0.1 → 3.0.3

package/dist/server.js

@@ -20437,11 +20437,11 @@ var AccountManager = class _AccountManager {
         usage: () => this.requestSaveToDisk(),
         stale: (account, label) => this.ignoreStale(account, label)
       },
-      // A repository-backed manager gets its own new trackers. A pool-file
-      // manager without supplied trackers shares the process-wide ones
-      // (`getHealthTracker`, `getTokenTracker`), as it always has.
-      healthTracker: options.healthTracker ?? (repositoryBacked ? new HealthScoreTracker() : getHealthTracker),
-      tokenTracker: options.tokenTracker ?? (repositoryBacked ? new TokenBucketTracker() : getTokenTracker),
+      // A repository-backed manager gets its own new trackers, which run on
+      // this manager's clock. A pool-file manager without supplied trackers
+      // shares the process-wide ones (`getHealthTracker`, `getTokenTracker`).
+      healthTracker: options.healthTracker ?? (repositoryBacked ? new HealthScoreTracker({}, this.now) : getHealthTracker),
+      tokenTracker: options.tokenTracker ?? (repositoryBacked ? new TokenBucketTracker({}, this.now) : getTokenTracker),
       now: this.now,
       random: options.random ?? (() => Math.random()),
       pid: options.pid ?? process.pid,
@@ -24237,29 +24237,29 @@ function appendClaudeThinkingHint(payload, hint = CLAUDE_INTERLEAVED_THINKING_HI
 }
 
 // ../core/dist/transform/gemini.js
-var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
-  "additionalProperties",
-  "$schema",
-  "$id",
-  "$comment",
-  "$ref",
-  "$defs",
-  "definitions",
-  "const",
-  "contentMediaType",
-  "contentEncoding",
-  "if",
-  "then",
-  "else",
-  "not",
-  "patternProperties",
-  "unevaluatedProperties",
-  "unevaluatedItems",
-  "dependentRequired",
-  "dependentSchemas",
-  "propertyNames",
-  "minContains",
-  "maxContains"
+var ALLOWED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "items",
+  "required",
+  "description",
+  "format",
+  "pattern",
+  "title",
+  "nullable",
+  "propertyOrdering",
+  "example",
+  "default",
+  "enum",
+  "anyOf",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties"
 ]);
 var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
   "minLength",
@@ -24274,13 +24274,121 @@ var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
   "exclusiveMaximum",
   "multipleOf"
 ]);
+function isSchemaObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function describeValue(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function sameSchemaValue(left, right) {
+  if (left === right)
+    return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => sameSchemaValue(value, right[index]));
+  }
+  if (!isSchemaObject(left) || !isSchemaObject(right))
+    return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameSchemaValue(left[key], right[key]));
+}
+function mergeSchemaAllOf(schema, hints) {
+  if (!Array.isArray(schema.allOf))
+    return schema;
+  const { allOf, ...base } = schema;
+  const branches = [base, ...allOf];
+  const properties = {};
+  const required2 = /* @__PURE__ */ new Set();
+  const descriptions = [];
+  const metadata = {};
+  let unambiguous = allOf.length > 0;
+  for (const branch of branches) {
+    if (!isSchemaObject(branch) || branch.type !== void 0 && String(branch.type).toUpperCase() !== "OBJECT" || branch.properties !== void 0 && !isSchemaObject(branch.properties)) {
+      unambiguous = false;
+      break;
+    }
+    for (const [key, value] of Object.entries(branch)) {
+      if (!["properties", "required", "description"].includes(key) && !Object.hasOwn(metadata, key))
+        metadata[key] = value;
+    }
+    if (typeof branch.description === "string")
+      descriptions.push(branch.description);
+    for (const [name, property] of Object.entries(branch.properties ?? {})) {
+      if (Object.hasOwn(properties, name) && !sameSchemaValue(properties[name], property))
+        unambiguous = false;
+      properties[name] = property;
+    }
+    if (Array.isArray(branch.required)) {
+      for (const name of branch.required) {
+        if (typeof name === "string")
+          required2.add(name);
+      }
+    }
+  }
+  if (unambiguous) {
+    return {
+      ...metadata,
+      type: "object",
+      properties,
+      ...required2.size ? { required: [...required2] } : {},
+      ...descriptions.length ? { description: descriptions.join(" ") } : {}
+    };
+  }
+  hints.push("allOf: using the first branch; other intersection constraints omitted.");
+  const first = isSchemaObject(allOf[0]) ? allOf[0] : {};
+  return {
+    ...base,
+    ...first,
+    ...base.description ? { description: base.description } : {}
+  };
+}
+var CLAUDE_VALIDATED_HINT_FIELDS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "format",
+  "default"
+]);
+function flattenClaudeUnion(schema, hints) {
+  if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0)
+    return schema;
+  const { anyOf, ...base } = schema;
+  const branches = anyOf.filter(isSchemaObject);
+  if (!branches.length)
+    return base;
+  if (branches.length === anyOf.length && branches.every((branch) => Array.isArray(branch.enum) && branch.enum.length > 0 && branch.enum.every((value) => typeof value === "string") && (branch.type === void 0 || branch.type === "STRING") && !branch.properties && !branch.items)) {
+    return {
+      ...base,
+      type: "STRING",
+      enum: [...new Set(branches.flatMap((branch) => branch.enum))]
+    };
+  }
+  const typeName = (branch) => branch.properties ? "object" : branch.items ? "array" : String(branch.type ?? "null").toLowerCase();
+  const score = (branch) => {
+    const type = typeName(branch);
+    return type === "object" ? 3 : type === "array" ? 2 : type === "null" ? 0 : 1;
+  };
+  let selected = branches[0];
+  for (const branch of branches.slice(1)) {
+    if (score(branch) > score(selected))
+      selected = branch;
+  }
+  const result = { ...base, ...selected };
+  if (typeof base.description === "string" && base.description) {
+    result.description = typeof selected.description === "string" && selected.description && selected.description !== base.description ? `${base.description} (${selected.description})` : base.description;
+  }
+  if (branches.length > 1)
+    hints.push(`Accepts: ${[...new Set(branches.map(typeName))].join(" | ")}`);
+  return result;
+}
 function toGeminiSchema(schema, options = {}) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     return schema;
   }
-  const inputSchema = schema;
-  const result = {};
   const numericConstraintHints = [];
+  const inputSchema = mergeSchemaAllOf(schema, numericConstraintHints);
+  let result = {};
   const propertyNames = /* @__PURE__ */ new Set();
   if (inputSchema.properties && typeof inputSchema.properties === "object") {
     for (const propName of Object.keys(inputSchema.properties)) {
@@ -24288,9 +24396,51 @@ function toGeminiSchema(schema, options = {}) {
     }
   }
   for (const [key, value] of Object.entries(inputSchema)) {
-    if (UNSUPPORTED_SCHEMA_FIELDS.has(key)) {
+    if (options.claudeValidated) {
+      if (key === "title")
+        continue;
+      if (key === "additionalProperties" && value === false)
+        numericConstraintHints.push("No extra properties allowed");
+      if (CLAUDE_VALIDATED_HINT_FIELDS.has(key)) {
+        if (value !== void 0 && typeof value !== "object")
+          numericConstraintHints.push(`${key}: ${value}`);
+        continue;
+      }
+    }
+    if (key === "const") {
+      if (typeof value === "string")
+        result.enum = [value];
+      else
+        numericConstraintHints.push(`Must be ${describeValue(value)}.`);
+      continue;
+    }
+    if (NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
+      const exclusive = key === "exclusiveMinimum" || key === "exclusiveMaximum";
+      if (exclusive && !options.moveNumericConstraintsToDescription && String(inputSchema.type).toUpperCase() === "INTEGER" && typeof value === "number" && Number.isFinite(value)) {
+        const lower = key === "exclusiveMinimum";
+        const bound = lower ? Math.floor(value) + 1 : Math.ceil(value) - 1;
+        const inclusiveKey = lower ? "minimum" : "maximum";
+        const existing = inputSchema[inclusiveKey];
+        if (Number.isSafeInteger(bound)) {
+          result[inclusiveKey] = typeof existing === "number" ? lower ? Math.max(existing, bound) : Math.min(existing, bound) : bound;
+          continue;
+        }
+      }
+      if (options.moveNumericConstraintsToDescription || exclusive || key === "multipleOf") {
+        if (["string", "number", "boolean"].includes(typeof value))
+          numericConstraintHints.push(`${key}: ${value}`);
+        continue;
+      }
+    }
+    if (key === "oneOf" && Array.isArray(value)) {
+      if (!Array.isArray(inputSchema.anyOf))
+        result.anyOf = value.map((item) => toGeminiSchema(item, options));
+      else
+        numericConstraintHints.push("oneOf: additional union constraints omitted.");
       continue;
     }
+    if (!ALLOWED_SCHEMA_FIELDS.has(key))
+      continue;
     if (key === "type" && typeof value === "string") {
       result[key] = value.toUpperCase();
     } else if (key === "properties" && typeof value === "object" && value !== null) {
@@ -24301,16 +24451,15 @@ function toGeminiSchema(schema, options = {}) {
       result[key] = props;
     } else if (key === "items" && typeof value === "object") {
       result[key] = toGeminiSchema(value, options);
-    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+    } else if (key === "anyOf" && Array.isArray(value)) {
       result[key] = value.map((item) => toGeminiSchema(item, options));
     } else if (key === "enum" && Array.isArray(value)) {
-      result[key] = value;
-    } else if (options.moveNumericConstraintsToDescription && NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
-      if (typeof value === "string" || typeof value === "number") {
-        numericConstraintHints.push(`${key}: ${value}`);
+      if (value.every((item) => typeof item === "string")) {
+        if (typeof inputSchema.const !== "string")
+          result.enum = value;
+      } else {
+        numericConstraintHints.push(`Allowed values: ${value.map(describeValue).join(", ")}.`);
       }
-    } else if (key === "default" || key === "examples") {
-      result[key] = value;
     } else if (key === "required" && Array.isArray(value)) {
       if (propertyNames.size > 0) {
         const validRequired = value.filter((prop) => typeof prop === "string" && propertyNames.has(prop));
@@ -24320,10 +24469,23 @@ function toGeminiSchema(schema, options = {}) {
       } else {
         result[key] = value;
       }
+    } else if ((key === "minimum" || key === "maximum") && typeof result[key] === "number" && typeof value === "number") {
+      result[key] = key === "minimum" ? Math.max(result[key], value) : Math.min(result[key], value);
     } else {
       result[key] = value;
     }
   }
+  if (options.claudeValidated) {
+    result = flattenClaudeUnion(result, numericConstraintHints);
+    if (isSchemaObject(result.properties) && Array.isArray(result.required)) {
+      const properties = result.properties;
+      const required2 = result.required.filter((name) => typeof name === "string" && Object.hasOwn(properties, name));
+      if (required2.length)
+        result.required = required2;
+      else
+        delete result.required;
+    }
+  }
   if (numericConstraintHints.length > 0) {
     const hint = numericConstraintHints.join(", ");
     result.description = typeof result.description === "string" && result.description ? `${result.description} (${hint})` : hint;
@@ -28984,7 +29146,7 @@ function createStoreAccountLimits(input2) {
 }
 
 // src/sidebar-state.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname15, join as join13 } from "node:path";
 
@@ -29008,7 +29170,7 @@ if (xdgConfig) {
 }
 
 // src/sidebar-state.ts
-var SIDEBAR_STATE_VERSION = 1;
+var SIDEBAR_STATE_VERSION = 2;
 var DEFAULT_SIDEBAR_STATE = {
   version: SIDEBAR_STATE_VERSION,
   checkedAt: 0,
@@ -29069,7 +29231,7 @@ function normalizeSidebarState(input2) {
   }
   const record2 = input2;
   const version = record2.version;
-  if (version !== SIDEBAR_STATE_VERSION) {
+  if (version !== 1 && version !== SIDEBAR_STATE_VERSION) {
     return {
       ...DEFAULT_SIDEBAR_STATE,
       lastError: `unsupported-version:${stringifySafe(version)}`
@@ -29124,6 +29286,7 @@ function normalizeAccount(input2) {
   return {
     id,
     label,
+    ...typeof record2.email === "string" ? { email: record2.email } : {},
     enabled,
     health,
     current,
@@ -29145,6 +29308,7 @@ function normalizeQuota(input2) {
   if (!isObject(input2)) return null;
   const record2 = input2;
   const remaining = toFiniteNumber(record2.remainingPercent);
+  const fraction = toFiniteNumber(record2.remainingFraction);
   if (remaining === null) return null;
   const resetAt = toFiniteNumber(record2.resetAt) ?? void 0;
   const checkedAt = toFiniteNumber(record2.checkedAt) ?? void 0;
@@ -29158,10 +29322,12 @@ function normalizeQuota(input2) {
       );
       const ra = toFiniteNumber(w.resetAt);
       const ca = toFiniteNumber(w.checkedAt);
+      const rf = toFiniteNumber(w.remainingFraction);
       if (win !== "weekly" && win !== "5h" || rp === null) return null;
       return {
         window: win,
         remainingPercent: clampNumber(rp, 0, 100),
+        ...rf !== null ? { remainingFraction: clampNumber(rf, 0, 1) } : {},
         resetAt: ra ?? void 0,
         ...ca !== null && ca >= 0 ? { checkedAt: ca } : {}
       };
@@ -29170,6 +29336,7 @@ function normalizeQuota(input2) {
   }
   return {
     remainingPercent: clampNumber(remaining, 0, 100),
+    ...fraction !== null ? { remainingFraction: clampNumber(fraction, 0, 1) } : {},
     resetAt,
     ...checkedAt !== void 0 ? { checkedAt } : {},
     windows
@@ -29221,6 +29388,7 @@ function stringifySafe(value) {
 }
 function ensureSidebarStateDir(path5 = getSidebarStateFile()) {
   mkdirSync3(dirname15(path5), { recursive: true, mode: SIDEBAR_STATE_DIR_MODE });
+  chmodSync3(dirname15(path5), SIDEBAR_STATE_DIR_MODE);
 }
 function pruneActiveRouting(map, now) {
   const cutoff = now - ACTIVE_ROUTING_MAX_AGE_MS;
@@ -29299,6 +29467,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
       0,
       100
     ),
+    remainingFraction: clampNumber(w.remainingFraction, 0, 1),
     resetAt: typeof w.resetTime === "string" && w.resetTime.length > 0 ? (() => {
       const parsed = Date.parse(w.resetTime);
       return Number.isFinite(parsed) ? parsed : void 0;
@@ -29306,6 +29475,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
   })) : void 0;
   return {
     remainingPercent,
+    remainingFraction: clampNumber(fraction, 0, 1),
     resetAt,
     windows,
     ...readingAt !== void 0 ? { checkedAt: readingAt } : {}
@@ -29342,6 +29512,7 @@ function redactAccountForSidebar(source) {
   return {
     id,
     label,
+    ...typeof source.email === "string" ? { email: source.email } : {},
     enabled,
     health,
     current,
@@ -29664,6 +29835,7 @@ async function pushSidebarQuotaSnapshot(getAccounts, backoffUntil = 0, getActive
         accounts.map((entry) => ({
           index: entry.index,
           label: entry.label,
+          email: entry.email,
           enabled: entry.enabled,
           current: activeByFamily ? isAccountCurrent(entry.index, activeByFamily) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -31095,7 +31267,7 @@ function clearSignatureCache(sessionId) {
 }
 
 // src/plugin/image-saver.ts
-import { chmodSync as chmodSync3, existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join15 } from "node:path";
 function getImageOutputDir(outputDir) {
@@ -31103,7 +31275,7 @@ function getImageOutputDir(outputDir) {
   if (!existsSync9(resolved)) {
     mkdirSync5(resolved, { recursive: true, mode: 448 });
   }
-  chmodSync3(resolved, 448);
+  chmodSync4(resolved, 448);
   return resolved;
 }
 function generateImageFilename(mimeType) {
@@ -31124,7 +31296,7 @@ function saveImageToDisk(base64Data, mimeType, outputDir) {
     const resolvedOutputDir = getImageOutputDir(outputDir);
     const filePath = join15(resolvedOutputDir, generateImageFilename(mimeType));
     writeFileSync3(filePath, Buffer.from(base64Data, "base64"), { mode: 384 });
-    chmodSync3(filePath, 384);
+    chmodSync4(filePath, 384);
     return filePath;
   } catch (error) {
     console.error("[image-saver] Failed to save image:", error);
@@ -31560,10 +31732,6 @@ import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync6, writeFileSy
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join16 } from "node:path";
 var DUMP_STATUS_TITLE = "## Gemini Dump Status";
-var DUMP_ENABLED_TITLE = "## Gemini Dump Enabled";
-var DUMP_DISABLED_TITLE = "## Gemini Dump Disabled";
-var DUMP_USAGE_TITLE = "## Gemini Dump Usage";
-var DUMP_USAGE = "Usage: `/gemini-dump`, `/gemini-dump on`, or `/gemini-dump off`.";
 var DUMP_DIR_ENV = "OPENCODE_ANTIGRAVITY_GEMINI_DUMP_DIR";
 var DEFAULT_DUMP_DIR = join16(tmpdir3(), "opencode-antigravity-gemini-dumps");
 var DUMP_DIR_MODE = 448;
@@ -31580,8 +31748,7 @@ function createGeminiDumpState(options = {}) {
       enabled = next;
     },
     dumpRequest: (input2) => enabled ? writeGeminiDump(input2) : null,
-    buildStatusSummary: (input2) => renderGeminiDumpStatus(input2?.enabled ?? enabled),
-    executeCommand: (input2) => renderGeminiDumpCommand(input2.argumentsText, input2.enabled ?? enabled)
+    buildStatusSummary: (input2) => renderGeminiDumpStatus(input2?.enabled ?? enabled)
   };
 }
 var legacyDumpState = createGeminiDumpState();
@@ -31594,15 +31761,6 @@ function setGeminiDumpEnabled(enabled) {
 function getGeminiDumpDirectory() {
   return process.env[DUMP_DIR_ENV] || DEFAULT_DUMP_DIR;
 }
-function parseGeminiDumpCommandAction(argumentsText) {
-  const normalized = argumentsText.trim().split(/\s+/).filter(Boolean);
-  if (normalized.length === 0) return { type: "status" };
-  if (normalized.length === 1 && normalized[0] === "on")
-    return { type: "enable" };
-  if (normalized.length === 1 && normalized[0] === "off")
-    return { type: "disable" };
-  return { type: "usage" };
-}
 function renderGeminiDumpStatus(enabled) {
   return [
     DUMP_STATUS_TITLE,
@@ -31613,23 +31771,6 @@ function renderGeminiDumpStatus(enabled) {
     "- Warning: dumps contain prompt/session content; turn this off after debugging"
   ].join("\n");
 }
-function renderGeminiDumpCommand(argumentsText, enabled) {
-  const action = parseGeminiDumpCommandAction(argumentsText);
-  if (action.type === "status") return renderGeminiDumpStatus(enabled);
-  if (action.type === "enable") {
-    return [DUMP_ENABLED_TITLE, "", renderGeminiDumpStatus(true)].join("\n");
-  }
-  if (action.type === "disable") {
-    return [DUMP_DISABLED_TITLE, "", renderGeminiDumpStatus(false)].join("\n");
-  }
-  return [
-    DUMP_USAGE_TITLE,
-    "",
-    DUMP_USAGE,
-    "",
-    renderGeminiDumpStatus(enabled)
-  ].join("\n");
-}
 function hashText2(value) {
   return createHash14("sha256").update(value).digest("hex");
 }
@@ -32294,31 +32435,6 @@ function createSessionRecoveryHook(ctx, config) {
 // src/plugin/request-helpers.ts
 var log8 = createLogger4("request-helpers");
 var ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features";
-var UNSUPPORTED_CONSTRAINTS = [
-  "minLength",
-  "maxLength",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "pattern",
-  "minItems",
-  "maxItems",
-  "format",
-  "default",
-  "examples"
-];
-var UNSUPPORTED_KEYWORDS = [
-  ...UNSUPPORTED_CONSTRAINTS,
-  "$schema",
-  "$defs",
-  "definitions",
-  "const",
-  "$ref",
-  "additionalProperties",
-  "propertyNames",
-  "title",
-  "$id",
-  "$comment"
-];
 function appendDescriptionHint(schema, hint) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -32348,23 +32464,6 @@ function convertRefsToHints(schema) {
   }
   return result;
 }
-function convertConstToEnum(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => convertConstToEnum(item));
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "const" && !schema.enum) {
-      result.enum = [value];
-    } else {
-      result[key] = convertConstToEnum(value);
-    }
-  }
-  return result;
-}
 function addEnumHints(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -32373,7 +32472,7 @@ function addEnumHints(schema) {
     return schema.map((item) => addEnumHints(item));
   }
   let result = { ...schema };
-  if (Array.isArray(result.enum) && result.enum.length > 1 && result.enum.length <= 10) {
+  if (Array.isArray(result.enum) && result.enum.every((value) => typeof value === "string") && result.enum.length > 1 && result.enum.length <= 10) {
     const vals = result.enum.map((v) => String(v)).join(", ");
     result = appendDescriptionHint(result, `Allowed: ${vals}`);
   }
@@ -32384,213 +32483,6 @@ function addEnumHints(schema) {
   }
   return result;
 }
-function addAdditionalPropertiesHints(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => addAdditionalPropertiesHints(item));
-  }
-  let result = { ...schema };
-  if (result.additionalProperties === false) {
-    result = appendDescriptionHint(result, "No extra properties allowed");
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (key !== "additionalProperties" && typeof value === "object" && value !== null) {
-      result[key] = addAdditionalPropertiesHints(value);
-    }
-  }
-  return result;
-}
-function moveConstraintsToDescription(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => moveConstraintsToDescription(item));
-  }
-  let result = { ...schema };
-  for (const constraint of UNSUPPORTED_CONSTRAINTS) {
-    if (result[constraint] !== void 0 && typeof result[constraint] !== "object") {
-      result = appendDescriptionHint(
-        result,
-        `${constraint}: ${result[constraint]}`
-      );
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = moveConstraintsToDescription(value);
-    }
-  }
-  return result;
-}
-function mergeAllOf(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => mergeAllOf(item));
-  }
-  const result = { ...schema };
-  if (Array.isArray(result.allOf)) {
-    const merged = {};
-    const mergedRequired = [];
-    for (const item of result.allOf) {
-      if (!item || typeof item !== "object") continue;
-      if (item.properties && typeof item.properties === "object") {
-        merged.properties = { ...merged.properties, ...item.properties };
-      }
-      if (Array.isArray(item.required)) {
-        for (const req of item.required) {
-          if (!mergedRequired.includes(req)) {
-            mergedRequired.push(req);
-          }
-        }
-      }
-      for (const [key, value] of Object.entries(item)) {
-        if (key !== "properties" && key !== "required" && merged[key] === void 0) {
-          merged[key] = value;
-        }
-      }
-    }
-    if (merged.properties) {
-      result.properties = { ...result.properties, ...merged.properties };
-    }
-    if (mergedRequired.length > 0) {
-      const existingRequired = Array.isArray(result.required) ? result.required : [];
-      result.required = Array.from(
-        /* @__PURE__ */ new Set([...existingRequired, ...mergedRequired])
-      );
-    }
-    for (const [key, value] of Object.entries(merged)) {
-      if (key !== "properties" && key !== "required" && result[key] === void 0) {
-        result[key] = value;
-      }
-    }
-    delete result.allOf;
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = mergeAllOf(value);
-    }
-  }
-  return result;
-}
-function scoreSchemaOption(schema) {
-  if (!schema || typeof schema !== "object") {
-    return { score: 0, typeName: "unknown" };
-  }
-  const type = schema.type;
-  if (type === "object" || schema.properties) {
-    return { score: 3, typeName: "object" };
-  }
-  if (type === "array" || schema.items) {
-    return { score: 2, typeName: "array" };
-  }
-  if (type && type !== "null") {
-    return { score: 1, typeName: type };
-  }
-  return { score: 0, typeName: type || "null" };
-}
-function tryMergeEnumFromUnion(options) {
-  if (!Array.isArray(options) || options.length === 0) {
-    return null;
-  }
-  const enumValues = [];
-  for (const option of options) {
-    if (!option || typeof option !== "object") {
-      return null;
-    }
-    if (option.const !== void 0) {
-      enumValues.push(String(option.const));
-      continue;
-    }
-    if (Array.isArray(option.enum) && option.enum.length === 1) {
-      enumValues.push(String(option.enum[0]));
-      continue;
-    }
-    if (Array.isArray(option.enum) && option.enum.length > 0) {
-      for (const val of option.enum) {
-        enumValues.push(String(val));
-      }
-      continue;
-    }
-    if (option.properties || option.items || option.anyOf || option.oneOf || option.allOf) {
-      return null;
-    }
-    if (option.type && !option.const && !option.enum) {
-      return null;
-    }
-  }
-  return enumValues.length > 0 ? enumValues : null;
-}
-function flattenAnyOfOneOf(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => flattenAnyOfOneOf(item));
-  }
-  let result = { ...schema };
-  for (const unionKey of ["anyOf", "oneOf"]) {
-    if (Array.isArray(result[unionKey]) && result[unionKey].length > 0) {
-      const options = result[unionKey];
-      const parentDesc = typeof result.description === "string" ? result.description : "";
-      const mergedEnum = tryMergeEnumFromUnion(options);
-      if (mergedEnum !== null) {
-        const { [unionKey]: _2, ...rest2 } = result;
-        result = {
-          ...rest2,
-          type: "string",
-          enum: mergedEnum
-        };
-        if (parentDesc) {
-          result.description = parentDesc;
-        }
-        continue;
-      }
-      let bestIdx = 0;
-      let bestScore = -1;
-      const allTypes = [];
-      for (let i = 0; i < options.length; i++) {
-        const { score, typeName } = scoreSchemaOption(options[i]);
-        if (typeName) {
-          allTypes.push(typeName);
-        }
-        if (score > bestScore) {
-          bestScore = score;
-          bestIdx = i;
-        }
-      }
-      let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: "string" };
-      if (parentDesc) {
-        const childDesc = typeof selected.description === "string" ? selected.description : "";
-        if (childDesc && childDesc !== parentDesc) {
-          selected = {
-            ...selected,
-            description: `${parentDesc} (${childDesc})`
-          };
-        } else if (!childDesc) {
-          selected = { ...selected, description: parentDesc };
-        }
-      }
-      if (allTypes.length > 1) {
-        const uniqueTypes = Array.from(new Set(allTypes));
-        const hint = `Accepts: ${uniqueTypes.join(" | ")}`;
-        selected = appendDescriptionHint(selected, hint);
-      }
-      const { [unionKey]: _, description: __, ...rest } = result;
-      result = { ...rest, ...selected };
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = flattenAnyOfOneOf(value);
-    }
-  }
-  return result;
-}
 function flattenTypeArrays(schema, nullableFields, currentPath) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -32659,62 +32551,6 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
   }
   return result;
 }
-function removeUnsupportedKeywords(schema, insideProperties = false) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => removeUnsupportedKeywords(item, false));
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (!insideProperties && UNSUPPORTED_KEYWORDS.includes(key)) {
-      continue;
-    }
-    if (typeof value === "object" && value !== null) {
-      if (key === "properties") {
-        const propertiesResult = {};
-        for (const [propName, propSchema] of Object.entries(value)) {
-          propertiesResult[propName] = removeUnsupportedKeywords(
-            propSchema,
-            false
-          );
-        }
-        result[key] = propertiesResult;
-      } else {
-        result[key] = removeUnsupportedKeywords(value, false);
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function cleanupRequiredFields(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => cleanupRequiredFields(item));
-  }
-  const result = { ...schema };
-  if (Array.isArray(result.required) && result.properties && typeof result.properties === "object") {
-    const validRequired = result.required.filter(
-      (req) => Object.hasOwn(result.properties, req)
-    );
-    if (validRequired.length === 0) {
-      delete result.required;
-    } else if (validRequired.length !== result.required.length) {
-      result.required = validRequired;
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = cleanupRequiredFields(value);
-    }
-  }
-  return result;
-}
 function addEmptySchemaPlaceholder(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -32747,19 +32583,11 @@ function cleanJSONSchemaForAntigravity(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
   }
-  let result = schema;
-  result = convertRefsToHints(result);
-  result = convertConstToEnum(result);
+  let result = convertRefsToHints(schema);
   result = addEnumHints(result);
-  result = addAdditionalPropertiesHints(result);
-  result = moveConstraintsToDescription(result);
-  result = mergeAllOf(result);
-  result = flattenAnyOfOneOf(result);
   result = flattenTypeArrays(result);
-  result = removeUnsupportedKeywords(result);
-  result = cleanupRequiredFields(result);
   result = addEmptySchemaPlaceholder(result);
-  return result;
+  return toGeminiSchema(result, { claudeValidated: true });
 }
 var DEFAULT_THINKING_BUDGET = 16e3;
 function isThinkingCapableModel2(modelName) {
@@ -35455,10 +35283,10 @@ function prepareAntigravityRequestIn(wire, input2, init, accessToken, projectId,
             const normalizeSchema = (schema) => {
               const createPlaceholderSchema = (base = {}) => ({
                 ...base,
-                type: "object",
+                type: "OBJECT",
                 properties: {
                   [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: "boolean",
+                    type: "BOOLEAN",
                     description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION
                   }
                 },
@@ -35474,11 +35302,11 @@ function prepareAntigravityRequestIn(wire, input2, init, accessToken, projectId,
                 return createPlaceholderSchema();
               }
               const hasProperties = cleaned.properties && typeof cleaned.properties === "object" && Object.keys(cleaned.properties).length > 0;
-              cleaned.type = "object";
+              cleaned.type = "OBJECT";
               if (!hasProperties) {
                 cleaned.properties = {
                   [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: "boolean",
+                    type: "BOOLEAN",
                     description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION
                   }
                 };
@@ -43858,10 +43686,32 @@ function createGaRpcActivation(options) {
       accountsStatus: { kind: "complete" },
       accounts: accounts.rows.map(({ selector, row }) => ({
         selector,
-        ...redactAccountForSidebar(row)
+        ...gaAccountFields(redactAccountForSidebar(row))
       }))
     };
   };
+  const gaAccountFields = (account) => {
+    const { email: _email, quota, ...rest } = account;
+    const entry = (value) => {
+      if (value === void 0) return void 0;
+      const { remainingFraction: _fraction, windows, ...fields } = value;
+      return windows === void 0 ? fields : {
+        ...fields,
+        windows: windows.map(
+          ({ remainingFraction: _windowFraction, ...window }) => window
+        )
+      };
+    };
+    const gemini = entry(quota.gemini);
+    const nonGemini = entry(quota["non-gemini"]);
+    return {
+      ...rest,
+      quota: {
+        ...gemini ? { gemini } : {},
+        ...nonGemini ? { "non-gemini": nonGemini } : {}
+      }
+    };
+  };
   const state = async (input2, signal) => {
     const parsed = AntigravityStateInputSchema.parse(input2);
     if (!parsed.ok) throw new GaRpcInputError(parsed.issues);
@@ -49045,6 +48895,7 @@ function createAuthLoader({
             return {
               index: entry.index,
               label: entry.label,
+              email: entry.email,
               enabled: entry.enabled,
               current: isAccountCurrent(entry.index, activeByFamily),
               coolingDownUntil: entry.coolingDownUntil,
@@ -49298,6 +49149,185 @@ function createAuthLoader({
   return authLoader;
 }
 
+// src/plugin/vault-quota-refresh.ts
+async function checkAndPublishVaultQuota(input2, publishSidebar) {
+  const report = await checkVaultQuota(input2);
+  if (report.checked > 0 && !input2.signal.aborted) await publishSidebar();
+  return report;
+}
+
+// src/plugin/vault-sidebar-projection.ts
+function quotaReadingForVaultRoute(route, state) {
+  const stored = state.accounts[route.accountIdentity];
+  return stored?.observed.routeId === route.routeId && stored.observed.credentialId === route.credentialId ? stored.quota : void 0;
+}
+function buildVaultSidebarProjection(pool, state, checkedAt = Date.now()) {
+  const projection = buildSidebarMachineStateFromAccounts(
+    pool.selector.rows.map((row) => {
+      const quota = quotaReadingForVaultRoute(row.route, state);
+      return {
+        index: row.index,
+        email: row.route.email,
+        enabled: row.enabled,
+        current: false,
+        coolingDownUntil: row.coolingDownUntil,
+        healthScore: pool.selector.healthTracker.getScore(row.index),
+        cachedQuota: quota ? cachedQuotaOf(quota) : void 0,
+        cachedQuotaUpdatedAt: quota?.cachedQuotaUpdatedAt ?? void 0
+      };
+    }),
+    { checkedAt }
+  );
+  return {
+    ...projection,
+    accounts: projection.accounts.map((account) => ({
+      ...account,
+      id: `vault-${account.id}`
+    }))
+  };
+}
+
+// src/plugin/background-vault-quota-refresh.ts
+var BackgroundVaultQuotaRefresh = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.random = options.random ?? Math.random;
+    this.acquireLock = options.acquireLock ?? acquireFencedFileLock;
+  }
+  options;
+  timer = null;
+  inFlight = null;
+  controller = null;
+  disposed = false;
+  started = false;
+  now;
+  random;
+  acquireLock;
+  start() {
+    if (this.disposed || this.started) return;
+    this.started = true;
+    this.schedule(Math.floor(this.random() * 3e4));
+  }
+  /** Custody notifications cancel admitted work as soon as authority changes. */
+  abortTick() {
+    this.controller?.abort();
+  }
+  async dispose() {
+    this.disposed = true;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.abortTick();
+    await this.inFlight;
+  }
+  schedule(delay) {
+    if (this.disposed || !this.started) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.tick();
+    }, delay);
+    this.timer.unref?.();
+  }
+  /** One serialized tick; also used by deterministic composition tests. */
+  tick() {
+    if (this.disposed) return Promise.resolve();
+    if (this.inFlight) return this.inFlight;
+    const controller = new AbortController();
+    this.controller = controller;
+    let extraJitter = 0;
+    this.inFlight = this.runTick(controller).catch(() => {
+      extraJitter = 15e3;
+    }).finally(() => {
+      this.inFlight = null;
+      this.controller = null;
+      this.schedule(
+        this.options.intervalMs + Math.floor(this.random() * this.options.intervalMs * 0.1) + extraJitter
+      );
+    });
+    return this.inFlight;
+  }
+  async assertActive(controller) {
+    if (this.disposed || await this.options.readAuthority() !== "vault")
+      controller.abort();
+    controller.signal.throwIfAborted();
+  }
+  async runTick(controller) {
+    await this.assertActive(controller);
+    ensureSidebarStateDir(this.options.sidebarStateFile);
+    const lock = await this.acquireLock({
+      path: this.options.sidebarStateFile,
+      name: "bg-vault-quota-poll",
+      ttlMs: 6e4,
+      renew: true
+    });
+    if (!lock) return;
+    let released = false;
+    void lock.whenLost().then(() => {
+      if (!released) controller.abort();
+    });
+    try {
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const { source, pool } = await this.options.currentVaultPool();
+      await this.assertActive(controller);
+      await pool.sync();
+      await this.assertActive(controller);
+      const state = await this.options.readProviderState();
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const threshold = Math.max(
+        this.options.intervalMs - 6e4,
+        Math.floor(this.options.intervalMs / 2)
+      );
+      const now = this.now();
+      const due = pool.selector.rows.some((row) => {
+        const quota = quotaReadingForVaultRoute(row.route, state);
+        const at = quota?.cachedQuotaUpdatedAt;
+        return quota?.cachedQuota == null || typeof at !== "number" || !Number.isFinite(at) || at < 0 || now - at >= threshold;
+      });
+      if (!due) return;
+      await checkAndPublishVaultQuota(
+        {
+          pool,
+          signal: controller.signal,
+          now: this.now,
+          fetchReading: async (ref, signal) => {
+            await this.assertActive(controller);
+            const reading = await fetchVaultAccountQuota({
+              source,
+              ref,
+              signal,
+              logger: this.options.logger,
+              transport: async (url, init, extra) => {
+                await this.assertActive(controller);
+                await lock.assertOwned();
+                controller.signal.throwIfAborted();
+                return this.options.transport(
+                  url,
+                  { ...init, signal: extra.signal ?? controller.signal },
+                  extra
+                );
+              }
+            });
+            await this.assertActive(controller);
+            await lock.assertOwned();
+            return reading;
+          }
+        },
+        async () => {
+          await this.assertActive(controller);
+          await lock.assertOwned();
+          await this.options.publishSidebar();
+        }
+      );
+    } finally {
+      released = true;
+      await lock.release().catch(() => {
+      });
+    }
+  }
+};
+
 // src/plugin/prompt-context.ts
 function isRecord15(value) {
   return typeof value === "object" && value !== null;
@@ -50568,6 +50598,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       await drainSidebarWrites();
     }
   });
+  let vaultQuotaPoller;
   const vaultCustody = createOpenCodeVaultCustody({
     accountFile: resolve11(getStoragePath()),
     readHostSlot: async () => {
@@ -50578,7 +50609,10 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     // The request executor reports failed bearer authorization to Claustrum,
     // which decides whether its served credential needs replacement.
     reporterSource: "direct",
-    onAuthorityChanged: () => scheduleSidebarPublication(),
+    onAuthorityChanged: (authority) => {
+      if (authority !== "vault") vaultQuotaPoller?.abortTick();
+      scheduleSidebarPublication();
+    },
     onRosterChanged: () => scheduleSidebarPublication()
   });
   let vaultPool;
@@ -50625,6 +50659,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return manager.getAccounts().map((entry) => ({
         index: entry.index,
         label: entry.label,
+        email: entry.email,
         enabled: entry.enabled,
         current: isAccountCurrent(entry.index, activeByFamily),
         coolingDownUntil: entry.coolingDownUntil,
@@ -50652,6 +50687,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return buildSidebarMachineStateFromAccounts(
         manager?.getAccounts().map((entry) => ({
           index: entry.index,
+          email: entry.email,
           enabled: entry.enabled,
           current: active2 ? isAccountCurrent(entry.index, active2) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -50669,23 +50705,13 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     vault: async () => {
       const { pool } = await currentVaultPool();
       await pool.sync();
-      const projection = buildSidebarMachineStateFromAccounts(
-        pool.selector.rows.map((entry) => ({
-          index: entry.index,
-          enabled: entry.enabled,
-          current: false,
-          coolingDownUntil: entry.coolingDownUntil,
-          healthScore: pool.selector.healthTracker.getScore(entry.index),
-          cachedQuota: entry.cachedQuota,
-          cachedQuotaUpdatedAt: entry.cachedQuotaUpdatedAt
-        }))
+      const projection = buildVaultSidebarProjection(
+        pool,
+        await vaultCustody.readState(),
+        dependencies.clock.now()
       );
       return {
         ...projection,
-        accounts: projection.accounts.map((account) => ({
-          ...account,
-          id: `vault-${account.id}`
-        })),
         ...projection.accounts.length === 0 ? { lastError: VAULT_ACCOUNT_REMEDY } : {}
       };
     },
@@ -50764,6 +50790,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     options._onPollerCreated?.(poller);
     poller.start();
     lifecycle.register({ dispose: () => poller.dispose() }, "producer");
+    vaultQuotaPoller = new BackgroundVaultQuotaRefresh({
+      intervalMs: config.background_quota_refresh_interval_minutes * 6e4,
+      sidebarStateFile: getSidebarStateFile(),
+      readAuthority: readAuthority2,
+      currentVaultPool,
+      readProviderState: () => vaultCustody.readState(),
+      publishSidebar: () => sidebarPublisher.publish(),
+      transport: dependencies.fetchImpl,
+      logger,
+      now: dependencies.clock.now,
+      random: dependencies.clock.random
+    });
+    options._onVaultPollerCreated?.(vaultQuotaPoller);
+    vaultQuotaPoller.start();
+    lifecycle.register(vaultQuotaPoller, "producer");
   }
   const operatorSettings = createOperatorSettingsController({
     projectConfigPath: join29(directory, ".opencode", "antigravity.json"),
@@ -50887,17 +50928,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
                 vaultSelectors2.set(key, selector);
                 return selector;
               },
-              (signal) => checkVaultQuota({
-                pool,
-                signal,
-                fetchReading: (ref, check) => fetchVaultAccountQuota({
-                  source,
-                  ref,
-                  signal: check,
-                  logger,
-                  transport: dependencies.fetchImpl
-                })
-              })
+              (signal) => checkAndPublishVaultQuota(
+                {
+                  pool,
+                  signal,
+                  now: dependencies.clock.now,
+                  fetchReading: (ref, check) => fetchVaultAccountQuota({
+                    source,
+                    ref,
+                    signal: check,
+                    logger,
+                    transport: dependencies.fetchImpl
+                  })
+                },
+                () => sidebarPublisher.publish()
+              )
             )
           })
         };
@@ -51145,10 +51190,8 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     apply: async (request) => {
       const current = await currentMenu();
       if (current.kind === "unavailable") throw new Error(current.message);
-      const result = await current.menu.apply(
-        request,
-        menuInvocation(pushNotification, request.sessionId)
-      );
+      const invocation = menuInvocation(pushNotification, request.sessionId);
+      const result = await current.menu.apply(request, invocation);
       try {
         if (await readAuthority2() === "local")
           await lifecycle.getAccountManager()?.refreshFromRepository();
@@ -51165,6 +51208,11 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
           request.sessionId
         );
       }
+      const refreshed = await currentMenu();
+      if (refreshed.kind === "menu" && refreshed.menu !== current.menu) {
+        const payload = await refreshed.menu.open(invocation);
+        return { ...result, menu: payload.menu };
+      }
       return result;
     },
     drain: drainNotifications