agent-afk 5.1.0 → 5.2.0

package/dist/agent/subagent/wave.d.ts

@@ -0,0 +1,11 @@
+import type { SubagentHandle } from './handle.js';
+import type { SubagentResult } from './result.js';
+export interface WaveTask<T = unknown> {
+    handle: SubagentHandle<T>;
+    prompt: string;
+}
+export interface RunWaveOptions {
+    failFast?: boolean;
+    teardown?: boolean;
+}
+export declare function runWave<T = unknown>(tasks: ReadonlyArray<WaveTask<T>>, options?: RunWaveOptions): Promise<SubagentResult<T>[]>;

package/dist/agent/subagent-hooks.d.ts

@@ -0,0 +1,12 @@
+import type { HookDecision, HookRegistry, PostToolUseContext, PostToolUseFailureContext, PreToolUseContext, SubagentStartContext, SubagentStopContext } from './hooks.js';
+import type { TraceWriter } from './trace/index.js';
+export interface SubagentHookDispatchOptions {
+    signal?: AbortSignal;
+    onError?: (err: Error) => void;
+    traceWriter?: TraceWriter;
+}
+export declare function dispatchSubagentStart(registry: HookRegistry | undefined, context: SubagentStartContext, options?: SubagentHookDispatchOptions): Promise<void>;
+export declare function dispatchSubagentStop(registry: HookRegistry | undefined, context: SubagentStopContext, options?: SubagentHookDispatchOptions): Promise<HookDecision>;
+export declare function dispatchPreToolUse(registry: HookRegistry | undefined, context: PreToolUseContext, options?: SubagentHookDispatchOptions): Promise<void>;
+export declare function dispatchPostToolUse(registry: HookRegistry | undefined, context: PostToolUseContext, options?: SubagentHookDispatchOptions): Promise<void>;
+export declare function dispatchPostToolUseFailure(registry: HookRegistry | undefined, context: PostToolUseFailureContext, options?: SubagentHookDispatchOptions): Promise<void>;

package/dist/agent/subagent.d.ts

@@ -0,0 +1,66 @@
+import type { CanUseTool } from './types/sdk-types.js';
+import type { ZodType } from 'zod';
+import { type ChildAbortedListener } from './abort-graph.js';
+import type { HookRegistry } from './hooks.js';
+import type { AgentConfig, IAgentSession } from './types.js';
+import type { SubagentProgressSink } from './types/session-types.js';
+import type { AbortOrigin, TraceWriter } from './trace/index.js';
+import type { Surface } from './awareness/types.js';
+import { type PhaseRole } from './tools/nesting.js';
+import { type SubagentHandle } from './subagent/handle.js';
+import type { SubagentStatus, SubagentResult, SubagentTrace } from './subagent/result.js';
+export type { SubagentStatus, SubagentResult, SubagentTrace, SubagentHandle };
+export declare const DENY_ELICITATION: NonNullable<AgentConfig['onElicitation']>;
+export interface ForkParent {
+    sessionId?: string;
+    id?: string;
+}
+export interface ForkSubagentOptions<T = unknown> {
+    parent: Pick<IAgentSession, 'sessionId'> & Partial<Pick<IAgentSession, 'getInputStreamRef' | 'abortSignal' | 'hookRegistry'>>;
+    config: AgentConfig;
+    idPrefix?: string;
+    outputSchema?: ZodType<T>;
+    agentType?: string;
+    parentId?: string;
+    denyElicitations?: boolean;
+    phaseRole?: PhaseRole;
+}
+export interface SubagentManagerOptions {
+    canUseTool?: CanUseTool;
+    parentAbortSignal?: AbortSignal;
+    hookRegistry?: HookRegistry;
+    progressSink?: SubagentProgressSink;
+    apiKey?: string;
+    baseUrl?: string;
+    cwd?: string;
+    traceWriter?: TraceWriter;
+    surface?: Surface;
+    onSubagentSucceeded?: (usage: import('./subagent/result.js').SubagentTrace['usage'], costUsd: number | undefined) => void;
+}
+export declare class SubagentManager {
+    private readonly active;
+    private readonly parentCanUseTool;
+    private readonly hookRegistry;
+    private readonly progressSink;
+    private readonly parentApiKey;
+    private readonly parentBaseUrl;
+    private parentCwd;
+    private readonly parentTraceWriter;
+    private readonly parentSurface;
+    private readonly abortGraph;
+    private readonly rootId;
+    private readonly rootController;
+    private counter;
+    private onSubagentSucceededCb;
+    constructor(options?: SubagentManagerOptions);
+    list(): Array<Pick<SubagentHandle, 'id' | 'status'>>;
+    get(id: string): SubagentHandle | undefined;
+    onChildAborted(listener: ChildAbortedListener): () => void;
+    setOnSubagentSucceeded(cb: (usage: import('./subagent/result.js').SubagentTrace['usage'], costUsd: number | undefined) => void): void;
+    setCwd(cwd: string): void;
+    abortAll(reason?: unknown, origin?: AbortOrigin): void;
+    forkSubagent<T = unknown>(options: ForkSubagentOptions<T>): Promise<SubagentHandle<T>>;
+    kill(id: string): Promise<boolean>;
+    killAll(): Promise<void>;
+    teardownAll(): Promise<void>;
+}

