@cortexkit/opencode-openai-auth 1.3.0 → 1.4.0

package/src/tui-compiled/runtime/shared/0f77ebc3c914c9c6-custody.js

@@ -4,6 +4,7 @@ import { ClaustrumUnreachableError, classifyVaultFailure, } from "./94f53cfd572b
 import { readClaustrumEnrollmentToken } from "./b9588ad4725c1d10-enrollment.js";
 import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
 import { CUSTODY_PLACEHOLDER_PREFIX } from "./d9d2892a4c371301-host-slot.js";
+import { ScopedRosterWatch, } from "./dc9290c2a7552ba6-watch.js";
 /** Only a new version of the same account may replace an in-flight 401. */
 export function isScopedCredentialRotation(served, current) {
     return (current !== undefined &&
@@ -132,6 +133,9 @@ export class ClaustrumScopedCustody {
     #lastProbeAt = -Infinity;
     #probeDelay = 2_000;
     #closed = false;
+    /** The view of the last successful `discover()`, for `watchRoster`. */
+    #discoveredView;
+    #watches = new Set();
     constructor(options) {
         const tokenPath = options.tokenPath;
         if (options.readToken) {
@@ -197,7 +201,9 @@ export class ClaustrumScopedCustody {
         this.#probing = true;
         // Both triggers share list_scoped discovery, including its receipt-drop rules.
         // Sends never await discovery or let idle backoff delay the next send probe.
-        void this.discover()
+        // A probe commits no roster, so it is not the host's discovery and does
+        // not move the view a roster watch compares notices against.
+        void this.#list()
             .catch(() => {
             if (idle && this.#outage)
                 this.#probeDelay = Math.min(this.#probeDelay * 2, 30_000);
@@ -271,6 +277,11 @@ export class ClaustrumScopedCustody {
      * skipped records: they simply are not this consumer's.
      */
     async discover(signal) {
+        const inventory = await this.#list(signal);
+        this.#discoveredView = inventory.view;
+        return inventory;
+    }
+    async #list(signal) {
         let inventory;
         let token;
         try {
@@ -567,6 +578,61 @@ export class ClaustrumScopedCustody {
             throw error;
         }
     }
+    /**
+     * Watch this consumer's visible vault accounts instead of listing them on a
+     * short timer. Opens one `watchScoped` on this custody's client and calls
+     * `onView` when the host must run its discovery (see
+     * `ClaustrumRosterWatchOptions`). A claustrum-client without `watchScoped`
+     * (before 0.12.0) or a vault that answers `unknown_method` reports
+     * `fallback` and opens nothing. A watch that closes before any notice was
+     * never accepted: the client reads once to learn why, and the watch reports
+     * `fallback` and tries one new watch after `WATCH_RETRY_MS`, never in a
+     * loop. A watch that closes after notices is re-opened after
+     * `RESUBSCRIBE_BACKOFF_MS`, doubling per close in a row. A lost transport
+     * starts this custody's outage, exactly as an unreachable call does, and
+     * the first notice of a watch ends it. Timers are unreferenced; `close()`
+     * on the returned watch or on this custody stops it.
+     *
+     * The watch keeps no history, so the host still lists on a slow timer while
+     * the mode is `watching`: every `SAFETY_POLL_MS` (five minutes). In any
+     * other mode the host keeps its usual list timer.
+     */
+    watchRoster(options) {
+        this.#check();
+        const watch = new ScopedRosterWatch({
+            client: this.#client,
+            enrollmentToken: () => this.#token(),
+            view: options.view ?? (() => this.#discoveredView),
+            discover: async (view) => {
+                await options.onView(view);
+            },
+            onRefused: (error) => {
+                // Apply a refused watch as discover() applies a refused account
+                // listing: every kept receipt is dropped.
+                this.listFailed(error);
+                options.onRefused?.(error);
+            },
+            onTransportLost: () => this.transportLost(),
+            onReachable: () => this.reachable(),
+            onError: options.onError,
+            onMode: options.onMode,
+            logger: this.#logger,
+            now: this.#now,
+            setTimeoutImpl: this.#setTimeout,
+            clearTimeoutImpl: this.#clearTimeout,
+        });
+        this.#watches.add(watch);
+        watch.start();
+        return {
+            get mode() {
+                return watch.mode;
+            },
+            close: () => {
+                this.#watches.delete(watch);
+                watch.stop();
+            },
+        };
+    }
     close() {
         if (this.#closed)
             return;
@@ -574,6 +640,9 @@ export class ClaustrumScopedCustody {
         if (this.#probeTimer)
             this.#clearTimeout(this.#probeTimer);
         this.#probeTimer = undefined;
+        for (const watch of this.#watches)
+            watch.stop();
+        this.#watches.clear();
         this.#kept.clear();
         this.#client.close();
     }

package/src/tui-compiled/runtime/shared/169b2b4bf30909bc-consumer.js

@@ -3,9 +3,10 @@ import { combineAbortSignals } from "./6371b24a0573d79e-any-signal.js";
 import { ClaustrumScopedCustody, decideScopedRetryAfter401, } from "./0f77ebc3c914c9c6-custody.js";
 import { readClaustrumEnrollmentToken } from "./b9588ad4725c1d10-enrollment.js";
 import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
-import { acquireInsulaQuotaSource } from "./d0f0b6be200311af-insula.js";
-import { acceptVaultRoute, declineVaultRoute, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
-import { SAFETY_POLL_MS, ScopedRosterWatch } from "./dc9290c2a7552ba6-watch.js";
+import { acquireInsulaQuotaSource, } from "./d0f0b6be200311af-insula.js";
+import { pendingVaultQuota, retainVaultQuotaWriter } from "./81dddd203f1b92a3-quota-writer.js";
+import { acceptVaultRoute, applyVaultQuota, declineVaultRoute, forgetPendingVaultDiscovery, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
+import { SAFETY_POLL_MS } from "./dc9290c2a7552ba6-watch.js";
 /**
  * One plugin host's view of its vault accounts. It turns vault credentials
  * into rows for `/routing`, authorizes each physical send with the vault, and
@@ -19,8 +20,6 @@ export class ClaustrumConsumer {
     #shutdown = new AbortController();
     #logger;
     #custody;
-    /** The custody's client, kept so `start()` can open its vault watch. */
-    #client;
     #connecting;
     #refreshing;
     #roster;
@@ -34,11 +33,16 @@ export class ClaustrumConsumer {
     #insula;
     #vaultWatch;
     #releaseInsulaWatch;
+    #insulaSkips = new Map();
     /** When this instance last completed a discovery, by `now`. */
     #discoveredAt;
+    #releaseQuotaWriter;
     constructor(options) {
         this.#options = options;
         this.#logger = options.logger ?? createLogger('claustrum');
+        this.#releaseQuotaWriter = retainVaultQuotaWriter(options.rosterPath, (publication) => {
+            this.#roster = applyVaultQuota(this.#roster, publication).roster;
+        });
     }
     #assertOpen(signal) {
         this.#shutdown.signal.throwIfAborted();
@@ -90,7 +94,6 @@ export class ClaustrumConsumer {
                     client.close();
                     this.#assertOpen();
                 }
-                this.#client = client;
                 this.#custody = new ClaustrumScopedCustody({
                     client,
                     family: this.#options.family,
@@ -143,9 +146,8 @@ export class ClaustrumConsumer {
     }
     /** Close the watches with the connection they belong to. */
     #stopWatch() {
-        this.#vaultWatch?.stop();
+        this.#vaultWatch?.close();
         this.#vaultWatch = undefined;
-        this.#client = undefined;
         this.#releaseInsulaWatch?.();
         this.#releaseInsulaWatch = undefined;
     }
@@ -179,11 +181,9 @@ export class ClaustrumConsumer {
             let discovered;
             const roster = await refreshVaultRoster({
                 path: this.#options.rosterPath,
-                custody: {
-                    discover: async (signal) => {
-                        discovered = await custody.discover(signal);
-                        return discovered;
-                    },
+                custody,
+                onInventory: (inventory) => {
+                    discovered = inventory;
                 },
                 isActive: () => this.#active(),
                 signal: this.#shutdown.signal,
@@ -196,7 +196,7 @@ export class ClaustrumConsumer {
             });
             this.#assertOpen();
             const changed = roster?.view !== this.#roster?.view;
-            this.#roster = roster;
+            this.#roster = pendingVaultQuota(this.#options.rosterPath, roster);
             custody.retain(roster?.rows ?? []);
             // Each discovery replaces the previous value, including with unknown. A
             // refresh that served a peer's roster discovered nothing and leaves it;
@@ -271,42 +271,30 @@ export class ClaustrumConsumer {
      * reached in vault mode: a host in local mode never connects.
      */
     #openWatch() {
-        const client = this.#client;
-        if (this.#shutdown.signal.aborted || !client || !this.#custody)
+        const custody = this.#custody;
+        if (this.#shutdown.signal.aborted || !custody)
             return;
-        if (!this.#vaultWatch) {
-            const watch = new ScopedRosterWatch({
-                client,
-                enrollmentToken: async () => (await readClaustrumEnrollmentToken(this.#options.tokenPath)).token,
-                view: () => this.#roster?.view,
-                // The existing discovery, so a watched change commits the roster and
-                // re-applies it to kept receipts exactly as a poll does. A refresh
-                // already in flight may have listed before the change was announced,
-                // so wait for it and list again.
-                discover: async () => {
-                    while (this.#refreshing)
-                        await this.#refreshing.catch(() => { });
-                    await this.refresh();
-                },
-                onRefused: (error) => {
-                    // As a poll that met the same refusal from list_scoped would.
-                    this.#custody?.listFailed(error);
+        // The same entry point a host without a consumer uses, so both apply
+        // notices, refusals and outages alike.
+        this.#vaultWatch ??= custody.watchRoster({
+            view: () => this.#roster?.view,
+            // The existing discovery, so a watched change commits the roster and
+            // re-applies it to kept receipts exactly as a poll does. A refresh
+            // already in flight may have listed before the change was announced,
+            // so wait for it and list again.
+            onView: async () => {
+                while (this.#refreshing)
+                    await this.#refreshing.catch(() => { });
+                await this.refresh();
+            },
+            // Custody has dropped kept receipts, as a poll meeting the same
+            // refusal from list_scoped would.
+            onRefused: (error) => this.#options.onError?.(error),
+            onError: (error) => {
+                if (!this.#shutdown.signal.aborted)
                     this.#options.onError?.(error);
-                },
-                onTransportLost: () => this.#custody?.transportLost(),
-                onReachable: () => this.#custody?.reachable(),
-                onError: (error) => {
-                    if (!this.#shutdown.signal.aborted)
-                        this.#options.onError?.(error);
-                },
-                logger: this.#logger,
-                now: this.#options.now,
-                setTimeoutImpl: this.#options.setTimeoutImpl,
-                clearTimeoutImpl: this.#options.clearTimeoutImpl,
-            });
-            this.#vaultWatch = watch;
-            watch.start();
-        }
+            },
+        });
         if (this.#options.insula && this.#insula && !this.#releaseInsulaWatch)
             this.#releaseInsulaWatch = this.#insula.source.watch({
                 provider: this.#options.insula.provider,
@@ -364,7 +352,7 @@ export class ClaustrumConsumer {
             return undefined;
         try {
             await readClaustrumEnrollmentToken(this.#options.tokenPath);
-            const roster = await readVaultRoster(this.#options.rosterPath);
+            const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
             const row = roster?.rows.find((entry) => entry.routeId === routeId);
             return this.#normalizeInsulaQuota(row?.accountIdentity);
         }
@@ -372,6 +360,44 @@ export class ClaustrumConsumer {
             return undefined;
         }
     }
+    /** Cache-only background lookup, preserving the reason a route has no reading. */
+    async lookupInsulaQuotaForRoute(routeId) {
+        const options = this.#options.insula;
+        if (!options || this.#shutdown.signal.aborted || !(await this.#active()))
+            return { miss: 'unreachable' };
+        try {
+            await readClaustrumEnrollmentToken(this.#options.tokenPath);
+            const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+            const account = roster?.rows.find((row) => row.routeId === routeId)?.accountIdentity;
+            if (!account || !this.#insula)
+                return { miss: 'unreachable' };
+            const result = this.#insula.source.lookup(options.provider, account, (this.#options.now ?? Date.now)());
+            const reading = result.reading &&
+                options.normalize(result.reading.entry, result.reading.context);
+            if (result.miss)
+                return { miss: result.miss, ...(reading !== undefined && { reading }) };
+            // Refusing an echo or unsupported window leaves the plugin's poll in charge.
+            return reading === undefined ? { miss: 'unreachable' } : { reading };
+        }
+        catch {
+            return { miss: 'unreachable' };
+        }
+    }
+    /** Skip the fallback poll while insula is cold or its upstream fetch failed. */
+    async pollInsulaQuotaForRoute(routeId, fallback) {
+        const result = await this.lookupInsulaQuotaForRoute(routeId);
+        if (result.miss === 'cold' || result.miss === 'upstream-failed') {
+            if (this.#insulaSkips.get(routeId) !== result.miss) {
+                this.#insulaSkips.set(routeId, result.miss);
+                this.#logger.warn('skipped insula provider poll', {
+                    reason: result.miss,
+                });
+            }
+            return undefined;
+        }
+        this.#insulaSkips.delete(routeId);
+        return result.miss ? fallback() : result.reading;
+    }
     #normalizeInsulaQuota(accountIdentity) {
         if (!this.#options.insula || !accountIdentity)
             return undefined;
@@ -396,7 +422,7 @@ export class ClaustrumConsumer {
             this.#insula = undefined;
             throw new ClaustrumConsumerError('not-active', 'Claustrum scoped custody is not active');
         }
-        const current = await readVaultRoster(this.#options.rosterPath);
+        const current = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
         this.#assertOpen(signal);
         const observed = roster.rows.find((row) => row.routeId === routeId);
         const configured = current?.rows.find((row) => row.routeId === routeId);
@@ -488,13 +514,13 @@ export class ClaustrumConsumer {
     async decline(routeId) {
         this.#assertOpen();
         await declineVaultRoute(this.#options.rosterPath, routeId);
-        this.#roster = await readVaultRoster(this.#options.rosterPath);
+        this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
         this.#custody?.retain(this.#roster?.rows ?? []);
     }
     async accept(routeId) {
         this.#assertOpen();
         await acceptVaultRoute(this.#options.rosterPath, routeId);
-        this.#roster = await readVaultRoster(this.#options.rosterPath);
+        this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
     }
     /**
      * Store a quota or profile observation for a vault route. The receipt the
@@ -504,7 +530,7 @@ export class ClaustrumConsumer {
      */
     async recordQuota(routeId, observation, attempt) {
         this.#assertOpen();
-        const kept = await recordVaultQuota(this.#options.rosterPath, {
+        return recordVaultQuota(this.#options.rosterPath, {
             routeId,
             observation,
             credentialId: attempt.credentialId,
@@ -516,27 +542,21 @@ export class ClaustrumConsumer {
                 expectedAccountIdentity: attempt.expectedAccountIdentity,
             }),
         });
-        if (kept)
-            this.#roster = await readVaultRoster(this.#options.rosterPath);
-        return kept;
     }
     /**
      * Store a background observation that belongs to an account rather than to
      * a served credential (an insula reading from `cachedInsulaQuotaForRoute`).
      * It lands only while the route is still bound to that known account, so no
      * credential fetch is needed and a replaced account's reading is dropped.
-     * The in-memory roster is reloaded from the file, without a vault call.
+     * Memory updates immediately; durable publication is detached and coalesced.
      */
     async recordAccountQuota(routeId, accountIdentity, observation) {
         this.#assertOpen();
-        const kept = await recordVaultAccountQuota(this.#options.rosterPath, {
+        return recordVaultAccountQuota(this.#options.rosterPath, {
             routeId,
             accountIdentity,
             observation,
         });
-        if (kept)
-            this.#roster = await readVaultRoster(this.#options.rosterPath);
-        return kept;
     }
     close() {
         if (this.#shutdown.signal.aborted)
@@ -551,5 +571,12 @@ export class ClaustrumConsumer {
         this.#insula = undefined;
         this.#roster = undefined;
         this.#grantReach = undefined;
+        void this.#releaseQuotaWriter();
+        forgetPendingVaultDiscovery(this.#options.rosterPath);
+    }
+    /** Close immediately; the last consumer also waits for the writer's bounded drain. */
+    async dispose() {
+        this.close();
+        await this.#releaseQuotaWriter();
     }
 }

package/src/tui-compiled/runtime/shared/2577ec69f9973ae9-quota-normalize.js

@@ -56,8 +56,33 @@ export function normalizeQuotaHeaders(h) {
   const secondary = windowFromHeader(h, "x-codex-secondary-used-percent");
   if (secondary)
     snapshot.secondary = secondary;
+  const credits = creditsFromHeaders(h);
+  if (credits)
+    snapshot.credits = credits;
   return snapshot;
 }
+function headerBool(h, name) {
+  const raw = h.get(name)?.trim();
+  if (raw === void 0)
+    return;
+  if (raw.toLowerCase() === "true" || raw === "1")
+    return !0;
+  if (raw.toLowerCase() === "false" || raw === "0")
+    return !1;
+  return;
+}
+function creditsFromHeaders(h) {
+  const hasCredits = headerBool(h, "x-codex-credits-has-credits"), unlimited = headerBool(h, "x-codex-credits-unlimited");
+  if (hasCredits === void 0 || unlimited === void 0)
+    return;
+  const balance = nonNegativeNumberish(h.get("x-codex-credits-balance")?.trim());
+  return {
+    hasCredits,
+    unlimited,
+    ...balance !== void 0 ? { balance } : {},
+    checkedAt: Date.now()
+  };
+}
 export function isCompleteQuotaHeaderFrame(h) {
   const states = QUOTA_USED_PERCENT_HEADERS.map((name) => usedPercentHeaderState(h, name));
   return states.includes("valid") && !states.includes("invalid");
@@ -85,8 +110,26 @@ export function normalizeWsFrame(event) {
   const secondary = windowFromWs(event.rate_limits?.secondary);
   if (secondary)
     snapshot.secondary = secondary;
+  const credits = creditsFromWs(event.credits);
+  if (credits)
+    snapshot.credits = credits;
   return snapshot;
 }
+function creditsFromWs(value) {
+  if (value === null || typeof value !== "object")
+    return;
+  const credits = value;
+  if (typeof credits.has_credits !== "boolean" || typeof credits.unlimited !== "boolean")
+    return;
+  const balance = nonNegativeNumberish(typeof credits.balance === "string" ? credits.balance.trim() : credits.balance);
+  return {
+    hasCredits: credits.has_credits,
+    unlimited: credits.unlimited,
+    ...balance !== void 0 ? { balance } : {},
+    ...typeof credits.overage_limit_reached === "boolean" ? { overageLimitReached: credits.overage_limit_reached } : {},
+    checkedAt: Date.now()
+  };
+}
 function nonNegativeNumberish(value) {
   if (value == null || value === "")
     return;
@@ -147,7 +190,8 @@ export function normalizeWham(json) {
       hasCredits: credits.has_credits,
       unlimited: credits.unlimited,
       overageLimitReached: credits.overage_limit_reached,
-      ...balance !== void 0 ? { balance } : {}
+      ...balance !== void 0 ? { balance } : {},
+      checkedAt: Date.now()
     };
   }
   return snapshot;