@mastra/agent-builder 0.0.0-rag-chunk-extract-llm-option-20250926183645 → 0.0.0-remove-unused-model-providers-api-20251030210744

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';
@@ -501,11 +501,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;
   }
@@ -658,31 +658,9 @@ 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;
@@ -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.info("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.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.info("Using default model");
-  return defaultModel;
+  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.
 
@@ -1100,7 +1078,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({
@@ -1729,7 +1707,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);
@@ -3212,7 +3190,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 +3212,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 +3235,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 +3264,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 +3292,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 +3316,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({
@@ -3426,12 +3404,12 @@ 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({
         model,
@@ -3491,10 +3469,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
       });
@@ -3568,8 +3548,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 +3573,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 = "{}";
@@ -3670,9 +3650,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));
@@ -3698,10 +3678,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 = [];
@@ -4050,12 +4030,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).",
@@ -4240,7 +4220,7 @@ 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") {
@@ -4318,10 +4298,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");
@@ -4341,8 +4321,8 @@ 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",
         description: "Specialized agent for validating and fixing template integration issues",
@@ -4482,9 +4462,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;
@@ -5052,7 +5034,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,
@@ -5065,7 +5047,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) => {
@@ -5078,10 +5060,10 @@ 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({
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
@@ -5111,8 +5093,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;
@@ -5136,7 +5120,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`
         );
@@ -5150,7 +5134,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`
       );
@@ -5295,7 +5279,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**
@@ -5374,10 +5358,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;
   }
@@ -5493,7 +5477,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
 
@@ -5685,7 +5669,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 {
@@ -5744,7 +5728,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();
@@ -5806,10 +5790,10 @@ 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({
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
@@ -5821,8 +5805,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;
@@ -5873,7 +5859,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,
@@ -5888,7 +5874,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 = {
@@ -5933,18 +5919,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;
@@ -5973,7 +5952,7 @@ ${additionalInstructions}`;
         })}
 
 ${workflowBuilderPrompts.validation.instructions}`;
-        const stream = await executionAgent.streamVNext(iterationPrompt, {
+        const stream = await executionAgent.stream(iterationPrompt, {
           structuredOutput: {
             schema: TaskExecutionIterationInputSchema(tasks.length),
             model