@mastra/agent-builder 0.0.0-monorepo-binary-20251013210052 → 0.0.0-netlify-no-bundle-20251127120354

package/dist/index.js

@@ -1,6 +1,5 @@
 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';
 import { mkdtemp, rm, readFile, writeFile, readdir, mkdir, copyFile, stat } from 'fs/promises';
 import { join, resolve, basename, extname, dirname, isAbsolute, relative } from 'path';
@@ -11,7 +10,6 @@ import { existsSync, readFileSync } from 'fs';
 import { createRequire } from 'module';
 import { promisify } from 'util';
 import { ModelRouterLanguageModel } from '@mastra/core/llm';
-import { MemoryProcessor } from '@mastra/core/memory';
 import { tmpdir } from 'os';
 import { openai } from '@ai-sdk/openai';
 import { createStep, createWorkflow } from '@mastra/core/workflows';
@@ -501,11 +499,11 @@ async function renameAndCopyFile(sourceFile, targetFile) {
 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;
   }
@@ -674,13 +672,13 @@ var createModelInstance = async (provider, modelId, version = "v2") => {
   }
 };
 var resolveModel = async ({
-  runtimeContext,
+  requestContext,
   defaultModel = "openai/gpt-4.1",
   projectPath
 }) => {
-  const modelFromContext = runtimeContext.get("model");
+  const modelFromContext = requestContext.get("model");
   if (modelFromContext) {
-    console.info("Using model from runtime context");
+    console.info("Using model from request context");
     if (isValidMastraLanguageModel(modelFromContext)) {
       return modelFromContext;
     }
@@ -688,13 +686,13 @@ 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.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;
     }
   }
@@ -868,7 +866,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.
 
@@ -906,12 +904,14 @@ 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'),
   tools: { weatherTool },
   memory: new Memory({
     storage: new LibSQLStore({
+      id: 'mastra-memory-storage',
       url: 'file:../mastra.db', // ask user what database to use, use this as the default
     }),
   }),
@@ -940,8 +940,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);
   },
 });
 \`\`\`
@@ -959,7 +959,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');
     }
@@ -1013,7 +1013,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) {
@@ -1078,7 +1079,8 @@ 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
+    id: 'mastra-storage',
+    // stores observability, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
   logger: new PinoLogger({
@@ -1122,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({
@@ -1142,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({
@@ -1174,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({
@@ -1199,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
           });
         }
       }),
@@ -1240,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
@@ -1275,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({
@@ -1300,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
@@ -1329,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
@@ -1373,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({
@@ -1407,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,
@@ -1447,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
@@ -1477,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({
@@ -1503,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":
@@ -1565,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":
@@ -1651,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,
@@ -1707,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);
@@ -3080,13 +3082,15 @@ export const mastra = new Mastra({
     }
   }
 };
-var ToolSummaryProcessor = class extends MemoryProcessor {
+var ToolSummaryProcessor = class {
+  id = "tool-summary-processor";
+  name = "ToolSummaryProcessor";
   summaryAgent;
   summaryCache = /* @__PURE__ */ new Map();
   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
@@ -3120,30 +3124,37 @@ var ToolSummaryProcessor = class extends MemoryProcessor {
       keys: Array.from(this.summaryCache.keys())
     };
   }
-  async process(messages) {
+  async processInput({
+    messages,
+    messageList: _messageList
+  }) {
     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);
+      if (message.content.format === 2 && message.content.parts) {
+        for (let partIndex = 0; partIndex < message.content.parts.length; partIndex++) {
+          const part = message.content.parts[partIndex];
+          if (part && part.type === "tool-invocation" && part.toolInvocation?.state === "result") {
+            const cacheKey = this.createCacheKey(part.toolInvocation);
             const cachedSummary = this.summaryCache.get(cacheKey);
             if (cachedSummary) {
-              content.result = `Tool call summary: ${cachedSummary}`;
+              message.content.parts[partIndex] = {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "result",
+                  step: part.toolInvocation.step,
+                  toolCallId: part.toolInvocation.toolCallId,
+                  toolName: part.toolInvocation.toolName,
+                  args: part.toolInvocation.args,
+                  result: `Tool call summary: ${cachedSummary}`
+                }
+              };
             } else {
               const summaryPromise = this.summaryAgent.generate(
-                `Summarize the following tool call: ${JSON.stringify(toolCall)} and result: ${JSON.stringify(content)}`
+                `Summarize the following tool call: ${JSON.stringify(part.toolInvocation)}`
               );
               summaryTasks.push({
-                content,
+                message,
+                partIndex,
                 promise: summaryPromise,
                 cacheKey
               });
@@ -3161,10 +3172,24 @@ var ToolSummaryProcessor = class extends MemoryProcessor {
           const summaryResult = result.value;
           const summaryText = summaryResult.text;
           this.summaryCache.set(task.cacheKey, summaryText);
-          task.content.result = `Tool call summary: ${summaryText}`;
+          if (task.message.content.format === 2 && task.message.content.parts) {
+            const part = task.message.content.parts[task.partIndex];
+            if (part && part.type === "tool-invocation" && part.toolInvocation?.state === "result") {
+              task.message.content.parts[task.partIndex] = {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "result",
+                  step: part.toolInvocation.step,
+                  toolCallId: part.toolInvocation.toolCallId,
+                  toolName: part.toolInvocation.toolName,
+                  args: part.toolInvocation.args,
+                  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]`;
         }
       });
     }
