agent-afk 5.97.8 → 5.99.0

package/dist/agent/fast-mode.d.ts

@@ -0,0 +1,24 @@
+export type FastModePreference = 'on' | 'off';
+export type FastExecutionPath = 'top-level' | 'child' | 'subagent' | 'skill' | 'compaction' | 'summarization' | 'one-shot' | 'auxiliary';
+export type FastModeInactiveReason = 'preference-off' | 'unsupported-provider' | 'custom-endpoint' | 'excluded-execution-path' | 'unsupported-model';
+export interface FastModeContext {
+    resolvedModelId: string;
+    providerFamily: string;
+    hasCustomEndpoint: boolean;
+    executionPath: FastExecutionPath;
+}
+export type FastModeStatus = Readonly<{
+    preference: FastModePreference;
+    effective: boolean;
+    reason?: FastModeInactiveReason;
+}>;
+export type FastTurnDecision = FastModeStatus;
+export declare function resolveFastModeStatus(preference: FastModePreference, context: FastModeContext): FastModeStatus;
+export declare class FastModeController {
+    private preference;
+    constructor(initial?: FastModePreference);
+    getPreference(): FastModePreference;
+    setPreference(preference: FastModePreference): void;
+    resolveStatus(context: FastModeContext): FastModeStatus;
+    snapshotTurn(context: FastModeContext): FastTurnDecision;
+}

package/dist/agent/providers/anthropic-direct/auth.d.ts

@@ -14,5 +14,5 @@ export declare function buildClientOptions(token: string, mode: AuthMode, baseUr
     baseURL?: string;
     fetch?: typeof fetch;
 };
-export declare function buildRequestHeaders(mode: AuthMode, sessionId: string, requestId: string, withEffort?: boolean, extendedCacheTtl?: boolean): Record<string, string>;
+export declare function buildRequestHeaders(mode: AuthMode, sessionId: string, requestId: string, withEffort?: boolean, extendedCacheTtl?: boolean, withFast?: boolean): Record<string, string>;
 export declare function buildSystemPrefix(mode: AuthMode): ContentBlockParam[] | null;

package/dist/agent/providers/anthropic-direct/beta-headers.d.ts

@@ -0,0 +1,10 @@
+export declare const FAST_MODE_BETA = "fast-mode-2026-02-01";
+export interface BetaHeaderOptions {
+    oauthEntries?: readonly string[];
+    effort?: boolean;
+    extendedCacheTtl?: boolean;
+    fast?: boolean;
+    effortEntry: string;
+    extendedCacheEntry: string;
+}
+export declare function composeBetaHeader(options: BetaHeaderOptions): string | undefined;

package/dist/agent/providers/anthropic-direct/index.d.ts

@@ -1,49 +1,3 @@
-import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
-export { resolveEffort, resolveMaxTokens, resolveThinkingParam } from './resolve-params.js';
-import { type AnthropicDirectProviderOptions } from './provider-options.js';
-export { __setAnthropicClientFactory, type AnthropicClientFactory, type AnthropicDirectProviderOptions, } from './provider-options.js';
-export declare class AnthropicDirectProvider implements ModelProvider {
-    readonly name = "anthropic-direct";
-    private readonly externalTools;
-    private readonly memoryStore;
-    private readonly providerFactory?;
-    private readonly skillExecutor?;
-    private readonly schemas;
-    private readonly hookRegistry;
-    private readonly permissions;
-    private readonly canUseTool;
-    private readonly subagentExecutor;
-    private readonly composeExecutor;
-    private readonly surface;
-    private readonly declaredSurface;
-    private readonly readOnlyMemory;
-    private readonly readOnlyBash;
-    private readonly mcpManager;
-    private readonly customTools;
-    private _sharedReadRoots;
-    private _sharedWriteRoots;
-    private _currentPermissionMode;
-    private _initialResolveBase;
-    private _currentCwd;
-    private _mcpToolsCache;
-    private _mcpHandlersCache;
-    private _presenceSessionId;
-    private _mintedSessionId;
-    constructor(opts?: AnthropicDirectProviderOptions);
-    private buildDispatcher;
-    close(): void;
-    complete(args: ProviderCompleteArgs): Promise<string>;
-    private ensureSharedRoots;
-    private readonly grantManager;
-    addReadRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
-    addWriteRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
-    revokeRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
-    getGrants(): {
-        resolveBase: string | undefined;
-        readRoots: string[];
-        writeRoots: string[];
-        allowAll: boolean;
-    };
-    query(args: ProviderQueryArgs): ProviderQuery;
-}
-export declare const anthropicDirectProvider: ModelProvider;
+export { AnthropicDirectProvider, anthropicDirectProvider, resolveEffort, resolveMaxTokens, resolveThinkingParam, __setAnthropicClientFactory, } from './provider-runtime.js';
+export { AnthropicDirectQuery } from './query-runtime.js';
+export type { AnthropicClientFactory, AnthropicDirectProviderOptions, } from './provider-runtime.js';

