@mastra/agent-builder 0.0.1 → 0.0.2-alpha.0

package/dist/index.js

@@ -10,7 +10,7 @@ import { z } from 'zod';
 import { existsSync, readFileSync } from 'fs';
 import { createRequire } from 'module';
 import { promisify } from 'util';
-import { openai as openai$1 } from '@ai-sdk/openai_v5';
+import { openai as openai$1 } from '@ai-sdk/openai-v5';
 import { MemoryProcessor } from '@mastra/core/memory';
 import { tmpdir } from 'os';
 import { openai } from '@ai-sdk/openai';
@@ -34,7 +34,8 @@ var AgentBuilderInputSchema = z.object({
   repo: z.string().describe("Git URL or local path of the template repo"),
   ref: z.string().optional().describe("Tag/branch/commit to checkout (defaults to main/master)"),
   slug: z.string().optional().describe("Slug for branch/scripts; defaults to inferred from repo"),
-  targetPath: z.string().optional().describe("Project path to merge into; defaults to current directory")
+  targetPath: z.string().optional().describe("Project path to merge into; defaults to current directory"),
+  variables: z.record(z.string()).optional().describe("Environment variables to set in .env file")
 });
 z.object({
   slug: z.string(),
@@ -64,7 +65,8 @@ var FileCopyInputSchema = z.object({
   templateDir: z.string(),
   commitSha: z.string(),
   slug: z.string(),
-  targetPath: z.string().optional()
+  targetPath: z.string().optional(),
+  variables: z.record(z.string()).optional()
 });
 var FileCopyResultSchema = z.object({
   success: z.boolean(),
@@ -100,7 +102,9 @@ var IntelligentMergeResultSchema = z.object({
 var ValidationResultsSchema = z.object({
   valid: z.boolean(),
   errorsFixed: z.number(),
-  remainingErrors: z.number()
+  remainingErrors: z.number(),
+  errors: z.array(z.any()).optional()
+  // Include specific validation errors
 });
 var ValidationFixInputSchema = z.object({
   commitSha: z.string(),
@@ -148,7 +152,8 @@ var CloneTemplateResultSchema = z.object({
   commitSha: z.string(),
   slug: z.string(),
   success: z.boolean().optional(),
-  error: z.string().optional()
+  error: z.string().optional(),
+  targetPath: z.string().optional()
 });
 var PackageAnalysisSchema = z.object({
   name: z.string().optional(),
@@ -493,21 +498,8 @@ async function renameAndCopyFile(sourceFile, targetFile) {
   console.log(`\u{1F4DD} Copied with unique name: ${basename(uniqueTargetFile)}`);
   return uniqueTargetFile;
 }
-var resolveModel = (runtimeContext) => {
-  const modelFromContext = runtimeContext.get("model");
-  if (modelFromContext) {
-    console.log(`Using model: ${modelFromContext}`);
-    if (isValidMastraLanguageModel(modelFromContext)) {
-      return modelFromContext;
-    }
-    throw new Error(
-      'Invalid model provided. Model must be a MastraLanguageModel instance (e.g., openai("gpt-4"), anthropic("claude-3-5-sonnet"), etc.)'
-    );
-  }
-  return openai$1("gpt-4.1");
-};
 var isValidMastraLanguageModel = (model) => {
-  return model && typeof model === "object" && typeof model.modelId === "string" && typeof model.generate === "function";
+  return model && typeof model === "object" && typeof model.modelId === "string";
 };
 var resolveTargetPath = (inputData, runtimeContext) => {
   if (inputData.targetPath) {
@@ -529,6 +521,208 @@ var resolveTargetPath = (inputData, runtimeContext) => {
   }
   return cwd;
 };
+var mergeGitignoreFiles = (targetContent, templateContent, templateSlug) => {
+  const targetLines = targetContent.replace(/\r\n/g, "\n").split("\n");
+  const templateLines = templateContent.replace(/\r\n/g, "\n").split("\n");
+  const existingEntries = /* @__PURE__ */ new Set();
+  for (const line of targetLines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const normalized = trimmed.replace(/^\.\//, "").replace(/\\/g, "/");
+      existingEntries.add(normalized);
+    }
+  }
+  const newEntries = [];
+  for (const line of templateLines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const normalized = trimmed.replace(/^\.\//, "").replace(/\\/g, "/");
+      if (!existingEntries.has(normalized)) {
+        const isNegation = normalized.startsWith("!");
+        const basePath = isNegation ? normalized.slice(1) : normalized;
+        const hasConflict = isNegation ? existingEntries.has(basePath) : existingEntries.has("!" + basePath);
+        if (!hasConflict) {
+          newEntries.push(trimmed);
+        } else {
+          console.log(`\u26A0 Skipping conflicting .gitignore rule: ${trimmed} (conflicts with existing rule)`);
+        }
+      }
+    }
+  }
+  if (newEntries.length === 0) {
+    return targetContent;
+  }
+  const result = [...targetLines];
+  const lastLine = result[result.length - 1];
+  if (result.length > 0 && lastLine && lastLine.trim() !== "") {
+    result.push("");
+  }
+  result.push(`# Added by template: ${templateSlug}`);
+  result.push(...newEntries);
+  return result.join("\n");
+};
+var mergeEnvFiles = (targetContent, templateVariables, templateSlug) => {
+  const targetLines = targetContent.replace(/\r\n/g, "\n").split("\n");
+  const existingVars = /* @__PURE__ */ new Set();
+  for (const line of targetLines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const equalIndex = trimmed.indexOf("=");
+      if (equalIndex > 0) {
+        const varName = trimmed.substring(0, equalIndex).trim();
+        existingVars.add(varName);
+      }
+    }
+  }
+  const newVars = [];
+  for (const [key, value] of Object.entries(templateVariables)) {
+    if (!existingVars.has(key)) {
+      newVars.push({ key, value });
+    } else {
+      console.log(`\u26A0 Skipping existing environment variable: ${key} (already exists in .env)`);
+    }
+  }
+  if (newVars.length === 0) {
+    return targetContent;
+  }
+  const result = [...targetLines];
+  const lastLine = result[result.length - 1];
+  if (result.length > 0 && lastLine && lastLine.trim() !== "") {
+    result.push("");
+  }
+  result.push(`# Added by template: ${templateSlug}`);
+  for (const { key, value } of newVars) {
+    result.push(`${key}=${value}`);
+  }
+  return result.join("\n");
+};
+var detectAISDKVersion = async (projectPath) => {
+  try {
+    const packageJsonPath = join(projectPath, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      console.log("No package.json found, defaulting to v2");
+      return "v2";
+    }
+    const packageContent = await readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageContent);
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+      ...packageJson.peerDependencies
+    };
+    const providerPackages = ["@ai-sdk/openai", "@ai-sdk/anthropic", "@ai-sdk/google", "@ai-sdk/groq", "@ai-sdk/xai"];
+    for (const pkg of providerPackages) {
+      const version = allDeps[pkg];
+      if (version) {
+        const versionMatch = version.match(/(\d+)/);
+        if (versionMatch) {
+          const majorVersion = parseInt(versionMatch[1]);
+          if (majorVersion >= 2) {
+            console.log(`Detected ${pkg} v${majorVersion} -> using v2 specification`);
+            return "v2";
+          } else {
+            console.log(`Detected ${pkg} v${majorVersion} -> using v1 specification`);
+            return "v1";
+          }
+        }
+      }
+    }
+    console.log("No AI SDK version detected, defaulting to v2");
+    return "v2";
+  } catch (error) {
+    console.warn(`Failed to detect AI SDK version: ${error instanceof Error ? error.message : String(error)}`);
+    return "v2";
+  }
+};
+var createModelInstance = async (provider, modelId, version = "v2") => {
+  try {
+    const providerMap = {
+      v1: {
+        openai: async () => {
+          const { openai: openai2 } = await import('@ai-sdk/openai');
+          return openai2(modelId);
+        },
+        anthropic: async () => {
+          const { anthropic } = await import('@ai-sdk/anthropic');
+          return anthropic(modelId);
+        },
+        groq: async () => {
+          const { groq } = await import('@ai-sdk/groq');
+          return groq(modelId);
+        },
+        xai: async () => {
+          const { xai } = await import('@ai-sdk/xai');
+          return xai(modelId);
+        },
+        google: async () => {
+          const { google } = await import('@ai-sdk/google');
+          return google(modelId);
+        }
+      },
+      v2: {
+        openai: async () => {
+          const { openai: openai2 } = await import('@ai-sdk/openai-v5');
+          return openai2(modelId);
+        },
+        anthropic: async () => {
+          const { anthropic } = await import('@ai-sdk/anthropic-v5');
+          return anthropic(modelId);
+        },
+        groq: async () => {
+          const { groq } = await import('@ai-sdk/groq-v5');
+          return groq(modelId);
+        },
+        xai: async () => {
+          const { xai } = await import('@ai-sdk/xai-v5');
+          return xai(modelId);
+        },
+        google: async () => {
+          const { google } = await import('@ai-sdk/google-v5');
+          return google(modelId);
+        }
+      }
+    };
+    const providerFn = providerMap[version][provider];
+    if (!providerFn) {
+      console.error(`Unsupported provider: ${provider}`);
+      return null;
+    }
+    const modelInstance = await providerFn();
+    console.log(`Created ${provider} model instance (${version}): ${modelId}`);
+    return modelInstance;
+  } catch (error) {
+    console.error(`Failed to create model instance: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+};
+var resolveModel = async ({
+  runtimeContext,
+  defaultModel = openai$1("gpt-4.1"),
+  projectPath
+}) => {
+  const modelFromContext = runtimeContext.get("model");
+  if (modelFromContext) {
+    console.log("Using model from runtime context");
+    if (isValidMastraLanguageModel(modelFromContext)) {
+      return modelFromContext;
+    }
+    throw new Error(
+      'Invalid model provided. Model must be a MastraLanguageModel instance (e.g., openai("gpt-4"), anthropic("claude-3-5-sonnet"), etc.)'
+    );
+  }
+  const selectedModel = runtimeContext.get("selectedModel");
+  if (selectedModel?.provider && selectedModel?.modelId && projectPath) {
+    console.log(`Resolving selected model: ${selectedModel.provider}/${selectedModel.modelId}`);
+    const version = await detectAISDKVersion(projectPath);
+    const modelInstance = await createModelInstance(selectedModel.provider, selectedModel.modelId, version);
+    if (modelInstance) {
+      runtimeContext.set("model", modelInstance);
+      return modelInstance;
+    }
+  }
+  console.log("Using default model");
+  return defaultModel;
+};
 
 // src/defaults.ts
 var AgentBuilderDefaults = class _AgentBuilderDefaults {
@@ -710,7 +904,6 @@ You have access to an enhanced set of tools based on production coding agent pat
 **Important**: All file paths are resolved relative to the project directory unless absolute paths are provided.
 
 ### Communication & Workflow
-- **askClarification**: Ask users for clarification when requirements are unclear or multiple options exist.
 - **attemptCompletion**: Signal task completion with validation status and confidence metrics.
 
 ### Guidelines for Enhanced Tools:
@@ -928,8 +1121,8 @@ export const mastra = new Mastra({
     "mcp-server": "src/mastra/mcp",
     network: "src/mastra/networks"
   };
-  static DEFAULT_TOOLS = async (projectPath, mode = "code-editor") => {
-    const agentBuilderTools = {
+  static DEFAULT_TOOLS = async (projectPath) => {
+    return {
       readFile: createTool({
         id: "read-file",
         description: "Read contents of a file with optional line range selection.",
@@ -1162,37 +1355,6 @@ export const mastra = new Mastra({
           return await _AgentBuilderDefaults.showFileLines({ ...context, projectPath });
         }
       }),
-      // Interactive Communication
-      askClarification: createTool({
-        id: "ask-clarification",
-        description: "Ask the user for clarification when requirements are unclear or when multiple options exist.",
-        inputSchema: z.object({
-          question: z.string().describe("The specific question to ask"),
-          options: z.array(
-            z.object({
-              id: z.string(),
-              description: z.string(),
-              implications: z.string().optional()
-            })
-          ).optional().describe("Multiple choice options if applicable"),
-          context: z.string().optional().describe("Additional context about why clarification is needed"),
-          urgency: z.enum(["low", "medium", "high"]).default("medium").describe("How urgent the clarification is")
-        }),
-        outputSchema: z.object({
-          questionId: z.string(),
-          question: z.string(),
-          options: z.array(
-            z.object({
-              id: z.string(),
-              description: z.string()
-            })
-          ).optional(),
-          awaitingResponse: z.boolean()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.askClarification(context);
-        }
-      }),
       // Enhanced Pattern Search
       smartSearch: createTool({
         id: "smart-search",
@@ -1276,332 +1438,305 @@ export const mastra = new Mastra({
             files
           });
         }
-      })
-    };
-    if (mode === "template") {
-      return agentBuilderTools;
-    } else {
-      return {
-        ...agentBuilderTools,
-        // Web Search (replaces MCP web search)
-        webSearch: createTool({
-          id: "web-search",
-          description: "Search the web for current information and return structured results.",
-          inputSchema: z.object({
-            query: z.string().describe("Search query"),
-            maxResults: z.number().default(10).describe("Maximum number of results to return"),
-            region: z.string().default("us").describe("Search region/country code"),
-            language: z.string().default("en").describe("Search language"),
-            includeImages: z.boolean().default(false).describe("Include image results"),
-            dateRange: z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-            query: z.string(),
-            results: z.array(
-              z.object({
-                title: z.string(),
-                url: z.string(),
-                snippet: z.string(),
-                domain: z.string(),
-                publishDate: z.string().optional(),
-                relevanceScore: z.number().optional()
-              })
-            ),
-            totalResults: z.number(),
-            searchTime: z.number(),
-            suggestions: z.array(z.string()).optional(),
-            error: z.string().optional()
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.webSearch(context);
-          }
+      }),
+      // Web Search (replaces MCP web search)
+      webSearch: createTool({
+        id: "web-search",
+        description: "Search the web for current information and return structured results.",
+        inputSchema: z.object({
+          query: z.string().describe("Search query"),
+          maxResults: z.number().default(10).describe("Maximum number of results to return"),
+          region: z.string().default("us").describe("Search region/country code"),
+          language: z.string().default("en").describe("Search language"),
+          includeImages: z.boolean().default(false).describe("Include image results"),
+          dateRange: z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
         }),
-        // Enhanced Code Discovery
-        codeAnalyzer: createTool({
-          id: "code-analyzer",
-          description: "Analyze codebase structure, discover definitions, and understand architecture patterns.",
-          inputSchema: z.object({
-            action: z.enum(["definitions", "dependencies", "patterns", "structure"]).describe("Type of analysis to perform"),
-            path: z.string().describe("Directory or file path to analyze"),
-            language: z.string().optional().describe("Programming language filter"),
-            depth: z.number().default(3).describe("Directory traversal depth"),
-            includeTests: z.boolean().default(false).describe("Include test files in analysis")
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-            analysis: z.object({
-              definitions: z.array(
-                z.object({
-                  name: z.string(),
-                  type: z.string(),
-                  file: z.string(),
-                  line: z.number().optional(),
-                  scope: z.string().optional()
-                })
-              ).optional(),
-              dependencies: z.array(
-                z.object({
-                  name: z.string(),
-                  type: z.enum(["import", "require", "include"]),
-                  source: z.string(),
-                  target: z.string()
-                })
-              ).optional(),
-              patterns: z.array(
-                z.object({
-                  pattern: z.string(),
-                  description: z.string(),
-                  files: z.array(z.string())
-                })
-              ).optional(),
-              structure: z.object({
-                directories: z.number(),
-                files: z.number(),
-                languages: z.record(z.number()),
-                complexity: z.string()
-              }).optional()
-            }),
-            message: z.string()
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.analyzeCode(context);
-          }
+        outputSchema: z.object({
+          success: z.boolean(),
+          query: z.string(),
+          results: z.array(
+            z.object({
+              title: z.string(),
+              url: z.string(),
+              snippet: z.string(),
+              domain: z.string(),
+              publishDate: z.string().optional(),
+              relevanceScore: z.number().optional()
+            })
+          ),
+          totalResults: z.number(),
+          searchTime: z.number(),
+          suggestions: z.array(z.string()).optional(),
+          error: z.string().optional()
         }),
-        // Task Completion Signaling
-        attemptCompletion: createTool({
-          id: "attempt-completion",
-          description: "Signal that you believe the requested task has been completed and provide a summary.",
-          inputSchema: z.object({
-            summary: z.string().describe("Summary of what was accomplished"),
-            changes: z.array(
-              z.object({
-                type: z.enum([
-                  "file_created",
-                  "file_modified",
-                  "file_deleted",
-                  "command_executed",
-                  "dependency_added"
-                ]),
-                description: z.string(),
-                path: z.string().optional()
-              })
-            ).describe("List of changes made"),
-            validation: z.object({
-              testsRun: z.boolean().default(false),
-              buildsSuccessfully: z.boolean().default(false),
-              manualTestingRequired: z.boolean().default(false)
-            }).describe("Validation status"),
-            nextSteps: z.array(z.string()).optional().describe("Suggested next steps or follow-up actions")
-          }),
-          outputSchema: z.object({
-            completionId: z.string(),
-            status: z.enum(["completed", "needs_review", "needs_testing"]),
-            summary: z.string(),
-            confidence: z.number().min(0).max(100)
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.signalCompletion(context);
-          }
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.webSearch(context);
+        }
+      }),
+      // Task Completion Signaling
+      attemptCompletion: createTool({
+        id: "attempt-completion",
+        description: "Signal that you believe the requested task has been completed and provide a summary.",
+        inputSchema: z.object({
+          summary: z.string().describe("Summary of what was accomplished"),
+          changes: z.array(
+            z.object({
+              type: z.enum(["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]),
+              description: z.string(),
+              path: z.string().optional()
+            })
+          ).describe("List of changes made"),
+          validation: z.object({
+            testsRun: z.boolean().default(false),
+            buildsSuccessfully: z.boolean().default(false),
+            manualTestingRequired: z.boolean().default(false)
+          }).describe("Validation status"),
+          nextSteps: z.array(z.string()).optional().describe("Suggested next steps or follow-up actions")
         }),
-        manageProject: createTool({
-          id: "manage-project",
-          description: "Handles project management including creating project structures, managing dependencies, and package operations.",
-          inputSchema: z.object({
-            action: z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
-            features: z.array(z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
-            packages: z.array(
-              z.object({
-                name: z.string(),
-                version: z.string().optional()
-              })
-            ).optional().describe("Packages to install/upgrade")
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-            installed: z.array(z.string()).optional(),
-            upgraded: z.array(z.string()).optional(),
-            warnings: z.array(z.string()).optional(),
-            message: z.string().optional(),
-            details: z.string().optional(),
-            error: z.string().optional()
-          }),
-          execute: async ({ context }) => {
-            const { action, features, packages } = context;
-            try {
-              switch (action) {
-                case "create":
-                  return await _AgentBuilderDefaults.createMastraProject({
-                    projectName: projectPath,
-                    features
-                  });
-                case "install":
-                  if (!packages?.length) {
-                    return {
-                      success: false,
-                      message: "Packages array is required for install action"
-                    };
-                  }
-                  return await _AgentBuilderDefaults.installPackages({
-                    packages,
-                    projectPath
-                  });
-                case "upgrade":
-                  if (!packages?.length) {
-                    return {
-                      success: false,
-                      message: "Packages array is required for upgrade action"
-                    };
-                  }
-                  return await _AgentBuilderDefaults.upgradePackages({
-                    packages,
-                    projectPath
-                  });
-                // case 'check':
-                //   return await AgentBuilderDefaults.checkProject({
-                //     projectPath,
-                //   });
-                default:
+        outputSchema: z.object({
+          completionId: z.string(),
+          status: z.enum(["completed", "needs_review", "needs_testing"]),
+          summary: z.string(),
+          confidence: z.number().min(0).max(100)
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.signalCompletion(context);
+        }
+      }),
+      manageProject: createTool({
+        id: "manage-project",
+        description: "Handles project management including creating project structures, managing dependencies, and package operations.",
+        inputSchema: z.object({
+          action: z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
+          features: z.array(z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
+          packages: z.array(
+            z.object({
+              name: z.string(),
+              version: z.string().optional()
+            })
+          ).optional().describe("Packages to install/upgrade")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          installed: z.array(z.string()).optional(),
+          upgraded: z.array(z.string()).optional(),
+          warnings: z.array(z.string()).optional(),
+          message: z.string().optional(),
+          details: z.string().optional(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          const { action, features, packages } = context;
+          try {
+            switch (action) {
+              case "create":
+                return await _AgentBuilderDefaults.createMastraProject({
+                  projectName: projectPath,
+                  features
+                });
+              case "install":
+                if (!packages?.length) {
                   return {
                     success: false,
-                    message: `Unknown action: ${action}`
+                    message: "Packages array is required for install action"
                   };
-              }
-            } catch (error) {
-              return {
-                success: false,
-                message: `Error executing ${action}: ${error instanceof Error ? error.message : String(error)}`
-              };
+                }
+                return await _AgentBuilderDefaults.installPackages({
+                  packages,
+                  projectPath
+                });
+              case "upgrade":
+                if (!packages?.length) {
+                  return {
+                    success: false,
+                    message: "Packages array is required for upgrade action"
+                  };
+                }
+                return await _AgentBuilderDefaults.upgradePackages({
+                  packages,
+                  projectPath
+                });
+              default:
+                return {
+                  success: false,
+                  message: `Unknown action: ${action}`
+                };
             }
+          } catch (error) {
+            return {
+              success: false,
+              message: `Error executing ${action}: ${error instanceof Error ? error.message : String(error)}`
+            };
           }
+        }
+      }),
+      manageServer: createTool({
+        id: "manage-server",
+        description: "Manages the Mastra server - start, stop, restart, and check status, use the terminal tool to make curl requests to the server. There is an openapi spec for the server at http://localhost:{port}/openapi.json",
+        inputSchema: z.object({
+          action: z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
+          port: z.number().optional().default(4200).describe("Port to run the server on")
         }),
-        manageServer: createTool({
-          id: "manage-server",
-          description: "Manages the Mastra server - start, stop, restart, and check status, use the terminal tool to make curl requests to the server. There is an openapi spec for the server at http://localhost:{port}/openapi.json",
-          inputSchema: z.object({
-            action: z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
-            port: z.number().optional().default(4200).describe("Port to run the server on")
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-            status: z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
-            pid: z.number().optional(),
-            port: z.number().optional(),
-            url: z.string().optional(),
-            message: z.string().optional(),
-            stdout: z.array(z.string()).optional().describe("Server output lines captured during startup"),
-            error: z.string().optional()
-          }),
-          execute: async ({ context }) => {
-            const { action, port } = context;
-            try {
-              switch (action) {
-                case "start":
-                  return await _AgentBuilderDefaults.startMastraServer({
-                    port,
-                    projectPath
-                  });
-                case "stop":
-                  return await _AgentBuilderDefaults.stopMastraServer({
-                    port,
-                    projectPath
-                  });
-                case "restart":
-                  const stopResult = await _AgentBuilderDefaults.stopMastraServer({
-                    port,
-                    projectPath
-                  });
-                  if (!stopResult.success) {
-                    return {
-                      success: false,
-                      status: "unknown",
-                      message: `Failed to restart: could not stop server on port ${port}`,
-                      error: stopResult.error || "Unknown stop error"
-                    };
-                  }
-                  await new Promise((resolve4) => setTimeout(resolve4, 500));
-                  const startResult = await _AgentBuilderDefaults.startMastraServer({
-                    port,
-                    projectPath
-                  });
-                  if (!startResult.success) {
-                    return {
-                      success: false,
-                      status: "stopped",
-                      message: `Failed to restart: server stopped successfully but failed to start on port ${port}`,
-                      error: startResult.error || "Unknown start error"
-                    };
-                  }
+        outputSchema: z.object({
+          success: z.boolean(),
+          status: z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
+          pid: z.number().optional(),
+          port: z.number().optional(),
+          url: z.string().optional(),
+          message: z.string().optional(),
+          stdout: z.array(z.string()).optional().describe("Server output lines captured during startup"),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          const { action, port } = context;
+          try {
+            switch (action) {
+              case "start":
+                return await _AgentBuilderDefaults.startMastraServer({
+                  port,
+                  projectPath
+                });
+              case "stop":
+                return await _AgentBuilderDefaults.stopMastraServer({
+                  port,
+                  projectPath
+                });
+              case "restart":
+                const stopResult = await _AgentBuilderDefaults.stopMastraServer({
+                  port,
+                  projectPath
+                });
+                if (!stopResult.success) {
                   return {
-                    ...startResult,
-                    message: `Mastra server restarted successfully on port ${port}`
+                    success: false,
+                    status: "unknown",
+                    message: `Failed to restart: could not stop server on port ${port}`,
+                    error: stopResult.error || "Unknown stop error"
                   };
-                case "status":
-                  return await _AgentBuilderDefaults.checkMastraServerStatus({
-                    port,
-                    projectPath
-                  });
-                default:
+                }
+                await new Promise((resolve4) => setTimeout(resolve4, 500));
+                const startResult = await _AgentBuilderDefaults.startMastraServer({
+                  port,
+                  projectPath
+                });
+                if (!startResult.success) {
                   return {
                     success: false,
-                    status: "unknown",
-                    message: `Unknown action: ${action}`
+                    status: "stopped",
+                    message: `Failed to restart: server stopped successfully but failed to start on port ${port}`,
+                    error: startResult.error || "Unknown start error"
                   };
-              }
-            } catch (error) {
-              return {
-                success: false,
-                status: "unknown",
-                message: `Error managing server: ${error instanceof Error ? error.message : String(error)}`
-              };
+                }
+                return {
+                  ...startResult,
+                  message: `Mastra server restarted successfully on port ${port}`
+                };
+              case "status":
+                return await _AgentBuilderDefaults.checkMastraServerStatus({
+                  port,
+                  projectPath
+                });
+              default:
+                return {
+                  success: false,
+                  status: "unknown",
+                  message: `Unknown action: ${action}`
+                };
             }
+          } catch (error) {
+            return {
+              success: false,
+              status: "unknown",
+              message: `Error managing server: ${error instanceof Error ? error.message : String(error)}`
+            };
           }
+        }
+      }),
+      httpRequest: createTool({
+        id: "http-request",
+        description: "Makes HTTP requests to the Mastra server or external APIs for testing and integration",
+        inputSchema: z.object({
+          method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
+          url: z.string().describe("Full URL or path (if baseUrl provided)"),
+          baseUrl: z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
+          headers: z.record(z.string()).optional().describe("HTTP headers"),
+          body: z.any().optional().describe("Request body (will be JSON stringified if object)"),
+          timeout: z.number().optional().default(3e4).describe("Request timeout in milliseconds")
         }),
-        httpRequest: createTool({
-          id: "http-request",
-          description: "Makes HTTP requests to the Mastra server or external APIs for testing and integration",
-          inputSchema: z.object({
-            method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
-            url: z.string().describe("Full URL or path (if baseUrl provided)"),
-            baseUrl: z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
-            headers: z.record(z.string()).optional().describe("HTTP headers"),
-            body: z.any().optional().describe("Request body (will be JSON stringified if object)"),
-            timeout: z.number().optional().default(3e4).describe("Request timeout in milliseconds")
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-            status: z.number().optional(),
-            statusText: z.string().optional(),
-            headers: z.record(z.string()).optional(),
-            data: z.any().optional(),
-            error: z.string().optional(),
-            url: z.string(),
-            method: z.string()
-          }),
-          execute: async ({ context }) => {
-            const { method, url, baseUrl, headers, body, timeout } = context;
-            try {
-              return await _AgentBuilderDefaults.makeHttpRequest({
-                method,
-                url,
-                baseUrl,
-                headers,
-                body,
-                timeout
-              });
-            } catch (error) {
-              return {
-                success: false,
-                url: baseUrl ? `${baseUrl}${url}` : url,
-                method,
-                error: error instanceof Error ? error.message : String(error)
-              };
-            }
+        outputSchema: z.object({
+          success: z.boolean(),
+          status: z.number().optional(),
+          statusText: z.string().optional(),
+          headers: z.record(z.string()).optional(),
+          data: z.any().optional(),
+          error: z.string().optional(),
+          url: z.string(),
+          method: z.string()
+        }),
+        execute: async ({ context }) => {
+          const { method, url, baseUrl, headers, body, timeout } = context;
+          try {
+            return await _AgentBuilderDefaults.makeHttpRequest({
+              method,
+              url,
+              baseUrl,
+              headers,
+              body,
+              timeout
+            });
+          } catch (error) {
+            return {
+              success: false,
+              url: baseUrl ? `${baseUrl}${url}` : url,
+              method,
+              error: error instanceof Error ? error.message : String(error)
+            };
           }
-        })
-      };
-    }
+        }
+      })
+    };
   };
+  /**
+   * Filter tools for template builder mode (excludes web search and other advanced tools)
+   */
+  static filterToolsForTemplateBuilder(tools) {
+    const templateBuilderTools = [
+      "readFile",
+      "writeFile",
+      "listDirectory",
+      "executeCommand",
+      "taskManager",
+      "multiEdit",
+      "replaceLines",
+      "showFileLines",
+      "smartSearch",
+      "validateCode"
+    ];
+    const filtered = {};
+    for (const toolName of templateBuilderTools) {
+      if (tools[toolName]) {
+        filtered[toolName] = tools[toolName];
+      }
+    }
+    return filtered;
+  }
+  /**
+   * Filter tools for code editor mode (includes all tools)
+   */
+  static filterToolsForCodeEditor(tools) {
+    return tools;
+  }
+  /**
+   * Get tools for a specific mode
+   */
+  static async getToolsForMode(projectPath, mode = "code-editor") {
+    const allTools = await _AgentBuilderDefaults.DEFAULT_TOOLS(projectPath);
+    if (mode === "template") {
+      return _AgentBuilderDefaults.filterToolsForTemplateBuilder(allTools);
+    } else {
+      return _AgentBuilderDefaults.filterToolsForCodeEditor(allTools);
+    }
+  }
   /**
    * Create a new Mastra project using create-mastra CLI
    */
@@ -1679,49 +1814,6 @@ export const mastra = new Mastra({
       };
     }
   }
-  // /**
-  //  * Check project health and status
-  //  */
-  // static async checkProject({ projectPath }: { projectPath?: string }) {
-  //   try {
-  //     const execOptions = projectPath ? { cwd: projectPath } : {};
-  //     let hasPackageJson = false;
-  //     let hasMastraConfig = false;
-  //     try {
-  //       await exec('test -f package.json', execOptions);
-  //       hasPackageJson = true;
-  //     } catch {
-  //       // ignore
-  //     }
-  //     try {
-  //       await exec('test -f mastra.config.* || test -d src/mastra || test -d mastra', execOptions);
-  //       hasMastraConfig = true;
-  //     } catch {
-  //       // ignore
-  //     }
-  //     const warnings: string[] = [];
-  //     if (!hasPackageJson) {
-  //       warnings.push('No package.json found - this may not be a Node.js project');
-  //     }
-  //     if (!hasMastraConfig) {
-  //       warnings.push('No Mastra configuration found - run "npx create-mastra" to initialize');
-  //     }
-  //     return {
-  //       success: true,
-  //       message: `Project health check completed for ${projectPath || 'current directory'}`,
-  //       warnings,
-  //       checks: {
-  //         hasPackageJson,
-  //         hasMastraConfig,
-  //       },
-  //     };
-  //   } catch (error) {
-  //     return {
-  //       success: false,
-  //       message: `Failed to check project: ${error instanceof Error ? error.message : String(error)}`,
-  //     };
-  //   }
-  // }
   /**
    * Start the Mastra server
    */
@@ -2469,166 +2561,6 @@ export const mastra = new Mastra({
       };
     }
   }
-  /**
-   * Analyze codebase structure and patterns
-   */
-  static async analyzeCode(context) {
-    try {
-      const { action, path, language, depth = 3 } = context;
-      const ALLOWED_LANGUAGES = [
-        "js",
-        "ts",
-        "jsx",
-        "tsx",
-        "py",
-        "java",
-        "go",
-        "cpp",
-        "c",
-        "cs",
-        "rb",
-        "php",
-        "rs",
-        "kt",
-        "swift",
-        "m",
-        "scala",
-        "sh",
-        "json",
-        "yaml",
-        "yml",
-        "toml",
-        "ini"
-      ];
-      let languagePattern = "*";
-      if (language && ALLOWED_LANGUAGES.includes(language)) {
-        languagePattern = `*.${language}`;
-      }
-      switch (action) {
-        case "definitions":
-          const definitionPatterns = [
-            "function\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-            "class\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-            "interface\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-            "const\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=",
-            "export\\s+(function|class|interface|const)\\s+([a-zA-Z_][a-zA-Z0-9_]*)"
-          ];
-          const definitions = [];
-          for (const pattern of definitionPatterns) {
-            try {
-              const { stdout } = await execFile("rg", [
-                "-n",
-                pattern,
-                path,
-                "--type",
-                languagePattern,
-                "--max-depth",
-                String(depth)
-              ]);
-              const matches = stdout.split("\n").filter((line) => line.trim());
-              matches.forEach((match) => {
-                const parts = match.split(":");
-                if (parts.length >= 3) {
-                  const file = parts[0];
-                  const lineStr = parts[1];
-                  const line = parseInt(lineStr || "0");
-                  const content = parts.slice(2).join(":");
-                  const nameMatch = content.match(/([a-zA-Z_][a-zA-Z0-9_]*)/);
-                  if (nameMatch && nameMatch[1]) {
-                    definitions.push({
-                      name: nameMatch[1],
-                      type: pattern.includes("function") ? "function" : pattern.includes("class") ? "class" : pattern.includes("interface") ? "interface" : "variable",
-                      file: file || "",
-                      line,
-                      scope: "top-level"
-                    });
-                  }
-                }
-              });
-            } catch {
-            }
-          }
-          return {
-            success: true,
-            analysis: { definitions },
-            message: `Found ${definitions.length} code definitions`
-          };
-        case "dependencies":
-          const depPatterns = [
-            `import\\s+.*\\s+from\\s+['"]([^'"]+)['"]`,
-            `require\\(['"]([^'"]+)['"]\\)`,
-            '#include\\s+[<"]([^>"]+)[>"]'
-          ];
-          const dependencies = [];
-          for (const pattern of depPatterns) {
-            try {
-              const { stdout } = await execFile("rg", ["-n", pattern, path, "--type", languagePattern]);
-              const matches = stdout.split("\n").filter((line) => line.trim());
-              matches.forEach((match) => {
-                const parts = match.split(":");
-                if (parts.length >= 3) {
-                  const file = parts[0];
-                  const content = parts.slice(2).join(":");
-                  const depMatch = content.match(new RegExp(pattern));
-                  if (depMatch && depMatch[1]) {
-                    dependencies.push({
-                      name: depMatch[1],
-                      type: pattern.includes("import") ? "import" : pattern.includes("require") ? "require" : "include",
-                      source: file || "",
-                      target: depMatch[1]
-                    });
-                  }
-                }
-              });
-            } catch {
-            }
-          }
-          return {
-            success: true,
-            analysis: { dependencies },
-            message: `Found ${dependencies.length} dependencies`
-          };
-        case "structure":
-          const { stdout: lsOutput } = await execFile("find", [path, "-type", "f", "-name", languagePattern]);
-          const allFiles = lsOutput.split("\n").filter((line) => line.trim());
-          const files = allFiles.slice(0, 1e3);
-          const { stdout: dirOutput } = await execFile("find", [path, "-type", "d"]);
-          const directories = dirOutput.split("\n").filter((line) => line.trim()).length;
-          const languages = {};
-          files.forEach((file) => {
-            const ext = file.split(".").pop();
-            if (ext) {
-              languages[ext] = (languages[ext] || 0) + 1;
-            }
-          });
-          const complexity = files.length > 1e3 ? "high" : files.length > 100 ? "medium" : "low";
-          return {
-            success: true,
-            analysis: {
-              structure: {
-                directories,
-                files: files.length,
-                languages,
-                complexity
-              }
-            },
-            message: `Analyzed project structure: ${files.length} files in ${directories} directories`
-          };
-        default:
-          return {
-            success: false,
-            analysis: {},
-            message: `Unknown analysis action: ${action}`
-          };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        analysis: {},
-        message: `Code analysis error: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
   /**
    * Perform multiple edits across files atomically
    */
@@ -2796,25 +2728,6 @@ export const mastra = new Mastra({
       };
     }
   }
-  /**
-   * Ask user for clarification
-   */
-  static async askClarification(context) {
-    const questionId = `q_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    if (!_AgentBuilderDefaults.pendingQuestions) {
-      _AgentBuilderDefaults.pendingQuestions = /* @__PURE__ */ new Map();
-    }
-    _AgentBuilderDefaults.pendingQuestions.set(questionId, {
-      ...context,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    return {
-      questionId,
-      question: context.question,
-      options: context.options?.map((opt) => ({ id: opt.id, description: opt.description })),
-      awaitingResponse: true
-    };
-  }
   /**
    * Signal task completion
    */
@@ -3221,90 +3134,212 @@ var ToolSummaryProcessor = class extends MemoryProcessor {
     this.summaryCache.clear();
   }
   /**
-   * Gets cache statistics
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.summaryCache.size,
+      keys: Array.from(this.summaryCache.keys())
+    };
+  }
+  async process(messages) {
+    const summaryTasks = [];
+    for (const message of messages) {
+      if (message.role === "tool" && Array.isArray(message.content) && message.content.length > 0 && message.content?.some((content) => content.type === "tool-result")) {
+        for (const content of message.content) {
+          if (content.type === "tool-result") {
+            const assistantMessageWithToolCall = messages.find(
+              (message2) => message2.role === "assistant" && Array.isArray(message2.content) && message2.content.length > 0 && message2.content?.some(
+                (assistantContent) => assistantContent.type === "tool-call" && assistantContent.toolCallId === content.toolCallId
+              )
+            );
+            const toolCall = Array.isArray(assistantMessageWithToolCall?.content) ? assistantMessageWithToolCall?.content.find(
+              (assistantContent) => assistantContent.type === "tool-call" && assistantContent.toolCallId === content.toolCallId
+            ) : null;
+            const cacheKey = this.createCacheKey(toolCall);
+            const cachedSummary = this.summaryCache.get(cacheKey);
+            if (cachedSummary) {
+              content.result = `Tool call summary: ${cachedSummary}`;
+            } else {
+              const summaryPromise = this.summaryAgent.generate(
+                `Summarize the following tool call: ${JSON.stringify(toolCall)} and result: ${JSON.stringify(content)}`
+              );
+              summaryTasks.push({
+                content,
+                promise: summaryPromise,
+                cacheKey
+              });
+            }
+          }
+        }
+      }
+    }
+    if (summaryTasks.length > 0) {
+      const summaryResults = await Promise.allSettled(summaryTasks.map((task) => task.promise));
+      summaryTasks.forEach((task, index) => {
+        const result = summaryResults[index];
+        if (!result) return;
+        if (result.status === "fulfilled") {
+          const summaryResult = result.value;
+          const summaryText = summaryResult.text;
+          this.summaryCache.set(task.cacheKey, summaryText);
+          task.content.result = `Tool call summary: ${summaryText}`;
+        } else if (result.status === "rejected") {
+          console.warn(`Failed to generate summary for tool call:`, result.reason);
+          task.content.result = `Tool call summary: [Summary generation failed]`;
+        }
+      });
+    }
+    return messages;
+  }
+};
+
+// src/agent/index.ts
+var AgentBuilder = class extends Agent {
+  builderConfig;
+  /**
+   * Constructor for AgentBuilder
+   */
+  constructor(config) {
+    const additionalInstructions = config.instructions ? `## Priority Instructions 
+
+${config.instructions}` : "";
+    const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
+    const agentConfig = {
+      name: "agent-builder",
+      description: "An AI agent specialized in generating Mastra agents, tools, and workflows from natural language requirements.",
+      instructions: combinedInstructions,
+      model: config.model,
+      tools: async () => {
+        return {
+          ...await AgentBuilderDefaults.getToolsForMode(config.projectPath, config.mode),
+          ...config.tools || {}
+        };
+      },
+      memory: new Memory({
+        options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
+        processors: [
+          // use the write to disk processor to debug the agent's context
+          // new WriteToDiskProcessor({ prefix: 'before-filter' }),
+          new ToolSummaryProcessor({ summaryModel: config.summaryModel || config.model }),
+          new TokenLimiter(1e5)
+          // new WriteToDiskProcessor({ prefix: 'after-filter' }),
+        ]
+      })
+    };
+    super(agentConfig);
+    this.builderConfig = config;
+  }
+  /**
+   * Enhanced generate method with AgentBuilder-specific configuration
+   * Overrides the base Agent generate method to provide additional project context
+   */
+  generate = async (messages, generateOptions = {}) => {
+    const { maxSteps, ...baseOptions } = generateOptions;
+    const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${additionalInstructions}`;
+    }
+    const enhancedContext = [...baseOptions.context || []];
+    const enhancedOptions = {
+      ...baseOptions,
+      maxSteps: maxSteps || 100,
+      // Higher default for code generation
+      temperature: 0.3,
+      // Lower temperature for more consistent code generation
+      instructions: enhancedInstructions,
+      context: enhancedContext
+    };
+    this.logger.debug(`[AgentBuilder:${this.name}] Starting generation with enhanced context`, {
+      projectPath: this.builderConfig.projectPath
+    });
+    return super.generate(messages, enhancedOptions);
+  };
+  /**
+   * Enhanced stream method with AgentBuilder-specific configuration
+   * Overrides the base Agent stream method to provide additional project context
+   */
+  stream = async (messages, streamOptions = {}) => {
+    const { maxSteps, ...baseOptions } = streamOptions;
+    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${additionalInstructions}`;
+    }
+    const enhancedContext = [...baseOptions.context || []];
+    const enhancedOptions = {
+      ...baseOptions,
+      maxSteps: maxSteps || 100,
+      // Higher default for code generation
+      temperature: 0.3,
+      // Lower temperature for more consistent code generation
+      instructions: enhancedInstructions,
+      context: enhancedContext
+    };
+    this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
+      projectPath: this.builderConfig.projectPath
+    });
+    return super.stream(messages, enhancedOptions);
+  };
+  /**
+   * Enhanced stream method with AgentBuilder-specific configuration
+   * Overrides the base Agent stream method to provide additional project context
    */
-  getCacheStats() {
-    return {
-      size: this.summaryCache.size,
-      keys: Array.from(this.summaryCache.keys())
-    };
-  }
-  async process(messages) {
-    const summaryTasks = [];
-    for (const message of messages) {
-      if (message.role === "tool" && Array.isArray(message.content) && message.content.length > 0 && message.content?.some((content) => content.type === "tool-result")) {
-        for (const content of message.content) {
-          if (content.type === "tool-result") {
-            const assistantMessageWithToolCall = messages.find(
-              (message2) => message2.role === "assistant" && Array.isArray(message2.content) && message2.content.length > 0 && message2.content?.some(
-                (assistantContent) => assistantContent.type === "tool-call" && assistantContent.toolCallId === content.toolCallId
-              )
-            );
-            const toolCall = Array.isArray(assistantMessageWithToolCall?.content) ? assistantMessageWithToolCall?.content.find(
-              (assistantContent) => assistantContent.type === "tool-call" && assistantContent.toolCallId === content.toolCallId
-            ) : null;
-            const cacheKey = this.createCacheKey(toolCall);
-            const cachedSummary = this.summaryCache.get(cacheKey);
-            if (cachedSummary) {
-              content.result = `Tool call summary: ${cachedSummary}`;
-            } else {
-              const summaryPromise = this.summaryAgent.generate(
-                `Summarize the following tool call: ${JSON.stringify(toolCall)} and result: ${JSON.stringify(content)}`
-              );
-              summaryTasks.push({
-                content,
-                promise: summaryPromise,
-                cacheKey
-              });
-            }
-          }
-        }
-      }
-    }
-    if (summaryTasks.length > 0) {
-      const summaryResults = await Promise.allSettled(summaryTasks.map((task) => task.promise));
-      summaryTasks.forEach((task, index) => {
-        const result = summaryResults[index];
-        if (!result) return;
-        if (result.status === "fulfilled") {
-          const summaryResult = result.value;
-          const summaryText = summaryResult.text;
-          this.summaryCache.set(task.cacheKey, summaryText);
-          task.content.result = `Tool call summary: ${summaryText}`;
-        } else if (result.status === "rejected") {
-          console.warn(`Failed to generate summary for tool call:`, result.reason);
-          task.content.result = `Tool call summary: [Summary generation failed]`;
-        }
-      });
+  async streamVNext(messages, streamOptions) {
+    const { ...baseOptions } = streamOptions || {};
+    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${additionalInstructions}`;
     }
-    return messages;
-  }
-};
-var WriteToDiskProcessor = class extends MemoryProcessor {
-  prefix;
-  constructor({ prefix = "messages" } = {}) {
-    super({ name: "WriteToDiskProcessor" });
-    this.prefix = prefix;
-  }
-  async process(messages) {
-    await writeFile(`${this.prefix}-${Date.now()}-${process.pid}.json`, JSON.stringify(messages, null, 2));
-    return messages;
+    const enhancedContext = [...baseOptions.context || []];
+    const enhancedOptions = {
+      ...baseOptions,
+      temperature: 0.3,
+      // Lower temperature for more consistent code generation
+      maxSteps: baseOptions?.maxSteps || 100,
+      instructions: enhancedInstructions,
+      context: enhancedContext
+    };
+    this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
+      projectPath: this.builderConfig.projectPath
+    });
+    return super.streamVNext(messages, enhancedOptions);
   }
-};
-var resolveModel2 = (runtimeContext) => {
-  const modelFromContext = runtimeContext.get("model");
-  if (modelFromContext) {
-    if (isValidMastraLanguageModel2(modelFromContext)) {
-      return modelFromContext;
+  async generateVNext(messages, options) {
+    const { ...baseOptions } = options || {};
+    const originalInstructions = await this.getInstructions({ runtimeContext: options?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${additionalInstructions}`;
     }
-    throw new Error(
-      'Invalid model provided. Model must be a MastraLanguageModel instance (e.g., openai("gpt-4"), anthropic("claude-3-5-sonnet"), etc.)'
-    );
+    const enhancedContext = [...baseOptions.context || []];
+    const enhancedOptions = {
+      ...baseOptions,
+      temperature: 0.3,
+      // Lower temperature for more consistent code generation
+      maxSteps: baseOptions?.maxSteps || 100,
+      instructions: enhancedInstructions,
+      context: enhancedContext
+    };
+    this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
+      projectPath: this.builderConfig.projectPath
+    });
+    return super.generateVNext(messages, enhancedOptions);
   }
-  return openai("gpt-4.1");
-};
-var isValidMastraLanguageModel2 = (model) => {
-  return model && typeof model === "object" && typeof model.modelId === "string" && typeof model.generate === "function";
 };
 var cloneTemplateStep = createStep({
   id: "clone-template",
@@ -3312,7 +3347,7 @@ var cloneTemplateStep = createStep({
   inputSchema: AgentBuilderInputSchema,
   outputSchema: CloneTemplateResultSchema,
   execute: async ({ inputData }) => {
-    const { repo, ref = "main", slug } = inputData;
+    const { repo, ref = "main", slug, targetPath } = inputData;
     if (!repo) {
       throw new Error("Repository URL or path is required");
     }
@@ -3328,7 +3363,8 @@ var cloneTemplateStep = createStep({
         templateDir: tempDir,
         commitSha: commitSha.trim(),
         slug: inferredSlug,
-        success: true
+        success: true,
+        targetPath
       };
     } catch (error) {
       try {
@@ -3340,7 +3376,8 @@ var cloneTemplateStep = createStep({
         commitSha: "",
         slug: slug || "unknown",
         success: false,
-        error: `Failed to clone template: ${error instanceof Error ? error.message : String(error)}`
+        error: `Failed to clone template: ${error instanceof Error ? error.message : String(error)}`,
+        targetPath
       };
     }
   }
@@ -3391,10 +3428,13 @@ var discoverUnitsStep = createStep({
   outputSchema: DiscoveryResultSchema,
   execute: async ({ inputData, runtimeContext }) => {
     const { templateDir } = inputData;
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
+    console.log("targetPath", targetPath);
+    const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
     try {
       const agent = new Agent({
-        model: resolveModel2(runtimeContext),
+        model,
         instructions: `You are an expert at analyzing Mastra projects.
 
 Your task is to scan the provided directory and identify all available units (agents, workflows, tools, MCP servers, networks).
@@ -3432,8 +3472,8 @@ Return the actual exported names of the units, as well as the file names.`,
           listDirectory: tools.listDirectory
         }
       });
-      const result = await agent.generate(
-        `Analyze the Mastra project directory structure at "${templateDir}".
+      const isV2 = model.specificationVersion === "v2";
+      const prompt = `Analyze the Mastra project directory structure at "${templateDir}".
 
             List directory contents using listDirectory tool, and then analyze each file with readFile tool.
       IMPORTANT:
@@ -3442,19 +3482,22 @@ Return the actual exported names of the units, as well as the file names.`,
       - Return the actual exported variable names, as well as the file names
       - If a directory doesn't exist or has no files, return an empty array
 
-      Return the analysis in the exact format specified in the output schema.`,
-        {
-          experimental_output: z.object({
-            agents: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
-            workflows: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
-            tools: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
-            mcp: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
-            networks: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
-            other: z.array(z.object({ name: z.string(), file: z.string() })).optional()
-          }),
-          maxSteps: 100
-        }
-      );
+      Return the analysis in the exact format specified in the output schema.`;
+      const output = z.object({
+        agents: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+        workflows: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+        tools: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+        mcp: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+        networks: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+        other: z.array(z.object({ name: z.string(), file: z.string() })).optional()
+      });
+      const result = isV2 ? await agent.generateVNext(prompt, {
+        output,
+        maxSteps: 100
+      }) : await agent.generate(prompt, {
+        experimental_output: output,
+        maxSteps: 100
+      });
       const template = result.object ?? {};
       const units = [];
       template.agents?.forEach((agentId) => {
@@ -3875,7 +3918,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetMastraIndex,
               unit: { kind: "other", id: "mastra-index" }
             });
-            console.log("\u2713 Copied src/mastra/index.ts from template to target");
+            console.log("\u2713 Copied Mastra index file from template");
           }
         }
       } catch (e) {
@@ -3886,6 +3929,88 @@ var programmaticFileCopyStep = createStep({
           targetFile: "src/mastra/index.ts"
         });
       }
+      try {
+        const targetGitignore = resolve(targetPath, ".gitignore");
+        const templateGitignore = resolve(templateDir, ".gitignore");
+        const targetExists = existsSync(targetGitignore);
+        const templateExists = existsSync(templateGitignore);
+        if (templateExists) {
+          if (!targetExists) {
+            await copyFile(templateGitignore, targetGitignore);
+            copiedFiles.push({
+              source: templateGitignore,
+              destination: targetGitignore,
+              unit: { kind: "other", id: "gitignore" }
+            });
+            console.log("\u2713 Copied .gitignore from template to target");
+          } else {
+            const targetContent = await readFile(targetGitignore, "utf-8");
+            const templateContent = await readFile(templateGitignore, "utf-8");
+            const mergedContent = mergeGitignoreFiles(targetContent, templateContent, slug);
+            if (mergedContent !== targetContent) {
+              const addedLines = mergedContent.split("\n").length - targetContent.split("\n").length;
+              await writeFile(targetGitignore, mergedContent, "utf-8");
+              copiedFiles.push({
+                source: templateGitignore,
+                destination: targetGitignore,
+                unit: { kind: "other", id: "gitignore-merge" }
+              });
+              console.log(`\u2713 Merged template .gitignore entries into existing .gitignore (${addedLines} new entries)`);
+            } else {
+              console.log("\u2139 No new .gitignore entries to add from template");
+            }
+          }
+        }
+      } catch (e) {
+        conflicts.push({
+          unit: { kind: "other", id: "gitignore" },
+          issue: `Failed to handle .gitignore file: ${e instanceof Error ? e.message : String(e)}`,
+          sourceFile: ".gitignore",
+          targetFile: ".gitignore"
+        });
+      }
+      try {
+        const { variables } = inputData;
+        if (variables && Object.keys(variables).length > 0) {
+          const targetEnv = resolve(targetPath, ".env");
+          const targetExists = existsSync(targetEnv);
+          if (!targetExists) {
+            const envContent = [
+              `# Environment variables for ${slug}`,
+              ...Object.entries(variables).map(([key, value]) => `${key}=${value}`)
+            ].join("\n");
+            await writeFile(targetEnv, envContent, "utf-8");
+            copiedFiles.push({
+              source: "[template variables]",
+              destination: targetEnv,
+              unit: { kind: "other", id: "env" }
+            });
+            console.log(`\u2713 Created .env file with ${Object.keys(variables).length} template variables`);
+          } else {
+            const targetContent = await readFile(targetEnv, "utf-8");
+            const mergedContent = mergeEnvFiles(targetContent, variables, slug);
+            if (mergedContent !== targetContent) {
+              const addedLines = mergedContent.split("\n").length - targetContent.split("\n").length;
+              await writeFile(targetEnv, mergedContent, "utf-8");
+              copiedFiles.push({
+                source: "[template variables]",
+                destination: targetEnv,
+                unit: { kind: "other", id: "env-merge" }
+              });
+              console.log(`\u2713 Merged new environment variables into existing .env file (${addedLines} new entries)`);
+            } else {
+              console.log("\u2139 No new environment variables to add (all already exist in .env)");
+            }
+          }
+        }
+      } catch (e) {
+        conflicts.push({
+          unit: { kind: "other", id: "env" },
+          issue: `Failed to handle .env file: ${e instanceof Error ? e.message : String(e)}`,
+          sourceFile: ".env",
+          targetFile: ".env"
+        });
+      }
       if (copiedFiles.length > 0) {
         try {
           const fileList = copiedFiles.map((f) => f.destination);
@@ -3930,6 +4055,7 @@ var intelligentMergeStep = createStep({
     const { conflicts, copiedFiles, commitSha, slug, templateDir, branchName } = inputData;
     const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
+      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
       const copyFileTool = createTool({
         id: "copy-file",
         description: "Copy a file from template to target project (use only for edge cases - most files are already copied programmatically).",
@@ -3967,7 +4093,7 @@ var intelligentMergeStep = createStep({
       const agentBuilder = new AgentBuilder({
         projectPath: targetPath,
         mode: "template",
-        model: resolveModel2(runtimeContext),
+        model,
         instructions: `
 You are an expert at integrating Mastra template components into existing projects.
 
@@ -4070,7 +4196,7 @@ Template information:
       console.log(`Creating task list with ${tasks.length} tasks...`);
       await AgentBuilderDefaults.manageTaskList({ action: "create", tasks });
       await logGitState(targetPath, "before intelligent merge");
-      const result = await agentBuilder.stream(`
+      const prompt = `
 You need to work through a task list to complete the template integration.
 
 CRITICAL INSTRUCTIONS:
@@ -4112,31 +4238,37 @@ For each task:
 - DO NOT perform validation - that's handled by the dedicated validation step
 
 Start by listing your tasks and work through them systematically!
-`);
+`;
+      const isV2 = model.specificationVersion === "v2";
+      const result = isV2 ? await agentBuilder.streamVNext(prompt) : await agentBuilder.stream(prompt);
       const actualResolutions = [];
       for await (const chunk of result.fullStream) {
         if (chunk.type === "step-finish" || chunk.type === "step-start") {
+          const chunkData = "payload" in chunk ? chunk.payload : chunk;
           console.log({
             type: chunk.type,
-            msgId: chunk.messageId
+            msgId: chunkData.messageId
           });
         } else {
           console.log(JSON.stringify(chunk, null, 2));
-          if (chunk.type === "tool-result" && chunk.toolName === "manageTaskList") {
-            try {
-              const toolResult = chunk.result;
-              if (toolResult.action === "update" && toolResult.status === "completed") {
-                actualResolutions.push({
-                  taskId: toolResult.taskId || "",
-                  action: toolResult.action,
-                  status: toolResult.status,
-                  content: toolResult.content || "",
-                  notes: toolResult.notes
-                });
-                console.log(`\u{1F4CB} Task completed: ${toolResult.taskId} - ${toolResult.content}`);
+          if (chunk.type === "tool-result") {
+            const chunkData = "payload" in chunk ? chunk.payload : chunk;
+            if (chunkData.toolName === "manageTaskList") {
+              try {
+                const toolResult = chunkData.result;
+                if (toolResult.action === "update" && toolResult.status === "completed") {
+                  actualResolutions.push({
+                    taskId: toolResult.taskId || "",
+                    action: toolResult.action,
+                    status: toolResult.status,
+                    content: toolResult.content || "",
+                    notes: toolResult.notes
+                  });
+                  console.log(`\u{1F4CB} Task completed: ${toolResult.taskId} - ${toolResult.content}`);
+                }
+              } catch (parseError) {
+                console.warn("Failed to parse task management result:", parseError);
               }
-            } catch (parseError) {
-              console.warn("Failed to parse task management result:", parseError);
             }
           }
         }
@@ -4209,7 +4341,8 @@ var validationAndFixStep = createStep({
     );
     let currentIteration = 1;
     try {
-      const allTools = await AgentBuilderDefaults.DEFAULT_TOOLS(targetPath, "template");
+      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
+      const allTools = await AgentBuilderDefaults.getToolsForMode(targetPath, "template");
       const validationAgent = new Agent({
         name: "code-validator-fixer",
         description: "Specialized agent for validating and fixing template integration issues",
@@ -4318,7 +4451,7 @@ INTEGRATED UNITS:
 ${JSON.stringify(orderedUnits, null, 2)}
 
 Be thorough and methodical. Always use listDirectory to verify actual file existence before fixing imports.`,
-        model: resolveModel2(runtimeContext),
+        model,
         tools: {
           validateCode: allTools.validateCode,
           readFile: allTools.readFile,
@@ -4335,7 +4468,9 @@ Be thorough and methodical. Always use listDirectory to verify actual file exist
         errorsFixed: 0,
         remainingErrors: 1,
         // Start with 1 to enter the loop
-        iteration: currentIteration
+        iteration: currentIteration,
+        lastValidationErrors: []
+        // Store the actual error details
       };
       while (validationResults.remainingErrors > 0 && currentIteration <= maxIterations) {
         console.log(`
@@ -4345,24 +4480,32 @@ Be thorough and methodical. Always use listDirectory to verify actual file exist
 Start by running validateCode with all validation types to get a complete picture of any issues, then systematically fix them.` : `Continue validation and fixing for the template integration at ${targetPath}. This is iteration ${currentIteration} of validation.
 
 Previous iterations may have fixed some issues, so start by re-running validateCode to see the current state, then fix any remaining issues.`;
-        const result = await validationAgent.stream(iterationPrompt, {
-          experimental_output: z.object({ success: z.boolean() })
+        const isV2 = model.specificationVersion === "v2";
+        const output = z.object({ success: z.boolean() });
+        const result = isV2 ? await validationAgent.streamVNext(iterationPrompt, {
+          output
+        }) : await validationAgent.stream(iterationPrompt, {
+          experimental_output: output
         });
         let iterationErrors = 0;
         let previousErrors = validationResults.remainingErrors;
+        let lastValidationResult = null;
         for await (const chunk of result.fullStream) {
           if (chunk.type === "step-finish" || chunk.type === "step-start") {
+            const chunkData = "payload" in chunk ? chunk.payload : chunk;
             console.log({
               type: chunk.type,
-              msgId: chunk.messageId,
+              msgId: chunkData.messageId,
               iteration: currentIteration
             });
           } else {
             console.log(JSON.stringify(chunk, null, 2));
           }
           if (chunk.type === "tool-result") {
-            if (chunk.toolName === "validateCode") {
-              const toolResult = chunk.result;
+            const chunkData = "payload" in chunk ? chunk.payload : chunk;
+            if (chunkData.toolName === "validateCode") {
+              const toolResult = chunkData.result;
+              lastValidationResult = toolResult;
               if (toolResult?.summary) {
                 iterationErrors = toolResult.summary.totalErrors || 0;
                 console.log(`Iteration ${currentIteration}: Found ${iterationErrors} errors`);
@@ -4374,6 +4517,9 @@ Previous iterations may have fixed some issues, so start by re-running validateC
         validationResults.errorsFixed += Math.max(0, previousErrors - iterationErrors);
         validationResults.valid = iterationErrors === 0;
         validationResults.iteration = currentIteration;
+        if (iterationErrors > 0 && lastValidationResult?.errors) {
+          validationResults.lastValidationErrors = lastValidationResult.errors;
+        }
         console.log(`Iteration ${currentIteration} complete: ${iterationErrors} errors remaining`);
         if (iterationErrors === 0) {
           console.log(`\u2705 All validation issues resolved in ${currentIteration} iterations!`);
@@ -4396,14 +4542,16 @@ Previous iterations may have fixed some issues, so start by re-running validateC
       } catch (commitError) {
         console.warn("Failed to commit validation fixes:", commitError);
       }
+      const success = validationResults.valid;
       return {
-        success: true,
+        success,
         applied: true,
-        message: `Validation completed in ${currentIteration} iteration${currentIteration > 1 ? "s" : ""}. ${validationResults.valid ? "All issues resolved!" : `${validationResults.remainingErrors} issues remaining`}`,
+        message: `Validation completed in ${currentIteration} iteration${currentIteration > 1 ? "s" : ""}. ${validationResults.valid ? "All issues resolved!" : `${validationResults.remainingErrors} issue${validationResults.remainingErrors > 1 ? "s" : ""} remaining`}`,
         validationResults: {
           valid: validationResults.valid,
           errorsFixed: validationResults.errorsFixed,
-          remainingErrors: validationResults.remainingErrors
+          remainingErrors: validationResults.remainingErrors,
+          errors: validationResults.lastValidationErrors
         }
       };
     } catch (error) {
@@ -4497,7 +4645,8 @@ var agentBuilderTemplateWorkflow = createWorkflow({
     templateDir: cloneResult.templateDir,
     commitSha: cloneResult.commitSha,
     slug: cloneResult.slug,
-    targetPath: initData.targetPath
+    targetPath: initData.targetPath,
+    variables: initData.variables
   };
 }).then(programmaticFileCopyStep).map(async ({ getStepResult, getInitData }) => {
   const copyResult = getStepResult(programmaticFileCopyStep);
@@ -4564,6 +4713,9 @@ var agentBuilderTemplateWorkflow = createWorkflow({
   if (validationResult.validationResults?.errorsFixed > 0) {
     messages.push(`${validationResult.validationResults.errorsFixed} validation errors fixed`);
   }
+  if (validationResult.validationResults?.remainingErrors > 0) {
+    messages.push(`${validationResult.validationResults.remainingErrors} validation issues remain`);
+  }
   const comprehensiveMessage = messages.length > 0 ? `Template merge completed: ${messages.join(", ")}` : validationResult.message || "Template merge completed";
   return {
     success: overallSuccess,
@@ -4935,8 +5087,9 @@ var planningIterationStep = createStep({
       `Current Q&A state: ${storedQAPairs.length} question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
     );
     try {
+      const model = await resolveModel({ runtimeContext });
       const planningAgent = new Agent({
-        model: resolveModel(runtimeContext),
+        model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
           storedQAPairs
         }),
@@ -5662,8 +5815,9 @@ var workflowResearchStep = createStep({
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Starting workflow research...");
     try {
+      const model = await resolveModel({ runtimeContext });
       const researchAgent = new Agent({
-        model: resolveModel(runtimeContext),
+        model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
         name: "Workflow Research Agent"
         // tools: filteredMcpTools,
@@ -5740,6 +5894,7 @@ var taskExecutionStep = createStep({
     console.log(`Starting task execution for ${action}ing workflow: ${workflowName}`);
     console.log(`Executing ${tasks.length} tasks using AgentBuilder stream...`);
     try {
+      const model = await resolveModel({ runtimeContext });
       const currentProjectPath = projectPath || process.cwd();
       console.log("Pre-populating taskManager with planned tasks...");
       const taskManagerContext = {
@@ -5760,7 +5915,7 @@ var taskExecutionStep = createStep({
       }
       const executionAgent = new AgentBuilder({
         projectPath: currentProjectPath,
-        model: resolveModel(runtimeContext),
+        model,
         tools: {
           "task-manager": restrictedTaskManager
         },
@@ -5827,7 +5982,7 @@ ${workflowBuilderPrompts.validation.instructions}`;
         const stream = await executionAgent.streamVNext(iterationPrompt, {
           structuredOutput: {
             schema: TaskExecutionIterationInputSchema(tasks.length),
-            model: resolveModel(runtimeContext)
+            model
           },
           ...enhancedOptions
         });
@@ -5992,131 +6147,6 @@ var agentBuilderWorkflows = {
   "workflow-builder": workflowBuilderWorkflow
 };
 
-// src/agent/index.ts
-var AgentBuilder = class extends Agent {
-  builderConfig;
-  /**
-   * Constructor for AgentBuilder
-   */
-  constructor(config) {
-    const additionalInstructions = config.instructions ? `## Priority Instructions 
-
-${config.instructions}` : "";
-    const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
-    const agentConfig = {
-      name: "agent-builder",
-      description: "An AI agent specialized in generating Mastra agents, tools, and workflows from natural language requirements.",
-      instructions: combinedInstructions,
-      model: config.model,
-      tools: async () => {
-        return {
-          ...await AgentBuilderDefaults.DEFAULT_TOOLS(config.projectPath, config.mode),
-          ...config.tools || {}
-        };
-      },
-      workflows: agentBuilderWorkflows,
-      memory: new Memory({
-        options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
-        processors: [
-          new WriteToDiskProcessor({ prefix: "before-filter" }),
-          new ToolSummaryProcessor({ summaryModel: config.summaryModel || config.model }),
-          new TokenLimiter(1e5),
-          new WriteToDiskProcessor({ prefix: "after-filter" })
-        ]
-      })
-    };
-    super(agentConfig);
-    this.builderConfig = config;
-  }
-  /**
-   * Enhanced generate method with AgentBuilder-specific configuration
-   * Overrides the base Agent generate method to provide additional project context
-   */
-  generate = async (messages, generateOptions = {}) => {
-    const { ...baseOptions } = generateOptions;
-    const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
-    const additionalInstructions = baseOptions.instructions;
-    let enhancedInstructions = originalInstructions;
-    if (additionalInstructions) {
-      enhancedInstructions = `${originalInstructions}
-
-${additionalInstructions}`;
-    }
-    const enhancedContext = [...baseOptions.context || []];
-    const enhancedOptions = {
-      ...baseOptions,
-      maxSteps: 300,
-      // Higher default for code generation
-      temperature: 0.3,
-      // Lower temperature for more consistent code generation
-      instructions: enhancedInstructions,
-      context: enhancedContext
-    };
-    this.logger.debug(`[AgentBuilder:${this.name}] Starting generation with enhanced context`, {
-      projectPath: this.builderConfig.projectPath
-    });
-    return super.generate(messages, enhancedOptions);
-  };
-  /**
-   * Enhanced stream method with AgentBuilder-specific configuration
-   * Overrides the base Agent stream method to provide additional project context
-   */
-  stream = async (messages, streamOptions = {}) => {
-    const { ...baseOptions } = streamOptions;
-    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
-    const additionalInstructions = baseOptions.instructions;
-    let enhancedInstructions = originalInstructions;
-    if (additionalInstructions) {
-      enhancedInstructions = `${originalInstructions}
-
-${additionalInstructions}`;
-    }
-    const enhancedContext = [...baseOptions.context || []];
-    const enhancedOptions = {
-      ...baseOptions,
-      maxSteps: 100,
-      // Higher default for code generation
-      temperature: 0.3,
-      // Lower temperature for more consistent code generation
-      instructions: enhancedInstructions,
-      context: enhancedContext
-    };
-    this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
-      projectPath: this.builderConfig.projectPath
-    });
-    return super.stream(messages, enhancedOptions);
-  };
-  /**
-   * Generate a Mastra agent from natural language requirements
-   */
-  async generateAgent(requirements, options) {
-    const prompt = `Generate a Mastra agent based on these requirements: ${requirements}
-
-Please provide:
-1. Complete agent code with proper configuration
-2. Any custom tools the agent needs
-3. Example usage
-4. Testing recommendations
-
-${options?.outputFormat === "explanation" ? "Focus on explaining the approach and architecture." : ""}
-${options?.outputFormat === "code" ? "Focus on providing complete, working code." : ""}
-${!options?.outputFormat || options.outputFormat === "both" ? "Provide both explanation and complete code." : ""}`;
-    return this.generate(prompt, {
-      runtimeContext: options?.runtimeContext
-    });
-  }
-  /**
-   * Get the default configuration for AgentBuilder
-   */
-  static defaultConfig(projectPath) {
-    return {
-      instructions: AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(projectPath),
-      memoryConfig: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
-      tools: AgentBuilderDefaults.DEFAULT_TOOLS
-    };
-  }
-};
-
 export { AgentBuilder, AgentBuilderDefaults, agentBuilderTemplateWorkflow, agentBuilderWorkflows, mergeTemplateBySlug, planningAndApprovalWorkflow, workflowBuilderWorkflow };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map