@cortexkit/anthropic-auth-core 1.22.0 → 2.0.0

package/dist/provider-error.d.ts

@@ -0,0 +1,139 @@
+export interface ProviderErrorRedactor {
+    /** Scrub credentials from error text. */
+    redactText(text: string): string;
+    /**
+     * Scrub credentials from any thrown value without running caller code.
+     * Strings come back scrubbed and other primitives unchanged. Objects come
+     * back as a fresh projection that keeps only the fields hosts classify on
+     * (name, message, status, code, type, retry hints, headers, the nested
+     * `error` envelope, `cause` and aggregate `errors`), each read as own data
+     * and scrubbed. The original object, its prototype, getters, private state
+     * and any response body, stream or URL are never returned. Never throws.
+     */
+    redactError(error: unknown): unknown;
+    /**
+     * Scrub a provider response. Successful non-stream responses are returned
+     * as-is. Successful event streams keep every successful frame byte-for-byte
+     * and rewrite only error envelopes. Non-2xx responses get scrubbed status
+     * text, headers, URL and body; the body is read lazily when the caller
+     * reads it. After disposal a non-2xx response keeps only its status and
+     * verifiable retry/rate-limit headers.
+     */
+    redactResponse(response: Response): Response;
+    /** Forget the credentials. Later error reads fail closed to a generic message. */
+    dispose(): void;
+}
+/** Replacement for every scrubbed credential. */
+export declare const PROVIDER_ERROR_REDACTION = "[REDACTED]";
+/** Message used when error material is read after the redactor was disposed. */
+export declare const PROVIDER_ERROR_WITHHELD_MESSAGE = "Provider error details were withheld because the request attempt has ended";
+/** Message used when a non-2xx body is too large to scrub safely. */
+export declare const PROVIDER_ERROR_OVERSIZED_MESSAGE = "Provider error body exceeded the redaction size limit and was withheld";
+/** Largest non-2xx body read into memory for scrubbing. */
+export declare const PROVIDER_ERROR_MAX_BODY_BYTES: number;
+/** Largest SSE frame carried while looking for its end. */
+export declare const PROVIDER_ERROR_MAX_FRAME_BYTES: number;
+/**
+ * For producers of a non-2xx body, such as the relay, that stop buffering it
+ * at PROVIDER_ERROR_MAX_BODY_BYTES: error the raw body stream with a new
+ * instance, and the body handed out by `redactResponse` ends with the fixed
+ * PROVIDER_ERROR_OVERSIZED_MESSAGE JSON instead of an error, also when the
+ * redactor or scope was already disposed. Bytes the source had queued are
+ * dropped. Only objects this constructor created count: membership is
+ * looked up by identity in a private set, so nothing on the value (its
+ * message, code, prototype or any getter) is read, and a look-alike, a
+ * proxy around an instance or an object with the same prototype is treated
+ * as an ordinary failure. Not exported from the Core package entry point.
+ */
+export declare class ProviderErrorSourceOversizedError extends Error {
+    constructor();
+}
+/** Message of the error thrown when a closed stream scope is fed again. */
+export declare const PROVIDER_ERROR_SCOPE_CLOSED_MESSAGE = "Provider error stream scope is closed";
+/**
+ * Internal scope for a producer that already holds the raw event-stream
+ * bytes of one physical attempt (the relay): it feeds them through the same
+ * pipeline as `redactResponse` without wrapping a Response.
+ */
+export interface ProviderErrorStreamScope {
+    /**
+     * Bytes to forward for this chunk. Unchanged frames come back as the same
+     * bytes; only error envelopes are rewritten; an incomplete frame is held
+     * until its blank line. A frame over the bound throws
+     * `SseFrameTooLargeError`, and any failure disposes the scope.
+     */
+    push(chunk: Uint8Array): Uint8Array[];
+    /** End of input: bytes for the unterminated tail, then the scope disposes. */
+    finish(): Uint8Array[];
+    /** Scrub a thrown error; generic once the scope is disposed. */
+    redactError(error: unknown): unknown;
+    /** Drop the credentials and any held partial frame. Idempotent. */
+    dispose(): void;
+}
+/**
+ * Create a stream scope for one physical attempt or reconnect, holding the
+ * exact credentials that attempt sent. Create a fresh scope after every
+ * fresh authorization. After `finish()` or `dispose()`, `push` and `finish`
+ * throw an error carrying no content and `redactError` fails closed.
+ */
+export declare function createProviderErrorStreamScope(secrets: readonly string[]): ProviderErrorStreamScope;
+/**
+ * Create a redactor for one request attempt. `secrets` are the exact
+ * credentials that attempt sent; pass a new redactor for every attempt so a
+ * rotated or fallback credential is scrubbed by the attempt that used it, and
+ * call `dispose()` when the attempt ends.
+ */
+export declare function createProviderErrorRedactor(secrets: readonly string[]): ProviderErrorRedactor;
+/**
+ * What the request asked for, which decides how a successful body is
+ * treated: `event-stream` for streaming model requests (the body always goes
+ * through the error-only SSE rewrite, whatever content type the response
+ * claims), `http` for every other request (successful bodies are returned
+ * untouched and never read).
+ */
+export type ProviderResponseMode = 'event-stream' | 'http';
+/** How a response scope retired its credentials. */
+export type ProviderResponseSettlement = 'eof' | 'cancel' | 'error' | 'untouched' | 'disposed';
+/**
+ * Lifetime of one direct provider response. The credentials are retired at
+ * the response's terminal point rather than when the host remembers to
+ * dispose.
+ */
+export interface ProviderErrorResponseScope {
+    /**
+     * Scrub exactly one response. In `http` mode a successful response is
+     * returned as-is without reading its body; in `event-stream` mode a
+     * successful body is wrapped so only error envelopes are rewritten,
+     * whatever its content type. In both modes a non-2xx response gets
+     * scrubbed status text, headers, URL and a lazily scrubbed body. A second
+     * call, or any call after the scope has settled, throws a TypeError.
+     */
+    redactResponse(response: Response): Response;
+    /** Scrub a thrown error while live; generic once the scope has settled. */
+    redactError(error: unknown): unknown;
+    /** Retire the credentials now. Idempotent. */
+    dispose(): void;
+    /**
+     * Resolves once, at the first terminal point, and never rejects:
+     * - `eof`, `cancel` or `error` when a wrapped body (a successful event
+     *   stream or a non-2xx body) ends, is cancelled by its consumer, or fails;
+     * - `untouched` when `redactResponse` returned without wrapping a body,
+     *   such as a successful non-event-stream response, whose body is never
+     *   read;
+     * - `disposed` when `dispose()` came first.
+     * It marks the credentials' retirement, not completed I/O cleanup: a
+     * source cancellation may still be pending.
+     */
+    readonly settled: Promise<ProviderResponseSettlement>;
+}
+/** Message of the TypeError thrown when a response scope is reused. */
+export declare const PROVIDER_ERROR_RESPONSE_SCOPE_USED_MESSAGE = "Provider error response scope accepts one response while live";
+/**
+ * Create a response scope for one physical attempt, holding the exact
+ * credentials that attempt sent, and the mode of the request that attempt
+ * made. Host code that classifies the outcome after
+ * the scope settles (retry, rerouting or quota decisions) must use the
+ * status, headers and already-scrubbed frames it read during the attempt:
+ * once settled, `redactError` only returns a generic error.
+ */
+export declare function createProviderErrorResponseScope(secrets: readonly string[], mode: ProviderResponseMode): ProviderErrorResponseScope;