package/dist/agent/providers/anthropic-direct/loop/round-request.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderEvent } from '../../../provider.js';
-import type { AnthropicToolDef, RunTurnInput, WireToolDef } from '../types.js';
+import type { AnthropicMessagesCreateParams, AnthropicToolDef, RunTurnInput, WireToolDef } from '../types.js';
 import { type FirstByteTimeoutHandle } from '../../shared/first-byte-timeout.js';
 import { type StreamStallHandle } from '../../shared/stream-stall-timeout.js';
 import { type RoundRetryBudget } from './retry-budget.js';
@@ -25,4 +25,5 @@ export interface OpenRoundContext {
     ttfbTimeoutMs: number;
     stallTimeoutMs: number;
 }
+export declare function buildRoundParams(input: Pick<RunTurnInput, 'model' | 'maxTokens' | 'messages' | 'system' | 'tools' | 'thinking' | 'effort' | 'fastMode'>): AnthropicMessagesCreateParams;
 export declare function openRound({ input, turn, retry, ttfbTimeoutMs, stallTimeoutMs, }: OpenRoundContext): AsyncGenerator<ProviderEvent, OpenRoundResult, void>;

package/dist/agent/providers/anthropic-direct/pricing.d.ts

@@ -10,4 +10,9 @@ export interface CacheWriteSplit {
     ephemeral5m: number;
     ephemeral1h: number;
 }
-export declare function deriveCallCostUsd(model: string, inputTokens: number, outputTokens: number, cachedInputTokens: number, cacheCreationTokens: number, cacheWriteSplit?: CacheWriteSplit): number | undefined;
+export type AnthropicSpeed = 'standard' | 'fast';
+export interface SpeedPricingContext {
+    requestSpeed?: AnthropicSpeed;
+    responseSpeed?: AnthropicSpeed;
+}
+export declare function deriveCallCostUsd(model: string, inputTokens: number, outputTokens: number, cachedInputTokens: number, cacheCreationTokens: number, cacheWriteSplit?: CacheWriteSplit, speed?: SpeedPricingContext): number | undefined;

package/dist/agent/providers/anthropic-direct/provider-context.d.ts

@@ -0,0 +1,31 @@
+import type { CanUseTool } from '../../types/sdk-types.js';
+import type { SessionToolDispatcher } from '../../tools/dispatcher.js';
+import type { ToolDispatcher } from './tool-dispatcher.js';
+import type { SkillExecutor } from '../../tools/skill-executor.js';
+import type { AnthropicClientFactory } from './provider-options.js';
+import type { BuildDispatcherOptions } from './build-dispatcher.js';
+export interface ProviderQueryContext {
+    readonly externalTools: ToolDispatcher | undefined;
+    readonly providerFactory: AnthropicClientFactory | undefined;
+    readonly skillExecutor: SkillExecutor | undefined;
+    readonly subagentExecutor: import('../../tools/subagent-executor.js').SubagentExecutor | undefined;
+    readonly composeExecutor: import('../../tools/compose-executor.js').ComposeExecutor | undefined;
+    readonly canUseTool: CanUseTool | undefined;
+    readonly surface: string;
+    readonly declaredSurface: string | undefined;
+    readonly readOnlyMemory: boolean;
+    readonly mcpManager: import('../../mcp/index.js').McpManager | undefined;
+    readonly fastModeController: import('../../fast-mode.js').FastModeController | undefined;
+    getSharedReadRoots(): string[] | undefined;
+    getSharedWriteRoots(): string[] | undefined;
+    getCurrentCwd(): string | undefined;
+    setCurrentCwd(cwd: string | undefined): void;
+    getCurrentPermissionMode(): string;
+    setCurrentPermissionMode(mode: string): void;
+    getMintedSessionId(): string | null;
+    setMintedSessionId(v: string | null): void;
+    getPresenceSessionId(): string | null;
+    setPresenceSessionId(v: string | null): void;
+    ensureSharedRoots(cwd?: string): void;
+    buildDispatcher(permissionMode: string, opts?: BuildDispatcherOptions): SessionToolDispatcher;
+}