package/dist/agent/timeout.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_SESSION_TIMEOUT_MS = 0;
+export declare const RESET_DRAIN_TIMEOUT_MS = 5000;
+export interface WithTimeoutOptions {
+    controller?: AbortController;
+    label?: string;
+}
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, options?: WithTimeoutOptions): Promise<T>;

package/dist/agent/tool-category.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCategory } from './providers/anthropic-direct/types.js';
+export type { ToolCategory };
+export declare const SUBAGENT_TOOLS: Set<string>;
+export declare const SKILL_TOOLS: Set<string>;
+export declare const DAG_TOOLS: Set<string>;
+export declare const NESTING_TOOLS: Set<string>;
+export declare const READ_ONLY_PHASE_TOOLS: readonly string[];
+export declare function categorizeTool(name: string): ToolCategory;
+export declare function dispatchTagForCategory(cat: ToolCategory): string | undefined;

package/dist/agent/tools/child-credential.d.ts

@@ -0,0 +1,6 @@
+export declare function isAnthropicCredential(key: string | undefined): key is string;
+export declare function applyParentCredentialFallback(args: {
+    childModel: string;
+    resolved: string | undefined;
+    parentApiKey: string | undefined;
+}): string | undefined;

package/dist/agent/tools/compose-executor.d.ts

@@ -0,0 +1,29 @@
+import type { AgentModelInput, IAgentSession } from '../types.js';
+import type { Surface } from '../awareness/types.js';
+import type { ToolCall, ToolResult } from './types.js';
+export interface ComposeExecutorContext {
+    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'>;
+    defaultModel?: AgentModelInput;
+    defaultSubagentModel?: AgentModelInput;
+    apiKey?: string;
+    resolveApiKeyForModel?: (model: string) => string | undefined;
+    baseUrl?: string;
+    systemPrompt: string;
+    cwd?: string;
+    surface?: Surface;
+    depth?: number;
+}
+export interface TruncationEvent {
+    nodeId: string;
+    emittedChars: number;
+    totalChars: number;
+    spillPath?: string;
+}
+export declare function cleanupComposeSpills(sessionId: string): void;
+export declare class ComposeExecutor {
+    private readonly ctx;
+    private currentCwd;
+    constructor(ctx: ComposeExecutorContext);
+    setCwd(cwd: string): void;
+    execute(call: ToolCall): Promise<ToolResult>;
+}

package/dist/agent/tools/custom-tool.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { AnthropicToolDef, ToolHandler, ToolHandlerContext } from './types.js';
+export interface CustomToolDef {
+    schema: AnthropicToolDef;
+    handler: ToolHandler;
+}
+export declare function tool<S extends z.ZodType>(name: string, description: string, schema: S, handler: (input: z.infer<S>, signal: AbortSignal, context?: ToolHandlerContext) => ReturnType<ToolHandler>): CustomToolDef;

package/dist/agent/tools/dispatcher.d.ts