package/dist/quota-header-feed.d.ts

@@ -1,6 +1,13 @@
 import { type AccountStorage, type OAuthQuotaSnapshot, type QuotaFieldName, type QuotaFieldSource, type QuotaFieldSources } from './accounts.ts';
 export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 3;
 export declare const QUOTA_HEADER_FEED_LEASE_MS = 180000;
+/**
+ * Lease files are per process; each carries only the accounts whose response
+ * headers THAT process harvested. Consumers MUST union entries across all files
+ * inside `lease_horizon_ms`, deduplicating by account; "newest file wins" is wrong.
+ * `anthropic_account_uuid` is always present: null is unresolvable, while absence
+ * identifies an old producer. A fallback `account_ref` is store-local.
+ */
 export type QuotaHeaderFeedIdentity = {
     identity_source: 'credential_id';
     credential_id: string;
@@ -22,9 +29,12 @@ type QuotaHeaderFeedMetadata = {
     observed_at_ms: number;
 };
 export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    /** Always present: null means UUID resolution failed; absence denotes an old producer. */
+    anthropic_account_uuid: string | null;
     quota: QuotaHeaderFeedQuota;
 };
 export type QuotaHeaderFeedPublishEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    anthropic_account_uuid: string | null;
     quota: Omit<QuotaHeaderFeedQuota, 'provenance'> & {
         fieldSources?: QuotaFieldSources;
     };
@@ -44,8 +54,11 @@ export declare class QuotaHeaderFeedRegistry {
         now?: () => number;
         leaseMs?: number;
         instanceId?: string;
+        removeFile?: (path: string) => Promise<void>;
+        beforeRemoveFile?: (path: string) => Promise<void>;
     });
     publish(entry: QuotaHeaderFeedPublishEntry): Promise<void>;
+    private reapStaleSiblingLeases;
     list(): Promise<QuotaHeaderFeedEntry[]>;
     dispose(): Promise<void>;
 }

package/dist/quota-manager.d.ts

@@ -17,9 +17,24 @@ export type QuotaRefreshResult = {
     /** False when backoff or a cross-process lock served the existing cache. */
     fetched: boolean;
 };
+/** Pace a physical usage GET and verify the selected credential is still eligible before sending. */
+export type QuotaRequestDispatch = (send: () => Promise<Response>, revalidate: () => Promise<void>) => Promise<Response>;
 export type QuotaManagerOptions = {
     storage: AccountStorage | null;
     fetchImpl?: typeof fetch;
+    /**
+     * This callback checks or obtains credentials before its own HTTP request.
+     * accessToken may be empty when the host uses a native pool or vault instead
+     * of keeping a token in its quota settings snapshot. Pass dispatch into the
+     * native quota operation so every physical GET, including a retry, is paced
+     * only after admission and rechecks host custody and credential eligibility
+     * after the spacing wait.
+     */
+    fetchQuotaSnapshot?: (request: {
+        kind: 'main' | 'fallback';
+        accountId: string | undefined;
+        accessToken: string;
+    }, dispatch: QuotaRequestDispatch) => Promise<OAuthQuotaSnapshot>;
     now?: () => number;
     onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string, fetchStartedAt: number, quotaErrorGeneration: number, quotaErrorClearedAt: number | undefined) => void;
     onApiError?: (error: AccountOperationError, quotaErrorGeneration: number) => void;