package/dist/agent/providers/anthropic-direct/provider-grants.d.ts

@@ -0,0 +1,16 @@
+import { PathGrantManager } from '../../tools/grant-manager.js';
+export declare class ProviderGrantState {
+    private _readRoots;
+    private _writeRoots;
+    private _initialResolveBase;
+    private _currentCwd;
+    private _permissionMode;
+    readonly manager: PathGrantManager;
+    get readRoots(): string[] | undefined;
+    get writeRoots(): string[] | undefined;
+    get currentCwd(): string | undefined;
+    set currentCwd(cwd: string | undefined);
+    get permissionMode(): string;
+    set permissionMode(mode: string);
+    ensureInitialized(cwd?: string): void;
+}

package/dist/agent/providers/anthropic-direct/provider-options.d.ts

@@ -7,6 +7,7 @@ import type { SkillExecutor } from '../../tools/skill-executor.js';
 import type { ComposeExecutor } from '../../tools/compose-executor.js';
 import type { ToolPermissionConfig } from '../../tools/permissions.js';
 import type { ToolDispatcher } from './tool-dispatcher.js';
+import type { FastModeController } from '../../fast-mode.js';
 export type AnthropicClientFactory = (opts: ({
     authToken: string;
 } | {
@@ -18,6 +19,7 @@ export type AnthropicClientFactory = (opts: ({
 export declare function __setAnthropicClientFactory(factory: AnthropicClientFactory | null): void;
 export declare function getClientFactory(): AnthropicClientFactory | null;
 export interface AnthropicDirectProviderOptions {
+    fastModeController?: FastModeController;
     tools?: ToolDispatcher;
     hookRegistry?: HookRegistry;
     permissions?: ToolPermissionConfig;

package/dist/agent/providers/anthropic-direct/provider-query-build.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderQuery, ProviderQueryArgs } from '../../provider.js';
+import type { ProviderQueryContext } from './provider-context.js';
+import type { QuerySetupResult } from './provider-query-setup.js';
+export declare function buildProviderQuery(ctx: ProviderQueryContext, args: ProviderQueryArgs, setup: QuerySetupResult): ProviderQuery;

package/dist/agent/providers/anthropic-direct/provider-query-setup.d.ts

@@ -0,0 +1,26 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AgentConfig } from '../../types/config-types.js';
+import type { ProviderQueryArgs } from '../../provider.js';
+import { setUpQueryClient } from './query/client-setup.js';
+import { wireQueryDispatcher } from './query/dispatcher-wiring.js';
+import { assembleQueryPrompt } from './query/prompt-assembly.js';
+import type { ProviderQueryContext } from './provider-context.js';
+export interface QuerySetupResult {
+    client: Anthropic;
+    authMode: import('./types.js').AuthMode;
+    localMode: boolean;
+    model: string;
+    maxTokens: number;
+    cwd: string;
+    systemPrefix: Awaited<ReturnType<typeof setUpQueryClient>>['systemPrefix'];
+    throttleQueue: ReturnType<typeof setUpQueryClient>['throttleQueue'];
+    tokenRefresher: ReturnType<typeof setUpQueryClient>['tokenRefresher'];
+    queryDispatcher: ReturnType<typeof wireQueryDispatcher>['queryDispatcher'];
+    runtimeStateSource: ReturnType<typeof wireQueryDispatcher>['runtimeStateSource'];
+    toolDefs: ReturnType<typeof wireQueryDispatcher>['toolDefs'];
+    resolvedSessionId: ReturnType<typeof wireQueryDispatcher>['resolvedSessionId'];
+    stableSystemPrefix: ReturnType<typeof assembleQueryPrompt>['stableSystemPrefix'];
+    toolSystemAppend: ReturnType<typeof assembleQueryPrompt>['toolSystemAppend'];
+}
+export declare function resolveUserSystem(sp: AgentConfig['systemPrompt']): string | null;
+export declare function setUpQuerySession(ctx: ProviderQueryContext, args: ProviderQueryArgs, providerName: string, defaultModel: string): QuerySetupResult;

package/dist/agent/providers/anthropic-direct/provider-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
+export { resolveEffort, resolveMaxTokens, resolveThinkingParam } from './resolve-params.js';
+import { type AnthropicDirectProviderOptions } from './provider-options.js';
+export { __setAnthropicClientFactory, type AnthropicClientFactory, type AnthropicDirectProviderOptions, } from './provider-options.js';
+export { resolveUserSystem } from './provider-query-setup.js';
+export declare class AnthropicDirectProvider implements ModelProvider {
+    readonly name = "anthropic-direct";
+    private readonly externalTools;
+    private readonly memoryStore;
+    private readonly providerFactory?;
+    private readonly skillExecutor?;
+    private readonly schemas;
+    private readonly hookRegistry;
+    private readonly permissions;
+    private readonly canUseTool;
+    private readonly subagentExecutor;
+    private readonly composeExecutor;
+    private readonly surface;
+    private readonly declaredSurface;
+    private readonly readOnlyMemory;
+    private readonly readOnlyBash;
+    private readonly mcpManager;
+    private readonly customTools;
+    private readonly fastModeController?;
+    private readonly grants;
+    private _mcpToolsCache;
+    private _mcpHandlersCache;
+    private _presenceSessionId;
+    private _mintedSessionId;
+    constructor(opts?: AnthropicDirectProviderOptions);
+    private buildDispatcher;
+    close(): void;
+    complete(args: ProviderCompleteArgs): Promise<string>;
+    addReadRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    addWriteRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    revokeRoot(absPath: string, source?: 'slash' | 'tool', sessionId?: string): void;
+    getGrants(): {
+        resolveBase: string | undefined;
+        readRoots: string[];
+        writeRoots: string[];
+        allowAll: boolean;
+    };
+    private queryContext;
+    query(args: ProviderQueryArgs): ProviderQuery;
+}
+export declare const anthropicDirectProvider: ModelProvider;

package/dist/agent/providers/anthropic-direct/provider-schemas.d.ts

@@ -0,0 +1,3 @@
+import type { AnthropicDirectProviderOptions } from './provider-options.js';
+import type { AnthropicToolDef } from '../../tools/types.js';
+export declare function buildProviderSchemas(opts: AnthropicDirectProviderOptions): AnthropicToolDef[];

package/dist/agent/providers/anthropic-direct/query/auth-retry-tier.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext } from './retry-context.js';
+export declare function isRetryableAuth(ctx: RetryTierContext, error: Error): boolean;
+export declare function turnWithAuthRetry(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/providers/anthropic-direct/query/overload-pause-tier.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext, TierGenerator } from './retry-context.js';
+export declare function turnWithOverloadPause(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/providers/anthropic-direct/query/retry-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const TWO_HOURS_MS: number;
+export declare const RATE_LIMIT_TRANSIENT_MAX_RETRIES = 3;
+export declare const RATE_LIMIT_RETRY_MAX_WAIT_MS = 120000;
+export declare const RATE_LIMIT_RETRY_DEFAULT_WAIT_MS = 5000;
+export declare const RATE_LIMIT_RETRY_JITTER_MS = 1000;
+export declare const NO_TS_RETRY_INTERVAL_MS: number;

package/dist/agent/providers/anthropic-direct/query/retry-context.d.ts

@@ -0,0 +1,20 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { ProviderEvent } from '../../../provider.js';
+import type { AuthMode, RunTurnInput } from '../types.js';
+export type UsageLimitWaitResult = 'aborted' | 'timer' | 'hot-swap';
+export type TierGenerator = (ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean) => AsyncGenerator<ProviderEvent, void, void>;
+export interface RetryTierContext {
+    readonly authMode: AuthMode;
+    readonly surface: string | undefined;
+    readonly autoResumeOnUsageLimit: boolean;
+    readonly tokenRefresher: (() => Promise<Anthropic | null>) | undefined;
+    getClient(): Anthropic;
+    rotateHeaders(runInput: Pick<RunTurnInput, 'effort' | 'fastMode'>): Record<string, string>;
+    forceClientRefresh(): Promise<{
+        accountId: string;
+        swapped: boolean;
+    } | null>;
+    getUsageLimitWait(): Promise<UsageLimitWaitResult> | null;
+    setUsageLimitWait(p: Promise<UsageLimitWaitResult> | null): void;
+    markCredentialSnapshotStale(): void;
+}

package/dist/agent/providers/anthropic-direct/query/retry-layer.d.ts

@@ -1,9 +1,8 @@
 import type Anthropic from '@anthropic-ai/sdk';
 import type { ProviderEvent } from '../../../provider.js';
 import type { AuthMode, RunTurnInput } from '../types.js';
-export declare const TWO_HOURS_MS: number;
-export declare const RATE_LIMIT_TRANSIENT_MAX_RETRIES = 3;
-export declare const RATE_LIMIT_RETRY_MAX_WAIT_MS = 120000;
+export { TWO_HOURS_MS, RATE_LIMIT_TRANSIENT_MAX_RETRIES, RATE_LIMIT_RETRY_MAX_WAIT_MS, } from './retry-constants.js';
+export type { RetryTierContext, UsageLimitWaitResult } from './retry-context.js';
 export interface RetryLayerOptions {
     client: Anthropic;
     authMode: AuthMode;
@@ -26,15 +25,12 @@ export declare class RetryLayer {
     private credentialSnapshotStale;
     constructor(opts: RetryLayerOptions);
     get client(): Anthropic;
-    private rotateHeaders;
     get authMode(): AuthMode;
+    private rotateHeaders;
+    private tierContext;
     forceClientRefresh(): Promise<{
         accountId: string;
         swapped: boolean;
     } | null>;
     turnWithRetries(runInput: RunTurnInput, isClosed: () => boolean): AsyncGenerator<ProviderEvent, void, void>;
-    private turnWithOverloadPause;
-    private turnWithUsageLimitRetry;
-    private turnWithAuthRetry;
-    private isRetryableAuth;
 }

package/dist/agent/providers/anthropic-direct/query/turn-request.d.ts

@@ -0,0 +1,31 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { FastModeController, FastTurnDecision } from '../../../fast-mode.js';
+import type { AnthropicClientLike, AnthropicToolDef, RunTurnInput, ToolDispatcherLike } from '../types.js';
+export interface TurnRequestInput {
+    client: AnthropicClientLike;
+    messages: RunTurnInput['messages'];
+    system: ContentBlockParam[] | string | null;
+    tools: AnthropicToolDef[] | null;
+    toolDispatcher: ToolDispatcherLike;
+    model: string;
+    maxTokens: number;
+    signal: AbortSignal;
+    authMode: import('../types.js').AuthMode;
+    sessionId: string;
+    requestId: string;
+    fastModeController?: FastModeController;
+    baseUrl?: string;
+    thinking?: RunTurnInput['thinking'];
+    effort?: RunTurnInput['effort'];
+    maxToolUseIterations?: number;
+    traceWriter?: RunTurnInput['traceWriter'];
+    subagentId?: string;
+    throttleQueue?: RunTurnInput['throttleQueue'];
+    onUsageProgress?: RunTurnInput['onUsageProgress'];
+}
+export declare function prepareTurnRequest(input: TurnRequestInput): {
+    decision: FastTurnDecision | undefined;
+    runInput: RunTurnInput;
+};
+export declare const FAST_ERROR_PREFIX = "[Fast mode requested; no standard-mode fallback will be attempted]";
+export declare function annotateFastError(error: unknown, fast: boolean): Error;

package/dist/agent/providers/anthropic-direct/query/usage-limit-pause.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext, TierGenerator } from './retry-context.js';
+export declare function usageLimitNoTimestampPause(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator, pendingErrorEvent: ProviderEvent): AsyncGenerator<ProviderEvent, void, void>;
+export declare function usageLimitResetPause(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator, pendingErrorEvent: ProviderEvent, resetsAt: Date): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/providers/anthropic-direct/query/usage-limit-tier.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderEvent } from '../../../provider.js';
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext, TierGenerator } from './retry-context.js';
+export declare function turnWithUsageLimitRetry(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/providers/anthropic-direct/query-capabilities.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderAccountInfo, ProviderContextUsage, ProviderMcpServerStatus } from '../../provider.js';
+import type { SessionState } from './query/session-state.js';
+import type { AuthMode } from './types.js';
+export declare function computeContextUsage(state: SessionState): ProviderContextUsage;
+export declare function mcpServerStatusList(mcpManager: import('../../mcp/index.js').McpManager | undefined): ProviderMcpServerStatus[];
+export declare function accountInfoFor(authMode: AuthMode): ProviderAccountInfo;

package/dist/agent/providers/anthropic-direct/query-events.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderEvent } from '../../provider.js';
+export declare function interruptedTurnCompletedEvent(sessionId: string): ProviderEvent;

package/dist/agent/providers/anthropic-direct/query-live-updates.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDispatcher } from './tool-dispatcher.js';
+import type { SessionState } from './query/session-state.js';
+export declare function setLiveModel(state: SessionState, model?: string): void;
+export declare function setLivePermissionMode(options: {
+    state: SessionState;
+    mode: string;
+    onPermissionMode?: (mode: string) => void;
+}): void;
+export declare function setLiveCwd(options: {
+    state: SessionState;
+    cwd: string;
+    cwdDependentsFactory?: (cwd: string) => {
+        userSystem: string;
+        dispatcher: ToolDispatcher;
+    };
+}): void;
+export declare function setLiveSystemPrompt(options: {
+    state: SessionState;
+    basePrompt: string | undefined;
+    systemPromptRebuildFactory?: (basePrompt: string | undefined) => string;
+}): boolean;

package/dist/agent/providers/anthropic-direct/query-maintenance.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderCompactResult, ProviderRewindConversationResult, RewindTarget } from '../../provider.js';
+import type { AbortCoordinator } from '../shared/abort-coordinator.js';
+import type { RetryLayer } from './query/retry-layer.js';
+import type { SessionState } from './query/session-state.js';
+export declare function compactQueryHistory(options: {
+    state: SessionState;
+    abort: AbortCoordinator;
+    retry: RetryLayer;
+    initSessionId: string;
+    traceWriter?: import('../../trace/index.js').TraceWriter;
+}): Promise<ProviderCompactResult>;
+export declare function queryRewindTargets(state: SessionState): RewindTarget[];
+export declare function rewindQueryConversation(state: SessionState, abort: AbortCoordinator, turnIndex: number): ProviderRewindConversationResult;

