@cortexkit/anthropic-auth-core 2.2.1 → 2.2.3

package/dist/internal-types/claustrum/consumer.d.ts

@@ -169,8 +169,10 @@ export declare class ClaustrumConsumer<Q = QuotaObservation> {
      * a served credential (an insula reading from `cachedInsulaQuotaForRoute`).
      * It lands only while the route is still bound to that known account, so no
      * credential fetch is needed and a replaced account's reading is dropped.
-     * The in-memory roster is reloaded from the file, without a vault call.
+     * Memory updates immediately; durable publication is detached and coalesced.
      */
     recordAccountQuota(routeId: string, accountIdentity: string, observation: QuotaObservation): Promise<boolean>;
     close(): void;
+    /** Close immediately; the last consumer also waits for the writer's bounded drain. */
+    dispose(): Promise<void>;
 }

package/dist/internal-types/claustrum/enrollment.d.ts

@@ -1,4 +1,9 @@
 import { type ClaustrumClientOptions as ClaustrumEnrollmentClientOptions, type EnrollmentPollOutcome, type EnrollmentTokenFile, writeEnrollmentTokenFile } from '@cortexkit/claustrum-client';
+/**
+ * The code a vault without the enrollment ceremony answers a proposal with.
+ * Setup reports it as "this vault cannot connect plugins" instead of waiting.
+ */
+export declare const UNSUPPORTED_ENROLLMENT_CODE = "unknown_method";
 /**
  * Codes the vault's closed enrollment-refusal vocabulary marks permanent. The
  * client labels some module error frames transient/retry regardless, so the

package/dist/internal-types/claustrum/index.d.ts

@@ -9,6 +9,7 @@ export { ClaustrumConsumerError, type ClaustrumConsumerFailureKind, type Claustr
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, type HostSlotContent, isCustodyPlaceholder, isCustodyPlaceholderValue, } from './host-slot.js';
 export { acquireInsulaQuotaSource, type InsulaQuotaContext, type InsulaQuotaLookup, type InsulaQuotaMiss, type InsulaQuotaOptions, type InsulaQuotaReading, type InsulaQuotaResult, type InsulaQuotaSource, type InsulaUsageEntry, type InsulaUsageTransport, type InsulaUsageWatch, type InsulaUsageWindow, type InsulaWatchOptions, } from './insula.js';
 export { acceptAccount, type DeclinedAccount, declineAccount, isDeclined, } from './interlock.js';
+export { drainVaultQuota } from './quota-writer.js';
 export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
 export { type ChangeNotice, ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, type ScopedRosterWatchOptions, type ScopedWatchEnd, type ScopedWatchHandle, type ScopedWatchNoticeShape, type ScopedWatchSource, WATCH_RETRY_MS, type WatchMode, } from './watch.js';
 /**

package/dist/internal-types/claustrum/quota-writer.d.ts

@@ -0,0 +1,18 @@
+import { type QuotaObservation } from '../quota/index.js';
+import { type QuotaReceipt, type VaultRosterFile } from './roster.js';
+export type VaultQuotaPublication = {
+    routeId: string;
+    accountIdentity?: string;
+    receipt?: QuotaReceipt;
+    observation: QuotaObservation;
+};
+type Listener = (publication: VaultQuotaPublication) => void;
+/** Retain the shared writer; the last consumer's close drains it. */
+export declare function retainVaultQuotaWriter(path: string, listener: Listener): () => Promise<void>;
+/** Enqueue without filesystem work; each quota field retains its own receipt fence. */
+export declare function enqueueVaultQuota(path: string, publication: VaultQuotaPublication): Promise<boolean>;
+/** Overlay uncommitted observations when a consumer reloads the durable roster. */
+export declare function pendingVaultQuota(path: string, roster: VaultRosterFile | undefined): VaultRosterFile | undefined;
+/** Wait at most timeoutMs for detached publication; shutdown loss is acceptable. */
+export declare function drainVaultQuota(path: string, timeoutMs?: number): Promise<void>;
+export {};

