zilmate 1.9.3 → 1.10.1

package/dist/agents/manager.d.ts

@@ -352,7 +352,7 @@ export declare function createManagerAgent(runId?: string, options?: {
         secureSetupHint: string;
     }>;
     launchSecureSetup: import("ai").Tool<{
-        section?: "gateway" | "redis" | "jobs" | "all" | "composio" | "tavily" | "qstash" | "voice" | "workspace" | undefined;
+        section?: "gateway" | "redis" | "jobs" | "all" | "voice" | "composio" | "tavily" | "qstash" | "workspace" | undefined;
     }, {
         instruction: string;
         command: string;
@@ -543,6 +543,88 @@ export declare function createManagerAgent(runId?: string, options?: {
         suggestion: string;
         path?: never;
     }>;
+    executeCommandAsync: import("ai").Tool<{
+        command: string;
+        cwd?: string | undefined;
+        env?: Record<string, string> | undefined;
+    }, {
+        success: boolean;
+        id: string;
+        status: string;
+        message: string;
+        command: string;
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+        command: string;
+        id?: never;
+        status?: never;
+        message?: never;
+    }>;
+    checkCommandStatus: import("ai").Tool<{
+        id: string;
+    }, {
+        success: boolean;
+        error: string;
+        id?: never;
+        command?: never;
+        cwd?: never;
+        status?: never;
+        exitCode?: never;
+        startTime?: never;
+        endTime?: never;
+        stdout?: never;
+        stderr?: never;
+    } | {
+        success: boolean;
+        id: string;
+        command: string;
+        cwd: string;
+        status: "completed" | "running" | "failed" | "killed";
+        exitCode: number | null;
+        startTime: string;
+        endTime: string | undefined;
+        error: string | undefined;
+        stdout: string;
+        stderr: string;
+    }>;
+    sendInputToProcess: import("ai").Tool<{
+        id: string;
+        input: string;
+    }, {
+        success: boolean;
+        error: string;
+        message?: never;
+    } | {
+        success: boolean;
+        message: string;
+        error?: never;
+    }>;
+    killCommand: import("ai").Tool<{
+        id: string;
+    }, {
+        success: boolean;
+        error: string;
+        message?: never;
+    } | {
+        success: boolean;
+        message: string;
+        error?: never;
+    }>;
+    listBackgroundCommands: import("ai").Tool<Record<string, never>, {
+        success: boolean;
+        processes: {
+            id: string;
+            command: string;
+            cwd: string;
+            status: "completed" | "running" | "failed" | "killed";
+            exitCode: number | null;
+            startTime: string;
+            endTime: string | undefined;
+        }[];
+        count: number;
+    }>;
     dragAndDrop: import("ai").Tool<{
         fromX: number;
         fromY: number;
@@ -598,14 +680,14 @@ export declare function createManagerAgent(runId?: string, options?: {
         result: string;
     }>;
     mouseAction: import("ai").Tool<{
-        action: "move" | "click" | "doubleClick" | "rightClick" | "scroll";
+        action: "move" | "click" | "scroll" | "doubleClick" | "rightClick";
         x: number;
         y: number;
         scrollAmount: number;
         duration: number;
-        scrollDirection?: "up" | "down" | "left" | "right" | undefined;
+        scrollDirection?: "down" | "up" | "left" | "right" | undefined;
     }, {
-        action: "move" | "click" | "doubleClick" | "rightClick" | "scroll";
+        action: "move" | "click" | "scroll" | "doubleClick" | "rightClick";
         x: number;
         y: number;
         result: string;
@@ -738,6 +820,833 @@ export declare function createManagerAgent(runId?: string, options?: {
     cancelJob: import("ai").Tool<{
         id: string;
     }, import("../server.js").ZilMateJob | null>;
+    listCloudBucket: import("ai").Tool<{
+        provider: "s3" | "gcs" | "vercel-blob";
+        limit: number;
+        bucketName?: string | undefined;
+        prefix?: string | undefined;
+    }, {
+        error: string;
+        provider?: never;
+        bucket?: never;
+        files?: never;
+        method?: never;
+    } | {
+        provider: "s3";
+        bucket: string | undefined;
+        files: {
+            key: string;
+            size: number;
+            lastModified: string;
+            url: string;
+        }[];
+        error?: never;
+        method?: never;
+    } | {
+        provider: "gcs";
+        bucket: string | undefined;
+        files: {
+            key: any;
+            size: number;
+            lastModified: any;
+            url: string;
+        }[];
+        error?: never;
+        method?: never;
+    } | {
+        provider: "vercel-blob";
+        files: {
+            key: string;
+            size: number;
+            lastModified: string;
+            url: string;
+        }[];
+        error?: never;
+        bucket?: never;
+        method?: never;
+    } | {
+        provider: "s3";
+        bucket: string | undefined;
+        method: string;
+        files: ({
+            key: string;
+            size: number;
+            isFolder: boolean;
+            lastModified?: never;
+            url?: never;
+        } | {
+            key: string;
+            size: number;
+            lastModified: string;
+            url: string;
+            isFolder?: never;
+        })[];
+        error?: never;
+    } | {
+        provider: "gcs";
+        bucket: string | undefined;
+        method: string;
+        files: {
+            key: string;
+            size: number;
+            lastModified: string;
+            url: string;
+        }[];
+        error?: never;
+    } | {
+        provider: "vercel-blob";
+        method: string;
+        files: any;
+        error?: never;
+        bucket?: never;
+    }>;
+    uploadFileToCloud: import("ai").Tool<{
+        provider: "s3" | "gcs" | "vercel-blob";
+        localFilePath: string;
+        destinationKey: string;
+        bucketName?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        provider?: never;
+        bucket?: never;
+        key?: never;
+        url?: never;
+        contentType?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        contentType: string;
+        error?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        contentType: string;
+        error?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        key: string;
+        url: string;
+        contentType: string;
+        error?: never;
+        bucket?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        contentType: string;
+        method: string;
+        error?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        contentType: string;
+        method: string;
+        error?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        key: string;
+        url: string;
+        method: string;
+        error?: never;
+        bucket?: never;
+        contentType?: never;
+    }>;
+    downloadFileFromCloud: import("ai").Tool<{
+        provider: "s3" | "gcs" | "vercel-blob";
+        destinationKey: string;
+        localFilePath: string;
+        bucketName?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        provider?: never;
+        bucket?: never;
+        key?: never;
+        localPath?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        localPath: string;
+        error?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        localPath: string;
+        error?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        url: string;
+        localPath: string;
+        error?: never;
+        bucket?: never;
+        key?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        localPath: string;
+        method: string;
+        error?: never;
+        url?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        localPath: string;
+        method: string;
+        error?: never;
+        url?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        url: string;
+        localPath: string;
+        method: string;
+        error?: never;
+        bucket?: never;
+        key?: never;
+    }>;
+    deleteCloudFile: import("ai").Tool<{
+        provider: "s3" | "gcs" | "vercel-blob";
+        destinationKey: string;
+        bucketName?: string | undefined;
+        recursive?: boolean | undefined;
+    }, {
+        error: string;
+        success?: never;
+        provider?: never;
+        bucket?: never;
+        deletedCount?: never;
+        key?: never;
+        prefix?: never;
+        recursive?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        deletedCount: number;
+        error?: never;
+        key?: never;
+        prefix?: never;
+        recursive?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        error?: never;
+        deletedCount?: never;
+        prefix?: never;
+        recursive?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        prefix: string;
+        recursive: boolean;
+        error?: never;
+        deletedCount?: never;
+        key?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        error?: never;
+        deletedCount?: never;
+        prefix?: never;
+        recursive?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        deletedCount: number;
+        error?: never;
+        bucket?: never;
+        key?: never;
+        prefix?: never;
+        recursive?: never;
+        url?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        url: string;
+        error?: never;
+        bucket?: never;
+        deletedCount?: never;
+        key?: never;
+        prefix?: never;
+        recursive?: never;
+        method?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        recursive: boolean | undefined;
+        method: string;
+        error?: never;
+        deletedCount?: never;
+        prefix?: never;
+        url?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        recursive: boolean | undefined;
+        method: string;
+        error?: never;
+        deletedCount?: never;
+        prefix?: never;
+        url?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        url: string;
+        method: string;
+        error?: never;
+        bucket?: never;
+        deletedCount?: never;
+        key?: never;
+        prefix?: never;
+        recursive?: never;
+    }>;
+    generateCloudSignedUrl: import("ai").Tool<{
+        provider: "s3" | "gcs" | "vercel-blob";
+        destinationKey: string;
+        expiresIn: number;
+        operation: "read" | "write";
+        bucketName?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        provider?: never;
+        bucket?: never;
+        key?: never;
+        url?: never;
+        operation?: never;
+        expires?: never;
+        note?: never;
+    } | {
+        success: boolean;
+        provider: "s3";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        operation: "read" | "write";
+        expires: number;
+        error?: never;
+        note?: never;
+    } | {
+        success: boolean;
+        provider: "gcs";
+        bucket: string | undefined;
+        key: string;
+        url: string;
+        operation: "read" | "write";
+        expires: number;
+        error?: never;
+        note?: never;
+    } | {
+        success: boolean;
+        provider: "vercel-blob";
+        key: string;
+        url: string;
+        note: string;
+        error?: never;
+        bucket?: never;
+        operation?: never;
+        expires?: never;
+    } | {
+        success: boolean;
+        error: string;
+        url: string;
+        provider?: never;
+        bucket?: never;
+        key?: never;
+        operation?: never;
+        expires?: never;
+        note?: never;
+    }>;
+    transcodeVideo: import("ai").Tool<{
+        inputPath: string;
+        outputPath: string;
+        resolution?: string | undefined;
+        fps?: number | undefined;
+        durationSeconds?: number | undefined;
+        codec?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        inputPath?: never;
+        outputPath?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        inputPath: string;
+        outputPath: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        inputPath?: never;
+        outputPath?: never;
+    }>;
+    extractAudio: import("ai").Tool<{
+        videoPath: string;
+        audioOutputPath: string;
+    }, {
+        error: string;
+        success?: never;
+        videoPath?: never;
+        audioOutputPath?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        videoPath: string;
+        audioOutputPath: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        videoPath?: never;
+        audioOutputPath?: never;
+    }>;
+    speechToText: import("ai").Tool<{
+        audioPath: string;
+        language?: string | undefined;
+    }, {
+        error: string;
+        audioPath?: never;
+        provider?: never;
+        model?: never;
+        confidence?: never;
+        transcript?: never;
+    } | {
+        audioPath: string;
+        provider: string;
+        model: string;
+        confidence: any;
+        transcript: any;
+        error?: never;
+    } | {
+        audioPath: string;
+        provider: string;
+        model: string;
+        transcript: any;
+        error?: never;
+        confidence?: never;
+    }>;
+    optimizeImage: import("ai").Tool<{
+        imagePath: string;
+        outputPath: string;
+        quality: number;
+        maxWidth?: number | undefined;
+        maxHeight?: number | undefined;
+        format?: "png" | "jpeg" | "webp" | undefined;
+        watermarkText?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        imagePath?: never;
+        outputPath?: never;
+        quality?: never;
+        watermarked?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        imagePath: string;
+        outputPath: string;
+        quality: number;
+        watermarked: boolean;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        imagePath?: never;
+        outputPath?: never;
+        quality?: never;
+        watermarked?: never;
+    }>;
+    textToSpeech: import("ai").Tool<{
+        text: string;
+        outputPath: string;
+        voice?: string | undefined;
+    }, {
+        success: boolean;
+        provider: string;
+        model: string;
+        outputPath: string;
+        error?: never;
+    } | {
+        error: string;
+        success?: never;
+        provider?: never;
+        model?: never;
+        outputPath?: never;
+    }>;
+    listOpenPorts: import("ai").Tool<Record<string, never>, {
+        ports: any;
+        error?: never;
+        rawError?: never;
+    } | {
+        error: string;
+        rawError: any;
+        ports?: never;
+    }>;
+    pingHost: import("ai").Tool<{
+        host: string;
+    }, {
+        host: string;
+        success: boolean;
+        output: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        host: string;
+        success: boolean;
+        error: string;
+        rawError: any;
+        output?: never;
+    }>;
+    traceRoute: import("ai").Tool<{
+        host: string;
+    }, {
+        host: string;
+        output: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        host: string;
+        error: string;
+        rawError: any;
+        output?: never;
+    }>;
+    getDatabaseSchema: import("ai").Tool<{
+        databasePath: string;
+    }, {
+        error: string;
+        databasePath?: never;
+        method?: never;
+        schema?: never;
+        tables?: never;
+    } | {
+        databasePath: string;
+        method: string;
+        schema: string;
+        error?: never;
+        tables?: never;
+    } | {
+        databasePath: string;
+        method: string;
+        schema: any;
+        tables: any;
+        error?: never;
+    }>;
+    runDatabaseQuery: import("ai").Tool<{
+        databasePath: string;
+        sql: string;
+    }, any>;
+    listSystemProcesses: import("ai").Tool<{
+        sortBy: "memory" | "cpu" | "pid";
+        limit: number;
+        filterName?: string | undefined;
+    }, {
+        processes: {
+            pid: number;
+            name: string;
+            cpu: number;
+            memory: number;
+        }[];
+        error?: never;
+        rawError?: never;
+    } | {
+        error: string;
+        rawError: any;
+        processes?: never;
+    }>;
+    killSystemProcess: import("ai").Tool<{
+        force: boolean;
+        pid?: number | undefined;
+        name?: string | undefined;
+        port?: number | undefined;
+    }, {
+        error: string;
+        success?: never;
+        killedPids?: never;
+        name?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        killedPids?: never;
+        name?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        killedPids: number[];
+        error?: never;
+        name?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        name: string;
+        error?: never;
+        killedPids?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        killedPids?: never;
+        name?: never;
+    }>;
+    getSystemMetrics: import("ai").Tool<Record<string, never>, {
+        success: boolean;
+        metrics: {
+            os: {
+                name: string;
+                platform: NodeJS.Platform;
+                release: string;
+                architecture: NodeJS.Architecture;
+                uptimeSeconds: number;
+                uptimeHours: number;
+            };
+            cpu: {
+                activeUtilizationPercent: number;
+                cores: number;
+                model: string;
+            };
+            memory: {
+                totalGb: number;
+                freeGb: number;
+                usedGb: number;
+                utilizationPercent: number;
+            };
+            disk: {
+                workspacePath: string;
+                totalGb: number;
+                freeGb: number;
+                usedGb: number;
+                utilizationPercent: number;
+            };
+        };
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        metrics?: never;
+    }>;
+    listDockerContainers: import("ai").Tool<{
+        all: boolean;
+    }, {
+        error: string;
+        containers?: never;
+        rawError?: never;
+    } | {
+        containers: any[];
+        error?: never;
+        rawError?: never;
+    } | {
+        error: string;
+        rawError: any;
+        containers?: never;
+    }>;
+    getDockerContainerLogs: import("ai").Tool<{
+        container: string;
+        tail: number;
+    }, {
+        error: string;
+        container?: never;
+        logs?: never;
+        rawError?: never;
+    } | {
+        container: string;
+        logs: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        error: string;
+        rawError: any;
+        container?: never;
+        logs?: never;
+    }>;
+    controlDockerContainer: import("ai").Tool<{
+        container: string;
+        action: "stop" | "start" | "restart" | "kill";
+    }, {
+        error: string;
+        success?: never;
+        container?: never;
+        action?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        container: string;
+        action: "stop" | "start" | "restart" | "kill";
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        container?: never;
+        action?: never;
+    }>;
+    validateEnv: import("ai").Tool<Record<string, never>, {
+        error: string;
+        envExists?: never;
+        exampleExists?: never;
+        missingInEnv?: never;
+        missingInExample?: never;
+        presentInBoth?: never;
+    } | {
+        envExists: boolean;
+        exampleExists: boolean;
+        missingInEnv: string[];
+        missingInExample: string[];
+        presentInBoth: string[];
+        error?: never;
+    }>;
+    manageDockerCompose: import("ai").Tool<{
+        action: "logs" | "down" | "ps" | "restart" | "up" | "build";
+        composeFile?: string | undefined;
+        services?: string[] | undefined;
+    }, {
+        error: string;
+        success?: never;
+        action?: never;
+        command?: never;
+        stdout?: never;
+        stderr?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        action: "logs" | "down" | "ps" | "restart" | "up" | "build";
+        command: string;
+        stdout: string;
+        stderr: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        action?: never;
+        command?: never;
+        stdout?: never;
+        stderr?: never;
+    }>;
+    runDockerContainer: import("ai").Tool<{
+        image: string;
+        autoRemove: boolean;
+        name?: string | undefined;
+        ports?: string[] | undefined;
+        env?: string[] | undefined;
+        volumes?: string[] | undefined;
+        restartPolicy?: "no" | "always" | "unless-stopped" | "on-failure" | undefined;
+        network?: string | undefined;
+        memoryLimit?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        image?: never;
+        containerId?: never;
+        name?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        image: string;
+        containerId: string;
+        name: string | null;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        image?: never;
+        containerId?: never;
+        name?: never;
+    }>;
+    execDockerCommand: import("ai").Tool<{
+        container: string;
+        command: string[];
+        user?: string | undefined;
+        workdir?: string | undefined;
+    }, {
+        error: string;
+        success?: never;
+        container?: never;
+        stdout?: never;
+        stderr?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        container: string;
+        stdout: string;
+        stderr: string;
+        error?: never;
+        rawError?: never;
+    } | {
+        success: boolean;
+        error: string;
+        rawError: any;
+        container?: never;
+        stdout?: never;
+        stderr?: never;
+    }>;
     readClipboard: import("ai").Tool<{
         maxCharacters?: number | undefined;
     }, {
@@ -831,6 +1740,102 @@ export declare function createManagerAgent(runId?: string, options?: {
         error: any;
         input?: never;
     }>;
+    simulateMouse: import("ai").Tool<{
+        action: "move" | "click" | "double-click" | "right-click" | "drag" | "scroll";
+        x?: number | undefined;
+        y?: number | undefined;
+        endX?: number | undefined;
+        endY?: number | undefined;
+        scrollAmount?: number | undefined;
+    }, {
+        success: boolean;
+        action: "move" | "click" | "double-click" | "right-click" | "drag" | "scroll";
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+        action?: never;
+    }>;
+    displaySystemNotification: import("ai").Tool<{
+        title: string;
+        message: string;
+    }, {
+        success: boolean;
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    recordAudioSnippet: import("ai").Tool<{
+        durationSeconds: number;
+    }, {
+        success: boolean;
+        file: string;
+        durationSeconds: number;
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+        file?: never;
+        durationSeconds?: never;
+    }>;
+    getActiveWindowContext: import("ai").Tool<Record<string, never>, {
+        title?: string;
+        process?: string;
+        pid?: number;
+        success: boolean;
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    controlSystemVolume: import("ai").Tool<{
+        action: "set" | "get" | "mute" | "unmute" | "media-play-pause" | "media-next" | "media-prev";
+        level?: number | undefined;
+    }, {
+        success: boolean;
+        action: "media-play-pause";
+        level?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        action: "media-next";
+        level?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        action: "media-prev";
+        level?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        action: "mute";
+        level?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        action: "unmute";
+        level?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        action: "set";
+        level: number;
+        error?: never;
+    } | {
+        success: boolean;
+        error: string;
+        action?: never;
+        level?: never;
+    } | {
+        success: boolean;
+        level: number;
+        action?: never;
+        error?: never;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
     searchFiles: import("ai").Tool<{
         query: string;
         root?: string | undefined;