agent-afk 5.1.0 → 5.2.0

package/dist/agent/provider.d.ts

@@ -0,0 +1,212 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { AgentConfig } from './types/config-types.js';
+export interface ProviderSessionInfo {
+    sessionId: string;
+    model?: string;
+    permissionMode?: string;
+    cwd?: string;
+    tools?: string[];
+    slashCommands?: string[];
+    skills?: string[];
+    plugins?: Array<{
+        name: string;
+        path: string;
+    }>;
+    mcpServers?: Array<{
+        name: string;
+        status: string;
+    }>;
+    apiKeySource?: string;
+    version?: string;
+    outputStyle?: string;
+}
+export interface ProviderUsage {
+    inputTokens?: number;
+    cachedInputTokens?: number;
+    cacheCreationTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    contextWindowTokens?: number;
+    totalCostUsd?: number;
+    stopReason?: string | null;
+    durationMs?: number;
+    durationApiMs?: number;
+    isError?: boolean;
+    resultSubtype?: string;
+    modelUsage?: Record<string, unknown>;
+    permissionDenials?: unknown[];
+    errors?: string[];
+    raw?: Record<string, unknown>;
+}
+export interface ProviderProgress {
+    taskId: string;
+    description: string;
+    summary?: string;
+    lastToolName?: string;
+    totalTokens: number;
+    toolUses: number;
+    durationMs: number;
+}
+export type ProviderEvent = {
+    type: 'session.init';
+    info: ProviderSessionInfo;
+} | {
+    type: 'session.status';
+    sessionId: string;
+    status?: string | null;
+    permissionMode?: string;
+} | {
+    type: 'delta.text';
+    text: string;
+    sessionId?: string;
+} | {
+    type: 'delta.reasoning';
+    text: string;
+    sessionId?: string;
+} | {
+    type: 'assistant.message';
+    text: string;
+    sessionId?: string;
+} | {
+    type: 'tool.use.start';
+    toolUseId: string;
+    toolName: string;
+    toolInput: string;
+    toolInputRaw?: string;
+    sessionId?: string;
+} | {
+    type: 'tool.use';
+    summary: string;
+    toolUseIds?: string[];
+    sessionId?: string;
+} | {
+    type: 'tool.output';
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+    truncated?: boolean;
+    sessionId?: string;
+    toolName?: string;
+} | {
+    type: 'tool.diff';
+    toolUseId: string;
+    diff: import('../utils/diff.js').DiffPayload;
+    sessionId?: string;
+} | {
+    type: 'turn.completed';
+    usage: ProviderUsage;
+    sessionId?: string;
+} | {
+    type: 'progress';
+    progress: ProviderProgress;
+    sessionId?: string;
+} | {
+    type: 'suggestion';
+    suggestion: string;
+    sessionId?: string;
+} | {
+    type: 'stream.retry';
+    sessionId?: string;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'paused';
+    reason: 'usage-limit';
+    resetsAt?: Date;
+    accountId?: string;
+    autoResume?: boolean;
+} | {
+    type: 'resumed';
+    hotSwapped: boolean;
+    accountId?: string;
+};
+export interface ProviderUserTurn {
+    content: string | ContentBlockParam[];
+    sessionId?: string;
+}
+export interface ProviderQueryArgs {
+    prompt: AsyncIterable<ProviderUserTurn>;
+    config: AgentConfig;
+}
+export interface ProviderQuery extends AsyncIterable<ProviderEvent> {
+    interrupt(): Promise<void>;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: string): Promise<void>;
+    supportedCommands(): Promise<ProviderCommandInfo[]>;
+    supportedModels(): Promise<ProviderModelInfo[]>;
+    supportedAgents(): Promise<ProviderAgentInfo[]>;
+    getContextUsage(): Promise<ProviderContextUsage>;
+    mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
+    accountInfo(): Promise<ProviderAccountInfo>;
+    rewindFiles(userMessageId: string, options?: {
+        dryRun?: boolean;
+    }): Promise<ProviderRewindResult>;
+    compact?(): Promise<ProviderCompactResult>;
+    setCwd?(cwd: string): void;
+    reauth?(): Promise<{
+        accountId: string;
+        swapped: boolean;
+    } | null>;
+    close(): void | Promise<void>;
+}
+export interface ProviderCommandInfo {
+    name: string;
+    description?: string;
+    argumentHint?: string;
+}
+export interface ProviderModelInfo {
+    value: string;
+    displayName?: string;
+    description?: string;
+}
+export interface ProviderAgentInfo {
+    name: string;
+    description?: string;
+}
+export interface ProviderContextUsage {
+    tools?: unknown[];
+    agents?: unknown[];
+    isAutoCompactEnabled?: boolean;
+    apiUsage?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+export interface ProviderMcpServerStatus {
+    name: string;
+    status: string;
+}
+export interface ProviderAccountInfo {
+    email?: string;
+    organization?: string;
+    subscriptionType?: string;
+    [key: string]: unknown;
+}
+export interface ProviderRewindResult {
+    canRewind: boolean;
+    error?: string;
+    filesChanged?: string[];
+    insertions?: number;
+    deletions?: number;
+}
+export interface ProviderCompactResult {
+    compacted: boolean;
+    reason?: string;
+    messagesBefore: number;
+    messagesAfter: number;
+    tokensSavedEstimate?: number;
+}
+export interface ProviderCompleteArgs {
+    system: string;
+    user: string;
+    model?: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface ModelProvider {
+    readonly name: string;
+    query(args: ProviderQueryArgs): ProviderQuery;
+    complete?(args: ProviderCompleteArgs): Promise<string>;
+    close?(): void | Promise<void>;
+}

package/dist/agent/providers/anthropic-direct/afk-mode-addendum.d.ts

@@ -0,0 +1,3 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+export declare const AFK_MODE_ADDENDUM_TEXT: string;
+export declare function buildAfkModeAddendumBlock(mode: string | undefined): ContentBlockParam | null;

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

@@ -0,0 +1,16 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { AuthMode } from './types.js';
+export declare const OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,extended-cache-ttl-2025-04-11";
+export declare const EFFORT_BETA_HEADER = "effort-2025-11-24";
+export declare const CLI_USER_AGENT = "claude-cli/1.0.0 (external, cli)";
+export declare const BILLING_HEADER_TEXT = "x-anthropic-billing-header: cc_version=1.0.0.test; cc_entrypoint=cli; cch=00000;";
+export declare function detectAuthMode(token: string): AuthMode;
+export declare function buildClientOptions(token: string, mode: AuthMode, baseUrl?: string): ({
+    authToken: string;
+} | {
+    apiKey: string;
+}) & {
+    baseURL?: string;
+};
+export declare function buildRequestHeaders(mode: AuthMode, sessionId: string, requestId: string, withEffort?: boolean): Record<string, string>;
+export declare function buildSystemPrefix(mode: AuthMode): ContentBlockParam[] | null;

package/dist/agent/providers/anthropic-direct/cache-policy.d.ts

@@ -0,0 +1,7 @@
+import type { ContentBlockParam, MessageParam } from '@anthropic-ai/sdk/resources';
+export declare function isCacheEnabled(opts?: {
+    baseUrl?: string;
+}): boolean;
+export declare function getCacheTtl(): '5m' | '1h';
+export declare function withSystemBreakpoint(blocks: ContentBlockParam[], ttl: '5m' | '1h'): ContentBlockParam[];
+export declare function withMessagesBreakpoint(messages: MessageParam[], ttl: '5m' | '1h'): MessageParam[];

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

@@ -0,0 +1,10 @@
+import type { MessageParam } from '@anthropic-ai/sdk/resources';
+import type { AnthropicMessagesCreateParams } from './types.js';
+export declare const COMPACT_SYSTEM_PROMPT: string;
+export declare const COMPACT_SUMMARY_HEADER = "[Compacted summary of earlier conversation]";
+export declare const COMPACT_ACK_TEXT = "Acknowledged. Continuing from the summary above.";
+export declare function isFreshUserTurn(msg: MessageParam): boolean;
+export declare function findCompactionBoundary(messages: ReadonlyArray<MessageParam>, keepLastN: number): number;
+export declare function buildSummarizationRequest(olderMessages: ReadonlyArray<MessageParam>, model: string, maxTokens: number): AnthropicMessagesCreateParams;
+export declare function applyCompaction(messages: ReadonlyArray<MessageParam>, boundary: number, summaryText: string): MessageParam[];
+export declare function estimateTokensSaved(before: ReadonlyArray<MessageParam>, boundary: number, summaryText: string): number;

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

@@ -0,0 +1,75 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
+export { resolveEffort, resolveMaxTokens, resolveThinkingParam } from './resolve-params.js';
+import type { ToolDispatcher } from './tool-dispatcher.js';
+import { type ToolPermissionConfig } from '../../tools/permissions.js';
+import type { HookRegistry } from '../../hooks.js';
+import type { SubagentExecutor } from '../../tools/subagent-executor.js';
+import type { SkillExecutor } from '../../tools/skill-executor.js';
+import type { ComposeExecutor } from '../../tools/compose-executor.js';
+import { MemoryStore } from '../../memory/index.js';
+export type AnthropicClientFactory = (opts: ({
+    authToken: string;
+} | {
+    apiKey: string;
+}) & {
+    baseURL?: string;
+}) => Anthropic;
+export declare function __setAnthropicClientFactory(factory: AnthropicClientFactory | null): void;
+export interface AnthropicDirectProviderOptions {
+    tools?: ToolDispatcher;
+    hookRegistry?: HookRegistry;
+    permissions?: ToolPermissionConfig;
+    clientFactory?: AnthropicClientFactory;
+    subagentExecutor?: SubagentExecutor;
+    skillExecutor?: SkillExecutor;
+    composeExecutor?: ComposeExecutor;
+    memoryStore?: MemoryStore;
+    surface?: string;
+    readOnlyMemory?: boolean;
+    readOnlyBash?: boolean;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    customTools?: import('../../tools/custom-tool.js').CustomToolDef[];
+}
+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 subagentExecutor;
+    private readonly composeExecutor;
+    private readonly surface;
+    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;
+    constructor(opts?: AnthropicDirectProviderOptions);
+    private buildDispatcher;
+    close(): void;
+    complete(args: ProviderCompleteArgs): Promise<string>;
+    private ensureSharedRoots;
+    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 appendProviderAuditLog;
+    query(args: ProviderQueryArgs): ProviderQuery;
+}
+export declare const anthropicDirectProvider: ModelProvider;

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

@@ -0,0 +1,8 @@
+import type { ProviderEvent } from '../../provider.js';
+import type { AnthropicToolDef, RunTurnInput, WireToolDef } from './types.js';
+export declare const DEFAULT_MAX_TOOL_USE_ITERATIONS = 0;
+export declare function toWireTool(tool: AnthropicToolDef): WireToolDef;
+export declare const OVERLOAD_MAX_RETRIES = 3;
+export declare function isTransientServerError(err: Error): boolean;
+export declare function isOverloadedErrorEvent(err: unknown): boolean;
+export declare function runTurn(input: RunTurnInput): AsyncGenerator<ProviderEvent, void, void>;

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

@@ -0,0 +1,15 @@
+import Anthropic from '@anthropic-ai/sdk';
+export interface OneShotInput {
+    token: string;
+    model: string;
+    system: string;
+    user: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    clientFactory?: (opts: {
+        authToken: string;
+    } | {
+        apiKey: string;
+    }) => Anthropic;
+}
+export declare function oneShotCompletion(input: OneShotInput): Promise<string>;

package/dist/agent/providers/anthropic-direct/plan-mode-addendum.d.ts

@@ -0,0 +1,3 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+export declare const PLAN_MODE_ADDENDUM_TEXT: string;
+export declare function buildPlanModeAddendumBlock(mode: string | undefined): ContentBlockParam | null;

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

@@ -0,0 +1,15 @@
+export type AbortReason = 'interrupted' | 'closed';
+export declare const CLOSED_SENTINEL: "__closed__";
+export type ClosedSentinel = typeof CLOSED_SENTINEL;
+export declare class AbortCoordinator {
+    private current;
+    private pendingReason;
+    readonly closedPromise: Promise<ClosedSentinel>;
+    private closeResolve;
+    constructor();
+    begin(): AbortController;
+    clear(controller: AbortController): void;
+    requestAbort(reason: AbortReason): void;
+    isIdle(): boolean;
+    markClosed(): void;
+}

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

@@ -0,0 +1,15 @@
+import type { ProviderUsage } from '../../../provider.js';
+export declare function computeUsedTokens(usage: Partial<ProviderUsage>): number;
+export declare function contextWindowTokensUsed(usage: Partial<ProviderUsage>): number;
+export type ContextUsageApiBreakdown = {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+    cache_creation_input_tokens: number;
+};
+export interface ContextUsageFields {
+    totalTokens: number;
+    apiUsage: ContextUsageApiBreakdown | null;
+}
+export declare function buildContextUsageFields(last: ProviderUsage | null | undefined): ContextUsageFields;
+export declare function shouldAutoCompact(usedTokens: number, contextLimit: number, threshold: number): boolean;

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

@@ -0,0 +1,12 @@
+import type { ProviderCompactResult } from '../../../provider.js';
+import type { SessionState } from './session-state.js';
+import type { AbortCoordinator } from './abort-coordinator.js';
+import type { RetryLayer } from './retry-layer.js';
+export interface CompactHandlerDeps {
+    state: SessionState;
+    abort: AbortCoordinator;
+    retry: RetryLayer;
+    initSessionId: string;
+    traceWriter?: import('../../../trace/index.js').TraceWriter;
+}
+export declare function compactHistory(deps: CompactHandlerDeps): Promise<ProviderCompactResult>;

package/dist/agent/providers/anthropic-direct/query/repair-orphan-tool-uses.d.ts

@@ -0,0 +1,2 @@
+import type { MessageParam } from '@anthropic-ai/sdk/resources';
+export declare function repairOrphanToolUses(messages: MessageParam[]): void;

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

@@ -0,0 +1,30 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { ProviderEvent } from '../../../provider.js';
+import type { AuthMode, RunTurnInput } from '../types.js';
+export interface RetryLayerOptions {
+    client: Anthropic;
+    authMode: AuthMode;
+    initSessionId: string;
+    tokenRefresher?: () => Promise<Anthropic | null>;
+    autoResumeOnUsageLimit: boolean;
+}
+export declare class RetryLayer {
+    private _client;
+    private readonly _authMode;
+    private readonly initSessionId;
+    private readonly tokenRefresher?;
+    private readonly autoResumeOnUsageLimit;
+    private refreshPromise;
+    private usageLimitWaitPromise;
+    constructor(opts: RetryLayerOptions);
+    get client(): Anthropic;
+    get authMode(): AuthMode;
+    forceClientRefresh(): Promise<{
+        accountId: string;
+        swapped: boolean;
+    } | null>;
+    turnWithRetries(runInput: RunTurnInput, isClosed: () => boolean): AsyncGenerator<ProviderEvent, void, void>;
+    private turnWithUsageLimitRetry;
+    private turnWithAuthRetry;
+    private isRetryableAuth;
+}

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

@@ -0,0 +1,23 @@
+import type { MessageParam } from '@anthropic-ai/sdk/resources';
+import type { ProviderUsage } from '../../../provider.js';
+import type { ToolDispatcher } from '../tool-dispatcher.js';
+export interface SessionState {
+    readonly messages: MessageParam[];
+    currentModel: string;
+    requestedModel: string;
+    currentPermissionMode: string;
+    userSystem: string | null;
+    toolDispatcher: ToolDispatcher;
+    lastUsage: ProviderUsage | null;
+    closed: boolean;
+    autoCompactThreshold: number | undefined;
+}
+export declare function createSessionState(opts: {
+    model: string;
+    requestedModel?: string;
+    permissionMode: string;
+    userSystem: string | null;
+    toolDispatcher: ToolDispatcher;
+    initialMessages?: MessageParam[];
+    autoCompactThreshold?: number;
+}): SessionState;

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

@@ -0,0 +1,73 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { ContentBlockParam, MessageParam } from '@anthropic-ai/sdk/resources';
+import type { ProviderAccountInfo, ProviderAgentInfo, ProviderCommandInfo, ProviderCompactResult, ProviderContextUsage, ProviderEvent, ProviderMcpServerStatus, ProviderModelInfo, ProviderQuery, ProviderRewindResult, ProviderUserTurn } from '../../provider.js';
+import type { ToolDispatcher } from './tool-dispatcher.js';
+import type { AnthropicToolDef, AuthMode } from './types.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;
+    traceWriter?: import('../../trace/index.js').TraceWriter;
+    autoResumeOnUsageLimit?: boolean;
+    cwdDependentsFactory?: (cwd: string) => {
+        userSystem: string;
+        dispatcher: ToolDispatcher;
+    };
+    onPermissionMode?: (mode: string) => void;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    autoCompactThreshold?: number;
+}
+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 traceWriter?;
+    private readonly state;
+    private readonly abort;
+    private readonly retry;
+    private readonly cwdDependentsFactory?;
+    private readonly onPermissionMode?;
+    private readonly mcpManager?;
+    constructor(opts: AnthropicDirectQueryOptions);
+    [Symbol.asyncIterator](): AsyncIterator<ProviderEvent>;
+    private composeSystem;
+    interrupt(): Promise<void>;
+    private makeInterruptedTurnEvent;
+    setModel(model?: string): Promise<void>;
+    setPermissionMode(mode: string): Promise<void>;
+    setCwd(cwd: string): void;
+    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>;
+    close(): void;
+}

