@cortexkit/anthropic-auth-core 1.19.0 → 1.20.0

package/dist/prime.d.ts

@@ -0,0 +1,219 @@
+import { type AccountStorage, type OAuthQuotaSnapshot, type PrimeUsageCounters } from './accounts.ts';
+import { CLAUDE_HAIKU_4_5_PRICING } from './models.ts';
+export { CLAUDE_HAIKU_4_5_PRICING };
+/**
+ * `/claude-prime` — opt-in 5h quota window priming. Default OFF.
+ *
+ * Every OAuth account (main + enabled fallbacks) gets one minimal request
+ * fired ~60s after its `five_hour.resetsAt`, exactly once across concurrent
+ * OpenCode processes. Catch-up on boot; redundancy guard via fresh quota
+ * check; cross-process atomic marker claim via `writeFile(..., flag: 'wx')`.
+ */
+export declare const CLAUDE_PRIME_COMMAND_NAME = "claude-prime";
+export declare const PRIME_TICK_MS = 60000;
+export declare const PRIME_DUE_OFFSET_MS = 60000;
+export declare const PRIME_MARKER_MAX_AGE_MS: number;
+export declare const PRIME_POST_FIRE_REFRESH_MS = 90000;
+/** Minimum interval between forced quota checks for an unchanged reset epoch. */
+export declare const PRIME_CHECK_THROTTLE_MS: number;
+export type PrimeCommandAction = {
+    type: 'status';
+} | {
+    type: 'enable';
+} | {
+    type: 'disable';
+} | {
+    type: 'usage';
+};
+export type PrimeAccountStatus = {
+    id: string;
+    label: string;
+    nextDueAt?: number;
+    lastPrimedAt?: number | null;
+    lastResult?: 'ok' | 'error';
+    usage?: import('./accounts.ts').PrimeUsageCounters;
+    estimatedCostUsd?: number;
+};
+export type PrimeSendResult = {
+    ok: true;
+    status: number;
+    ms: number;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+} | {
+    ok: false;
+    status?: number;
+    ms?: number;
+    error: string;
+    reason?: 'token-refresh' | 'send';
+};
+/**
+ * Pure command parser — accepts `''` / `on` / `off` and treats anything else
+ * as a usage error. Mirrors `parseFastModeCommandAction` shape so all
+ * `claude-*` commands stay uniform.
+ */
+export declare function parsePrimeCommandAction(input: string): PrimeCommandAction;
+/**
+ * Per-million-token USD cost projection. Locale-independent math; the display
+ * layer is responsible for formatting. Returns 0 for absent counters so
+ * pre-fire accounts still get a clean number in the sidebar/dialog.
+ */
+export declare function estimatePrimeCostUsd(usage?: import('./accounts.ts').PrimeUsageCounters): number;
+/**
+ * Project per-account prime status. Enumerates a synthetic `main` plus each
+ * enabled OAuth fallback. `nextDueAt` is the stored five-hour reset plus
+ * `PRIME_DUE_OFFSET_MS`; null when no reset is known. Manager-transient
+ * `lastPrimedAt`/`lastResult` overlay the persisted counters so the dialog and
+ * sidebar can show "just attempted" without waiting for the next save.
+ */
+export declare function buildPrimeAccountStatuses(storage: AccountStorage | null, options?: {
+    now?: number;
+    transient?: ReadonlyMap<string, {
+        lastPrimedAt?: number;
+        lastResult?: 'ok' | 'error';
+    }>;
+}): PrimeAccountStatus[];
+/**
+ * Pure multi-line status summary shared by the OpenCode dialog, the sidebar
+ * expanded row, and the Pi display. Title is stable text the dialog uses to
+ * anchor and the orchestrator uses to assert RED.
+ */
+export declare function buildPrimeStatusSummary(input: {
+    enabled: boolean;
+    accounts: PrimeAccountStatus[];
+}): string;
+/**
+ * Pure executor — returns markdown text and an optional `updated` envelope.
+ * Effects (persistent toggle, manager start/stop) are the caller's job; Pi
+ * uses this same function in display-only mode.
+ */
+export declare function executePrimeCommand(input: {
+    argumentsText: string;
+    enabled: boolean;
+    accounts: PrimeAccountStatus[];
+}): {
+    text: string;
+    updated?: {
+        enabled: boolean;
+    };
+};
+/**
+ * Which gate of the eligibility check failed. The manager logs the human
+ * reason string on every ineligible account (including API-key and
+ * disabled), per the spec's Logging table.
+ */
+export type PrimeEligibilityReason = 'not-oauth' | 'disabled' | 'needs-reauth' | 'killswitch';
+export type PrimeEligibilityResult = {
+    eligible: true;
+} | {
+    eligible: false;
+    reason: PrimeEligibilityReason;
+};
+/**
+ * Eligibility check shared by the manager tick and the dialog preview.
+ * Returns a discriminated result so the manager can log a specific reason
+ * per the spec's Logging table. Quota policy is evaluated authoritatively on
+ * the fresh snapshot immediately before claim.
+ */
+export declare function primeIsEligible(input: {
+    storage: AccountStorage | null;
+    accountId: 'main' | string;
+    isOAuth: boolean;
+    isEnabled: boolean;
+    hasPermanentRefreshError: boolean;
+    quota?: OAuthQuotaSnapshot;
+}): PrimeEligibilityResult;
+export declare function primeEligibilityReasonLabel(reason: PrimeEligibilityReason): string;
+export declare const PRIME_REQUEST_BODY: {
+    readonly model: "claude-haiku-4-5";
+    readonly max_tokens: 1;
+    readonly system: 'Reply with 1 when you receive 0.';
+    readonly messages: readonly [{
+        readonly role: 'user';
+        readonly content: '0';
+    }];
+};
+export declare function buildPrimeRequestBody(): {
+    model: string;
+    max_tokens: number;
+    system: string;
+    messages: Array<{
+        role: 'user';
+        content: string;
+    }>;
+};
+/**
+ * Refresh result from a fresh-check. `fresh=false` means the adapter
+ * returned a cached snapshot (e.g. quota API in 429-backoff, or another
+ * process holds the quota file lock). PrimeManager treats a stale
+ * result as "do not claim, retry next tick" so a cached past
+ * `resetsAt` can never cause a duplicate prime against an
+ * already-started window.
+ */
+export type PrimeRefreshResult = {
+    quota: OAuthQuotaSnapshot;
+    fresh: boolean;
+};
+export declare function primeStorageFingerprint(storagePath: string): string;
+export declare function primeMarkerNamespaceDir(markerDir: string, storagePath: string): string;
+export declare function primeAccountMarkerDir(markerDir: string, storagePath: string, accountFingerprint: string): string;
+export declare function primeMarkerPath(markerDir: string, accountId: 'main' | string, resetsAtEpochMs: number): string;
+/**
+ * Scheduler for `/claude-prime`. Mirrors `CacheKeepManager` lifecycle (unref'd
+ * 60s interval, idempotent start/stop, swallowed tick errors) but adds the
+ * cross-process atomic marker claim before firing — exactly one OpenCode
+ * process fires per reset epoch even with N concurrent instances.
+ *
+ * Dependencies are injected so the manager can be exercised deterministically
+ * without filesystem, network, or live OAuth state.
+ */
+export type PrimeManagerOptions = {
+    loadStorage: () => Promise<AccountStorage | null>;
+    /** Returns a non-secret digest, or undefined when identity is unavailable. */
+    getAccountFingerprint: (accountId: 'main' | string) => Promise<string | undefined>;
+    refreshQuota: (accountId: 'main' | string) => Promise<PrimeRefreshResult>;
+    sendPrime: (accountId: 'main' | string) => Promise<PrimeSendResult>;
+    recordSuccess: (accountId: 'main' | string, usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+    }) => Promise<PrimeUsageCounters>;
+    now?: () => number;
+    markerDir?: string;
+    storagePath: string;
+};
+export declare class PrimeManager {
+    private timer;
+    private postFireRefreshTimers;
+    private lastForcedCheck;
+    private stopped;
+    options: PrimeManagerOptions;
+    private transient;
+    private counters;
+    private windowActive;
+    constructor(options: PrimeManagerOptions);
+    updateOptions(options: PrimeManagerOptions): void;
+    start(): void;
+    stop(): void;
+    isStopped(): boolean;
+    tick(): Promise<void>;
+    /**
+     * Project cumulative per-account status for the sidebar and dialog. Machine
+     * values only — formatting belongs in the TUI/sidebar/Pi layer.
+     */
+    stats(storage?: AccountStorage | null, nowArg?: number): PrimeAccountStatus[];
+    /** True if the most recent fresh-check observed the window as already running. */
+    isWindowActive(accountId: 'main' | string): boolean;
+    private runForAccount;
+    private tryClaim;
+    private tryClaimBootstrap;
+    private tryClaimPath;
+    private hasAnyClaimMarker;
+    private fire;
+    private schedulePostFireRefresh;
+    private sweepMarkers;
+    private sweepMarkerDirectory;
+    private storageMarkerDir;
+    private markerDir;
+}