@@ -3184,26 +3209,26 @@ var AgentBuilder = class extends Agent {
 ${config.instructions}` : "";
     const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
     const agentConfig = {
+      id: "agent-builder",
       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),
+          ...await AgentBuilderDefaults.listToolsForMode(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' }),
-        ]
-      })
+        options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG
+      }),
+      inputProcessors: [
+        // 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 WriteToDiskProcessor({ prefix: 'after-filter' }),
+      ]
     };
     super(agentConfig);
     this.builderConfig = config;
@@ -3214,7 +3239,7 @@ ${config.instructions}` : "";
    */
   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) {
@@ -3243,7 +3268,7 @@ ${additionalInstructions}`;
    */
   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) {
@@ -3272,7 +3297,7 @@ ${additionalInstructions}`;
    */
   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) {
@@ -3296,7 +3321,7 @@ ${additionalInstructions}`;
   }
   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) {
@@ -3404,14 +3429,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.info("targetPath", targetPath);
-    const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: openai("gpt-4.1") });
+    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.
 
@@ -3548,8 +3574,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);
@@ -3573,10 +3599,10 @@ var packageMergeStep = createStep({
   description: "Merge template package.json dependencies into target project",
   inputSchema: PackageMergeInputSchema,
   outputSchema: PackageMergeResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  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 = "{}";
@@ -3650,9 +3676,9 @@ var installStep = createStep({
   description: "Install packages based on merged package.json",
   inputSchema: InstallInputSchema,
   outputSchema: InstallResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  execute: async ({ inputData, requestContext }) => {
     console.info("Running install step...");
-    const targetPath = resolveTargetPath(inputData, runtimeContext);
+    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));
@@ -3678,10 +3704,10 @@ var programmaticFileCopyStep = createStep({
   description: "Programmatically copy template files to target project based on ordered units",
   inputSchema: FileCopyInputSchema,
   outputSchema: FileCopyResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  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 = [];
@@ -4030,12 +4056,12 @@ var intelligentMergeStep = createStep({
   description: "Use AgentBuilder to intelligently merge template files",
   inputSchema: IntelligentMergeInputSchema,
   outputSchema: IntelligentMergeResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  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).",
@@ -4048,9 +4074,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))) {
@@ -4298,10 +4324,10 @@ 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 }) => {
+  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.info("\u23ED\uFE0F Skipping validation - no files copied or conflicts resolved");
@@ -4321,10 +4347,11 @@ var validationAndFixStep = createStep({
     );
     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:
 
@@ -4727,7 +4754,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,
@@ -5034,7 +5061,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,
@@ -5047,7 +5074,7 @@ var planningIterationStep = createStep({
     } = inputData;
     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 || {} };
     if (Object.keys(newAnswers).length > 0) {
       storedQAPairs = storedQAPairs.map((pair) => {
@@ -5060,11 +5087,12 @@ var planningIterationStep = createStep({
         }
         return pair;
       });
-      runtimeContext.set(qaKey, storedQAPairs);
+      requestContext.set(qaKey, storedQAPairs);
     }
     try {
-      const model = await resolveModel({ runtimeContext });
+      const model = await resolveModel({ requestContext });
       const planningAgent = new Agent({
+        id: "workflow-planning-agent",
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
           storedQAPairs
@@ -5094,7 +5122,9 @@ var planningIterationStep = createStep({
         research
       });
       const result = await planningAgent.generate(planningPrompt, {
-        output: PlanningAgentOutputSchema
+        structuredOutput: {
+          schema: PlanningAgentOutputSchema
+        }
         // maxSteps: 15,
       });
       const planResult = await result.object;
@@ -5118,7 +5148,7 @@ var planningIterationStep = createStep({
           answeredAt: null
         }));
         storedQAPairs = [...storedQAPairs, ...newQAPairs];
-        runtimeContext.set(qaKey, storedQAPairs);
+        requestContext.set(qaKey, storedQAPairs);
         console.info(
           `Updated Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
         );