@@ -0,0 +1,75 @@
+import type { HookRegistry } from '../hooks.js';
+import type { AnthropicToolDef } from '../providers/anthropic-direct/types.js';
+import type { ToolDispatcher } from '../providers/anthropic-direct/tool-dispatcher.js';
+import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
+import type { SubagentExecutor } from './subagent-executor.js';
+import type { SkillExecutor } from './skill-executor.js';
+import type { ComposeExecutor } from './compose-executor.js';
+import type { ToolHandler, ConcurrencyClassifier } from './types.js';
+import { type ToolPermissionConfig } from './permissions.js';
+import type { TraceWriter } from '../trace/index.js';
+export declare function defaultConcurrencyClassifier(toolName: string): boolean;
+export declare const REPEAT_CIRCUIT_BREAKER_THRESHOLD = 8;
+export interface SessionToolDispatcherOptions {
+    handlers: Map<string, ToolHandler>;
+    schemas: AnthropicToolDef[];
+    hookRegistry: HookRegistry | undefined;
+    permissions?: ToolPermissionConfig;
+    subagentExecutor?: SubagentExecutor;
+    skillExecutor?: SkillExecutor;
+    composeExecutor?: ComposeExecutor;
+    concurrencyClassifier?: ConcurrencyClassifier;
+    cwd?: string;
+    readRoots?: string[];
+    writeRoots?: string[];
+    allowAll?: boolean;
+    env?: Record<string, string>;
+    sessionId?: string;
+    parentSessionId?: string;
+    traceWriter?: TraceWriter;
+    readOnlyBash?: boolean;
+}
+export declare class SessionToolDispatcher implements ToolDispatcher {
+    private readonly handlers;
+    private readonly schemas;
+    private readonly hookRegistry;
+    private readonly permissions;
+    private readonly subagentExecutor;
+    private readonly skillExecutor;
+    private readonly composeExecutor;
+    private readonly classifier;
+    private resolveBase;
+    private readonly _readRoots;
+    private readonly _writeRoots;
+    private _allowAll;
+    private readonly _env;
+    private readonly sessionId;
+    private readonly parentSessionId;
+    private readonly traceWriter;
+    private readonly readOnlyBash;
+    private repeatBreaker;
+    constructor(opts: SessionToolDispatcherOptions);
+    private get handlerContext();
+    private callHandlerContext;
+    addReadRoot(absPath: string, source?: 'slash' | 'tool'): void;
+    addWriteRoot(absPath: string, source?: 'slash' | 'tool'): void;
+    revokeRoot(absPath: string, source?: 'slash' | 'tool'): void;
+    getGrants(): {
+        resolveBase: string | undefined;
+        readRoots: string[];
+        writeRoots: string[];
+        allowAll: boolean;
+    };
+    setAllowAll(allow: boolean): void;
+    setResolveBase(newCwd: string): void;
+    private appendAuditLog;
+    get toolDefs(): readonly AnthropicToolDef[];
+    private checkReadOnlyBash;
+    private checkRepeatCircuitBreaker;
+    execute(call: ToolCall): Promise<ToolResult>;
+    executeBatch(calls: ToolCall[]): Promise<ToolResult[]>;
+    private executeCore;
+    private executeCompose;
+    private firePostToolUse;
+    private firePostToolUseFailure;
+}

package/dist/agent/tools/handlers/_cwd-utils.d.ts

@@ -0,0 +1,9 @@
+import type { ToolHandlerContext } from '../types.js';
+export declare function realpathSafe(p: string): string;
+export declare function _resetRootRealpathCacheForTests(): void;
+export declare function resolveAndContain(inputPath: string, context: ToolHandlerContext | undefined, mode?: 'read' | 'write'): string;
+export declare function wouldBeRestricted(inputPath: string, context: ToolHandlerContext | undefined, mode?: 'read' | 'write'): {
+    restricted: boolean;
+    resolved: string;
+    roots: string[];
+};

package/dist/agent/tools/handlers/ask-question.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from '../types.js';
+export declare const askQuestionHandler: ToolHandler;

