@mastra/server 0.0.0-fix-memory-search-fetch-20251027160505 → 0.0.0-fix-persist-session-cache-option-mcp-server-20251030161352

package/dist/{chunk-EGLGMBWW.cjs → chunk-4BKR6543.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkB7QWVGQQ_cjs = require('./chunk-B7QWVGQQ.cjs');
 var chunkX6C7BUWN_cjs = require('./chunk-X6C7BUWN.cjs');
 var chunk2PLXW4ZX_cjs = require('./chunk-2PLXW4ZX.cjs');
 var chunkLPM6BBAX_cjs = require('./chunk-LPM6BBAX.cjs');
-var chunkCJFKRVED_cjs = require('./chunk-CJFKRVED.cjs');
+var chunkPUYDRTPG_cjs = require('./chunk-PUYDRTPG.cjs');
+var chunkYNGDJJOH_cjs = require('./chunk-YNGDJJOH.cjs');
 var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
 var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.cjs');
 var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
@@ -744,12 +744,17 @@ chunkO7I5CWRX_cjs.__export(agent_builder_exports, {
   getAgentBuilderActionRunExecutionResultHandler: () => getAgentBuilderActionRunExecutionResultHandler,
   getAgentBuilderActionRunsHandler: () => getAgentBuilderActionRunsHandler,
   getAgentBuilderActionsHandler: () => getAgentBuilderActionsHandler,
+  observeStreamAgentBuilderActionHandler: () => observeStreamAgentBuilderActionHandler,
+  observeStreamLegacyAgentBuilderActionHandler: () => observeStreamLegacyAgentBuilderActionHandler,
+  observeStreamVNextAgentBuilderActionHandler: () => observeStreamVNextAgentBuilderActionHandler,
   resumeAgentBuilderActionHandler: () => resumeAgentBuilderActionHandler,
   resumeAsyncAgentBuilderActionHandler: () => resumeAsyncAgentBuilderActionHandler,
+  resumeStreamAgentBuilderActionHandler: () => resumeStreamAgentBuilderActionHandler,
   sendAgentBuilderActionRunEventHandler: () => sendAgentBuilderActionRunEventHandler,
   startAgentBuilderActionRunHandler: () => startAgentBuilderActionRunHandler,
   startAsyncAgentBuilderActionHandler: () => startAsyncAgentBuilderActionHandler,
   streamAgentBuilderActionHandler: () => streamAgentBuilderActionHandler,
+  streamLegacyAgentBuilderActionHandler: () => streamLegacyAgentBuilderActionHandler,
   streamVNextAgentBuilderActionHandler: () => streamVNextAgentBuilderActionHandler,
   watchAgentBuilderActionHandler: () => watchAgentBuilderActionHandler
 });
@@ -2026,15 +2031,64 @@ var zodToJsonSchema = (schema, options) => {
 // ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js
 var esm_default = zodToJsonSchema;
 
-// ../schema-compat/dist/chunk-GWTUXMDD.js
+// ../schema-compat/dist/chunk-U2HXWNAF.js
+var PATCHED = Symbol("__mastra_patched__");
+function patchRecordSchemas(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema[PATCHED]) return schema;
+  schema[PATCHED] = true;
+  const def = schema._zod?.def;
+  if (def?.type === "record" && def.keyType && !def.valueType) {
+    def.valueType = def.keyType;
+    def.keyType = zod.z.string();
+  }
+  if (!def) return schema;
+  if (def.type === "object" && def.shape) {
+    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    for (const key of Object.keys(shape)) {
+      patchRecordSchemas(shape[key]);
+    }
+  }
+  if (def.type === "array" && def.element) {
+    patchRecordSchemas(def.element);
+  }
+  if (def.type === "union" && def.options) {
+    def.options.forEach(patchRecordSchemas);
+  }
+  if (def.type === "record") {
+    if (def.keyType) patchRecordSchemas(def.keyType);
+    if (def.valueType) patchRecordSchemas(def.valueType);
+  }
+  if (def.type === "intersection") {
+    if (def.left) patchRecordSchemas(def.left);
+    if (def.right) patchRecordSchemas(def.right);
+  }
+  if (def.type === "lazy") {
+    if (def.getter && typeof def.getter === "function") {
+      const originalGetter = def.getter;
+      def.getter = function() {
+        const innerSchema = originalGetter();
+        if (innerSchema) {
+          patchRecordSchemas(innerSchema);
+        }
+        return innerSchema;
+      };
+    }
+  }
+  if (def.innerType) {
+    patchRecordSchemas(def.innerType);
+  }
+  return schema;
+}
 function zodToJsonSchema2(zodSchema4, target = "jsonSchema7", strategy = "relative") {
   const fn = "toJSONSchema";
   if (fn in zod.z) {
+    patchRecordSchemas(zodSchema4);
     return zod.z[fn](zodSchema4, {
       unrepresentable: "any",
       override: (ctx) => {
-        const def = ctx.zodSchema?._zod?.def;
-        if (def && def.type === "date") {
+        const def = ctx.zodSchema?._def || ctx.zodSchema?._zod?.def;
+        if (def && (def.typeName === "ZodDate" || def.type === "date")) {
           ctx.jsonSchema.type = "string";
           ctx.jsonSchema.format = "date-time";
         }
@@ -9871,6 +9925,16 @@ var ContainsHandler = class {
     );
   }
 };
+var DefaultHandler = class {
+  apply(zodSchema4, schema) {
+    const { default: v } = schema;
+    if (v === void 0) return zodSchema4;
+    if (!zodSchema4.safeParse(v).success) {
+      return zodSchema4;
+    }
+    return zodSchema4.default(v);
+  }
+};
 var primitiveHandlers = [
   // Type constraints - should run first
   new ConstHandler(),
@@ -9917,6 +9981,7 @@ var refinementHandlers = [
   // Other refinements
   new NotHandler(),
   new UniqueItemsHandler(),
+  new DefaultHandler(),
   // Metadata last
   new MetadataHandler()
 ];
@@ -10510,6 +10575,9 @@ var Memory = class extends memory.MastraMemory {
       sortDirection
     });
   }
+  async listThreadsByResourceId(args) {
+    return this.storage.listThreadsByResourceId(args);
+  }
   async handleWorkingMemoryFromMetadata({
     workingMemory,
     resourceId,
@@ -11036,7 +11104,7 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     const isMDWorkingMemory = !(`schema` in config.workingMemory) && (typeof config.workingMemory.template === `string` || config.workingMemory.template) && config.workingMemory;
     return Boolean(isMDWorkingMemory && isMDWorkingMemory.version === `vnext`);
   }
-  getTools(config) {
+  listTools(config) {
     const mergedConfig = this.getMergedThreadConfig(config);
     if (mergedConfig.workingMemory?.enabled) {
       return {
@@ -12643,13 +12711,13 @@ function asSchema3(schema) {
 }
 var __defProp4 = Object.defineProperty;
 var __export4 = (target, all) => {
-  for (var name172 in all)
-    __defProp4(target, name172, { get: all[name172], enumerable: true });
+  for (var name163 in all)
+    __defProp4(target, name163, { get: all[name163], enumerable: true });
 };
-var name74 = "AI_NoObjectGeneratedError";
-var marker75 = `vercel.ai.error.${name74}`;
-var symbol75 = Symbol.for(marker75);
-var _a75;
+var name65 = "AI_NoObjectGeneratedError";
+var marker65 = `vercel.ai.error.${name65}`;
+var symbol65 = Symbol.for(marker65);
+var _a65;
 var NoObjectGeneratedError3 = class extends AISDKError2 {
   constructor({
     message = "No object generated.",
@@ -12659,18 +12727,18 @@ var NoObjectGeneratedError3 = class extends AISDKError2 {
     usage,
     finishReason
   }) {
-    super({ name: name74, message, cause });
-    this[_a75] = true;
+    super({ name: name65, message, cause });
+    this[_a65] = true;
     this.text = text22;
     this.response = response;
     this.usage = usage;
     this.finishReason = finishReason;
   }
   static isInstance(error) {
-    return AISDKError2.hasMarker(error, marker75);
+    return AISDKError2.hasMarker(error, marker65);
   }
 };
-_a75 = symbol75;
+_a65 = symbol65;
 var dataContentSchema3 = z42.z.union([
   z42.z.string(),
   z42.z.instanceof(Uint8Array),
@@ -12678,8 +12746,8 @@ var dataContentSchema3 = z42.z.union([
   z42.z.custom(
     // Buffer might not be available in some environments such as CloudFlare:
     (value) => {
-      var _a172, _b8;
-      return (_b8 = (_a172 = globalThis.Buffer) == null ? void 0 : _a172.isBuffer(value)) != null ? _b8 : false;
+      var _a163, _b8;
+      return (_b8 = (_a163 = globalThis.Buffer) == null ? void 0 : _a163.isBuffer(value)) != null ? _b8 : false;
     },
     { message: "Must be a Buffer" }
   )
@@ -13228,130 +13296,6 @@ var object3 = ({
     }
   };
 };
-var ClientOrServerImplementationSchema3 = z42.z.looseObject({
-  name: z42.z.string(),
-  version: z42.z.string()
-});
-var BaseParamsSchema3 = z42.z.looseObject({
-  _meta: z42.z.optional(z42.z.object({}).loose())
-});
-var ResultSchema3 = BaseParamsSchema3;
-var RequestSchema3 = z42.z.object({
-  method: z42.z.string(),
-  params: z42.z.optional(BaseParamsSchema3)
-});
-var ServerCapabilitiesSchema3 = z42.z.looseObject({
-  experimental: z42.z.optional(z42.z.object({}).loose()),
-  logging: z42.z.optional(z42.z.object({}).loose()),
-  prompts: z42.z.optional(
-    z42.z.looseObject({
-      listChanged: z42.z.optional(z42.z.boolean())
-    })
-  ),
-  resources: z42.z.optional(
-    z42.z.looseObject({
-      subscribe: z42.z.optional(z42.z.boolean()),
-      listChanged: z42.z.optional(z42.z.boolean())
-    })
-  ),
-  tools: z42.z.optional(
-    z42.z.looseObject({
-      listChanged: z42.z.optional(z42.z.boolean())
-    })
-  )
-});
-ResultSchema3.extend({
-  protocolVersion: z42.z.string(),
-  capabilities: ServerCapabilitiesSchema3,
-  serverInfo: ClientOrServerImplementationSchema3,
-  instructions: z42.z.optional(z42.z.string())
-});
-var PaginatedResultSchema3 = ResultSchema3.extend({
-  nextCursor: z42.z.optional(z42.z.string())
-});
-var ToolSchema3 = z42.z.object({
-  name: z42.z.string(),
-  description: z42.z.optional(z42.z.string()),
-  inputSchema: z42.z.object({
-    type: z42.z.literal("object"),
-    properties: z42.z.optional(z42.z.object({}).loose())
-  }).loose()
-}).loose();
-PaginatedResultSchema3.extend({
-  tools: z42.z.array(ToolSchema3)
-});
-var TextContentSchema3 = z42.z.object({
-  type: z42.z.literal("text"),
-  text: z42.z.string()
-}).loose();
-var ImageContentSchema3 = z42.z.object({
-  type: z42.z.literal("image"),
-  data: z42.z.base64(),
-  mimeType: z42.z.string()
-}).loose();
-var ResourceContentsSchema3 = z42.z.object({
-  /**
-   * The URI of this resource.
-   */
-  uri: z42.z.string(),
-  /**
-   * The MIME type of this resource, if known.
-   */
-  mimeType: z42.z.optional(z42.z.string())
-}).loose();
-var TextResourceContentsSchema3 = ResourceContentsSchema3.extend({
-  text: z42.z.string()
-});
-var BlobResourceContentsSchema3 = ResourceContentsSchema3.extend({
-  blob: z42.z.base64()
-});
-var EmbeddedResourceSchema3 = z42.z.object({
-  type: z42.z.literal("resource"),
-  resource: z42.z.union([TextResourceContentsSchema3, BlobResourceContentsSchema3])
-}).loose();
-ResultSchema3.extend({
-  content: z42.z.array(
-    z42.z.union([TextContentSchema3, ImageContentSchema3, EmbeddedResourceSchema3])
-  ),
-  isError: z42.z.boolean().default(false).optional()
-}).or(
-  ResultSchema3.extend({
-    toolResult: z42.z.unknown()
-  })
-);
-var JSONRPC_VERSION3 = "2.0";
-var JSONRPCRequestSchema3 = z42.z.object({
-  jsonrpc: z42.z.literal(JSONRPC_VERSION3),
-  id: z42.z.union([z42.z.string(), z42.z.number().int()])
-}).merge(RequestSchema3).strict();
-var JSONRPCResponseSchema3 = z42.z.object({
-  jsonrpc: z42.z.literal(JSONRPC_VERSION3),
-  id: z42.z.union([z42.z.string(), z42.z.number().int()]),
-  result: ResultSchema3
-}).strict();
-var JSONRPCErrorSchema3 = z42.z.object({
-  jsonrpc: z42.z.literal(JSONRPC_VERSION3),
-  id: z42.z.union([z42.z.string(), z42.z.number().int()]),
-  error: z42.z.object({
-    code: z42.z.number().int(),
-    message: z42.z.string(),
-    data: z42.z.optional(z42.z.unknown())
-  })
-}).strict();
-var JSONRPCNotificationSchema3 = z42.z.object({
-  jsonrpc: z42.z.literal(JSONRPC_VERSION3)
-}).merge(
-  z42.z.object({
-    method: z42.z.string(),
-    params: z42.z.optional(BaseParamsSchema3)
-  })
-).strict();
-z42.z.union([
-  JSONRPCRequestSchema3,
-  JSONRPCNotificationSchema3,
-  JSONRPCResponseSchema3,
-  JSONRPCErrorSchema3
-]);
 
 // ../agent-builder/dist/index.js
 var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
@@ -13818,11 +13762,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;
   }
@@ -13991,13 +13935,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;
     }
@@ -14005,13 +13949,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;
     }
   }
@@ -15022,7 +14966,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);
@@ -16503,7 +16447,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 || {}
         };
       },
@@ -16527,7 +16471,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) {
@@ -16556,7 +16500,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) {
@@ -16585,7 +16529,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) {
@@ -16609,7 +16553,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) {
@@ -16717,12 +16661,12 @@ var discoverUnitsStep = workflows.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: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
+    const model = await resolveModel({ requestContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
     try {
       const agent$1 = new agent.Agent({
         model,
@@ -16861,8 +16805,8 @@ var prepareBranchStep = workflows.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);
@@ -16886,10 +16830,10 @@ var packageMergeStep = workflows.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 = path.join(targetPath, "package.json");
       let targetPkgRaw = "{}";
@@ -16963,9 +16907,9 @@ var installStep = workflows.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) => path.join(targetPath, f)).find((f) => fs.existsSync(f));
@@ -16991,10 +16935,10 @@ var programmaticFileCopyStep = workflows.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 = [];
@@ -17343,12 +17287,12 @@ var intelligentMergeStep = workflows.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: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
+      const model = await resolveModel({ requestContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
       const copyFileTool = tools.createTool({
         id: "copy-file",
         description: "Copy a file from template to target project (use only for edge cases - most files are already copied programmatically).",
@@ -17611,10 +17555,10 @@ var validationAndFixStep = workflows.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");
@@ -17634,8 +17578,8 @@ var validationAndFixStep = workflows.createStep({
     );
     let currentIteration = 1;
     try {
-      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
-      const allTools = await AgentBuilderDefaults.getToolsForMode(targetPath, "template");
+      const model = await resolveModel({ requestContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
+      const allTools = await AgentBuilderDefaults.listToolsForMode(targetPath, "template");
       const validationAgent = new agent.Agent({
         name: "code-validator-fixer",
         description: "Specialized agent for validating and fixing template integration issues",
@@ -18330,7 +18274,7 @@ var planningIterationStep = workflows.createStep({
   outputSchema: PlanningIterationResultSchema,
   suspendSchema: PlanningIterationSuspendSchema,
   resumeSchema: PlanningIterationResumeSchema,
-  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+  execute: async ({ inputData, resumeData, suspend, requestContext }) => {
     const {
       action,
       workflowName,
@@ -18343,7 +18287,7 @@ var planningIterationStep = workflows.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) => {
@@ -18356,10 +18300,10 @@ var planningIterationStep = workflows.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.Agent({
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
@@ -18416,7 +18360,7 @@ var planningIterationStep = workflows.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`
         );
@@ -18430,7 +18374,7 @@ var planningIterationStep = workflows.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`
       );
@@ -18573,7 +18517,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**
@@ -18652,10 +18596,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;
   }
@@ -18771,7 +18715,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
 
@@ -18961,7 +18905,7 @@ var workflowDiscoveryStep = workflows.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 {
@@ -19020,7 +18964,7 @@ var projectDiscoveryStep = workflows.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();
@@ -19082,10 +19026,10 @@ var workflowResearchStep = workflows.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.Agent({
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
@@ -19151,7 +19095,7 @@ var taskExecutionStep = workflows.createStep({
   outputSchema: TaskExecutionResultSchema,
   suspendSchema: TaskExecutionSuspendSchema,
   resumeSchema: TaskExecutionResumeSchema,
-  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+  execute: async ({ inputData, resumeData, suspend, requestContext }) => {
     const {
       action,
       workflowName,
@@ -19164,7 +19108,7 @@ var taskExecutionStep = workflows.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 = {
@@ -19209,18 +19153,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;
@@ -19422,8 +19359,8 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
     const mastra = actionArgs.mastra;
     const logger = mastra.getLogger();
     try {
-      chunkCJFKRVED_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
-      if (actionId && !chunkCJFKRVED_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+      chunkYNGDJJOH_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkYNGDJJOH_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
         throw new chunk7NADHFD2_cjs.HTTPException(400, {
           message: `Invalid agent-builder action: ${actionId}. Valid actions are: ${Object.keys(agentBuilderWorkflows).join(", ")}`
         });
@@ -19438,7 +19375,7 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
         const result = await workflowHandlerFn(handlerArgs);
         return result;
       } finally {
-        chunkCJFKRVED_cjs.WorkflowRegistry.cleanup();
+        chunkYNGDJJOH_cjs.WorkflowRegistry.cleanup();
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -19452,10 +19389,10 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
 }
 var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () => {
   try {
-    const registryWorkflows = chunkCJFKRVED_cjs.WorkflowRegistry.getAllWorkflows();
+    const registryWorkflows = chunkYNGDJJOH_cjs.WorkflowRegistry.getAllWorkflows();
     const _workflows = Object.entries(registryWorkflows).reduce(
       (acc, [key, workflow]) => {
-        acc[key] = chunkCJFKRVED_cjs.getWorkflowInfo(workflow);
+        acc[key] = chunkYNGDJJOH_cjs.getWorkflowInfo(workflow);
         return acc;
       },
       {}
@@ -19466,59 +19403,79 @@ var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () =
   }
 }, "Getting agent builder actions");
 var getAgentBuilderActionByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.getWorkflowByIdHandler,
+  chunkPUYDRTPG_cjs.getWorkflowByIdHandler,
   "Getting agent builder action by ID"
 );
 var getAgentBuilderActionRunByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.getWorkflowRunByIdHandler,
+  chunkPUYDRTPG_cjs.getWorkflowRunByIdHandler,
   "Getting agent builder action run by ID"
 );
 var getAgentBuilderActionRunExecutionResultHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.getWorkflowRunExecutionResultHandler,
+  chunkPUYDRTPG_cjs.getWorkflowRunExecutionResultHandler,
   "Getting agent builder action run execution result"
 );
 var createAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.createWorkflowRunHandler,
+  chunkPUYDRTPG_cjs.createWorkflowRunHandler,
   "Creating agent builder action run"
 );
 var startAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.startAsyncWorkflowHandler,
+  chunkPUYDRTPG_cjs.startAsyncWorkflowHandler,
   "Starting async agent builder action"
 );
 var startAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.startWorkflowRunHandler,
+  chunkPUYDRTPG_cjs.startWorkflowRunHandler,
   "Starting agent builder action run"
 );
 var watchAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.watchWorkflowHandler,
+  chunkPUYDRTPG_cjs.watchWorkflowHandler,
   "Watching agent builder action"
 );
 var streamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.streamLegacyWorkflowHandler,
+  chunkPUYDRTPG_cjs.streamWorkflowHandler,
   "Streaming agent builder action"
 );
+var streamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
+  chunkPUYDRTPG_cjs.streamLegacyWorkflowHandler,
+  "Streaming legacy agent builder action"
+);
 var streamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.streamVNextWorkflowHandler,
+  chunkPUYDRTPG_cjs.streamVNextWorkflowHandler,
   "Streaming VNext agent builder action"
 );
+var observeStreamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
+  chunkPUYDRTPG_cjs.observeStreamLegacyWorkflowHandler,
+  "Observing legacy stream for agent builder action"
+);
+var observeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
+  chunkPUYDRTPG_cjs.observeStreamWorkflowHandler,
+  "Observing stream for agent builder action"
+);
+var observeStreamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
+  chunkPUYDRTPG_cjs.observeStreamVNextWorkflowHandler,
+  "Observing VNext stream for agent builder action"
+);
 var resumeAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.resumeAsyncWorkflowHandler,
+  chunkPUYDRTPG_cjs.resumeAsyncWorkflowHandler,
   "Resuming async agent builder action"
 );
 var resumeAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.resumeWorkflowHandler,
+  chunkPUYDRTPG_cjs.resumeWorkflowHandler,
   "Resuming agent builder action"
 );
+var resumeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
+  chunkPUYDRTPG_cjs.resumeStreamWorkflowHandler,
+  "Resuming stream for agent builder action"
+);
 var getAgentBuilderActionRunsHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.getWorkflowRunsHandler,
+  chunkPUYDRTPG_cjs.listWorkflowRunsHandler,
   "Getting agent builder action runs"
 );
 var cancelAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.cancelWorkflowRunHandler,
+  chunkPUYDRTPG_cjs.cancelWorkflowRunHandler,
   "Cancelling agent builder action run"
 );
 var sendAgentBuilderActionRunEventHandler = createAgentBuilderWorkflowHandler(
-  chunkB7QWVGQQ_cjs.sendWorkflowRunEventHandler,
+  chunkPUYDRTPG_cjs.sendWorkflowRunEventHandler,
   "Sending agent builder action run event"
 );
 
@@ -19530,13 +19487,18 @@ exports.getAgentBuilderActionRunByIdHandler = getAgentBuilderActionRunByIdHandle
 exports.getAgentBuilderActionRunExecutionResultHandler = getAgentBuilderActionRunExecutionResultHandler;
 exports.getAgentBuilderActionRunsHandler = getAgentBuilderActionRunsHandler;
 exports.getAgentBuilderActionsHandler = getAgentBuilderActionsHandler;
+exports.observeStreamAgentBuilderActionHandler = observeStreamAgentBuilderActionHandler;
+exports.observeStreamLegacyAgentBuilderActionHandler = observeStreamLegacyAgentBuilderActionHandler;
+exports.observeStreamVNextAgentBuilderActionHandler = observeStreamVNextAgentBuilderActionHandler;
 exports.resumeAgentBuilderActionHandler = resumeAgentBuilderActionHandler;
 exports.resumeAsyncAgentBuilderActionHandler = resumeAsyncAgentBuilderActionHandler;
+exports.resumeStreamAgentBuilderActionHandler = resumeStreamAgentBuilderActionHandler;
 exports.sendAgentBuilderActionRunEventHandler = sendAgentBuilderActionRunEventHandler;
 exports.startAgentBuilderActionRunHandler = startAgentBuilderActionRunHandler;
 exports.startAsyncAgentBuilderActionHandler = startAsyncAgentBuilderActionHandler;
 exports.streamAgentBuilderActionHandler = streamAgentBuilderActionHandler;
+exports.streamLegacyAgentBuilderActionHandler = streamLegacyAgentBuilderActionHandler;
 exports.streamVNextAgentBuilderActionHandler = streamVNextAgentBuilderActionHandler;
 exports.watchAgentBuilderActionHandler = watchAgentBuilderActionHandler;
-//# sourceMappingURL=chunk-EGLGMBWW.cjs.map
-//# sourceMappingURL=chunk-EGLGMBWW.cjs.map
+//# sourceMappingURL=chunk-4BKR6543.cjs.map
+//# sourceMappingURL=chunk-4BKR6543.cjs.map