import { ToolLoopAgent } from 'ai';
export declare function createDeveloperHelperAgent(runId?: string): ToolLoopAgent<never, {
    readScratchpad: import("ai").Tool<Record<string, never>, string>;
    appendScratchpad: import("ai").Tool<{
        note: string;
    }, string>;
    getSharedValue: import("ai").Tool<{
        key: string;
    }, any>;
    setSharedValue: import("ai").Tool<{
        key: string;
        value: any;
    }, string>;
    listSharedKeys: import("ai").Tool<Record<string, never>, string[]>;
    docsSearch: import("ai").Tool<{
        query: string;
    }, import("../tools/web-search.tool.js").WebSearchResult[]>;
    docsFetch: import("ai").Tool<{
        url: string;
    }, string>;
    webSearch: import("ai").Tool<{
        query: string;
        maxResults?: number | undefined;
        searchDepth?: "basic" | "advanced" | undefined;
        includeAnswer?: boolean | undefined;
        includeRawContent?: "text" | "markdown" | undefined;
        includeDomains?: string[] | undefined;
        excludeDomains?: string[] | undefined;
        topic?: "general" | "news" | "finance" | undefined;
        timeRange?: "day" | "week" | "month" | "year" | undefined;
    }, {
        answer: string | undefined;
        results: {
            title: string;
            url: string;
            content: string;
            rawContent: string | undefined;
            score: number | undefined;
            publishedDate: string | undefined;
        }[];
    }>;
    webExtract: import("ai").Tool<{
        urls: string[];
        query?: string | undefined;
        extractDepth?: "basic" | "advanced" | undefined;
        format?: "text" | "markdown" | undefined;
        chunksPerSource?: number | undefined;
    }, {
        results: {
            url: string;
            title: string;
            rawContent: string;
        }[];
        failedResults: {
            url: string;
            error: string;
        }[];
    }>;
    webMap: import("ai").Tool<{
        url: string;
        instructions?: string | undefined;
        maxDepth?: number | undefined;
        limit?: number | undefined;
        allowExternal?: boolean | undefined;
    }, {
        baseUrl: string;
        results: string[];
    }>;
    deepResearch: import("ai").Tool<{
        input: string;
        model?: "mini" | "pro" | undefined;
        timeoutSeconds?: number | undefined;
        pollIntervalSeconds?: number | undefined;
    }, {
        requestId: string;
        status: string;
        content: string;
        sources: {
            title: string;
            url: string;
        }[];
        message?: never;
    } | {
        requestId: string;
        status: string;
        message: string;
        content?: never;
        sources?: never;
    }>;
    appKnowledge: import("ai").Tool<{
        key: "agent-docs" | "readme";
    }, string>;
    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;
    }>;
    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;
    }>;
    getCurrentTime: import("ai").Tool<{
        timeZone?: string | undefined;
    }, {
        iso: string;
        unixMs: number;
        timeZone: string;
        formatted: string;
    }>;
}, never>;
//# sourceMappingURL=developer-helper.agent.d.ts.map