package/dist/internal-types/claustrum/roster.d.ts

@@ -2,6 +2,8 @@ import { type QuotaMap, type QuotaObservation } from '../quota/index.js';
 import type { RoutingRow } from '../routing/index.js';
 import type { ClaustrumScopedAttempt, ClaustrumScopedCustody, SkippedVaultRecord, VaultCredential, VaultCredentialType, VaultInventory } from './custody.js';
 import { type DeclinedAccount } from './interlock.js';
+import { type VaultQuotaPublication } from './quota-writer.js';
+export { drainVaultQuota } from './quota-writer.js';
 /**
  * One vault account as the pool sees it. It carries no bearer material: the
  * access token is fetched from the vault for every send. Several vault
@@ -91,6 +93,7 @@ export interface VaultRosterLockContext {
     assertOwned: () => Promise<void>;
 }
 export interface MutateVaultRosterOptions {
+    signal?: AbortSignal;
     /**
      * Runs when the new roster is fully staged on disk, immediately before the
      * rename that publishes it, so a caller can confirm a lease of its own at
@@ -127,7 +130,10 @@ export type QuotaReceipt = Pick<ClaustrumScopedAttempt, 'credentialId' | 'accoun
  * write is fenced on the receipt the reading was taken with: it lands only
  * while the row still holds that receipt's credential (as representative or
  * alias) and account, so a slow read for a replaced account can never land on
- * its successor. Returns whether the observation was kept.
+ * its successor. Resolves false when the fence refuses the reading against the
+ * roster as it stands now (on disk, plus readings this process has not
+ * written yet), and true once the reading is queued for the next write. The
+ * write applies the fence again, so a rebind between the two still refuses.
  */
 export declare function recordVaultQuota(path: string, input: QuotaReceipt & {
     routeId: string;
@@ -139,19 +145,28 @@ export declare function recordVaultQuota(path: string, input: QuotaReceipt & {
  * lands only while the row is still bound to that exact known account, so a
  * reading taken before a replacement never reaches the successor. Unlike
  * `recordVaultQuota` it never binds an account: a row without a known account
- * is refused. Returns whether the observation was kept.
+ * is refused. Resolves false when the row is not bound to that account now,
+ * and true once the reading is queued, as `recordVaultQuota` does.
  */
 export declare function recordVaultAccountQuota(path: string, input: {
     routeId: string;
     accountIdentity: string;
     observation: QuotaObservation;
 }): Promise<boolean>;
+/** Apply the same identity fence to memory overlays and durable quota batches. */
+export declare function applyVaultQuota(current: VaultRosterFile | undefined, input: VaultQuotaPublication): {
+    roster: VaultRosterFile | undefined;
+    kept: boolean;
+};
+export declare function forgetPendingVaultDiscovery(path: string): void;
 /**
  * Discover and commit the roster. The lease covers the list call and the
  * commit, not just the write: an opaque view cannot tell a delayed old reply
  * from a newer one, so a run that lost its lease is refused at commit. A
  * failed list, or custody switching off mid-run, never writes anything; a
  * peer holding the lease means its last committed roster is served instead.
+ * A write-lock timeout keeps the discovered inventory for the next poll,
+ * unless a peer has superseded its base view in the meantime.
  */
 export declare function refreshVaultRoster(options: {
     path: string;
@@ -159,6 +174,7 @@ export declare function refreshVaultRoster(options: {
     isActive?: () => boolean | Promise<boolean>;
     signal?: AbortSignal;
     projection?: ProjectionOptions | (() => ProjectionOptions);
+    onInventory?: (inventory: VaultInventory) => void;
 }): Promise<VaultRosterFile | undefined>;
 /**
  * A host-owned main account as last verified from the vault: the plugin's

package/dist/internal-types/fs/private-files.d.ts

@@ -5,6 +5,8 @@ type Backend = typeof import('@cortexkit/private-files');
 type Kind = 'file' | 'directory';
 /** Tests inject a backend here; production always imports the private-files package. */
 export declare function setPrivateFilesBackendForTest(api?: Backend): void;
+/** The fixed `reason` of a refusal because the Windows native addon did not load. */
+export declare const PRIVATE_FILES_UNAVAILABLE_REASON = "native-addon-unavailable";
 export declare class PrivateFileError extends Error {
     readonly path: string;
     readonly stage: string;

package/dist/internal-types/fs/with-lock.d.ts

@@ -28,6 +28,7 @@ export interface LockOptions {
     ttlMs: number;
     timeoutMs: number;
     renew?: boolean;
+    signal?: AbortSignal;
     onStep?: Parameters<typeof acquireRefreshFileLock>[0]['onStep'];
     onRenewalTimer?: Parameters<typeof acquireRefreshFileLock>[0]['onRenewalTimer'];
 }

package/dist/internal-types/quota/format.d.ts

@@ -1,3 +1,4 @@
+import { type QuotaCredits } from './map.js';
 import type { ProjectedLimit, ProjectedQuota } from './projection.js';
 /** A reading older than this is marked with its age. */
 export declare const QUOTA_STALE_AFTER_MS: number;
@@ -31,6 +32,13 @@ export interface QuotaWindowPart {
     kind: 'window' | 'budget';
     /** The display name of a quota window, or `credits` for the budget. */
     name: string;
+    /**
+     * The label the narrow line gives this item: an account-wide window keeps
+     * its name (`5h`), a model-scoped window reads as its model's short name
+     * (`Fa` for Fable, extended until names in the same reading differ), and
+     * the budget reads `cr`. For layouts too narrow for the full name.
+     */
+    short: string;
     /** The shared figure wording, including `credits` for budget figures. */
     figure: string;
     /** The unrounded remaining percentage, clamped to 0–100, when known. */
@@ -84,3 +92,14 @@ export declare function quotaTextParts(quota: ProjectedQuota | undefined, option
  * provider answered without a limit for any window.
  */
 export declare function formatQuota(quota: ProjectedQuota | undefined, options: QuotaTextOptions): string;
+/**
+ * Prepaid credits as one short value, worded as the official Codex client's
+ * status view words them: `Unlimited` for unlimited credits, `<n> credits`
+ * for a finite positive balance (rounded to a whole number), `Available` when
+ * the account has credits but no usable balance was reported, and undefined
+ * when the account has no credits (or `credits` is undefined), so a caller
+ * shows no credits row at all. Unlimited wins even when `hasCredits` is false.
+ * No other formatter adds this text; a caller that wants a credits row asks
+ * for it.
+ */
+export declare function quotaCreditsText(credits: Pick<QuotaCredits, 'hasCredits' | 'unlimited' | 'balance'> | undefined): string | undefined;

package/dist/internal-types/quota/index.d.ts

@@ -1,9 +1,9 @@
 export type { QuotaCodec } from './codec.js';
 export { quotaCodec } from './codec.js';
 export type { QuotaParts, QuotaTextForm, QuotaTextOptions, QuotaWindowPart, } from './format.js';
-export { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from './format.js';
-export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, QuotaAbsentEntry, QuotaCounter, QuotaEntry, QuotaMap, QuotaReadingEntry, QuotaRetiredEntry, } from './map.js';
-export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from './map.js';
+export { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaCreditsText, quotaTextParts, quotaWindowName, quotaWindowParts, } from './format.js';
+export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, QuotaAbsentEntry, QuotaCounter, QuotaCredits, QuotaEntry, QuotaMap, QuotaReadingEntry, QuotaRetiredEntry, } from './map.js';
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaCredits, isQuotaMap, } from './map.js';
 export type { ObservedBudget, ObservedPair, ObservedReading, QuotaObservation, } from './merge.js';
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from './merge.js';
 export type { ExhaustionReset, ProjectedBudget, ProjectedLimit, ProjectedQuota, QuotaGroup, } from './projection.js';

package/dist/internal-types/quota/map.d.ts

@@ -48,12 +48,30 @@ export interface QuotaCounter {
     value: number;
     checkedAt: number;
 }
+/**
+ * Prepaid credits a provider account holds beside its rate-limit windows (for
+ * example a ChatGPT workspace's credits, which keep requests working after a
+ * window is used up). This is a state, not a count or the spend budget: the
+ * account has credits or not, they may be unlimited, and the provider may
+ * report a balance. It carries its own observation time.
+ */
+export interface QuotaCredits {
+    hasCredits: boolean;
+    unlimited: boolean;
+    /** The balance the provider reported, when it reported one. */
+    balance?: number;
+    /** The provider's verdict that the overage allowance is used up. */
+    overageLimitReached?: boolean;
+    checkedAt: number;
+}
 export interface QuotaMap {
     limits: QuotaEntry[];
     /** Absent means no observation has reported on the budget yet. */
     budget?: CreditBudgetEntry;
     /** Provider-named counts, each with its own observation time. */
     counters?: Record<string, QuotaCounter>;
+    /** Absent means no observation has reported on prepaid credits yet. */
+    credits?: QuotaCredits;
 }
 export declare function emptyQuotaMap(): QuotaMap;
 /** The time an entry speaks for: its reading, retirement or absence time. */
@@ -61,9 +79,14 @@ export declare function entryTime(entry: QuotaEntry): number;
 export declare function limitKey(scope: string, label: string): string;
 export declare function isCreditBudgetEntry(value: unknown): value is CreditBudgetEntry;
 export declare function isQuotaCounters(value: unknown): value is Record<string, QuotaCounter>;
+/** True when `value` is a well-formed prepaid-credits record. */
+export declare function isQuotaCredits(value: unknown): value is QuotaCredits;
 /** Keep usable counters without letting one malformed count hide a quota map. */
 export declare function readQuotaCounters(value: unknown): Record<string, QuotaCounter> | undefined;
-/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+/**
+ * Decode persisted quota, dropping malformed counters or a malformed credits
+ * record but not limit or budget evidence.
+ */
 export declare function decodeQuotaMap(value: unknown): QuotaMap | undefined;
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys

package/dist/internal-types/quota/merge.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaCounter, type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaCredits, type QuotaMap } from './map.js';
 export interface ObservedReading {
     /** Defaults to `all`. */
     scope?: string;
@@ -34,6 +34,11 @@ export interface QuotaObservation {
     budget?: ObservedBudget;
     /** Each named count uses its own time, independently of limits and budget. */
     counters?: Record<string, QuotaCounter>;
+    /**
+     * Prepaid credits, judged by their own time independently of limits, budget
+     * and counters. Absent means the observation says nothing about credits.
+     */
+    credits?: QuotaCredits;
 }
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export declare class QuotaCodecError extends TypeError {

package/dist/internal-types/quota/projection.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaCounter, type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaCredits, type QuotaMap } from './map.js';
 export interface ProjectedLimit {
     scope: string;
     label: string;
@@ -40,6 +40,8 @@ export interface ProjectedQuota {
     /** Present only when the stored budget is a reading, not cleared. */
     budget?: ProjectedBudget;
     counters?: Record<string, QuotaCounter>;
+    /** The stored prepaid credits, unchanged in every scope. */
+    credits?: QuotaCredits;
     /**
      * The named groups the windows belong to, in the order the plugin lists
      * them. Set only by a plugin whose windows all belong to such groups; the

package/dist/internal-types/setup/enroll.d.ts

@@ -0,0 +1,34 @@
+import { type MenuTerminal } from '../auth-menu/terminal.js';
+import type { SetupHost, SetupIO, SetupPlugin } from './types.js';
+/** Fixed text: no version, host or account detail, so it is safe to print anywhere. */
+export declare const UNSUPPORTED_VAULT_MESSAGE = "This Claustrum vault does not support connecting plugins yet, so setup cannot connect to it. Run setup without --claustrum to use local accounts.";
+/**
+ * The longest setup waits, in total, for the vault to create the enrollment
+ * request and for an operator to approve it. It matches the wait setup always
+ * had (300 one-second polls), but is now measured on the clock: a vault that
+ * answers each request slowly can no longer stretch it.
+ */
+export declare const ENROLLMENT_WAIT_MS = 300000;
+/** Why a host's enrollment ended without a token. */
+export type HostNotEnrolledReason = 'connection-failed' | 'unsupported-vault' | 'request-not-created' | 'approval-pending' | 'refused' | 'invalid-request' | 'incomplete';
+/**
+ * Thrown when the enrollment ended without writing the host's token: the vault
+ * could not be reached, it cannot enroll plugins, it refused the request, it
+ * never created one, approval never came before setup stopped waiting, or
+ * the enrollment failed in some other way (`incomplete`).
+ * Setup can then report the host as not connected without reading its files.
+ * The message is fixed text built only from vetted values, never from what
+ * the vault or client threw. `lastErrorCode` is the last enrollment error code
+ * setup saw, from the vault or from the client's transport (for example
+ * `transport_error`), for diagnostics; it carries no secret.
+ */
+export declare class HostNotEnrolledError extends Error {
+    readonly reason: HostNotEnrolledReason;
+    readonly lastErrorCode?: string;
+    constructor(message: string, details: {
+        reason: HostNotEnrolledReason;
+        lastErrorCode?: string;
+    });
+}
+/** Enroll an independently revocable host; plugin callbacks choose its credential store and account permissions. */
+export declare function connectSetupHost(plugin: SetupPlugin, host: SetupHost, io: SetupIO, terminal: MenuTerminal, fence: () => Promise<void>): Promise<void>;

package/dist/internal-types/setup/index.d.ts

@@ -1,6 +1,7 @@
 export { AMBIGUOUS_OPENCODE_MESSAGE, runSetup } from './command.js';
 export { SetupCommandError, setupEnrollment } from './command-error.js';
 export { detectHosts, detectOpenCodeGeneration, findExecutableOnPath, openCodeDesktopMarkers, } from './detect.js';
+export { ENROLLMENT_WAIT_MS, HostNotEnrolledError, type HostNotEnrolledReason, UNSUPPORTED_VAULT_MESSAGE, } from './enroll.js';
 export { assertHostsStopped, createProcessFence, listSetupProcesses, ProcessFenceViolationError, ProcessInspectionError, type ProcessInspectionStep, } from './process-fence.js';
 export { type PlannedWrite, planOpenCodeRegistration, registerOpenCode, registerPi, updatePluginConfig, } from './register.js';
 export type { CommandResult, CommandRunner, HostDetection, OpenCodeGeneration, ProcessFence, SetupCallbackContext, SetupDetection, SetupEnrollmentOutcome, SetupEnvironment, SetupFileSystem, SetupHost, SetupHostEnrollment, SetupIO, SetupPlugin, SetupResult, } from './types.js';

package/dist/internal-types/setup/process-fence.d.ts

@@ -33,11 +33,25 @@ export declare function listSetupProcesses(runner?: CommandRunner, options?: {
     onStep?: (details: ProcessInspectionStep) => void;
     /** False skips the Windows PowerShell query for Node and Bun command lines. */
     inspectRuntimes?: boolean;
+    /**
+     * The process to leave out, the running setup itself. Defaults to
+     * `process.pid`; tests pass a value no listed process can have, because in
+     * a container this process can hold any small PID a fixture uses.
+     */
+    selfPid?: number;
+    /**
+     * Windows only: answer with one CIM query for the images a fence cares
+     * about (host programs, Node and Bun), returning image name, PID and
+     * command line together, instead of `tasklist` followed by a second CIM
+     * query. The result lists only those processes.
+     */
+    hostImagesOnly?: boolean;
 }): Promise<Array<{
     pid: number;
     command: string;
 }>>;
 export declare function createProcessFence(runner?: CommandRunner, options?: {
     platform?: string;
+    selfPid?: number;
 }): ProcessFence;
 export declare function assertHostsStopped(fence: ProcessFence, env?: SetupEnvironment): Promise<void>;

package/dist/internal-types/setup/types.d.ts

@@ -125,6 +125,11 @@ export interface SetupIO {
         handshakeTimeoutMs: number;
     }) => Promise<ClaustrumEnrollmentConnection>;
     wait?: (ms: number) => Promise<void>;
+    /**
+     * Monotonic milliseconds that bound the enrollment wait. Defaults to
+     * `performance.now`; tests pair it with `wait` to run a fake clock.
+     */
+    now?: () => number;
 }
 export interface HostDetection {
     installed: boolean;

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

@@ -1,9 +1,10 @@
+import { PER_TURN_CONTROL_BETA } from './model-capabilities.ts';
 /**
- * Per-turn control beta that Claude Code sends on Opus 5.5, Sonnet 5.5,
- * Fable 5.1 and Haiku 5.5. It enables effort changes carried by empty
+ * Per-turn control beta that Claude Code sends on the models whose
+ * capability rows list it. It enables effort changes carried by empty
  * `role: "system"` messages on the eligible models below.
  */
-export declare const PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
+export { PER_TURN_CONTROL_BETA };
 export type AdaptiveEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export type MidConversationEffortTransition = {
     /** Number of assistant messages preceding the user boundary for this effort. */
@@ -12,30 +13,33 @@ export type MidConversationEffortTransition = {
 };
 export declare function normalizeAdaptiveEffort(value: unknown): AdaptiveEffort | undefined;
 /**
- * Models that require adaptive thinking for per-message effort: Opus 5.5
- * and Sonnet 5.5, including dated and `[1m]` context-window ids. Header
- * eligibility is separate; `sendsPerTurnControlBeta` follows Claude Code.
+ * Models that require adaptive thinking for per-message effort (capability
+ * `effortMarkers: "with-adaptive-thinking"`: Opus 5.5 and Sonnet 5.5),
+ * including dated and `[1m]` context-window ids. Header eligibility is
+ * separate; `sendsPerTurnControlBeta` follows Claude Code.
  */
 export declare function usesPerTurnControl(model: unknown): boolean;
 /**
- * Models whose OAuth requests carry `PER_TURN_CONTROL_BETA`: Opus 5.5 and
- * Sonnet 5.5, plus Fable 5.1 and Haiku 5.5, which Claude Code 2.1.302 also
- * sends it on. Sending the beta does not by itself make a model eligible for
- * effort markers; `supportsPerMessageEffort` decides that.
+ * Models whose OAuth requests carry `PER_TURN_CONTROL_BETA`: those whose
+ * Claude Code main beta list includes it (Opus 5.5, Sonnet 5.5, Fable 5.1 and
+ * Haiku 5.5 in Claude Code 2.1.302). Sending the beta does not by itself make
+ * a model eligible for effort markers; `supportsPerMessageEffort` decides that.
  */
 export declare function sendsPerTurnControlBeta(model: unknown): boolean;
 /**
  * Whether a request may move effort changes into empty system messages.
  *
- * Fable 5.1 is always eligible, whatever its thinking field says. Opus 5.5
- * and Sonnet 5.5 qualify only with adaptive thinking: Anthropic rejects a
- * differing per-message effort with HTTP 400 on Sonnet 5.5 `between_tools`,
- * and asks callers to use adaptive thinking to vary effort.
+ * Models with `effortMarkers: "always"` (Fable 5.1) are always eligible,
+ * whatever the thinking field says. Models with `"with-adaptive-thinking"`
+ * (Opus 5.5, Sonnet 5.5) qualify only with adaptive thinking: Anthropic
+ * rejects a differing per-message effort with HTTP 400 on Sonnet 5.5
+ * `between_tools`, and asks callers to use adaptive thinking to vary effort.
  */
 export declare function supportsPerMessageEffort(body: Record<string, unknown>): boolean;
 /**
  * The effort Anthropic applies when a request sets no `output_config.effort`:
- * `medium` on Opus 5.5 and Haiku 5.5, `high` on the other models.
+ * the capability row's default (`medium` on Opus 5.5 and Haiku 5.5), and
+ * `high` on models without a row.
  * A history entry without a recognized effort level uses this value.
  */
 export declare function defaultAdaptiveEffort(model: unknown): AdaptiveEffort;

package/dist/model-capabilities.d.ts

@@ -0,0 +1,136 @@
+import type { AdaptiveEffort } from './mid-conversation-output-config.ts';
+/**
+ * One row per Claude model that this plugin treats differently from an
+ * unknown model. Every per-model decision in Core (family checks, effort
+ * handling, Claude Code betas, turn-end notes, thinking-binding controls) and
+ * the per-model facts OpenCode and Pi read (catalogue entries, fallback
+ * eligibility) come from this table, so adding a model is one new row.
+ *
+ * Ids stay exact. A request model resolves to a row only when it equals the
+ * row's id (after removing OpenCode's `[1m]` context-window qualifier) or
+ * extends it as the row's `idSuffixes` allows; when several rows match, the
+ * longest id wins. A model that matches no row gets the defaults described on
+ * each field.
+ */
+/** Per-turn control beta Claude Code sends on the models whose rows list it. */
+export declare const PER_TURN_CONTROL_BETA = "per-turn-control-2026-07-01";
+/** Beta that allows turn-scoped system messages (`clear_at`). */
+export declare const TURN_END_NOTE_BETA = "mid-conversation-system-clear-at-2026-08-21";
+export declare const CLAUDE_CODE_FULL_AGENT_BETAS: readonly ["claude-code-20250219", 'oauth-2025-04-20', 'interleaved-thinking-2025-05-14', 'thinking-token-count-2026-05-13', 'context-management-2025-06-27', "prompt-caching-scope-2026-01-05", 'mid-conversation-tool-changes-2026-07-01', 'advanced-tool-use-2025-11-20', "mid-conversation-system-clear-at-2026-08-21", 'effort-2025-11-24', 'thinking-binding-controls-2026-08-01', 'thinking-display-updates-2026-08-18', 'extended-cache-ttl-2025-04-11', 'cache-diagnosis-2026-04-07'];
+/**
+ * Claude Code's `anthropic-beta` list for each request class, before the
+ * body-dependent additions (turn-end note, structured outputs, fast mode and
+ * caller-supplied betas). `main` is a conversation turn; `title` is any other
+ * auxiliary request; `quota` is a one-token auxiliary probe.
+ */
+export type ClaudeCodeBetaLists = {
+    main: readonly string[];
+    title: readonly string[];
+    quota: readonly string[];
+};
+/** The lists for a model without its own row. */
+export declare const CLAUDE_CODE_DEFAULT_BETAS: ClaudeCodeBetaLists;
+export type ClaudeModelFamily = 'fable' | 'mythos' | 'opus' | 'sonnet' | 'haiku';
+/** Per-million-token USD prices. */
+export type ClaudeModelPricing = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite5m: number;
+    cacheWrite1h: number;
+};
+/**
+ * Catalogue facts for a model the plugin registers itself in OpenCode and Pi,
+ * rather than taking from the host's own model list.
+ */
+export type ClaudeModelCatalogue = {
+    releaseDate: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    pricing: ClaudeModelPricing;
+    /** Higher prices for every token of a request above `inputTokensAbove` input tokens. */
+    longContext?: {
+        inputTokensAbove: number;
+        pricing: ClaudeModelPricing;
+    };
+};
+/** Source-model keys for content-filter recovery to Opus 4.8 in OpenCode. */
+export type ClaudeRefusalRecoveryFamily = 'fable-5' | 'fable-5-1' | 'opus-5' | 'opus-5-5';
+export type ClaudeModelCapabilities = {
+    /** Exact Anthropic model id. */
+    id: string;
+    /** Display name in host model pickers. */
+    name: string;
+    family: ClaudeModelFamily;
+    /**
+     * Longer ids that also resolve to this row: `any` accepts the id followed by
+     * `-` and anything (a date, `-fast`); `dated` accepts only `-YYYYMMDD`.
+     */
+    idSuffixes: 'any' | 'dated';
+    /** Shown as limited availability. */
+    limited?: true;
+    /** Absent when the model comes from the host's own catalogue. */
+    catalogue?: ClaudeModelCatalogue;
+    /**
+     * Thinking settings the API accepts. OpenCode's transform.ts and Pi's
+     * convert.ts still normalize thinking with per-family code; a test checks
+     * that OpenCode's result agrees with this list.
+     */
+    thinkingModes: readonly ('adaptive' | 'disabled' | 'between_tools')[];
+    /** The API rejects `tool_choice` of type `any` or `tool`, so it is removed. */
+    rejectsForcedToolChoice: boolean;
+    efforts: {
+        /**
+         * Efforts offered as host model variants with adaptive thinking. Absent:
+         * the host's own variants are left alone. Unknown models: absent.
+         */
+        variants?: readonly AdaptiveEffort[];
+        /** Anthropic's effort when a request sets none. Unknown models: `high`. */
+        default: AdaptiveEffort;
+    };
+    /**
+     * When effort changes may be sent as empty `role: "system"` messages:
+     * `always` (and top-level effort is then pinned on every request),
+     * `with-adaptive-thinking` (only when the request's thinking is adaptive),
+     * or `none`. Unknown models: `none`.
+     */
+    effortMarkers: 'none' | 'with-adaptive-thinking' | 'always';
+    /** Turn-end notes may be inserted. Unknown models: no. */
+    turnEndNote: boolean;
+    /** `thinking.block_binding` may be set. Unknown models: no. */
+    thinkingBindingControls: boolean;
+    /** Unknown models: `CLAUDE_CODE_DEFAULT_BETAS`. */
+    claudeCodeBetas: ClaudeCodeBetaLists;
+    /** OpenCode may ask Anthropic for its server-side safety fallback. */
+    serverSideFallback: boolean;
+    /** OpenCode recovers from a content-filter refusal on Opus 4.8 under this key. */
+    refusalRecoveryFamily?: ClaudeRefusalRecoveryFamily;
+    /**
+     * Model-scoped weekly quota this model draws from. Quota matching in
+     * accounts.ts and native-quota-codec.ts still matches the substrings
+     * `fable`/`mythos`; a test checks that they agree with this field.
+     */
+    scopedQuota?: 'fable' | 'mythos';
+    /**
+     * Fast mode (`speed: "fast"`) is offered. `isFastModeSupportedModel` also
+     * keeps its older prefix rule for ids outside this table.
+     */
+    fastMode: boolean;
+};
+export declare const CLAUDE_MODEL_CAPABILITIES: readonly ClaudeModelCapabilities[];
+/** Remove OpenCode's context-window qualifier before model-family checks. */
+export declare function normalizeAnthropicModelId(model: string): string;
+/**
+ * The row for a request model, or `undefined` for a model this plugin does
+ * not special-case. See the table's description for how ids match.
+ */
+export declare function resolveClaudeModelCapabilities(model: unknown): ClaudeModelCapabilities | undefined;
+/** The row for an exact model id; throws when the table has no such row. */
+export declare function getClaudeModelCapabilities(id: string): ClaudeModelCapabilities;
+/** Catalogue facts for an exact model id; throws when the row has none. */
+export declare function getClaudeModelCatalogue(id: string): ClaudeModelCatalogue;
+/**
+ * Whether effort is pinned in top-level `output_config` on every request,
+ * even one without an effort change.
+ */
+export declare function pinsEffortOnEveryRequest(model: unknown): boolean;