@mastra/agent-builder 0.0.0-experimental-agent-builder-20250815195917 → 0.0.0-issue-7498-20250905233741

package/dist/defaults.d.ts

@@ -0,0 +1,3548 @@
+import { z } from 'zod';
+export declare class AgentBuilderDefaults {
+    static DEFAULT_INSTRUCTIONS: (projectPath?: string) => string;
+    static DEFAULT_MEMORY_CONFIG: {
+        lastMessages: number;
+    };
+    static DEFAULT_FOLDER_STRUCTURE: {
+        agent: string;
+        workflow: string;
+        tool: string;
+        'mcp-server': string;
+        network: string;
+    };
+    static DEFAULT_TOOLS: (projectPath: string) => Promise<{
+        readFile: import("@mastra/core/tools").Tool<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            encoding: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            encoding: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+        }, {
+            filePath: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            encoding?: string | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            content: z.ZodOptional<z.ZodString>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            metadata: z.ZodOptional<z.ZodObject<{
+                size: z.ZodNumber;
+                totalLines: z.ZodNumber;
+                encoding: z.ZodString;
+                lastModified: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                encoding: string;
+                size: number;
+                totalLines: number;
+                lastModified: string;
+            }, {
+                encoding: string;
+                size: number;
+                totalLines: number;
+                lastModified: string;
+            }>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            error?: string | undefined;
+            content?: string | undefined;
+            lines?: string[] | undefined;
+            metadata?: {
+                encoding: string;
+                size: number;
+                totalLines: number;
+                lastModified: string;
+            } | undefined;
+        }, {
+            success: boolean;
+            error?: string | undefined;
+            content?: string | undefined;
+            lines?: string[] | undefined;
+            metadata?: {
+                encoding: string;
+                size: number;
+                totalLines: number;
+                lastModified: string;
+            } | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            encoding: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            encoding: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+        }, {
+            filePath: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            encoding?: string | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                encoding: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                encoding: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+            }, {
+                filePath: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+                encoding?: string | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                content: z.ZodOptional<z.ZodString>;
+                lines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                metadata: z.ZodOptional<z.ZodObject<{
+                    size: z.ZodNumber;
+                    totalLines: z.ZodNumber;
+                    encoding: z.ZodString;
+                    lastModified: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    encoding: string;
+                    size: number;
+                    totalLines: number;
+                    lastModified: string;
+                }, {
+                    encoding: string;
+                    size: number;
+                    totalLines: number;
+                    lastModified: string;
+                }>>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                error?: string | undefined;
+                content?: string | undefined;
+                lines?: string[] | undefined;
+                metadata?: {
+                    encoding: string;
+                    size: number;
+                    totalLines: number;
+                    lastModified: string;
+                } | undefined;
+            }, {
+                success: boolean;
+                error?: string | undefined;
+                content?: string | undefined;
+                lines?: string[] | undefined;
+                metadata?: {
+                    encoding: string;
+                    size: number;
+                    totalLines: number;
+                    lastModified: string;
+                } | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                encoding: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                encoding: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+            }, {
+                filePath: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+                encoding?: string | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        writeFile: import("@mastra/core/tools").Tool<z.ZodObject<{
+            filePath: z.ZodString;
+            content: z.ZodString;
+            createDirs: z.ZodDefault<z.ZodBoolean>;
+            encoding: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            encoding: string;
+            content: string;
+            createDirs: boolean;
+        }, {
+            filePath: string;
+            content: string;
+            encoding?: string | undefined;
+            createDirs?: boolean | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            filePath: z.ZodString;
+            bytesWritten: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            success: boolean;
+            filePath: string;
+            error?: string | undefined;
+            bytesWritten?: number | undefined;
+        }, {
+            message: string;
+            success: boolean;
+            filePath: string;
+            error?: string | undefined;
+            bytesWritten?: number | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            filePath: z.ZodString;
+            content: z.ZodString;
+            createDirs: z.ZodDefault<z.ZodBoolean>;
+            encoding: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            encoding: string;
+            content: string;
+            createDirs: boolean;
+        }, {
+            filePath: string;
+            content: string;
+            encoding?: string | undefined;
+            createDirs?: boolean | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                filePath: z.ZodString;
+                content: z.ZodString;
+                createDirs: z.ZodDefault<z.ZodBoolean>;
+                encoding: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                encoding: string;
+                content: string;
+                createDirs: boolean;
+            }, {
+                filePath: string;
+                content: string;
+                encoding?: string | undefined;
+                createDirs?: boolean | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                filePath: z.ZodString;
+                bytesWritten: z.ZodOptional<z.ZodNumber>;
+                message: z.ZodString;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                success: boolean;
+                filePath: string;
+                error?: string | undefined;
+                bytesWritten?: number | undefined;
+            }, {
+                message: string;
+                success: boolean;
+                filePath: string;
+                error?: string | undefined;
+                bytesWritten?: number | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                filePath: z.ZodString;
+                content: z.ZodString;
+                createDirs: z.ZodDefault<z.ZodBoolean>;
+                encoding: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                encoding: string;
+                content: string;
+                createDirs: boolean;
+            }, {
+                filePath: string;
+                content: string;
+                encoding?: string | undefined;
+                createDirs?: boolean | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        listDirectory: import("@mastra/core/tools").Tool<z.ZodObject<{
+            path: z.ZodString;
+            recursive: z.ZodDefault<z.ZodBoolean>;
+            includeHidden: z.ZodDefault<z.ZodBoolean>;
+            pattern: z.ZodDefault<z.ZodString>;
+            maxDepth: z.ZodDefault<z.ZodNumber>;
+            includeMetadata: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            recursive: boolean;
+            includeHidden: boolean;
+            pattern: string;
+            maxDepth: number;
+            includeMetadata: boolean;
+        }, {
+            path: string;
+            recursive?: boolean | undefined;
+            includeHidden?: boolean | undefined;
+            pattern?: string | undefined;
+            maxDepth?: number | undefined;
+            includeMetadata?: boolean | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            items: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                path: z.ZodString;
+                type: z.ZodEnum<["file", "directory", "symlink"]>;
+                size: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodString>;
+                permissions: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                type: "file" | "directory" | "symlink";
+                name: string;
+                size?: number | undefined;
+                lastModified?: string | undefined;
+                permissions?: string | undefined;
+            }, {
+                path: string;
+                type: "file" | "directory" | "symlink";
+                name: string;
+                size?: number | undefined;
+                lastModified?: string | undefined;
+                permissions?: string | undefined;
+            }>, "many">;
+            totalItems: z.ZodNumber;
+            path: z.ZodString;
+            message: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            message: string;
+            success: boolean;
+            items: {
+                path: string;
+                type: "file" | "directory" | "symlink";
+                name: string;
+                size?: number | undefined;
+                lastModified?: string | undefined;
+                permissions?: string | undefined;
+            }[];
+            totalItems: number;
+            error?: string | undefined;
+        }, {
+            path: string;
+            message: string;
+            success: boolean;
+            items: {
+                path: string;
+                type: "file" | "directory" | "symlink";
+                name: string;
+                size?: number | undefined;
+                lastModified?: string | undefined;
+                permissions?: string | undefined;
+            }[];
+            totalItems: number;
+            error?: string | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            path: z.ZodString;
+            recursive: z.ZodDefault<z.ZodBoolean>;
+            includeHidden: z.ZodDefault<z.ZodBoolean>;
+            pattern: z.ZodDefault<z.ZodString>;
+            maxDepth: z.ZodDefault<z.ZodNumber>;
+            includeMetadata: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            recursive: boolean;
+            includeHidden: boolean;
+            pattern: string;
+            maxDepth: number;
+            includeMetadata: boolean;
+        }, {
+            path: string;
+            recursive?: boolean | undefined;
+            includeHidden?: boolean | undefined;
+            pattern?: string | undefined;
+            maxDepth?: number | undefined;
+            includeMetadata?: boolean | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                path: z.ZodString;
+                recursive: z.ZodDefault<z.ZodBoolean>;
+                includeHidden: z.ZodDefault<z.ZodBoolean>;
+                pattern: z.ZodDefault<z.ZodString>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+                includeMetadata: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                recursive: boolean;
+                includeHidden: boolean;
+                pattern: string;
+                maxDepth: number;
+                includeMetadata: boolean;
+            }, {
+                path: string;
+                recursive?: boolean | undefined;
+                includeHidden?: boolean | undefined;
+                pattern?: string | undefined;
+                maxDepth?: number | undefined;
+                includeMetadata?: boolean | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                items: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    path: z.ZodString;
+                    type: z.ZodEnum<["file", "directory", "symlink"]>;
+                    size: z.ZodOptional<z.ZodNumber>;
+                    lastModified: z.ZodOptional<z.ZodString>;
+                    permissions: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    type: "file" | "directory" | "symlink";
+                    name: string;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                    permissions?: string | undefined;
+                }, {
+                    path: string;
+                    type: "file" | "directory" | "symlink";
+                    name: string;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                    permissions?: string | undefined;
+                }>, "many">;
+                totalItems: z.ZodNumber;
+                path: z.ZodString;
+                message: z.ZodString;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                message: string;
+                success: boolean;
+                items: {
+                    path: string;
+                    type: "file" | "directory" | "symlink";
+                    name: string;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                    permissions?: string | undefined;
+                }[];
+                totalItems: number;
+                error?: string | undefined;
+            }, {
+                path: string;
+                message: string;
+                success: boolean;
+                items: {
+                    path: string;
+                    type: "file" | "directory" | "symlink";
+                    name: string;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                    permissions?: string | undefined;
+                }[];
+                totalItems: number;
+                error?: string | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                path: z.ZodString;
+                recursive: z.ZodDefault<z.ZodBoolean>;
+                includeHidden: z.ZodDefault<z.ZodBoolean>;
+                pattern: z.ZodDefault<z.ZodString>;
+                maxDepth: z.ZodDefault<z.ZodNumber>;
+                includeMetadata: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                recursive: boolean;
+                includeHidden: boolean;
+                pattern: string;
+                maxDepth: number;
+                includeMetadata: boolean;
+            }, {
+                path: string;
+                recursive?: boolean | undefined;
+                includeHidden?: boolean | undefined;
+                pattern?: string | undefined;
+                maxDepth?: number | undefined;
+                includeMetadata?: boolean | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        executeCommand: import("@mastra/core/tools").Tool<z.ZodObject<{
+            command: z.ZodString;
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            captureOutput: z.ZodDefault<z.ZodBoolean>;
+            shell: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            command: string;
+            timeout: number;
+            captureOutput: boolean;
+            workingDirectory?: string | undefined;
+            shell?: string | undefined;
+            env?: Record<string, string> | undefined;
+        }, {
+            command: string;
+            workingDirectory?: string | undefined;
+            timeout?: number | undefined;
+            captureOutput?: boolean | undefined;
+            shell?: string | undefined;
+            env?: Record<string, string> | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            stdout: z.ZodOptional<z.ZodString>;
+            stderr: z.ZodOptional<z.ZodString>;
+            command: z.ZodString;
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            executionTime: z.ZodOptional<z.ZodNumber>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            command: string;
+            error?: string | undefined;
+            stdout?: string | undefined;
+            stderr?: string | undefined;
+            workingDirectory?: string | undefined;
+            exitCode?: number | undefined;
+            executionTime?: number | undefined;
+        }, {
+            success: boolean;
+            command: string;
+            error?: string | undefined;
+            stdout?: string | undefined;
+            stderr?: string | undefined;
+            workingDirectory?: string | undefined;
+            exitCode?: number | undefined;
+            executionTime?: number | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            command: z.ZodString;
+            workingDirectory: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            captureOutput: z.ZodDefault<z.ZodBoolean>;
+            shell: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            command: string;
+            timeout: number;
+            captureOutput: boolean;
+            workingDirectory?: string | undefined;
+            shell?: string | undefined;
+            env?: Record<string, string> | undefined;
+        }, {
+            command: string;
+            workingDirectory?: string | undefined;
+            timeout?: number | undefined;
+            captureOutput?: boolean | undefined;
+            shell?: string | undefined;
+            env?: Record<string, string> | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                command: z.ZodString;
+                workingDirectory: z.ZodOptional<z.ZodString>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                captureOutput: z.ZodDefault<z.ZodBoolean>;
+                shell: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                command: string;
+                timeout: number;
+                captureOutput: boolean;
+                workingDirectory?: string | undefined;
+                shell?: string | undefined;
+                env?: Record<string, string> | undefined;
+            }, {
+                command: string;
+                workingDirectory?: string | undefined;
+                timeout?: number | undefined;
+                captureOutput?: boolean | undefined;
+                shell?: string | undefined;
+                env?: Record<string, string> | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                exitCode: z.ZodOptional<z.ZodNumber>;
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                command: z.ZodString;
+                workingDirectory: z.ZodOptional<z.ZodString>;
+                executionTime: z.ZodOptional<z.ZodNumber>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                command: string;
+                error?: string | undefined;
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+                workingDirectory?: string | undefined;
+                exitCode?: number | undefined;
+                executionTime?: number | undefined;
+            }, {
+                success: boolean;
+                command: string;
+                error?: string | undefined;
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+                workingDirectory?: string | undefined;
+                exitCode?: number | undefined;
+                executionTime?: number | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                command: z.ZodString;
+                workingDirectory: z.ZodOptional<z.ZodString>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                captureOutput: z.ZodDefault<z.ZodBoolean>;
+                shell: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                command: string;
+                timeout: number;
+                captureOutput: boolean;
+                workingDirectory?: string | undefined;
+                shell?: string | undefined;
+                env?: Record<string, string> | undefined;
+            }, {
+                command: string;
+                workingDirectory?: string | undefined;
+                timeout?: number | undefined;
+                captureOutput?: boolean | undefined;
+                shell?: string | undefined;
+                env?: Record<string, string> | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        taskManager: import("@mastra/core/tools").Tool<z.ZodObject<{
+            action: z.ZodEnum<["create", "update", "list", "complete", "remove"]>;
+            tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+                priority: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                notes: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                priority: "high" | "medium" | "low";
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                notes?: string | undefined;
+            }, {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                priority?: "high" | "medium" | "low" | undefined;
+                notes?: string | undefined;
+            }>, "many">>;
+            taskId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            action: "create" | "update" | "list" | "complete" | "remove";
+            tasks?: {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                priority: "high" | "medium" | "low";
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                notes?: string | undefined;
+            }[] | undefined;
+            taskId?: string | undefined;
+        }, {
+            action: "create" | "update" | "list" | "complete" | "remove";
+            tasks?: {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                priority?: "high" | "medium" | "low" | undefined;
+                notes?: string | undefined;
+            }[] | undefined;
+            taskId?: string | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            tasks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodString;
+                status: z.ZodString;
+                priority: z.ZodString;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                notes: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                status: string;
+                id: string;
+                content: string;
+                priority: string;
+                createdAt: string;
+                updatedAt: string;
+                dependencies?: string[] | undefined;
+                notes?: string | undefined;
+            }, {
+                status: string;
+                id: string;
+                content: string;
+                priority: string;
+                createdAt: string;
+                updatedAt: string;
+                dependencies?: string[] | undefined;
+                notes?: string | undefined;
+            }>, "many">;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            success: boolean;
+            tasks: {
+                status: string;
+                id: string;
+                content: string;
+                priority: string;
+                createdAt: string;
+                updatedAt: string;
+                dependencies?: string[] | undefined;
+                notes?: string | undefined;
+            }[];
+        }, {
+            message: string;
+            success: boolean;
+            tasks: {
+                status: string;
+                id: string;
+                content: string;
+                priority: string;
+                createdAt: string;
+                updatedAt: string;
+                dependencies?: string[] | undefined;
+                notes?: string | undefined;
+            }[];
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            action: z.ZodEnum<["create", "update", "list", "complete", "remove"]>;
+            tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+                priority: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                notes: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                priority: "high" | "medium" | "low";
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                notes?: string | undefined;
+            }, {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                priority?: "high" | "medium" | "low" | undefined;
+                notes?: string | undefined;
+            }>, "many">>;
+            taskId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            action: "create" | "update" | "list" | "complete" | "remove";
+            tasks?: {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                priority: "high" | "medium" | "low";
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                notes?: string | undefined;
+            }[] | undefined;
+            taskId?: string | undefined;
+        }, {
+            action: "create" | "update" | "list" | "complete" | "remove";
+            tasks?: {
+                status: "pending" | "in_progress" | "completed" | "blocked";
+                id: string;
+                dependencies?: string[] | undefined;
+                content?: string | undefined;
+                priority?: "high" | "medium" | "low" | undefined;
+                notes?: string | undefined;
+            }[] | undefined;
+            taskId?: string | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                action: z.ZodEnum<["create", "update", "list", "complete", "remove"]>;
+                tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    content: z.ZodOptional<z.ZodString>;
+                    status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+                    priority: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+                    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    notes: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    priority: "high" | "medium" | "low";
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    notes?: string | undefined;
+                }, {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    priority?: "high" | "medium" | "low" | undefined;
+                    notes?: string | undefined;
+                }>, "many">>;
+                taskId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                action: "create" | "update" | "list" | "complete" | "remove";
+                tasks?: {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    priority: "high" | "medium" | "low";
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    notes?: string | undefined;
+                }[] | undefined;
+                taskId?: string | undefined;
+            }, {
+                action: "create" | "update" | "list" | "complete" | "remove";
+                tasks?: {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    priority?: "high" | "medium" | "low" | undefined;
+                    notes?: string | undefined;
+                }[] | undefined;
+                taskId?: string | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                tasks: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    content: z.ZodString;
+                    status: z.ZodString;
+                    priority: z.ZodString;
+                    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    notes: z.ZodOptional<z.ZodString>;
+                    createdAt: z.ZodString;
+                    updatedAt: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    status: string;
+                    id: string;
+                    content: string;
+                    priority: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    dependencies?: string[] | undefined;
+                    notes?: string | undefined;
+                }, {
+                    status: string;
+                    id: string;
+                    content: string;
+                    priority: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    dependencies?: string[] | undefined;
+                    notes?: string | undefined;
+                }>, "many">;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                success: boolean;
+                tasks: {
+                    status: string;
+                    id: string;
+                    content: string;
+                    priority: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    dependencies?: string[] | undefined;
+                    notes?: string | undefined;
+                }[];
+            }, {
+                message: string;
+                success: boolean;
+                tasks: {
+                    status: string;
+                    id: string;
+                    content: string;
+                    priority: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    dependencies?: string[] | undefined;
+                    notes?: string | undefined;
+                }[];
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                action: z.ZodEnum<["create", "update", "list", "complete", "remove"]>;
+                tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    content: z.ZodOptional<z.ZodString>;
+                    status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+                    priority: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+                    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    notes: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    priority: "high" | "medium" | "low";
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    notes?: string | undefined;
+                }, {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    priority?: "high" | "medium" | "low" | undefined;
+                    notes?: string | undefined;
+                }>, "many">>;
+                taskId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                action: "create" | "update" | "list" | "complete" | "remove";
+                tasks?: {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    priority: "high" | "medium" | "low";
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    notes?: string | undefined;
+                }[] | undefined;
+                taskId?: string | undefined;
+            }, {
+                action: "create" | "update" | "list" | "complete" | "remove";
+                tasks?: {
+                    status: "pending" | "in_progress" | "completed" | "blocked";
+                    id: string;
+                    dependencies?: string[] | undefined;
+                    content?: string | undefined;
+                    priority?: "high" | "medium" | "low" | undefined;
+                    notes?: string | undefined;
+                }[] | undefined;
+                taskId?: string | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        multiEdit: import("@mastra/core/tools").Tool<z.ZodObject<{
+            operations: z.ZodArray<z.ZodObject<{
+                filePath: z.ZodString;
+                edits: z.ZodArray<z.ZodObject<{
+                    oldString: z.ZodString;
+                    newString: z.ZodString;
+                    replaceAll: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }, {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                edits: {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }[];
+            }, {
+                filePath: string;
+                edits: {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }[];
+            }>, "many">;
+            createBackup: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            operations: {
+                filePath: string;
+                edits: {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }[];
+            }[];
+            createBackup: boolean;
+        }, {
+            operations: {
+                filePath: string;
+                edits: {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }[];
+            }[];
+            createBackup?: boolean | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            results: z.ZodArray<z.ZodObject<{
+                filePath: z.ZodString;
+                editsApplied: z.ZodNumber;
+                errors: z.ZodArray<z.ZodString, "many">;
+                backup: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                errors: string[];
+                filePath: string;
+                editsApplied: number;
+                backup?: string | undefined;
+            }, {
+                errors: string[];
+                filePath: string;
+                editsApplied: number;
+                backup?: string | undefined;
+            }>, "many">;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            success: boolean;
+            results: {
+                errors: string[];
+                filePath: string;
+                editsApplied: number;
+                backup?: string | undefined;
+            }[];
+        }, {
+            message: string;
+            success: boolean;
+            results: {
+                errors: string[];
+                filePath: string;
+                editsApplied: number;
+                backup?: string | undefined;
+            }[];
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            operations: z.ZodArray<z.ZodObject<{
+                filePath: z.ZodString;
+                edits: z.ZodArray<z.ZodObject<{
+                    oldString: z.ZodString;
+                    newString: z.ZodString;
+                    replaceAll: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }, {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                edits: {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }[];
+            }, {
+                filePath: string;
+                edits: {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }[];
+            }>, "many">;
+            createBackup: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            operations: {
+                filePath: string;
+                edits: {
+                    replaceAll: boolean;
+                    oldString: string;
+                    newString: string;
+                }[];
+            }[];
+            createBackup: boolean;
+        }, {
+            operations: {
+                filePath: string;
+                edits: {
+                    oldString: string;
+                    newString: string;
+                    replaceAll?: boolean | undefined;
+                }[];
+            }[];
+            createBackup?: boolean | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                operations: z.ZodArray<z.ZodObject<{
+                    filePath: z.ZodString;
+                    edits: z.ZodArray<z.ZodObject<{
+                        oldString: z.ZodString;
+                        newString: z.ZodString;
+                        replaceAll: z.ZodDefault<z.ZodBoolean>;
+                    }, "strip", z.ZodTypeAny, {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }, {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    filePath: string;
+                    edits: {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }[];
+                }, {
+                    filePath: string;
+                    edits: {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }[];
+                }>, "many">;
+                createBackup: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                operations: {
+                    filePath: string;
+                    edits: {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }[];
+                }[];
+                createBackup: boolean;
+            }, {
+                operations: {
+                    filePath: string;
+                    edits: {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }[];
+                }[];
+                createBackup?: boolean | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                results: z.ZodArray<z.ZodObject<{
+                    filePath: z.ZodString;
+                    editsApplied: z.ZodNumber;
+                    errors: z.ZodArray<z.ZodString, "many">;
+                    backup: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    errors: string[];
+                    filePath: string;
+                    editsApplied: number;
+                    backup?: string | undefined;
+                }, {
+                    errors: string[];
+                    filePath: string;
+                    editsApplied: number;
+                    backup?: string | undefined;
+                }>, "many">;
+                message: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                success: boolean;
+                results: {
+                    errors: string[];
+                    filePath: string;
+                    editsApplied: number;
+                    backup?: string | undefined;
+                }[];
+            }, {
+                message: string;
+                success: boolean;
+                results: {
+                    errors: string[];
+                    filePath: string;
+                    editsApplied: number;
+                    backup?: string | undefined;
+                }[];
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                operations: z.ZodArray<z.ZodObject<{
+                    filePath: z.ZodString;
+                    edits: z.ZodArray<z.ZodObject<{
+                        oldString: z.ZodString;
+                        newString: z.ZodString;
+                        replaceAll: z.ZodDefault<z.ZodBoolean>;
+                    }, "strip", z.ZodTypeAny, {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }, {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    filePath: string;
+                    edits: {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }[];
+                }, {
+                    filePath: string;
+                    edits: {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }[];
+                }>, "many">;
+                createBackup: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                operations: {
+                    filePath: string;
+                    edits: {
+                        replaceAll: boolean;
+                        oldString: string;
+                        newString: string;
+                    }[];
+                }[];
+                createBackup: boolean;
+            }, {
+                operations: {
+                    filePath: string;
+                    edits: {
+                        oldString: string;
+                        newString: string;
+                        replaceAll?: boolean | undefined;
+                    }[];
+                }[];
+                createBackup?: boolean | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        replaceLines: import("@mastra/core/tools").Tool<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            newContent: z.ZodString;
+            createBackup: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            startLine: number;
+            endLine: number;
+            createBackup: boolean;
+            newContent: string;
+        }, {
+            filePath: string;
+            startLine: number;
+            endLine: number;
+            newContent: string;
+            createBackup?: boolean | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            message: z.ZodString;
+            linesReplaced: z.ZodOptional<z.ZodNumber>;
+            backup: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            success: boolean;
+            error?: string | undefined;
+            backup?: string | undefined;
+            linesReplaced?: number | undefined;
+        }, {
+            message: string;
+            success: boolean;
+            error?: string | undefined;
+            backup?: string | undefined;
+            linesReplaced?: number | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            newContent: z.ZodString;
+            createBackup: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            startLine: number;
+            endLine: number;
+            createBackup: boolean;
+            newContent: string;
+        }, {
+            filePath: string;
+            startLine: number;
+            endLine: number;
+            newContent: string;
+            createBackup?: boolean | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                newContent: z.ZodString;
+                createBackup: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                startLine: number;
+                endLine: number;
+                createBackup: boolean;
+                newContent: string;
+            }, {
+                filePath: string;
+                startLine: number;
+                endLine: number;
+                newContent: string;
+                createBackup?: boolean | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                message: z.ZodString;
+                linesReplaced: z.ZodOptional<z.ZodNumber>;
+                backup: z.ZodOptional<z.ZodString>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                success: boolean;
+                error?: string | undefined;
+                backup?: string | undefined;
+                linesReplaced?: number | undefined;
+            }, {
+                message: string;
+                success: boolean;
+                error?: string | undefined;
+                backup?: string | undefined;
+                linesReplaced?: number | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                newContent: z.ZodString;
+                createBackup: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                startLine: number;
+                endLine: number;
+                createBackup: boolean;
+                newContent: string;
+            }, {
+                filePath: string;
+                startLine: number;
+                endLine: number;
+                newContent: string;
+                createBackup?: boolean | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        showFileLines: import("@mastra/core/tools").Tool<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            context: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            context: number;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+        }, {
+            filePath: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            context?: number | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            lines: z.ZodArray<z.ZodObject<{
+                lineNumber: z.ZodNumber;
+                content: z.ZodString;
+                isTarget: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                content: string;
+                lineNumber: number;
+                isTarget: boolean;
+            }, {
+                content: string;
+                lineNumber: number;
+                isTarget: boolean;
+            }>, "many">;
+            totalLines: z.ZodNumber;
+            message: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            success: boolean;
+            lines: {
+                content: string;
+                lineNumber: number;
+                isTarget: boolean;
+            }[];
+            totalLines: number;
+            error?: string | undefined;
+        }, {
+            message: string;
+            success: boolean;
+            lines: {
+                content: string;
+                lineNumber: number;
+                isTarget: boolean;
+            }[];
+            totalLines: number;
+            error?: string | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            filePath: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            context: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            context: number;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+        }, {
+            filePath: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            context?: number | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                context: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                context: number;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+            }, {
+                filePath: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+                context?: number | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                lines: z.ZodArray<z.ZodObject<{
+                    lineNumber: z.ZodNumber;
+                    content: z.ZodString;
+                    isTarget: z.ZodBoolean;
+                }, "strip", z.ZodTypeAny, {
+                    content: string;
+                    lineNumber: number;
+                    isTarget: boolean;
+                }, {
+                    content: string;
+                    lineNumber: number;
+                    isTarget: boolean;
+                }>, "many">;
+                totalLines: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                success: boolean;
+                lines: {
+                    content: string;
+                    lineNumber: number;
+                    isTarget: boolean;
+                }[];
+                totalLines: number;
+                error?: string | undefined;
+            }, {
+                message: string;
+                success: boolean;
+                lines: {
+                    content: string;
+                    lineNumber: number;
+                    isTarget: boolean;
+                }[];
+                totalLines: number;
+                error?: string | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                filePath: z.ZodString;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                context: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                filePath: string;
+                context: number;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+            }, {
+                filePath: string;
+                startLine?: number | undefined;
+                endLine?: number | undefined;
+                context?: number | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        smartSearch: import("@mastra/core/tools").Tool<z.ZodObject<{
+            query: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<["text", "regex", "fuzzy", "semantic"]>>;
+            scope: z.ZodOptional<z.ZodObject<{
+                paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                fileTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                maxResults: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                maxResults: number;
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+            }, {
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+                maxResults?: number | undefined;
+            }>>;
+            context: z.ZodOptional<z.ZodObject<{
+                beforeLines: z.ZodDefault<z.ZodNumber>;
+                afterLines: z.ZodDefault<z.ZodNumber>;
+                includeDefinitions: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                beforeLines: number;
+                afterLines: number;
+                includeDefinitions: boolean;
+            }, {
+                beforeLines?: number | undefined;
+                afterLines?: number | undefined;
+                includeDefinitions?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "text" | "regex" | "fuzzy" | "semantic";
+            query: string;
+            context?: {
+                beforeLines: number;
+                afterLines: number;
+                includeDefinitions: boolean;
+            } | undefined;
+            scope?: {
+                maxResults: number;
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+            } | undefined;
+        }, {
+            query: string;
+            type?: "text" | "regex" | "fuzzy" | "semantic" | undefined;
+            context?: {
+                beforeLines?: number | undefined;
+                afterLines?: number | undefined;
+                includeDefinitions?: boolean | undefined;
+            } | undefined;
+            scope?: {
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+                maxResults?: number | undefined;
+            } | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            matches: z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodNumber;
+                column: z.ZodOptional<z.ZodNumber>;
+                match: z.ZodString;
+                context: z.ZodObject<{
+                    before: z.ZodArray<z.ZodString, "many">;
+                    after: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    before: string[];
+                    after: string[];
+                }, {
+                    before: string[];
+                    after: string[];
+                }>;
+                relevance: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                file: string;
+                match: string;
+                context: {
+                    before: string[];
+                    after: string[];
+                };
+                line: number;
+                column?: number | undefined;
+                relevance?: number | undefined;
+            }, {
+                file: string;
+                match: string;
+                context: {
+                    before: string[];
+                    after: string[];
+                };
+                line: number;
+                column?: number | undefined;
+                relevance?: number | undefined;
+            }>, "many">;
+            summary: z.ZodObject<{
+                totalMatches: z.ZodNumber;
+                filesSearched: z.ZodNumber;
+                patterns: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                totalMatches: number;
+                filesSearched: number;
+                patterns: string[];
+            }, {
+                totalMatches: number;
+                filesSearched: number;
+                patterns: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            matches: {
+                file: string;
+                match: string;
+                context: {
+                    before: string[];
+                    after: string[];
+                };
+                line: number;
+                column?: number | undefined;
+                relevance?: number | undefined;
+            }[];
+            summary: {
+                totalMatches: number;
+                filesSearched: number;
+                patterns: string[];
+            };
+        }, {
+            success: boolean;
+            matches: {
+                file: string;
+                match: string;
+                context: {
+                    before: string[];
+                    after: string[];
+                };
+                line: number;
+                column?: number | undefined;
+                relevance?: number | undefined;
+            }[];
+            summary: {
+                totalMatches: number;
+                filesSearched: number;
+                patterns: string[];
+            };
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            query: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<["text", "regex", "fuzzy", "semantic"]>>;
+            scope: z.ZodOptional<z.ZodObject<{
+                paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                fileTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                maxResults: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                maxResults: number;
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+            }, {
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+                maxResults?: number | undefined;
+            }>>;
+            context: z.ZodOptional<z.ZodObject<{
+                beforeLines: z.ZodDefault<z.ZodNumber>;
+                afterLines: z.ZodDefault<z.ZodNumber>;
+                includeDefinitions: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                beforeLines: number;
+                afterLines: number;
+                includeDefinitions: boolean;
+            }, {
+                beforeLines?: number | undefined;
+                afterLines?: number | undefined;
+                includeDefinitions?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "text" | "regex" | "fuzzy" | "semantic";
+            query: string;
+            context?: {
+                beforeLines: number;
+                afterLines: number;
+                includeDefinitions: boolean;
+            } | undefined;
+            scope?: {
+                maxResults: number;
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+            } | undefined;
+        }, {
+            query: string;
+            type?: "text" | "regex" | "fuzzy" | "semantic" | undefined;
+            context?: {
+                beforeLines?: number | undefined;
+                afterLines?: number | undefined;
+                includeDefinitions?: boolean | undefined;
+            } | undefined;
+            scope?: {
+                paths?: string[] | undefined;
+                fileTypes?: string[] | undefined;
+                excludePaths?: string[] | undefined;
+                maxResults?: number | undefined;
+            } | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                query: z.ZodString;
+                type: z.ZodDefault<z.ZodEnum<["text", "regex", "fuzzy", "semantic"]>>;
+                scope: z.ZodOptional<z.ZodObject<{
+                    paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    fileTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    maxResults: z.ZodDefault<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    maxResults: number;
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                }, {
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                    maxResults?: number | undefined;
+                }>>;
+                context: z.ZodOptional<z.ZodObject<{
+                    beforeLines: z.ZodDefault<z.ZodNumber>;
+                    afterLines: z.ZodDefault<z.ZodNumber>;
+                    includeDefinitions: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    beforeLines: number;
+                    afterLines: number;
+                    includeDefinitions: boolean;
+                }, {
+                    beforeLines?: number | undefined;
+                    afterLines?: number | undefined;
+                    includeDefinitions?: boolean | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "text" | "regex" | "fuzzy" | "semantic";
+                query: string;
+                context?: {
+                    beforeLines: number;
+                    afterLines: number;
+                    includeDefinitions: boolean;
+                } | undefined;
+                scope?: {
+                    maxResults: number;
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                } | undefined;
+            }, {
+                query: string;
+                type?: "text" | "regex" | "fuzzy" | "semantic" | undefined;
+                context?: {
+                    beforeLines?: number | undefined;
+                    afterLines?: number | undefined;
+                    includeDefinitions?: boolean | undefined;
+                } | undefined;
+                scope?: {
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                    maxResults?: number | undefined;
+                } | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                matches: z.ZodArray<z.ZodObject<{
+                    file: z.ZodString;
+                    line: z.ZodNumber;
+                    column: z.ZodOptional<z.ZodNumber>;
+                    match: z.ZodString;
+                    context: z.ZodObject<{
+                        before: z.ZodArray<z.ZodString, "many">;
+                        after: z.ZodArray<z.ZodString, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        before: string[];
+                        after: string[];
+                    }, {
+                        before: string[];
+                        after: string[];
+                    }>;
+                    relevance: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    file: string;
+                    match: string;
+                    context: {
+                        before: string[];
+                        after: string[];
+                    };
+                    line: number;
+                    column?: number | undefined;
+                    relevance?: number | undefined;
+                }, {
+                    file: string;
+                    match: string;
+                    context: {
+                        before: string[];
+                        after: string[];
+                    };
+                    line: number;
+                    column?: number | undefined;
+                    relevance?: number | undefined;
+                }>, "many">;
+                summary: z.ZodObject<{
+                    totalMatches: z.ZodNumber;
+                    filesSearched: z.ZodNumber;
+                    patterns: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    totalMatches: number;
+                    filesSearched: number;
+                    patterns: string[];
+                }, {
+                    totalMatches: number;
+                    filesSearched: number;
+                    patterns: string[];
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                matches: {
+                    file: string;
+                    match: string;
+                    context: {
+                        before: string[];
+                        after: string[];
+                    };
+                    line: number;
+                    column?: number | undefined;
+                    relevance?: number | undefined;
+                }[];
+                summary: {
+                    totalMatches: number;
+                    filesSearched: number;
+                    patterns: string[];
+                };
+            }, {
+                success: boolean;
+                matches: {
+                    file: string;
+                    match: string;
+                    context: {
+                        before: string[];
+                        after: string[];
+                    };
+                    line: number;
+                    column?: number | undefined;
+                    relevance?: number | undefined;
+                }[];
+                summary: {
+                    totalMatches: number;
+                    filesSearched: number;
+                    patterns: string[];
+                };
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                query: z.ZodString;
+                type: z.ZodDefault<z.ZodEnum<["text", "regex", "fuzzy", "semantic"]>>;
+                scope: z.ZodOptional<z.ZodObject<{
+                    paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    fileTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    maxResults: z.ZodDefault<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    maxResults: number;
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                }, {
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                    maxResults?: number | undefined;
+                }>>;
+                context: z.ZodOptional<z.ZodObject<{
+                    beforeLines: z.ZodDefault<z.ZodNumber>;
+                    afterLines: z.ZodDefault<z.ZodNumber>;
+                    includeDefinitions: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    beforeLines: number;
+                    afterLines: number;
+                    includeDefinitions: boolean;
+                }, {
+                    beforeLines?: number | undefined;
+                    afterLines?: number | undefined;
+                    includeDefinitions?: boolean | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "text" | "regex" | "fuzzy" | "semantic";
+                query: string;
+                context?: {
+                    beforeLines: number;
+                    afterLines: number;
+                    includeDefinitions: boolean;
+                } | undefined;
+                scope?: {
+                    maxResults: number;
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                } | undefined;
+            }, {
+                query: string;
+                type?: "text" | "regex" | "fuzzy" | "semantic" | undefined;
+                context?: {
+                    beforeLines?: number | undefined;
+                    afterLines?: number | undefined;
+                    includeDefinitions?: boolean | undefined;
+                } | undefined;
+                scope?: {
+                    paths?: string[] | undefined;
+                    fileTypes?: string[] | undefined;
+                    excludePaths?: string[] | undefined;
+                    maxResults?: number | undefined;
+                } | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        validateCode: import("@mastra/core/tools").Tool<z.ZodObject<{
+            projectPath: z.ZodOptional<z.ZodString>;
+            validationType: z.ZodArray<z.ZodEnum<["types", "lint", "schemas", "tests", "build"]>, "many">;
+            files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+            projectPath?: string | undefined;
+            files?: string[] | undefined;
+        }, {
+            validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+            projectPath?: string | undefined;
+            files?: string[] | undefined;
+        }>, z.ZodObject<{
+            valid: z.ZodBoolean;
+            errors: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["typescript", "eslint", "schema", "test", "build"]>;
+                severity: z.ZodEnum<["error", "warning", "info"]>;
+                message: z.ZodString;
+                file: z.ZodOptional<z.ZodString>;
+                line: z.ZodOptional<z.ZodNumber>;
+                column: z.ZodOptional<z.ZodNumber>;
+                code: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                type: "build" | "typescript" | "eslint" | "schema" | "test";
+                severity: "error" | "warning" | "info";
+                code?: string | undefined;
+                file?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            }, {
+                message: string;
+                type: "build" | "typescript" | "eslint" | "schema" | "test";
+                severity: "error" | "warning" | "info";
+                code?: string | undefined;
+                file?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            }>, "many">;
+            summary: z.ZodObject<{
+                totalErrors: z.ZodNumber;
+                totalWarnings: z.ZodNumber;
+                validationsPassed: z.ZodArray<z.ZodString, "many">;
+                validationsFailed: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                totalErrors: number;
+                totalWarnings: number;
+                validationsPassed: string[];
+                validationsFailed: string[];
+            }, {
+                totalErrors: number;
+                totalWarnings: number;
+                validationsPassed: string[];
+                validationsFailed: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            valid: boolean;
+            errors: {
+                message: string;
+                type: "build" | "typescript" | "eslint" | "schema" | "test";
+                severity: "error" | "warning" | "info";
+                code?: string | undefined;
+                file?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            }[];
+            summary: {
+                totalErrors: number;
+                totalWarnings: number;
+                validationsPassed: string[];
+                validationsFailed: string[];
+            };
+        }, {
+            valid: boolean;
+            errors: {
+                message: string;
+                type: "build" | "typescript" | "eslint" | "schema" | "test";
+                severity: "error" | "warning" | "info";
+                code?: string | undefined;
+                file?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            }[];
+            summary: {
+                totalErrors: number;
+                totalWarnings: number;
+                validationsPassed: string[];
+                validationsFailed: string[];
+            };
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            projectPath: z.ZodOptional<z.ZodString>;
+            validationType: z.ZodArray<z.ZodEnum<["types", "lint", "schemas", "tests", "build"]>, "many">;
+            files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+            projectPath?: string | undefined;
+            files?: string[] | undefined;
+        }, {
+            validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+            projectPath?: string | undefined;
+            files?: string[] | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                projectPath: z.ZodOptional<z.ZodString>;
+                validationType: z.ZodArray<z.ZodEnum<["types", "lint", "schemas", "tests", "build"]>, "many">;
+                files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+                projectPath?: string | undefined;
+                files?: string[] | undefined;
+            }, {
+                validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+                projectPath?: string | undefined;
+                files?: string[] | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                valid: z.ZodBoolean;
+                errors: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<["typescript", "eslint", "schema", "test", "build"]>;
+                    severity: z.ZodEnum<["error", "warning", "info"]>;
+                    message: z.ZodString;
+                    file: z.ZodOptional<z.ZodString>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                    column: z.ZodOptional<z.ZodNumber>;
+                    code: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    type: "build" | "typescript" | "eslint" | "schema" | "test";
+                    severity: "error" | "warning" | "info";
+                    code?: string | undefined;
+                    file?: string | undefined;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }, {
+                    message: string;
+                    type: "build" | "typescript" | "eslint" | "schema" | "test";
+                    severity: "error" | "warning" | "info";
+                    code?: string | undefined;
+                    file?: string | undefined;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }>, "many">;
+                summary: z.ZodObject<{
+                    totalErrors: z.ZodNumber;
+                    totalWarnings: z.ZodNumber;
+                    validationsPassed: z.ZodArray<z.ZodString, "many">;
+                    validationsFailed: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    totalErrors: number;
+                    totalWarnings: number;
+                    validationsPassed: string[];
+                    validationsFailed: string[];
+                }, {
+                    totalErrors: number;
+                    totalWarnings: number;
+                    validationsPassed: string[];
+                    validationsFailed: string[];
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                valid: boolean;
+                errors: {
+                    message: string;
+                    type: "build" | "typescript" | "eslint" | "schema" | "test";
+                    severity: "error" | "warning" | "info";
+                    code?: string | undefined;
+                    file?: string | undefined;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }[];
+                summary: {
+                    totalErrors: number;
+                    totalWarnings: number;
+                    validationsPassed: string[];
+                    validationsFailed: string[];
+                };
+            }, {
+                valid: boolean;
+                errors: {
+                    message: string;
+                    type: "build" | "typescript" | "eslint" | "schema" | "test";
+                    severity: "error" | "warning" | "info";
+                    code?: string | undefined;
+                    file?: string | undefined;
+                    line?: number | undefined;
+                    column?: number | undefined;
+                }[];
+                summary: {
+                    totalErrors: number;
+                    totalWarnings: number;
+                    validationsPassed: string[];
+                    validationsFailed: string[];
+                };
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                projectPath: z.ZodOptional<z.ZodString>;
+                validationType: z.ZodArray<z.ZodEnum<["types", "lint", "schemas", "tests", "build"]>, "many">;
+                files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+                projectPath?: string | undefined;
+                files?: string[] | undefined;
+            }, {
+                validationType: ("types" | "schemas" | "tests" | "lint" | "build")[];
+                projectPath?: string | undefined;
+                files?: string[] | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        webSearch: import("@mastra/core/tools").Tool<z.ZodObject<{
+            query: z.ZodString;
+            maxResults: z.ZodDefault<z.ZodNumber>;
+            region: z.ZodDefault<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
+            includeImages: z.ZodDefault<z.ZodBoolean>;
+            dateRange: z.ZodDefault<z.ZodEnum<["day", "week", "month", "year", "all"]>>;
+        }, "strip", z.ZodTypeAny, {
+            query: string;
+            maxResults: number;
+            region: string;
+            language: string;
+            includeImages: boolean;
+            dateRange: "day" | "week" | "month" | "year" | "all";
+        }, {
+            query: string;
+            maxResults?: number | undefined;
+            region?: string | undefined;
+            language?: string | undefined;
+            includeImages?: boolean | undefined;
+            dateRange?: "day" | "week" | "month" | "year" | "all" | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            query: z.ZodString;
+            results: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                url: z.ZodString;
+                snippet: z.ZodString;
+                domain: z.ZodString;
+                publishDate: z.ZodOptional<z.ZodString>;
+                relevanceScore: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                url: string;
+                snippet: string;
+                domain: string;
+                publishDate?: string | undefined;
+                relevanceScore?: number | undefined;
+            }, {
+                title: string;
+                url: string;
+                snippet: string;
+                domain: string;
+                publishDate?: string | undefined;
+                relevanceScore?: number | undefined;
+            }>, "many">;
+            totalResults: z.ZodNumber;
+            searchTime: z.ZodNumber;
+            suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            results: {
+                title: string;
+                url: string;
+                snippet: string;
+                domain: string;
+                publishDate?: string | undefined;
+                relevanceScore?: number | undefined;
+            }[];
+            query: string;
+            totalResults: number;
+            searchTime: number;
+            error?: string | undefined;
+            suggestions?: string[] | undefined;
+        }, {
+            success: boolean;
+            results: {
+                title: string;
+                url: string;
+                snippet: string;
+                domain: string;
+                publishDate?: string | undefined;
+                relevanceScore?: number | undefined;
+            }[];
+            query: string;
+            totalResults: number;
+            searchTime: number;
+            error?: string | undefined;
+            suggestions?: string[] | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            query: z.ZodString;
+            maxResults: z.ZodDefault<z.ZodNumber>;
+            region: z.ZodDefault<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
+            includeImages: z.ZodDefault<z.ZodBoolean>;
+            dateRange: z.ZodDefault<z.ZodEnum<["day", "week", "month", "year", "all"]>>;
+        }, "strip", z.ZodTypeAny, {
+            query: string;
+            maxResults: number;
+            region: string;
+            language: string;
+            includeImages: boolean;
+            dateRange: "day" | "week" | "month" | "year" | "all";
+        }, {
+            query: string;
+            maxResults?: number | undefined;
+            region?: string | undefined;
+            language?: string | undefined;
+            includeImages?: boolean | undefined;
+            dateRange?: "day" | "week" | "month" | "year" | "all" | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                query: z.ZodString;
+                maxResults: z.ZodDefault<z.ZodNumber>;
+                region: z.ZodDefault<z.ZodString>;
+                language: z.ZodDefault<z.ZodString>;
+                includeImages: z.ZodDefault<z.ZodBoolean>;
+                dateRange: z.ZodDefault<z.ZodEnum<["day", "week", "month", "year", "all"]>>;
+            }, "strip", z.ZodTypeAny, {
+                query: string;
+                maxResults: number;
+                region: string;
+                language: string;
+                includeImages: boolean;
+                dateRange: "day" | "week" | "month" | "year" | "all";
+            }, {
+                query: string;
+                maxResults?: number | undefined;
+                region?: string | undefined;
+                language?: string | undefined;
+                includeImages?: boolean | undefined;
+                dateRange?: "day" | "week" | "month" | "year" | "all" | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                query: z.ZodString;
+                results: z.ZodArray<z.ZodObject<{
+                    title: z.ZodString;
+                    url: z.ZodString;
+                    snippet: z.ZodString;
+                    domain: z.ZodString;
+                    publishDate: z.ZodOptional<z.ZodString>;
+                    relevanceScore: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    title: string;
+                    url: string;
+                    snippet: string;
+                    domain: string;
+                    publishDate?: string | undefined;
+                    relevanceScore?: number | undefined;
+                }, {
+                    title: string;
+                    url: string;
+                    snippet: string;
+                    domain: string;
+                    publishDate?: string | undefined;
+                    relevanceScore?: number | undefined;
+                }>, "many">;
+                totalResults: z.ZodNumber;
+                searchTime: z.ZodNumber;
+                suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                results: {
+                    title: string;
+                    url: string;
+                    snippet: string;
+                    domain: string;
+                    publishDate?: string | undefined;
+                    relevanceScore?: number | undefined;
+                }[];
+                query: string;
+                totalResults: number;
+                searchTime: number;
+                error?: string | undefined;
+                suggestions?: string[] | undefined;
+            }, {
+                success: boolean;
+                results: {
+                    title: string;
+                    url: string;
+                    snippet: string;
+                    domain: string;
+                    publishDate?: string | undefined;
+                    relevanceScore?: number | undefined;
+                }[];
+                query: string;
+                totalResults: number;
+                searchTime: number;
+                error?: string | undefined;
+                suggestions?: string[] | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                query: z.ZodString;
+                maxResults: z.ZodDefault<z.ZodNumber>;
+                region: z.ZodDefault<z.ZodString>;
+                language: z.ZodDefault<z.ZodString>;
+                includeImages: z.ZodDefault<z.ZodBoolean>;
+                dateRange: z.ZodDefault<z.ZodEnum<["day", "week", "month", "year", "all"]>>;
+            }, "strip", z.ZodTypeAny, {
+                query: string;
+                maxResults: number;
+                region: string;
+                language: string;
+                includeImages: boolean;
+                dateRange: "day" | "week" | "month" | "year" | "all";
+            }, {
+                query: string;
+                maxResults?: number | undefined;
+                region?: string | undefined;
+                language?: string | undefined;
+                includeImages?: boolean | undefined;
+                dateRange?: "day" | "week" | "month" | "year" | "all" | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        attemptCompletion: import("@mastra/core/tools").Tool<z.ZodObject<{
+            summary: z.ZodString;
+            changes: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]>;
+                description: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }, {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }>, "many">;
+            validation: z.ZodObject<{
+                testsRun: z.ZodDefault<z.ZodBoolean>;
+                buildsSuccessfully: z.ZodDefault<z.ZodBoolean>;
+                manualTestingRequired: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                testsRun: boolean;
+                buildsSuccessfully: boolean;
+                manualTestingRequired: boolean;
+            }, {
+                testsRun?: boolean | undefined;
+                buildsSuccessfully?: boolean | undefined;
+                manualTestingRequired?: boolean | undefined;
+            }>;
+            nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            validation: {
+                testsRun: boolean;
+                buildsSuccessfully: boolean;
+                manualTestingRequired: boolean;
+            };
+            summary: string;
+            changes: {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }[];
+            nextSteps?: string[] | undefined;
+        }, {
+            validation: {
+                testsRun?: boolean | undefined;
+                buildsSuccessfully?: boolean | undefined;
+                manualTestingRequired?: boolean | undefined;
+            };
+            summary: string;
+            changes: {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }[];
+            nextSteps?: string[] | undefined;
+        }>, z.ZodObject<{
+            completionId: z.ZodString;
+            status: z.ZodEnum<["completed", "needs_review", "needs_testing"]>;
+            summary: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            status: "completed" | "needs_review" | "needs_testing";
+            summary: string;
+            completionId: string;
+            confidence: number;
+        }, {
+            status: "completed" | "needs_review" | "needs_testing";
+            summary: string;
+            completionId: string;
+            confidence: number;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            summary: z.ZodString;
+            changes: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]>;
+                description: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }, {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }>, "many">;
+            validation: z.ZodObject<{
+                testsRun: z.ZodDefault<z.ZodBoolean>;
+                buildsSuccessfully: z.ZodDefault<z.ZodBoolean>;
+                manualTestingRequired: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                testsRun: boolean;
+                buildsSuccessfully: boolean;
+                manualTestingRequired: boolean;
+            }, {
+                testsRun?: boolean | undefined;
+                buildsSuccessfully?: boolean | undefined;
+                manualTestingRequired?: boolean | undefined;
+            }>;
+            nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            validation: {
+                testsRun: boolean;
+                buildsSuccessfully: boolean;
+                manualTestingRequired: boolean;
+            };
+            summary: string;
+            changes: {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }[];
+            nextSteps?: string[] | undefined;
+        }, {
+            validation: {
+                testsRun?: boolean | undefined;
+                buildsSuccessfully?: boolean | undefined;
+                manualTestingRequired?: boolean | undefined;
+            };
+            summary: string;
+            changes: {
+                type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                description: string;
+                path?: string | undefined;
+            }[];
+            nextSteps?: string[] | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                summary: z.ZodString;
+                changes: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]>;
+                    description: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }, {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }>, "many">;
+                validation: z.ZodObject<{
+                    testsRun: z.ZodDefault<z.ZodBoolean>;
+                    buildsSuccessfully: z.ZodDefault<z.ZodBoolean>;
+                    manualTestingRequired: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    testsRun: boolean;
+                    buildsSuccessfully: boolean;
+                    manualTestingRequired: boolean;
+                }, {
+                    testsRun?: boolean | undefined;
+                    buildsSuccessfully?: boolean | undefined;
+                    manualTestingRequired?: boolean | undefined;
+                }>;
+                nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                validation: {
+                    testsRun: boolean;
+                    buildsSuccessfully: boolean;
+                    manualTestingRequired: boolean;
+                };
+                summary: string;
+                changes: {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }[];
+                nextSteps?: string[] | undefined;
+            }, {
+                validation: {
+                    testsRun?: boolean | undefined;
+                    buildsSuccessfully?: boolean | undefined;
+                    manualTestingRequired?: boolean | undefined;
+                };
+                summary: string;
+                changes: {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }[];
+                nextSteps?: string[] | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                completionId: z.ZodString;
+                status: z.ZodEnum<["completed", "needs_review", "needs_testing"]>;
+                summary: z.ZodString;
+                confidence: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                status: "completed" | "needs_review" | "needs_testing";
+                summary: string;
+                completionId: string;
+                confidence: number;
+            }, {
+                status: "completed" | "needs_review" | "needs_testing";
+                summary: string;
+                completionId: string;
+                confidence: number;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                summary: z.ZodString;
+                changes: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]>;
+                    description: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }, {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }>, "many">;
+                validation: z.ZodObject<{
+                    testsRun: z.ZodDefault<z.ZodBoolean>;
+                    buildsSuccessfully: z.ZodDefault<z.ZodBoolean>;
+                    manualTestingRequired: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    testsRun: boolean;
+                    buildsSuccessfully: boolean;
+                    manualTestingRequired: boolean;
+                }, {
+                    testsRun?: boolean | undefined;
+                    buildsSuccessfully?: boolean | undefined;
+                    manualTestingRequired?: boolean | undefined;
+                }>;
+                nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                validation: {
+                    testsRun: boolean;
+                    buildsSuccessfully: boolean;
+                    manualTestingRequired: boolean;
+                };
+                summary: string;
+                changes: {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }[];
+                nextSteps?: string[] | undefined;
+            }, {
+                validation: {
+                    testsRun?: boolean | undefined;
+                    buildsSuccessfully?: boolean | undefined;
+                    manualTestingRequired?: boolean | undefined;
+                };
+                summary: string;
+                changes: {
+                    type: "file_created" | "file_modified" | "file_deleted" | "command_executed" | "dependency_added";
+                    description: string;
+                    path?: string | undefined;
+                }[];
+                nextSteps?: string[] | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        manageProject: import("@mastra/core/tools").Tool<z.ZodObject<{
+            action: z.ZodEnum<["create", "install", "upgrade"]>;
+            features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                version?: string | undefined;
+            }, {
+                name: string;
+                version?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            action: "create" | "install" | "upgrade";
+            features?: string[] | undefined;
+            packages?: {
+                name: string;
+                version?: string | undefined;
+            }[] | undefined;
+        }, {
+            action: "create" | "install" | "upgrade";
+            features?: string[] | undefined;
+            packages?: {
+                name: string;
+                version?: string | undefined;
+            }[] | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            installed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            upgraded: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            message: z.ZodOptional<z.ZodString>;
+            details: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            message?: string | undefined;
+            error?: string | undefined;
+            installed?: string[] | undefined;
+            upgraded?: string[] | undefined;
+            warnings?: string[] | undefined;
+            details?: string | undefined;
+        }, {
+            success: boolean;
+            message?: string | undefined;
+            error?: string | undefined;
+            installed?: string[] | undefined;
+            upgraded?: string[] | undefined;
+            warnings?: string[] | undefined;
+            details?: string | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            action: z.ZodEnum<["create", "install", "upgrade"]>;
+            features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                version?: string | undefined;
+            }, {
+                name: string;
+                version?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            action: "create" | "install" | "upgrade";
+            features?: string[] | undefined;
+            packages?: {
+                name: string;
+                version?: string | undefined;
+            }[] | undefined;
+        }, {
+            action: "create" | "install" | "upgrade";
+            features?: string[] | undefined;
+            packages?: {
+                name: string;
+                version?: string | undefined;
+            }[] | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                action: z.ZodEnum<["create", "install", "upgrade"]>;
+                features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    version?: string | undefined;
+                }, {
+                    name: string;
+                    version?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                action: "create" | "install" | "upgrade";
+                features?: string[] | undefined;
+                packages?: {
+                    name: string;
+                    version?: string | undefined;
+                }[] | undefined;
+            }, {
+                action: "create" | "install" | "upgrade";
+                features?: string[] | undefined;
+                packages?: {
+                    name: string;
+                    version?: string | undefined;
+                }[] | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                installed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                upgraded: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                message: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodString>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                message?: string | undefined;
+                error?: string | undefined;
+                installed?: string[] | undefined;
+                upgraded?: string[] | undefined;
+                warnings?: string[] | undefined;
+                details?: string | undefined;
+            }, {
+                success: boolean;
+                message?: string | undefined;
+                error?: string | undefined;
+                installed?: string[] | undefined;
+                upgraded?: string[] | undefined;
+                warnings?: string[] | undefined;
+                details?: string | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                action: z.ZodEnum<["create", "install", "upgrade"]>;
+                features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    version?: string | undefined;
+                }, {
+                    name: string;
+                    version?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                action: "create" | "install" | "upgrade";
+                features?: string[] | undefined;
+                packages?: {
+                    name: string;
+                    version?: string | undefined;
+                }[] | undefined;
+            }, {
+                action: "create" | "install" | "upgrade";
+                features?: string[] | undefined;
+                packages?: {
+                    name: string;
+                    version?: string | undefined;
+                }[] | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        manageServer: import("@mastra/core/tools").Tool<z.ZodObject<{
+            action: z.ZodEnum<["start", "stop", "restart", "status"]>;
+            port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            action: "status" | "start" | "stop" | "restart";
+            port: number;
+        }, {
+            action: "status" | "start" | "stop" | "restart";
+            port?: number | undefined;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            status: z.ZodEnum<["running", "stopped", "starting", "stopping", "unknown"]>;
+            pid: z.ZodOptional<z.ZodNumber>;
+            port: z.ZodOptional<z.ZodNumber>;
+            url: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            stdout: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "unknown" | "running" | "stopped" | "starting" | "stopping";
+            success: boolean;
+            message?: string | undefined;
+            error?: string | undefined;
+            stdout?: string[] | undefined;
+            url?: string | undefined;
+            port?: number | undefined;
+            pid?: number | undefined;
+        }, {
+            status: "unknown" | "running" | "stopped" | "starting" | "stopping";
+            success: boolean;
+            message?: string | undefined;
+            error?: string | undefined;
+            stdout?: string[] | undefined;
+            url?: string | undefined;
+            port?: number | undefined;
+            pid?: number | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            action: z.ZodEnum<["start", "stop", "restart", "status"]>;
+            port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            action: "status" | "start" | "stop" | "restart";
+            port: number;
+        }, {
+            action: "status" | "start" | "stop" | "restart";
+            port?: number | undefined;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                action: z.ZodEnum<["start", "stop", "restart", "status"]>;
+                port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                action: "status" | "start" | "stop" | "restart";
+                port: number;
+            }, {
+                action: "status" | "start" | "stop" | "restart";
+                port?: number | undefined;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                status: z.ZodEnum<["running", "stopped", "starting", "stopping", "unknown"]>;
+                pid: z.ZodOptional<z.ZodNumber>;
+                port: z.ZodOptional<z.ZodNumber>;
+                url: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                stdout: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                status: "unknown" | "running" | "stopped" | "starting" | "stopping";
+                success: boolean;
+                message?: string | undefined;
+                error?: string | undefined;
+                stdout?: string[] | undefined;
+                url?: string | undefined;
+                port?: number | undefined;
+                pid?: number | undefined;
+            }, {
+                status: "unknown" | "running" | "stopped" | "starting" | "stopping";
+                success: boolean;
+                message?: string | undefined;
+                error?: string | undefined;
+                stdout?: string[] | undefined;
+                url?: string | undefined;
+                port?: number | undefined;
+                pid?: number | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                action: z.ZodEnum<["start", "stop", "restart", "status"]>;
+                port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                action: "status" | "start" | "stop" | "restart";
+                port: number;
+            }, {
+                action: "status" | "start" | "stop" | "restart";
+                port?: number | undefined;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+        httpRequest: import("@mastra/core/tools").Tool<z.ZodObject<{
+            method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+            url: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodAny>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            timeout: number;
+            url: string;
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            baseUrl?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: any;
+        }, {
+            url: string;
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            timeout?: number | undefined;
+            baseUrl?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: any;
+        }>, z.ZodObject<{
+            success: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodNumber>;
+            statusText: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            data: z.ZodOptional<z.ZodAny>;
+            error: z.ZodOptional<z.ZodString>;
+            url: z.ZodString;
+            method: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            url: string;
+            method: string;
+            status?: number | undefined;
+            error?: string | undefined;
+            data?: any;
+            headers?: Record<string, string> | undefined;
+            statusText?: string | undefined;
+        }, {
+            success: boolean;
+            url: string;
+            method: string;
+            status?: number | undefined;
+            error?: string | undefined;
+            data?: any;
+            headers?: Record<string, string> | undefined;
+            statusText?: string | undefined;
+        }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+            method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+            url: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodAny>;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            timeout: number;
+            url: string;
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            baseUrl?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: any;
+        }, {
+            url: string;
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            timeout?: number | undefined;
+            baseUrl?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: any;
+        }>>> & {
+            inputSchema: z.ZodObject<{
+                method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+                url: z.ZodString;
+                baseUrl: z.ZodOptional<z.ZodString>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                body: z.ZodOptional<z.ZodAny>;
+                timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                timeout: number;
+                url: string;
+                method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+                baseUrl?: string | undefined;
+                headers?: Record<string, string> | undefined;
+                body?: any;
+            }, {
+                url: string;
+                method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+                timeout?: number | undefined;
+                baseUrl?: string | undefined;
+                headers?: Record<string, string> | undefined;
+                body?: any;
+            }>;
+            outputSchema: z.ZodObject<{
+                success: z.ZodBoolean;
+                status: z.ZodOptional<z.ZodNumber>;
+                statusText: z.ZodOptional<z.ZodString>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                data: z.ZodOptional<z.ZodAny>;
+                error: z.ZodOptional<z.ZodString>;
+                url: z.ZodString;
+                method: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                url: string;
+                method: string;
+                status?: number | undefined;
+                error?: string | undefined;
+                data?: any;
+                headers?: Record<string, string> | undefined;
+                statusText?: string | undefined;
+            }, {
+                success: boolean;
+                url: string;
+                method: string;
+                status?: number | undefined;
+                error?: string | undefined;
+                data?: any;
+                headers?: Record<string, string> | undefined;
+                statusText?: string | undefined;
+            }>;
+            execute: (context: import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+                method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+                url: z.ZodString;
+                baseUrl: z.ZodOptional<z.ZodString>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                body: z.ZodOptional<z.ZodAny>;
+                timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                timeout: number;
+                url: string;
+                method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+                baseUrl?: string | undefined;
+                headers?: Record<string, string> | undefined;
+                body?: any;
+            }, {
+                url: string;
+                method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+                timeout?: number | undefined;
+                baseUrl?: string | undefined;
+                headers?: Record<string, string> | undefined;
+                body?: any;
+            }>>, options: import("ai").ToolExecutionOptions | import("ai").ToolCallOptions) => Promise<any>;
+        };
+    }>;
+    /**
+     * Filter tools for template builder mode (excludes web search and other advanced tools)
+     */
+    static filterToolsForTemplateBuilder(tools: Record<string, any>): Record<string, any>;
+    /**
+     * Filter tools for code editor mode (includes all tools)
+     */
+    static filterToolsForCodeEditor(tools: Record<string, any>): Record<string, any>;
+    /**
+     * Get tools for a specific mode
+     */
+    static getToolsForMode(projectPath: string, mode?: 'template' | 'code-editor'): Promise<Record<string, any>>;
+    /**
+     * Create a new Mastra project using create-mastra CLI
+     */
+    static createMastraProject({ features, projectName }: {
+        features?: string[];
+        projectName?: string;
+    }): Promise<{
+        success: boolean;
+        projectPath: string;
+        message: string;
+        details: string;
+        error: string;
+    } | {
+        success: boolean;
+        message: string;
+        projectPath?: undefined;
+        details?: undefined;
+        error?: undefined;
+    }>;
+    /**
+     * Install packages using the detected package manager
+     */
+    static installPackages({ packages, projectPath, }: {
+        packages: Array<{
+            name: string;
+            version?: string;
+        }>;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        installed: string[];
+        message: string;
+        details: string;
+    } | {
+        success: boolean;
+        message: string;
+        installed?: undefined;
+        details?: undefined;
+    }>;
+    /**
+     * Upgrade packages using the detected package manager
+     */
+    static upgradePackages({ packages, projectPath, }: {
+        packages?: Array<{
+            name: string;
+            version?: string;
+        }>;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        upgraded: string[];
+        message: string;
+        details: string;
+    } | {
+        success: boolean;
+        message: string;
+        upgraded?: undefined;
+        details?: undefined;
+    }>;
+    /**
+     * Start the Mastra server
+     */
+    static startMastraServer({ port, projectPath, env, }: {
+        port?: number;
+        projectPath?: string;
+        env?: Record<string, string>;
+    }): Promise<any>;
+    /**
+     * Stop the Mastra server
+     */
+    static stopMastraServer({ port, projectPath: _projectPath }: {
+        port?: number;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        status: "error";
+        error: string;
+        message?: undefined;
+    } | {
+        success: boolean;
+        status: "stopped";
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        status: "unknown";
+        message: string;
+        error: string;
+    } | {
+        success: boolean;
+        status: "unknown";
+        error: string;
+        message?: undefined;
+    }>;
+    /**
+     * Check Mastra server status
+     */
+    static checkMastraServerStatus({ port, projectPath: _projectPath, }: {
+        port?: number;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        status: "running";
+        port: number;
+        url: string;
+        message: string;
+    } | {
+        success: boolean;
+        status: "unknown";
+        port: number;
+        message: string;
+        url?: undefined;
+    } | {
+        success: boolean;
+        status: "stopped" | "starting";
+        port: number;
+        message: string;
+        url?: undefined;
+    }>;
+    private static tsProgram;
+    private static programProjectPath;
+    /**
+     * Validate code using hybrid approach: syntax -> types -> lint
+     *
+     * BEST PRACTICES FOR CODING AGENTS:
+     *
+     * ✅ RECOMMENDED (Fast & Accurate):
+     * validateCode({
+     *   validationType: ['types', 'lint'],
+     *   files: ['src/workflows/my-workflow.ts', 'src/components/Button.tsx']
+     * })
+     *
+     * Performance: ~150ms
+     * - Syntax check (1ms) - catches 80% of issues instantly
+     * - Semantic validation (100ms) - full type checking with dependencies
+     * - ESLint (50ms) - style and best practices
+     * - Only shows errors from YOUR files
+     *
+     * ❌ AVOID (Slow & Noisy):
+     * validateCode({ validationType: ['types', 'lint'] }) // no files specified
+     *
+     * Performance: ~2000ms+
+     * - Full project CLI validation
+     * - Shows errors from all project files (confusing)
+     * - Much slower for coding agents
+     *
+     * @param projectPath - Project root directory (defaults to cwd)
+     * @param validationType - ['types', 'lint'] recommended for most use cases
+     * @param files - ALWAYS provide this for best performance
+     */
+    static validateCode({ projectPath, validationType, files, }: {
+        projectPath?: string;
+        validationType: Array<'types' | 'lint' | 'schemas' | 'tests' | 'build'>;
+        files?: string[];
+    }): Promise<{
+        valid: boolean;
+        errors: {
+            type: "typescript" | "eslint" | "schema" | "test" | "build";
+            severity: "error" | "warning" | "info";
+            message: string;
+            file?: string;
+            line?: number;
+            column?: number;
+            code?: string;
+        }[];
+        summary: {
+            totalErrors: number;
+            totalWarnings: number;
+            validationsPassed: string[];
+            validationsFailed: string[];
+        };
+    }>;
+    /**
+     * CLI-based validation for when no specific files are provided
+     */
+    static validateCodeCLI({ projectPath, validationType, }: {
+        projectPath?: string;
+        validationType: Array<'types' | 'lint' | 'schemas' | 'tests' | 'build'>;
+    }): Promise<{
+        valid: boolean;
+        errors: {
+            type: "typescript" | "eslint" | "schema" | "test" | "build";
+            severity: "error" | "warning" | "info";
+            message: string;
+            file?: string;
+            line?: number;
+            column?: number;
+            code?: string;
+        }[];
+        summary: {
+            totalErrors: number;
+            totalWarnings: number;
+            validationsPassed: string[];
+            validationsFailed: string[];
+        };
+    }>;
+    /**
+     * Hybrid validation for a single file
+     */
+    static validateSingleFileHybrid(filePath: string, fileContent: string, projectPath: string, validationType: Array<'types' | 'lint' | 'schemas' | 'tests' | 'build'>): Promise<{
+        errors: {
+            type: "typescript" | "eslint" | "schema" | "test" | "build";
+            severity: "error" | "warning" | "info";
+            message: string;
+            file?: string;
+            line?: number;
+            column?: number;
+            code?: string;
+        }[];
+    }>;
+    /**
+     * Fast syntax-only validation using TypeScript parser
+     */
+    static validateSyntaxOnly(fileContent: string, fileName: string): Promise<{
+        type: "typescript";
+        severity: "error";
+        message: string;
+        file?: string;
+        line?: number;
+        column?: number;
+    }[]>;
+    /**
+     * TypeScript semantic validation using incremental program
+     */
+    static validateTypesSemantic(filePath: string, projectPath: string): Promise<{
+        type: "typescript";
+        severity: "error" | "warning";
+        message: string;
+        file?: string;
+        line?: number;
+        column?: number;
+    }[]>;
+    /**
+     * ESLint validation for a single file
+     */
+    static validateESLintSingle(filePath: string, projectPath: string): Promise<{
+        type: "eslint";
+        severity: "error" | "warning";
+        message: string;
+        file?: string;
+        line?: number;
+        column?: number;
+        code?: string;
+    }[]>;
+    /**
+     * Get or create TypeScript program
+     */
+    static getOrCreateTSProgram(projectPath: string): Promise<any | null>;
+    /**
+     * Parse ESLint errors from JSON output
+     */
+    static parseESLintErrors(eslintResults: any[]): Array<{
+        type: 'eslint';
+        severity: 'error' | 'warning';
+        message: string;
+        file?: string;
+        line?: number;
+        column?: number;
+        code?: string;
+    }>;
+    /**
+     * Make HTTP request to server or external API
+     */
+    static makeHttpRequest({ method, url, baseUrl, headers, body, timeout, }: {
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+        url: string;
+        baseUrl?: string;
+        headers?: Record<string, string>;
+        body?: any;
+        timeout?: number;
+    }): Promise<{
+        success: boolean;
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        data: any;
+        url: string;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        error?: undefined;
+    } | {
+        success: boolean;
+        url: string;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        error: string;
+        status?: undefined;
+        statusText?: undefined;
+        headers?: undefined;
+        data?: undefined;
+    }>;
+    /**
+     * Enhanced task management system for complex coding tasks
+     */
+    static manageTaskList(context: {
+        action: 'create' | 'update' | 'list' | 'complete' | 'remove';
+        tasks?: Array<{
+            id: string;
+            content?: string;
+            status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+            priority: 'high' | 'medium' | 'low';
+            dependencies?: string[];
+            notes?: string;
+        }>;
+        taskId?: string;
+    }): Promise<{
+        success: boolean;
+        tasks: any[];
+        message: string;
+    }>;
+    /**
+     * Perform multiple edits across files atomically
+     */
+    static performMultiEdit(context: {
+        operations: Array<{
+            filePath: string;
+            edits: Array<{
+                oldString: string;
+                newString: string;
+                replaceAll?: boolean;
+            }>;
+        }>;
+        createBackup?: boolean;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        results: {
+            filePath: string;
+            editsApplied: number;
+            errors: string[];
+            backup?: string;
+        }[];
+        message: string;
+    }>;
+    /**
+     * Replace specific line ranges in a file with new content
+     */
+    static replaceLines(context: {
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        newContent: string;
+        createBackup?: boolean;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error: string;
+        linesReplaced?: undefined;
+        backup?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        linesReplaced: number;
+        backup: string | undefined;
+        error?: undefined;
+    }>;
+    /**
+     * Show file lines with line numbers for debugging
+     */
+    static showFileLines(context: {
+        filePath: string;
+        startLine?: number;
+        endLine?: number;
+        context?: number;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        lines: {
+            lineNumber: number;
+            content: string;
+            isTarget: boolean;
+        }[];
+        totalLines: number;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        lines: never[];
+        totalLines: number;
+        message: string;
+        error: string;
+    }>;
+    /**
+     * Signal task completion
+     */
+    static signalCompletion(context: {
+        summary: string;
+        changes: Array<{
+            type: 'file_created' | 'file_modified' | 'file_deleted' | 'command_executed' | 'dependency_added';
+            description: string;
+            path?: string;
+        }>;
+        validation: {
+            testsRun?: boolean;
+            buildsSuccessfully?: boolean;
+            manualTestingRequired?: boolean;
+        };
+        nextSteps?: string[];
+    }): Promise<{
+        completionId: string;
+        status: "completed" | "needs_review" | "needs_testing";
+        summary: string;
+        confidence: number;
+    }>;
+    /**
+     * Perform intelligent search with context
+     */
+    static performSmartSearch(context: {
+        query: string;
+        type?: 'text' | 'regex' | 'fuzzy' | 'semantic';
+        scope?: {
+            paths?: string[];
+            fileTypes?: string[];
+            excludePaths?: string[];
+            maxResults?: number;
+        };
+        context?: {
+            beforeLines?: number;
+            afterLines?: number;
+            includeDefinitions?: boolean;
+        };
+    }, projectPath: string): Promise<{
+        success: boolean;
+        matches: {
+            file: string;
+            line: number;
+            column?: number;
+            match: string;
+            context: {
+                before: string[];
+                after: string[];
+            };
+            relevance?: number;
+        }[];
+        summary: {
+            totalMatches: number;
+            filesSearched: number;
+            patterns: string[];
+        };
+    }>;
+    private static taskStorage;
+    private static pendingQuestions;
+    /**
+     * Read file contents with optional line range
+     */
+    static readFile(context: {
+        filePath: string;
+        startLine?: number;
+        endLine?: number;
+        encoding?: string;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        content: string;
+        lines: string[];
+        metadata: {
+            size: number;
+            totalLines: number;
+            encoding: string;
+            lastModified: string;
+        };
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        content?: undefined;
+        lines?: undefined;
+        metadata?: undefined;
+    }>;
+    /**
+     * Write content to file with directory creation and backup options
+     */
+    static writeFile(context: {
+        filePath: string;
+        content: string;
+        createDirs?: boolean;
+        encoding?: string;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        filePath: string;
+        bytesWritten: number;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        filePath: string;
+        message: string;
+        error: string;
+        bytesWritten?: undefined;
+    }>;
+    /**
+     * List directory contents with filtering and metadata
+     */
+    static listDirectory(context: {
+        path: string;
+        recursive?: boolean;
+        includeHidden?: boolean;
+        pattern?: string;
+        maxDepth?: number;
+        includeMetadata?: boolean;
+        projectPath?: string;
+    }): Promise<{
+        success: boolean;
+        items: {
+            name: string;
+            path: string;
+            type: "file" | "directory" | "symlink";
+            size?: number;
+            lastModified?: string;
+            permissions?: string;
+        }[];
+        totalItems: number;
+        path: string;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        items: never[];
+        totalItems: number;
+        path: string;
+        message: string;
+        error: string;
+    }>;
+    /**
+     * Execute shell commands with proper error handling
+     */
+    static executeCommand(context: {
+        command: string;
+        workingDirectory?: string;
+        timeout?: number;
+        captureOutput?: boolean;
+        shell?: string;
+        env?: Record<string, string>;
+    }): Promise<{
+        success: boolean;
+        exitCode: number;
+        stdout: string | undefined;
+        stderr: string | undefined;
+        command: string;
+        workingDirectory: string | undefined;
+        executionTime: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        exitCode: any;
+        stdout: string;
+        stderr: string;
+        command: string;
+        workingDirectory: string | undefined;
+        executionTime: number;
+        error: string;
+    }>;
+    /**
+     * Web search using a simple search approach
+     */
+    static webSearch(context: {
+        query: string;
+        maxResults?: number;
+        region?: string;
+        language?: string;
+        includeImages?: boolean;
+        dateRange?: 'day' | 'week' | 'month' | 'year' | 'all';
+    }): Promise<{
+        success: boolean;
+        query: string;
+        results: {
+            title: string;
+            url: string;
+            snippet: string;
+            domain: string;
+            publishDate?: string;
+            relevanceScore?: number;
+        }[];
+        totalResults: number;
+        searchTime: number;
+        suggestions: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        query: string;
+        results: never[];
+        totalResults: number;
+        searchTime: number;
+        error: string;
+        suggestions?: undefined;
+    }>;
+}
+//# sourceMappingURL=defaults.d.ts.map