@cortexkit/anthropic-auth-core 1.21.0 → 1.22.0

package/dist/index.js

@@ -5,13 +5,16 @@ export * from './cachekeep.js';
 export * from './cachekeep-registry.js';
 export * from './cch.js';
 export * from './claude-code.js';
+export * from './claustrum.js';
 export * from './commands/account.js';
 export * from './constants.js';
 export * from './dump.js';
 export * from './fast.js';
+export * from './json.js';
 export * from './killswitch.js';
 export * from './logger.js';
 export * from './logging.js';
+export * from './mid-conversation-output-config.js';
 export * from './models.js';
 export * from './oauth-profile.js';
 export * from './pkce.js';
@@ -25,3 +28,4 @@ export * from './relay.js';
 export * from './routing.js';
 export * from './start.js';
 export * from './sticky-routing.js';
+export * from './thinking-binding.js';

package/dist/json.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonRedacted(text: string): unknown;

package/dist/json.js

@@ -0,0 +1,10 @@
+export function parseJsonRedacted(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new SyntaxError('invalid JSON');
+        throw error;
+    }
+}

package/dist/mid-conversation-output-config.d.ts

@@ -0,0 +1,13 @@
+export declare const MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
+export type AdaptiveEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type MidConversationEffortTransition = {
+    /** Number of assistant messages preceding the user boundary for this effort. */
+    afterAssistantMessages: number;
+    effort: AdaptiveEffort;
+};
+export declare function normalizeAdaptiveEffort(value: unknown): AdaptiveEffort | undefined;
+export declare function usesMidConversationOutputConfig(body: Record<string, unknown>): boolean;
+export declare function applyMidConversationOutputConfig(body: Record<string, unknown>, transitions: readonly MidConversationEffortTransition[]): {
+    applied: boolean;
+    inserted: number;
+};

package/dist/mid-conversation-output-config.js

@@ -0,0 +1,89 @@
+import { isClaudeFable51Model } from './models.js';
+export const MID_CONVERSATION_OUTPUT_CONFIG_BETA = 'mid-conversation-output-config-2026-07-01';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function normalizeAdaptiveEffort(value) {
+    if (value === 'minimal')
+        return 'low';
+    if (value === 'low' ||
+        value === 'medium' ||
+        value === 'high' ||
+        value === 'xhigh' ||
+        value === 'max') {
+        return value;
+    }
+    return undefined;
+}
+export function usesMidConversationOutputConfig(body) {
+    return isClaudeFable51Model(body.model);
+}
+function compactTransitions(transitions) {
+    const compacted = [];
+    for (const transition of transitions) {
+        if (!Number.isSafeInteger(transition.afterAssistantMessages) ||
+            transition.afterAssistantMessages < 0 ||
+            !normalizeAdaptiveEffort(transition.effort)) {
+            continue;
+        }
+        const normalized = {
+            afterAssistantMessages: transition.afterAssistantMessages,
+            effort: transition.effort,
+        };
+        const previous = compacted.at(-1);
+        if (previous &&
+            previous.afterAssistantMessages === normalized.afterAssistantMessages) {
+            previous.effort = normalized.effort;
+            continue;
+        }
+        if (previous?.effort === normalized.effort)
+            continue;
+        compacted.push(normalized);
+    }
+    return compacted;
+}
+export function applyMidConversationOutputConfig(body, transitions) {
+    if (!usesMidConversationOutputConfig(body) || !Array.isArray(body.messages)) {
+        return { applied: false, inserted: 0 };
+    }
+    const compacted = compactTransitions(transitions);
+    const currentOutputConfig = isRecord(body.output_config)
+        ? body.output_config
+        : {};
+    const baseline = compacted[0]?.effort ??
+        normalizeAdaptiveEffort(currentOutputConfig.effort) ??
+        'high';
+    body.output_config = { ...currentOutputConfig, effort: baseline };
+    if (compacted.length < 2)
+        return { applied: true, inserted: 0 };
+    const messages = body.messages;
+    const transitionsByBoundary = new Map();
+    for (const transition of compacted.slice(1)) {
+        transitionsByBoundary.set(transition.afterAssistantMessages, transition.effort);
+    }
+    let assistantMessages = 0;
+    let activeEffort = baseline;
+    let inserted = 0;
+    const rewritten = [];
+    for (const message of messages) {
+        if (isRecord(message) &&
+            message.role === 'user' &&
+            transitionsByBoundary.has(assistantMessages)) {
+            const effort = transitionsByBoundary.get(assistantMessages);
+            if (effort && effort !== activeEffort) {
+                rewritten.push({
+                    role: 'system',
+                    content: [],
+                    output_config: { effort },
+                });
+                activeEffort = effort;
+                inserted++;
+            }
+        }
+        rewritten.push(message);
+        if (isRecord(message) && message.role === 'assistant')
+            assistantMessages++;
+    }
+    body.messages = rewritten;
+    return { applied: true, inserted };
+}