@@ -5132,7 +5162,7 @@ var planningIterationStep = createStep({
         });
       }
       console.info(`Planning complete with ${planResult.tasks.length} tasks`);
-      runtimeContext.set(qaKey, storedQAPairs);
+      requestContext.set(qaKey, storedQAPairs);
       console.info(
         `Final Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
       );
@@ -5277,7 +5307,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**
@@ -5356,10 +5386,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;
   }
@@ -5403,7 +5433,7 @@ export const mastra = new Mastra({
     sendEmailWorkflow,      // Use camelCase for keys
     dataProcessingWorkflow
   },
-  storage: new LibSQLStore({ url: 'file:./mastra.db' }), // Required for suspend/resume
+  storage: new LibSQLStore({ id: 'mastra-storage', url: 'file:./mastra.db' }), // Required for suspend/resume
 });
 \`\`\`
 
@@ -5451,7 +5481,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
@@ -5475,7 +5505,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
 
@@ -5648,11 +5678,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"
       }))
@@ -5667,7 +5697,7 @@ var workflowDiscoveryStep = createStep({
   description: "Discover existing workflows in the project",
   inputSchema: WorkflowBuilderInputSchema,
   outputSchema: WorkflowDiscoveryResultSchema,
-  execute: async ({ inputData, runtimeContext: _runtimeContext }) => {
+  execute: async ({ inputData, requestContext: _requestContext }) => {
     console.info("Starting workflow discovery...");
     const { projectPath = process.cwd() } = inputData;
     try {
@@ -5726,7 +5756,7 @@ var projectDiscoveryStep = createStep({
   description: "Analyze the project structure and setup",
   inputSchema: WorkflowDiscoveryResultSchema,
   outputSchema: ProjectDiscoveryResultSchema,
-  execute: async ({ inputData: _inputData, runtimeContext: _runtimeContext }) => {
+  execute: async ({ inputData: _inputData, requestContext: _requestContext }) => {
     console.info("Starting project discovery...");
     try {
       const projectPath = process.cwd();
@@ -5788,11 +5818,12 @@ var workflowResearchStep = createStep({
   description: "Research Mastra workflows and gather relevant documentation",
   inputSchema: ProjectDiscoveryResultSchema,
   outputSchema: WorkflowResearchResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
+  execute: async ({ inputData, requestContext }) => {
     console.info("Starting workflow research...");
     try {
-      const model = await resolveModel({ runtimeContext });
+      const model = await resolveModel({ requestContext });
       const researchAgent = new Agent({
+        id: "workflow-research-agent",
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
         name: "Workflow Research Agent"
@@ -5804,7 +5835,9 @@ var workflowResearchStep = createStep({
         hasWorkflowsDir: inputData.structure.hasWorkflowsDir
       });
       const result = await researchAgent.generate(researchPrompt, {
-        output: WorkflowResearchResultSchema
+        structuredOutput: {
+          schema: WorkflowResearchResultSchema
+        }
         // stopWhen: stepCountIs(10),
       });
       const researchResult = await result.object;
@@ -5855,7 +5888,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,
@@ -5870,7 +5903,7 @@ var taskExecutionStep = createStep({
     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.info("Pre-populating taskManager with planned tasks...");
       const taskManagerContext = {
@@ -5915,18 +5948,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;