package/dist/agent/providers/anthropic-direct/resolve-params.d.ts

@@ -0,0 +1,8 @@
+import type { MessageParam, ThinkingConfigParam } from '@anthropic-ai/sdk/resources';
+import type { AgentConfig, ResumeHistoryTurn } from '../../types/config-types.js';
+import type { EffortLevel, ThinkingConfig } from '../../types/sdk-types.js';
+export declare function resolveAutoCompactThreshold(autoCompact: AgentConfig['autoCompact']): number | undefined;
+export declare function resolveMaxTokens(config: AgentConfig, model: string): number;
+export declare function resumeHistoryToMessages(history: ResumeHistoryTurn[] | undefined): MessageParam[] | undefined;
+export declare function resolveThinkingParam(tc: ThinkingConfig, maxTokens: number, model?: string): ThinkingConfigParam;
+export declare function resolveEffort(callerEffort: EffortLevel | undefined, model: string): EffortLevel | undefined;

package/dist/agent/providers/anthropic-direct/tool-dispatcher.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCall, ToolResult, ToolDispatcherLike } from './types.js';
+export interface ToolDispatcher extends ToolDispatcherLike {
+}
+export declare class RejectAllToolDispatcher implements ToolDispatcher {
+    execute(call: ToolCall): Promise<ToolResult>;
+}
+export type { ToolCall, ToolResult } from './types.js';

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

@@ -0,0 +1,3 @@
+import type { RawMessageStreamEvent } from '@anthropic-ai/sdk/resources';
+import type { TranslateCtx, TranslateOutput } from './types.js';
+export declare function translateMessageStream(events: AsyncIterable<RawMessageStreamEvent>, ctx: TranslateCtx): AsyncIterable<TranslateOutput>;