package/dist/models.d.ts

@@ -1,5 +1,7 @@
 export declare const CLAUDE_FABLE_5_MODEL_ID = "claude-fable-5";
 export declare const CLAUDE_MYTHOS_5_MODEL_ID = "claude-mythos-5";
+export declare const CLAUDE_FABLE_5_1_MODEL_ID = "claude-fable-5-1";
+export declare const CLAUDE_MYTHOS_5_1_MODEL_ID = "claude-mythos-5-1";
 /**
  * Haiku 4.5 model identifier used by `/claude-prime` to start each OAuth
  * account's five-hour quota window with a minimal request. Usage is measured
@@ -16,7 +18,8 @@ export declare const CLAUDE_HAIKU_4_5_PRICING: {
     readonly input: 1;
     readonly output: 5;
 };
-export declare const CLAUDE_FABLE_MYTHOS_5_MODEL_IDS: readonly ["claude-fable-5", "claude-mythos-5"];
+export declare const CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS: readonly ["claude-fable-5-1", "claude-mythos-5-1"];
+export declare const CLAUDE_FABLE_MYTHOS_5_MODEL_IDS: readonly ["claude-fable-5", "claude-mythos-5", "claude-fable-5-1", "claude-mythos-5-1"];
 export type ClaudeFableMythos5ModelId = (typeof CLAUDE_FABLE_MYTHOS_5_MODEL_IDS)[number];
 export declare const CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING: {
     readonly type: 'adaptive';
@@ -29,15 +32,38 @@ export declare const CLAUDE_FABLE_MYTHOS_5_PRICING: {
     readonly cacheWrite5m: 12.5;
     readonly cacheWrite1h: 20;
 };
+export declare const CLAUDE_FABLE_MYTHOS_5_1_PRICING: {
+    readonly input: 10;
+    readonly output: 50;
+    readonly cacheRead: 0.25;
+    readonly cacheWrite5m: 12.5;
+    readonly cacheWrite1h: 20;
+};
 export declare const CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW = 1000000;
 export declare const CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS = 128000;
 export declare const CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE = "2026-06-09";
+export declare const CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE = "2026-09-01";
 export declare const CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS: Record<ClaudeFableMythos5ModelId, {
     id: ClaudeFableMythos5ModelId;
     name: string;
     limited?: boolean;
 }>;
+export declare const CLAUDE_FABLE_MYTHOS_5_1_MODEL_SPECS: {
+    "claude-fable-5-1": {
+        id: ClaudeFableMythos5ModelId;
+        name: string;
+        limited?: boolean;
+    };
+    "claude-mythos-5-1": {
+        id: ClaudeFableMythos5ModelId;
+        name: string;
+        limited?: boolean;
+    };
+};
 export declare function isClaudeFableOrMythos5Model(model: unknown): boolean;
+export declare function isClaudeFableOrMythos51Model(model: unknown): boolean;
+export declare function isClaudeFable51Model(model: unknown): boolean;
+export declare function getClaudeFableMythos5ReleaseDate(model: unknown): "2026-06-09" | "2026-09-01";
 export declare const CLAUDE_SONNET_5_MODEL_ID = "claude-sonnet-5";
 /**
  * Sonnet 5 enables adaptive thinking by default but ships `display: "omitted"`,

package/dist/models.js

@@ -1,5 +1,7 @@
 export const CLAUDE_FABLE_5_MODEL_ID = 'claude-fable-5';
 export const CLAUDE_MYTHOS_5_MODEL_ID = 'claude-mythos-5';
+export const CLAUDE_FABLE_5_1_MODEL_ID = 'claude-fable-5-1';
+export const CLAUDE_MYTHOS_5_1_MODEL_ID = 'claude-mythos-5-1';
 /**
  * Haiku 4.5 model identifier used by `/claude-prime` to start each OAuth
  * account's five-hour quota window with a minimal request. Usage is measured
@@ -16,9 +18,14 @@ export const CLAUDE_HAIKU_4_5_PRICING = {
     input: 1,
     output: 5,
 };
+export const CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS = [
+    CLAUDE_FABLE_5_1_MODEL_ID,
+    CLAUDE_MYTHOS_5_1_MODEL_ID,
+];
 export const CLAUDE_FABLE_MYTHOS_5_MODEL_IDS = [
     CLAUDE_FABLE_5_MODEL_ID,
     CLAUDE_MYTHOS_5_MODEL_ID,
+    ...CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS,
 ];
 export const CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING = {
     type: 'adaptive',
@@ -31,9 +38,17 @@ export const CLAUDE_FABLE_MYTHOS_5_PRICING = {
     cacheWrite5m: 12.5,
     cacheWrite1h: 20,
 };
+export const CLAUDE_FABLE_MYTHOS_5_1_PRICING = {
+    input: 10,
+    output: 50,
+    cacheRead: 0.25,
+    cacheWrite5m: 12.5,
+    cacheWrite1h: 20,
+};
 export const CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW = 1_000_000;
 export const CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS = 128_000;
 export const CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE = '2026-06-09';
+export const CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE = '2026-09-01';
 export const CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS = {
     [CLAUDE_FABLE_5_MODEL_ID]: {
         id: CLAUDE_FABLE_5_MODEL_ID,
@@ -44,11 +59,39 @@ export const CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS = {
         name: 'Claude Mythos 5',
         limited: true,
     },
+    [CLAUDE_FABLE_5_1_MODEL_ID]: {
+        id: CLAUDE_FABLE_5_1_MODEL_ID,
+        name: 'Claude Fable 5.1',
+    },
+    [CLAUDE_MYTHOS_5_1_MODEL_ID]: {
+        id: CLAUDE_MYTHOS_5_1_MODEL_ID,
+        name: 'Claude Mythos 5.1',
+        limited: true,
+    },
+};
+export const CLAUDE_FABLE_MYTHOS_5_1_MODEL_SPECS = {
+    [CLAUDE_FABLE_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_FABLE_5_1_MODEL_ID],
+    [CLAUDE_MYTHOS_5_1_MODEL_ID]: CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS[CLAUDE_MYTHOS_5_1_MODEL_ID],
 };
 export function isClaudeFableOrMythos5Model(model) {
     return (typeof model === 'string' &&
         CLAUDE_FABLE_MYTHOS_5_MODEL_IDS.some((id) => model === id || model.startsWith(`${id}-`)));
 }
+export function isClaudeFableOrMythos51Model(model) {
+    return (typeof model === 'string' &&
+        CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS.some((id) => model === id || model.startsWith(`${id}-`)));
+}
+export function isClaudeFable51Model(model) {
+    if (typeof model !== 'string')
+        return false;
+    return (model === CLAUDE_FABLE_5_1_MODEL_ID ||
+        model.startsWith(`${CLAUDE_FABLE_5_1_MODEL_ID}-`));
+}
+export function getClaudeFableMythos5ReleaseDate(model) {
+    return isClaudeFableOrMythos51Model(model)
+        ? CLAUDE_FABLE_MYTHOS_5_1_RELEASE_DATE
+        : CLAUDE_FABLE_MYTHOS_5_RELEASE_DATE;
+}
 export const CLAUDE_SONNET_5_MODEL_ID = 'claude-sonnet-5';
 /**
  * Sonnet 5 enables adaptive thinking by default but ships `display: "omitted"`,

package/dist/network-errors.d.ts

@@ -0,0 +1 @@
+export declare function isTransientNetworkError(error: unknown): boolean;

package/dist/network-errors.js

@@ -0,0 +1,27 @@
+const TRANSIENT_NETWORK_ERROR_CODES = new Set([
+    'EAI_AGAIN',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'ENOTFOUND',
+    'ETIMEDOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+]);
+function errorField(error, field) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const value = error[field];
+    return typeof value === 'string' ? value : undefined;
+}
+export function isTransientNetworkError(error) {
+    const code = errorField(error, 'code');
+    if (code && TRANSIENT_NETWORK_ERROR_CODES.has(code))
+        return true;
+    const message = error instanceof Error
+        ? error.message
+        : (errorField(error, 'message') ?? String(error));
+    if (message.includes('fetch failed'))
+        return true;
+    return [...TRANSIENT_NETWORK_ERROR_CODES].some((candidate) => message.includes(candidate));
+}

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

@@ -1,5 +1,5 @@
-import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
-export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+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;
 export type QuotaHeaderFeedIdentity = {
     identity_source: 'credential_id';
@@ -10,12 +10,25 @@ export type QuotaHeaderFeedIdentity = {
 } | {
     identity_source: 'none';
 };
-export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & {
+export type QuotaHeaderFeedProvenance = Partial<Record<QuotaFieldName, QuotaFieldSource>>;
+type QuotaHeaderFeedQuota = Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'> & {
+    provenance?: QuotaHeaderFeedProvenance;
+};
+type QuotaHeaderFeedMetadata = {
     schema_version: typeof QUOTA_HEADER_FEED_SCHEMA_VERSION;
     provider: 'anthropic';
     configured_account_count: number;
+    /** Header observation time; merged poll-owned fields retain their own checkedAt. */
     observed_at_ms: number;