package/dist/agent/providers/anthropic-direct/query-options.d.ts

@@ -0,0 +1,42 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { ContentBlockParam, MessageParam } from '@anthropic-ai/sdk/resources';
+import type { ProviderModelInfo, ProviderUserTurn } from '../../provider.js';
+import type { ToolDispatcher } from './tool-dispatcher.js';
+import type { AnthropicToolDef, AuthMode } from './types.js';
+import type { HookRegistry } from '../../hooks.js';
+export interface AnthropicDirectQueryOptions {
+    client: Anthropic;
+    authMode: AuthMode;
+    promptStream: AsyncIterable<ProviderUserTurn>;
+    toolDispatcher: ToolDispatcher;
+    sessionId?: string;
+    initialMessages?: MessageParam[];
+    model: string;
+    requestedModel?: string;
+    permissionMode?: string;
+    maxTokens: number;
+    tools: AnthropicToolDef[] | null;
+    userSystem: string | null;
+    systemPrefix: ContentBlockParam[] | null;
+    tokenRefresher?: () => Promise<Anthropic | null>;
+    thinking?: import('@anthropic-ai/sdk/resources').ThinkingConfigParam;
+    effort?: import('../../types/sdk-types.js').EffortLevel;
+    baseUrl?: string;
+    maxToolUseIterations?: number;
+    traceWriter?: import('../../trace/index.js').TraceWriter;
+    subagentId?: string;
+    autoResumeOnUsageLimit?: boolean;
+    surface?: string;
+    cwdDependentsFactory?: (cwd: string) => {
+        userSystem: string;
+        dispatcher: ToolDispatcher;
+    };
+    systemPromptRebuildFactory?: (basePrompt: string | undefined) => string;
+    onPermissionMode?: (mode: string) => void;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    autoCompactThreshold?: number;
+    hookRegistry?: HookRegistry;
+    throttleQueue?: import('./throttle-queue.js').ThrottleQueue;
+    fastModeController?: import('../../fast-mode.js').FastModeController;
+}
+export declare function starterModels(): ProviderModelInfo[];

