@cortexkit/anthropic-auth-core 1.21.0 → 1.23.0

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/model-remap.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Remap canonical Claude model IDs to proxy-compatible names
+ * using ANTHROPIC_DEFAULT_*_MODEL env vars.
+ *
+ * LiteLLM/proxy backends often use shorter model aliases
+ * (e.g. `claude-sonnet-4-6` instead of `claude-sonnet-4-20250514`).
+ * These proxy-route variables follow the Claude Code convention, except
+ * ANTHROPIC_DEFAULT_FABLE_MODEL, which is plugin-specific:
+ *
+ *   ANTHROPIC_MODEL                  — default for any claude-* model
+ *   ANTHROPIC_DEFAULT_SONNET_MODEL   — models matching claude-sonnet-*
+ *   ANTHROPIC_DEFAULT_OPUS_MODEL     — models matching claude-opus-*
+ *   ANTHROPIC_DEFAULT_HAIKU_MODEL    — models matching claude-haiku-*
+ *   ANTHROPIC_DEFAULT_FABLE_MODEL    — models matching claude-fable / claude-mythos
+ *
+ * Tier-specific vars take precedence over the generic ANTHROPIC_MODEL.
+ */
+/**
+ * Resolve a canonical model ID to its proxy-compatible alias.
+ * Returns the original model when no env override is configured.
+ */
+export declare function remapModelId(model: string): string;
+/**
+ * Remap the `model` field in a parsed request body in place.
+ * Returns true if the model was changed.
+ */
+export declare function remapRequestBodyModel(parsed: Record<string, unknown>): boolean;

package/dist/model-remap.js

@@ -0,0 +1,72 @@
+/**
+ * Remap canonical Claude model IDs to proxy-compatible names
+ * using ANTHROPIC_DEFAULT_*_MODEL env vars.
+ *
+ * LiteLLM/proxy backends often use shorter model aliases
+ * (e.g. `claude-sonnet-4-6` instead of `claude-sonnet-4-20250514`).
+ * These proxy-route variables follow the Claude Code convention, except
+ * ANTHROPIC_DEFAULT_FABLE_MODEL, which is plugin-specific:
+ *
+ *   ANTHROPIC_MODEL                  — default for any claude-* model
+ *   ANTHROPIC_DEFAULT_SONNET_MODEL   — models matching claude-sonnet-*
+ *   ANTHROPIC_DEFAULT_OPUS_MODEL     — models matching claude-opus-*
+ *   ANTHROPIC_DEFAULT_HAIKU_MODEL    — models matching claude-haiku-*
+ *   ANTHROPIC_DEFAULT_FABLE_MODEL    — models matching claude-fable / claude-mythos
+ *
+ * Tier-specific vars take precedence over the generic ANTHROPIC_MODEL.
+ */
+function getEnv(name) {
+    const value = process.env[name]?.trim();
+    return value || undefined;
+}
+function getModelTier(model) {
+    if (/^claude-sonnet(?:-|$)/.test(model))
+        return 'sonnet';
+    if (/^claude-opus(?:-|$)/.test(model))
+        return 'opus';
+    if (/^claude-haiku(?:-|$)/.test(model))
+        return 'haiku';
+    if (/^claude-(?:fable|mythos)(?:-|$)/.test(model))
+        return 'fable';
+    return null;
+}
+const TIER_ENV_MAP = {
+    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
+};
+/**
+ * Resolve a canonical model ID to its proxy-compatible alias.
+ * Returns the original model when no env override is configured.
+ */
+export function remapModelId(model) {
+    if (typeof model !== 'string' || !model)
+        return model;
+    const tier = getModelTier(model);
+    if (tier) {
+        const tierModel = getEnv(TIER_ENV_MAP[tier]);
+        if (tierModel)
+            return tierModel;
+    }
+    // Generic fallback for any claude-* model
+    if (model.startsWith('claude-')) {
+        const defaultModel = getEnv('ANTHROPIC_MODEL');
+        if (defaultModel)
+            return defaultModel;
+    }
+    return model;
+}
+/**
+ * Remap the `model` field in a parsed request body in place.
+ * Returns true if the model was changed.
+ */
+export function remapRequestBodyModel(parsed) {
+    if (typeof parsed.model !== 'string')
+        return false;
+    const remapped = remapModelId(parsed.model);
+    if (remapped === parsed.model)
+        return false;
+    parsed.model = remapped;
+    return true;
+}

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
@@ -7,6 +9,8 @@ export declare const CLAUDE_MYTHOS_5_MODEL_ID = "claude-mythos-5";
  * above so per-million-token cost estimation does not conflate families.
  */
 export declare const CLAUDE_HAIKU_4_5_MODEL_ID = "claude-haiku-4-5";
