@mastra/agent-builder 0.0.0-iterate-traces-ui-again-20250912091900 → 0.0.0-main-test-20251105183450

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Agent } from '@mastra/core/agent';
+import { Agent, tryGenerateWithJsonFallback, tryStreamWithJsonFallback } from '@mastra/core/agent';
 import { Memory } from '@mastra/memory';
 import { TokenLimiter } from '@mastra/memory/processors';
 import { exec as exec$1, execFile as execFile$1, spawn as spawn$1 } from 'child_process';
@@ -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 { ModelRouterLanguageModel } from '@mastra/core/llm';
 import { MemoryProcessor } from '@mastra/core/memory';
 import { tmpdir } from 'os';
 import { openai } from '@ai-sdk/openai';
@@ -224,7 +224,7 @@ function isInWorkspaceSubfolder(cwd) {
       if (currentDir === cwd) {
         continue;
       }
-      console.log(`Checking for workspace indicators in: ${currentDir}`);
+      console.info(`Checking for workspace indicators in: ${currentDir}`);
       if (existsSync(resolve(currentDir, "pnpm-workspace.yaml"))) {
         return true;
       }
@@ -244,7 +244,7 @@ function isInWorkspaceSubfolder(cwd) {
     }
     return false;
   } catch (error) {
-    console.log(`Error in workspace detection: ${error}`);
+    console.warn(`Error in workspace detection: ${error}`);
     return false;
   }
 }
@@ -315,12 +315,12 @@ function spawnWithOutput(command, args, options) {
 }
 async function spawnSWPM(cwd, command, packageNames) {
   try {
-    console.log("Running install command with swpm");
+    console.info("Running install command with swpm");
     const swpmPath = createRequire(import.meta.filename).resolve("swpm");
     await spawn(swpmPath, [command, ...packageNames], { cwd });
     return;
   } catch (e) {
-    console.log("Failed to run install command with swpm", e);
+    console.warn("Failed to run install command with swpm", e);
   }
   try {
     let packageManager;
@@ -348,11 +348,11 @@ async function spawnSWPM(cwd, command, packageNames) {
       }
     }
     args.push(...packageNames);
-    console.log(`Falling back to ${packageManager} ${args.join(" ")}`);
+    console.info(`Falling back to ${packageManager} ${args.join(" ")}`);
     await spawn(packageManager, args, { cwd });
     return;
   } catch (e) {
-    console.log(`Failed to run install command with native package manager: ${e}`);
+    console.warn(`Failed to run install command with native package manager: ${e}`);
   }
   throw new Error(`Failed to run install command with swpm and native package managers`);
 }
@@ -383,10 +383,10 @@ async function logGitState(targetPath, label) {
     const gitStatusResult = await git(targetPath, "status", "--porcelain");
     const gitLogResult = await git(targetPath, "log", "--oneline", "-3");
     const gitCountResult = await git(targetPath, "rev-list", "--count", "HEAD");
-    console.log(`\u{1F4CA} Git state ${label}:`);
-    console.log("Status:", gitStatusResult.stdout.trim() || "Clean working directory");
-    console.log("Recent commits:", gitLogResult.stdout.trim());
-    console.log("Total commits:", gitCountResult.stdout.trim());
+    console.info(`\u{1F4CA} Git state ${label}:`);
+    console.info("Status:", gitStatusResult.stdout.trim() || "Clean working directory");
+    console.info("Recent commits:", gitLogResult.stdout.trim());
+    console.info("Total commits:", gitCountResult.stdout.trim());
   } catch (gitError) {
     console.warn(`Could not get git state ${label}:`, gitError);
   }