package/dist/agent/providers/anthropic-direct/query-runtime.d.ts

@@ -0,0 +1,53 @@
+import type { ProviderAccountInfo, ProviderAgentInfo, ProviderCommandInfo, ProviderCompactResult, ProviderContextUsage, ProviderEvent, ProviderMcpServerStatus, ProviderModelInfo, ProviderQuery, ProviderRewindConversationResult, ProviderRewindResult, RewindTarget } from '../../provider.js';
+import type { AnthropicDirectQueryOptions } from './query-options.js';
+export type { AnthropicDirectQueryOptions } from './query-options.js';
+export declare class AnthropicDirectQuery implements ProviderQuery {
+    private readonly initSessionId;
+    private readonly promptStream;
+    private readonly maxTokens;
+    private readonly tools;
+    private readonly systemPrefix;
+    private readonly thinking?;
+    private readonly effort?;
+    private readonly baseUrl?;
+    private readonly maxToolUseIterations?;
+    private readonly traceWriter?;
+    private readonly subagentId?;
+    private readonly state;
+    private readonly abort;
+    private readonly retry;
+    private readonly cwdDependentsFactory?;
+    private readonly systemPromptRebuildFactory?;
+    private readonly onPermissionMode?;
+    private readonly mcpManager?;
+    private readonly hookRegistry?;
+    private readonly throttleQueue?;
+    private readonly fastModeController?;
+    constructor(opts: AnthropicDirectQueryOptions);
+    private turnDriverContext;
+    [Symbol.asyncIterator](): AsyncIterator<ProviderEvent>;
+    private composeSystem;
+    interrupt(reason?: import('../../abort-reason.js').ProviderAbortReason): Promise<void>;
+    private makeInterruptedTurnEvent;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: string): Promise<void>;
+    setCwd(cwd: string): void;
+    setSystemPrompt(basePrompt: string | undefined): boolean;
+    supportedCommands(): Promise<ProviderCommandInfo[]>;
+    supportedModels(): Promise<ProviderModelInfo[]>;
+    supportedAgents(): Promise<ProviderAgentInfo[]>;
+    getContextUsage(): Promise<ProviderContextUsage>;
+    mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
+    accountInfo(): Promise<ProviderAccountInfo>;
+    reauth(): Promise<{
+        accountId: string;
+        swapped: boolean;
+    } | null>;
+    rewindFiles(_userMessageId: string, _options?: {
+        dryRun?: boolean;
+    }): Promise<ProviderRewindResult>;
+    compact(): Promise<ProviderCompactResult>;
+    listRewindTargets(): RewindTarget[];
+    rewindConversation(turnIndex: number): Promise<ProviderRewindConversationResult>;
+    close(): void;
+}