+/** Remove OpenCode's context-window qualifier before model-family checks. */
+export declare function normalizeAnthropicModelId(model: string): string;
 /**
  * Per-million-token USD pricing for Haiku 4.5. Used to project the cumulative
  * cost of prime requests from persisted usage counters — never persisted on
@@ -16,7 +20,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 +34,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"`,
@@ -64,4 +92,21 @@ export declare const CLAUDE_OPUS_5_ADAPTIVE_THINKING: {
     readonly display: 'summarized';
 };
 export declare function isClaudeOpus5Model(model: unknown): boolean;
+export declare const CLAUDE_OPUS_5_5_MODEL_ID = "claude-opus-5-5";
+export declare const CLAUDE_OPUS_5_5_RELEASE_DATE = "2026-09-18";
+export declare const CLAUDE_OPUS_5_5_CONTEXT_WINDOW = 1000000;
+export declare const CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS = 128000;
+export declare const CLAUDE_OPUS_5_5_PRICING: {
+    readonly input: 4;
+    readonly output: 20;
+    readonly cacheRead: 0.2;
+    readonly cacheWrite5m: 5;
+    readonly cacheWrite1h: 8;
+};
+export declare const CLAUDE_OPUS_5_5_ADAPTIVE_THINKING: {
+    readonly type: 'adaptive';
+    readonly display: 'summarized';
+};
+export declare function isClaudeOpus55Model(model: unknown): boolean;
+export declare function isClaudeOpus5FamilyModel(model: unknown): boolean;
 export declare function isOpenAIReasoningSignature(value: unknown): boolean;

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
@@ -7,6 +9,10 @@ export const CLAUDE_MYTHOS_5_MODEL_ID = 'claude-mythos-5';
  * above so per-million-token cost estimation does not conflate families.
  */
 export const CLAUDE_HAIKU_4_5_MODEL_ID = 'claude-haiku-4-5';