@@ -38,7 +53,10 @@ export declare class QuotaManager {
     private fallbackAuthLineages;
     private fallbackGenerations;
     private inflightMain;
+    private lastMainPollAttempt;
     private inflightMainAccountId;
+    private inflightMainAccessToken;
+    private inflightMainToken;
     private inflightFallbacks;
     private mainLastApiError;
     private fallbackApiErrors;
@@ -46,6 +64,7 @@ export declare class QuotaManager {
     private lastApiCallAt;
     private storage;
     private readonly fetchImpl;
+    private readonly fetchQuotaSnapshot;
     private readonly now;
     private readonly onMainQuotaFetched;
     private readonly onApiError;
@@ -61,10 +80,13 @@ export declare class QuotaManager {
      * Cached fallback quota entry, scoped to the configured account id.
      */
     getFallback(accountId: string, account?: Pick<OAuthAccount, 'authLineageId'>): QuotaEntry | null;
+    /** A configured transport obtains its own credentials; policy snapshots need no tokens. */
+    canFetchWithoutAccessToken(): boolean;
     getAllFallbacks(): Map<string, QuotaEntry>;
     setMain(mainAccountId: string | undefined, entry: QuotaEntry): void;
+    clearMain(): void;
     /** Bind quota state to the account behind the current main credential. */
-    setMainQuotaAccountIdentity(accountIdentity: string | undefined, strict?: boolean): number | undefined;
+    setMainQuotaAccountIdentity(accountIdentity: string | undefined, strict?: boolean, force?: boolean): number | undefined;
     setFallback(accountId: string, entry: QuotaEntry, account: Pick<OAuthAccount, 'authLineageId'> | undefined): void;
     clearFallback(accountId: string): void;
     pushMainFromHeaders(mainAccountId: string | undefined, incoming: OAuthQuotaSnapshot): QuotaEntry;
@@ -122,13 +144,16 @@ export declare class QuotaManager {
     private static quotaLockName;
     private bindFallbackLineage;
     private acceptFallbackQuotaObservation;
+    private isClosed;
+    close(): void;
     /**
-     * Serialize API calls through a shared gate so only one
-     * quota API request runs at a time, with a minimum gap
-     * between calls. Prevents concurrent and rapid-fire calls
-     * from triggering Anthropic's rate limits.
+     * Serialize quota refresh work, including credential admission and locks.
+     * The transport separately paces physical GETs. A refresh refused before
+     * HTTP dispatch must not postpone the next usable account's poll.
      */
     private _enqueueApiFetch;
+    private _quotaDispatch;
+    private _quotaFetch;
     private _fetchMain;
     private _fetchFallback;
     private static isAuthError;

package/dist/relay.d.ts

@@ -11,6 +11,19 @@ export type RelayPatch = {
     deleteCount: number;
     insert: string;
 };
+export type RelayAttemptAuthorization = {
+    headers: Headers;
+    /** Called only for a genuine upstream response, never optimistic/transport status. */
+    onUpstreamStatus?: (status: number) => void;
+    /**
+     * Additional exact credentials this physical attempt sends upstream, used
+     * only to scrub provider error material echoed back for this attempt. The
+     * credentials in the outgoing `authorization` and `x-api-key` headers are
+     * always scrubbed as well; this list can only add to them.
+     */
+    errorSecrets?: readonly string[];
+};
+export type AuthorizeRelayAttempt = () => Promise<RelayAttemptAuthorization>;
 export declare function getRelayConfig(storage: AccountStorage | null): RelayConfig | null;
 export declare function generateRelayToken(): string;
 export declare function hashBody(body: string): string;
@@ -23,7 +36,15 @@ export declare function sendViaRelay(options: {
     body: RequestInit['body'] | null | undefined;
     fallback: () => Promise<Response>;
     affinity?: string | null;
+    /**
+     * Resolve a WebSocket send with a synthetic 200 event stream before the
+     * upstream answers. Honoured only for streaming requests (body `stream` is
+     * true); any other request waits for the real response on the same
+     * WebSocket transport.
+     */
     optimisticResponse?: boolean;
+    /** Fresh authorization for every physical relay attempt, including internal retries. */
+    authorizeAttempt?: AuthorizeRelayAttempt;
     /**
      * Observes genuine upstream headers once per delivered response. WebSocket
      * retries before downstream bytes replace staged headers, so the callback
@@ -36,4 +57,4 @@ export declare function sendViaRelay(options: {
     setTimeoutImpl?: typeof globalThis.setTimeout;
     clearTimeoutImpl?: typeof globalThis.clearTimeout;
 }): Promise<Response>;
-export declare const WORKER_SCRIPT = "\nasync function hashBody(body) {\n  const bytes = new TextEncoder().encode(body)\n  const digest = await crypto.subtle.digest('SHA-256', bytes)\n  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('')\n  return 'sha256:' + hex\n}\n\nfunction applyPatch(base, patch) {\n  return base.slice(0, patch.start) + patch.insert + base.slice(patch.start + patch.deleteCount)\n}\n\nfunction applyPatchSet(base, patch) {\n  if (!Array.isArray(patch)) return applyPatch(base, patch)\n  if (patch.length === 0) return base\n\n  let result = ''\n  let cursor = 0\n  for (const item of patch) {\n    if (item.start < cursor) return { error: 'overlapping patch', status: 400 }\n    result += base.slice(cursor, item.start)\n    result += item.insert\n    cursor = item.start + item.deleteCount\n  }\n  return result + base.slice(cursor)\n}\n\nasync function readState(env, affinity) {\n  const raw = await env.RELAY_STATE.get('session:' + affinity)\n  return raw ? JSON.parse(raw) : null\n}\n\nasync function writeState(env, affinity, state) {\n  await env.RELAY_STATE.put('session:' + affinity, JSON.stringify(state), { expirationTtl: 86400 })\n}\n\nasync function resolveBody(env, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    const state = await readState(env, payload.affinity)\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nasync function prepareUpstream(env, payload) {\n  if ((payload.protocol !== 1 && payload.protocol !== 2) || payload.type !== 'request' || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = await resolveBody(env, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n\n  if (typeof body !== 'string' || (await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const stateWrite = writeState(env, payload.affinity, { body, hash: payload.next_hash, revision: payload.revision }).catch(() => {})\n  console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'relay',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, stateWrite }\n}\n\nfunction resolveBodyFromState(state, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nfunction deferWorkerTask(task) {\n  return new Promise((resolve) => setTimeout(resolve, 0)).then(task)\n}\n\nconst WEBSOCKET_STREAM_FLUSH_BYTES = 1024\nconst WEBSOCKET_STREAM_FLUSH_MS = 20\n\nfunction createWebSocketStreamCoalescer(socket, options = {}) {\n  const flushBytes = options.flushBytes || WEBSOCKET_STREAM_FLUSH_BYTES\n  const flushMs = options.flushMs ?? WEBSOCKET_STREAM_FLUSH_MS\n  let chunks = []\n  let byteLength = 0\n  let flushTimer = null\n  const stats = {\n    upstreamChunks: 0,\n    upstreamBytes: 0,\n    frames: 0,\n    frameBytes: 0,\n  }\n\n  const clearFlushTimer = () => {\n    if (flushTimer === null) return\n    clearTimeout(flushTimer)\n    flushTimer = null\n  }\n\n  const mergeChunks = () => {\n    if (chunks.length === 1) return chunks[0]\n    const frame = new Uint8Array(byteLength)\n    let offset = 0\n    for (const chunk of chunks) {\n      frame.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return frame\n  }\n\n  const flush = () => {\n    clearFlushTimer()\n    if (byteLength === 0) return\n    const frame = mergeChunks()\n    chunks = []\n    byteLength = 0\n    socket.send(frame)\n    stats.frames += 1\n    stats.frameBytes += frame.byteLength\n  }\n\n  const scheduleFlush = () => {\n    if (flushTimer !== null) return\n    flushTimer = setTimeout(flush, flushMs)\n  }\n\n  return {\n    push(value) {\n      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value)\n      if (chunk.byteLength === 0) return\n      stats.upstreamChunks += 1\n      stats.upstreamBytes += chunk.byteLength\n      chunks.push(chunk)\n      byteLength += chunk.byteLength\n      if (byteLength >= flushBytes) flush()\n      else scheduleFlush()\n    },\n    flush,\n    stats() {\n      return { ...stats, pendingBytes: byteLength }\n    },\n  }\n}\n\nfunction checkpointWebSocketState(env, payload, body, nextState) {\n  return deferWorkerTask(async () => {\n    try {\n      if ((await hashBody(body)) !== payload.next_hash) {\n        throw new Error('hash mismatch')\n      }\n      await writeState(env, payload.affinity, nextState)\n    } catch (error) {\n      console.log(JSON.stringify({\n        relay: 'opencode-anthropic-auth',\n        transport: 'websocket',\n        event: 'checkpoint_write_failed',\n        affinity: String(payload.affinity).slice(0, 12),\n        message: error instanceof Error ? error.message : String(error),\n      }))\n    }\n  })\n}\n\nasync function prepareWebSocketUpstream(env, state, payload) {\n  if (payload.protocol !== 2 || payload.type !== 'request' || !payload.id || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = resolveBodyFromState(state, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n  if (typeof body !== 'string') return { error: 'invalid body', status: 400 }\n  if ((await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const nextState = { body, hash: payload.next_hash, revision: payload.revision }\n  const checkpoint = checkpointWebSocketState(env, payload, body, nextState)\n  const logAccepted = () => console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'websocket',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, state: nextState, checkpoint, logAccepted }\n}\n\nfunction headersToObject(headers) {\n  const result = {}\n  for (const [key, value] of headers.entries()) result[key] = value\n  return result\n}\n\nasync function handleRelayPayload(env, payload) {\n  const prepared = await prepareUpstream(env, payload)\n  if (prepared.error) return prepared\n  const upstream = await fetch(payload.upstream.url, {\n    method: payload.upstream.method || 'POST',\n    headers: payload.upstream.headers,\n    body: prepared.body,\n  })\n  return { upstream, stateWrite: prepared.stateWrite }\n}\n\nasync function handleWebSocket(socket, env, ctx, payload, getState, setState) {\n  const heartbeat = setInterval(() => {\n    try {\n      socket.send(JSON.stringify({ protocol: 2, type: 'keepalive' }))\n    } catch {\n      clearInterval(heartbeat)\n    }\n  }, 15000)\n  let streamCoalescer = null\n  try {\n    const result = await prepareWebSocketUpstream(env, getState(), payload)\n    if (result.error) {\n      socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: result.status, message: result.error }))\n      return\n    }\n\n    setState(result.state)\n    socket.send(JSON.stringify({ protocol: 2, type: 'accepted', id: payload.id, hash: result.state.hash, revision: result.state.revision }))\n    ctx?.waitUntil?.(deferWorkerTask(result.logAccepted))\n\n    const upstreamPromise = fetch(payload.upstream.url, {\n      method: payload.upstream.method || 'POST',\n      headers: payload.upstream.headers,\n      body: result.body,\n    })\n    ctx?.waitUntil?.(result.checkpoint)\n    const upstream = await upstreamPromise\n    socket.send(JSON.stringify({\n      protocol: 2,\n      type: 'response_start',\n      id: payload.id,\n      status: upstream.status,\n      statusText: upstream.statusText,\n      headers: headersToObject(upstream.headers),\n    }))\n\n    const reader = upstream.body?.getReader()\n    if (reader) {\n      streamCoalescer = createWebSocketStreamCoalescer(socket)\n      while (true) {\n        const { done, value } = await reader.read()\n        if (done) break\n        streamCoalescer.push(value)\n      }\n      streamCoalescer.flush()\n    }\n    const stats = streamCoalescer?.stats?.() || {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'done', id: payload.id, ...stats }))\n  } catch (error) {\n    try {\n      streamCoalescer?.flush?.()\n    } catch {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: 500, message: error instanceof Error ? error.message : String(error) }))\n  } finally {\n    clearInterval(heartbeat)\n  }\n}\n\nexport default {\n  async fetch(request, env, ctx) {\n    if (request.headers.get('Upgrade') === 'websocket') {\n      const url = new URL(request.url)\n      const token = url.searchParams.get('token')\n      const affinity = url.searchParams.get('affinity')\n      if (token !== env.RELAY_TOKEN) return new Response('unauthorized', { status: 401 })\n      if (!affinity) return new Response('missing affinity', { status: 400 })\n      const pair = new WebSocketPair()\n      const client = pair[0]\n      const server = pair[1]\n      server.binaryType = 'arraybuffer'\n      let state = null\n      let ready = false\n      server.accept()\n      const loadState = readState(env, affinity).then((loadedState) => {\n        state = loadedState\n        ready = true\n        server.send(JSON.stringify({\n          protocol: 2,\n          type: 'ready',\n          state: state ? { hash: state.hash, revision: state.revision } : null,\n        }))\n      }).catch((error) => {\n        server.send(JSON.stringify({ protocol: 2, type: 'error', status: 500, message: error instanceof Error ? error.message : String(error) }))\n        server.close(1011, 'state load failed')\n      })\n      ctx?.waitUntil?.(loadState)\n      if (!ctx?.waitUntil) void loadState\n      let busy = false\n      server.addEventListener('message', (event) => {\n        if (!ready) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 425, message: 'relay state is not ready' }))\n          return\n        }\n        if (busy) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 429, message: 'request already in flight' }))\n          return\n        }\n        let payload\n        try {\n          payload = JSON.parse(event.data)\n        } catch {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 400, message: 'invalid JSON payload' }))\n          return\n        }\n        payload.affinity = affinity\n        busy = true\n        const run = handleWebSocket(server, env, ctx, payload, () => state, (nextState) => { state = nextState }).finally(() => { busy = false })\n        ctx?.waitUntil?.(run)\n        if (!ctx?.waitUntil) void run\n      })\n      return new Response(null, { status: 101, webSocket: client })\n    }\n\n    if (request.method === 'GET') {\n      return Response.json({ status: 'ok', transports: ['http', 'websocket'] })\n    }\n    if (request.method !== 'POST') return new Response('method not allowed', { status: 405 })\n    if (request.headers.get('x-relay-token') !== env.RELAY_TOKEN) {\n      return new Response('unauthorized', { status: 401 })\n    }\n\n    try {\n      const payload = await request.json()\n      const result = await handleRelayPayload(env, payload)\n      if (result.error) return Response.json({ error: result.error }, { status: result.status })\n\n      if (result.stateWrite) ctx.waitUntil(result.stateWrite)\n\n      const upstream = result.upstream\n      return new Response(upstream.body, {\n        status: upstream.status,\n        statusText: upstream.statusText,\n        headers: upstream.headers,\n      })\n    } catch (error) {\n      return Response.json(\n        { error: error instanceof Error ? error.message : 'internal relay error' },\n        { status: 502 },\n      )\n    }\n  },\n}\n";
+export declare const WORKER_SCRIPT = "\nasync function hashBody(body) {\n  const bytes = new TextEncoder().encode(body)\n  const digest = await crypto.subtle.digest('SHA-256', bytes)\n  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('')\n  return 'sha256:' + hex\n}\n\nfunction applyPatch(base, patch) {\n  return base.slice(0, patch.start) + patch.insert + base.slice(patch.start + patch.deleteCount)\n}\n\nfunction applyPatchSet(base, patch) {\n  if (!Array.isArray(patch)) return applyPatch(base, patch)\n  if (patch.length === 0) return base\n\n  let result = ''\n  let cursor = 0\n  for (const item of patch) {\n    if (item.start < cursor) return { error: 'overlapping patch', status: 400 }\n    result += base.slice(cursor, item.start)\n    result += item.insert\n    cursor = item.start + item.deleteCount\n  }\n  return result + base.slice(cursor)\n}\n\nasync function readState(env, affinity) {\n  const raw = await env.RELAY_STATE.get('session:' + affinity)\n  return raw ? JSON.parse(raw) : null\n}\n\nasync function writeState(env, affinity, state) {\n  await env.RELAY_STATE.put('session:' + affinity, JSON.stringify(state), { expirationTtl: 86400 })\n}\n\nasync function resolveBody(env, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    const state = await readState(env, payload.affinity)\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nasync function prepareUpstream(env, payload) {\n  if ((payload.protocol !== 1 && payload.protocol !== 2) || payload.type !== 'request' || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = await resolveBody(env, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n\n  if (typeof body !== 'string' || (await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const stateWrite = writeState(env, payload.affinity, { body, hash: payload.next_hash, revision: payload.revision }).catch(() => {})\n  console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'relay',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, stateWrite }\n}\n\nfunction resolveBodyFromState(state, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nfunction deferWorkerTask(task) {\n  return new Promise((resolve) => setTimeout(resolve, 0)).then(task)\n}\n\nconst WEBSOCKET_STREAM_FLUSH_BYTES = 1024\nconst WEBSOCKET_STREAM_FLUSH_MS = 20\n\nfunction createWebSocketStreamCoalescer(socket, options = {}) {\n  const flushBytes = options.flushBytes || WEBSOCKET_STREAM_FLUSH_BYTES\n  const flushMs = options.flushMs ?? WEBSOCKET_STREAM_FLUSH_MS\n  let chunks = []\n  let byteLength = 0\n  let flushTimer = null\n  const stats = {\n    upstreamChunks: 0,\n    upstreamBytes: 0,\n    frames: 0,\n    frameBytes: 0,\n  }\n\n  const clearFlushTimer = () => {\n    if (flushTimer === null) return\n    clearTimeout(flushTimer)\n    flushTimer = null\n  }\n\n  const mergeChunks = () => {\n    if (chunks.length === 1) return chunks[0]\n    const frame = new Uint8Array(byteLength)\n    let offset = 0\n    for (const chunk of chunks) {\n      frame.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return frame\n  }\n\n  const flush = () => {\n    clearFlushTimer()\n    if (byteLength === 0) return\n    const frame = mergeChunks()\n    chunks = []\n    byteLength = 0\n    socket.send(frame)\n    stats.frames += 1\n    stats.frameBytes += frame.byteLength\n  }\n\n  const scheduleFlush = () => {\n    if (flushTimer !== null) return\n    flushTimer = setTimeout(flush, flushMs)\n  }\n\n  return {\n    push(value) {\n      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value)\n      if (chunk.byteLength === 0) return\n      stats.upstreamChunks += 1\n      stats.upstreamBytes += chunk.byteLength\n      chunks.push(chunk)\n      byteLength += chunk.byteLength\n      if (byteLength >= flushBytes) flush()\n      else scheduleFlush()\n    },\n    flush,\n    stats() {\n      return { ...stats, pendingBytes: byteLength }\n    },\n  }\n}\n\nfunction checkpointWebSocketState(env, payload, body, nextState) {\n  return deferWorkerTask(async () => {\n    try {\n      if ((await hashBody(body)) !== payload.next_hash) {\n        throw new Error('hash mismatch')\n      }\n      await writeState(env, payload.affinity, nextState)\n    } catch {\n      console.log(JSON.stringify({\n        relay: 'opencode-anthropic-auth',\n        transport: 'websocket',\n        event: 'checkpoint_write_failed',\n        affinity: String(payload.affinity).slice(0, 12),\n        code: 'checkpoint_write_error',\n      }))\n    }\n  })\n}\n\nasync function prepareWebSocketUpstream(env, state, payload) {\n  if (payload.protocol !== 2 || payload.type !== 'request' || !payload.id || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = resolveBodyFromState(state, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n  if (typeof body !== 'string') return { error: 'invalid body', status: 400 }\n  if ((await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const nextState = { body, hash: payload.next_hash, revision: payload.revision }\n  const checkpoint = checkpointWebSocketState(env, payload, body, nextState)\n  const logAccepted = () => console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'websocket',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, state: nextState, checkpoint, logAccepted }\n}\n\nfunction headersToObject(headers) {\n  const result = {}\n  for (const [key, value] of headers.entries()) result[key] = value\n  return result\n}\n\nasync function handleRelayPayload(env, payload) {\n  const prepared = await prepareUpstream(env, payload)\n  if (prepared.error) return prepared\n  const upstream = await fetch(payload.upstream.url, {\n    method: payload.upstream.method || 'POST',\n    headers: payload.upstream.headers,\n    body: prepared.body,\n  })\n  return { upstream, stateWrite: prepared.stateWrite }\n}\n\nasync function handleWebSocket(socket, env, ctx, payload, getState, setState) {\n  const heartbeat = setInterval(() => {\n    try {\n      socket.send(JSON.stringify({ protocol: 2, type: 'keepalive' }))\n    } catch {\n      clearInterval(heartbeat)\n    }\n  }, 15000)\n  let streamCoalescer = null\n  try {\n    const result = await prepareWebSocketUpstream(env, getState(), payload)\n    if (result.error) {\n      socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: result.status, message: result.error }))\n      return\n    }\n\n    setState(result.state)\n    socket.send(JSON.stringify({ protocol: 2, type: 'accepted', id: payload.id, hash: result.state.hash, revision: result.state.revision }))\n    ctx?.waitUntil?.(deferWorkerTask(result.logAccepted))\n\n    const upstreamPromise = fetch(payload.upstream.url, {\n      method: payload.upstream.method || 'POST',\n      headers: payload.upstream.headers,\n      body: result.body,\n    })\n    ctx?.waitUntil?.(result.checkpoint)\n    const upstream = await upstreamPromise\n    socket.send(JSON.stringify({\n      protocol: 2,\n      type: 'response_start',\n      id: payload.id,\n      status: upstream.status,\n      statusText: upstream.statusText,\n      headers: headersToObject(upstream.headers),\n    }))\n\n    const reader = upstream.body?.getReader()\n    if (reader) {\n      streamCoalescer = createWebSocketStreamCoalescer(socket)\n      while (true) {\n        const { done, value } = await reader.read()\n        if (done) break\n        streamCoalescer.push(value)\n      }\n      streamCoalescer.flush()\n    }\n    const stats = streamCoalescer?.stats?.() || {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'done', id: payload.id, ...stats }))\n  } catch (error) {\n    try {\n      streamCoalescer?.flush?.()\n    } catch {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: 500, message: error instanceof Error ? error.message : String(error) }))\n  } finally {\n    clearInterval(heartbeat)\n  }\n}\n\nexport default {\n  async fetch(request, env, ctx) {\n    if (request.headers.get('Upgrade') === 'websocket') {\n      const url = new URL(request.url)\n      const token = url.searchParams.get('token')\n      const affinity = url.searchParams.get('affinity')\n      if (token !== env.RELAY_TOKEN) return new Response('unauthorized', { status: 401 })\n      if (!affinity) return new Response('missing affinity', { status: 400 })\n      const pair = new WebSocketPair()\n      const client = pair[0]\n      const server = pair[1]\n      server.binaryType = 'arraybuffer'\n      let state = null\n      let ready = false\n      server.accept()\n      const loadState = readState(env, affinity).then((loadedState) => {\n        state = loadedState\n        ready = true\n        server.send(JSON.stringify({\n          protocol: 2,\n          type: 'ready',\n          state: state ? { hash: state.hash, revision: state.revision } : null,\n        }))\n      }).catch((error) => {\n        server.send(JSON.stringify({ protocol: 2, type: 'error', status: 500, message: error instanceof Error ? error.message : String(error) }))\n        server.close(1011, 'state load failed')\n      })\n      ctx?.waitUntil?.(loadState)\n      if (!ctx?.waitUntil) void loadState\n      let busy = false\n      server.addEventListener('message', (event) => {\n        if (!ready) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 425, message: 'relay state is not ready' }))\n          return\n        }\n        if (busy) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 429, message: 'request already in flight' }))\n          return\n        }\n        let payload\n        try {\n          payload = JSON.parse(event.data)\n        } catch {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 400, message: 'invalid JSON payload' }))\n          return\n        }\n        payload.affinity = affinity\n        busy = true\n        const run = handleWebSocket(server, env, ctx, payload, () => state, (nextState) => { state = nextState }).finally(() => { busy = false })\n        ctx?.waitUntil?.(run)\n        if (!ctx?.waitUntil) void run\n      })\n      return new Response(null, { status: 101, webSocket: client })\n    }\n\n    if (request.method === 'GET') {\n      return Response.json({ status: 'ok', transports: ['http', 'websocket'] })\n    }\n    if (request.method !== 'POST') return new Response('method not allowed', { status: 405 })\n    if (request.headers.get('x-relay-token') !== env.RELAY_TOKEN) {\n      return new Response('unauthorized', { status: 401 })\n    }\n\n    try {\n      const payload = await request.json()\n      const result = await handleRelayPayload(env, payload)\n      if (result.error) return Response.json({ error: result.error }, { status: result.status })\n\n      if (result.stateWrite) ctx.waitUntil(result.stateWrite)\n\n      const upstream = result.upstream\n      return new Response(upstream.body, {\n        status: upstream.status,\n        statusText: upstream.statusText,\n        headers: upstream.headers,\n      })\n    } catch (error) {\n      return Response.json(\n        { error: error instanceof Error ? error.message : 'internal relay error' },\n        { status: 502 },\n      )\n    }\n  },\n}\n";

package/dist/request-history.d.ts

@@ -0,0 +1,34 @@
+export declare const TRAILING_ASSISTANT_HISTORY_MESSAGE: string;
+/** Shape-only details keep conversation content out of errors and logs. */
+export declare class TrailingAssistantHistoryError extends Error {
+    readonly details: {
+        messageCount: number;
+        trailingMessageIndex: number;
+        emptyMessagesAfter: number;
+        contentShape: 'string' | 'array' | 'missing' | 'other';
+        contentBlockCount?: number;
+        contentBlockTypes?: string[];
+    };
+    readonly check = "meaningful_trailing_assistant";
+    constructor(details: {
+        messageCount: number;
+        trailingMessageIndex: number;
+        emptyMessagesAfter: number;
+        contentShape: 'string' | 'array' | 'missing' | 'other';
+        contentBlockCount?: number;
+        contentBlockTypes?: string[];
+    });
+}
+/**
+ * Refuse meaningful or unknown assistant trailers without mutating history.
+ * Converters can use this before lowering so dropped opaque or incomplete
+ * blocks cannot hide a missing user boundary. Return the empty-trailer count.
+ * Ordinary user-ended requests inspect only the final element.
+ */
+export declare function assertNoMeaningfulTrailingAssistant(messages: readonly unknown[]): number;
+/**
+ * Remove only provably empty trailers from an owned wire-message array. The
+ * wire does not distinguish a completed answer from a partial prefill, so
+ * deleting meaningful content could replay the previous question.
+ */
+export declare function stripEmptyTrailingAssistantMessages(messages: unknown): number;

package/dist/sse.d.ts

@@ -0,0 +1,81 @@
+/** Largest single frame a framer accepts before it refuses the stream. */
+export declare const DEFAULT_SSE_MAX_FRAME_BYTES: number;
+/**
+ * Raised when a single frame, terminated or not, grows past the framer's
+ * byte bound. The framer cannot continue after this error. The message
+ * carries only sizes, never frame content.
+ */
+export declare class SseFrameTooLargeError extends Error {
+    readonly code = "SSE_FRAME_TOO_LARGE";
+    readonly maxFrameBytes: number;
+    constructor(maxFrameBytes: number);
+}
+export interface SseFramerOptions {
+    /** Upper bound for one frame, complete or partial, in bytes. */
+    maxFrameBytes?: number;
+}
+export interface SseFramer {
+    /**
+     * Feed the next chunk of the stream. Returns every frame completed by this
+     * chunk, in order. Each frame includes its own line terminators and the
+     * blank line that ends it. Returned arrays may be views of `chunk`, so
+     * callers must not mutate them. Throws `SseFrameTooLargeError` when any
+     * single frame, complete or still partial, exceeds the bound; frames
+     * completed earlier in the same chunk are not returned in that case, and
+     * the framer refuses all later input.
+     */
+    push(chunk: Uint8Array): Uint8Array[];
+    /**
+     * Signal end of input and return the unterminated tail, if any. A stream
+     * that ends mid-frame yields that partial frame here instead of losing it.
+     */
+    finish(): Uint8Array | undefined;
+    /** Bytes of the current partial frame held while waiting for its end. */
+    readonly bufferedBytes: number;
+}
+export declare function createSseFramer(options?: SseFramerOptions): SseFramer;
+/** One parsed frame. Field values follow the WHATWG event-stream rules. */
+export interface SseEvent {
+    /** Last `event:` value, or undefined when the frame sets none. */
+    event?: string;
+    /**
+     * All `data:` lines joined with LF, or undefined when the frame has no data
+     * line (a comment or heartbeat that dispatches no event).
+     */
+    data?: string;
+    /** Last `id:` value, ignoring values that contain NUL. */
+    id?: string;
+    /** Last `retry:` value made only of ASCII digits. */
+    retry?: number;
+}
+export interface SseDecodeOptions {
+    /**
+     * The frame is the first one of its stream, so one leading byte-order mark
+     * is dropped as the event-stream rules require. Elsewhere U+FEFF is an
+     * ordinary character (for example part of a field name) and is kept.
+     */
+    streamStart?: boolean;
+}
+/**
+ * Decode a frame as UTF-8, replacing invalid sequences like EventSource. A
+ * leading byte-order mark is dropped only for the first frame of a stream.
+ * The one-argument form stays usable as an `Array.prototype.map` callback.
+ */
+export declare function decodeSseFrame(frame: Uint8Array): string;
+export declare function decodeSseFrame(frame: Uint8Array, options: SseDecodeOptions): string;
+/**
+ * Parse one frame produced by `createSseFramer`. Accepts CRLF, LF and CR line
+ * endings in any mix, comment lines, fields without a colon and multi-line
+ * data. Unknown fields are ignored.
+ */
+export declare function parseSseFrame(frame: Uint8Array | string): SseEvent;
+/** True when the frame ends with a blank line rather than being an EOF tail. */
+export declare function isTerminatedSseFrame(frame: Uint8Array): boolean;
+/**
+ * Cheap raw-byte gate for frames that might be error envelopes: the literal
+ * `error`, or any JSON `\u` escape, which could spell an `error` key or type
+ * without the literal appearing. Frames that fail this gate cannot be error
+ * envelopes and are never decoded. Frames that pass still need parsing; a
+ * successful text delta that mentions "error" passes the gate too.
+ */
+export declare function isSseCandidateFrame(frame: Uint8Array): boolean;

package/dist/sticky-routing.d.ts

@@ -1,4 +1,6 @@
 import { type AccountOperationError, type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
+import type { NativeVaultRosterDocument } from './native-roster-seed.ts';
+import { type NativeVaultRoutingSeed } from './native-vault-seed.ts';
 export declare const STICKY_ROUTING_MAIN_ACCOUNT_ID = "main";
 export declare const STICKY_ROUTING_SHORT_RESET_GRACE_MS: number;
 export declare const STICKY_ROUTING_ASSIGNMENT_TTL_MS: number;
@@ -22,7 +24,10 @@ export type StickyRouteCandidate = {
 };
 export type StickyRouteAssignment = {
     accountId: string;
+    /** Verified account UUID for a credential held by the vault. Pins using credentials stored by this host omit the field. */
+    accountIdentity?: string;
     family: StickyRouteFamily;
+    affinityModelId?: string;
     assignedAt: number;
     lastSeenAt: number;
     initialInputBytes: number;
@@ -57,6 +62,21 @@ export declare function createStickyNoRouteResponse(input: {
     modelId?: string;
     now?: number;
 }): Response;
+/**
+ * Produce deterministic journal bytes from captured, parsed legacy routing JSON.
+ * The offline caller must prove each old-to-concrete row binding, including main;
+ * a map entry is not credential or identity proof. Unmapped assignments and their
+ * implicit prompt-byte deficits are dropped. Quota observations must separately
+ * retain their proven checkedAt values for those deficits to remain attributable.
+ *
+ * The caller owns source/path revalidation, the digest, journal authority and the
+ * locked temp-plus-rename write with an ownership check before rename. An absent
+ * source is handled by the caller, not by substituting an empty state here. This
+ * helper neither authorizes migration nor reads clocks, prunes or writes state.
+ * Invalid source data or unusable map values throw Error('invalid-source') without
+ * including any captured data. Input must be parsed JSON, not executable objects.
+ */
+export declare function migrateStickyRoutingState(source: unknown, rowIdMap: ReadonlyMap<string, string>): string;
 export declare function stickyQuotaSnapshotIsFresh(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, now?: number, modelId?: string): boolean;
 export declare function stickyRouteFamilyForModel(model: unknown): StickyRouteFamily;
 export declare function stickyRouteCandidateWeight(input: {
@@ -80,10 +100,12 @@ export declare class StickySessionRouter {
     private state;
     private stateMtimeNs;
     private touchChain;
+    private seedFinalized;
     constructor(options: {
         path: string;
         now?: () => number;
         assignmentTtlMs?: number;
+        vaultSeed?: NativeVaultRoutingSeed;
     });
     private now;
     private readState;
@@ -93,14 +115,21 @@ export declare class StickySessionRouter {
     private assignmentIsActive;
     private prune;
     private writeState;
+    /** Import legacy session pins only after vault account discovery produces a complete verified roster. No empty routing file is published while that roster is incomplete. */
+    prepareLegacySeed(knownRoster?: NativeVaultRosterDocument | null): Promise<void>;
+    private logicalAccountId;
+    setVaultSeed(seed: NativeVaultRoutingSeed | undefined): void;
     private scheduleTouch;
     private selectCandidate;
     resolve(input: {
         sessionId: string;
         family: StickyRouteFamily;
         modelId?: string;
+        affinityModelId?: string;
         candidates: readonly StickyRouteCandidate[];
         retainAccountIds: ReadonlySet<string>;
+        /** Verified UUIDs for every vault account the host retains, even when quota prevents selection. Omit when credentials are stored by the host instead of the vault. */
+        accountIdentities?: ReadonlyMap<string, string>;
         storage: AccountStorage | null;
         inputBytes: number;
         preferredAccountId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "1.22.0",
+  "version": "2.0.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -21,14 +21,20 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json --emitDeclarationOnly && bun scripts/build.ts",
     "test": "bun run build && bun test src/tests",
+    "test:scripts": "bun test scripts",
+    "check:native-type-closure": "bun scripts/check-native-type-closure.ts",
     "typecheck": "tsc",
     "types": "tsc",
     "prepublishOnly": "bun run build"
   },
+  "devDependencies": {
+    "@cortexkit/common-auth": "0.14.2"
+  },
   "dependencies": {
-    "@cortexkit/subc-client": "^0.8.1",
+    "@cortexkit/claustrum-client": "0.6.2",
+    "jsonc-parser": "^3.3.1",
     "xxhash-wasm": "^1.1.0"
   }
 }