package/dist/agent/providers/anthropic-direct/query-system.d.ts

@@ -0,0 +1,7 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { SessionState } from './query/session-state.js';
+export declare function composeQuerySystem(options: {
+    state: SessionState;
+    systemPrefix: ContentBlockParam[] | null;
+    baseUrl?: string;
+}): ContentBlockParam[] | null;

package/dist/agent/providers/anthropic-direct/query-turn-driver.d.ts

@@ -0,0 +1,30 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { ProviderCompactResult, ProviderEvent, ProviderUserTurn } from '../../provider.js';
+import type { AnthropicToolDef } from './types.js';
+import type { SessionState } from './query/session-state.js';
+import type { AbortCoordinator } from '../shared/abort-coordinator.js';
+import type { RetryLayer } from './query/retry-layer.js';
+import type { HookRegistry } from '../../hooks.js';
+export interface TurnDriverContext {
+    readonly initSessionId: string;
+    readonly promptStream: AsyncIterable<ProviderUserTurn>;
+    readonly state: SessionState;
+    readonly abort: AbortCoordinator;
+    readonly retry: RetryLayer;
+    readonly maxTokens: number;
+    readonly tools: AnthropicToolDef[] | null;
+    readonly thinking: import('@anthropic-ai/sdk/resources').ThinkingConfigParam | undefined;
+    readonly effort: import('../../types/sdk-types.js').EffortLevel | undefined;
+    readonly baseUrl: string | undefined;
+    readonly maxToolUseIterations: number | undefined;
+    readonly traceWriter: import('../../trace/index.js').TraceWriter | undefined;
+    readonly subagentId: string | undefined;
+    readonly mcpManager: import('../../mcp/index.js').McpManager | undefined;
+    readonly hookRegistry: HookRegistry | undefined;
+    readonly throttleQueue: import('./throttle-queue.js').ThrottleQueue | undefined;
+    readonly fastModeController: import('../../fast-mode.js').FastModeController | undefined;
+    composeSystem(): ContentBlockParam[] | null;
+    makeInterruptedTurnEvent(): ProviderEvent;
+    compact(): Promise<ProviderCompactResult>;
+}
+export declare function driveTurns(ctx: TurnDriverContext): AsyncGenerator<ProviderEvent, void, void>;