+/** Remove OpenCode's context-window qualifier before model-family checks. */
+export function normalizeAnthropicModelId(model) {
+    return model.endsWith('[1m]') ? model.slice(0, -4) : model;
+}
 /**
  * Per-million-token USD pricing for Haiku 4.5. Used to project the cumulative
  * cost of prime requests from persisted usage counters — never persisted on
@@ -16,9 +22,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 +42,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,10 +63,43 @@ 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}-`)));
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return CLAUDE_FABLE_MYTHOS_5_MODEL_IDS.some((id) => normalized === id || normalized.startsWith(`${id}-`));
+}
+export function isClaudeFableOrMythos51Model(model) {
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return CLAUDE_FABLE_MYTHOS_5_1_MODEL_IDS.some((id) => normalized === id || normalized.startsWith(`${id}-`));
+}
+export function isClaudeFable51Model(model) {
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return (normalized === CLAUDE_FABLE_5_1_MODEL_ID ||
+        normalized.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';
 /**
@@ -58,9 +110,11 @@ export const CLAUDE_SONNET_5_MODEL_ID = 'claude-sonnet-5';
  */
 export const CLAUDE_SONNET_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
 export function isClaudeSonnet5Model(model) {
-    return (typeof model === 'string' &&
-        (model === CLAUDE_SONNET_5_MODEL_ID ||
-            model.startsWith(`${CLAUDE_SONNET_5_MODEL_ID}-`)));
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return (normalized === CLAUDE_SONNET_5_MODEL_ID ||
+        normalized.startsWith(`${CLAUDE_SONNET_5_MODEL_ID}-`));
 }
 export const CLAUDE_OPUS_5_MODEL_ID = 'claude-opus-5';
 /**
@@ -73,9 +127,34 @@ export const CLAUDE_OPUS_5_MODEL_ID = 'claude-opus-5';
  */
 export const CLAUDE_OPUS_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
 export function isClaudeOpus5Model(model) {
-    return (typeof model === 'string' &&
-        (model === CLAUDE_OPUS_5_MODEL_ID ||
-            model.startsWith(`${CLAUDE_OPUS_5_MODEL_ID}-`)));
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return (!isClaudeOpus55Model(normalized) &&
+        (normalized === CLAUDE_OPUS_5_MODEL_ID ||
+            normalized.startsWith(`${CLAUDE_OPUS_5_MODEL_ID}-`)));
+}
+export const CLAUDE_OPUS_5_5_MODEL_ID = 'claude-opus-5-5';
+export const CLAUDE_OPUS_5_5_RELEASE_DATE = '2026-09-18';
+export const CLAUDE_OPUS_5_5_CONTEXT_WINDOW = 1_000_000;
+export const CLAUDE_OPUS_5_5_MAX_OUTPUT_TOKENS = 128_000;
+export const CLAUDE_OPUS_5_5_PRICING = {
+    input: 4,
+    output: 20,
+    cacheRead: 0.2,
+    cacheWrite5m: 5,
+    cacheWrite1h: 8,
+};
+export const CLAUDE_OPUS_5_5_ADAPTIVE_THINKING = CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING;
+export function isClaudeOpus55Model(model) {
+    if (typeof model !== 'string')
+        return false;
+    const normalized = normalizeAnthropicModelId(model);
+    return (normalized === CLAUDE_OPUS_5_5_MODEL_ID ||
+        normalized.startsWith(`${CLAUDE_OPUS_5_5_MODEL_ID}-`));
+}
+export function isClaudeOpus5FamilyModel(model) {
+    return isClaudeOpus5Model(model) || isClaudeOpus55Model(model);
 }
 export function isOpenAIReasoningSignature(value) {
     if (typeof value !== 'string')

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/oauth-profile.d.ts

@@ -1,8 +1,9 @@
-import type { OAuthAccountProfile } from './accounts.ts';
+import type { OAuthAccountProfile, ProviderAccountUuid } from './accounts.ts';
 export declare const PROFILE_TTL_MS: number;
 export declare function fetchOAuthAccountProfile(input: {
     accessToken: string;
     accountIdentity?: string;
+    providerAccountUuid?: ProviderAccountUuid;
     fetchImpl?: typeof fetch;
     now?: () => number;
     signal?: AbortSignal;

package/dist/oauth-profile.js

@@ -1,6 +1,9 @@
+import { assertNotCustodyTombstone } from './claustrum.js';
 const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
 export const PROFILE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 export async function fetchOAuthAccountProfile(input) {
+    // The bearer value is guarded where it becomes a header, like every other builder.
+    assertNotCustodyTombstone(input.accessToken, 'anthropic');
     const response = await (input.fetchImpl ?? fetch)(PROFILE_URL, {
         method: 'GET',
         signal: input.signal,
@@ -29,6 +32,9 @@ export async function fetchOAuthAccountProfile(input) {
         ...(input.accountIdentity !== undefined && {
             accountIdentity: input.accountIdentity,
         }),
+        ...(input.providerAccountUuid !== undefined && {
+            providerAccountUuid: input.providerAccountUuid,
+        }),
     };
 }
 export function oauthProfileMatchesIdentity(profile, accountIdentity) {

package/dist/prime.d.ts

@@ -30,7 +30,7 @@ export type PrimeAccountStatus = {
     label: string;
     nextDueAt?: number;
     lastPrimedAt?: number | null;
-    lastResult?: 'ok' | 'error';
+    lastResult?: 'ok' | 'error' | 'skipped';
     usage?: import('./accounts.ts').PrimeUsageCounters;
     estimatedCostUsd?: number;
 };
@@ -47,7 +47,7 @@ export type PrimeSendResult = {
     status?: number;
     ms?: number;
     error: string;
-    reason?: 'token-refresh' | 'send';
+    reason?: 'token-refresh' | 'vault-cold' | 'send';
 };
 /**
  * Pure command parser — accepts `''` / `on` / `off` and treats anything else
@@ -72,7 +72,7 @@ export declare function buildPrimeAccountStatuses(storage: AccountStorage | null
     now?: number;
     transient?: ReadonlyMap<string, {
         lastPrimedAt?: number;
-        lastResult?: 'ok' | 'error';
+        lastResult?: 'ok' | 'error' | 'skipped';
     }>;
 }): PrimeAccountStatus[];
 /**
@@ -182,9 +182,17 @@ export type PrimeManagerOptions = {
     now?: () => number;
     markerDir?: string;
     storagePath: string;
+    setIntervalImpl?: typeof globalThis.setInterval;
+    clearIntervalImpl?: typeof globalThis.clearInterval;
+    setTimeoutImpl?: typeof globalThis.setTimeout;
+    clearTimeoutImpl?: typeof globalThis.clearTimeout;
 };
 export declare class PrimeManager {
     private timer;
+    private readonly setIntervalImpl;
+    private readonly clearIntervalImpl;
+    private readonly setTimeoutImpl;
+    private readonly clearTimeoutImpl;
     private postFireRefreshTimers;
     private lastForcedCheck;
     private stopped;

package/dist/prime.js

@@ -155,6 +155,8 @@ function formatPrimed(lastPrimedAt, lastResult) {
     });
     if (lastResult === 'error')
         return `primed ${time} err`;
+    if (lastResult === 'skipped')
+        return `primed ${time} skipped`;
     return `primed ${time} \u2713`;
 }
 function formatUsd(value) {
@@ -346,6 +348,10 @@ function storedResetMs(window) {
 }
 export class PrimeManager {
     timer = null;
+    setIntervalImpl;
+    clearIntervalImpl;
+    setTimeoutImpl;
+    clearTimeoutImpl;
     postFireRefreshTimers = new Set();
     lastForcedCheck = new Map();
     // Set true by `stop()` so a tick already in flight can short-circuit
@@ -373,6 +379,11 @@ export class PrimeManager {
     windowActive = new Map();
     constructor(options) {
         this.options = options;
+        this.setIntervalImpl = options.setIntervalImpl ?? globalThis.setInterval;
+        this.clearIntervalImpl =
+            options.clearIntervalImpl ?? globalThis.clearInterval;
+        this.setTimeoutImpl = options.setTimeoutImpl ?? globalThis.setTimeout;
+        this.clearTimeoutImpl = options.clearTimeoutImpl ?? globalThis.clearTimeout;
     }
     updateOptions(options) {
         this.options = options;
@@ -382,7 +393,7 @@ export class PrimeManager {
             return;
         this.stopped = false;
         logger.trace('prime', 'manager started');
-        this.timer = setInterval(() => {
+        this.timer = this.setIntervalImpl(() => {
             void this.tick().catch((error) => {
                 logger.warn('prime', 'tick failed', {
                     error: error instanceof Error ? error.message : String(error),
@@ -399,11 +410,12 @@ export class PrimeManager {
         const hadPostFireRefresh = this.postFireRefreshTimers.size > 0;
         this.stopped = true;
         if (this.timer) {
-            clearInterval(this.timer);
+            this.clearIntervalImpl(this.timer);
             this.timer = null;
         }
-        for (const timer of this.postFireRefreshTimers)
-            clearTimeout(timer);
+        for (const timer of this.postFireRefreshTimers) {
+            this.clearTimeoutImpl(timer);
+        }
         this.postFireRefreshTimers.clear();
         this.lastForcedCheck.clear();
         if (!hadTimer && !hadPostFireRefresh)
@@ -687,7 +699,7 @@ export class PrimeManager {
         if (this.stopped)
             return;
         if (!result.ok) {
-            // Spec Logging table: two distinct warn events.
+            // `vault-cold` is a cache-warm skip; it is not a provider failure.
             // - `prime token refresh failed` — token-refresh failure
             //   before the request fires (reason: 'token-refresh').
             // - `prime fire failed` — HTTP error / fetch throw /
@@ -698,6 +710,12 @@ export class PrimeManager {
                     error: result.error,
                 });
             }
+            else if (result.reason === 'vault-cold') {
+                logger.debug('prime', 'prime vault credential cold', {
+                    account: evaluation.label,
+                    reason: result.reason,
+                });
+            }
             else {
                 logger.warn('prime', 'prime fire failed', {
                     account: evaluation.label,
@@ -707,7 +725,7 @@ export class PrimeManager {
             }
             this.transient.set(evaluation.id, {
                 lastPrimedAt: now,
-                lastResult: 'error',
+                lastResult: result.reason === 'vault-cold' ? 'skipped' : 'error',
             });
             return;
         }
@@ -757,7 +775,7 @@ export class PrimeManager {
         // Unified fire-response headers can arm the window instantly on newer
         // trees. This branch predates header harvesting, so a delayed poll captures
         // the reset after the usage API's observed propagation lag.
-        const timer = setTimeout(() => {
+        const timer = this.setTimeoutImpl(() => {
             this.postFireRefreshTimers.delete(timer);
             if (this.stopped)
                 return;