package/dist/agent/tools/handlers/bash.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandler } from '../types.js';
+export declare function createBashHandler(permissionMode: string, cwd?: string): ToolHandler;
+export declare const bashHandler: ToolHandler;

package/dist/agent/tools/handlers/browser-act.d.ts

@@ -0,0 +1,4 @@
+import type { ToolHandler } from '../types.js';
+import type { BrowserHandlerOptions } from './browser-open.js';
+export declare function createBrowserActHandler(opts?: BrowserHandlerOptions): ToolHandler;
+export declare const browserActHandler: ToolHandler;

package/dist/agent/tools/handlers/browser-close.d.ts

@@ -0,0 +1,4 @@
+import type { ToolHandler } from '../types.js';
+import type { BrowserHandlerOptions } from './browser-open.js';
+export declare function createBrowserCloseHandler(opts?: BrowserHandlerOptions): ToolHandler;
+export declare const browserCloseHandler: ToolHandler;

package/dist/agent/tools/handlers/browser-observe.d.ts

@@ -0,0 +1,4 @@
+import type { ToolHandler } from '../types.js';
+import type { BrowserHandlerOptions } from './browser-open.js';
+export declare function createBrowserObserveHandler(opts?: BrowserHandlerOptions): ToolHandler;
+export declare const browserObserveHandler: ToolHandler;

package/dist/agent/tools/handlers/browser-open.d.ts

@@ -0,0 +1,6 @@
+import type { ToolHandler } from '../types.js';
+export interface BrowserHandlerOptions {
+    getBrowserProvider?: () => Promise<import('../../../browser/provider.js').BrowserProvider>;
+}
+export declare function createBrowserOpenHandler(opts?: BrowserHandlerOptions): ToolHandler;
+export declare const browserOpenHandler: ToolHandler;

package/dist/agent/tools/handlers/browser-screenshot.d.ts

@@ -0,0 +1,4 @@
+import type { ToolHandler } from '../types.js';
+import type { BrowserHandlerOptions } from './browser-open.js';
+export declare function createBrowserScreenshotHandler(opts?: BrowserHandlerOptions): ToolHandler;
+export declare const browserScreenshotHandler: ToolHandler;

package/dist/agent/tools/handlers/config-ops.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandler } from '../types.js';
+export declare const configGetHandler: ToolHandler;
+export declare const configSetHandler: ToolHandler;

package/dist/agent/tools/handlers/edit-file.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from '../types.js';
+export declare const editFileHandler: ToolHandler;

package/dist/agent/tools/handlers/exit-plan-mode.d.ts

@@ -0,0 +1,5 @@
+import type { AnthropicToolDef, ToolHandler } from '../types.js';
+import type { PlanExitControls } from '../../types/config-types.js';
+export declare const EXIT_PLAN_MODE_TOOL_NAME = "exit_plan_mode";
+export declare const exitPlanModeTool: AnthropicToolDef;
+export declare function createExitPlanModeHandler(controls: PlanExitControls): ToolHandler;

package/dist/agent/tools/handlers/glob.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandler } from '../types.js';
+export declare function createGlobHandler(cwd?: string): ToolHandler;
+export declare const globHandler: ToolHandler;

package/dist/agent/tools/handlers/grep.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandler } from '../types.js';
+export declare function createGrepHandler(cwd?: string): ToolHandler;
+export declare const grepHandler: ToolHandler;

package/dist/agent/tools/handlers/index.d.ts