-    quota: Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'>;
+};
+export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    quota: QuotaHeaderFeedQuota;
+};
+export type QuotaHeaderFeedPublishEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    quota: Omit<QuotaHeaderFeedQuota, 'provenance'> & {
+        fieldSources?: QuotaFieldSources;
+    };
+    accountKey: string;
 };
 export declare function getDefaultQuotaHeaderFeedDirectory(): string;
 export declare function configuredAnthropicOAuthAccountCount(input: {
@@ -32,9 +45,8 @@ export declare class QuotaHeaderFeedRegistry {
         leaseMs?: number;
         instanceId?: string;
     });
-    publish(entry: QuotaHeaderFeedEntry & {
-        accountKey: string;
-    }): Promise<void>;
+    publish(entry: QuotaHeaderFeedPublishEntry): Promise<void>;
     list(): Promise<QuotaHeaderFeedEntry[]>;
     dispose(): Promise<void>;
 }
+export {};

package/dist/quota-header-feed.js

@@ -2,8 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { chmod, mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { isOAuthAccount, } from './accounts.js';
-export const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+import { isOAuthAccount, QUOTA_FIELD_NAMES, } from './accounts.js';
+export const QUOTA_HEADER_FEED_SCHEMA_VERSION = 3;
 export const QUOTA_HEADER_FEED_LEASE_MS = 180_000;
 export function getDefaultQuotaHeaderFeedDirectory() {
     return (process.env.OPENCODE_ANTHROPIC_AUTH_QUOTA_FEED_DIR ??
@@ -129,6 +129,20 @@ function projectExtraUsage(value) {
         exhausted: candidate.exhausted,
     };
 }
+function projectQuotaProvenance(value, presentFields) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const provenance = {};
+    for (const field of QUOTA_FIELD_NAMES) {
+        if (!presentFields.has(field))
+            continue;
+        const source = candidate[field];
+        if (source === 'poll' || source === 'headers')
+            provenance[field] = source;
+    }
+    return Object.keys(provenance).length > 0 ? provenance : undefined;
+}
 function projectQuota(quota) {
     const fiveHour = projectQuotaWindow(quota.five_hour);
     const sevenDay = projectQuotaWindow(quota.seven_day);
@@ -138,6 +152,22 @@ function projectQuota(quota) {
             .filter((entry) => entry != null)
         : undefined;
     const extraUsage = projectExtraUsage(quota.extraUsage);
+    const presentFields = new Set();
+    if (fiveHour)
+        presentFields.add('five_hour');
+    if (sevenDay)
+        presentFields.add('seven_day');
+    if (typeof quota.bindingWindow === 'string') {
+        presentFields.add('bindingWindow');
+    }
+    if (typeof quota.fallbackAdvised === 'boolean') {
+        presentFields.add('fallbackAdvised');
+    }
+    if (scoped)
+        presentFields.add('scoped');
+    if (extraUsage)
+        presentFields.add('extraUsage');
+    const provenance = projectQuotaProvenance(quota.fieldSources, presentFields);
     return {
         ...(fiveHour && { five_hour: fiveHour }),
         ...(sevenDay && { seven_day: sevenDay }),
@@ -149,6 +179,7 @@ function projectQuota(quota) {
         }),
         ...(scoped && { scoped }),
         ...(extraUsage && { extraUsage }),
+        ...(provenance && { provenance }),
     };
 }
 export class QuotaHeaderFeedRegistry {

package/dist/quota-headers.js

@@ -1,3 +1,4 @@
+import { QUOTA_FIELD_NAMES, quotaFieldSource } from './accounts.js';
 const PREFIX = 'anthropic-ratelimit-unified-';
 const WINDOW_KEYS = {
     '5h': 'five_hour',
@@ -31,38 +32,90 @@ function normalizeWindow(headers, suffix, checkedAt) {
     };
 }
 export function normalizeQuotaHeaders(headers, now = Date.now()) {
+    const fieldSources = {};
+    const fallbackHeader = headers.get(`${PREFIX}fallback`);
     const snapshot = {
-        fallbackAdvised: headers.get(`${PREFIX}fallback`) === 'available',
+        fallbackAdvised: fallbackHeader === 'available',
         source: 'headers',
         checkedAt: now,
     };
     for (const [suffix, key] of Object.entries(WINDOW_KEYS)) {
         const window = normalizeWindow(headers, suffix, now);
-        if (window)
+        if (window) {
             snapshot[key] = window;
+            fieldSources[key] = 'headers';
+        }
     }
     const representativeClaim = headers.get(`${PREFIX}representative-claim`);
     if (representativeClaim) {
         snapshot.bindingWindow = representativeClaim;
         snapshot.bindingWindowSource = 'headers';
+        fieldSources.bindingWindow = 'headers';
     }
-    return snapshot;
+    if (fallbackHeader !== null)
+        fieldSources.fallbackAdvised = 'headers';
+    return {
+        ...snapshot,
+        fieldSources,
+    };
 }
 export function mergeHeaderQuotaSnapshot(existing, incoming) {
-    const { scoped: existingScoped, extraUsage: existingExtraUsage, ...existingWithoutPollOwnedFields } = existing ?? {};
-    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, ...incomingWithoutPollOwnedFields } = incoming;
+    const { scoped: existingScoped, extraUsage: existingExtraUsage, fieldSources: existingFieldSources, ...existingWithoutPollOwnedFields } = existing ?? {};
+    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, fieldSources: incomingFieldSources, ...incomingWithoutPollOwnedFields } = incoming;
+    const fieldSources = {};
+    for (const field of QUOTA_FIELD_NAMES) {
+        const value = field === 'scoped'
+            ? existingScoped
+            : field === 'extraUsage'
+                ? existingExtraUsage
+                : field === 'fallbackAdvised'
+                    ? incomingFieldSources?.fallbackAdvised !== undefined
+                        ? incoming.fallbackAdvised
+                        : (existing?.fallbackAdvised ?? incoming.fallbackAdvised)
+                    : field === 'bindingWindow'
+                        ? existing?.bindingWindowSource === 'poll'
+                            ? existing?.bindingWindow
+                            : (incoming.bindingWindow ?? existing?.bindingWindow)
+                        : (incoming[field] ?? existing?.[field]);
+        if (value === undefined)
+            continue;
+        const source = field === 'fallbackAdvised'
+            ? (incomingFieldSources?.fallbackAdvised ??
+                (existing?.fallbackAdvised !== undefined
+                    ? existingFieldSources
+                        ? existingFieldSources.fallbackAdvised
+                        : quotaFieldSource(existing, field)
+                    : undefined))
+            : (field === 'scoped' || field === 'extraUsage') && value !== undefined
+                ? 'poll'
+                : field === 'bindingWindow' &&
+                    existing?.bindingWindowSource === 'poll' &&
+                    existing.bindingWindow !== undefined
+                    ? 'poll'
+                    : incoming[field] !== undefined
+                        ? (incomingFieldSources?.[field] ??
+                            quotaFieldSource(incoming, field))
+                        : (existingFieldSources?.[field] ??
+                            quotaFieldSource(existing, field));
+        if (source)
+            fieldSources[field] = source;
+    }
     return {
         ...existingWithoutPollOwnedFields,
         ...incomingWithoutPollOwnedFields,
         ...(Array.isArray(existingScoped) && { scoped: existingScoped }),
         ...(existingExtraUsage != null && { extraUsage: existingExtraUsage }),
+        fallbackAdvised: incomingFieldSources?.fallbackAdvised !== undefined
+            ? incoming.fallbackAdvised
+            : (existing?.fallbackAdvised ?? incoming.fallbackAdvised),
         bindingWindow: existing?.bindingWindowSource === 'poll'
             ? existing.bindingWindow
             : (incoming.bindingWindow ?? existing?.bindingWindow),
         bindingWindowSource: existing?.bindingWindowSource === 'poll'
             ? 'poll'
             : (incoming.bindingWindowSource ?? existing?.bindingWindowSource),
-        // Source tracks 5h/7d freshness; preserved scoped and credit fields remain poll-owned.
+        ...(Object.keys(fieldSources).length > 0 && { fieldSources }),
+        // Top-level source remains headers for compatibility; fieldSources records ownership after partial harvests.
         source: 'headers',
     };
 }

