@cortexkit/pi-anthropic-auth 1.23.0 → 2.0.0

package/dist/native.js

@@ -0,0 +1,308 @@
+import { resolve } from 'node:path';
+import { acquireNativeAccountRuntime, createNativeUsagePublisher, getAccountStatePath, getHostClaustrumEnrollmentPaths, isKillswitchEnabled, killswitchPassesPolicy, logger, nativeMigrationAuthorityPhase, nativeRuntimeOptionIdentity, quotaSnapshotHasStandardWindows, quotaSnapshotPassesModelScope, quotaSnapshotPassesPolicy, readNativeAccountsForRequest, readNativeMigrationJournal, resolveClaustrumConnectionPath, resolveNativePoolPaths, } from '@cortexkit/anthropic-auth-core';
+import { getPiAccountStoragePath, getPiClaustrumConnectionOptions, getPiConfigDir, requirePiNativeHostAuth, } from './paths.js';
+export function piAttemptAccessToken(attempt) {
+    return attempt.source === 'vault'
+        ? attempt.receipt.accessToken
+        : attempt.admission.access;
+}
+function requestPolicy(routeId, modelId) {
+    return (account, current) => {
+        if (!account.enabled)
+            return { status: 'blocked', reason: 'account-disabled' };
+        if (account.source === 'local' && current.mode !== 'local')
+            return { status: 'blocked', reason: 'local-mode-unavailable' };
+        const storage = current.policyStorage;
+        const needsQuotaPolicy = quotaSnapshotHasStandardWindows(account.quota) &&
+            (account.source !== 'vault' ||
+                Boolean(storage.quota?.minimumRemaining) ||
+                isKillswitchEnabled(storage));
+        const blocked = (isKillswitchEnabled(storage) &&
+            !killswitchPassesPolicy(account.quota, storage, routeId === 'main' ? undefined : routeId, modelId)) ||
+            (routeId !== 'main' &&
+                ((needsQuotaPolicy &&
+                    !quotaSnapshotPassesPolicy(account.quota, storage)) ||
+                    !quotaSnapshotPassesModelScope(account.quota, modelId)));
+        return blocked
+            ? { status: 'blocked', reason: 'quota-ineligible' }
+            : { status: 'allowed' };
+    };
+}
+const runtimes = new Map();
+const RUNTIME_LIMIT = 16;
+function runtimeCacheKey(storagePath) {
+    const enrollment = getHostClaustrumEnrollmentPaths('pi');
+    return JSON.stringify([
+        resolve(storagePath),
+        resolve(getAccountStatePath(storagePath)),
+        resolve(getPiConfigDir()),
+        enrollment.tokenPath,
+        enrollment.statePath,
+        getPiClaustrumConnectionOptions(storagePath).identity,
+        resolve(resolveClaustrumConnectionPath(process.env.PI_ANTHROPIC_AUTH_CLAUSTRUM_CONNECTION_FILE, {
+            ...process.env,
+            OPENCODE_ANTHROPIC_AUTH_CLAUSTRUM_CONNECTION_FILE: undefined,
+        })),
+    ]);
+}
+/**
+ * Core's refusal for an install that offline setup has never migrated, such
+ * as a 1.x install upgraded in place. Core does not export the error class,
+ * so it is matched by name and code; no other error matches.
+ */
+export function isNativeMigrationRequired(error) {
+    return (error instanceof Error &&
+        error.name === 'NativeAuthorityError' &&
+        Reflect.get(error, 'code') === 'migration-required');
+}
+/** Checks Pi host authentication and enrollment before delegating credential authorization and metadata writes to the shared account runtime. */
+/** How often Pi asks the vault for account changes, matching OpenCode's default. Model requests no longer rediscover a healthy roster, so this poll is how Pi notices a re-login or a newly added account. */
+export const PI_VAULT_POLL_INTERVAL_MS = 2000;
+export class PiNativeRuntime {
+    paths;
+    initialization;
+    vaultWatch;
+    closed = false;
+    closing;
+    usagePublications = createNativeUsagePublisher('native-auth');
+    constructor(storagePath, options = {}) {
+        const env = { ...process.env };
+        const poll = options.vaultPoll ?? { intervalMs: PI_VAULT_POLL_INTERVAL_MS };
+        const identity = getPiClaustrumConnectionOptions(storagePath).identity;
+        this.paths = resolveNativePoolPaths(storagePath);
+        this.initialization = this.paths.then((paths) => {
+            const runtime = acquireNativeAccountRuntime({
+                paths,
+                host: 'pi',
+                vault: {
+                    // Core checks Pi enrollment and reads a fresh scoped receipt on every send.
+                    // Keep the injected connector's identity rather than wrapping it per instance.
+                    connect: options.connect,
+                    env,
+                    identity,
+                },
+            });
+            if (this.closed)
+                runtime.close();
+            // Refresh returns at once while this host uses local accounts, so the
+            // poll costs one enrollment read per tick outside vault custody.
+            else if (poll.intervalMs > 0) {
+                this.vaultWatch = runtime.vault.watch({
+                    intervalMs: poll.intervalMs,
+                    setInterval: poll.setInterval,
+                    clearInterval: poll.clearInterval,
+                });
+                // A failed first discovery must not surface as an unhandled rejection;
+                // the next poll or a request's bounded refresh retries it.
+                void this.vaultWatch.ready.catch(() => { });
+            }
+            return runtime;
+        });
+        // Initialization is lazy from the host's perspective; a path failure is
+        // surfaced by service(), not as an unhandled background rejection.
+        void this.initialization.catch(() => { });
+    }
+    async service() {
+        if (this.closed)
+            throw new Error('Pi native authentication is closed');
+        await requirePiNativeHostAuth();
+        const runtime = await this.initialization;
+        if (this.closed)
+            throw new Error('Pi native authentication is closed');
+        return runtime;
+    }
+    async routingPath() {
+        return (await this.routingStorage()).path;
+    }
+    async routingStorage() {
+        const runtime = await this.service();
+        const snapshot = await runtime.read();
+        if (snapshot.mode === 'claustrum') {
+            if (!snapshot.routingPath)
+                throw new Error('Vault routing storage is unavailable');
+            return { path: snapshot.routingPath, vaultSeed: snapshot.routingSeed };
+        }
+        // Keep local session-to-account assignments at the exact file destination
+        // recorded by migration; guessing a new path would lose those assignments.
+        const journal = await readNativeMigrationJournal(await this.paths);
+        if (!journal ||
+            !nativeMigrationAuthorityPhase(journal) ||
+            !journal.routingPaths.destination)
+            throw new Error('Pi native routing requires committed offline migration');
+        return { path: journal.routingPaths.destination };
+    }
+    /**
+     * Return the account runtime's migration-refusal error when local credentials
+     * have not been migrated by offline setup, or undefined when no such refusal
+     * occurs. Bypass the Pi login check in service() so older installations with
+     * a stored Pi login are recognized too. An enrolled vault may initialize its
+     * public settings on this read; local storage is never changed.
+     */
+    async migrationRefusal() {
+        if (this.closed)
+            return undefined;
+        try {
+            await (await this.initialization).read();
+            return undefined;
+        }
+        catch (error) {
+            return isNativeMigrationRequired(error) ? error : undefined;
+        }
+    }
+    /** Read the published inventory even when no account can serve, so /claude can show its sign-in remedy. */
+    async view(signal) {
+        const runtime = await this.service();
+        signal?.throwIfAborted();
+        return runtime.read();
+    }
+    /** Admit a model request without rediscovering a healthy roster. */
+    async requestView(signal) {
+        const runtime = await this.service();
+        return readNativeAccountsForRequest(runtime, signal);
+    }
+    async authorize(routeId, signal, modelId) {
+        const runtime = await this.service();
+        const snapshot = await runtime.read();
+        const account = snapshot.accounts.find((candidate) => candidate.id === routeId);
+        if (!account?.enabled || account.type !== 'oauth')
+            throw new Error('Pi native OAuth route is unavailable');
+        const policy = requestPolicy(routeId, modelId);
+        if (policy(account, snapshot).status === 'blocked')
+            throw new Error('Pi native quota policy refused the OAuth route');
+        if (snapshot.mode === 'claustrum') {
+            const receipt = await runtime.authorizeVault(routeId, signal);
+            if (!receipt.assertedAccountIdentity)
+                throw new Error('Pi native OAuth identity is unasserted');
+            const current = await runtime.read();
+            const admitted = current.accounts.find((candidate) => candidate.id === routeId);
+            // After the vault lookup, recheck quota limits for this request’s model.
+            // A policy refusal must not report the OAuth token as invalid.
+            if (!admitted ||
+                current.mode !== 'claustrum' ||
+                admitted.accountIdentity !== receipt.assertedAccountIdentity ||
+                requestPolicy(routeId, modelId)(admitted, current).status === 'blocked')
+                throw new Error('Pi native quota policy refused the OAuth route');
+            return {
+                source: 'vault',
+                accountIdentity: receipt.assertedAccountIdentity,
+                receipt,
+            };
+        }
+        const admission = await runtime.authorizeLocal(routeId, { signal, policy });
+        if (admission.status !== 'usable' || !admission.binding.identity)
+            throw new Error('Pi native OAuth admission refused');
+        return {
+            source: 'local',
+            accountIdentity: admission.binding.identity,
+            admission,
+        };
+    }
+    async retry(routeId, served, signal, modelId) {
+        const runtime = await this.service();
+        if (served.source === 'vault') {
+            const current = await runtime.read();
+            const account = current.accounts.find((candidate) => candidate.id === routeId);
+            if (!account ||
+                current.mode !== 'claustrum' ||
+                requestPolicy(routeId, modelId)(account, current).status === 'blocked')
+                return undefined;
+            const decision = await runtime.vault.prepareRetry(served.receipt, signal);
+            logger.debug('native-auth', 'Pi 401 retry decision', {
+                source: 'vault',
+                servedVersion: served.receipt.recordVersion,
+                currentVersion: decision.retry
+                    ? decision.receipt.recordVersion
+                    : undefined,
+                retry: decision.retry,
+                reason: decision.retry ? 'rotated' : decision.reason,
+            });
+            if (!decision.retry || !decision.receipt.assertedAccountIdentity)
+                return undefined;
+            const after = await runtime.read();
+            const admitted = after.accounts.find((candidate) => candidate.id === routeId);
+            if (!admitted ||
+                after.mode !== 'claustrum' ||
+                admitted.accountIdentity !== decision.receipt.assertedAccountIdentity ||
+                requestPolicy(routeId, modelId)(admitted, after).status === 'blocked')
+                return undefined;
+            return {
+                source: 'vault',
+                accountIdentity: decision.receipt.assertedAccountIdentity,
+                receipt: decision.receipt,
+            };
+        }
+        const admission = await runtime.authorizeLocal(routeId, {
+            intent: 'refresh',
+            rejectedAccessToken: served.admission.access,
+            signal,
+            policy: requestPolicy(routeId, modelId),
+        });
+        if (admission.status !== 'usable' ||
+            admission.binding.identity !== served.accountIdentity ||
+            admission.access === served.admission.access)
+            return undefined;
+        return {
+            source: 'local',
+            accountIdentity: served.accountIdentity,
+            admission,
+        };
+    }
+    async report(served, status, source) {
+        if (served.source === 'vault' && status === 401)
+            await (await this.service()).vault.reportFailure(served.receipt, status, source);
+    }
+    async markUsed(served, servingRuntime) {
+        const runtime = servingRuntime ?? (await this.service());
+        const patch = { lastUsed: Date.now() };
+        if (served.source === 'vault')
+            await runtime.vault.publish(served.receipt, patch);
+        else
+            await runtime.publishLocal(served.admission.subject, patch);
+    }
+    close() {
+        this.closed = true;
+        this.vaultWatch?.close();
+        this.closing ??= (async () => {
+            await this.usagePublications.drain();
+            await this.initialization.then((runtime) => runtime.close(), () => { });
+        })();
+        return this.closing;
+    }
+}
+export function getPiNativeRuntime(storagePath = getPiAccountStoragePath(), options = {}) {
+    const contextKey = runtimeCacheKey(storagePath);
+    const key = JSON.stringify([
+        contextKey,
+        nativeRuntimeOptionIdentity(options.connect),
+    ]);
+    const existing = runtimes.get(key);
+    if (existing)
+        return existing.runtime;
+    if (!options.connect) {
+        // A supplied connector installs the context's test transport. Ordinary host
+        // lookups reuse it, but an explicitly different connector owns another key.
+        const configured = [...runtimes.values()].find((entry) => entry.contextKey === contextKey);
+        if (configured)
+            return configured.runtime;
+    }
+    const runtime = new PiNativeRuntime(storagePath, options);
+    while (runtimes.size >= RUNTIME_LIMIT) {
+        const oldest = runtimes.keys().next().value;
+        if (oldest === undefined)
+            break;
+        void runtimes.get(oldest)?.runtime.close();
+        runtimes.delete(oldest);
+    }
+    runtimes.set(key, { contextKey, storagePath: resolve(storagePath), runtime });
+    return runtime;
+}
+export function closePiNativeRuntime(storagePath = getPiAccountStoragePath()) {
+    const closing = [];
+    for (const [key, entry] of runtimes) {
+        if (entry.storagePath !== resolve(storagePath))
+            continue;
+        runtimes.delete(key);
+        closing.push(entry.runtime.close());
+    }
+    return Promise.all(closing).then(() => { });
+}