@@ -0,0 +1,21 @@
+import type { ToolHandler } from '../types.js';
+import { bashHandler } from './bash.js';
+import { readFileHandler } from './read-file.js';
+import { writeFileHandler } from './write-file.js';
+import { editFileHandler } from './edit-file.js';
+import { globHandler } from './glob.js';
+import { grepHandler } from './grep.js';
+import { listDirectoryHandler } from './list-directory.js';
+import { sendTelegramHandler } from './send-telegram.js';
+import { webScrapeHandler } from './web-scrape.js';
+import { createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler } from './schedules.js';
+import { terminalFontSizeHandler } from './terminal-font-size.js';
+import { configGetHandler, configSetHandler } from './config-ops.js';
+import { askQuestionHandler } from './ask-question.js';
+import { browserOpenHandler } from './browser-open.js';
+import { browserObserveHandler } from './browser-observe.js';
+import { browserActHandler } from './browser-act.js';
+import { browserScreenshotHandler } from './browser-screenshot.js';
+import { browserCloseHandler } from './browser-close.js';
+export declare function createBuiltinHandlers(permissionMode?: string, cwd?: string): Map<string, ToolHandler>;
+export { bashHandler, readFileHandler, writeFileHandler, editFileHandler, globHandler, grepHandler, listDirectoryHandler, sendTelegramHandler, webScrapeHandler, createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler, terminalFontSizeHandler, configGetHandler, configSetHandler, askQuestionHandler, browserOpenHandler, browserObserveHandler, browserActHandler, browserScreenshotHandler, browserCloseHandler, };

package/dist/agent/tools/handlers/list-directory.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from '../types.js';
+export declare const listDirectoryHandler: ToolHandler;

package/dist/agent/tools/handlers/playwright-hints.d.ts

@@ -0,0 +1,5 @@
+import type { ToolFailureClass } from '../../trace/types.js';
+export declare function browserTimeoutFailureClass(err: unknown): ToolFailureClass | undefined;
+export declare const PLAYWRIGHT_MISSING_HINTS: readonly ["Cannot find package", "ERR_MODULE_NOT_FOUND", "Executable doesn't exist"];
+export declare function isPlaywrightMissing(msg: string): boolean;
+export declare function playwrightMissingHint(msg: string): string;

package/dist/agent/tools/handlers/read-file.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from '../types.js';
+export declare const readFileHandler: ToolHandler;

package/dist/agent/tools/handlers/schedules.d.ts

@@ -0,0 +1,7 @@
+import type { ToolHandler } from '../types.js';
+import { type DaemonSyncResult } from '../../daemon/http-client.js';
+export type { DaemonSyncResult };
+export declare const createScheduleHandler: ToolHandler;
+export declare const listSchedulesHandler: ToolHandler;
+export declare const getScheduleHistoryHandler: ToolHandler;
+export declare const cancelScheduleHandler: ToolHandler;

package/dist/agent/tools/handlers/send-telegram.d.ts

@@ -0,0 +1,6 @@
+import { type PushOptions, type PushResult } from '../../../telegram/push.js';
+import type { ToolHandler } from '../types.js';
+type PushFn = (options: PushOptions) => Promise<PushResult>;
+export declare function createSendTelegramHandler(pushFn?: PushFn): ToolHandler;
+export declare const sendTelegramHandler: ToolHandler;
+export {};

package/dist/agent/tools/handlers/terminal-font-size.d.ts

@@ -0,0 +1,15 @@
+import type { ToolHandler } from '../types.js';
+export declare const DEFAULT_FONT_SIZE = 16;
+export declare const MIN_FONT_SIZE = 6;
+export declare const MAX_FONT_SIZE = 60;
+export interface EditorTarget {
+    name: string;
+    path: string;
+}
+export interface TerminalFontSizeHandlerOpts {
+    discoverFn?: () => EditorTarget[];
+    writeFn?: (path: string, data: string, encoding: BufferEncoding) => Promise<void>;
+}
+export declare function discoverEditors(): EditorTarget[];
+export declare function createTerminalFontSizeHandler(opts?: TerminalFontSizeHandlerOpts): ToolHandler;
+export declare const terminalFontSizeHandler: ToolHandler;

package/dist/agent/tools/handlers/test-runner-detector.d.ts

@@ -0,0 +1,8 @@
+export type Runner = 'vitest' | 'jest' | 'pytest' | 'mocha' | 'go-test' | 'cargo' | 'rspec' | 'phpunit';
+export interface TestResult {
+    runner: Runner;
+    passed: number;
+    failed: number;
+    skipped?: number;
+}
+export declare function detectTestResult(output: string): TestResult | null;

package/dist/agent/tools/handlers/web-scrape.d.ts

