@neovate/code 0.18.2 → 0.20.0

package/dist/index.d.ts

@@ -4,7 +4,10 @@ import type { OpenAIProvider } from '@ai-sdk/openai';
 import * as z from 'zod';
 import { z as _zod } from 'zod';
 
-declare type ApprovalCategory = 'read' | 'write' | 'command' | 'network';
+/** Supported application types for open and detect operations */
+declare type App = 'cursor' | 'vscode' | 'vscode-insiders' | 'zed' | 'windsurf' | 'iterm' | 'warp' | 'terminal' | 'antigravity' | 'finder' | 'sourcetree';
+
+declare type ApprovalCategory = 'read' | 'write' | 'command' | 'network' | 'ask';
 
 declare type ApprovalContext = {
     toolName: string;
@@ -96,6 +99,44 @@ declare type Config = {
     autoUpdate?: boolean;
     browser?: boolean;
     temperature?: number;
+    httpProxy?: string;
+    desktop?: DesktopConfig;
+    /**
+     * 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>;
+};
+
+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 {
@@ -113,6 +154,20 @@ export declare class _ConfigManager {
     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: string;
+};
+
 export declare class Context {
     #private;
     cwd: string;
@@ -163,6 +218,7 @@ declare interface CreateTaskInput {
 
 export declare function createTool<TSchema extends z.ZodTypeAny>(config: {
     name: string;
+    displayName?: string;
     description: string;
     parameters: TSchema;
     execute: (params: z.output<TSchema>) => Promise<ToolResult> | ToolResult;
@@ -173,6 +229,13 @@ export declare function createTool<TSchema extends z.ZodTypeAny>(config: {
     }) => string;
 }): Tool<TSchema>;
 
+declare type DesktopConfig = {
+    theme?: 'light' | 'dark' | 'system';
+    sendMessageWith?: 'enter' | 'cmdEnter';
+    terminalFont?: string;
+    terminalFontSize?: number;
+};
+
 declare type DiffViewerReturnDisplay = {
     type: 'diff_viewer';
     originalContent: string | {
@@ -187,6 +250,12 @@ declare type DiffViewerReturnDisplay = {
 
 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 & {
@@ -195,6 +264,333 @@ declare type EventMessage = BaseMessage & {
     data: any;
 };
 
+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 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;
+    };
+    error?: string;
+};
+
+/**
+ * Central type registry for all message bus handlers.
+ * Maps handler method names to their input and output types.
+ */
+declare type HandlerMap = {
+    '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;
+    };
+    'mcp.getStatus': {
+        input: McpGetStatusInput;
+        output: McpGetStatusOutput;
+    };
+    'mcp.reconnect': {
+        input: McpReconnectInput;
+        output: McpReconnectOutput;
+    };
+    'mcp.list': {
+        input: McpListInput;
+        output: McpListOutput;
+    };
+    'models.list': {
+        input: ModelsListInput;
+        output: ModelsListOutput;
+    };
+    '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;
+    };
+    'providers.list': {
+        input: ProvidersListInput;
+        output: ProvidersListOutput;
+    };
+    'session.initialize': {
+        input: SessionInitializeInput;
+        output: SessionInitializeOutput;
+    };
+    'session.messages.list': {
+        input: SessionMessagesListInput;
+        output: SessionMessagesListOutput;
+    };
+    '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.list': {
+        input: SessionsListInput;
+        output: SessionsListOutput;
+    };
+    'sessions.resume': {
+        input: SessionsResumeInput;
+        output: SessionsResumeOutput;
+    };
+    '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.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;
+    };
+    toolApproval: {
+        input: ToolApprovalInput;
+        output: ToolApprovalOutput;
+    };
+};
+
 declare type ImagePart = {
     type: 'image';
     data: string;
@@ -242,6 +638,28 @@ declare interface MCPConfig {
     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;
@@ -249,6 +667,30 @@ declare type McpHttpServerConfig = {
     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;
@@ -280,6 +722,17 @@ declare class MCPManager {
     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';
@@ -304,16 +757,20 @@ 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 messageHandlers;
     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>;
@@ -384,6 +841,32 @@ declare interface ModelModalities {
     output: ('text' | 'audio' | 'image')[];
 }
 
+declare type ModelsListInput = {
+    cwd: string;
+};
+
+declare type ModelsListOutput = {
+    success: boolean;
+    data: {
+        groupedModels: Array<{
+            provider: string;
+            providerId: string;
+            models: Array<{
+                name: string;
+                modelId: string;
+                value: string;
+            }>;
+        }>;
+        currentModel: any;
+        currentModelInfo: {
+            providerName: string;
+            modelName: string;
+            modelId: string;
+            modelContextLimit: number;
+        } | null;
+    };
+};
+
 declare type NormalizedMessage = Message_2 & {
     type: 'message';
     timestamp: string;
@@ -408,6 +891,21 @@ declare type OutputStyleOpts = {
     prompt: string;
 };
 
+declare type OutputStylesListInput = {
+    cwd: string;
+};
+
+declare type OutputStylesListOutput = {
+    success: boolean;
+    data: {
+        outputStyles: Array<{
+            name: string;
+            description: string;
+        }>;
+        currentOutputStyle: any;
+    };
+};
+
 declare class Paths {
     globalConfigDir: string;
     globalProjectDir: string;
@@ -538,6 +1036,178 @@ declare class PluginManager {
     apply({ hook, args, memo, type, pluginContext, }: PluginApplyOpts): Promise<any>;
 }
 
+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;
+                syncStatus: any;
+            };
+        };
+    };
+};
+
+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 interface PromptCommand extends BaseSlashCommand {
     type: 'prompt';
     progressMessage?: string;
@@ -564,11 +1234,31 @@ declare interface Provider {
         baseURL?: string;
         apiKey?: string;
         headers?: Record<string, string>;
+        httpProxy?: string;
     };
 }
 
 declare type ProviderConfig = Partial<Omit<Provider, 'createModel'>>;
 
+declare type ProvidersListInput = {
+    cwd: string;
+};
+
+declare type ProvidersListOutput = {
+    success: boolean;
+    data: {
+        providers: Array<{
+            id: string;
+            name: string;
+            doc?: string;
+            env?: string[];
+            apiEnv?: string[];
+            validEnvs: string[];
+            hasApiKey: boolean;
+        }>;
+    };
+};
+
 declare type ProvidersMap = Record<string, Provider>;
 
 export declare function _query(opts: {
@@ -578,8 +1268,12 @@ export declare function _query(opts: {
     model?: ModelInfo;
     systemPrompt?: string;
     onMessage?: (message: NormalizedMessage) => Promise<void>;
+    thinking?: ThinkingConfig | false;
+    responseFormat?: ResponseFormat;
 }): Promise<LoopResult>;
 
+declare type ReasoningEffort = 'low' | 'medium' | 'high';
+
 declare type ReasoningPart = {
     type: 'reasoning';
     text: string;
@@ -591,6 +1285,15 @@ declare type RequestMessage = BaseMessage & {
     params: any;
 };
 
+declare type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json';
+    schema?: any;
+    name?: string;
+    description?: string;
+};
+
 declare type ResponseMessage = BaseMessage & {
     type: 'response';
     result?: any;
@@ -607,13 +1310,276 @@ export declare function runNeovate(opts: {
     upgrade?: UpgradeOptions;
 }): Promise<void>;
 
+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 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>;
+    };
+};
+
+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 SessionsResumeInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SessionsResumeOutput = {
+    success: boolean;
+    data: {
+        sessionId: string;
+        logFile: 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[];
+    };
+};
+
 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;
@@ -630,6 +1596,10 @@ declare type TextPart = {
     text: string;
 };
 
+declare type ThinkingConfig = {
+    effort: ReasoningEffort;
+};
+
 declare type TodoItem = _zod.infer<typeof TodoItemSchema>;
 
 declare const TodoItemSchema: _zod.ZodObject<{
@@ -676,6 +1646,16 @@ declare type ToolApprovalInfo = {
     category?: ApprovalCategory;
 };
 
+declare type ToolApprovalInput = {
+    toolUse: ToolUse;
+    category?: ApprovalCategory;
+};
+
+declare type ToolApprovalOutput = {
+    approved: boolean;
+    params?: Record<string, unknown>;
+};
+
 declare type ToolContent = Array<ToolResultPart>;
 
 declare type ToolMessage = {
@@ -757,6 +1737,120 @@ declare type UserMessage = {
     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 UtilsOpenInput = {
+    cwd: string;
+    sessionId?: string;
+    app: App;
+};
+
+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 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 { }