package/dist/paths.d.ts

@@ -11,3 +11,5 @@ export declare function getPiClaustrumConnectionOptions(storagePath?: string): {
 };
 /** Read-only metadata inspection; never create or rewrite Pi's credential store. */
 export declare function hasPiLocalAnthropicOAuth(): Promise<boolean>;
+/** The user must approve removing the host’s Anthropic OAuth credential before the shared account store can serve requests. */
+export declare function requirePiNativeHostAuth(): Promise<void>;

package/dist/paths.js

@@ -48,3 +48,9 @@ export async function hasPiLocalAnthropicOAuth() {
         throw new Error('Cannot safely inspect Pi authentication metadata');
     }
 }
+/** The user must approve removing the host’s Anthropic OAuth credential before the shared account store can serve requests. */
+export async function requirePiNativeHostAuth() {
+    if (await hasPiLocalAnthropicOAuth()) {
+        throw new Error('Pi still has a host Anthropic OAuth credential. Run offline setup to migrate it and approve its removal before using the native pool.');
+    }
+}

package/dist/stream.d.ts

@@ -1,14 +1,15 @@
-import { type ApiKeyAccount, ClaustrumScopedRuntime, type ClaustrumScopedRuntimeOptions, type MidConversationEffortTransition } from '@cortexkit/anthropic-auth-core';
+import { type ApiKeyAccount, CacheKeepManager, type MidConversationEffortTransition } from '@cortexkit/anthropic-auth-core';
 import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from '@earendil-works/pi-ai';