@@ -0,0 +1,11 @@
+import type { ToolHandler } from '../types.js';
+import type { RenderFn } from '../../../web/types.js';
+type FetchFn = typeof fetch;
+interface WebScrapeOptions {
+    fetchFn?: FetchFn;
+    env?: Record<string, string | undefined>;
+    renderFn?: RenderFn;
+}
+export declare function createWebScrapeHandler(opts?: WebScrapeOptions): ToolHandler;
+export declare const webScrapeHandler: ToolHandler;
+export {};

package/dist/agent/tools/handlers/write-denylist.d.ts

@@ -0,0 +1,4 @@
+export declare const BUILTIN_WRITE_DENYLIST: readonly string[];
+export declare function getWriteDenylist(): readonly string[];
+export declare function safeRealpath(p: string): string;
+export declare function assertNotDenylisted(filePath: string, handlerName?: string): void;

package/dist/agent/tools/handlers/write-file.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHandler } from '../types.js';
+export declare const writeFileHandler: ToolHandler;

package/dist/agent/tools/hooks/bash-restriction-hook.d.ts

@@ -0,0 +1,8 @@
+import type { GrantManager } from '../../../cli/slash/commands/allow-dir.js';
+import type { HookContext, HookDecision } from '../../hooks.js';
+export interface BashRestrictionHookOptions {
+    getGrantManager: () => GrantManager | undefined;
+    disableInterpreterGuard?: boolean;
+    forceInterpreterGuard?: boolean;
+}
+export declare function createBashRestrictionHook(opts: BashRestrictionHookOptions): (context: HookContext) => HookDecision;

package/dist/agent/tools/hooks/path-approval-hook.d.ts

@@ -0,0 +1,14 @@
+import type { GrantManager } from '../../../cli/slash/commands/allow-dir.js';
+import type { HookHandler } from '../../hooks.js';
+export type PathApprovalSurface = 'repl' | 'telegram' | 'unknown';
+export interface PathApprovalHookOptions {
+    getGrantManager: () => GrantManager | undefined;
+    getCwd: () => string | undefined;
+    surface: PathApprovalSurface;
+}
+export interface PathApprovalHookHandlers {
+    preToolUse: HookHandler;
+    postToolUse: HookHandler;
+    sessionEnd: HookHandler;
+}
+export declare function createPathApprovalHook(opts: PathApprovalHookOptions): PathApprovalHookHandlers;

package/dist/agent/tools/index.d.ts

@@ -0,0 +1,7 @@
+export { builtinToolSchemas, BUILTIN_TOOL_NAMES, ALL_TOOL_SCHEMAS, agentTool, skillTool, composeTool, } from './schemas.js';
+export type { ToolHandler, ToolCall, ToolResult, AnthropicToolDef, ToolDispatcher, ConcurrencyClassifier } from './types.js';
+export { SessionToolDispatcher, defaultConcurrencyClassifier } from './dispatcher.js';
+export type { SessionToolDispatcherOptions } from './dispatcher.js';
+export { checkToolPermission } from './permissions.js';
+export type { ToolPermissionConfig, PermissionCheckResult } from './permissions.js';
+export { createBuiltinHandlers } from './handlers/index.js';

package/dist/agent/tools/nesting.d.ts

