tarsk 0.3.0 → 0.3.2

package/node_modules/@neovate/code/dist/index.d.ts

@@ -0,0 +1,3170 @@
+import type { AnthropicProvider } from '@ai-sdk/anthropic';
+import EventEmitter from 'events';
+import type { LanguageModelMiddleware } from 'ai';
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+import type { OpenAICompatibleProvider } from '@ai-sdk/openai-compatible';
+import type { OpenAIProvider } from '@ai-sdk/openai';
+import * as z from 'zod';
+import { z as _zod } from 'zod';
+
+declare interface AddSkillOptions {
+    global?: boolean;
+    claude?: boolean;
+    overwrite?: boolean;
+    name?: string;
+    targetDir?: string;
+}
+
+declare interface AddSkillResult {
+    installed: SkillMetadata[];
+    skipped: {
+        name: string;
+        reason: string;
+    }[];
+    errors: SkillError[];
+}
+
+declare type AgentConfig = {
+    model?: string;
+};
+
+declare interface AgentDefinition {
+    agentType: string;
+    whenToUse: string;
+    systemPrompt: string;
+    model: string;
+    source: AgentSource;
+    tools?: string[];
+    disallowedTools?: string[];
+    forkContext?: boolean;
+    color?: string;
+    path?: string;
+    /**
+     * Controls whether the agent is available for use.
+     * - boolean: Static toggle (default: true)
+     * - function: Dynamic check based on context
+     */
+    isEnabled?: boolean | ((context: Context) => boolean);
+}
+
+declare interface AgentExecutionResult {
+    status: 'completed' | 'failed';
+    agentId: string;
+    content: string;
+    totalToolCalls: number;
+    totalDuration: number;
+    model?: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+
+declare interface AgentLoadError {
+    path: string;
+    message: string;
+}
+
+declare class AgentManager {
+    private agents;
+    private context;
+    private errors;
+    constructor(opts: {
+        context: Context;
+    });
+    private registerBuiltinAgents;
+    registerAgent(definition: AgentDefinition): void;
+    isAgentEnabled(agent: AgentDefinition): boolean;
+    getAgent(agentType: string): AgentDefinition | undefined;
+    getAllAgents(): AgentDefinition[];
+    getAgentTypes(): string[];
+    executeTask(input: TaskToolInput, context: {
+        tools: Tool[];
+        cwd: string;
+        signal?: AbortSignal;
+        parentSessionId?: string;
+        forkContextMessages?: NormalizedMessage[];
+        onMessage?: (message: NormalizedMessage, agentId: string, model: string) => void | Promise<void>;
+        onToolApprove?: (opts: {
+            toolUse: ToolUse;
+            category?: ApprovalCategory;
+        }) => Promise<boolean | ToolApprovalResult>;
+    }): Promise<AgentExecutionResult>;
+    getAgentDescriptions(): string;
+    loadAgents(): Promise<void>;
+    private loadAgentsFromPlugins;
+    getErrors(): AgentLoadError[];
+    private loadAgentsFromDirectory;
+    private loadAgentFile;
+    private convertToolNames;
+    private parseAgentFile;
+}
+
+declare type AgentResultReturnDisplay = {
+    type: 'agent_result';
+    agentId: string;
+    agentType: string;
+    description: string;
+    prompt: string;
+    content: string;
+    stats: {
+        toolCalls: number;
+        duration: number;
+        tokens: {
+            input: number;
+            output: number;
+        };
+    };
+    status: 'completed' | 'failed';
+};
+
+declare enum AgentSource {
+    BuiltIn = "built-in",
+    Plugin = "plugin",
+    User = "user",
+    ProjectClaude = "project-claude",
+    Project = "project",
+    GlobalClaude = "global-claude",
+    Global = "global"
+}
+
+declare enum ApiFormat {
+    Anthropic = "anthropic",
+    OpenAI = "openai",
+    Responses = "responses",
+    Google = "google",
+    _OpenRouter = "_openrouter"
+}
+
+/** Supported application types for open and detect operations */
+declare type App = 'cursor' | 'vscode' | 'vscode-insiders' | 'zed' | 'windsurf' | 'iterm' | 'warp' | 'terminal' | 'antigravity' | 'finder' | 'sourcetree' | 'fork';
+
+declare type ApprovalCategory = 'read' | 'write' | 'command' | 'network' | 'ask';
+
+declare type ApprovalContext = {
+    toolName: string;
+    params: Record<string, any>;
+    approvalMode: string;
+    context: any;
+};
+
+declare type ApprovalMode = 'default' | 'autoEdit' | 'yolo';
+
+export declare type Argv = {
+    _: string[];
+    help: boolean;
+    mcp: boolean;
+    quiet: boolean;
+    continue?: boolean;
+    version: boolean;
+    appendSystemPrompt?: string;
+    approvalMode?: string;
+    cwd?: string;
+    host?: string;
+    language?: string;
+    model?: string;
+    outputFormat?: string;
+    outputStyle?: string;
+    planModel?: string;
+    smallModel?: string;
+    visionModel?: string;
+    resume?: string;
+    systemPrompt?: string;
+    tools?: string;
+    port?: number;
+    plugin: string[];
+    mcpConfig: string[];
+    extensions: Record<string, any>;
+};
+
+declare type AssistantContent = string | Array<TextPart | ReasoningPart | ToolUsePart>;
+
+declare type AssistantMessage = {
+    role: 'assistant';
+    content: AssistantContent;
+    text: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+    };
+};
+
+declare interface BackgroundTask {
+    id: string;
+    command: string;
+    pid: number;
+    pgid?: number;
+    status: 'running' | 'completed' | 'killed' | 'failed';
+    createdAt: number;
+    output: string;
+    exitCode: number | null;
+}
+
+declare class BackgroundTaskManager {
+    private tasks;
+    createTask(input: CreateTaskInput): string;
+    getTask(id: string): BackgroundTask | null;
+    getAllTasks(): BackgroundTask[];
+    appendOutput(id: string, output: string): void;
+    updateTaskStatus(id: string, status: BackgroundTask['status'], exitCode?: number | null): void;
+    deleteTask(id: string): void;
+    private isProcessAlive;
+    killTask(id: string): Promise<boolean>;
+}
+
+declare type BaseMessage = {
+    id: MessageId;
+    timestamp: number;
+};
+
+declare interface BaseSlashCommand {
+    name: string;
+    description: string;
+    isEnabled?: boolean;
+}
+
+declare type CommitConfig = {
+    language: string;
+    systemPrompt?: string;
+    model?: string;
+};
+
+declare type Config = {
+    model: string;
+    planModel: string;
+    smallModel?: string;
+    visionModel?: string;
+    language: string;
+    quiet: boolean;
+    approvalMode: ApprovalMode;
+    plugins: string[];
+    mcpServers: Record<string, McpServerConfig>;
+    provider?: Record<string, ProviderConfig>;
+    systemPrompt?: string;
+    todo?: boolean;
+    /**
+     * Controls whether automatic conversation compression is enabled.
+     * When set to false, conversation history will accumulate and context limit will be exceeded.
+     *
+     * @default true
+     */
+    autoCompact?: boolean;
+    /**
+     * Controls whether automatic tool output truncation is enabled.
+     * When enabled, large tool outputs (>2000 lines or >50KB) will be truncated
+     * and full content saved to a local file.
+     *
+     * @default true
+     */
+    truncation?: boolean;
+    commit?: CommitConfig;
+    outputStyle?: string;
+    outputFormat?: 'text' | 'stream-json' | 'json';
+    autoUpdate?: boolean;
+    temperature?: number;
+    httpProxy?: string;
+    /**
+     * Extensions configuration for third-party custom agents.
+     * Allows arbitrary nested configuration without validation.
+     */
+    extensions?: Record<string, any>;
+    /**
+     * Tools configuration for enabling/disabling specific tools.
+     * Key is the tool name, value is boolean (false to disable).
+     */
+    tools?: Record<string, boolean>;
+    /**
+     * Agent configuration for customizing agent behavior per agent type.
+     * Example: { explore: { model: "anthropic/claude-haiku-4" } }
+     */
+    agent?: Record<string, AgentConfig>;
+    /**
+     * Extra SKILL.md file paths for user-defined skills.
+     * Accepts absolute paths to SKILL.md files or directories containing SKILL.md.
+     * Example: ["/path/to/my-skill/SKILL.md", "/path/to/skill-dir"]
+     */
+    skills?: string[];
+    /**
+     * Notification configuration.
+     * - true: play default sound (Funk/warning)
+     * - false: disabled
+     * - string: custom sound name (e.g., "Glass", "Ping")
+     * - object: extended notification config (reserved for future use, e.g., url)
+     */
+    notification?: boolean | string;
+    /**
+     * Default thinking/reasoning effort level for models that support it.
+     * - 'low', 'medium', 'high', 'max', 'xhigh': Use specified level if supported
+     * - 'maxOrXhigh': Prefer xhigh if available, otherwise max
+     */
+    thinkingLevel?: 'low' | 'medium' | 'high' | 'max' | 'xhigh' | 'maxOrXhigh';
+    /**
+     * Controls whether rewind checkpoints are enabled.
+     * When enabled, snapshots are created after each AI response to allow
+     * rewinding to previous states with code restoration.
+     *
+     * @default true
+     */
+    checkpoints?: boolean;
+};
+
+declare type ConfigGetInput = {
+    cwd: string;
+    isGlobal: boolean;
+    key: string;
+};
+
+declare type ConfigGetOutput = {
+    success: boolean;
+    data: {
+        value: any;
+    };
+};
+
+declare type ConfigListInput = {
+    cwd: string;
+};
+
+declare type ConfigListOutput = {
+    success: boolean;
+    data: {
+        globalConfigDir: string;
+        projectConfigDir: string;
+        config: any;
+    };
+};
+
+export declare class _ConfigManager {
+    globalConfig: Partial<Config>;
+    projectConfig: Partial<Config>;
+    argvConfig: Partial<Config>;
+    globalConfigPath: string;
+    projectConfigPath: string;
+    constructor(cwd: string, productName: string, argvConfig: Partial<Config>);
+    get config(): Config;
+    removeConfig(global: boolean, key: string, values?: string[]): void;
+    addConfig(global: boolean, key: string, values: string[]): void;
+    getConfig(global: boolean, key: string): any;
+    setConfig(global: boolean, key: string, value: string): void;
+    updateConfig(global: boolean, newConfig: Partial<Config>): void;
+}
+
+declare type ConfigRemoveInput = {
+    cwd: string;
+    isGlobal: boolean;
+    key: string;
+    values?: string[];
+};
+
+declare type ConfigSetInput = {
+    cwd: string;
+    isGlobal: boolean;
+    key: string;
+    value: any;
+};
+
+export declare class Context {
+    #private;
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    config: Config;
+    paths: Paths;
+    argvConfig: Record<string, any>;
+    mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    fileHistoryManager: FileHistoryManager;
+    skillManager?: SkillManager;
+    messageBus?: MessageBus;
+    agentManager?: AgentManager;
+    plugins: (string | Plugin_2)[];
+    fetch?: typeof globalThis.fetch;
+    globalData: GlobalData;
+    constructor(opts: ContextOpts);
+    apply(applyOpts: Omit<PluginApplyOpts, 'pluginContext'>): Promise<any>;
+    destroy(): Promise<void>;
+    static create(opts: ContextCreateOpts): Promise<Context>;
+}
+
+declare type ContextCreateOpts = {
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    argvConfig: Record<string, any>;
+    plugins: (string | Plugin_2)[];
+    messageBus?: MessageBus;
+    fetch?: typeof globalThis.fetch;
+};
+
+declare type ContextOpts = {
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    config: Config;
+    pluginManager: PluginManager;
+    paths: Paths;
+    argvConfig: Record<string, any>;
+    mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    fileHistoryManager: FileHistoryManager;
+    skillManager?: SkillManager;
+    messageBus?: MessageBus;
+    agentManager?: AgentManager;
+    plugins: (string | Plugin_2)[];
+    fetch?: typeof globalThis.fetch;
+    globalData: GlobalData;
+};
+
+declare type CreateModel = (name: string, provider: Provider, options: {
+    globalConfigDir: string;
+    setGlobalConfig: (key: string, value: string, isGlobal: boolean) => void;
+    customFetch?: (url: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
+}) => Promise<LanguageModelV3> | LanguageModelV3;
+
+export declare function createSession(options: SDKSessionOptions): Promise<SDKSession>;
+
+declare interface CreateTaskInput {
+    command: string;
+    pid: number;
+    pgid?: number;
+}
+
+export declare function createTool<TSchema extends z.ZodTypeAny>(config: {
+    name: string;
+    displayName?: string;
+    description: string;
+    parameters: TSchema;
+    execute: (params: z.output<TSchema>, toolCallId?: string) => Promise<ToolResult> | ToolResult;
+    approval?: ToolApprovalInfo;
+    getDescription?: ({ params, cwd, }: {
+        params: z.output<TSchema>;
+        cwd: string;
+    }) => string;
+}): Tool<TSchema>;
+
+declare type DiffViewerReturnDisplay = {
+    type: 'diff_viewer';
+    originalContent: string | {
+        inputKey: string;
+    };
+    newContent: string | {
+        inputKey: string;
+    };
+    filePath: string;
+    [key: string]: any;
+};
+
+declare type Enforce = 'pre' | 'post';
+
+/** Standard error response */
+declare type ErrorResponse = {
+    success: false;
+    error: string;
+};
+
+declare type EventHandler = (data: any) => void;
+
+declare type EventMessage = BaseMessage & {
+    type: 'event';
+    event: string;
+    data: any;
+};
+
+/**
+ * Backup metadata for a single file
+ */
+declare type FileBackupMeta = {
+    /** Backup file name, format: {hash}@v{version}, null means file was deleted */
+    backupFileName: string | null;
+    /** Version number (incremental) */
+    version: number;
+    /** Backup time */
+    backupTime: Date;
+};
+
+/**
+ * File diff content for UI display
+ */
+declare type FileDiff = {
+    path: string;
+    oldContent: string;
+    newContent: string;
+};
+
+declare class FileHistory {
+    private cwd;
+    private sessionId;
+    private backupDir;
+    private snapshots;
+    private trackedFiles;
+    private pendingBackups;
+    constructor(opts: {
+        cwd: string;
+        sessionId: string;
+        backupRoot?: string;
+        snapshots?: Snapshot[];
+    });
+    /**
+     * Factory method: Create FileHistory instance from session data
+     */
+    static fromSession(opts: {
+        cwd: string;
+        sessionId: string;
+        snapshots: SerializedSnapshot_2[];
+        backupRoot?: string;
+    }): FileHistory;
+    /**
+     * Add file to tracking list and create immediate backup.
+     * Accepts either absolute path or relative path (relative to cwd).
+     *
+     * This should be called BEFORE the file is modified, so we backup the OLD content.
+     */
+    trackFile(filePath: string): void;
+    /**
+     * Track a new file (does not exist yet) before it gets created.
+     * Records backupFileName as null to indicate the file was newly created.
+     */
+    trackNewFile(filePath: string): void;
+    /**
+     * Check if message has a snapshot
+     */
+    hasSnapshot(messageId: string): boolean;
+    /**
+     * Generate backup file name: SHA256(relativePath).slice(0,16)@v{version}
+     */
+    private generateBackupFileName;
+    /**
+     * Detect if file has changed compared to backup (metadata-first)
+     */
+    private hasFileChanged;
+    /**
+     * Create file backup
+     */
+    private createBackup;
+    /**
+     * Check if there are pending backups waiting to be snapshotted.
+     * Use this to determine if a snapshot should be created for this turn.
+     */
+    hasPendingBackups(): boolean;
+    /**
+     * Create snapshot using pending backups created by trackFile.
+     * Only files with pending backups (modified this turn) are included.
+     * Returns null if no files were modified this turn.
+     */
+    createSnapshot(messageId: string): Snapshot | null;
+    /**
+     * Get all snapshot previews
+     */
+    getSnapshotPreviews(): SnapshotPreview_2[];
+    /**
+     * Calculate file diff using real line-by-line comparison
+     */
+    private calculateDiff;
+    /**
+     * Restore single file
+     */
+    private restoreFile;
+    /**
+     * Rewind to specified message's snapshot.
+     * Restores files to the state AT the target snapshot, reverting all changes
+     * made by snapshots after the target.
+     */
+    rewindToMessage(messageId: string, dryRun?: boolean): RewindResult_2;
+    /**
+     * Read file content safely, returns empty string if file doesn't exist
+     */
+    private readFileContent;
+    /**
+     * Get file contents for diff display
+     */
+    private getFileDiffContents;
+    /**
+     * Preview rewind (dry run)
+     * @param cumulative - If true, calculates changes from this point to current state (for UI display)
+     *                     If false, only shows changes in this specific snapshot
+     */
+    previewRewind(messageId: string, cumulative?: boolean): RewindResult_2;
+}
+
+declare class FileHistoryManager {
+    private instances;
+    private cwd;
+    private backupRoot;
+    constructor(opts: FileHistoryManagerOpts);
+    /**
+     * Gets or creates a FileHistory instance for the given sessionId.
+     * If sessionLogPath is provided, attempts to load existing snapshots from session.jsonl.
+     *
+     * @param sessionId - Session ID (can be main session or agent session like 'agent-xxx')
+     * @param sessionLogPath - Optional path to session.jsonl for loading existing snapshots
+     * @returns FileHistory instance for the session
+     */
+    getOrCreate(sessionId: string, sessionLogPath?: string): FileHistory;
+    /**
+     * Directly sets a FileHistory instance for a session.
+     * Used by snapshot.loadFromSession handler.
+     *
+     * @param sessionId - Session ID
+     * @param fileHistory - FileHistory instance to set
+     */
+    set(sessionId: string, fileHistory: FileHistory): void;
+    /**
+     * Gets a FileHistory instance without creating it.
+     * Returns undefined if no instance exists.
+     *
+     * @param sessionId - Session ID
+     * @returns FileHistory instance or undefined
+     */
+    get(sessionId: string): FileHistory | undefined;
+    /**
+     * Clears FileHistory instance(s).
+     *
+     * @param sessionId - Optional session ID. If provided, clears only that session.
+     *                    If not provided, clears all sessions.
+     */
+    clear(sessionId?: string): void;
+    /**
+     * Destroys all FileHistory instances.
+     * Called when the Context is destroyed.
+     */
+    destroy(): void;
+}
+
+declare interface FileHistoryManagerOpts {
+    cwd: string;
+    backupRoot: string;
+}
+
+declare type GitCloneInput = {
+    url: string;
+    destination: string;
+    taskId?: string;
+};
+
+declare type GitCloneOutput = {
+    success: boolean;
+    data?: {
+        clonePath: string;
+        repoName: string;
+    };
+    error?: string;
+    errorCode?: string;
+    needsCredentials?: boolean;
+};
+
+declare type GitCommitInput = {
+    cwd: string;
+    message: string;
+    noVerify?: boolean;
+};
+
+declare type GitCreateBranchInput = {
+    cwd: string;
+    name: string;
+};
+
+declare type GitCreateBranchOutput = {
+    success: boolean;
+    data?: {
+        branchName: string;
+        wasRenamed: boolean;
+    };
+    error?: string;
+};
+
+declare type GitCreatePRInput = {
+    cwd: string;
+    branchName: string;
+    body?: string;
+};
+
+declare type GitCreatePROutput = {
+    success: boolean;
+    data?: {
+        prUrl: string;
+    };
+    error?: string;
+};
+
+declare type GitDetectGitHubInput = {
+    cwd: string;
+};
+
+declare type GitDetectGitHubOutput = {
+    success: boolean;
+    data?: {
+        hasGhCli: boolean;
+        isGitHubRemote: boolean;
+    };
+    error?: string;
+};
+
+declare type GitPushInput = {
+    cwd: string;
+};
+
+declare type GitStageInput = {
+    cwd: string;
+    all?: boolean;
+};
+
+declare type GitStatusInput = {
+    cwd: string;
+};
+
+declare type GitStatusOutput = {
+    success: boolean;
+    data?: {
+        isRepo: boolean;
+        hasUncommittedChanges: boolean;
+        hasStagedChanges: boolean;
+        isGitInstalled: boolean;
+        isUserConfigured: {
+            name: boolean;
+            email: boolean;
+        };
+        isMerging: boolean;
+        unstagedFiles: Array<{
+            status: string;
+            file: string;
+        }>;
+    };
+    error?: string;
+};
+
+declare class GlobalData {
+    private globalDataPath;
+    constructor({ globalDataPath }: {
+        globalDataPath: string;
+    });
+    private readData;
+    private writeData;
+    getProjectHistory({ cwd }: {
+        cwd: string;
+    }): string[];
+    addProjectHistory({ cwd, history }: {
+        cwd: string;
+        history: string;
+    }): void;
+    getProjectLastAccessed({ cwd }: {
+        cwd: string;
+    }): number | null;
+    updateProjectLastAccessed({ cwd }: {
+        cwd: string;
+    }): void;
+    getRecentModels(): string[];
+    addRecentModel(model: string): void;
+}
+
+declare type GlobalDataRecentModelsAddInput = {
+    cwd: string;
+    model: string;
+};
+
+declare type GlobalDataRecentModelsGetInput = {
+    cwd: string;
+};
+
+declare type GlobalDataRecentModelsGetOutput = {
+    success: boolean;
+    data: {
+        recentModels: string[];
+        thinkingLevel: string | undefined;
+    };
+};
+
+/**
+ * Central type registry for all message bus handlers.
+ * Maps handler method names to their input and output types.
+ */
+declare type HandlerMap = {
+    'globalData.recentModels.get': {
+        input: GlobalDataRecentModelsGetInput;
+        output: GlobalDataRecentModelsGetOutput;
+    };
+    'globalData.recentModels.add': {
+        input: GlobalDataRecentModelsAddInput;
+        output: SuccessResponse;
+    };
+    'config.get': {
+        input: ConfigGetInput;
+        output: ConfigGetOutput;
+    };
+    'config.set': {
+        input: ConfigSetInput;
+        output: SuccessResponse;
+    };
+    'config.remove': {
+        input: ConfigRemoveInput;
+        output: SuccessResponse;
+    };
+    'config.list': {
+        input: ConfigListInput;
+        output: ConfigListOutput;
+    };
+    'git.clone': {
+        input: GitCloneInput;
+        output: GitCloneOutput;
+    };
+    'git.clone.cancel': {
+        input: {
+            taskId: string;
+        };
+        output: SuccessResponse;
+    };
+    'git.status': {
+        input: GitStatusInput;
+        output: GitStatusOutput;
+    };
+    'git.stage': {
+        input: GitStageInput;
+        output: SuccessResponse | ErrorResponse;
+    };
+    'git.commit': {
+        input: GitCommitInput;
+        output: SuccessResponse | ErrorResponse;
+    };
+    'git.push': {
+        input: GitPushInput;
+        output: SuccessResponse | ErrorResponse;
+    };
+    'git.createBranch': {
+        input: GitCreateBranchInput;
+        output: GitCreateBranchOutput;
+    };
+    'git.detectGitHub': {
+        input: GitDetectGitHubInput;
+        output: GitDetectGitHubOutput;
+    };
+    'git.createPR': {
+        input: GitCreatePRInput;
+        output: GitCreatePROutput;
+    };
+    'mcp.getStatus': {
+        input: McpGetStatusInput;
+        output: McpGetStatusOutput;
+    };
+    'mcp.reconnect': {
+        input: McpReconnectInput;
+        output: McpReconnectOutput;
+    };
+    'mcp.list': {
+        input: McpListInput;
+        output: McpListOutput;
+    };
+    'models.list': {
+        input: ModelsListInput;
+        output: ModelsListOutput;
+    };
+    'models.test': {
+        input: ModelsTestInput;
+        output: ModelsTestOutput;
+    };
+    'outputStyles.list': {
+        input: OutputStylesListInput;
+        output: OutputStylesListOutput;
+    };
+    'project.addHistory': {
+        input: ProjectAddHistoryInput;
+        output: SuccessResponse;
+    };
+    'project.clearContext': {
+        input: ProjectClearContextInput;
+        output: SuccessResponse;
+    };
+    'project.addMemory': {
+        input: ProjectAddMemoryInput;
+        output: SuccessResponse;
+    };
+    'project.analyzeContext': {
+        input: ProjectAnalyzeContextInput;
+        output: ProjectAnalyzeContextOutput;
+    };
+    'project.getRepoInfo': {
+        input: ProjectGetRepoInfoInput;
+        output: ProjectGetRepoInfoOutput;
+    };
+    'project.workspaces.list': {
+        input: ProjectWorkspacesListInput;
+        output: ProjectWorkspacesListOutput;
+    };
+    'project.workspaces.get': {
+        input: ProjectWorkspacesGetInput;
+        output: ProjectWorkspacesGetOutput;
+    };
+    'project.workspaces.create': {
+        input: ProjectWorkspacesCreateInput;
+        output: ProjectWorkspacesCreateOutput;
+    };
+    'project.workspaces.delete': {
+        input: ProjectWorkspacesDeleteInput;
+        output: ProjectWorkspacesDeleteOutput;
+    };
+    'project.workspaces.merge': {
+        input: ProjectWorkspacesMergeInput;
+        output: ProjectWorkspacesMergeOutput;
+    };
+    'project.workspaces.createGithubPR': {
+        input: ProjectWorkspacesCreateGithubPRInput;
+        output: ProjectWorkspacesCreateGithubPROutput;
+    };
+    'project.generateCommit': {
+        input: ProjectGenerateCommitInput;
+        output: ProjectGenerateCommitOutput;
+    };
+    'projects.list': {
+        input: ProjectsListInput;
+        output: ProjectsListOutput;
+    };
+    'providers.list': {
+        input: ProvidersListInput;
+        output: ProvidersListOutput;
+    };
+    'providers.login.initOAuth': {
+        input: ProvidersLoginInitOAuthInput;
+        output: ProvidersLoginInitOAuthOutput;
+    };
+    'providers.login.completeOAuth': {
+        input: ProvidersLoginCompleteOAuthInput;
+        output: ProvidersLoginCompleteOAuthOutput;
+    };
+    'providers.login.status': {
+        input: ProvidersLoginStatusInput;
+        output: ProvidersLoginStatusOutput;
+    };
+    'providers.login.pollOAuth': {
+        input: ProvidersLoginPollOAuthInput;
+        output: ProvidersLoginPollOAuthOutput;
+    };
+    'session.initialize': {
+        input: SessionInitializeInput;
+        output: SessionInitializeOutput;
+    };
+    'session.messages.list': {
+        input: SessionMessagesListInput;
+        output: SessionMessagesListOutput;
+    };
+    'session.export': {
+        input: SessionExportSessionMarkdownInput;
+        output: SessionExportSessionMarkdownOutput;
+    };
+    'session.getModel': {
+        input: SessionGetModelInput;
+        output: SessionGetModelOutput;
+    };
+    'session.send': {
+        input: SessionSendInput;
+        output: SessionSendOutput;
+    };
+    'session.cancel': {
+        input: SessionCancelInput;
+        output: SuccessResponse;
+    };
+    'session.addMessages': {
+        input: SessionAddMessagesInput;
+        output: SuccessResponse;
+    };
+    'session.compact': {
+        input: SessionCompactInput;
+        output: SessionCompactOutput;
+    };
+    'session.config.setApprovalMode': {
+        input: SessionConfigSetApprovalModeInput;
+        output: SuccessResponse;
+    };
+    'session.config.addApprovalTools': {
+        input: SessionConfigAddApprovalToolsInput;
+        output: SuccessResponse;
+    };
+    'session.config.setSummary': {
+        input: SessionConfigSetSummaryInput;
+        output: SuccessResponse;
+    };
+    'session.config.setPastedTextMap': {
+        input: SessionConfigSetPastedTextMapInput;
+        output: SuccessResponse;
+    };
+    'session.config.setPastedImageMap': {
+        input: SessionConfigSetPastedImageMapInput;
+        output: SuccessResponse;
+    };
+    'session.config.getAdditionalDirectories': {
+        input: SessionConfigGetAdditionalDirectoriesInput;
+        output: SessionConfigGetAdditionalDirectoriesOutput;
+    };
+    'session.config.addDirectory': {
+        input: SessionConfigAddDirectoryInput;
+        output: SuccessResponse;
+    };
+    'session.config.removeDirectory': {
+        input: SessionConfigRemoveDirectoryInput;
+        output: SuccessResponse;
+    };
+    'session.config.set': {
+        input: SessionConfigSetInput;
+        output: SuccessResponse;
+    };
+    'session.config.get': {
+        input: SessionConfigGetInput;
+        output: SessionConfigGetOutput;
+    };
+    'session.config.remove': {
+        input: SessionConfigRemoveInput;
+        output: SuccessResponse;
+    };
+    'sessions.remove': {
+        input: SessionsRemoveInput;
+        output: SessionsRemoveOutput;
+    };
+    'sessions.list': {
+        input: SessionsListInput;
+        output: SessionsListOutput;
+    };
+    'sessions.resume': {
+        input: SessionsResumeInput;
+        output: SessionsResumeOutput;
+    };
+    'skills.list': {
+        input: SkillsListInput;
+        output: SkillsListOutput;
+    };
+    'skills.get': {
+        input: SkillsGetInput;
+        output: SkillsGetOutput;
+    };
+    'skills.add': {
+        input: SkillsAddInput;
+        output: SkillsAddOutput;
+    };
+    'skills.remove': {
+        input: SkillsRemoveInput;
+        output: SkillsRemoveOutput;
+    };
+    'skills.preview': {
+        input: SkillsPreviewInput;
+        output: SkillsPreviewOutput;
+    };
+    'skills.install': {
+        input: SkillsInstallInput;
+        output: SkillsInstallOutput;
+    };
+    'slashCommand.list': {
+        input: SlashCommandListInput;
+        output: SlashCommandListOutput;
+    };
+    'slashCommand.get': {
+        input: SlashCommandGetInput;
+        output: SlashCommandGetOutput;
+    };
+    'slashCommand.execute': {
+        input: SlashCommandExecuteInput;
+        output: SlashCommandExecuteOutput;
+    };
+    'status.get': {
+        input: StatusGetInput;
+        output: StatusGetOutput;
+    };
+    'utils.query': {
+        input: UtilsQueryInput;
+        output: UtilsQueryOutput;
+    };
+    'utils.quickQuery': {
+        input: UtilsQuickQueryInput;
+        output: UtilsQuickQueryOutput;
+    };
+    'utils.summarizeMessage': {
+        input: UtilsSummarizeMessageInput;
+        output: UtilsSummarizeMessageOutput;
+    };
+    'utils.getPaths': {
+        input: UtilsGetPathsInput;
+        output: UtilsGetPathsOutput;
+    };
+    'utils.searchPaths': {
+        input: UtilsSearchPathsInput;
+        output: UtilsSearchPathsOutput;
+    };
+    'utils.telemetry': {
+        input: UtilsTelemetryInput;
+        output: SuccessResponse;
+    };
+    'utils.files.list': {
+        input: UtilsFilesListInput;
+        output: UtilsFilesListOutput;
+    };
+    'utils.tool.executeBash': {
+        input: UtilsToolExecuteBashInput;
+        output: UtilsToolExecuteBashOutput;
+    };
+    'utils.open': {
+        input: UtilsOpenInput;
+        output: SuccessResponse;
+    };
+    'utils.detectApps': {
+        input: UtilsDetectAppsInput;
+        output: UtilsDetectAppsOutput;
+    };
+    'utils.playSound': {
+        input: UtilsPlaySoundInput;
+        output: UtilsPlaySoundOutput;
+    };
+    'utils.notify': {
+        input: UtilsNotifyInput;
+        output: UtilsNotifyOutput;
+    };
+    toolApproval: {
+        input: ToolApprovalInput;
+        output: ToolApprovalOutput;
+    };
+    'snapshot.trackFile': {
+        input: SnapshotTrackFileInput;
+        output: SuccessResponse;
+    };
+    'snapshot.create': {
+        input: SnapshotCreateInput;
+        output: SnapshotCreateOutput;
+    };
+    'snapshot.list': {
+        input: SnapshotListInput;
+        output: SnapshotListOutput;
+    };
+    'snapshot.has': {
+        input: SnapshotHasInput;
+        output: SnapshotHasOutput;
+    };
+    'snapshot.rewind': {
+        input: SnapshotRewindInput;
+        output: SnapshotRewindOutput;
+    };
+    'snapshot.previewRewind': {
+        input: SnapshotPreviewRewindInput;
+        output: SnapshotPreviewRewindOutput;
+    };
+    'snapshot.loadFromSession': {
+        input: SnapshotLoadFromSessionInput;
+        output: SuccessResponse;
+    };
+};
+
+declare type ImagePart = {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+
+declare type Interleaved = {
+    tagName?: string;
+    separator?: string;
+    startWithReasoning?: boolean;
+};
+
+declare interface LocalCommand extends BaseSlashCommand {
+    type: 'local';
+    call(args: string, context: Context): Promise<string>;
+}
+
+declare interface LocalJSXCommand extends BaseSlashCommand {
+    type: 'local-jsx';
+    call(onDone: (result: string | null) => void, context: Context, args?: string): Promise<React.ReactNode>;
+}
+
+declare type LoopResult = {
+    success: true;
+    data: Record<string, any>;
+    metadata: {
+        turnsCount: number;
+        toolCallsCount: number;
+        duration: number;
+    };
+} | {
+    success: false;
+    error: {
+        type: 'tool_denied' | 'max_turns_exceeded' | 'api_error' | 'canceled';
+        message: string;
+        details?: Record<string, any>;
+    };
+};
+
+declare interface MCPConfig {
+    type?: 'stdio' | 'sse' | 'http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    disable?: boolean;
+    /**
+     * The timeout for tool calls in milliseconds.
+     */
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+
+declare type McpGetStatusInput = {
+    cwd: string;
+};
+
+declare type McpGetStatusOutput = {
+    success: boolean;
+    error?: string;
+    data: {
+        servers: Record<string, {
+            status: string;
+            error?: string;
+            toolCount: number;
+            tools: string[];
+        }>;
+        configs: Record<string, McpServerConfig>;
+        globalConfigPath: string;
+        projectConfigPath: string;
+        isReady: boolean;
+        isLoading: boolean;
+    };
+};
+
+declare type McpHttpServerConfig = {
+    type: 'http';
+    url: string;
+    disable?: boolean;
+    headers?: Record<string, string>;
+};
+
+declare type McpListInput = {
+    cwd: string;
+};
+
+declare type McpListOutput = {
+    success: boolean;
+    data: {
+        projectServers: Record<string, McpServerConfig>;
+        globalServers: Record<string, McpServerConfig>;
+        activeServers: Record<string, {
+            status: 'pending' | 'connecting' | 'connected' | 'failed' | 'disconnected';
+            config: McpServerConfig;
+            error?: string;
+            toolCount?: number;
+            tools: string[];
+            scope: 'global' | 'project';
+        }>;
+        projectConfigPath: string;
+        globalConfigPath: string;
+        isReady: boolean;
+        isLoading: boolean;
+    };
+};
+
+declare class MCPManager {
+    #private;
+    private servers;
+    private configs;
+    private isInitialized;
+    private initPromise?;
+    private initLock;
+    static create(mcpServers: Record<string, MCPConfig>): MCPManager;
+    initAsync(): Promise<void>;
+    private _performInit;
+    private _connectServer;
+    getAllTools(): Promise<Tool[]>;
+    getTools(keys: string[]): Promise<Tool[]>;
+    destroy(): Promise<void>;
+    getServerNames(): string[];
+    hasServer(name: string): boolean;
+    getServerStatus(name: string): MCPServerStatus | undefined;
+    getServerError(name: string): string | undefined;
+    getAllServerStatus(): Promise<Record<string, {
+        status: MCPServerStatus;
+        error?: string;
+        toolCount: number;
+    }>>;
+    isReady(): boolean;
+    isLoading(): boolean;
+    retryConnection(serverName: string): Promise<void>;
+    private _createClient;
+    private _testConnectionAndFetchTools;
+    private _isTemporaryError;
+}
+
+declare type McpReconnectInput = {
+    cwd: string;
+    serverName: string;
+};
+
+declare type McpReconnectOutput = {
+    success: boolean;
+    message?: string;
+    error?: string;
+};
+
+declare type McpServerConfig = McpStdioServerConfig | McpSSEServerConfig | McpHttpServerConfig;
+
+declare type MCPServerStatus = 'pending' | 'connecting' | 'connected' | 'failed' | 'disconnected';
+
+declare type McpSSEServerConfig = {
+    type: 'sse';
+    url: string;
+    disable?: boolean;
+    headers?: Record<string, string>;
+};
+
+declare type McpStdioServerConfig = {
+    type: 'stdio';
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    disable?: boolean;
+};
+
+declare type Message = RequestMessage | ResponseMessage | EventMessage;
+
+declare type Message_2 = SystemMessage | UserMessage | AssistantMessage | ToolMessage | ToolMessage2;
+
+declare class MessageBus extends EventEmitter {
+    messageHandlers: Map<string, MessageHandler>;
+    private transport?;
+    private pendingRequests;
+    private eventHandlers;
+    constructor();
+    setTransport(transport: MessageTransport): void;
+    isConnected(): boolean;
+    request<K extends keyof HandlerMap>(method: K, params: HandlerMap[K]['input'], options?: {
+        timeout?: number;
+    }): Promise<HandlerMap[K]['output']>;
+    request(method: string, params: any, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    registerHandler<K extends keyof HandlerMap>(method: K, handler: (data: HandlerMap[K]['input']) => Promise<HandlerMap[K]['output']>): void;
+    registerHandler(method: string, handler: MessageHandler): void;
+    unregisterHandler(method: string): void;
+    emitEvent(event: string, data: any): Promise<void>;
+    onEvent(event: string, handler: EventHandler): void;
+    offEvent(event: string, handler: EventHandler): void;
+    private handleIncomingMessage;
+    private handleRequest;
+    private handleResponse;
+    private handleEvent;
+    private sendResponse;
+}
+
+declare type MessageHandler = (data: any) => Promise<any>;
+
+declare type MessageId = string;
+
+declare interface MessageTransport {
+    send: (message: Message) => Promise<void>;
+    onMessage: (handler: (message: Message) => void) => void;
+    onError: (handler: (error: Error) => void) => void;
+    onClose: (handler: () => void) => void;
+    close: () => Promise<void>;
+    isConnected: () => boolean;
+}
+
+declare interface Model {
+    id: string;
+    name: string;
+    shortName?: string;
+    attachment: boolean;
+    reasoning: boolean;
+    temperature: boolean;
+    tool_call: boolean;
+    knowledge: string;
+    release_date: string;
+    last_updated: string;
+    modalities: ModelModalities;
+    open_weights: boolean;
+    cost: ModelCost;
+    limit: ModelLimit;
+    aliases?: string[];
+    apiFormat?: ApiFormat;
+    createModel?: CreateModel;
+    interleaved?: Interleaved;
+    variants?: Record<string, any>;
+}
+
+declare type ModelAlias = Record<string, string>;
+
+declare interface ModelCost {
+    input: number;
+    output: number;
+    cache_read?: number;
+    cache_write?: number;
+}
+
+declare type ModelInfo = {
+    provider: Provider;
+    model: Omit<Model, 'cost'>;
+    _mCreator: (hooks?: {
+        onRequest?: UtilsOnRequestHook;
+        onResponse?: UtilsOnResponseHook;
+    }) => Promise<LanguageModelV3>;
+};
+
+declare interface ModelLimit {
+    context: number;
+    output: number;
+}
+
+declare type ModelMap = Record<string, Omit<Model, 'id' | 'cost'>>;
+
+declare interface ModelModalities {
+    input: ('text' | 'image' | 'audio' | 'video' | 'pdf')[];
+    output: ('text' | 'audio' | 'image')[];
+}
+
+declare type ModelsListInput = {
+    cwd: string;
+};
+
+declare type ModelsListOutput = {
+    success: boolean;
+    data: {
+        groupedModels: Array<{
+            provider: string;
+            providerId: string;
+            isActive: boolean;
+            models: Array<{
+                name: string;
+                modelId: string;
+                value: string;
+            }>;
+        }>;
+        currentModel: any;
+        currentModelInfo: {
+            providerName: string;
+            modelName: string;
+            modelId: string;
+            modelContextLimit: number;
+        } | null;
+        nullModels: Array<{
+            providerId: string;
+            modelId: string;
+        }>;
+        recentModels: string[];
+        thinkingLevel: string | undefined;
+    };
+};
+
+declare type ModelsTestInput = {
+    cwd?: string;
+    model: string;
+    timeout?: number;
+    prompt?: string;
+};
+
+declare type ModelsTestOutput = {
+    success: true;
+    data: {
+        model: string;
+        provider: string;
+        modelName: string;
+        prompt: string;
+        response: string;
+        responseTime: number;
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+        } | null;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type NodeBridgeHandlers = Partial<{
+    [K in keyof HandlerMap]: (data: HandlerMap[K]['input'], context: Context) => Promise<HandlerMap[K]['output']> | HandlerMap[K]['output'];
+}>;
+
+declare type NormalizedMessage = Message_2 & {
+    type: 'message';
+    timestamp: string;
+    uuid: string;
+    parentUuid: string | null;
+    uiContent?: string;
+    metadata?: {
+        agentId?: string;
+        agentType?: string;
+        [key: string]: any;
+    };
+};
+
+declare class OutputStyle {
+    name: string;
+    description: string;
+    isCodingRelated: boolean;
+    prompt: string;
+    constructor(opts: OutputStyleOpts);
+    isDefault(): boolean;
+}
+
+declare type OutputStyleOpts = {
+    name: string;
+    description: string;
+    isCodingRelated: boolean;
+    prompt: string;
+};
+
+declare type OutputStylesListInput = {
+    cwd: string;
+};
+
+declare type OutputStylesListOutput = {
+    success: boolean;
+    data: {
+        outputStyles: Array<{
+            name: string;
+            description: string;
+        }>;
+        currentOutputStyle: any;
+    };
+};
+
+export declare function parseArgs(argv: any): Promise<Argv>;
+
+declare class Paths {
+    globalConfigDir: string;
+    globalProjectDir: string;
+    projectConfigDir: string;
+    fileHistoryDir: string;
+    constructor(opts: {
+        productName: string;
+        cwd: string;
+    });
+    getSessionLogPath(sessionId: string): string;
+    getLatestSessionId(): string | undefined;
+    getAllSessions(): {
+        sessionId: string;
+        modified: Date;
+        created: Date;
+        messageCount: number;
+        summary: string;
+    }[];
+    getGlobalDataPath(): string;
+}
+
+declare type PlanModeExitReturnDisplay = {
+    type: 'plan_mode_exit';
+    planFilePath: string;
+    planContent: string | null;
+    isAgent: boolean;
+    scenario: 'approved_with_plan' | 'approved_without_plan' | 'agent_completed';
+};
+
+declare type Plugin_2 = {
+    enforce?: Enforce;
+    name?: string;
+    config?: (this: TempPluginContext, opts: {
+        config: Config;
+        argvConfig: Record<string, any>;
+    }) => Partial<Config> | Promise<Partial<Config>>;
+    slashCommand?: (this: PluginContext) => Promise<SlashCommand[]> | SlashCommand[];
+    skill?: (this: PluginContext) => Promise<string[]> | string[];
+    outputStyle?: (this: PluginContext) => Promise<OutputStyle[]> | OutputStyle[];
+    provider?: (this: PluginContext, providers: ProvidersMap, opts: {
+        models: ModelMap;
+        defaultModelCreator: (name: string, provider: Provider) => LanguageModelV3;
+        createOpenAI: (options: any) => OpenAIProvider;
+        createOpenAICompatible: (options: any) => OpenAICompatibleProvider;
+        createAnthropic: (options: any) => AnthropicProvider;
+    }) => Promise<ProvidersMap> | ProvidersMap;
+    modelAlias?: (this: PluginContext, modelAlias: ModelAlias) => Promise<ModelAlias> | ModelAlias;
+    initialized?: (this: PluginContext, opts: {
+        cwd: string;
+        quiet: boolean;
+    }) => Promise<void> | void;
+    destroy?: (this: PluginContext) => Promise<void> | void;
+    context?: (this: PluginContext, opts: {
+        userPrompt: string | null;
+        sessionId: string;
+    }) => Promise<Record<string, string> | {}> | Record<string, string> | {};
+    env?: (this: PluginContext, opts: {
+        userPrompt: string | null;
+        sessionId: string;
+    }) => Promise<Record<string, string> | {}> | Record<string, string> | {};
+    userPrompt?: (this: PluginContext, userPrompt: string, opts: {
+        sessionId: string;
+    }) => Promise<string> | string;
+    systemPrompt?: (this: PluginContext, systemPrompt: string, opts: {
+        isPlan?: boolean;
+        sessionId: string;
+    }) => Promise<string> | string;
+    tool?: (this: PluginContext, opts: {
+        isPlan?: boolean;
+        sessionId: string;
+    }) => Promise<Tool[]> | Tool[];
+    toolUse?: (this: PluginContext, toolUse: ToolUse, opts: {
+        sessionId: string;
+    }) => Promise<ToolUse> | ToolUse;
+    toolResult?: (this: PluginContext, toolResult: ToolResult, opts: {
+        toolUse: ToolUse;
+        approved: boolean;
+        sessionId: string;
+    }) => Promise<ToolResult> | ToolResult;
+    query?: (this: PluginContext, opts: {
+        usage: Usage;
+        startTime: Date;
+        endTime: Date;
+        sessionId: string;
+    }) => Promise<void> | void;
+    conversation?: (this: PluginContext, opts: {
+        userPrompt: string | null;
+        result: LoopResult;
+        startTime: Date;
+        endTime: Date;
+        sessionId: string;
+    }) => Promise<void> | void;
+    status?: (this: PluginContext) => Promise<Status> | Status;
+    agent?: (this: PluginContext) => Promise<PluginAgentDefinition[]> | PluginAgentDefinition[];
+    telemetry?: (this: PluginContext, opts: {
+        name: string;
+        payload: Record<string, any>;
+    }) => Promise<void> | void;
+    stop?: (this: PluginContext, opts: {
+        sessionId: string;
+        result: LoopResult;
+        usage: Usage;
+        turnsCount: number;
+        toolCallsCount: number;
+        duration: number;
+        model: string;
+    }) => Promise<void> | void;
+    subagentStop?: (this: PluginContext, opts: {
+        parentSessionId: string;
+        agentId: string;
+        agentType: string;
+        result: AgentExecutionResult;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        totalToolCalls: number;
+        totalDuration: number;
+        model: string;
+    }) => Promise<void> | void;
+    nodeBridgeHandler?: (this: PluginContext) => Promise<NodeBridgeHandlers> | NodeBridgeHandlers;
+};
+export { Plugin_2 as Plugin }
+
+declare type PluginAgentDefinition = Omit<AgentDefinition, 'source' | 'model'> & {
+    model?: string;
+};
+
+declare type PluginApplyOpts = {
+    hook: keyof Plugin_2;
+    args: any[];
+    memo?: any;
+    type: PluginHookType;
+    pluginContext: any;
+};
+
+declare type PluginContext = Context;
+
+declare enum PluginHookType {
+    First = "first",
+    Series = "series",
+    SeriesMerge = "seriesMerge",
+    SeriesLast = "seriesLast",
+    Parallel = "parallel"
+}
+
+declare class PluginManager {
+    #private;
+    constructor(rawPlugins: Plugin_2[]);
+    apply({ hook, args, memo, type, pluginContext, }: PluginApplyOpts): Promise<any>;
+}
+
+declare interface PreviewSkillsResult {
+    tempDir: string;
+    skills: SkillPreview[];
+    errors: SkillError[];
+}
+
+declare type ProjectAddHistoryInput = {
+    cwd: string;
+    history: string;
+};
+
+declare type ProjectAddMemoryInput = {
+    cwd: string;
+    global: boolean;
+    rule: string;
+};
+
+declare type ProjectAnalyzeContextInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type ProjectAnalyzeContextOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        systemPrompt: {
+            tokens: number;
+            percentage: number;
+        };
+        systemTools: {
+            tokens: number;
+            percentage: number;
+        };
+        mcpTools: {
+            tokens: number;
+            percentage: number;
+        };
+        messages: {
+            tokens: number;
+            percentage: number;
+        };
+        freeSpace: {
+            tokens: number;
+            percentage: number;
+        };
+        totalContextWindow: number;
+    };
+};
+
+declare type ProjectClearContextInput = {
+    cwd?: string;
+};
+
+declare type ProjectGenerateCommitInput = {
+    cwd: string;
+    language?: string;
+    systemPrompt?: string;
+    model?: string;
+    diff?: string;
+    fileList?: string;
+};
+
+declare type ProjectGenerateCommitOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        commitMessage: string;
+        branchName: string;
+        isBreakingChange: boolean;
+        summary: string;
+    };
+};
+
+declare type ProjectGetRepoInfoInput = {
+    cwd: string;
+};
+
+declare type ProjectGetRepoInfoOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        repoData: {
+            path: string;
+            name: string;
+            workspaceIds: string[];
+            metadata: {
+                lastAccessed: number;
+                settings: any;
+            };
+            gitRemote?: {
+                originUrl: string | null;
+                defaultBranch: string | null;
+            };
+        };
+        timings?: Record<string, number>;
+    };
+};
+
+declare type ProjectsListInput = {
+    cwd: string;
+    includeSessionDetails?: boolean;
+};
+
+declare type ProjectsListOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        projects: Array<{
+            path: string;
+            lastAccessed: number | null;
+            sessionCount: number;
+            sessions?: Array<{
+                sessionId: string;
+                modified: Date;
+                created: Date;
+                messageCount: number;
+                summary: string;
+            }>;
+        }>;
+    };
+};
+
+declare type ProjectWorkspacesCreateGithubPRInput = {
+    cwd: string;
+    name: string;
+    title?: string;
+    description?: string;
+    baseBranch?: string;
+};
+
+declare type ProjectWorkspacesCreateGithubPROutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        prUrl: string;
+        prNumber: number;
+    };
+};
+
+declare type ProjectWorkspacesCreateInput = {
+    cwd: string;
+    name?: string;
+    skipUpdate?: boolean;
+};
+
+declare type ProjectWorkspacesCreateOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        workspace: {
+            name: string;
+            path: string;
+            branch: string;
+        };
+    };
+};
+
+declare type ProjectWorkspacesDeleteInput = {
+    cwd: string;
+    name: string;
+    force?: boolean;
+};
+
+declare type ProjectWorkspacesDeleteOutput = {
+    success: boolean;
+    error?: string;
+};
+
+declare type ProjectWorkspacesGetInput = {
+    cwd: string;
+    workspaceId: string;
+};
+
+declare type ProjectWorkspacesGetOutput = {
+    success: boolean;
+    error?: string;
+    data?: WorkspaceData;
+};
+
+declare type ProjectWorkspacesListInput = {
+    cwd: string;
+};
+
+declare type ProjectWorkspacesListOutput = {
+    success: boolean;
+    error?: string;
+    data?: {
+        workspaces: WorkspaceData[];
+    };
+};
+
+declare type ProjectWorkspacesMergeInput = {
+    cwd: string;
+    name: string;
+};
+
+declare type ProjectWorkspacesMergeOutput = {
+    success: boolean;
+    error?: string;
+};
+
+declare function prompt_2(message: string, options: SDKSessionOptions): Promise<SDKResultMessage>;
+export { prompt_2 as prompt }
+
+declare interface PromptCommand extends BaseSlashCommand {
+    type: 'prompt';
+    progressMessage?: string;
+    model?: string;
+    getPromptForCommand(args: string): Promise<Array<{
+        role: string;
+        content: string;
+    }>>;
+}
+
+declare interface Provider {
+    id: string;
+    env: string[];
+    name: string;
+    apiEnv?: string[];
+    api?: string;
+    doc: string;
+    models: Record<string, ProviderModel>;
+    createModel?: CreateModel;
+    apiFormat?: ApiFormat;
+    options?: {
+        baseURL?: string;
+        apiKey?: string;
+        headers?: Record<string, string>;
+        httpProxy?: string;
+    };
+    source?: 'built-in' | string;
+    headers?: Record<string, string>;
+    middlewares?: LanguageModelMiddleware[];
+    interleaved?: Interleaved;
+}
+
+export declare type ProviderConfig = Partial<Omit<Provider, 'createModel'>>;
+
+declare type ProviderModel = string | Partial<Model>;
+
+declare type ProvidersListInput = {
+    cwd: string;
+};
+
+declare type ProvidersListOutput = {
+    success: boolean;
+    data: {
+        providers: Array<{
+            id: string;
+            name: string;
+            doc?: string;
+            env?: string[];
+            apiEnv?: string[];
+            api?: string;
+            apiFormat?: 'anthropic' | 'openai' | 'responses';
+            source?: 'built-in' | string;
+            options?: {
+                baseURL?: string;
+                apiKey?: string;
+                headers?: Record<string, string>;
+                httpProxy?: string;
+            };
+            validEnvs: string[];
+            hasApiKey: boolean;
+            maskedApiKey?: string;
+            apiKeyOrigin?: 'env' | 'config';
+            apiKeyEnvName?: string;
+            oauthUser?: string;
+        }>;
+    };
+};
+
+declare type ProvidersLoginCompleteOAuthInput = {
+    cwd: string;
+    providerId: 'github-copilot' | 'qwen' | 'codex';
+    oauthSessionId: string;
+    code: string;
+};
+
+declare type ProvidersLoginCompleteOAuthOutput = {
+    success: true;
+    data: {
+        user?: string;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type ProvidersLoginInitOAuthInput = {
+    cwd: string;
+    providerId: 'github-copilot' | 'qwen' | 'codex';
+    timeout?: number;
+};
+
+declare type ProvidersLoginInitOAuthOutput = {
+    success: true;
+    data: {
+        authUrl: string;
+        userCode?: string;
+        oauthSessionId: string;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type ProvidersLoginPollOAuthInput = {
+    cwd: string;
+    oauthSessionId: string;
+};
+
+declare type ProvidersLoginPollOAuthOutput = {
+    success: true;
+    data: {
+        status: 'pending' | 'completed' | 'error';
+        user?: string;
+        error?: string;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type ProvidersLoginStatusInput = {
+    cwd: string;
+    providerId: string;
+};
+
+declare type ProvidersLoginStatusOutput = {
+    success: true;
+    data: {
+        isLoggedIn: boolean;
+        user?: string;
+    };
+};
+
+declare type ProvidersMap = Record<string, Provider>;
+
+export declare function _query(opts: {
+    userPrompt: string;
+    messages?: NormalizedMessage[];
+    context?: Context;
+    model?: ModelInfo;
+    systemPrompt?: string;
+    onMessage?: (message: NormalizedMessage) => Promise<void>;
+    thinking?: ThinkingConfig | false;
+    responseFormat?: ResponseFormat;
+}): Promise<LoopResult>;
+
+declare type ReasoningEffort = 'low' | 'medium' | 'high' | 'max' | 'xhigh';
+
+declare type ReasoningPart = {
+    type: 'reasoning';
+    text: string;
+};
+
+declare type RequestMessage = BaseMessage & {
+    type: 'request';
+    method: string;
+    params: any;
+};
+
+declare type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json';
+    schema?: any;
+    name?: string;
+    description?: string;
+};
+
+declare type ResponseMessage = BaseMessage & {
+    type: 'response';
+    result?: any;
+    error?: any;
+};
+
+export declare function resumeSession(sessionId: string, options: SDKSessionOptions): Promise<SDKSession>;
+
+declare type ReturnDisplay = string | DiffViewerReturnDisplay | TodoWriteReturnDisplay | AgentResultReturnDisplay | PlanModeExitReturnDisplay;
+
+declare type RewindResult = {
+    success: boolean;
+    error?: string;
+    filesChanged: string[];
+    insertions: number;
+    deletions: number;
+};
+
+/**
+ * Rewind operation result
+ */
+declare type RewindResult_2 = {
+    success: boolean;
+    error?: string;
+    /** List of restored files */
+    filesChanged: string[];
+    /** Change statistics */
+    insertions: number;
+    deletions: number;
+    /** File diffs for UI display (only in preview mode) */
+    fileDiffs?: FileDiff[];
+};
+
+export declare function runNeovate(opts: {
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    plugins: Plugin_2[];
+    upgrade?: UpgradeOptions;
+    argv: Argv;
+    fetch?: typeof globalThis.fetch;
+}): Promise<{
+    shutdown?: () => Promise<void>;
+}>;
+
+export declare type SDKMessage = NormalizedMessage | SDKSystemMessage | SDKResultMessage;
+
+declare type SDKResultMessage = {
+    type: 'result';
+    subtype: 'success' | 'error';
+    isError: boolean;
+    content: string;
+    sessionId: string;
+    __result?: any;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+};
+
+export declare interface SDKSession {
+    readonly sessionId: string;
+    send(message: string | SDKUserMessage): Promise<void>;
+    receive(): AsyncGenerator<SDKMessage, void>;
+    close(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+export declare type SDKSessionOptions = {
+    model: string;
+    cwd?: string;
+    productName?: string;
+    plugins?: Plugin_2[];
+    /**
+     * Custom provider configurations to add or override built-in providers.
+     * Allows specifying custom API endpoints and model definitions.
+     *
+     * @example
+     * ```typescript
+     * providers: {
+     *   "my-custom-provider": {
+     *     api: "https://my-api.example.com/v1",
+     *     env: ["MY_API_KEY"],
+     *     models: {
+     *       "my-model": "deepseek-v3.2" // Reference existing model
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    providers?: Record<string, ProviderConfig>;
+    /**
+     * Extra SKILL.md file paths for user-defined skills.
+     * Accepts absolute paths to SKILL.md files or directories containing SKILL.md.
+     *
+     * @example
+     * ```typescript
+     * skills: [
+     *   "/path/to/my-skill/SKILL.md",
+     *   "/path/to/skill-directory"
+     * ]
+     * ```
+     */
+    skills?: string[];
+};
+
+declare type SDKSystemMessage = {
+    type: 'system';
+    subtype: 'init';
+    sessionId: string;
+    model: string;
+    cwd: string;
+    tools: string[];
+};
+
+export declare type SDKUserMessage = {
+    type: 'user';
+    message: UserContent;
+    parentUuid: string | null;
+    uuid: string;
+    sessionId: string;
+};
+
+declare type SerializedSnapshot = {
+    messageId: string;
+    timestamp: string;
+    trackedFileBackups: Record<string, {
+        backupFileName: string | null;
+        version: number;
+        backupTime: string;
+    }>;
+};
+
+/**
+ * Serialized snapshot data (for JSONL storage)
+ */
+declare type SerializedSnapshot_2 = {
+    messageId: string;
+    timestamp: string;
+    trackedFileBackups: Record<string, {
+        backupFileName: string | null;
+        version: number;
+        backupTime: string;
+    }>;
+};
+
+declare type SessionAddMessagesInput = {
+    cwd: string;
+    sessionId: string;
+    messages: Message_2[];
+    parentUuid?: string;
+};
+
+declare type SessionCancelInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionCompactInput = {
+    cwd: string;
+    sessionId: string;
+    messages: NormalizedMessage[];
+};
+
+declare type SessionCompactOutput = {
+    success: boolean;
+    data: {
+        summary: string;
+    };
+};
+
+declare type SessionConfigAddApprovalToolsInput = {
+    cwd: string;
+    sessionId: string;
+    approvalTool: string;
+};
+
+declare type SessionConfigAddDirectoryInput = {
+    cwd: string;
+    sessionId: string;
+    directory: string;
+};
+
+declare type SessionConfigGetAdditionalDirectoriesInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionConfigGetAdditionalDirectoriesOutput = {
+    success: boolean;
+    data: {
+        directories: string[];
+    };
+};
+
+declare type SessionConfigGetInput = {
+    cwd: string;
+    sessionId: string;
+    key?: string;
+};
+
+declare type SessionConfigGetOutput = {
+    success: boolean;
+    data: {
+        value: any;
+    };
+};
+
+declare type SessionConfigRemoveDirectoryInput = {
+    cwd: string;
+    sessionId: string;
+    directory: string;
+};
+
+declare type SessionConfigRemoveInput = {
+    cwd: string;
+    sessionId: string;
+    key: string;
+};
+
+declare type SessionConfigSetApprovalModeInput = {
+    cwd: string;
+    sessionId: string;
+    approvalMode: ApprovalMode;
+};
+
+declare type SessionConfigSetInput = {
+    cwd: string;
+    sessionId: string;
+    key: string;
+    value: any;
+};
+
+declare type SessionConfigSetPastedImageMapInput = {
+    cwd: string;
+    sessionId: string;
+    pastedImageMap: Record<string, string>;
+};
+
+declare type SessionConfigSetPastedTextMapInput = {
+    cwd: string;
+    sessionId: string;
+    pastedTextMap: Record<string, string>;
+};
+
+declare type SessionConfigSetSummaryInput = {
+    cwd: string;
+    sessionId: string;
+    summary: string;
+};
+
+declare type SessionExportSessionMarkdownInput = {
+    cwd: string;
+    sessionId: string | undefined;
+};
+
+declare type SessionExportSessionMarkdownOutput = {
+    success: true;
+    data: {
+        filePath: string;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SessionGetModelInput = {
+    cwd: string;
+    sessionId: string;
+    includeModelInfo?: boolean;
+};
+
+declare type SessionGetModelOutput = {
+    success: true;
+    data: {
+        model: string | null;
+    };
+} | {
+    success: true;
+    data: {
+        model: string | null;
+        modelInfo: ModelInfo | null;
+        providers: ProvidersMap;
+    };
+} | {
+    success: false;
+    error: any;
+};
+
+declare type SessionInitializeInput = {
+    cwd: string;
+    sessionId?: string;
+};
+
+declare type SessionInitializeOutput = {
+    success: boolean;
+    error?: any;
+    data: {
+        productName: string;
+        productASCIIArt: string | undefined;
+        version: string;
+        model: any;
+        planModel: string | undefined;
+        initializeModelError: string | null;
+        providers: any;
+        approvalMode: ApprovalMode;
+        sessionSummary: string | undefined;
+        pastedTextMap: Record<string, string>;
+        pastedImageMap: Record<string, string>;
+        thinkingLevel: string | undefined;
+    };
+};
+
+declare type SessionMessagesListInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionMessagesListOutput = {
+    success: boolean;
+    data: {
+        messages: NormalizedMessage[];
+    };
+};
+
+declare type SessionSendInput = {
+    message: string | null;
+    cwd: string;
+    sessionId: string | undefined;
+    planMode: boolean;
+    model?: string;
+    attachments?: ImagePart[];
+    parentUuid?: string;
+    thinking?: ThinkingConfig;
+};
+
+declare type SessionSendOutput = any;
+
+declare type SessionsListInput = {
+    cwd: string;
+};
+
+declare type SessionsListOutput = {
+    success: boolean;
+    data: {
+        sessions: Array<{
+            sessionId: string;
+            modified: Date;
+            created: Date;
+            messageCount: number;
+            summary: string;
+        }>;
+    };
+};
+
+declare type SessionsRemoveInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionsRemoveOutput = {
+    success: boolean;
+    error?: string;
+};
+
+declare type SessionsResumeInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionsResumeOutput = {
+    success: boolean;
+    data: {
+        sessionId: string;
+        logFile: string;
+    };
+};
+
+declare interface SkillError {
+    path: string;
+    message: string;
+}
+
+declare class SkillManager {
+    private skillsMap;
+    private errors;
+    private paths;
+    private context;
+    constructor(opts: SkillManagerOpts);
+    getSkills(): SkillMetadata[];
+    getSkill(name: string): SkillMetadata | undefined;
+    getErrors(): SkillError[];
+    readSkillBody(skill: SkillMetadata): Promise<string>;
+    loadSkills(): Promise<void>;
+    private loadSkillsFromDirectory;
+    private loadSkillFile;
+    /**
+     * Load skill from a path that can be either a SKILL.md file or a directory containing SKILL.md.
+     */
+    private loadSkillPath;
+    private parseSkillFile;
+    addSkill(source: string, options?: AddSkillOptions): Promise<AddSkillResult>;
+    private normalizeSource;
+    private extractFolderName;
+    private scanForSkills;
+    private copyDirectory;
+    private parseSkillFileForAdd;
+    previewSkills(source: string): Promise<PreviewSkillsResult>;
+    installFromPreview(preview: PreviewSkillsResult, selectedSkills: SkillPreview[], source: string, options?: AddSkillOptions): Promise<AddSkillResult>;
+    cleanupPreview(preview: PreviewSkillsResult): void;
+    removeSkill(name: string, targetDir?: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+
+declare interface SkillManagerOpts {
+    context: Context;
+}
+
+declare interface SkillMetadata {
+    name: string;
+    description: string;
+    path: string;
+    source: SkillSource;
+}
+
+declare interface SkillPreview {
+    name: string;
+    description: string;
+    skillPath: string;
+    skillDir: string;
+}
+
+declare type SkillsAddInput = {
+    cwd: string;
+    source: string;
+    global?: boolean;
+    claude?: boolean;
+    overwrite?: boolean;
+    name?: string;
+    targetDir?: string;
+};
+
+declare type SkillsAddOutput = {
+    success: true;
+    data: {
+        installed: Array<{
+            name: string;
+            description: string;
+            path: string;
+            source: SkillSourceType;
+        }>;
+        skipped: Array<{
+            name: string;
+            reason: string;
+        }>;
+        errors: Array<{
+            path: string;
+            message: string;
+        }>;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SkillsGetInput = {
+    cwd: string;
+    name: string;
+};
+
+declare type SkillsGetOutput = {
+    success: true;
+    data: {
+        skill: {
+            name: string;
+            description: string;
+            path: string;
+            source: SkillSourceType;
+            body: string;
+        };
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SkillsInstallInput = {
+    cwd: string;
+    previewId: string;
+    selectedSkills: string[];
+    source: string;
+    global?: boolean;
+    claude?: boolean;
+    overwrite?: boolean;
+    name?: string;
+    targetDir?: string;
+};
+
+declare type SkillsInstallOutput = {
+    success: true;
+    data: {
+        installed: Array<{
+            name: string;
+            description: string;
+            path: string;
+            source: SkillSourceType;
+        }>;
+        skipped: Array<{
+            name: string;
+            reason: string;
+        }>;
+        errors: Array<{
+            path: string;
+            message: string;
+        }>;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SkillsListInput = {
+    cwd: string;
+};
+
+declare type SkillsListOutput = {
+    success: boolean;
+    data: {
+        skills: Array<{
+            name: string;
+            description: string;
+            path: string;
+            source: SkillSourceType;
+        }>;
+        errors: Array<{
+            path: string;
+            message: string;
+        }>;
+    };
+};
+
+declare enum SkillSource {
+    Plugin = "plugin",
+    Config = "config",
+    GlobalClaude = "global-claude",
+    Global = "global",
+    ProjectClaude = "project-claude",
+    Project = "project"
+}
+
+/** Skill source types */
+declare type SkillSourceType = 'plugin' | 'config' | 'global-claude' | 'global' | 'project-claude' | 'project';
+
+declare type SkillsPreviewInput = {
+    cwd: string;
+    source: string;
+};
+
+declare type SkillsPreviewOutput = {
+    success: true;
+    data: {
+        previewId: string;
+        skills: Array<{
+            name: string;
+            description: string;
+            skillPath: string;
+        }>;
+        errors: Array<{
+            path: string;
+            message: string;
+        }>;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SkillsRemoveInput = {
+    cwd: string;
+    name: string;
+    targetDir?: string;
+};
+
+declare type SkillsRemoveOutput = {
+    success: boolean;
+    error?: string;
+};
+
+declare type SlashCommand = LocalCommand | LocalJSXCommand | PromptCommand;
+
+declare type SlashCommandExecuteInput = {
+    cwd: string;
+    sessionId: string;
+    command: string;
+    args: string;
+};
+
+declare type SlashCommandExecuteOutput = {
+    success: boolean;
+    data: {
+        messages: any[];
+    };
+};
+
+declare type SlashCommandGetInput = {
+    cwd: string;
+    command: string;
+};
+
+declare type SlashCommandGetOutput = {
+    success: boolean;
+    data: {
+        commandEntry: any;
+    };
+};
+
+declare type SlashCommandListInput = {
+    cwd: string;
+};
+
+declare type SlashCommandListOutput = {
+    success: boolean;
+    data: {
+        slashCommands: any[];
+    };
+};
+
+/**
+ * File state snapshot at a specific message point
+ */
+declare type Snapshot = {
+    /** Associated message UUID */
+    messageId: string;
+    /** Snapshot creation time */
+    timestamp: Date;
+    /** Relative path -> backup metadata mapping */
+    trackedFileBackups: Record<string, FileBackupMeta>;
+};
+
+declare type SnapshotCreateInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+    description?: string;
+};
+
+declare type SnapshotCreateOutput = {
+    success: boolean;
+    data: {
+        snapshot: SnapshotPreview | null;
+    };
+};
+
+declare type SnapshotHasInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+};
+
+declare type SnapshotHasOutput = {
+    success: boolean;
+    data: {
+        hasSnapshot: boolean;
+    };
+};
+
+declare type SnapshotListInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SnapshotListOutput = {
+    success: boolean;
+    data: {
+        snapshots: SnapshotPreview[];
+    };
+};
+
+declare type SnapshotLoadFromSessionInput = {
+    cwd: string;
+    sessionId: string;
+    snapshots: SerializedSnapshot[];
+};
+
+declare type SnapshotPreview = {
+    messageId: string;
+    timestamp: Date;
+    fileCount: number;
+    changes?: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+};
+
+/**
+ * Snapshot preview info (for UI display)
+ */
+declare type SnapshotPreview_2 = {
+    messageId: string;
+    timestamp: Date;
+    fileCount: number;
+    /** Change statistics relative to previous snapshot */
+    changes?: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+};
+
+declare type SnapshotPreviewRewindInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+    cumulative?: boolean;
+};
+
+declare type SnapshotPreviewRewindOutput = {
+    success: true;
+    data: {
+        result: RewindResult;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SnapshotRewindInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+};
+
+declare type SnapshotRewindOutput = {
+    success: true;
+    data: {
+        result: RewindResult;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SnapshotTrackFileInput = {
+    cwd: string;
+    sessionId: string;
+    filePath: string;
+    isNewFile?: boolean;
+};
+
+declare type Status = Record<string, {
+    description?: string;
+    items: string[];
+}>;
+
+declare type StatusGetInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type StatusGetOutput = {
+    success: boolean;
+    data: {
+        status: Record<string, {
+            description?: string;
+            items: string[];
+        }>;
+    };
+};
+
+/** Standard success response without data */
+declare type SuccessResponse = {
+    success: true;
+};
+
+declare type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+
+declare interface TaskToolInput {
+    description: string;
+    prompt: string;
+    subagent_type: string;
+    model?: string;
+    resume?: string;
+}
+
+declare type TempPluginContext = ContextCreateOpts & {
+    pluginManager: PluginManager;
+    config: Config;
+    apply: (opts: PluginApplyOpts) => Promise<any> | any;
+};
+
+declare type TextPart = {
+    type: 'text';
+    text: string;
+    hidden?: boolean;
+};
+
+declare type ThinkingConfig = {
+    effort: ReasoningEffort;
+};
+
+declare type TodoItem = _zod.infer<typeof TodoItemSchema>;
+
+declare const TodoItemSchema: _zod.ZodObject<{
+    id: _zod.ZodString;
+    content: _zod.ZodString;
+    status: _zod.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+    }>;
+    priority: _zod.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+}, _zod.core.$strip>;
+
+declare type TodoWriteReturnDisplay = {
+    type: 'todo_write';
+    oldTodos: TodoItem[];
+    newTodos: TodoItem[];
+};
+
+declare interface Tool<TSchema extends z.ZodTypeAny = z.ZodTypeAny> {
+    name: string;
+    description: string;
+    getDescription?: ({ params, cwd, }: {
+        params: z.output<TSchema>;
+        cwd: string;
+    }) => string;
+    displayName?: string;
+    execute: (params: z.output<TSchema>, toolCallId?: string) => Promise<ToolResult> | ToolResult;
+    approval?: ToolApprovalInfo;
+    parameters: TSchema;
+}
+
+declare type ToolApprovalInfo = {
+    needsApproval?: (context: ApprovalContext) => Promise<boolean> | boolean;
+    category?: ApprovalCategory;
+};
+
+declare type ToolApprovalInput = {
+    toolUse: ToolUse;
+    category?: ApprovalCategory;
+    sessionId: string;
+};
+
+declare type ToolApprovalOutput = {
+    approved: boolean;
+    params?: Record<string, unknown>;
+    denyReason?: string;
+};
+
+declare type ToolApprovalResult = boolean | {
+    approved: boolean;
+    params?: ToolParams;
+    denyReason?: string;
+};
+
+declare type ToolContent = Array<ToolResultPart>;
+
+declare type ToolMessage = {
+    role: 'user';
+    content: ToolContent;
+};
+
+declare type ToolMessage2 = {
+    role: 'tool';
+    content: ToolResultPart2[];
+};
+
+declare type ToolParams = Record<string, unknown>;
+
+declare type ToolResult = {
+    llmContent: string | (TextPart | ImagePart)[];
+    returnDisplay?: ReturnDisplay;
+    isError?: boolean;
+    metadata?: {
+        agentId?: string;
+        agentType?: string;
+        [key: string]: any;
+    };
+    truncated?: boolean;
+    outputPath?: string;
+};
+
+declare type ToolResultPart = {
+    type: 'tool_result';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    result: ToolResult;
+    agentId?: string;
+    agentType?: string;
+};
+
+declare type ToolResultPart2 = {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, any>;
+    result: ToolResult;
+    agentId?: string;
+    agentType?: string;
+    pruned?: boolean;
+    prunedAt?: number;
+};
+
+declare type ToolUse = {
+    name: string;
+    params: Record<string, any>;
+    callId: string;
+};
+
+declare type ToolUsePart = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    displayName?: string;
+    description?: string;
+};
+
+declare type UpgradeOptions = {
+    registryBase: string;
+    name: string;
+    version: string;
+    installDir: string;
+    files: string[];
+    channel?: string;
+    changelogUrl?: string;
+};
+
+declare class Usage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    constructor(init?: Partial<Usage>);
+    static empty(): Usage;
+    static fromEventUsage(eventUsage: any): Usage;
+    static fromAssistantMessage(message: AssistantMessage): Usage;
+    add(other: Usage): void;
+    reset(): void;
+    clone(): Usage;
+    isValid(): boolean;
+}
+
+declare type UserContent = string | Array<TextPart | ImagePart>;
+
+declare type UserMessage = {
+    role: 'user';
+    content: UserContent;
+    hidden?: boolean;
+};
+
+declare type UtilsDetectAppsInput = {
+    cwd: string;
+    apps?: App[];
+};
+
+declare type UtilsDetectAppsOutput = {
+    success: boolean;
+    data: {
+        apps: App[];
+    };
+};
+
+declare type UtilsFilesListInput = {
+    cwd: string;
+    query?: string;
+};
+
+declare type UtilsFilesListOutput = {
+    success: boolean;
+    data: {
+        files: any[];
+    };
+};
+
+declare type UtilsGetPathsInput = {
+    cwd: string;
+    maxFiles?: number;
+};
+
+declare type UtilsGetPathsOutput = {
+    success: boolean;
+    data: {
+        paths: string[];
+    };
+};
+
+declare type UtilsNotifyInput = {
+    cwd: string;
+    config: string | false | undefined;
+};
+
+declare type UtilsNotifyOutput = SuccessResponse;
+
+declare type UtilsOnRequestHook = (req: {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: unknown;
+}) => void;
+
+declare type UtilsOnResponseHook = (res: {
+    url: string;
+    status: number;
+    headers: Record<string, string>;
+}) => void;
+
+declare type UtilsOpenInput = {
+    cwd: string;
+    sessionId?: string;
+    app: App;
+};
+
+declare type UtilsPlaySoundInput = {
+    sound: string;
+    volume?: number;
+};
+
+declare type UtilsPlaySoundOutput = SuccessResponse | ErrorResponse;
+
+declare type UtilsQueryInput = {
+    userPrompt: string;
+    cwd: string;
+    systemPrompt?: string;
+    model?: string;
+    thinking?: ThinkingConfig;
+    responseFormat?: ResponseFormat;
+};
+
+declare type UtilsQueryOutput = any;
+
+declare type UtilsQuickQueryInput = {
+    userPrompt: string;
+    cwd: string;
+    systemPrompt?: string;
+    model?: string;
+    thinking?: ThinkingConfig;
+    responseFormat?: ResponseFormat;
+};
+
+declare type UtilsQuickQueryOutput = any;
+
+declare type UtilsSearchPathsInput = {
+    cwd: string;
+    query: string;
+    maxResults?: number;
+};
+
+declare type UtilsSearchPathsOutput = {
+    success: boolean;
+    data: {
+        paths: string[];
+        truncated: boolean;
+    };
+};
+
+declare type UtilsSummarizeMessageInput = {
+    message: string;
+    cwd: string;
+    model?: string;
+};
+
+declare type UtilsSummarizeMessageOutput = any;
+
+declare type UtilsTelemetryInput = {
+    cwd: string;
+    name: string;
+    payload: Record<string, any>;
+};
+
+declare type UtilsToolExecuteBashInput = {
+    cwd: string;
+    command: string;
+};
+
+declare type UtilsToolExecuteBashOutput = {
+    success: boolean;
+    data?: any;
+    error?: {
+        message: string;
+    };
+};
+
+declare type WorkspaceData = {
+    id: string;
+    repoPath: string;
+    branch: string;
+    worktreePath: string;
+    sessionIds: string[];
+    gitState: {
+        currentCommit: string;
+        isDirty: boolean;
+        pendingChanges: string[];
+    };
+    metadata: {
+        createdAt: number;
+        description: string;
+        status: 'active' | 'archived' | 'stale';
+    };
+    context: {
+        activeFiles: string[];
+        settings: any;
+        preferences: Record<string, unknown>;
+    };
+};
+
+export { _zod }
+
+export { }