package/dist/quota-manager.d.ts

@@ -23,6 +23,8 @@ export type QuotaManagerOptions = {
     now?: () => number;
     onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string, fetchStartedAt: number, quotaErrorGeneration: number, quotaErrorClearedAt: number | undefined) => void;
     onApiError?: (error: AccountOperationError, quotaErrorGeneration: number) => void;
+    onFallbackQuotaFetched?: (accountId: string, quota: OAuthQuotaSnapshot, checkedAt: number, fetchStartedAt: number) => void;
+    onFallbackApiError?: (accountId: string, error: AccountOperationError) => void;
 };
 export declare class QuotaManager {
     private main;
@@ -47,6 +49,8 @@ export declare class QuotaManager {
     private readonly now;
     private readonly onMainQuotaFetched;
     private readonly onApiError;
+    private readonly onFallbackQuotaFetched;
+    private readonly onFallbackApiError;
     constructor(opts: QuotaManagerOptions);
     /**
      * Cached main quota entry, scoped to the account behind the main credential.
@@ -69,7 +73,7 @@ export declare class QuotaManager {
     refreshMainWithMetadata(mainAccountIdOrAccessToken: string | undefined, accessToken?: string, expectedIdentityGeneration?: number): Promise<QuotaRefreshResult>;
     refreshFallback(accountId: string, accessToken: string, account: Pick<OAuthAccount, 'authLineageId'> | undefined): Promise<OAuthQuotaSnapshot>;
     refreshFallbackWithMetadata(accountId: string, accessToken: string, account: Pick<OAuthAccount, 'authLineageId'> | undefined): Promise<QuotaRefreshResult>;
-    refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
+    refreshAllFallbacks(accounts: OAuthAccount[], resolveAccessToken?: (account: OAuthAccount) => string | undefined): Promise<void>;
     /**
      * Fire-and-forget refresh. Does not await, swallows errors.
      */

package/dist/quota-manager.js

@@ -65,12 +65,16 @@ export class QuotaManager {
     now;
     onMainQuotaFetched;
     onApiError;
+    onFallbackQuotaFetched;
+    onFallbackApiError;
     constructor(opts) {
         this.storage = opts.storage;
         this.fetchImpl = opts.fetchImpl ?? fetch;
         this.now = opts.now ?? Date.now;
         this.onMainQuotaFetched = opts.onMainQuotaFetched;
         this.onApiError = opts.onApiError;
+        this.onFallbackQuotaFetched = opts.onFallbackQuotaFetched;
+        this.onFallbackApiError = opts.onFallbackApiError;
         this.seedMainFromStorage(opts.storage, opts.storage?.mainAccountId);
         this.seedMainBackoffFromStorage(opts.storage);
     }
@@ -255,19 +259,25 @@ export class QuotaManager {
         });
         return promise;
     }
-    async refreshAllFallbacks(accounts) {
+    async refreshAllFallbacks(accounts, resolveAccessToken) {
         const now = this.now();
         for (const account of accounts) {
             if (account.enabled === false)
                 continue;
-            if (!account.access)
+            const accessToken = resolveAccessToken?.(account) ??
+                (account.access &&
+                    account.expires !== undefined &&
+                    account.expires > now
+                    ? account.access
+                    : undefined);
+            if (!accessToken)
                 continue;
             this.bindFallbackLineage(account.id, account);
             const cached = this.getFallback(account.id);
             if (cached && now < cached.refreshAfter)
                 continue;
             try {
-                await this.refreshFallback(account.id, account.access, account);
+                await this.refreshFallback(account.id, accessToken, account);
             }
             catch {
                 // Best-effort — keep stale cache entry if fetch fails
@@ -462,6 +472,18 @@ export class QuotaManager {
                 continue;
             if (account.enabled === false)
                 continue;
+            const persistedError = account.lastQuotaRefreshError;
+            const persistedClearAt = quotaSnapshotCheckedAt(account.quota);
+            const currentError = this.fallbackApiErrors.get(account.id);
+            if (persistedError &&
+                quotaBackoffActive(persistedError, this.now()) &&
+                persistedClearAt <= (persistedError.checkedAt ?? 0) &&
+                (!currentError || persistedError.checkedAt >= currentError.checkedAt)) {
+                this.fallbackApiErrors.set(account.id, persistedError);
+            }
+            else if (currentError && persistedClearAt >= currentError.checkedAt) {
+                this.fallbackApiErrors.delete(account.id);
+            }
             if (!account.quota)
                 continue;
             const checkedAt = quotaSnapshotCheckedAt(account.quota);
@@ -696,6 +718,7 @@ export class QuotaManager {
                     throw new Error('Quota refresh is already in progress');
                 }
                 try {
+                    const fetchStartedAt = this.now();
                     const quota = await fetchOAuthQuotaSnapshot({
                         accessToken,
                         fetchImpl: this.fetchImpl,
@@ -715,6 +738,7 @@ export class QuotaManager {
                         checkedAt: completedQuota.checkedAt ?? now,
                     }, account);
                     this.fallbackApiErrors.delete(accountId);
+                    this.onFallbackQuotaFetched?.(accountId, completedQuota, now, fetchStartedAt);
                     return { quota: completedQuota, fetched: true };
                 }
                 finally {
@@ -769,11 +793,13 @@ export class QuotaManager {
         if (QuotaManager.isAuthError(error))
             return;
         const previous = this.fallbackApiErrors.get(accountId);
-        this.fallbackApiErrors.set(accountId, buildQuotaOperationError({
+        const quotaError = buildQuotaOperationError({
             error,
             now: this.now(),
             previous,
             accountIdentity: accountId,
-        }));
+        });
+        this.fallbackApiErrors.set(accountId, quotaError);
+        this.onFallbackApiError?.(accountId, quotaError);
     }
 }

package/dist/thinking-binding.d.ts

@@ -0,0 +1,7 @@
+import type { AccountStorage } from './accounts.ts';
+export declare const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
+export type ThinkingPrefixMismatchBehavior = 'account-default' | 'error' | 'drop_block';
+export declare function getThinkingPrefixMismatchBehavior(storage: Pick<AccountStorage, 'thinkingBinding'> | null | undefined): ThinkingPrefixMismatchBehavior;
+export declare function hasReplayableThinkingBlocks(body: Record<string, unknown>): boolean;
+export declare function applyThinkingBindingControls(body: Record<string, unknown>, behavior?: ThinkingPrefixMismatchBehavior): boolean;
+export declare function hasThinkingBindingControls(body: Record<string, unknown>): boolean;