@@ -0,0 +1,29 @@
+import type { IAgentSession } from '../types.js';
+import type { ModelProvider } from '../provider.js';
+import type { AgentModelInput } from '../types.js';
+import type { Surface } from '../awareness/types.js';
+import { SkillExecutor } from './skill-executor.js';
+import type { SubagentExecutor } from './subagent-executor.js';
+import type { TraceWriter } from '../trace/index.js';
+import type { BackgroundAgentRegistry } from '../background-registry.js';
+export declare const DEFAULT_MAX_NESTING_DEPTH = 3;
+export interface ChildProviderFactoryArgs {
+    childExecutor: SubagentExecutor;
+    childSkillExecutor?: SkillExecutor;
+    model?: AgentModelInput;
+    allowedTools?: string[];
+    readOnlyBash?: boolean;
+}
+export declare function createStubParentSession(signal: AbortSignal): Pick<IAgentSession, 'sessionId' | 'getInputStreamRef' | 'abortSignal'>;
+export declare const CHILD_ALLOWED_TOOLS: string[];
+export declare const RECON_ALLOWED_TOOLS: readonly string[];
+export declare const DEFAULT_READ_ONLY_SKILLS: ReadonlySet<string>;
+export interface CreateChildProviderFactoryOptions {
+    openaiBaseUrl?: string;
+}
+export declare function createChildProviderFactory(opts?: CreateChildProviderFactoryOptions): (args: ChildProviderFactoryArgs) => ModelProvider;
+export declare function buildReadOnlyReconProvider(model: AgentModelInput | undefined): ModelProvider;
+export declare function createChildSkillExecutorFactory(defaultModel: AgentModelInput, apiKey: string | undefined, childProviderFactory: (args: ChildProviderFactoryArgs) => ModelProvider, baseUrl?: string, traceWriter?: TraceWriter, backgroundRegistry?: BackgroundAgentRegistry, cwd?: string, resolveApiKeyForModel?: (model: string) => string | undefined, surface?: Surface): (depth: number, maxDepth: number, signal: AbortSignal) => SkillExecutor;
+export type PhaseRole = 'read-only' | 'read-write';
+export declare function buildSkillRestrictedProvider(allowedTools: string[], model: AgentModelInput | undefined): ModelProvider;
+export declare function buildPhaseRestrictedProvider(_role: 'read-only', model: AgentModelInput | undefined): ModelProvider;

package/dist/agent/tools/permissions.d.ts

@@ -0,0 +1,10 @@
+export interface ToolPermissionConfig {
+    allowedTools?: string[];
+}
+export interface PermissionCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+export declare function checkToolPermission(toolName: string, config?: ToolPermissionConfig): PermissionCheckResult;
+export declare function withMcpToolsAllowed(base: ToolPermissionConfig | undefined, mcpToolWireNames: readonly string[]): ToolPermissionConfig | undefined;
+export declare function withCustomToolsAllowed(base: ToolPermissionConfig | undefined, customToolNames: readonly string[]): ToolPermissionConfig | undefined;

package/dist/agent/tools/readonly-bash.d.ts

@@ -0,0 +1,4 @@
+export declare function classifyBashCommand(command: string): {
+    mutating: boolean;
+    reason?: string;
+};

package/dist/agent/tools/render-registry.d.ts

@@ -0,0 +1,3 @@
+export type ToolRenderFormatter = (rawContent: string) => string | null;
+export declare const toolRenderers: ReadonlyMap<string, ToolRenderFormatter>;
+export declare function renderToolResult(toolName: string | undefined, rawContent: string): string | null;

package/dist/agent/tools/renderers/bash-renderer.d.ts

@@ -0,0 +1 @@
+export declare function formatBashDisplay(rawContent: string): string | null;

package/dist/agent/tools/schemas.d.ts

@@ -0,0 +1,29 @@
+import type { AnthropicToolDef } from './types.js';
+export declare const bashTool: AnthropicToolDef;
+export declare const readFileTool: AnthropicToolDef;
+export declare const writeFileTool: AnthropicToolDef;
+export declare const editFileTool: AnthropicToolDef;
+export declare const globTool: AnthropicToolDef;
+export declare const grepTool: AnthropicToolDef;
+export declare const listDirectoryTool: AnthropicToolDef;
+export declare const sendTelegramTool: AnthropicToolDef;
+export declare const webScrapeTool: AnthropicToolDef;
+export declare const agentTool: AnthropicToolDef;
+export declare const skillTool: AnthropicToolDef;
+export declare const composeTool: AnthropicToolDef;
+export declare const createScheduleTool: AnthropicToolDef;
+export declare const listSchedulesTool: AnthropicToolDef;
+export declare const getScheduleHistoryTool: AnthropicToolDef;
+export declare const cancelScheduleTool: AnthropicToolDef;
+export declare const terminalFontSizeTool: AnthropicToolDef;
+export declare const configGetTool: AnthropicToolDef;
+export declare const configSetTool: AnthropicToolDef;
+export declare const askQuestionTool: AnthropicToolDef;
+export declare const browserOpenTool: AnthropicToolDef;
+export declare const browserObserveTool: AnthropicToolDef;
+export declare const browserActTool: AnthropicToolDef;
+export declare const browserScreenshotTool: AnthropicToolDef;
+export declare const browserCloseTool: AnthropicToolDef;
+export declare const builtinToolSchemas: readonly AnthropicToolDef[];
+export declare const BUILTIN_TOOL_NAMES: string[];
+export declare const ALL_TOOL_SCHEMAS: readonly AnthropicToolDef[];