@@ -458,18 +458,18 @@ async function gitCheckoutBranch(branchName, targetPath) {
   try {
     if (!await isInsideGitRepo(targetPath)) return;
     await git(targetPath, "checkout", "-b", branchName);
-    console.log(`Created new branch: ${branchName}`);
+    console.info(`Created new branch: ${branchName}`);
   } catch (error) {
     const errorStr = error instanceof Error ? error.message : String(error);
     if (errorStr.includes("already exists")) {
       try {
         await git(targetPath, "checkout", branchName);
-        console.log(`Switched to existing branch: ${branchName}`);
+        console.info(`Switched to existing branch: ${branchName}`);
       } catch {
         const timestamp = Date.now().toString().slice(-6);
         const uniqueBranchName = `${branchName}-${timestamp}`;
         await git(targetPath, "checkout", "-b", uniqueBranchName);
-        console.log(`Created unique branch: ${uniqueBranchName}`);
+        console.info(`Created unique branch: ${uniqueBranchName}`);
       }
     } else {
       throw error;
@@ -479,9 +479,9 @@ async function gitCheckoutBranch(branchName, targetPath) {
 async function backupAndReplaceFile(sourceFile, targetFile) {
   const backupFile = `${targetFile}.backup-${Date.now()}`;
   await copyFile(targetFile, backupFile);
-  console.log(`\u{1F4E6} Created backup: ${basename(backupFile)}`);
+  console.info(`\u{1F4E6} Created backup: ${basename(backupFile)}`);
   await copyFile(sourceFile, targetFile);
-  console.log(`\u{1F504} Replaced file with template version (backup created)`);
+  console.info(`\u{1F504} Replaced file with template version (backup created)`);
 }
 async function renameAndCopyFile(sourceFile, targetFile) {
   let counter = 1;
@@ -495,17 +495,17 @@ async function renameAndCopyFile(sourceFile, targetFile) {
     counter++;
   }
   await copyFile(sourceFile, uniqueTargetFile);
-  console.log(`\u{1F4DD} Copied with unique name: ${basename(uniqueTargetFile)}`);
+  console.info(`\u{1F4DD} Copied with unique name: ${basename(uniqueTargetFile)}`);
   return uniqueTargetFile;
 }
 var isValidMastraLanguageModel = (model) => {
   return model && typeof model === "object" && typeof model.modelId === "string";
 };
-var resolveTargetPath = (inputData, runtimeContext) => {
+var resolveTargetPath = (inputData, requestContext) => {
   if (inputData.targetPath) {
     return inputData.targetPath;
   }
-  const contextPath = runtimeContext.get("targetPath");
+  const contextPath = requestContext.get("targetPath");
   if (contextPath) {
     return contextPath;
   }
@@ -544,7 +544,7 @@ var mergeGitignoreFiles = (targetContent, templateContent, templateSlug) => {
         if (!hasConflict) {
           newEntries.push(trimmed);
         } else {
-          console.log(`\u26A0 Skipping conflicting .gitignore rule: ${trimmed} (conflicts with existing rule)`);
+          console.info(`\u26A0 Skipping conflicting .gitignore rule: ${trimmed} (conflicts with existing rule)`);
         }
       }
     }
@@ -579,7 +579,7 @@ var mergeEnvFiles = (targetContent, templateVariables, templateSlug) => {
     if (!existingVars.has(key)) {
       newVars.push({ key, value });
     } else {
-      console.log(`\u26A0 Skipping existing environment variable: ${key} (already exists in .env)`);
+      console.info(`\u26A0 Skipping existing environment variable: ${key} (already exists in .env)`);
     }
   }
   if (newVars.length === 0) {
@@ -600,7 +600,7 @@ var detectAISDKVersion = async (projectPath) => {
   try {
     const packageJsonPath = join(projectPath, "package.json");
     if (!existsSync(packageJsonPath)) {
-      console.log("No package.json found, defaulting to v2");
+      console.info("No package.json found, defaulting to v2");
       return "v2";
     }
     const packageContent = await readFile(packageJsonPath, "utf-8");
@@ -618,16 +618,16 @@ var detectAISDKVersion = async (projectPath) => {
         if (versionMatch) {
           const majorVersion = parseInt(versionMatch[1]);
           if (majorVersion >= 2) {
-            console.log(`Detected ${pkg} v${majorVersion} -> using v2 specification`);
+            console.info(`Detected ${pkg} v${majorVersion} -> using v2 specification`);
             return "v2";
           } else {
-            console.log(`Detected ${pkg} v${majorVersion} -> using v1 specification`);
+            console.info(`Detected ${pkg} v${majorVersion} -> using v1 specification`);
             return "v1";
           }
         }
       }
     }
-    console.log("No AI SDK version detected, defaulting to v2");
+    console.info("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)}`);
@@ -658,37 +658,15 @@ var createModelInstance = async (provider, modelId, version = "v2") => {
           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];
+    const providerFn = version === `v1` ? providerMap[version][provider] : () => new ModelRouterLanguageModel(`${provider}/${modelId}`);
     if (!providerFn) {
       console.error(`Unsupported provider: ${provider}`);
       return null;
     }
     const modelInstance = await providerFn();
-    console.log(`Created ${provider} model instance (${version}): ${modelId}`);
+    console.info(`Created ${provider} model instance (${version}): ${modelId}`);
     return modelInstance;
   } catch (error) {
     console.error(`Failed to create model instance: ${error instanceof Error ? error.message : String(error)}`);
@@ -696,13 +674,13 @@ var createModelInstance = async (provider, modelId, version = "v2") => {
   }
 };
 var resolveModel = async ({
-  runtimeContext,
-  defaultModel = openai$1("gpt-4.1"),
+  requestContext,
+  defaultModel = "openai/gpt-4.1",
   projectPath
 }) => {
-  const modelFromContext = runtimeContext.get("model");
+  const modelFromContext = requestContext.get("model");
   if (modelFromContext) {
-    console.log("Using model from runtime context");
+    console.info("Using model from request context");
     if (isValidMastraLanguageModel(modelFromContext)) {
       return modelFromContext;
     }
@@ -710,18 +688,18 @@ var resolveModel = async ({
       '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");
+  const selectedModel = requestContext.get("selectedModel");
   if (selectedModel?.provider && selectedModel?.modelId && projectPath) {
-    console.log(`Resolving selected model: ${selectedModel.provider}/${selectedModel.modelId}`);
+    console.info(`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);
+      requestContext.set("model", modelInstance);
       return modelInstance;
     }
   }
-  console.log("Using default model");
-  return defaultModel;
+  console.info("Using default model");
+  return typeof defaultModel === `string` ? new ModelRouterLanguageModel(defaultModel) : defaultModel;
 };
 
 // src/defaults.ts
@@ -890,7 +868,7 @@ You have access to an enhanced set of tools based on production coding agent pat
 ### Task Management
 - **taskManager**: Create and track multi-step coding tasks with states (pending, in_progress, completed, blocked). Use this for complex projects that require systematic progress tracking.
 
-### Code Discovery & Analysis  
+### Code Discovery & Analysis
 - **codeAnalyzer**: Analyze codebase structure, discover definitions (functions, classes, interfaces), map dependencies, and understand architectural patterns.
 - **smartSearch**: Intelligent search with context awareness, pattern matching, and relevance scoring.
 
@@ -928,6 +906,7 @@ import { LibSQLStore } from '@mastra/libsql';
 import { weatherTool } from '../tools/weather-tool';
 
 export const weatherAgent = new Agent({
+  id: 'weather-agent',
   name: 'Weather Agent',
   instructions: \${instructions},
   model: openai('gpt-4o-mini'),
@@ -962,8 +941,8 @@ export const weatherTool = createTool({
     conditions: z.string(),
     location: z.string(),
   }),
-  execute: async ({ context }) => {
-    return await getWeather(context.location);
+  execute: async (inputData) => {
+    return await getWeather(inputData.location);
   },
 });
 \`\`\`
@@ -981,7 +960,7 @@ const fetchWeather = createStep({
     city: z.string().describe('The city to get the weather for'),
   }),
   outputSchema: forecastSchema,
-  execute: async ({ inputData }) => {
+  execute: async (inputData) => {
     if (!inputData) {
       throw new Error('Input data not found');
     }
@@ -1035,7 +1014,8 @@ const planActivities = createStep({
   outputSchema: z.object({
     activities: z.string(),
   }),
-  execute: async ({ inputData, mastra }) => {
+  execute: async (inputData, context) => {
+    const mastra = context?.mastra;
     const forecast = inputData;
 
     if (!forecast) {
@@ -1100,7 +1080,7 @@ export const mastra = new Mastra({
   workflows: { weatherWorkflow },
   agents: { weatherAgent },
   storage: new LibSQLStore({
-    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
+    // stores observability, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
   logger: new PinoLogger({
@@ -1144,8 +1124,8 @@ export const mastra = new Mastra({
           }).optional(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.readFile({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.readFile({ ...inputData, projectPath });
         }
       }),
       writeFile: createTool({
@@ -1164,8 +1144,8 @@ export const mastra = new Mastra({
           message: z.string(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.writeFile({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.writeFile({ ...inputData, projectPath });
         }
       }),
       listDirectory: createTool({
@@ -1196,8 +1176,8 @@ export const mastra = new Mastra({
           message: z.string(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.listDirectory({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.listDirectory({ ...inputData, projectPath });
         }
       }),
       executeCommand: createTool({
@@ -1221,10 +1201,10 @@ export const mastra = new Mastra({
           executionTime: z.number().optional(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
+        execute: async (inputData) => {
           return await _AgentBuilderDefaults.executeCommand({
-            ...context,
-            workingDirectory: context.workingDirectory || projectPath
+            ...inputData,
+            workingDirectory: inputData.workingDirectory || projectPath
           });
         }
       }),
@@ -1262,8 +1242,8 @@ export const mastra = new Mastra({
           ),
           message: z.string()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.manageTaskList(context);
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.manageTaskList(inputData);
         }
       }),
       // Advanced File Operations
@@ -1297,8 +1277,8 @@ export const mastra = new Mastra({
           ),
           message: z.string()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.performMultiEdit({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.performMultiEdit({ ...inputData, projectPath });
         }
       }),
       replaceLines: createTool({
@@ -1322,8 +1302,8 @@ export const mastra = new Mastra({
           backup: z.string().optional(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.replaceLines({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.replaceLines({ ...inputData, projectPath });
         }
       }),
       // File diagnostics tool to help debug line replacement issues
@@ -1351,8 +1331,8 @@ export const mastra = new Mastra({
           message: z.string(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.showFileLines({ ...context, projectPath });
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.showFileLines({ ...inputData, projectPath });
         }
       }),
       // Enhanced Pattern Search
@@ -1395,8 +1375,8 @@ export const mastra = new Mastra({
             patterns: z.array(z.string())
           })
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.performSmartSearch(context, projectPath);
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.performSmartSearch(inputData, projectPath);
         }
       }),
       validateCode: createTool({
@@ -1429,8 +1409,8 @@ export const mastra = new Mastra({
             validationsFailed: z.array(z.string())
           })
         }),
-        execute: async ({ context }) => {
-          const { projectPath: validationProjectPath, validationType, files } = context;
+        execute: async (inputData) => {
+          const { projectPath: validationProjectPath, validationType, files } = inputData;
           const targetPath = validationProjectPath || projectPath;
           return await _AgentBuilderDefaults.validateCode({
             projectPath: targetPath,
@@ -1469,8 +1449,8 @@ export const mastra = new Mastra({
           suggestions: z.array(z.string()).optional(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.webSearch(context);
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.webSearch(inputData);
         }
       }),
       // Task Completion Signaling
@@ -1499,8 +1479,8 @@ export const mastra = new Mastra({
           summary: z.string(),
           confidence: z.number().min(0).max(100)
         }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.signalCompletion(context);
+        execute: async (inputData) => {
+          return await _AgentBuilderDefaults.signalCompletion(inputData);
         }
       }),
       manageProject: createTool({
@@ -1525,8 +1505,8 @@ export const mastra = new Mastra({
           details: z.string().optional(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          const { action, features, packages } = context;
+        execute: async (inputData) => {
+          const { action, features, packages } = inputData;
           try {
             switch (action) {
               case "create":
@@ -1587,8 +1567,8 @@ export const mastra = new Mastra({
           stdout: z.array(z.string()).optional().describe("Server output lines captured during startup"),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
-          const { action, port } = context;
+        execute: async (inputData) => {
+          const { action, port } = inputData;
           try {
             switch (action) {
               case "start":
@@ -1673,8 +1653,8 @@ export const mastra = new Mastra({
           url: z.string(),
           method: z.string()
         }),
-        execute: async ({ context }) => {
-          const { method, url, baseUrl, headers, body, timeout } = context;
+        execute: async (inputData) => {
+          const { method, url, baseUrl, headers, body, timeout } = inputData;
           try {
             return await _AgentBuilderDefaults.makeHttpRequest({
               method,
@@ -1729,7 +1709,7 @@ export const mastra = new Mastra({
   /**
    * Get tools for a specific mode
    */
-  static async getToolsForMode(projectPath, mode = "code-editor") {
+  static async listToolsForMode(projectPath, mode = "code-editor") {
     const allTools = await _AgentBuilderDefaults.DEFAULT_TOOLS(projectPath);
     if (mode === "template") {
       return _AgentBuilderDefaults.filterToolsForTemplateBuilder(allTools);
@@ -1756,7 +1736,7 @@ export const mastra = new Mastra({
         error: stderr
       };
     } catch (error) {
-      console.log(error);
+      console.error(error);
       return {
         success: false,
         message: `Failed to create project: ${error instanceof Error ? error.message : String(error)}`
@@ -1771,7 +1751,7 @@ export const mastra = new Mastra({
     projectPath
   }) {
     try {
-      console.log("Installing packages:", JSON.stringify(packages, null, 2));
+      console.info("Installing packages:", JSON.stringify(packages, null, 2));
       const packageStrings = packages.map((p) => `${p.name}`);
       await spawnSWPM(projectPath || "", "add", packageStrings);
       return {
@@ -1795,7 +1775,7 @@ export const mastra = new Mastra({
     projectPath
   }) {
     try {
-      console.log("Upgrading specific packages:", JSON.stringify(packages, null, 2));
+      console.info("Upgrading specific packages:", JSON.stringify(packages, null, 2));
       let packageNames = [];
       if (packages && packages.length > 0) {
         packageNames = packages.map((p) => `${p.name}`);
@@ -3108,7 +3088,8 @@ var ToolSummaryProcessor = class extends MemoryProcessor {
   constructor({ summaryModel }) {
     super({ name: "ToolSummaryProcessor" });
     this.summaryAgent = new Agent({
-      name: "ToolSummaryAgent",
+      id: "tool-summary-agent",
+      name: "Tool Summary Agent",
       description: "A summary agent that summarizes tool calls and results",
       instructions: "You are a summary agent that summarizes tool calls and results",
       model: summaryModel
@@ -3212,7 +3193,7 @@ ${config.instructions}` : "";
       model: config.model,
       tools: async () => {
         return {
-          ...await AgentBuilderDefaults.getToolsForMode(config.projectPath, config.mode),
+          ...await AgentBuilderDefaults.listToolsForMode(config.projectPath, config.mode),
           ...config.tools || {}
         };
       },
@@ -3234,9 +3215,9 @@ ${config.instructions}` : "";
    * Enhanced generate method with AgentBuilder-specific configuration
    * Overrides the base Agent generate method to provide additional project context
    */
-  generate = async (messages, generateOptions = {}) => {
+  generateLegacy = async (messages, generateOptions = {}) => {
     const { maxSteps, ...baseOptions } = generateOptions;
-    const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
+    const originalInstructions = await this.getInstructions({ requestContext: generateOptions?.requestContext });
     const additionalInstructions = baseOptions.instructions;
     let enhancedInstructions = originalInstructions;
     if (additionalInstructions) {
@@ -3257,15 +3238,15 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting generation with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.generate(messages, enhancedOptions);
+    return super.generateLegacy(messages, enhancedOptions);
   };
   /**
    * Enhanced stream method with AgentBuilder-specific configuration
    * Overrides the base Agent stream method to provide additional project context
    */
-  stream = async (messages, streamOptions = {}) => {
+  streamLegacy = async (messages, streamOptions = {}) => {
     const { maxSteps, ...baseOptions } = streamOptions;
-    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
+    const originalInstructions = await this.getInstructions({ requestContext: streamOptions?.requestContext });
     const additionalInstructions = baseOptions.instructions;
     let enhancedInstructions = originalInstructions;
     if (additionalInstructions) {
@@ -3286,15 +3267,15 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.stream(messages, enhancedOptions);
+    return super.streamLegacy(messages, enhancedOptions);
   };
   /**
    * Enhanced stream method with AgentBuilder-specific configuration
    * Overrides the base Agent stream method to provide additional project context
    */
-  async streamVNext(messages, streamOptions) {
+  async stream(messages, streamOptions) {
     const { ...baseOptions } = streamOptions || {};
-    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
+    const originalInstructions = await this.getInstructions({ requestContext: streamOptions?.requestContext });
     const additionalInstructions = baseOptions.instructions;
     let enhancedInstructions = originalInstructions;
     if (additionalInstructions) {
@@ -3314,11 +3295,11 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.streamVNext(messages, enhancedOptions);
+    return super.stream(messages, enhancedOptions);
   }
-  async generateVNext(messages, options) {
+  async generate(messages, options) {
     const { ...baseOptions } = options || {};
-    const originalInstructions = await this.getInstructions({ runtimeContext: options?.runtimeContext });
+    const originalInstructions = await this.getInstructions({ requestContext: options?.requestContext });
     const additionalInstructions = baseOptions.instructions;
     let enhancedInstructions = originalInstructions;
     if (additionalInstructions) {
@@ -3338,7 +3319,7 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.generateVNext(messages, enhancedOptions);
+    return super.generate(messages, enhancedOptions);
   }
 };
 var cloneTemplateStep = createStep({
@@ -3388,13 +3369,13 @@ var analyzePackageStep = createStep({
   inputSchema: CloneTemplateResultSchema,
   outputSchema: PackageAnalysisSchema,
   execute: async ({ inputData }) => {
-    console.log("Analyzing template package.json...");
+    console.info("Analyzing template package.json...");
     const { templateDir } = inputData;
     const packageJsonPath = join(templateDir, "package.json");
     try {
       const packageJsonContent = await readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
-      console.log("Template package.json:", JSON.stringify(packageJson, null, 2));
+      console.info("Template package.json:", JSON.stringify(packageJson, null, 2));
       return {
         dependencies: packageJson.dependencies || {},
         devDependencies: packageJson.devDependencies || {},
@@ -3426,14 +3407,15 @@ var discoverUnitsStep = createStep({
   description: "Discover template units by analyzing the templates directory structure",
   inputSchema: CloneTemplateResultSchema,
   outputSchema: DiscoveryResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  execute: async ({ inputData, requestContext }) => {
     const { templateDir } = inputData;
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    const targetPath = resolveTargetPath(inputData, requestContext);
     const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
-    console.log("targetPath", targetPath);
-    const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
+    console.info("targetPath", targetPath);
+    const model = await resolveModel({ requestContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
     try {
       const agent = new Agent({
+        id: "mastra-project-discoverer",
         model,
         instructions: `You are an expert at analyzing Mastra projects.
 
@@ -3491,10 +3473,12 @@ Return the actual exported names of the units, as well as the file names.`,
         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,
+      const result = isV2 ? await tryGenerateWithJsonFallback(agent, prompt, {
+        structuredOutput: {
+          schema: output
+        },
         maxSteps: 100
-      }) : await agent.generate(prompt, {
+      }) : await agent.generateLegacy(prompt, {
         experimental_output: output,
         maxSteps: 100
       });
@@ -3518,7 +3502,7 @@ Return the actual exported names of the units, as well as the file names.`,
       template.other?.forEach((otherId) => {
         units.push({ kind: "other", id: otherId.name, file: otherId.file });
       });
-      console.log("Discovered units:", JSON.stringify(units, null, 2));
+      console.info("Discovered units:", JSON.stringify(units, null, 2));
       if (units.length === 0) {
         throw new Error(`No Mastra units (agents, workflows, tools) found in template.
           Possible causes:
@@ -3568,8 +3552,8 @@ var prepareBranchStep = createStep({
   description: "Create or switch to integration branch before modifications",
   inputSchema: PrepareBranchInputSchema,
   outputSchema: PrepareBranchResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+  execute: async ({ inputData, requestContext }) => {
+    const targetPath = resolveTargetPath(inputData, requestContext);
     try {
       const branchName = `feat/install-template-${inputData.slug}`;
       await gitCheckoutBranch(branchName, targetPath);
@@ -3593,10 +3577,10 @@ var packageMergeStep = createStep({
   description: "Merge template package.json dependencies into target project",
   inputSchema: PackageMergeInputSchema,
   outputSchema: PackageMergeResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Package merge step starting...");
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Package merge step starting...");
     const { slug, packageInfo } = inputData;
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    const targetPath = resolveTargetPath(inputData, requestContext);
     try {
       const targetPkgPath = join(targetPath, "package.json");
       let targetPkgRaw = "{}";
@@ -3670,9 +3654,9 @@ var installStep = createStep({
   description: "Install packages based on merged package.json",
   inputSchema: InstallInputSchema,
   outputSchema: InstallResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Running install step...");
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Running install step...");
+    const targetPath = resolveTargetPath(inputData, requestContext);
     try {
       await spawnSWPM(targetPath, "install", []);
       const lock = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"].map((f) => join(targetPath, f)).find((f) => existsSync(f));
@@ -3698,10 +3682,10 @@ var programmaticFileCopyStep = createStep({
   description: "Programmatically copy template files to target project based on ordered units",
   inputSchema: FileCopyInputSchema,
   outputSchema: FileCopyResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Programmatic file copy step starting...");
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Programmatic file copy step starting...");
     const { orderedUnits, templateDir, commitSha, slug } = inputData;
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    const targetPath = resolveTargetPath(inputData, requestContext);
     try {
       const copiedFiles = [];
       const conflicts = [];
@@ -3742,7 +3726,7 @@ var programmaticFileCopyStep = createStep({
         }
       };
       for (const unit of orderedUnits) {
-        console.log(`Processing ${unit.kind} unit "${unit.id}" from file "${unit.file}"`);
+        console.info(`Processing ${unit.kind} unit "${unit.id}" from file "${unit.file}"`);
         let sourceFile;
         let resolvedUnitFile;
         if (unit.file.includes("/")) {
@@ -3773,7 +3757,7 @@ var programmaticFileCopyStep = createStep({
         }
         const targetDir = dirname(resolvedUnitFile);
         const namingConvention = await analyzeNamingConvention(targetDir);
-        console.log(`Detected naming convention in ${targetDir}: ${namingConvention}`);
+        console.info(`Detected naming convention in ${targetDir}: ${namingConvention}`);
         const hasExtension = extname(unit.id) !== "";
         const baseId = hasExtension ? basename(unit.id, extname(unit.id)) : unit.id;
         const fileExtension = extname(unit.file);
@@ -3781,7 +3765,7 @@ var programmaticFileCopyStep = createStep({
         const targetFile = resolve(targetPath, targetDir, convertedFileName);
         if (existsSync(targetFile)) {
           const strategy = determineConflictStrategy(unit, targetFile);
-          console.log(`File exists: ${convertedFileName}, using strategy: ${strategy}`);
+          console.info(`File exists: ${convertedFileName}, using strategy: ${strategy}`);
           switch (strategy) {
             case "skip":
               conflicts.push({
@@ -3790,7 +3774,7 @@ var programmaticFileCopyStep = createStep({
                 sourceFile: unit.file,
                 targetFile: `${targetDir}/${convertedFileName}`
               });
-              console.log(`\u23ED\uFE0F Skipped ${unit.kind} "${unit.id}": file already exists`);
+              console.info(`\u23ED\uFE0F Skipped ${unit.kind} "${unit.id}": file already exists`);
               continue;
             case "backup-and-replace":
               try {
@@ -3800,7 +3784,7 @@ var programmaticFileCopyStep = createStep({
                   destination: targetFile,
                   unit: { kind: unit.kind, id: unit.id }
                 });
-                console.log(
+                console.info(
                   `\u{1F504} Replaced ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${convertedFileName} (backup created)`
                 );
                 continue;
@@ -3821,7 +3805,7 @@ var programmaticFileCopyStep = createStep({
                   destination: uniqueTargetFile,
                   unit: { kind: unit.kind, id: unit.id }
                 });
-                console.log(`\u{1F4DD} Renamed ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${basename(uniqueTargetFile)}`);
+                console.info(`\u{1F4DD} Renamed ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${basename(uniqueTargetFile)}`);
                 continue;
               } catch (renameError) {
                 conflicts.push({
@@ -3850,7 +3834,7 @@ var programmaticFileCopyStep = createStep({
             destination: targetFile,
             unit: { kind: unit.kind, id: unit.id }
           });
-          console.log(`\u2713 Copied ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${convertedFileName}`);
+          console.info(`\u2713 Copied ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${convertedFileName}`);
         } catch (copyError) {
           conflicts.push({
             unit: { kind: unit.kind, id: unit.id },
@@ -3871,7 +3855,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetTsconfig,
               unit: { kind: "other", id: "tsconfig.json" }
             });
-            console.log("\u2713 Copied tsconfig.json from template to target");
+            console.info("\u2713 Copied tsconfig.json from template to target");
           } else {
             const minimalTsconfig = {
               compilerOptions: {
@@ -3893,7 +3877,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetTsconfig,
               unit: { kind: "other", id: "tsconfig.json" }
             });
-            console.log("\u2713 Generated minimal tsconfig.json in target");
+            console.info("\u2713 Generated minimal tsconfig.json in target");
           }
         }
       } catch (e) {
@@ -3918,7 +3902,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetMastraIndex,
               unit: { kind: "other", id: "mastra-index" }
             });
-            console.log("\u2713 Copied Mastra index file from template");
+            console.info("\u2713 Copied Mastra index file from template");
           }
         }
       } catch (e) {
@@ -3942,7 +3926,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetGitignore,
               unit: { kind: "other", id: "gitignore" }
             });
-            console.log("\u2713 Copied .gitignore from template to target");
+            console.info("\u2713 Copied .gitignore from template to target");
           } else {
             const targetContent = await readFile(targetGitignore, "utf-8");
             const templateContent = await readFile(templateGitignore, "utf-8");
@@ -3955,9 +3939,9 @@ var programmaticFileCopyStep = createStep({
                 destination: targetGitignore,
                 unit: { kind: "other", id: "gitignore-merge" }
               });
-              console.log(`\u2713 Merged template .gitignore entries into existing .gitignore (${addedLines} new entries)`);
+              console.info(`\u2713 Merged template .gitignore entries into existing .gitignore (${addedLines} new entries)`);
             } else {
-              console.log("\u2139 No new .gitignore entries to add from template");
+              console.info("\u2139 No new .gitignore entries to add from template");
             }
           }
         }
@@ -3985,7 +3969,7 @@ var programmaticFileCopyStep = createStep({
               destination: targetEnv,
               unit: { kind: "other", id: "env" }
             });
-            console.log(`\u2713 Created .env file with ${Object.keys(variables).length} template variables`);
+            console.info(`\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);
@@ -3997,9 +3981,9 @@ var programmaticFileCopyStep = createStep({
                 destination: targetEnv,
                 unit: { kind: "other", id: "env-merge" }
               });
-              console.log(`\u2713 Merged new environment variables into existing .env file (${addedLines} new entries)`);
+              console.info(`\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)");
+              console.info("\u2139 No new environment variables to add (all already exist in .env)");
             }
           }
         }
@@ -4020,13 +4004,13 @@ var programmaticFileCopyStep = createStep({
             fileList,
             { skipIfNoStaged: true }
           );
-          console.log(`\u2713 Committed ${copiedFiles.length} copied files`);
+          console.info(`\u2713 Committed ${copiedFiles.length} copied files`);
         } catch (commitError) {
           console.warn("Failed to commit copied files:", commitError);
         }
       }
       const message = `Programmatic file copy completed. Copied ${copiedFiles.length} files, ${conflicts.length} conflicts detected.`;
-      console.log(message);
+      console.info(message);
       return {
         success: true,
         copiedFiles,
@@ -4050,12 +4034,12 @@ var intelligentMergeStep = createStep({
   description: "Use AgentBuilder to intelligently merge template files",
   inputSchema: IntelligentMergeInputSchema,
   outputSchema: IntelligentMergeResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Intelligent merge step starting...");
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Intelligent merge step starting...");
     const { conflicts, copiedFiles, commitSha, slug, templateDir, branchName } = inputData;
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    const targetPath = resolveTargetPath(inputData, requestContext);
     try {
-      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
+      const model = await resolveModel({ requestContext, 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).",
@@ -4068,9 +4052,9 @@ var intelligentMergeStep = createStep({
           message: z.string(),
           error: z.string().optional()
         }),
-        execute: async ({ context }) => {
+        execute: async (input) => {
           try {
-            const { sourcePath, destinationPath } = context;
+            const { sourcePath, destinationPath } = input;
             const resolvedSourcePath = resolve(templateDir, sourcePath);
             const resolvedDestinationPath = resolve(targetPath, destinationPath);
             if (existsSync(resolvedSourcePath) && !existsSync(dirname(resolvedDestinationPath))) {
@@ -4178,8 +4162,8 @@ Template information:
       const registrableFiles = copiedFiles.filter((f) => registrableKinds.has(f.unit.kind));
       const targetMastraIndex = resolve(targetPath, "src/mastra/index.ts");
       const mastraIndexExists = existsSync(targetMastraIndex);
-      console.log(`Mastra index exists: ${mastraIndexExists} at ${targetMastraIndex}`);
-      console.log(
+      console.info(`Mastra index exists: ${mastraIndexExists} at ${targetMastraIndex}`);
+      console.info(
         "Registrable components:",
         registrableFiles.map((f) => `${f.unit.kind}:${f.unit.id}`)
       );
@@ -4193,7 +4177,7 @@ Template information:
           notes: `Components to register: ${registrableFiles.map((f) => `${f.unit.kind}:${f.unit.id}`).join(", ")}`
         });
       }
-      console.log(`Creating task list with ${tasks.length} tasks...`);
+      console.info(`Creating task list with ${tasks.length} tasks...`);
       await AgentBuilderDefaults.manageTaskList({ action: "create", tasks });
       await logGitState(targetPath, "before intelligent merge");
       const prompt = `
@@ -4240,17 +4224,17 @@ For each task:
 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 result = isV2 ? await agentBuilder.stream(prompt) : await agentBuilder.streamLegacy(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({
+          console.info({
             type: chunk.type,
             msgId: chunkData.messageId
           });
         } else {
-          console.log(JSON.stringify(chunk, null, 2));
+          console.info(JSON.stringify(chunk, null, 2));
           if (chunk.type === "tool-result") {
             const chunkData = "payload" in chunk ? chunk.payload : chunk;
             if (chunkData.toolName === "manageTaskList") {
@@ -4264,7 +4248,7 @@ Start by listing your tasks and work through them systematically!
                     content: toolResult.content || "",
                     notes: toolResult.notes
                   });
-                  console.log(`\u{1F4CB} Task completed: ${toolResult.taskId} - ${toolResult.content}`);
+                  console.info(`\u{1F4CB} Task completed: ${toolResult.taskId} - ${toolResult.content}`);
                 }
               } catch (parseError) {
                 console.warn("Failed to parse task management result:", parseError);
@@ -4318,13 +4302,13 @@ var validationAndFixStep = createStep({
   description: "Validate the merged template code and fix any issues using a specialized agent",
   inputSchema: ValidationFixInputSchema,
   outputSchema: ValidationFixResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Validation and fix step starting...");
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Validation and fix step starting...");
     const { commitSha, slug, orderedUnits, templateDir, copiedFiles, conflictsResolved, maxIterations = 5 } = inputData;
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    const targetPath = resolveTargetPath(inputData, requestContext);
     const hasChanges = copiedFiles.length > 0 || conflictsResolved && conflictsResolved.length > 0;
     if (!hasChanges) {
-      console.log("\u23ED\uFE0F Skipping validation - no files copied or conflicts resolved");
+      console.info("\u23ED\uFE0F Skipping validation - no files copied or conflicts resolved");
       return {
         success: true,
         applied: false,
@@ -4336,15 +4320,16 @@ var validationAndFixStep = createStep({
         }
       };
     }
-    console.log(
+    console.info(
       `\u{1F4CB} Changes detected: ${copiedFiles.length} files copied, ${conflictsResolved?.length || 0} conflicts resolved`
     );
     let currentIteration = 1;
     try {
-      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
-      const allTools = await AgentBuilderDefaults.getToolsForMode(targetPath, "template");
+      const model = await resolveModel({ requestContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
+      const allTools = await AgentBuilderDefaults.listToolsForMode(targetPath, "template");
       const validationAgent = new Agent({
-        name: "code-validator-fixer",
+        id: "code-validator-fixer",
+        name: "Code Validator Fixer",
         description: "Specialized agent for validating and fixing template integration issues",
         instructions: `You are a code validation and fixing specialist. Your job is to:
 
@@ -4462,7 +4447,7 @@ Be thorough and methodical. Always use listDirectory to verify actual file exist
           executeCommand: allTools.executeCommand
         }
       });
-      console.log("Starting validation and fix agent with internal loop...");
+      console.info("Starting validation and fix agent with internal loop...");
       let validationResults = {
         valid: false,
         errorsFixed: 0,
@@ -4473,7 +4458,7 @@ Be thorough and methodical. Always use listDirectory to verify actual file exist
         // Store the actual error details
       };
       while (validationResults.remainingErrors > 0 && currentIteration <= maxIterations) {
-        console.log(`
+        console.info(`
 === Validation Iteration ${currentIteration} ===`);
         const iterationPrompt = currentIteration === 1 ? `Please validate the template integration and fix any errors found in the project at ${targetPath}. The template "${slug}" (${commitSha.substring(0, 7)}) was just integrated and may have validation issues that need fixing.
 
@@ -4482,9 +4467,11 @@ Start by running validateCode with all validation types to get a complete pictur
 Previous iterations may have fixed some issues, so start by re-running validateCode to see the current state, then fix any remaining issues.`;
         const isV2 = model.specificationVersion === "v2";
         const output = z.object({ success: z.boolean() });
-        const result = isV2 ? await validationAgent.streamVNext(iterationPrompt, {
-          output
-        }) : await validationAgent.stream(iterationPrompt, {
+        const result = isV2 ? await tryStreamWithJsonFallback(validationAgent, iterationPrompt, {
+          structuredOutput: {
+            schema: output
+          }
+        }) : await validationAgent.streamLegacy(iterationPrompt, {
           experimental_output: output
         });
         let iterationErrors = 0;
@@ -4493,13 +4480,13 @@ Previous iterations may have fixed some issues, so start by re-running validateC
         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({
+            console.info({
               type: chunk.type,
               msgId: chunkData.messageId,
               iteration: currentIteration
             });
           } else {
-            console.log(JSON.stringify(chunk, null, 2));
+            console.info(JSON.stringify(chunk, null, 2));
           }
           if (chunk.type === "tool-result") {
             const chunkData = "payload" in chunk ? chunk.payload : chunk;
@@ -4508,7 +4495,7 @@ Previous iterations may have fixed some issues, so start by re-running validateC
               lastValidationResult = toolResult;
               if (toolResult?.summary) {
                 iterationErrors = toolResult.summary.totalErrors || 0;
-                console.log(`Iteration ${currentIteration}: Found ${iterationErrors} errors`);
+                console.info(`Iteration ${currentIteration}: Found ${iterationErrors} errors`);
               }
             }
           }
@@ -4520,12 +4507,12 @@ Previous iterations may have fixed some issues, so start by re-running validateC
         if (iterationErrors > 0 && lastValidationResult?.errors) {
           validationResults.lastValidationErrors = lastValidationResult.errors;
         }
-        console.log(`Iteration ${currentIteration} complete: ${iterationErrors} errors remaining`);
+        console.info(`Iteration ${currentIteration} complete: ${iterationErrors} errors remaining`);
         if (iterationErrors === 0) {
-          console.log(`\u2705 All validation issues resolved in ${currentIteration} iterations!`);
+          console.info(`\u2705 All validation issues resolved in ${currentIteration} iterations!`);
           break;
         } else if (currentIteration >= maxIterations) {
-          console.log(`\u26A0\uFE0F  Max iterations (${maxIterations}) reached. ${iterationErrors} errors still remaining.`);
+          console.info(`\u26A0\uFE0F  Max iterations (${maxIterations}) reached. ${iterationErrors} errors still remaining.`);
           break;
         }
         currentIteration++;
@@ -4570,7 +4557,7 @@ Previous iterations may have fixed some issues, so start by re-running validateC
     } finally {
       try {
         await rm(templateDir, { recursive: true, force: true });
-        console.log(`\u2713 Cleaned up template directory: ${templateDir}`);
+        console.info(`\u2713 Cleaned up template directory: ${templateDir}`);
       } catch (cleanupError) {
         console.warn("Failed to cleanup template directory:", cleanupError);
       }
@@ -4745,7 +4732,7 @@ var agentBuilderTemplateWorkflow = createWorkflow({
 }).commit();
 async function mergeTemplateBySlug(slug, targetPath) {
   const template = await getMastraTemplate(slug);
-  const run = await agentBuilderTemplateWorkflow.createRunAsync();
+  const run = await agentBuilderTemplateWorkflow.createRun();
   return await run.start({
     inputData: {
       repo: template.githubUrl,
@@ -5052,7 +5039,7 @@ var planningIterationStep = createStep({
   outputSchema: PlanningIterationResultSchema,
   suspendSchema: PlanningIterationSuspendSchema,
   resumeSchema: PlanningIterationResumeSchema,
-  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+  execute: async ({ inputData, resumeData, suspend, requestContext }) => {
     const {
       action,
       workflowName,
@@ -5063,12 +5050,10 @@ var planningIterationStep = createStep({
       research,
       userAnswers
     } = inputData;
-    console.log("Starting planning iteration...");
+    console.info("Starting planning iteration...");
     const qaKey = "workflow-builder-qa";
-    let storedQAPairs = runtimeContext.get(qaKey) || [];
+    let storedQAPairs = requestContext.get(qaKey) || [];
     const newAnswers = { ...userAnswers || {}, ...resumeData?.answers || {} };
-    console.log("before", storedQAPairs);
-    console.log("newAnswers", newAnswers);
     if (Object.keys(newAnswers).length > 0) {
       storedQAPairs = storedQAPairs.map((pair) => {
         if (newAnswers[pair.question.id]) {
@@ -5080,14 +5065,10 @@ var planningIterationStep = createStep({
         }
         return pair;
       });
-      runtimeContext.set(qaKey, storedQAPairs);
+      requestContext.set(qaKey, storedQAPairs);
     }
-    console.log("after", storedQAPairs);
-    console.log(
-      `Current Q&A state: ${storedQAPairs.length} question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
-    );
     try {
-      const model = await resolveModel({ runtimeContext });
+      const model = await resolveModel({ requestContext });
       const planningAgent = new Agent({
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
@@ -5117,8 +5098,10 @@ var planningIterationStep = createStep({
         projectStructure,
         research
       });
-      const result = await planningAgent.generateVNext(planningPrompt, {
-        output: PlanningAgentOutputSchema
+      const result = await planningAgent.generate(planningPrompt, {
+        structuredOutput: {
+          schema: PlanningAgentOutputSchema
+        }
         // maxSteps: 15,
       });
       const planResult = await result.object;
@@ -5133,8 +5116,8 @@ var planningIterationStep = createStep({
         };
       }
       if (planResult.questions && planResult.questions.length > 0 && !planResult.planComplete) {
-        console.log(`Planning needs user clarification: ${planResult.questions.length} questions`);
-        console.log(planResult.questions);
+        console.info(`Planning needs user clarification: ${planResult.questions.length} questions`);
+        console.info(planResult.questions);
         const newQAPairs = planResult.questions.map((question) => ({
           question,
           answer: null,
@@ -5142,8 +5125,8 @@ var planningIterationStep = createStep({
           answeredAt: null
         }));
         storedQAPairs = [...storedQAPairs, ...newQAPairs];
-        runtimeContext.set(qaKey, storedQAPairs);
-        console.log(
+        requestContext.set(qaKey, storedQAPairs);
+        console.info(
           `Updated Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
         );
         return suspend({
@@ -5155,9 +5138,9 @@ var planningIterationStep = createStep({
           }
         });
       }
-      console.log(`Planning complete with ${planResult.tasks.length} tasks`);
-      runtimeContext.set(qaKey, storedQAPairs);
-      console.log(
+      console.info(`Planning complete with ${planResult.tasks.length} tasks`);
+      requestContext.set(qaKey, storedQAPairs);
+      console.info(
         `Final Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
       );
       return {
@@ -5200,7 +5183,7 @@ var taskApprovalStep = createStep({
   execute: async ({ inputData, resumeData, suspend }) => {
     const { tasks } = inputData;
     if (!resumeData?.approved && resumeData?.approved !== false) {
-      console.log(`Requesting user approval for ${tasks.length} tasks`);
+      console.info(`Requesting user approval for ${tasks.length} tasks`);
       const summary = `Task List for Approval:
 
 ${tasks.length} tasks planned:
@@ -5213,14 +5196,14 @@ ${tasks.map((task, i) => `${i + 1}. [${task.priority.toUpperCase()}] ${task.cont
       });
     }
     if (resumeData.approved) {
-      console.log("Task list approved by user");
+      console.info("Task list approved by user");
       return {
         approved: true,
         tasks,
         message: "Task list approved, ready for execution"
       };
     } else {
-      console.log("Task list rejected by user");
+      console.info("Task list rejected by user");
       return {
         approved: false,
         tasks,
@@ -5237,7 +5220,7 @@ var planningAndApprovalWorkflow = createWorkflow({
   outputSchema: TaskApprovalOutputSchema,
   steps: [planningIterationStep, taskApprovalStep]
 }).dountil(planningIterationStep, async ({ inputData }) => {
-  console.log(`Sub-workflow planning check: planComplete=${inputData.planComplete}`);
+  console.info(`Sub-workflow planning check: planComplete=${inputData.planComplete}`);
   return inputData.planComplete === true;
 }).map(async ({ inputData }) => {
   return {
@@ -5301,7 +5284,7 @@ const myStep = createStep({
 - \`mastra\`: Access to Mastra instance (agents, tools, other workflows)
 - \`getStepResult(stepInstance)\`: Get results from previous steps
 - \`getInitData()\`: Access original workflow input data
-- \`runtimeContext\`: Runtime dependency injection context
+- \`requestContext\`: Runtime dependency injection context
 - \`runCount\`: Number of times this step has run (useful for retries)
 
 ### **\u{1F504} CONTROL FLOW METHODS**
@@ -5380,10 +5363,10 @@ const toolStep = createStep(myTool);
 
 // Method 2: Call tool in execute function
 const step = createStep({
-  execute: async ({ inputData, runtimeContext }) => {
+  execute: async ({ inputData, requestContext }) => {
     const result = await myTool.execute({
       context: inputData,
-      runtimeContext
+      requestContext
     });
     return result;
   }
@@ -5475,7 +5458,7 @@ export const mastra = new Mastra({
 **Running Workflows:**
 \`\`\`typescript
 // Create and start run
-const run = await workflow.createRunAsync();
+const run = await workflow.createRun();
 const result = await run.start({ inputData: {...} });
 
 // Stream execution for real-time monitoring
@@ -5499,7 +5482,7 @@ run.watch((event) => console.log(event));
 - Use workflows as steps: \`.then(otherWorkflow)\`
 - Enable complex workflow composition
 
-**Runtime Context:**
+**Request Context:**
 - Pass shared data across all steps
 - Enable dependency injection patterns
 
@@ -5672,11 +5655,11 @@ var restrictedTaskManager = createTool({
     ),
     message: z.string()
   }),
-  execute: async ({ context }) => {
+  execute: async (input) => {
     const adaptedContext = {
-      ...context,
-      action: context.action,
-      tasks: context.tasks?.map((task) => ({
+      ...input,
+      action: input.action,
+      tasks: input.tasks?.map((task) => ({
         ...task,
         priority: task.priority || "medium"
       }))
@@ -5691,13 +5674,13 @@ var workflowDiscoveryStep = createStep({
   description: "Discover existing workflows in the project",
   inputSchema: WorkflowBuilderInputSchema,
   outputSchema: WorkflowDiscoveryResultSchema,
-  execute: async ({ inputData, runtimeContext: _runtimeContext }) => {
-    console.log("Starting workflow discovery...");
+  execute: async ({ inputData, requestContext: _requestContext }) => {
+    console.info("Starting workflow discovery...");
     const { projectPath = process.cwd() } = inputData;
     try {
       const workflowsPath = join(projectPath, "src/mastra/workflows");
       if (!existsSync(workflowsPath)) {
-        console.log("No workflows directory found");
+        console.info("No workflows directory found");
         return {
           success: true,
           workflows: [],
@@ -5726,7 +5709,7 @@ var workflowDiscoveryStep = createStep({
           }
         }
       }
-      console.log(`Discovered ${workflows.length} existing workflows`);
+      console.info(`Discovered ${workflows.length} existing workflows`);
       return {
         success: true,
         workflows,
@@ -5750,8 +5733,8 @@ var projectDiscoveryStep = createStep({
   description: "Analyze the project structure and setup",
   inputSchema: WorkflowDiscoveryResultSchema,
   outputSchema: ProjectDiscoveryResultSchema,
-  execute: async ({ inputData: _inputData, runtimeContext: _runtimeContext }) => {
-    console.log("Starting project discovery...");
+  execute: async ({ inputData: _inputData, requestContext: _requestContext }) => {
+    console.info("Starting project discovery...");
     try {
       const projectPath = process.cwd();
       const projectStructure = {
@@ -5772,7 +5755,7 @@ var projectDiscoveryStep = createStep({
           console.warn("Failed to read package.json:", error);
         }
       }
-      console.log("Project discovery completed");
+      console.info("Project discovery completed");
       return {
         success: true,
         structure: {
@@ -5812,10 +5795,10 @@ var workflowResearchStep = createStep({
   description: "Research Mastra workflows and gather relevant documentation",
   inputSchema: ProjectDiscoveryResultSchema,
   outputSchema: WorkflowResearchResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Starting workflow research...");
+  execute: async ({ inputData, requestContext }) => {
+    console.info("Starting workflow research...");
     try {
-      const model = await resolveModel({ runtimeContext });
+      const model = await resolveModel({ requestContext });
       const researchAgent = new Agent({
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
@@ -5827,8 +5810,10 @@ var workflowResearchStep = createStep({
         dependencies: inputData.dependencies,
         hasWorkflowsDir: inputData.structure.hasWorkflowsDir
       });
-      const result = await researchAgent.generateVNext(researchPrompt, {
-        output: WorkflowResearchResultSchema
+      const result = await researchAgent.generate(researchPrompt, {
+        structuredOutput: {
+          schema: WorkflowResearchResultSchema
+        }
         // stopWhen: stepCountIs(10),
       });
       const researchResult = await result.object;
@@ -5845,7 +5830,7 @@ var workflowResearchStep = createStep({
           error: "Research agent failed to generate valid response"
         };
       }
-      console.log("Research completed successfully");
+      console.info("Research completed successfully");
       return {
         success: true,
         documentation: {
@@ -5879,7 +5864,7 @@ var taskExecutionStep = createStep({
   outputSchema: TaskExecutionResultSchema,
   suspendSchema: TaskExecutionSuspendSchema,
   resumeSchema: TaskExecutionResumeSchema,
-  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+  execute: async ({ inputData, resumeData, suspend, requestContext }) => {
     const {
       action,
       workflowName,
@@ -5891,12 +5876,12 @@ var taskExecutionStep = createStep({
       research,
       projectPath
     } = inputData;
-    console.log(`Starting task execution for ${action}ing workflow: ${workflowName}`);
-    console.log(`Executing ${tasks.length} tasks using AgentBuilder stream...`);
+    console.info(`Starting task execution for ${action}ing workflow: ${workflowName}`);
+    console.info(`Executing ${tasks.length} tasks using AgentBuilder stream...`);
     try {
-      const model = await resolveModel({ runtimeContext });
+      const model = await resolveModel({ requestContext });
       const currentProjectPath = projectPath || process.cwd();
-      console.log("Pre-populating taskManager with planned tasks...");
+      console.info("Pre-populating taskManager with planned tasks...");
       const taskManagerContext = {
         action: "create",
         tasks: tasks.map((task) => ({
@@ -5909,7 +5894,7 @@ var taskExecutionStep = createStep({
         }))
       };
       const taskManagerResult = await AgentBuilderDefaults.manageTaskList(taskManagerContext);
-      console.log(`Task manager initialized with ${taskManagerResult.tasks.length} tasks`);
+      console.info(`Task manager initialized with ${taskManagerResult.tasks.length} tasks`);
       if (!taskManagerResult.success) {
         throw new Error(`Failed to initialize task manager: ${taskManagerResult.message}`);
       }
@@ -5939,18 +5924,11 @@ ${workflowBuilderPrompts.validation.instructions}`
         tasks,
         resumeData
       });
-      const originalInstructions = await executionAgent.getInstructions({ runtimeContext });
-      const additionalInstructions = executionAgent.instructions;
-      let enhancedInstructions = originalInstructions;
-      if (additionalInstructions) {
-        enhancedInstructions = `${originalInstructions}
-
-${additionalInstructions}`;
-      }
+      const originalInstructions = await executionAgent.getInstructions({ requestContext });
       const enhancedOptions = {
         stopWhen: stepCountIs(100),
         temperature: 0.3,
-        instructions: enhancedInstructions
+        instructions: originalInstructions
       };
       let finalResult = null;
       let allTasksCompleted = false;
@@ -5962,13 +5940,13 @@ ${additionalInstructions}`;
         const currentTaskStatus = await AgentBuilderDefaults.manageTaskList({ action: "list" });
         const completedTasks = currentTaskStatus.tasks.filter((task) => task.status === "completed");
         const pendingTasks = currentTaskStatus.tasks.filter((task) => task.status !== "completed");
-        console.log(`
+        console.info(`
 === EXECUTION ITERATION ${iterationCount} ===`);
-        console.log(`Completed tasks: ${completedTasks.length}/${expectedTaskIds.length}`);
-        console.log(`Remaining tasks: ${pendingTasks.map((t) => t.id).join(", ")}`);
+        console.info(`Completed tasks: ${completedTasks.length}/${expectedTaskIds.length}`);
+        console.info(`Remaining tasks: ${pendingTasks.map((t) => t.id).join(", ")}`);
         allTasksCompleted = pendingTasks.length === 0;
         if (allTasksCompleted) {
-          console.log("All tasks completed! Breaking execution loop.");
+          console.info("All tasks completed! Breaking execution loop.");
           break;
         }
         const iterationPrompt = iterationCount === 1 ? executionPrompt : `${workflowBuilderPrompts.executionAgent.iterationPrompt({
@@ -5979,7 +5957,7 @@ ${additionalInstructions}`;
         })}
 
 ${workflowBuilderPrompts.validation.instructions}`;
-        const stream = await executionAgent.streamVNext(iterationPrompt, {
+        const stream = await executionAgent.stream(iterationPrompt, {
           structuredOutput: {
             schema: TaskExecutionIterationInputSchema(tasks.length),
             model
@@ -5992,19 +5970,19 @@ ${workflowBuilderPrompts.validation.instructions}`;
             finalMessage += chunk.payload.text;
           }
           if (chunk.type === "step-finish") {
-            console.log(finalMessage);
+            console.info(finalMessage);
             finalMessage = "";
           }
           if (chunk.type === "tool-result") {
-            console.log(JSON.stringify(chunk, null, 2));
+            console.info(JSON.stringify(chunk, null, 2));
           }
           if (chunk.type === "finish") {
-            console.log(chunk);
+            console.info(chunk);
           }
         }
         await stream.consumeStream();
         finalResult = await stream.object;
-        console.log(`Iteration ${iterationCount} result:`, { finalResult });
+        console.info(`Iteration ${iterationCount} result:`, { finalResult });
         if (!finalResult) {
           throw new Error(`No result received from agent execution on iteration ${iterationCount}`);
         }
@@ -6012,17 +5990,17 @@ ${workflowBuilderPrompts.validation.instructions}`;
         const postCompletedTasks = postIterationTaskStatus.tasks.filter((task) => task.status === "completed");
         const postPendingTasks = postIterationTaskStatus.tasks.filter((task) => task.status !== "completed");
         allTasksCompleted = postPendingTasks.length === 0;
-        console.log(
+        console.info(
           `After iteration ${iterationCount}: ${postCompletedTasks.length}/${expectedTaskIds.length} tasks completed in taskManager`
         );
         if (finalResult.status === "needs_clarification" && finalResult.questions && finalResult.questions.length > 0) {
-          console.log(
+          console.info(
             `Agent needs clarification on iteration ${iterationCount}: ${finalResult.questions.length} questions`
           );
           break;
         }
         if (finalResult.status === "completed" && !allTasksCompleted) {
-          console.log(
+          console.info(
             `Agent claimed completion but taskManager shows pending tasks: ${postPendingTasks.map((t) => t.id).join(", ")}`
           );
         }
@@ -6035,8 +6013,8 @@ ${workflowBuilderPrompts.validation.instructions}`;
         throw new Error("No result received from agent execution");
       }
       if (finalResult.status === "needs_clarification" && finalResult.questions && finalResult.questions.length > 0) {
-        console.log(`Agent needs clarification: ${finalResult.questions.length} questions`);
-        console.log("finalResult", JSON.stringify(finalResult, null, 2));
+        console.info(`Agent needs clarification: ${finalResult.questions.length} questions`);
+        console.info("finalResult", JSON.stringify(finalResult, null, 2));
         return suspend({
           questions: finalResult.questions,
           currentProgress: finalResult.progress,
@@ -6052,7 +6030,7 @@ ${workflowBuilderPrompts.validation.instructions}`;
       const finalAllTasksCompleted = finalPendingTasks.length === 0;
       const success = finalAllTasksCompleted && !finalResult.error;
       const message = success ? `Successfully completed workflow ${action} - all ${tasksExpected} tasks completed after ${iterationCount} iteration(s): ${finalResult.message}` : `Workflow execution finished with issues after ${iterationCount} iteration(s): ${finalResult.message}. Completed: ${tasksCompleted}/${tasksExpected} tasks`;
-      console.log(message);
+      console.info(message);
       const missingTasks = finalPendingTasks.map((task) => task.id);
       const validationErrors = [];
       if (finalResult.error) {
@@ -6120,7 +6098,7 @@ var workflowBuilderWorkflow = createWorkflow({
     userAnswers: void 0
   };
 }).dountil(planningAndApprovalWorkflow, async ({ inputData }) => {
-  console.log(`Sub-workflow check: approved=${inputData.approved}`);
+  console.info(`Sub-workflow check: approved=${inputData.approved}`);
   return inputData.approved === true;
 }).map(async ({ getStepResult, getInitData }) => {
   const initData = getInitData();