@neovate/code 0.18.1 → 0.19.0

package/dist/index.d.ts

@@ -4,7 +4,7 @@ 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';
+declare type ApprovalCategory = 'read' | 'write' | 'command' | 'network' | 'ask';
 
 declare type ApprovalContext = {
     toolName: string;
@@ -74,6 +74,7 @@ declare type Config = {
     model: string;
     planModel: string;
     smallModel?: string;
+    visionModel?: string;
     language: string;
     quiet: boolean;
     approvalMode: ApprovalMode;
@@ -95,6 +96,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 {
@@ -112,6 +151,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;
@@ -162,6 +215,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;
@@ -172,6 +226,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 | {
@@ -194,6 +255,209 @@ declare type EventMessage = BaseMessage & {
     data: any;
 };
 
+/**
+ * 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;
+    };
+    '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;
+    };
+    'providers.list': {
+        input: ProvidersListInput;
+        output: ProvidersListOutput;
+    };
+    'session.initialize': {
+        input: SessionInitializeInput;
+        output: SessionInitializeOutput;
+    };
+    'session.messages.list': {
+        input: SessionMessagesListInput;
+        output: SessionMessagesListOutput;
+    };
+    '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;
+    };
+    '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;
+    };
+    toolApproval: {
+        input: ToolApprovalInput;
+        output: ToolApprovalOutput;
+    };
+};
+
 declare type ImagePart = {
     type: 'image';
     data: string;
@@ -241,6 +505,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;
@@ -248,6 +534,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;
@@ -279,6 +589,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';
@@ -303,16 +624,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>;
@@ -383,6 +708,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;
@@ -407,6 +758,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;
@@ -537,6 +903,158 @@ 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 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;
@@ -555,16 +1073,39 @@ declare interface Provider {
     api?: string;
     doc: string;
     models: Record<string, string | Omit<Model, 'id' | 'cost'>>;
-    createModel(name: string, provider: Provider, globalConfigDir: string): Promise<LanguageModelV2> | LanguageModelV2;
+    createModel(name: string, provider: Provider, options: {
+        globalConfigDir: string;
+        setGlobalConfig: (key: string, value: string, isGlobal: boolean) => void;
+    }): Promise<LanguageModelV2> | LanguageModelV2;
     options?: {
         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: {
@@ -574,8 +1115,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;
@@ -587,6 +1132,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;
@@ -603,13 +1157,227 @@ 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 SessionConfigRemoveDirectoryInput = {
+    cwd: string;
+    sessionId: string;
+    directory: string;
+};
+
+declare type SessionConfigSetApprovalModeInput = {
+    cwd: string;
+    sessionId: string;
+    approvalMode: ApprovalMode;
+};
+
+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 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: boolean;
+};
+
 declare type SystemMessage = {
     role: 'system';
     content: string;
@@ -626,6 +1394,10 @@ declare type TextPart = {
     text: string;
 };
 
+declare type ThinkingConfig = {
+    effort: ReasoningEffort;
+};
+
 declare type TodoItem = _zod.infer<typeof TodoItemSchema>;
 
 declare const TodoItemSchema: _zod.ZodObject<{
@@ -672,6 +1444,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 = {
@@ -753,6 +1535,102 @@ declare type UserMessage = {
     hidden?: boolean;
 };
 
+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 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 { }