package/dist/agent/tools/skill-bridge.d.ts

@@ -0,0 +1,21 @@
+import '../../skills/all.js';
+import type { SdkPluginConfig } from '../types/sdk-types.js';
+export interface SkillManifestEntry {
+    name: string;
+    description: string;
+    source: 'builtin' | 'user' | 'project' | 'plugin' | 'imported';
+    argumentHint?: string;
+    whenToUse?: string;
+}
+export declare function buildSkillManifest(pluginConfigs?: SdkPluginConfig[]): string;
+export declare function collectSkillEntries(pluginConfigs?: SdkPluginConfig[]): SkillManifestEntry[];
+export interface PluginSkillBody {
+    body: string;
+    pluginPath: string;
+    allowedTools?: string[];
+    context?: string;
+    readOnly?: boolean;
+}
+export declare function discoverPluginSkillBodies(pluginConfigs?: SdkPluginConfig[]): Map<string, PluginSkillBody>;
+export declare function scanAllPluginRoots(): SdkPluginConfig[];
+export declare function ensurePluginEntrypointsLoaded(): Promise<void>;

package/dist/agent/tools/skill-depth-message.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_MAX_DEPTH_RECOVERY_HINT = "You are too deeply nested to delegate further \u2014 perform the work inline with your own tools instead of calling skill/agent/compose.";
+export declare function buildSkillMaxDepthRefusal(depth: number, maxDepth: number): string;

package/dist/agent/tools/skill-executor.d.ts

@@ -0,0 +1,45 @@
+import type { AgentModelInput, IAgentSession } from '../types.js';
+import type { ModelProvider } from '../provider.js';
+import type { ToolCall, ToolResult } from './types.js';
+import type { TraceWriter } from '../trace/index.js';
+import type { BackgroundAgentRegistry } from '../background-registry.js';
+import type { SdkPluginConfig } from '../types/sdk-types.js';
+import { type ChildProviderFactoryArgs } from './nesting.js';
+import type { Surface } from '../awareness/types.js';
+export interface SkillExecutorContext {
+    parentSession: Pick<IAgentSession, 'sessionId' | 'getInputStreamRef' | 'abortSignal'> & Partial<Pick<IAgentSession, 'hookRegistry'>>;
+    defaultModel?: string;
+    surface?: Surface;
+    defaultSubagentModel?: AgentModelInput;
+    apiKey?: string;
+    resolveApiKeyForModel?: (model: string) => string | undefined;
+    baseUrl?: string;
+    pluginConfigs?: SdkPluginConfig[];
+    depth?: number;
+    maxDepth?: number;
+    childProviderFactory?: (args: ChildProviderFactoryArgs) => ModelProvider;
+    childSkillExecutorFactory?: (depth: number, maxDepth: number, signal: AbortSignal) => SkillExecutor;
+    traceWriter?: TraceWriter;
+    backgroundRegistry?: BackgroundAgentRegistry;
+    cwd?: string;
+}
+export declare class SkillExecutor {
+    private readonly ctx;
+    private pluginBodies;
+    private currentCwd;
+    constructor(ctx: SkillExecutorContext);
+    setCwd(cwd: string): void;
+    private sessionIdentity;
+    execute(call: ToolCall): Promise<ToolResult>;
+    private executeRegistrySkill;
+    private buildForkedChildConfig;
+    private executeForkedRegistrySkill;
+    private formatLoadedSkillResult;
+    private emitLoadTelemetry;
+    private executeLoadedRegistrySkill;
+    private executeLoadedPluginSkill;
+    private substituteSkillArgs;
+    private executePluginSkill;
+    private getPluginSkillBody;
+    private createDispatchSkillCallback;
+}