@sctg/cline-core 3.84.0-beta.20260524130712

package/dist/extensions/tools/team/multi-agent.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Multi-Agent Coordination
+ *
+ * Utilities for orchestrating multiple agents working together.
+ */
+import { type AgentConfig, type AgentEvent, type AgentResult, type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus } from "@cline/shared";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+export { type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type MissionLogKind, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamOutcomeFragmentStatus, type TeamOutcomeStatus, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus, } from "@cline/shared";
+export interface TeamMemberConfig extends AgentConfig {
+    role?: string;
+}
+export interface AgentTask {
+    agentId: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TaskResult {
+    agentId: string;
+    result: AgentResult;
+    error?: Error;
+    metadata?: Record<string, unknown>;
+}
+export type TeamEvent = {
+    type: TeamMessageType.TaskStart;
+    agentId: string;
+    message: string;
+} | {
+    type: TeamMessageType.TaskEnd;
+    agentId: string;
+    result?: AgentResult;
+    error?: Error;
+    messages?: AgentResult["messages"];
+} | {
+    type: TeamMessageType.AgentEvent;
+    agentId: string;
+    event: AgentEvent;
+} | {
+    type: TeamMessageType.TeammateSpawned;
+    agentId: string;
+    role?: string;
+    teammate: TeammateLifecycleSpec;
+} | {
+    type: TeamMessageType.TeammateShutdown;
+    agentId: string;
+    reason?: string;
+} | {
+    type: TeamMessageType.TeamTaskUpdated;
+    task: TeamTask;
+} | {
+    type: TeamMessageType.TeamMessage;
+    message: TeamMailboxMessage;
+} | {
+    type: TeamMessageType.TeamMissionLog;
+    entry: MissionLogEntry;
+} | {
+    type: TeamMessageType.RunQueued;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunStarted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunProgress;
+    run: TeamRunRecord;
+    message: string;
+} | {
+    type: TeamMessageType.RunCompleted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunFailed;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunCancelled;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.RunInterrupted;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.OutcomeCreated;
+    outcome: TeamOutcome;
+} | {
+    type: TeamMessageType.OutcomeFragmentAttached;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFragmentReviewed;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFinalized;
+    outcome: TeamOutcome;
+};
+export interface AgentTeamsRuntimeOptions {
+    teamName: string;
+    leadAgentId?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConcurrentRuns?: number;
+    onTeamEvent?: (event: TeamEvent) => void;
+}
+export interface SpawnTeammateOptions {
+    agentId: string;
+    config: TeamMemberConfig;
+}
+export declare class AgentTeam {
+    private agents;
+    private configs;
+    private onTeamEvent?;
+    constructor(configs?: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void);
+    addAgent(id: string, config: TeamMemberConfig): void;
+    removeAgent(id: string): boolean;
+    getAgent(id: string): SessionRuntime | undefined;
+    getAgentIds(): string[];
+    get size(): number;
+    routeTo(agentId: string, message: string): Promise<AgentResult>;
+    continueTo(agentId: string, message: string): Promise<AgentResult>;
+    runParallel(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runSequential(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runPipeline(pipeline: string[], initialMessage: string, messageTransformer?: (prevResult: AgentResult, nextAgentId: string) => string): Promise<TaskResult[]>;
+    abortAll(): void;
+    clear(): void;
+    private emitEvent;
+}
+export declare function createAgentTeam(configs: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void): AgentTeam;
+export declare function createWorkerReviewerTeam(configs: {
+    worker: TeamMemberConfig;
+    reviewer: TeamMemberConfig;
+}): AgentTeam & {
+    doAndReview: (message: string) => Promise<{
+        workerResult: AgentResult;
+        reviewResult: AgentResult;
+    }>;
+};
+export declare class AgentTeamsRuntime {
+    private readonly teamId;
+    private readonly teamName;
+    private readonly onTeamEvent?;
+    private readonly members;
+    private readonly tasks;
+    private readonly missionLog;
+    private readonly mailbox;
+    private missionStepCounter;
+    private taskCounter;
+    private messageCounter;
+    private missionCounter;
+    private runCounter;
+    private outcomeCounter;
+    private outcomeFragmentCounter;
+    private readonly runs;
+    private readonly runQueue;
+    private queuedRunDispatchTimer;
+    private readonly outcomes;
+    private readonly outcomeFragments;
+    private readonly missionLogIntervalSteps;
+    private readonly missionLogIntervalMs;
+    private readonly maxConcurrentRuns;
+    constructor(options: AgentTeamsRuntimeOptions);
+    getTeamId(): string;
+    getTeamName(): string;
+    getMemberRole(agentId: string): "lead" | "teammate" | undefined;
+    getMemberIds(): string[];
+    getTeammateIds(): string[];
+    getTask(taskId: string): TeamTask | undefined;
+    listTasks(): TeamTask[];
+    listTaskItems(options?: {
+        status?: TeamTaskStatus;
+        assignee?: string;
+    }): TeamTaskListItem[];
+    listMissionLog(limit?: number): MissionLogEntry[];
+    listMailbox(agentId: string, options?: {
+        unreadOnly?: boolean;
+        markRead?: boolean;
+        limit?: number;
+    }): TeamMailboxMessage[];
+    getSnapshot(): TeamRuntimeSnapshot;
+    exportState(): TeamRuntimeState;
+    hydrateState(state: TeamRuntimeState): void;
+    isTeammateActive(agentId: string): boolean;
+    spawnTeammate({ agentId, config }: SpawnTeammateOptions): TeamMemberSnapshot;
+    shutdownTeammate(agentId: string, reason?: string): void;
+    updateTeammateConnections(overrides: Partial<Pick<AgentConfig, "apiKey" | "baseUrl" | "headers">>): void;
+    createTask(input: CreateTeamTaskInput): TeamTask;
+    claimTask(taskId: string, agentId: string): TeamTask;
+    blockTask(taskId: string, agentId: string, reason: string): TeamTask;
+    completeTask(taskId: string, agentId: string, summary: string): TeamTask;
+    routeToTeammate(agentId: string, message: string, options?: RouteToTeammateOptions): Promise<AgentResult>;
+    startTeammateRun(agentId: string, message: string, options?: RouteToTeammateOptions & {
+        priority?: number;
+        maxRetries?: number;
+        leaseOwner?: string;
+    }): TeamRunRecord;
+    private dispatchQueuedRuns;
+    private selectNextDispatchableQueuedRun;
+    private scheduleQueuedRunDispatch;
+    private clearQueuedRunDispatchTimer;
+    private countActiveRuns;
+    private executeQueuedRun;
+    listRuns(options?: {
+        status?: TeamRunStatus | null;
+        agentId?: string | null;
+        includeCompleted?: boolean | null;
+    }): TeamRunRecord[];
+    getRun(runId: string): TeamRunRecord | undefined;
+    awaitRun(runId: string, pollIntervalMs?: number): Promise<TeamRunRecord>;
+    awaitAllRuns(pollIntervalMs?: number): Promise<TeamRunRecord[]>;
+    cancelRun(runId: string, reason?: string): TeamRunRecord;
+    recoverActiveRuns(reason?: string): TeamRunRecord[];
+    markStaleRunsInterrupted(reason?: string): TeamRunRecord[];
+    sendMessage(fromAgentId: string, toAgentId: string, subject: string, body: string, taskId?: string): TeamMailboxMessage;
+    broadcast(fromAgentId: string, subject: string, body: string, options?: {
+        taskId?: string;
+    }): TeamMailboxMessage[];
+    appendMissionLog(input: AppendMissionLogInput): MissionLogEntry;
+    createOutcome(input: CreateTeamOutcomeInput): TeamOutcome;
+    listOutcomes(): TeamOutcome[];
+    attachOutcomeFragment(input: AttachTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    reviewOutcomeFragment(input: ReviewTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    listOutcomeFragments(outcomeId: string): TeamOutcomeFragment[];
+    finalizeOutcome(outcomeId: string): TeamOutcome;
+    cleanup(): void;
+    private requireTask;
+    private assertDependenciesResolved;
+    private getUnresolvedDependencies;
+    private trackMeaningfulEvent;
+    private recordRunActivityFromAgentEvent;
+    private recordRunProgress;
+    private formatProgressErrorActivity;
+    private recordProgressStep;
+    private buildMailboxNotification;
+    private emitEvent;
+}

package/dist/extensions/tools/team/projections.d.ts

@@ -0,0 +1,8 @@
+import type { TeamProgressLifecycleEvent, TeamProgressSummary, TeamRuntimeState } from "@cline/shared";
+import type { TeamEvent } from "./multi-agent";
+export declare function buildTeamProgressSummary(teamName: string, state: TeamRuntimeState): TeamProgressSummary;
+export declare function toTeamProgressLifecycleEvent(input: {
+    teamName: string;
+    sessionId: string;
+    event: TeamEvent;
+}): TeamProgressLifecycleEvent;

package/dist/extensions/tools/team/runtime.d.ts

@@ -0,0 +1,4 @@
+export { buildDelegatedAgentConfig, createDelegatedAgent, createDelegatedAgentConfigProvider, type DelegatedAgentConfigProvider, type DelegatedAgentConnectionConfig, type DelegatedAgentKind, type DelegatedAgentRuntimeConfig, } from "./delegated-agent";
+export { createSpawnAgentTool, type SpawnAgentInput, type SpawnAgentOutput, type SpawnAgentToolConfig, type SubAgentEndContext, type SubAgentStartContext, } from "./spawn-agent-tool";
+export { type AgentTask, AgentTeam, AgentTeamsRuntime, type AgentTeamsRuntimeOptions, createAgentTeam, createWorkerReviewerTeam, type SpawnTeammateOptions, type TaskResult, type TeamEvent, type TeamMemberConfig, } from "./multi-agent";
+export { type BootstrapAgentTeamsOptions, type BootstrapAgentTeamsResult, bootstrapAgentTeams, type CreateAgentTeamsToolsOptions, createAgentTeamsTools, reviveTeamStateDates, sanitizeTeamName, type TeamTeammateRuntimeConfig, } from "./team-tools";

package/dist/extensions/tools/team/spawn-agent-tool.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Reusable spawn_agent tool for delegating tasks to sub-agents.
+ */
+import { type AgentConfig, type AgentEvent, type AgentHooks, type AgentResult, type AgentTool, type AgentToolContext, type BasicLogger, type HookErrorMode, type ITelemetryService, type ToolApprovalRequest, type ToolApprovalResult, type ToolPolicy } from "@cline/shared";
+import { z } from "zod";
+import { type DelegatedAgentConfigProvider } from "./delegated-agent";
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentFinishReason = AgentResult["finishReason"];
+export declare const SpawnAgentInputSchema: z.ZodObject<{
+    systemPrompt: z.ZodString;
+    task: z.ZodString;
+}, z.core.$strip>;
+export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
+export interface SpawnAgentOutput {
+    text: string;
+    iterations: number;
+    finishReason: AgentFinishReason;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface SubAgentStartContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+}
+export interface SubAgentEndContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+    result?: SpawnAgentOutput;
+    agentResult?: AgentResult;
+    error?: Error;
+}
+export interface SpawnAgentToolConfig {
+    configProvider: DelegatedAgentConfigProvider;
+    defaultMaxIterations?: number;
+    subAgentTools?: AgentTool[];
+    createSubAgentTools?: (input: SpawnAgentInput, context: AgentToolContext) => AgentTool[] | Promise<AgentTool[]>;
+    onSubAgentEvent?: (event: AgentEvent) => void;
+    /**
+     * Lifecycle hooks forwarded to spawned sub-agent runs.
+     */
+    hooks?: AgentHooks;
+    /**
+     * Extension list forwarded to spawned sub-agent runs.
+     */
+    extensions?: AgentExtension[];
+    /**
+     * Error handling mode for forwarded lifecycle hooks.
+     */
+    hookErrorMode?: HookErrorMode;
+    /**
+     * Called after a sub-agent instance is created and before it starts running.
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+    /**
+     * Called once a sub-agent run finishes (success or error).
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+    /**
+     * Optional per-tool policy for spawned sub-agents.
+     */
+    toolPolicies?: Record<string, ToolPolicy>;
+    /**
+     * Optional approval callback for spawned sub-agent tool calls.
+     */
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    /**
+     * Optional logger forwarded to spawned sub-agent runs.
+     */
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+/**
+ * Create a spawn_agent tool that can run a delegated task with a focused sub-agent.
+ */
+export declare function createSpawnAgentTool(config: SpawnAgentToolConfig): AgentTool<SpawnAgentInput, SpawnAgentOutput>;
+export {};

package/dist/extensions/tools/team/subagent-prompts.d.ts

@@ -0,0 +1,3 @@
+import type { DelegatedAgentRuntimeConfig } from "./delegated-agent";
+export declare function buildTeammateSystemPrompt(prompt: string, config: DelegatedAgentRuntimeConfig): string;
+export declare function buildSubAgentSystemPrompt(prompt: string, config: DelegatedAgentRuntimeConfig): string;

package/dist/extensions/tools/team/team-tools.d.ts

@@ -0,0 +1,35 @@
+import { type AgentTool, type TeamRuntimeState, type TeamTeammateSpec } from "@cline/shared";
+import { type DelegatedAgentConfigProvider, type DelegatedAgentRuntimeConfig } from "./delegated-agent";
+import type { AgentTeamsRuntime } from "./multi-agent";
+export type TeamTeammateRuntimeConfig = DelegatedAgentRuntimeConfig;
+export interface CreateAgentTeamsToolsOptions {
+    runtime: AgentTeamsRuntime;
+    requesterId: string;
+    teammateConfigProvider: DelegatedAgentConfigProvider;
+    createBaseTools?: () => AgentTool[];
+    allowSpawn?: boolean;
+    includeSpawnTool?: boolean;
+    includeManagementTools?: boolean;
+    onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+export interface BootstrapAgentTeamsOptions {
+    runtime: AgentTeamsRuntime;
+    teammateConfigProvider: DelegatedAgentConfigProvider;
+    createBaseTools?: () => AgentTool[];
+    leadAgentId?: string;
+    restoredTeammates?: TeamTeammateSpec[];
+    restoredFromPersistence?: boolean;
+    includeLeadSpawnTool?: boolean;
+    includeLeadManagementTools?: boolean;
+    onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+export interface BootstrapAgentTeamsResult {
+    tools: AgentTool[];
+    restoredFromPersistence: boolean;
+    restoredTeammates: string[];
+}
+export declare const TEAM_TOOL_NAMES: readonly ["team_spawn_teammate", "team_shutdown_teammate", "team_status", "team_task", "team_run_task", "team_cancel_run", "team_list_runs", "team_await_runs", "team_send_message", "team_broadcast", "team_read_mailbox", "team_mission_log", "team_cleanup", "team_create_outcome", "team_attach_outcome_fragment", "team_review_outcome_fragment", "team_finalize_outcome", "team_list_outcomes"];
+export declare function bootstrapAgentTeams(options: BootstrapAgentTeamsOptions): BootstrapAgentTeamsResult;
+export declare function createAgentTeamsTools(options: CreateAgentTeamsToolsOptions): AgentTool[];
+export declare function reviveTeamStateDates(state: TeamRuntimeState): TeamRuntimeState;
+export declare function sanitizeTeamName(name: string): string;

package/dist/extensions/tools/types.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Types for Default Tools
+ *
+ * Type definitions for executors, configuration, and results.
+ */
+import type { AgentToolContext, ImageContent, TextContent } from "@cline/shared";
+import type { ApplyPatchInput, EditFileInput, ReadFileRequest, StructuredCommandInput } from "./schemas";
+/**
+ * Result from a single tool operation
+ */
+export interface ToolOperationResult {
+    /** The query/input that was executed */
+    query: string;
+    /** The result content (if successful) */
+    result: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Duration in MS */
+    duration?: number;
+}
+export type FileReadResultContent = string | Array<TextContent | ImageContent>;
+/**
+ * Executor for reading files
+ *
+ * @param request - File path and optional inclusive line range to read
+ * @param context - Tool execution context
+ * @returns The file content as a string
+ */
+export type FileReadExecutor = (request: ReadFileRequest, context: AgentToolContext) => Promise<FileReadResultContent>;
+/**
+ * Executor for searching the codebase
+ *
+ * @param query - Regex pattern to search for
+ * @param cwd - Current working directory for the search
+ * @param context - Tool execution context
+ * @returns Search results as a formatted string
+ */
+export type SearchExecutor = (query: string, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for running shell commands
+ *
+ * @param command - Shell command to execute
+ * @param cwd - Current working directory for execution
+ * @param context - Tool execution context
+ * @returns Command output (stdout)
+ */
+export type BashExecutor = (command: string | StructuredCommandInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for fetching web content
+ *
+ * @param url - URL to fetch
+ * @param prompt - Analysis prompt for the content
+ * @param context - Tool execution context
+ * @returns Analyzed/extracted content
+ */
+export type WebFetchExecutor = (url: string, prompt: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for editing files
+ *
+ * @param input - Editor command input
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type EditorExecutor = (input: EditFileInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for apply_patch operations
+ *
+ * @param input - apply_patch command payload
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type ApplyPatchExecutor = (input: ApplyPatchInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for invoking configured skills
+ *
+ * @param skill - Skill name to invoke
+ * @param args - Optional arguments for the skill
+ * @param context - Tool execution context
+ * @returns Skill loading/invocation result
+ */
+export type SkillsExecutor = (skill: string, args: string | undefined, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for asking a single follow-up question with selectable options
+ *
+ * @param question - Single clarifying question for the user
+ * @param options - 2-5 selectable answer options
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type AskQuestionExecutor = (question: string, options: string[], context: AgentToolContext) => Promise<string>;
+/**
+ * Skill metadata exposed by SkillsExecutor for clients/UI
+ */
+export interface SkillsExecutorSkillMetadata {
+    /** Normalized skill id (usually lowercased name) */
+    id: string;
+    /** Display name for the skill */
+    name: string;
+    /** Optional short description */
+    description?: string;
+    /** True when configured but intentionally disabled */
+    disabled: boolean;
+}
+/**
+ * A callable executor that can also expose configured skill metadata.
+ */
+export interface SkillsExecutorWithMetadata {
+    (skill: string, args: string | undefined, context: AgentToolContext): Promise<string>;
+    configuredSkills?: SkillsExecutorSkillMetadata[];
+}
+/**
+ * Executor for verifying a user's response to a question
+ *
+ * @param summary - Summary of the solution ans steps taken
+ * @param verified - Boolean indicating if the solution has been verified
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type VerifySubmitExecutor = (summary: string, verified: boolean, context: AgentToolContext) => Promise<string>;
+/**
+ * Collection of all tool executors
+ */
+export interface ToolExecutors {
+    /** File reading implementation */
+    readFile?: FileReadExecutor;
+    /** Codebase search implementation */
+    search?: SearchExecutor;
+    /** Shell command execution implementation */
+    bash?: BashExecutor;
+    /** Web content fetching implementation */
+    webFetch?: WebFetchExecutor;
+    /** Filesystem editor implementation */
+    editor?: EditorExecutor;
+    /** Apply patch implementation */
+    applyPatch?: ApplyPatchExecutor;
+    /** Skill invocation implementation */
+    skills?: SkillsExecutorWithMetadata;
+    /** Follow-up question implementation */
+    askQuestion?: AskQuestionExecutor;
+    /** Final submission implementation */
+    submit?: VerifySubmitExecutor;
+}
+/**
+ * Names of available default tools
+ */
+export type DefaultToolName = "read_files" | "search_codebase" | "run_commands" | "fetch_web_content" | "apply_patch" | "editor" | "skills" | "ask_question" | "submit_and_exit";
+/**
+ * Configuration for enabling/disabling default tools
+ */
+export interface DefaultToolsConfig {
+    /**
+     * Enable the read_files tool
+     * @default true
+     */
+    enableReadFiles?: boolean;
+    /**
+     * Enable the search_codebase tool
+     * @default true
+     */
+    enableSearch?: boolean;
+    /**
+     * Enable the run_commands tool
+     * @default true
+     */
+    enableBash?: boolean;
+    /**
+     * Enable the fetch_web_content tool
+     * @default true
+     */
+    enableWebFetch?: boolean;
+    /**
+     * Enable the apply_patch tool
+     * @default true
+     */
+    enableApplyPatch?: boolean;
+    /**
+     * Enable the editor tool
+     * @default true
+     */
+    enableEditor?: boolean;
+    /**
+     * Enable the skills tool
+     * @default true
+     */
+    enableSkills?: boolean;
+    /**
+     * Enable the ask_followup_question tool
+     * @default true
+     */
+    enableAskQuestion?: boolean;
+    /**
+     * Enable the submit_and_exit tool
+     * @default false
+     */
+    enableSubmitAndExit?: boolean;
+    /**
+     * Current working directory for tools that need it
+     */
+    cwd?: string;
+    /**
+     * Timeout for file read operations in milliseconds
+     * @default 10000
+     */
+    fileReadTimeoutMs?: number;
+    /**
+     * Timeout for bash command execution in milliseconds
+     * @default 30000
+     */
+    bashTimeoutMs?: number;
+    /**
+     * Timeout for web fetch operations in milliseconds
+     * @default 30000
+     */
+    webFetchTimeoutMs?: number;
+    /**
+     * Timeout for search operations in milliseconds
+     * @default 30000
+     */
+    searchTimeoutMs?: number;
+    /**
+     * Timeout for apply_patch operations in milliseconds
+     * @default 30000
+     */
+    applyPatchTimeoutMs?: number;
+    /**
+     * Timeout for editor operations in milliseconds
+     * @default 30000
+     */
+    editorTimeoutMs?: number;
+    /**
+     * Timeout for skills operations in milliseconds
+     * @default 15000
+     */
+    skillsTimeoutMs?: number;
+    /**
+     * Timeout for submit_and_exit operations in milliseconds
+     * @default 15000
+     */
+    submitTimeoutMs?: number;
+}
+/**
+ * Options for creating default tools
+ */
+export interface CreateDefaultToolsOptions extends DefaultToolsConfig {
+    /**
+     * Executor implementations for the tools
+     * Only tools with provided executors will be available
+     */
+    executors: ToolExecutors;
+}

package/dist/hooks/checkpoint-hooks.d.ts

@@ -0,0 +1,45 @@
+import type { AgentHooks, BasicLogger } from "@cline/shared";
+export interface CheckpointEntry {
+    ref: string;
+    createdAt: number;
+    runCount: number;
+    kind?: "stash" | "commit";
+}
+export interface CheckpointMetadata {
+    latest: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+type CreateCheckpointHooksOptions = {
+    cwd: string;
+    sessionId: string;
+    logger?: BasicLogger;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+    /**
+     * Optional custom checkpoint implementation. When provided, the built-in
+     * git stash/ref logic is skipped entirely and this function is called
+     * instead. Return `undefined` to skip writing a checkpoint for that run.
+     */
+    createCheckpoint?: (context: {
+        cwd: string;
+        sessionId: string;
+        runCount: number;
+    }) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+    /**
+     * Starting value for the internal run counter. Use this when a session
+     * is created with initial messages (e.g. after a checkpoint restore) so
+     * that new checkpoint entries get runCount values that don't collide
+     * with entries carried over from the source session.
+     */
+    initialRunCount?: number;
+};
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed - if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export declare function deleteCheckpointRefs(cwd: string | null | undefined, sessionId: string): Promise<void>;
+export declare function retainCheckpointRefs(cwd: string | null | undefined, sessionId: string, checkpoints: readonly CheckpointEntry[]): Promise<void>;
+export declare function createCheckpointHooks(options: CreateCheckpointHooksOptions): AgentHooks;
+export {};

package/dist/hooks/hook-extension.d.ts

@@ -0,0 +1,2 @@
+import type { AgentExtension, AgentHooks } from "@cline/shared";
+export declare function createAgentHooksExtension(name: string, hooks: AgentHooks | undefined): AgentExtension | undefined;