-export declare function getPiScopedRuntime(storagePath?: string, overrides?: Partial<Pick<ClaustrumScopedRuntimeOptions, 'connect' | 'pollIntervalMs' | 'setTimeoutImpl' | 'clearTimeoutImpl'>>): ClaustrumScopedRuntime;
-export declare function closePiScopedRuntime(storagePath?: string): void;
 export declare function clearPiStickyRoutingSession(storagePath: string, sessionId: string): Promise<void>;
 export declare function getPiTrackedCacheKeepSessions(): Promise<import("@cortexkit/anthropic-auth-core").CacheKeepTrackedSession[]>;
+/** Call prewarmNow directly to exercise its provider request without clock or timer mocks. */
+export declare function __prewarmPiCacheKeepForTest(input: Parameters<CacheKeepManager['prewarmNow']>[0]): Promise<import("@cortexkit/anthropic-auth-core").CacheKeepPrewarmResult>;
 type AnthropicEvent = {
     type?: string;
     index?: number;
     content_block?: Record<string, unknown>;
     delta?: Record<string, unknown>;
+    error?: Record<string, unknown>;
     message?: {
         usage?: Record<string, number>;
     };
@@ -18,5 +19,18 @@ export declare function buildExplicitBaseMessagesUrl(baseURL: string): URL;
 export declare function configureApiRouteHeaders(account: ApiKeyAccount, fastMode: boolean): Headers;
 export declare function parseSse(response: Response): AsyncGenerator<AnthropicEvent>;
 export declare function primaryResponseAllowsApiFallback(preflight: Response | string): boolean;
+/**
+ * Classify a successful stream by its first event without a tee: the bytes
+ * read are replayed in front of the rest of the body, so cancelling the
+ * returned response cancels the provider body itself. `preflight` is
+ * `rate_limit_error` for a streamed rate limit (the provider body is then
+ * cancelled and only the bytes read are replayed), else the returned
+ * response. A stream whose first event does not arrive within the budget, or
+ * cannot be read, is returned unclassified.
+ */
+export declare function firstStreamingError(response: Response): Promise<{
+    response: Response;
+    preflight: Response | 'rate_limit_error';
+}>;
 export declare function streamCortexKitAnthropic(model: Model<Api>, context: Context, options?: SimpleStreamOptions, effortTransitions?: readonly MidConversationEffortTransition[]): AssistantMessageEventStream;
 export {};