@mastra/core 1.0.0-beta.11 → 1.0.0-beta.14

package/dist/{chunk-2ULLRN4Y.js → chunk-QF4MHFSU.js}

@@ -1,27 +1,29 @@
-import { DefaultVoice } from './chunk-F2GAJSBI.js';
-import { EMITTER_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-NLNKQD2T.js';
-import { InMemoryStore } from './chunk-JIGDJK2O.js';
-import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-SXNQRJQD.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel } from './chunk-5PAEYE3Q.js';
-import { MastraLLMV1 } from './chunk-C36YRTZ6.js';
+import { DefaultVoice } from './chunk-GELVUDUY.js';
+import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-6PMMP3FR.js';
+import { InMemoryStore } from './chunk-GBQXIVL6.js';
+import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-4AT6YQKZ.js';
+import { createTextStreamResponse, createUIMessageStreamResponse, createUIMessageStream, parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-2SQB3WBT.js';
+import { generateId, asSchema, jsonSchema, APICallError, tool } from './chunk-G6E6V2Z4.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-QDVYP2T7.js';
+import { MastraLLMV1 } from './chunk-4CMIJQF6.js';
+import { PubSub } from './chunk-BVUMKER5.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, isZodType, deepMerge, selectFields, delay } from './chunk-IVV5TOMD.js';
+import { removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, isZodType, deepMerge, selectFields, delay } from './chunk-LDXKZYOV.js';
 import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-Y36Y5MTD.js';
-import { MastraError, getErrorFromUnknown } from './chunk-JJ5O45LH.js';
+import { MastraError, getErrorFromUnknown } from './chunk-YPLZDWG7.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
-import { Tool, createTool } from './chunk-THZTRBFS.js';
+import { Tool, createTool } from './chunk-373OC54J.js';
 import { RequestContext, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from './chunk-6TBWJV35.js';
 import { zodToJsonSchema as zodToJsonSchema$1 } from './chunk-PJKCPRYF.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 import { RegisteredLogger, ConsoleLogger } from './chunk-NRUZYMHE.js';
-import { __commonJS, __toESM } from './chunk-5WRI5ZAA.js';
-import z7, { z, ZodObject } from 'zod';
+import { __commonJS, __toESM } from './chunk-7D4SUZUM.js';
+import z8, { z, ZodObject } from 'zod';
 import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { TransformStream, ReadableStream as ReadableStream$1, WritableStream as WritableStream$1 } from 'stream/web';
 import EventEmitter2, { EventEmitter } from 'events';
 import { getErrorMessage, TypeValidationError } from '@ai-sdk/provider-v5';
-import { createTextStreamResponse, createUIMessageStreamResponse, createUIMessageStream, generateId, asSchema, parsePartialJson, isDeepEqualData, jsonSchema, APICallError, tool, stepCountIs } from 'ai-v5';
 import z4 from 'zod/v4';
 import { OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, GoogleSchemaCompatLayer, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, MetaSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
 import { isEmpty } from 'radash';
@@ -426,6 +428,8 @@ var DelayedPromise = class {
     }
   }
 };
+
+// src/stream/aisdk/v5/compat/prepare-tools.ts
 function prepareToolsAndToolChoice({
   tools,
   toolChoice,
@@ -439,17 +443,17 @@ function prepareToolsAndToolChoice({
   }
   const filteredTools = activeTools != null ? Object.entries(tools || {}).filter(([name]) => activeTools.includes(name)) : Object.entries(tools || {});
   return {
-    tools: filteredTools.map(([name, tool$1]) => {
+    tools: filteredTools.map(([name, tool2]) => {
       try {
         let inputSchema;
-        if ("inputSchema" in tool$1) {
-          inputSchema = tool$1.inputSchema;
-        } else if ("parameters" in tool$1) {
-          inputSchema = tool$1.parameters;
+        if ("inputSchema" in tool2) {
+          inputSchema = tool2.inputSchema;
+        } else if ("parameters" in tool2) {
+          inputSchema = tool2.parameters;
         }
         const sdkTool = tool({
           type: "function",
-          ...tool$1,
+          ...tool2,
           inputSchema
         });
         const toolType = sdkTool?.type ?? "function";
@@ -489,7 +493,7 @@ function prepareToolsAndToolChoice({
         console.error("Error preparing tool", e);
         return null;
       }
-    }).filter((tool) => tool !== null),
+    }).filter((tool2) => tool2 !== null),
     toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
   };
 }
@@ -725,6 +729,69 @@ The input text may be in any format (sentences, bullet points, paragraphs, etc.)
   }
 };
 
+// src/agent/utils.ts
+var supportedLanguageModelSpecifications = ["v2", "v3"];
+var isSupportedLanguageModel = (model) => {
+  return supportedLanguageModelSpecifications.includes(model.specificationVersion);
+};
+async function tryGenerateWithJsonFallback(agent, prompt, options) {
+  if (!options.structuredOutput?.schema) {
+    throw new MastraError({
+      id: "STRUCTURED_OUTPUT_OPTIONS_REQUIRED",
+      domain: "AGENT" /* AGENT */,
+      category: "USER" /* USER */,
+      text: "structuredOutput is required to use tryGenerateWithJsonFallback"
+    });
+  }
+  try {
+    return await agent.generate(prompt, options);
+  } catch (error) {
+    console.warn("Error in tryGenerateWithJsonFallback. Attempting fallback.", error);
+    return await agent.generate(prompt, {
+      ...options,
+      structuredOutput: { ...options.structuredOutput, jsonPromptInjection: true }
+    });
+  }
+}
+async function tryStreamWithJsonFallback(agent, prompt, options) {
+  if (!options.structuredOutput?.schema) {
+    throw new MastraError({
+      id: "STRUCTURED_OUTPUT_OPTIONS_REQUIRED",
+      domain: "AGENT" /* AGENT */,
+      category: "USER" /* USER */,
+      text: "structuredOutput is required to use tryStreamWithJsonFallback"
+    });
+  }
+  try {
+    const result = await agent.stream(prompt, options);
+    const object = await result.object;
+    if (!object) {
+      throw new MastraError({
+        id: "STRUCTURED_OUTPUT_OBJECT_UNDEFINED",
+        domain: "AGENT" /* AGENT */,
+        category: "USER" /* USER */,
+        text: "structuredOutput object is undefined"
+      });
+    }
+    return result;
+  } catch (error) {
+    console.warn("Error in tryStreamWithJsonFallback. Attempting fallback.", error);
+    return await agent.stream(prompt, {
+      ...options,
+      structuredOutput: { ...options.structuredOutput, jsonPromptInjection: true }
+    });
+  }
+}
+function resolveThreadIdFromArgs(args) {
+  if (args?.memory?.thread) {
+    if (typeof args.memory.thread === "string") return { id: args.memory.thread };
+    if (typeof args.memory.thread === "object" && args.memory.thread.id)
+      return args.memory.thread;
+  }
+  if (args?.threadId) return { id: args.threadId };
+  return void 0;
+}
+
 // src/processors/runner.ts
 var ProcessorState = class {
   accumulatedText = "";
@@ -1635,12 +1702,13 @@ var ProcessorRunner = class _ProcessorRunner {
       const { model: _model, ...rest } = result;
       if (result.model) {
         const resolvedModel = await resolveModelConfig(result.model);
-        if (resolvedModel.specificationVersion === "v1") {
+        const isSupported = isSupportedLanguageModel(resolvedModel);
+        if (!isSupported) {
           throw new MastraError({
             category: "USER",
             domain: "AGENT",
-            id: "PROCESSOR_RETURNED_V1_MODEL",
-            text: `Processor ${processor.id} returned a v1 model in step ${stepNumber}. v1 models are not supported in processInputStep.`
+            id: "PROCESSOR_RETURNED_UNSUPPORTED_MODEL",
+            text: `Processor ${processor.id} returned an unsupported model version ${resolvedModel.specificationVersion} in step ${stepNumber}. Only ${supportedLanguageModelSpecifications.join(", ")} models are supported in processInputStep.`
           });
         }
         return {
@@ -1839,10 +1907,8 @@ function convertFullStreamChunkToMastra(value, ctx) {
             reason: value.finishReason
           },
           output: {
-            usage: {
-              ...value.usage ?? {},
-              totalTokens: value?.usage?.totalTokens ?? (value.usage?.inputTokens ?? 0) + (value.usage?.outputTokens ?? 0)
-            }
+            // Normalize usage to handle both V2 (flat) and V3 (nested) formats
+            usage: normalizeUsage(value.usage)
           },
           metadata: {
             providerMetadata: value.providerMetadata
@@ -1894,6 +1960,7 @@ function convertMastraChunkToAISDKv5({
         type: "finish",
         // Cast needed: Mastra extends reason with 'tripwire' | 'retry' for processor scenarios
         finishReason: chunk.payload.stepResult.reason,
+        // Cast needed: Mastra's LanguageModelUsage has optional properties, V2 has required-but-nullable
         totalUsage: chunk.payload.output.usage
       };
     }
@@ -1912,18 +1979,8 @@ function convertMastraChunkToAISDKv5({
       };
     case "reasoning-signature":
       throw new Error('AISDKv5 chunk type "reasoning-signature" not supported');
-    // return {
-    //   type: 'reasoning-signature' as const,
-    //   id: chunk.payload.id,
-    //   signature: chunk.payload.signature,
-    // };
     case "redacted-reasoning":
       throw new Error('AISDKv5 chunk type "redacted-reasoning" not supported');
-    // return {
-    //   type: 'redacted-reasoning',
-    //   id: chunk.payload.id,
-    //   data: chunk.payload.data,
-    // };
     case "reasoning-end":
       return {
         type: "reasoning-end",
@@ -2077,6 +2134,44 @@ function convertMastraChunkToAISDKv5({
       return;
   }
 }
+function isV3Usage(usage) {
+  if (!usage || typeof usage !== "object") return false;
+  const u = usage;
+  return typeof u.inputTokens === "object" && u.inputTokens !== null && "total" in u.inputTokens && typeof u.outputTokens === "object" && u.outputTokens !== null && "total" in u.outputTokens;
+}
+function normalizeUsage(usage) {
+  if (!usage) {
+    return {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0,
+      reasoningTokens: void 0,
+      cachedInputTokens: void 0,
+      raw: void 0
+    };
+  }
+  if (isV3Usage(usage)) {
+    const inputTokens = usage.inputTokens.total;
+    const outputTokens = usage.outputTokens.total;
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens: (inputTokens ?? 0) + (outputTokens ?? 0),
+      reasoningTokens: usage.outputTokens.reasoning,
+      cachedInputTokens: usage.inputTokens.cacheRead,
+      raw: usage
+    };
+  }
+  const v2Usage = usage;
+  return {
+    inputTokens: v2Usage.inputTokens,
+    outputTokens: v2Usage.outputTokens,
+    totalTokens: v2Usage.totalTokens ?? (v2Usage.inputTokens ?? 0) + (v2Usage.outputTokens ?? 0),
+    reasoningTokens: v2Usage.reasoningTokens,
+    cachedInputTokens: v2Usage.cachedInputTokens,
+    raw: usage
+  };
+}
 
 // src/stream/aisdk/v5/output.ts
 var AISDKV5OutputStream = class {
@@ -2366,6 +2461,8 @@ var AISDKV5OutputStream = class {
     return this.#modelOutput.object;
   }
 };
+
+// src/stream/base/schema.ts
 function asJsonSchema(schema) {
   if (!schema) {
     return void 0;
@@ -2970,7 +3067,11 @@ var MastraModelOutput = class extends MastraBase {
   #warnings = [];
   #finishReason = void 0;
   #request = {};
-  #usageCount = { inputTokens: void 0, outputTokens: void 0, totalTokens: void 0 };
+  #usageCount = {
+    inputTokens: void 0,
+    outputTokens: void 0,
+    totalTokens: void 0
+  };
   #tripwire = void 0;
   #delayedPromises = {
     suspendPayload: new DelayedPromise(),
@@ -3317,23 +3418,25 @@ var MastraModelOutput = class extends MastraBase {
               };
               self.#finishReason = "other";
               self.#streamFinished = true;
-              self.#delayedPromises.text.resolve(self.#bufferedText.join(""));
-              self.#delayedPromises.finishReason.resolve("other");
-              self.#delayedPromises.object.resolve(void 0);
-              self.#delayedPromises.usage.resolve(self.#usageCount);
-              self.#delayedPromises.warnings.resolve(self.#warnings);
-              self.#delayedPromises.providerMetadata.resolve(void 0);
-              self.#delayedPromises.response.resolve({});
-              self.#delayedPromises.request.resolve({});
-              self.#delayedPromises.reasoning.resolve([]);
-              self.#delayedPromises.reasoningText.resolve(void 0);
-              self.#delayedPromises.sources.resolve([]);
-              self.#delayedPromises.files.resolve([]);
-              self.#delayedPromises.toolCalls.resolve([]);
-              self.#delayedPromises.toolResults.resolve([]);
-              self.#delayedPromises.steps.resolve(self.#bufferedSteps);
-              self.#delayedPromises.totalUsage.resolve(self.#usageCount);
-              self.#delayedPromises.content.resolve([]);
+              self.resolvePromises({
+                text: self.#bufferedText.join(""),
+                finishReason: "other",
+                object: void 0,
+                usage: self.#usageCount,
+                warnings: self.#warnings,
+                providerMetadata: void 0,
+                response: {},
+                request: {},
+                reasoning: [],
+                reasoningText: void 0,
+                sources: [],
+                files: [],
+                toolCalls: [],
+                toolResults: [],
+                steps: self.#bufferedSteps,
+                totalUsage: self.#usageCount,
+                content: []
+              });
               self.#emitChunk(chunk);
               controller.enqueue(chunk);
               self.#emitter.emit("finish");
@@ -3401,8 +3504,10 @@ var MastraModelOutput = class extends MastraBase {
                   if (lastStep && outputText && outputText !== originalText) {
                     lastStep.text = outputText;
                   }
-                  self.#delayedPromises.text.resolve(outputText || originalText);
-                  self.#delayedPromises.finishReason.resolve(self.#finishReason);
+                  this.resolvePromises({
+                    text: outputText || originalText,
+                    finishReason: self.#finishReason
+                  });
                   if (chunk.payload.metadata) {
                     const { providerMetadata, request, ...otherMetadata } = chunk.payload.metadata;
                     response = {
@@ -3412,9 +3517,10 @@ var MastraModelOutput = class extends MastraBase {
                     };
                   }
                 } else if (!self.#options.isLLMExecutionStep) {
-                  const textContent = self.#bufferedText.join("");
-                  self.#delayedPromises.text.resolve(textContent);
-                  self.#delayedPromises.finishReason.resolve(self.#finishReason);
+                  this.resolvePromises({
+                    text: self.#bufferedText.join(""),
+                    finishReason: self.#finishReason
+                  });
                 }
               } catch (error2) {
                 if (error2 instanceof TripWire) {
@@ -3424,35 +3530,41 @@ var MastraModelOutput = class extends MastraBase {
                     metadata: error2.options?.metadata,
                     processorId: error2.processorId
                   };
-                  self.#delayedPromises.finishReason.resolve("other");
-                  self.#delayedPromises.text.resolve("");
+                  self.resolvePromises({
+                    finishReason: "other",
+                    text: ""
+                  });
                 } else {
                   self.#error = getErrorFromUnknown(error2, {
                     fallbackMessage: "Unknown error in stream"
                   });
-                  self.#delayedPromises.finishReason.resolve("error");
-                  self.#delayedPromises.text.resolve("");
+                  self.resolvePromises({
+                    finishReason: "error",
+                    text: ""
+                  });
                 }
                 if (self.#delayedPromises.object.status.type !== "resolved") {
                   self.#delayedPromises.object.resolve(void 0);
                 }
               }
-              self.#delayedPromises.usage.resolve(self.#usageCount);
-              self.#delayedPromises.warnings.resolve(self.#warnings);
-              self.#delayedPromises.providerMetadata.resolve(chunk.payload.metadata?.providerMetadata);
-              self.#delayedPromises.response.resolve(response);
-              self.#delayedPromises.request.resolve(self.#request || {});
               const reasoningText = self.#bufferedReasoning.length > 0 ? self.#bufferedReasoning.map((reasoningPart) => reasoningPart.payload.text).join("") : void 0;
-              self.#delayedPromises.reasoningText.resolve(reasoningText);
-              self.#delayedPromises.reasoning.resolve(Object.values(self.#bufferedReasoningDetails || {}));
-              self.#delayedPromises.sources.resolve(self.#bufferedSources);
-              self.#delayedPromises.files.resolve(self.#bufferedFiles);
-              self.#delayedPromises.toolCalls.resolve(self.#toolCalls);
-              self.#delayedPromises.toolResults.resolve(self.#toolResults);
-              self.#delayedPromises.steps.resolve(self.#bufferedSteps);
-              self.#delayedPromises.totalUsage.resolve(self.#getTotalUsage());
-              self.#delayedPromises.content.resolve(messageList.get.response.aiV5.stepContent());
-              self.#delayedPromises.suspendPayload.resolve(void 0);
+              this.resolvePromises({
+                usage: self.#usageCount,
+                warnings: self.#warnings,
+                providerMetadata: chunk.payload.metadata?.providerMetadata,
+                response,
+                request: self.#request || {},
+                reasoningText,
+                reasoning: Object.values(self.#bufferedReasoningDetails || {}),
+                sources: self.#bufferedSources,
+                files: self.#bufferedFiles,
+                toolCalls: self.#toolCalls,
+                toolResults: self.#toolResults,
+                steps: self.#bufferedSteps,
+                totalUsage: self.#getTotalUsage(),
+                content: messageList.get.response.aiV5.stepContent(),
+                suspendPayload: void 0
+              });
               const baseFinishStep = self.#bufferedSteps[self.#bufferedSteps.length - 1];
               if (baseFinishStep) {
                 const onFinishPayload = {
@@ -3520,6 +3632,28 @@ var MastraModelOutput = class extends MastraBase {
           if (self.#delayedPromises.object.status.type === "pending") {
             self.#delayedPromises.object.resolve(void 0);
           }
+          if (self.#status === "suspended") {
+            const reasoningText = self.#bufferedReasoning.length > 0 ? self.#bufferedReasoning.map((reasoningPart) => reasoningPart.payload.text).join("") : void 0;
+            self.resolvePromises({
+              toolResults: self.#toolResults,
+              toolCalls: self.#toolCalls,
+              text: self.#bufferedText.join(""),
+              reasoning: Object.values(self.#bufferedReasoningDetails || {}),
+              reasoningText,
+              sources: self.#bufferedSources,
+              files: self.#bufferedFiles,
+              steps: self.#bufferedSteps,
+              usage: self.#usageCount,
+              totalUsage: self.#getTotalUsage(),
+              warnings: self.#warnings,
+              finishReason: "other",
+              content: self.messageList.get.response.aiV5.stepContent(),
+              object: void 0,
+              request: self.#request,
+              response: {},
+              providerMetadata: void 0
+            });
+          }
           Object.entries(self.#delayedPromises).forEach(([key, promise]) => {
             if (promise.status.type === "pending") {
               promise.reject(new Error(`promise '${key}' was not resolved or rejected when stream finished`));
@@ -3543,6 +3677,23 @@ var MastraModelOutput = class extends MastraBase {
       this.deserializeState(initialState);
     }
   }
+  resolvePromise(key, value) {
+    if (!(key in this.#delayedPromises)) {
+      throw new MastraError({
+        id: "MASTRA_MODEL_OUTPUT_INVALID_PROMISE_KEY",
+        domain: "LLM" /* LLM */,
+        category: "SYSTEM" /* SYSTEM */,
+        text: `Attempted to resolve invalid promise key '${key}' with value '${typeof value === "object" ? JSON.stringify(value, null, 2) : value}'`
+      });
+    }
+    this.#delayedPromises[key].resolve(value);
+  }
+  resolvePromises(data) {
+    for (const keyString in data) {
+      const key = keyString;
+      this.resolvePromise(key, data[key]);
+    }
+  }
   #getDelayedPromise(promise) {
     if (!this.#consumptionStarted) {
       void this.consumeStream();
@@ -4515,7 +4666,7 @@ var getModelOutputForTripwire = async ({
     model: {
       modelId: model.modelId,
       provider: model.provider,
-      version: model.specificationVersion || "v2"
+      version: model.specificationVersion
     },
     stream: tripwireStream,
     messageList,
@@ -4586,11 +4737,36 @@ function runScorer({
   };
   executeHook("onScorerRun" /* ON_SCORER_RUN */, payload);
 }
-
-// src/llm/model/is-v2-model.ts
-function isV2Model(model) {
-  return model.specificationVersion === "v2";
-}
+var EventEmitterPubSub = class extends PubSub {
+  emitter;
+  constructor(existingEmitter) {
+    super();
+    this.emitter = existingEmitter ?? new EventEmitter2();
+  }
+  async publish(topic, event) {
+    const id = crypto.randomUUID();
+    const createdAt = /* @__PURE__ */ new Date();
+    this.emitter.emit(topic, {
+      ...event,
+      id,
+      createdAt
+    });
+  }
+  async subscribe(topic, cb) {
+    this.emitter.on(topic, cb);
+  }
+  async unsubscribe(topic, cb) {
+    this.emitter.off(topic, cb);
+  }
+  async flush() {
+  }
+  /**
+   * Clean up all listeners during graceful shutdown.
+   */
+  async close() {
+    this.emitter.removeAllListeners();
+  }
+};
 var TextPartSchema = z.object({
   type: z.literal("text"),
   text: z.string()
@@ -4818,6 +4994,43 @@ var ExecutionEngine = class extends MastraBase {
   getLogger() {
     return this.logger;
   }
+  /**
+   * Invokes the onFinish and onError lifecycle callbacks if they are defined.
+   * Errors in callbacks are caught and logged, not propagated.
+   * @param result The workflow result containing status, result, error, steps, and tripwire info
+   */
+  async invokeLifecycleCallbacks(result) {
+    const { onFinish, onError } = this.options;
+    if (onFinish) {
+      try {
+        await Promise.resolve(
+          onFinish({
+            status: result.status,
+            result: result.result,
+            error: result.error,
+            steps: result.steps,
+            tripwire: result.tripwire
+          })
+        );
+      } catch (err) {
+        this.logger.error("Error in onFinish callback", { error: err });
+      }
+    }
+    if (onError && (result.status === "failed" || result.status === "tripwire")) {
+      try {
+        await Promise.resolve(
+          onError({
+            status: result.status,
+            error: result.error,
+            steps: result.steps,
+            tripwire: result.tripwire
+          })
+        );
+      } catch (err) {
+        this.logger.error("Error in onError callback", { error: err });
+      }
+    }
+  }
 };
 
 // src/workflows/step.ts
@@ -4850,7 +5063,16 @@ async function validateStepInput({
     if (!validatedInput.success) {
       const errors = getZodErrors(validatedInput.error);
       const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
-      validationError = new Error("Step input validation failed: \n" + errorMessages);
+      validationError = new MastraError(
+        {
+          id: "WORKFLOW_STEP_INPUT_VALIDATION_FAILED",
+          domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+          category: "USER" /* USER */,
+          text: "Step input validation failed: \n" + errorMessages
+        },
+        // keep the original zod error as the cause for consumers
+        validatedInput.error
+      );
     } else {
       const isEmptyData = isEmpty(validatedInput.data);
       inputData = isEmptyData ? prevOutput : validatedInput.data;
@@ -4869,7 +5091,16 @@ async function validateStepResumeData({ resumeData, step }) {
     if (!validatedResumeData.success) {
       const errors = getZodErrors(validatedResumeData.error);
       const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
-      validationError = new Error("Step resume data validation failed: \n" + errorMessages);
+      validationError = new MastraError(
+        {
+          id: "WORKFLOW_STEP_RESUME_DATA_VALIDATION_FAILED",
+          domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+          category: "USER" /* USER */,
+          text: "Step resume data validation failed: \n" + errorMessages
+        },
+        // keep the original zod error as the cause for consumers
+        validatedResumeData.error
+      );
     } else {
       resumeData = validatedResumeData.data;
     }
@@ -4891,7 +5122,16 @@ async function validateStepSuspendData({
     if (!validatedSuspendData.success) {
       const errors = getZodErrors(validatedSuspendData.error);
       const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
-      validationError = new Error("Step suspend data validation failed: \n" + errorMessages);
+      validationError = new MastraError(
+        {
+          id: "WORKFLOW_STEP_SUSPEND_DATA_VALIDATION_FAILED",
+          domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+          category: "USER" /* USER */,
+          text: "Step suspend data validation failed: \n" + errorMessages
+        },
+        // keep the original zod error as the cause for consumers
+        validatedSuspendData.error
+      );
     } else {
       suspendData = validatedSuspendData.data;
     }
@@ -5055,6 +5295,16 @@ var createTimeTravelExecutionParams = (params) => {
   };
   return timeTravelData;
 };
+function hydrateSerializedStepErrors(steps) {
+  if (steps) {
+    for (const step of Object.values(steps)) {
+      if (step.status === "failed" && "error" in step && step.error) {
+        step.error = getErrorFromUnknown(step.error, { serializeStack: false });
+      }
+    }
+  }
+  return steps;
+}
 
 // src/workflows/handlers/control-flow.ts
 async function executeParallel(engine, params) {
@@ -5071,7 +5321,7 @@ async function executeParallel(engine, params) {
     timeTravel,
     executionContext,
     tracingContext,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     outputWriter,
@@ -5144,7 +5394,7 @@ async function executeParallel(engine, params) {
         tracingContext: {
           currentSpan: parallelSpan
         },
-        emitter,
+        pubsub,
         abortController,
         requestContext,
         outputWriter,
@@ -5183,9 +5433,7 @@ async function executeParallel(engine, params) {
     };
   }
   if (execResults.status === "failed") {
-    parallelSpan?.error({
-      error: new Error(execResults.error)
-    });
+    parallelSpan?.error({ error: execResults.error });
   } else {
     parallelSpan?.end({
       output: execResults.output || execResults
@@ -5207,7 +5455,7 @@ async function executeConditional(engine, params) {
     timeTravel,
     executionContext,
     tracingContext,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     outputWriter,
@@ -5254,7 +5502,7 @@ async function executeConditional(engine, params) {
           abort: () => {
             abortController?.abort();
           },
-          [EMITTER_SYMBOL]: emitter,
+          [PUBSUB_SYMBOL]: pubsub,
           [STREAM_FORMAT_SYMBOL]: executionContext.format,
           engine: engine.getEngineContext(),
           abortSignal: abortController?.signal,
@@ -5284,18 +5532,20 @@ async function executeConditional(engine, params) {
         });
         return result;
       } catch (e) {
-        const error = engine.preprocessExecutionError(
-          e,
+        const errorInstance = getErrorFromUnknown(e, { serializeStack: false });
+        const mastraError = new MastraError(
           {
             id: "WORKFLOW_CONDITION_EVALUATION_FAILED",
-            domain: "MASTRA_WORKFLOW",
-            category: "USER",
+            domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+            category: "USER" /* USER */,
             details: { workflowId, runId }
           },
-          "Error evaluating condition: "
+          errorInstance
         );
+        engine.getLogger()?.trackException(mastraError);
+        engine.getLogger()?.error("Error evaluating condition: " + errorInstance.stack);
         evalSpan?.error({
-          error,
+          error: mastraError,
           attributes: {
             result: false
           }
@@ -5347,7 +5597,7 @@ async function executeConditional(engine, params) {
         tracingContext: {
           currentSpan: conditionalSpan
         },
-        emitter,
+        pubsub,
         abortController,
         requestContext,
         outputWriter,
@@ -5387,9 +5637,7 @@ async function executeConditional(engine, params) {
     };
   }
   if (execResults.status === "failed") {
-    conditionalSpan?.error({
-      error: new Error(execResults.error)
-    });
+    conditionalSpan?.error({ error: execResults.error });
   } else {
     conditionalSpan?.end({
       output: execResults.output || execResults
@@ -5410,7 +5658,7 @@ async function executeLoop(engine, params) {
     timeTravel,
     executionContext,
     tracingContext,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     outputWriter,
@@ -5450,7 +5698,7 @@ async function executeLoop(engine, params) {
       tracingContext: {
         currentSpan: loopSpan
       },
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5504,7 +5752,7 @@ async function executeLoop(engine, params) {
           abort: () => {
             abortController?.abort();
           },
-          [EMITTER_SYMBOL]: emitter,
+          [PUBSUB_SYMBOL]: pubsub,
           [STREAM_FORMAT_SYMBOL]: executionContext.format,
           engine: engine.getEngineContext(),
           abortSignal: abortController?.signal,
@@ -5551,7 +5799,7 @@ async function executeForeach(engine, params) {
     timeTravel,
     executionContext,
     tracingContext,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     outputWriter,
@@ -5579,12 +5827,16 @@ async function executeForeach(engine, params) {
     },
     tracingPolicy: engine.options?.tracingPolicy
   });
-  await emitter.emit("watch", {
-    type: "workflow-step-start",
-    payload: {
-      id: step.id,
-      ...stepInfo,
-      status: "running"
+  await pubsub.publish(`workflow.events.v2.${runId}`, {
+    type: "watch",
+    runId,
+    data: {
+      type: "workflow-step-start",
+      payload: {
+        id: step.id,
+        ...stepInfo,
+        status: "running"
+      }
     }
   });
   const prevPayload = stepResults[step.id];
@@ -5623,7 +5875,7 @@ async function executeForeach(engine, params) {
           resume: resumeToUse,
           prevOutput: item,
           tracingContext: { currentSpan: loopSpan },
-          emitter,
+          pubsub,
           abortController,
           requestContext,
           skipEmits: true,
@@ -5643,18 +5895,26 @@ async function executeForeach(engine, params) {
         if (execResults.status === "suspended") {
           foreachIndexObj[i + resultIndex] = execResults;
         } else {
-          await emitter.emit("watch", {
-            type: "workflow-step-result",
-            payload: {
-              id: step.id,
-              ...execResults
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: {
+              type: "workflow-step-result",
+              payload: {
+                id: step.id,
+                ...execResults
+              }
             }
           });
-          await emitter.emit("watch", {
-            type: "workflow-step-finish",
-            payload: {
-              id: step.id,
-              metadata: {}
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: {
+              type: "workflow-step-finish",
+              payload: {
+                id: step.id,
+                metadata: {}
+              }
             }
           });
           return result;
@@ -5673,11 +5933,15 @@ async function executeForeach(engine, params) {
     if (Object.keys(foreachIndexObj).length > 0) {
       const suspendedIndices = Object.keys(foreachIndexObj).map(Number);
       const foreachIndex = suspendedIndices[0];
-      await emitter.emit("watch", {
-        type: "workflow-step-suspended",
-        payload: {
-          id: step.id,
-          ...foreachIndexObj[foreachIndex]
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-suspended",
+          payload: {
+            id: step.id,
+            ...foreachIndexObj[foreachIndex]
+          }
         }
       });
       executionContext.suspendedPaths[step.id] = executionContext.executionPath;
@@ -5699,20 +5963,28 @@ async function executeForeach(engine, params) {
       };
     }
   }
-  await emitter.emit("watch", {
-    type: "workflow-step-result",
-    payload: {
-      id: step.id,
-      status: "success",
-      output: results,
-      endedAt: Date.now()
+  await pubsub.publish(`workflow.events.v2.${runId}`, {
+    type: "watch",
+    runId,
+    data: {
+      type: "workflow-step-result",
+      payload: {
+        id: step.id,
+        status: "success",
+        output: results,
+        endedAt: Date.now()
+      }
     }
   });
-  await emitter.emit("watch", {
-    type: "workflow-step-finish",
-    payload: {
-      id: step.id,
-      metadata: {}
+  await pubsub.publish(`workflow.events.v2.${runId}`, {
+    type: "watch",
+    runId,
+    data: {
+      type: "workflow-step-finish",
+      payload: {
+        id: step.id,
+        metadata: {}
+      }
     }
   });
   loopSpan?.end({
@@ -5789,7 +6061,7 @@ async function executeEntry(engine, params) {
     resume,
     executionContext,
     tracingContext,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     outputWriter,
@@ -5812,7 +6084,7 @@ async function executeEntry(engine, params) {
       resume,
       prevOutput,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5845,7 +6117,7 @@ async function executeEntry(engine, params) {
         state: executionContext.state
       },
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5915,7 +6187,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5934,7 +6206,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5953,7 +6225,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5973,7 +6245,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter,
@@ -5984,13 +6256,17 @@ async function executeEntry(engine, params) {
     const startedAt = Date.now();
     const sleepWaitingOperationId = `workflow.${workflowId}.run.${runId}.sleep.${entry.id}.waiting_ev`;
     await engine.wrapDurableOperation(sleepWaitingOperationId, async () => {
-      await emitter.emit("watch", {
-        type: "workflow-step-waiting",
-        payload: {
-          id: entry.id,
-          payload: prevOutput,
-          startedAt,
-          status: "waiting"
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-waiting",
+          payload: {
+            id: entry.id,
+            payload: prevOutput,
+            startedAt,
+            status: "waiting"
+          }
         }
       });
     });
@@ -6021,7 +6297,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter
@@ -6047,20 +6323,28 @@ async function executeEntry(engine, params) {
     stepResults[entry.id] = { ...stepInfo, status: "success", output: prevOutput };
     const sleepResultOperationId = `workflow.${workflowId}.run.${runId}.sleep.${entry.id}.result_ev`;
     await engine.wrapDurableOperation(sleepResultOperationId, async () => {
-      await emitter.emit("watch", {
-        type: "workflow-step-result",
-        payload: {
-          id: entry.id,
-          endedAt,
-          status: "success",
-          output: prevOutput
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-result",
+          payload: {
+            id: entry.id,
+            endedAt,
+            status: "success",
+            output: prevOutput
+          }
         }
       });
-      await emitter.emit("watch", {
-        type: "workflow-step-finish",
-        payload: {
-          id: entry.id,
-          metadata: {}
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-finish",
+          payload: {
+            id: entry.id,
+            metadata: {}
+          }
         }
       });
     });
@@ -6068,13 +6352,17 @@ async function executeEntry(engine, params) {
     const startedAt = Date.now();
     const sleepUntilWaitingOperationId = `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.waiting_ev`;
     await engine.wrapDurableOperation(sleepUntilWaitingOperationId, async () => {
-      await emitter.emit("watch", {
-        type: "workflow-step-waiting",
-        payload: {
-          id: entry.id,
-          payload: prevOutput,
-          startedAt,
-          status: "waiting"
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-waiting",
+          payload: {
+            id: entry.id,
+            payload: prevOutput,
+            startedAt,
+            status: "waiting"
+          }
         }
       });
     });
@@ -6105,7 +6393,7 @@ async function executeEntry(engine, params) {
       resume,
       executionContext,
       tracingContext,
-      emitter,
+      pubsub,
       abortController,
       requestContext,
       outputWriter
@@ -6131,20 +6419,28 @@ async function executeEntry(engine, params) {
     stepResults[entry.id] = { ...stepInfo, status: "success", output: prevOutput };
     const sleepUntilResultOperationId = `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.result_ev`;
     await engine.wrapDurableOperation(sleepUntilResultOperationId, async () => {
-      await emitter.emit("watch", {
-        type: "workflow-step-result",
-        payload: {
-          id: entry.id,
-          endedAt,
-          status: "success",
-          output: prevOutput
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-result",
+          payload: {
+            id: entry.id,
+            endedAt,
+            status: "success",
+            output: prevOutput
+          }
         }
       });
-      await emitter.emit("watch", {
-        type: "workflow-step-finish",
-        payload: {
-          id: entry.id,
-          metadata: {}
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: {
+          type: "workflow-step-finish",
+          payload: {
+            id: entry.id,
+            metadata: {}
+          }
         }
       });
     });
@@ -6166,9 +6462,10 @@ async function executeEntry(engine, params) {
     requestContext
   });
   if (execResults.status === "canceled") {
-    await emitter.emit("watch", {
-      type: "workflow-canceled",
-      payload: {}
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "workflow-canceled", payload: {} }
     });
   }
   return {
@@ -6185,7 +6482,7 @@ async function executeSleep(engine, params) {
     entry,
     prevOutput,
     stepResults,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     executionContext,
@@ -6229,7 +6526,7 @@ async function executeSleep(engine, params) {
         abort: () => {
           abortController?.abort();
         },
-        [EMITTER_SYMBOL]: emitter,
+        [PUBSUB_SYMBOL]: pubsub,
         [STREAM_FORMAT_SYMBOL]: executionContext.format,
         engine: engine.getEngineContext(),
         abortSignal: abortController?.signal,
@@ -6265,7 +6562,7 @@ async function executeSleepUntil(engine, params) {
     entry,
     prevOutput,
     stepResults,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     executionContext,
@@ -6310,7 +6607,7 @@ async function executeSleepUntil(engine, params) {
         abort: () => {
           abortController?.abort();
         },
-        [EMITTER_SYMBOL]: emitter,
+        [PUBSUB_SYMBOL]: pubsub,
         [STREAM_FORMAT_SYMBOL]: executionContext.format,
         engine: engine.getEngineContext(),
         abortSignal: abortController?.signal,
@@ -6357,7 +6654,7 @@ async function executeStep(engine, params) {
     resume,
     timeTravel,
     prevOutput,
-    emitter,
+    pubsub,
     abortController,
     requestContext,
     skipEmits = false,
@@ -6417,7 +6714,7 @@ async function executeStep(engine, params) {
   await engine.onStepExecutionStart({
     step,
     inputData,
-    emitter,
+    pubsub,
     executionContext,
     stepCallId,
     stepInfo,
@@ -6446,7 +6743,7 @@ async function executeStep(engine, params) {
       timeTravel,
       prevOutput,
       inputData,
-      emitter,
+      pubsub,
       startedAt: startTime ?? Date.now(),
       abortController,
       requestContext,
@@ -6568,7 +6865,7 @@ async function executeStep(engine, params) {
           nestedStepResults: timeTravel?.nestedStepResults,
           resumeData: timeTravel?.resumeData
         } : void 0,
-        [EMITTER_SYMBOL]: emitter,
+        [PUBSUB_SYMBOL]: pubsub,
         [STREAM_FORMAT_SYMBOL]: executionContext.format,
         engine: engine.getEngineContext(),
         abortSignal: abortController?.signal,
@@ -6640,7 +6937,8 @@ async function executeStep(engine, params) {
         stepId: step.id,
         stepCallId,
         execResults: { ...stepInfo, ...execResults },
-        emitter
+        pubsub,
+        runId
       });
     });
   }
@@ -6671,9 +6969,9 @@ async function runScorersForStep(params) {
       scorersToUse = await scorersToUse({
         requestContext
       });
-    } catch (error) {
-      engine.preprocessExecutionError(
-        error,
+    } catch (e) {
+      const errorInstance = getErrorFromUnknown(e, { serializeStack: false });
+      const mastraError = new MastraError(
         {
           id: "WORKFLOW_FAILED_TO_FETCH_SCORERS",
           domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
@@ -6684,8 +6982,10 @@ async function runScorersForStep(params) {
             stepId
           }
         },
-        "Error fetching scorers: "
+        errorInstance
       );
+      engine.getLogger()?.trackException(mastraError);
+      engine.getLogger()?.error("Error fetching scorers: " + errorInstance?.stack);
     }
   }
   if (!disableScorers && scorersToUse && Object.keys(scorersToUse || {}).length > 0) {
@@ -6710,42 +7010,30 @@ async function runScorersForStep(params) {
   }
 }
 async function emitStepResultEvents(params) {
-  const { stepId, stepCallId, execResults, emitter } = params;
+  const { stepId, stepCallId, execResults, pubsub, runId } = params;
   const payloadBase = stepCallId ? { id: stepId, stepCallId } : { id: stepId };
   if (execResults.status === "suspended") {
-    await emitter.emit("watch", {
-      type: "workflow-step-suspended",
-      payload: { ...payloadBase, ...execResults }
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "workflow-step-suspended", payload: { ...payloadBase, ...execResults } }
     });
   } else {
-    await emitter.emit("watch", {
-      type: "workflow-step-result",
-      payload: { ...payloadBase, ...execResults }
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "workflow-step-result", payload: { ...payloadBase, ...execResults } }
     });
-    await emitter.emit("watch", {
-      type: "workflow-step-finish",
-      payload: { ...payloadBase, metadata: {} }
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "workflow-step-finish", payload: { ...payloadBase, metadata: {} } }
     });
   }
 }
 
 // src/workflows/default.ts
 var DefaultExecutionEngine = class extends ExecutionEngine {
-  /**
-   * Preprocesses an error caught during workflow execution.
-   *
-   * - Wraps a non-MastraError exception
-   * - Logs error details
-   */
-  preprocessExecutionError(e, errorDefinition, logPrefix) {
-    const error = e instanceof MastraError ? e : new MastraError(errorDefinition, e);
-    if (!(e instanceof MastraError) && e instanceof Error && e.stack) {
-      error.stack = e.stack;
-    }
-    this.logger?.trackException(error);
-    this.logger?.error(logPrefix + error?.stack);
-    return error;
-  }
   /**
    * The retryCounts map is used to keep track of the retry count for each step.
    * The step id is used as the key and the retry count is the value.
@@ -6852,12 +7140,16 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     return this.wrapDurableOperation(params.operationId, async () => {
       const startedAt = Date.now();
       if (!params.skipEmits) {
-        await params.emitter.emit("watch", {
-          type: "workflow-step-start",
-          payload: {
-            id: params.step.id,
-            stepCallId: params.stepCallId,
-            ...params.stepInfo
+        await params.pubsub.publish(`workflow.events.v2.${params.executionContext.runId}`, {
+          type: "watch",
+          runId: params.executionContext.runId,
+          data: {
+            type: "workflow-step-start",
+            payload: {
+              id: params.step.id,
+              stepCallId: params.stepCallId,
+              ...params.stepInfo
+            }
           }
         });
       }
@@ -6897,29 +7189,30 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         return { ok: true, result };
       } catch (e) {
         if (i === params.retries) {
-          const processedError = this.preprocessExecutionError(
-            e,
+          const errorInstance = getErrorFromUnknown(e, {
+            serializeStack: false,
+            fallbackMessage: "Unknown step execution error"
+          });
+          const mastraError = new MastraError(
             {
               id: "WORKFLOW_STEP_INVOKE_FAILED",
               domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
               category: "USER" /* USER */,
               details: { workflowId: params.workflowId, runId: params.runId, stepId }
             },
-            `Error executing step ${stepId}: `
+            errorInstance
           );
+          this.logger?.trackException(mastraError);
+          this.logger?.error(`Error executing step ${stepId}: ` + errorInstance?.stack);
           params.stepSpan?.error({
-            error: processedError,
+            error: mastraError,
             attributes: { status: "failed" }
           });
-          const errorInstance = getErrorFromUnknown(processedError, {
-            includeStack: false,
-            fallbackMessage: "Unknown step execution error"
-          });
           return {
             ok: false,
             error: {
               status: "failed",
-              error: `Error: ${errorInstance.message}`,
+              error: errorInstance,
               endedAt: Date.now(),
               // Preserve TripWire data as plain object for proper serialization
               tripwire: e instanceof TripWire ? {
@@ -6933,7 +7226,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         }
       }
     }
-    return { ok: false, error: { status: "failed", error: "Unknown error", endedAt: Date.now() } };
+    return { ok: false, error: { status: "failed", error: new Error("Unknown error"), endedAt: Date.now() } };
   }
   /**
    * Format an error for the workflow result.
@@ -6943,12 +7236,12 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     const outputError = lastOutput?.error;
     const errorSource = error || outputError;
     const errorInstance = getErrorFromUnknown(errorSource, {
-      includeStack: false,
+      serializeStack: false,
       fallbackMessage: "Unknown workflow error"
     });
-    return typeof errorSource === "string" ? errorInstance.message : `Error: ${errorInstance.message}`;
+    return errorInstance.toJSON();
   }
-  async fmtReturnValue(emitter, stepResults, lastOutput, error) {
+  async fmtReturnValue(_pubsub, stepResults, lastOutput, error) {
     const base = {
       status: lastOutput.status,
       steps: stepResults,
@@ -6973,14 +7266,18 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         base.error = this.formatResultError(error, lastOutput);
       }
     } else if (lastOutput.status === "suspended") {
+      const suspendPayload = {};
       const suspendedStepIds = Object.entries(stepResults).flatMap(([stepId, stepResult]) => {
         if (stepResult?.status === "suspended") {
-          const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
+          const { __workflow_meta, ...rest } = stepResult?.suspendPayload ?? {};
+          suspendPayload[stepId] = rest;
+          const nestedPath = __workflow_meta?.path;
           return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
         }
         return [];
       });
       base.suspended = suspendedStepIds;
+      base.suspendPayload = suspendPayload;
     }
     return base;
   }
@@ -7112,7 +7409,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           currentSpan: workflowSpan
         },
         abortController: params.abortController,
-        emitter: params.emitter,
+        pubsub: params.pubsub,
         requestContext: currentRequestContext,
         outputWriter: params.outputWriter,
         disableScorers
@@ -7126,7 +7423,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         if (lastOutput.result.status === "bailed") {
           lastOutput.result.status = "success";
         }
-        const result2 = await this.fmtReturnValue(params.emitter, stepResults, lastOutput.result);
+        const result2 = await this.fmtReturnValue(params.pubsub, stepResults, lastOutput.result);
         await this.persistStepUpdate({
           workflowId,
           runId,
@@ -7154,6 +7451,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
             }
           });
         }
+        await this.invokeLifecycleCallbacks(result2);
         return {
           ...result2,
           ...lastOutput.result.status === "suspended" && params.outputOptions?.includeResumeLabels ? { resumeLabels: lastOutput.mutableContext.resumeLabels } : {},
@@ -7161,7 +7459,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         };
       }
     }
-    const result = await this.fmtReturnValue(params.emitter, stepResults, lastOutput.result);
+    const result = await this.fmtReturnValue(params.pubsub, stepResults, lastOutput.result);
     await this.persistStepUpdate({
       workflowId,
       runId,
@@ -7180,6 +7478,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         status: result.status
       }
     });
+    await this.invokeLifecycleCallbacks(result);
     if (params.outputOptions?.includeState) {
       return { ...result, state: lastState };
     }
@@ -7255,7 +7554,8 @@ function createStep(params, agentOptions) {
       outputSchema,
       execute: async ({
         inputData,
-        [EMITTER_SYMBOL]: emitter,
+        runId,
+        [PUBSUB_SYMBOL]: pubsub,
         [STREAM_FORMAT_SYMBOL]: streamFormat,
         requestContext,
         tracingContext,
@@ -7311,9 +7611,10 @@ function createStep(params, agentOptions) {
         }
         let tripwireChunk = null;
         if (streamFormat === "legacy") {
-          await emitter.emit("watch", {
-            type: "tool-call-streaming-start",
-            ...toolData ?? {}
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: { type: "tool-call-streaming-start", ...toolData ?? {} }
           });
           for await (const chunk of stream) {
             if (chunk.type === "tripwire") {
@@ -7321,16 +7622,17 @@ function createStep(params, agentOptions) {
               break;
             }
             if (chunk.type === "text-delta") {
-              await emitter.emit("watch", {
-                type: "tool-call-delta",
-                ...toolData ?? {},
-                argsTextDelta: chunk.textDelta
+              await pubsub.publish(`workflow.events.v2.${runId}`, {
+                type: "watch",
+                runId,
+                data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
               });
             }
           }
-          await emitter.emit("watch", {
-            type: "tool-call-streaming-finish",
-            ...toolData ?? {}
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
           });
         } else {
           for await (const chunk of stream) {
@@ -7840,7 +8142,9 @@ var Workflow = class extends MastraBase {
     this.#options = {
       validateInputs: options.validateInputs ?? true,
       shouldPersistSnapshot: options.shouldPersistSnapshot ?? (() => true),
-      tracingPolicy: options.tracingPolicy
+      tracingPolicy: options.tracingPolicy,
+      onFinish: options.onFinish,
+      onError: options.onError
     };
     if (!executionEngine) {
       this.executionEngine = new DefaultExecutionEngine({
@@ -7960,7 +8264,7 @@ var Workflow = class extends MastraBase {
         type: "step",
         step: {
           id: mappingStep2.id,
-          mapConfig: mappingConfig.toString()
+          mapConfig: mappingConfig.toString()?.length > 1e3 ? mappingConfig.toString().slice(0, 1e3) + "...\n}" : mappingConfig.toString()
         }
       });
       return this;
@@ -8032,7 +8336,7 @@ var Workflow = class extends MastraBase {
       type: "step",
       step: {
         id: mappingStep.id,
-        mapConfig: JSON.stringify(newMappingConfig, null, 2)
+        mapConfig: JSON.stringify(newMappingConfig, null, 2)?.length > 1e3 ? JSON.stringify(newMappingConfig, null, 2).slice(0, 1e3) + "...\n}" : JSON.stringify(newMappingConfig, null, 2)
       }
     });
     return this;
@@ -8219,7 +8523,9 @@ var Workflow = class extends MastraBase {
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, {
+      withNestedWorkflows: false
+    });
     if (workflowSnapshotInStorage && workflowSnapshotInStorage.status) {
       run.workflowRunStatus = workflowSnapshotInStorage.status;
     }
@@ -8281,7 +8587,7 @@ var Workflow = class extends MastraBase {
     restart,
     resume,
     timeTravel,
-    [EMITTER_SYMBOL]: emitter,
+    [PUBSUB_SYMBOL]: pubsub,
     mastra,
     requestContext,
     abort,
@@ -8316,7 +8622,11 @@ var Workflow = class extends MastraBase {
       await run.cancel();
     });
     const unwatch = run.watch((event) => {
-      emitter.emit("nested-watch", { event, workflowId: this.id });
+      void pubsub.publish("nested-watch", {
+        type: "nested-watch",
+        runId: run.runId,
+        data: { event, workflowId: this.id }
+      });
     });
     if (retryCount && retryCount > 0 && isResume && requestContext) {
       requestContext.set("__mastraWorflowInputData", inputData);
@@ -8480,7 +8790,8 @@ var Workflow = class extends MastraBase {
     }
     return finalSteps;
   }
-  async getWorkflowRunExecutionResult(runId, withNestedWorkflows = true) {
+  async getWorkflowRunExecutionResult(runId, options = {}) {
+    const { withNestedWorkflows = true, fields } = options;
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug("Cannot get workflow run execution result. Mastra storage is not initialized");
@@ -8499,21 +8810,57 @@ var Workflow = class extends MastraBase {
         return null;
       }
     }
-    const fullSteps = withNestedWorkflows ? await this.getWorkflowRunSteps({ runId, workflowId: this.id }) : snapshot.context;
+    const snapshotState = snapshot;
+    const defaultResult = {
+      status: snapshotState.status,
+      result: snapshotState.result,
+      error: snapshotState.error,
+      payload: snapshotState.context?.input,
+      steps: null,
+      // Will be populated below
+      activeStepsPath: snapshotState.activeStepsPath,
+      serializedStepGraph: snapshotState.serializedStepGraph
+    };
+    const allowedFields = new Set(Object.keys(defaultResult));
+    if (fields && fields.length > 0) {
+      const result = {};
+      for (const field of fields) {
+        if (!allowedFields.has(field)) {
+          continue;
+        }
+        if (field === "steps") {
+          let fullSteps2;
+          if (withNestedWorkflows) {
+            fullSteps2 = await this.getWorkflowRunSteps({ runId, workflowId: this.id });
+          } else {
+            const { input, ...stepsOnly } = snapshotState.context || {};
+            fullSteps2 = stepsOnly;
+          }
+          result.steps = fullSteps2;
+        } else if (field === "payload") {
+          result.payload = snapshotState.context?.input;
+        } else {
+          result[field] = snapshotState[field];
+        }
+      }
+      return result;
+    }
+    let fullSteps;
+    if (withNestedWorkflows) {
+      fullSteps = await this.getWorkflowRunSteps({ runId, workflowId: this.id });
+    } else {
+      const { input, ...stepsOnly } = snapshotState.context || {};
+      fullSteps = stepsOnly;
+    }
     return {
-      status: snapshot.status,
-      result: snapshot.result,
-      error: snapshot.error,
-      payload: snapshot.context?.input,
-      steps: fullSteps,
-      activeStepsPath: snapshot.activeStepsPath,
-      serializedStepGraph: snapshot.serializedStepGraph
+      ...defaultResult,
+      steps: fullSteps
     };
   }
 };
 var Run = class {
   #abortController;
-  emitter;
+  pubsub;
   /**
    * Unique identifier for this workflow
    */
@@ -8583,7 +8930,7 @@ var Run = class {
     this.executionEngine = params.executionEngine;
     this.executionGraph = params.executionGraph;
     this.#mastra = params.mastra;
-    this.emitter = new EventEmitter2();
+    this.pubsub = new EventEmitterPubSub();
     this.retryConfig = params.retryConfig;
     this.cleanup = params.cleanup;
     this.disableScorers = params.disableScorers;
@@ -8602,10 +8949,22 @@ var Run = class {
     return this.#abortController;
   }
   /**
-   * Cancels the workflow execution
+   * Cancels the workflow execution.
+   * This aborts any running execution and updates the workflow status to 'canceled' in storage.
    */
   async cancel() {
-    this.abortController?.abort();
+    this.abortController.abort();
+    this.workflowRunStatus = "canceled";
+    try {
+      await this.mastra?.getStorage()?.updateWorkflowState({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        opts: {
+          status: "canceled"
+        }
+      });
+    } catch {
+    }
   }
   async _validateInput(inputData) {
     let inputDataToUse = inputData;
@@ -8706,20 +9065,7 @@ var Run = class {
       serializedStepGraph: this.serializedStepGraph,
       input: inputDataToUse,
       initialState: initialStateToUse,
-      emitter: {
-        emit: async (event, data) => {
-          this.emitter.emit(event, data);
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.pubsub,
       retryConfig: this.retryConfig,
       requestContext: requestContext ?? new RequestContext(),
       abortController: this.abortController,
@@ -8742,6 +9088,19 @@ var Run = class {
   async start(args) {
     return this._start(args);
   }
+  /**
+   * Starts the workflow execution without waiting for completion (fire-and-forget).
+   * Returns immediately with the runId. The workflow executes in the background.
+   * Use this when you don't need to wait for the result or want to avoid polling failures.
+   * @param args The input data and configuration for the workflow
+   * @returns A promise that resolves immediately with the runId
+   */
+  async startAsync(args) {
+    this._start(args).catch((err) => {
+      console.error(`[Workflow ${this.workflowId}] Background execution failed:`, err);
+    });
+    return { runId: this.runId };
+  }
   /**
    * Starts the workflow execution with the provided input as a stream
    * @param input The input data for the workflow
@@ -8776,9 +9135,10 @@ var Run = class {
       }
     });
     this.closeStreamAction = async () => {
-      this.emitter.emit("watch", {
-        type: "workflow-finish",
-        payload: { runId: this.runId }
+      await this.pubsub.publish(`workflow.events.v2.${this.runId}`, {
+        type: "watch",
+        runId: this.runId,
+        data: { type: "workflow-finish", payload: { runId: this.runId } }
       });
       unwatch();
       await Promise.all(this.#observerHandlers.map((handler) => handler()));
@@ -8791,9 +9151,10 @@ var Run = class {
         writer.releaseLock();
       }
     };
-    this.emitter.emit("watch", {
-      type: "workflow-start",
-      payload: { runId: this.runId }
+    void this.pubsub.publish(`workflow.events.v2.${this.runId}`, {
+      type: "watch",
+      runId: this.runId,
+      data: { type: "workflow-start", payload: { runId: this.runId } }
     });
     this.executionResults = this._start({
       inputData,
@@ -8929,7 +9290,9 @@ var Run = class {
         self.closeStreamAction = async () => {
           unwatch();
           try {
-            await controller.close();
+            if (controller.desiredSize !== null) {
+              controller.close();
+            }
           } catch (err) {
             console.error("Error closing stream:", err);
           }
@@ -8942,7 +9305,11 @@ var Run = class {
           initialState,
           outputOptions,
           outputWriter: async (chunk) => {
-            void self.emitter.emit("watch", chunk);
+            void self.pubsub.publish(`workflow.events.v2.${self.runId}`, {
+              type: "watch",
+              runId: self.runId,
+              data: chunk
+            });
           }
         });
         let executionResults;
@@ -9040,7 +9407,9 @@ var Run = class {
         self.closeStreamAction = async () => {
           unwatch();
           try {
-            await controller.close();
+            if (controller.desiredSize !== null) {
+              controller.close();
+            }
           } catch (err) {
             console.error("Error closing stream:", err);
           }
@@ -9085,20 +9454,29 @@ var Run = class {
    * @internal
    */
   watch(cb) {
-    const nestedWatchCb = ({
-      event,
-      workflowId
-    }) => {
-      this.emitter.emit("watch", {
-        ...event,
-        ...event.payload?.id ? { payload: { ...event.payload, id: `${workflowId}.${event.payload.id}` } } : {}
-      });
+    const wrappedCb = (event) => {
+      if (event.runId === this.runId) {
+        cb(event.data);
+      }
     };
-    this.emitter.on("watch", cb);
-    this.emitter.on("nested-watch", nestedWatchCb);
+    const nestedWatchCb = (event) => {
+      if (event.runId === this.runId) {
+        const { event: nestedEvent, workflowId } = event.data;
+        void this.pubsub.publish(`workflow.events.v2.${this.runId}`, {
+          type: "watch",
+          runId: this.runId,
+          data: {
+            ...nestedEvent,
+            ...nestedEvent.payload?.id ? { payload: { ...nestedEvent.payload, id: `${workflowId}.${nestedEvent.payload.id}` } } : {}
+          }
+        });
+      }
+    };
+    void this.pubsub.subscribe(`workflow.events.v2.${this.runId}`, wrappedCb);
+    void this.pubsub.subscribe("nested-watch", nestedWatchCb);
     return () => {
-      this.emitter.off("watch", cb);
-      this.emitter.off("nested-watch", nestedWatchCb);
+      void this.pubsub.unsubscribe(`workflow.events.v2.${this.runId}`, wrappedCb);
+      void this.pubsub.unsubscribe("nested-watch", nestedWatchCb);
     };
   }
   /**
@@ -9226,21 +9604,7 @@ var Run = class {
         label: params.label
       },
       format: params.format,
-      emitter: {
-        emit: (event, data) => {
-          this.emitter.emit(event, data);
-          return Promise.resolve();
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.pubsub,
       requestContext: requestContextToUse,
       abortController: this.abortController,
       workflowSpan,
@@ -9340,20 +9704,7 @@ var Run = class {
       graph: this.executionGraph,
       serializedStepGraph: this.serializedStepGraph,
       restart: restartData,
-      emitter: {
-        emit: async (event, data) => {
-          this.emitter.emit(event, data);
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.pubsub,
       retryConfig: this.retryConfig,
       requestContext: requestContextToUse,
       abortController: this.abortController,
@@ -9446,20 +9797,7 @@ var Run = class {
       graph: this.executionGraph,
       timeTravel: timeTravelData,
       serializedStepGraph: this.serializedStepGraph,
-      emitter: {
-        emit: async (event, data) => {
-          this.emitter.emit(event, data);
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.pubsub,
       retryConfig: this.retryConfig,
       requestContext: requestContextToUse,
       abortController: this.abortController,
@@ -9507,7 +9845,9 @@ var Run = class {
         self.closeStreamAction = async () => {
           unwatch();
           try {
-            await controller.close();
+            if (controller.desiredSize !== null) {
+              controller.close();
+            }
           } catch (err) {
             console.error("Error closing stream:", err);
           }
@@ -9558,80 +9898,80 @@ var Run = class {
     return this.executionResults ?? this.streamOutput?.result;
   }
 };
-var languageModelUsageSchema = z7.object({
-  inputTokens: z7.number(),
-  outputTokens: z7.number(),
-  totalTokens: z7.number(),
-  reasoningTokens: z7.number().optional(),
-  cachedInputTokens: z7.number().optional()
+var languageModelUsageSchema = z8.object({
+  inputTokens: z8.number(),
+  outputTokens: z8.number(),
+  totalTokens: z8.number(),
+  reasoningTokens: z8.number().optional(),
+  cachedInputTokens: z8.number().optional()
 });
-var llmIterationStepResultSchema = z7.object({
-  reason: z7.string(),
-  warnings: z7.array(z7.any()),
-  isContinued: z7.boolean(),
-  logprobs: z7.any().optional(),
+var llmIterationStepResultSchema = z8.object({
+  reason: z8.string(),
+  warnings: z8.array(z8.any()),
+  isContinued: z8.boolean(),
+  logprobs: z8.any().optional(),
   totalUsage: languageModelUsageSchema.optional(),
-  headers: z7.record(z7.string()).optional(),
-  messageId: z7.string().optional(),
-  request: z7.record(z7.any()).optional()
+  headers: z8.record(z8.string()).optional(),
+  messageId: z8.string().optional(),
+  request: z8.record(z8.any()).optional()
 });
-var llmIterationOutputSchema = z7.object({
-  messageId: z7.string(),
-  messages: z7.object({
-    all: z7.array(z7.any()),
+var llmIterationOutputSchema = z8.object({
+  messageId: z8.string(),
+  messages: z8.object({
+    all: z8.array(z8.any()),
     // ModelMessage[] but too complex to validate at runtime
-    user: z7.array(z7.any()),
-    nonUser: z7.array(z7.any())
+    user: z8.array(z8.any()),
+    nonUser: z8.array(z8.any())
   }),
-  output: z7.object({
-    text: z7.string().optional(),
-    reasoning: z7.array(z7.any()).optional(),
-    reasoningText: z7.string().optional(),
-    files: z7.array(z7.any()).optional(),
+  output: z8.object({
+    text: z8.string().optional(),
+    reasoning: z8.array(z8.any()).optional(),
+    reasoningText: z8.string().optional(),
+    files: z8.array(z8.any()).optional(),
     // GeneratedFile[]
-    toolCalls: z7.array(z7.any()).optional(),
+    toolCalls: z8.array(z8.any()).optional(),
     // TypedToolCall[]
-    toolResults: z7.array(z7.any()).optional(),
+    toolResults: z8.array(z8.any()).optional(),
     // TypedToolResult[]
-    sources: z7.array(z7.any()).optional(),
+    sources: z8.array(z8.any()).optional(),
     // LanguageModelV2Source[]
-    staticToolCalls: z7.array(z7.any()).optional(),
-    dynamicToolCalls: z7.array(z7.any()).optional(),
-    staticToolResults: z7.array(z7.any()).optional(),
-    dynamicToolResults: z7.array(z7.any()).optional(),
+    staticToolCalls: z8.array(z8.any()).optional(),
+    dynamicToolCalls: z8.array(z8.any()).optional(),
+    staticToolResults: z8.array(z8.any()).optional(),
+    dynamicToolResults: z8.array(z8.any()).optional(),
     usage: languageModelUsageSchema,
-    steps: z7.array(z7.any())
+    steps: z8.array(z8.any())
     // StepResult[]
   }),
-  metadata: z7.object({
-    id: z7.string().optional(),
-    model: z7.string().optional(),
-    modelId: z7.string().optional(),
-    modelMetadata: z7.object({
-      modelId: z7.string(),
-      modelVersion: z7.string(),
-      modelProvider: z7.string()
+  metadata: z8.object({
+    id: z8.string().optional(),
+    model: z8.string().optional(),
+    modelId: z8.string().optional(),
+    modelMetadata: z8.object({
+      modelId: z8.string(),
+      modelVersion: z8.string(),
+      modelProvider: z8.string()
     }).optional(),
-    timestamp: z7.date().optional(),
-    providerMetadata: z7.record(z7.any()).optional(),
-    headers: z7.record(z7.string()).optional(),
-    request: z7.record(z7.any()).optional()
+    timestamp: z8.date().optional(),
+    providerMetadata: z8.record(z8.any()).optional(),
+    headers: z8.record(z8.string()).optional(),
+    request: z8.record(z8.any()).optional()
   }),
   stepResult: llmIterationStepResultSchema,
-  processorRetryCount: z7.number().optional(),
-  processorRetryFeedback: z7.string().optional()
+  processorRetryCount: z8.number().optional(),
+  processorRetryFeedback: z8.string().optional()
 });
-var toolCallInputSchema = z7.object({
-  toolCallId: z7.string(),
-  toolName: z7.string(),
-  args: z7.record(z7.any()),
-  providerMetadata: z7.record(z7.any()).optional(),
-  providerExecuted: z7.boolean().optional(),
-  output: z7.any().optional()
+var toolCallInputSchema = z8.object({
+  toolCallId: z8.string(),
+  toolName: z8.string(),
+  args: z8.record(z8.any()),
+  providerMetadata: z8.record(z8.any()).optional(),
+  providerExecuted: z8.boolean().optional(),
+  output: z8.any().optional()
 });
 var toolCallOutputSchema = toolCallInputSchema.extend({
-  result: z7.any(),
-  error: z7.any().optional()
+  result: z8.any(),
+  error: z8.any().optional()
 });
 
 // src/processors/processors/prepare-step.ts
@@ -9684,10 +10024,10 @@ var AISDKV5InputStream = class extends MastraModelInput {
   constructor({
     component,
     name,
-    generateId: generateId3
+    generateId: generateId2
   }) {
     super({ component, name });
-    this.#generateId = generateId3 ?? generateId;
+    this.#generateId = generateId2 ?? generateId;
   }
   async transform({
     runId,
@@ -9739,12 +10079,12 @@ function execute({
   headers,
   shouldThrowError,
   methodType,
-  generateId: generateId3
+  generateId: generateId2
 }) {
   const v5 = new AISDKV5InputStream({
     component: "LLM",
     name: model.modelId,
-    generateId: generateId3
+    generateId: generateId2
   });
   const toolsAndToolChoice = prepareToolsAndToolChoice({
     tools,
@@ -10027,10 +10367,10 @@ async function processOutputStream({
         break;
       }
       case "tool-call-input-streaming-start": {
-        const tool = tools?.[chunk.payload.toolName] || Object.values(tools || {})?.find((tool2) => `id` in tool2 && tool2.id === chunk.payload.toolName);
-        if (tool && "onInputStart" in tool) {
+        const tool2 = tools?.[chunk.payload.toolName] || Object.values(tools || {})?.find((tool3) => `id` in tool3 && tool3.id === chunk.payload.toolName);
+        if (tool2 && "onInputStart" in tool2) {
           try {
-            await tool?.onInputStart?.({
+            await tool2?.onInputStart?.({
               toolCallId: chunk.payload.toolCallId,
               messages: messageList.get.input.aiV5.model(),
               abortSignal: options?.abortSignal
@@ -10045,10 +10385,10 @@ async function processOutputStream({
         break;
       }
       case "tool-call-delta": {
-        const tool = tools?.[chunk.payload.toolName || ""] || Object.values(tools || {})?.find((tool2) => `id` in tool2 && tool2.id === chunk.payload.toolName);
-        if (tool && "onInputDelta" in tool) {
+        const tool2 = tools?.[chunk.payload.toolName || ""] || Object.values(tools || {})?.find((tool3) => `id` in tool3 && tool3.id === chunk.payload.toolName);
+        if (tool2 && "onInputDelta" in tool2) {
           try {
-            await tool?.onInputDelta?.({
+            await tool2?.onInputDelta?.({
               inputTextDelta: chunk.payload.argsTextDelta,
               toolCallId: chunk.payload.toolCallId,
               messages: messageList.get.input.aiV5.model(),
@@ -10259,7 +10599,7 @@ function executeStreamWithFallbackModels(models) {
       while (attempt <= maxRetries) {
         try {
           const isLastModel = attempt === maxRetries && index === models.length;
-          const result = await callback(modelConfig.model, isLastModel);
+          const result = await callback(modelConfig, isLastModel);
           finalResult = result;
           done = true;
           break;
@@ -10301,13 +10641,13 @@ function createLLMExecutionStep({
   inputProcessors,
   logger,
   agentId,
-  headers,
   downloadRetries,
   downloadConcurrency,
   processorStates,
   requestContext,
   methodType,
   modelSpanTracker,
+  autoResumeSuspendedTools,
   maxProcessorRetries
 }) {
   const initialSystemMessages = messageList.getAllSystemMessages();
@@ -10320,7 +10660,9 @@ function createLLMExecutionStep({
       let warnings;
       let request;
       let rawResponse;
-      const { outputStream, callBail, runState, stepTools } = await executeStreamWithFallbackModels(models)(async (model, isLastModel) => {
+      const { outputStream, callBail, runState, stepTools } = await executeStreamWithFallbackModels(models)(async (modelConfig, isLastModel) => {
+        const model = modelConfig.model;
+        const modelHeaders = modelConfig.headers;
         if (initialSystemMessages) {
           messageList.replaceAllSystemMessages(initialSystemMessages);
         }
@@ -10378,57 +10720,83 @@ function createLLMExecutionStep({
           downloadConcurrency,
           supportedUrls: currentStep.model?.supportedUrls
         };
-        const inputMessages = await messageList.get.all.aiV5.llmPrompt(messageListPromptArgs);
-        switch (currentStep.model.specificationVersion) {
-          case "v2": {
-            modelResult = executeWithContextSync({
-              span: modelSpanTracker?.getTracingContext()?.currentSpan,
-              fn: () => execute({
-                runId,
-                model: currentStep.model,
-                providerOptions: currentStep.providerOptions,
-                inputMessages,
-                tools: currentStep.tools,
-                toolChoice: currentStep.toolChoice,
-                activeTools: currentStep.activeTools,
-                options,
-                modelSettings: currentStep.modelSettings,
-                includeRawChunks,
-                structuredOutput: currentStep.structuredOutput,
-                headers,
-                methodType,
-                generateId: _internal?.generateId,
-                onResult: ({
-                  warnings: warningsFromStream,
-                  request: requestFromStream,
-                  rawResponse: rawResponseFromStream
-                }) => {
-                  warnings = warningsFromStream;
-                  request = requestFromStream || {};
-                  rawResponse = rawResponseFromStream;
-                  if (!isControllerOpen(controller)) {
-                    return;
-                  }
-                  controller.enqueue({
-                    runId,
-                    from: "AGENT" /* AGENT */,
-                    type: "step-start",
-                    payload: {
-                      request: request || {},
-                      warnings: warnings || [],
-                      messageId
-                    }
-                  });
-                },
-                shouldThrowError: !isLastModel
-              })
-            });
-            break;
-          }
-          default: {
-            throw new Error(`Unsupported model version: ${model.specificationVersion}`);
+        let inputMessages = await messageList.get.all.aiV5.llmPrompt(messageListPromptArgs);
+        if (autoResumeSuspendedTools) {
+          const messages2 = messageList.get.all.db();
+          const assistantMessages = [...messages2].reverse().filter((message) => message.role === "assistant");
+          const suspendedToolsMessage = assistantMessages.find(
+            (message) => message.content.metadata?.suspendedTools || message.content.metadata?.pendingToolApprovals
+          );
+          if (suspendedToolsMessage) {
+            const metadata = suspendedToolsMessage.content.metadata;
+            const suspendedToolObj = metadata?.suspendedTools || metadata?.pendingToolApprovals;
+            const suspendedTools = Object.values(suspendedToolObj);
+            if (suspendedTools.length > 0) {
+              inputMessages = inputMessages.map((message, index) => {
+                if (message.role === "system" && index === 0) {
+                  message.content = message.content + `
+
+Analyse the suspended tools: ${JSON.stringify(suspendedTools)}, using the messages available to you and the resumeSchema of each suspended tool, find the tool whose resumeData you can construct properly.
+                      resumeData can not be an empty object nor null/undefined.
+                      When you find that and call that tool, add the resumeData to the tool call arguments/input.
+                      Also, add the runId of the suspended tool as suspendedToolRunId to the tool call arguments/input.
+                      If the suspendedTool.type is 'approval', resumeData will be an object that contains 'approved' which can either be true or false depending on the user's message.`;
+                }
+                return message;
+              });
+            }
           }
         }
+        if (isSupportedLanguageModel(currentStep.model)) {
+          modelResult = executeWithContextSync({
+            span: modelSpanTracker?.getTracingContext()?.currentSpan,
+            fn: () => execute({
+              runId,
+              model: currentStep.model,
+              providerOptions: currentStep.providerOptions,
+              inputMessages,
+              tools: currentStep.tools,
+              toolChoice: currentStep.toolChoice,
+              activeTools: currentStep.activeTools,
+              options,
+              modelSettings: currentStep.modelSettings,
+              includeRawChunks,
+              structuredOutput: currentStep.structuredOutput,
+              // Merge headers: modelConfig headers first, then modelSettings overrides them
+              // Only create object if there are actual headers to avoid passing empty {}
+              headers: modelHeaders || currentStep.modelSettings?.headers ? { ...modelHeaders, ...currentStep.modelSettings?.headers } : void 0,
+              methodType,
+              generateId: _internal?.generateId,
+              onResult: ({
+                warnings: warningsFromStream,
+                request: requestFromStream,
+                rawResponse: rawResponseFromStream
+              }) => {
+                warnings = warningsFromStream;
+                request = requestFromStream || {};
+                rawResponse = rawResponseFromStream;
+                if (!isControllerOpen(controller)) {
+                  return;
+                }
+                controller.enqueue({
+                  runId,
+                  from: "AGENT" /* AGENT */,
+                  type: "step-start",
+                  payload: {
+                    request: request || {},
+                    warnings: warnings || [],
+                    messageId
+                  }
+                });
+              },
+              shouldThrowError: !isLastModel
+            })
+          });
+        } else {
+          throw new Error(
+            `Unsupported model version: ${currentStep.model.specificationVersion}. Supported versions: ${supportedLanguageModelSpecifications.join(", ")}`
+          );
+        }
         const outputStream2 = new MastraModelOutput({
           model: {
             modelId: currentStep.model.modelId,
@@ -10739,11 +11107,11 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
   }
   return createStep({
     id: "llmExecutionMappingStep",
-    inputSchema: z7.array(toolCallOutputSchema),
+    inputSchema: z8.array(toolCallOutputSchema),
     outputSchema: llmIterationOutputSchema,
     execute: async ({ inputData, getStepResult: getStepResult2, bail }) => {
       const initialResult = getStepResult2(llmExecutionStep);
-      if (inputData?.every((toolCall) => toolCall?.result === void 0)) {
+      if (inputData?.some((toolCall) => toolCall?.result === void 0)) {
         const errorResults = inputData.filter((toolCall) => toolCall?.error);
         const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
         if (errorResults?.length) {
@@ -10788,7 +11156,14 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
         if (initialResult.stepResult.reason !== "retry") {
           initialResult.stepResult.isContinued = false;
         }
-        return bail(initialResult);
+        return bail({
+          ...initialResult,
+          messages: {
+            all: rest.messageList.get.all.aiV5.model(),
+            user: rest.messageList.get.input.aiV5.model(),
+            nonUser: rest.messageList.get.response.aiV5.model()
+          }
+        });
       }
       if (inputData?.length) {
         for (const toolCall of inputData) {
@@ -10846,11 +11221,10 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
           }
         };
       }
+      return initialResult;
     }
   });
 }
-
-// src/loop/workflows/agentic-execution/tool-call-step.ts
 function createToolCallStep({
   tools,
   messageList,
@@ -10866,28 +11240,39 @@ function createToolCallStep({
     id: "toolCallStep",
     inputSchema: toolCallInputSchema,
     outputSchema: toolCallOutputSchema,
-    execute: async ({ inputData, suspend, resumeData, requestContext }) => {
+    execute: async ({ inputData, suspend, resumeData: workflowResumeData, requestContext }) => {
       const stepTools = _internal?.stepTools || tools;
-      const tool = stepTools?.[inputData.toolName] || Object.values(stepTools || {})?.find((t) => `id` in t && t.id === inputData.toolName);
-      const addToolApprovalMetadata = (toolCallId, toolName, args) => {
+      const tool2 = stepTools?.[inputData.toolName] || Object.values(stepTools || {})?.find((t) => `id` in t && t.id === inputData.toolName);
+      const addToolMetadata = ({
+        toolCallId,
+        toolName,
+        args,
+        suspendPayload,
+        resumeSchema,
+        type
+      }) => {
+        const metadataKey = type === "suspension" ? "suspendedTools" : "pendingToolApprovals";
         const responseMessages = messageList.get.response.db();
         const lastAssistantMessage = [...responseMessages].reverse().find((msg) => msg.role === "assistant");
         if (lastAssistantMessage) {
           const content = lastAssistantMessage.content;
           if (!content) return;
           const metadata = typeof lastAssistantMessage.content.metadata === "object" && lastAssistantMessage.content.metadata !== null ? lastAssistantMessage.content.metadata : {};
-          metadata.pendingToolApprovals = metadata.pendingToolApprovals || {};
-          metadata.pendingToolApprovals[toolCallId] = {
+          metadata[metadataKey] = metadata[metadataKey] || {};
+          metadata[metadataKey][toolName] = {
+            toolCallId,
             toolName,
             args,
-            type: "approval",
-            runId
+            type,
+            runId,
             // Store the runId so we can resume after page refresh
+            ...type === "suspension" ? { suspendPayload } : {},
+            resumeSchema
           };
           lastAssistantMessage.content.metadata = metadata;
         }
       };
-      const removeToolApprovalMetadata = async (toolCallId) => {
+      const removeToolMetadata = async (toolName, type) => {
         const { saveQueueManager, memoryConfig, threadId } = _internal || {};
         if (!saveQueueManager || !threadId) {
           return;
@@ -10898,24 +11283,25 @@ function createToolCallStep({
           const metadata = typeof content.metadata === "object" && content.metadata !== null ? content.metadata : void 0;
           return metadata;
         };
+        const metadataKey = type === "suspension" ? "suspendedTools" : "pendingToolApprovals";
         const allMessages = messageList.get.all.db();
         const lastAssistantMessage = [...allMessages].reverse().find((msg) => {
           const metadata = getMetadata(msg);
-          const pendingToolApprovals = metadata?.pendingToolApprovals;
-          return !!pendingToolApprovals?.[toolCallId];
+          const suspendedTools = metadata?.[metadataKey];
+          return !!suspendedTools?.[toolName];
         });
         if (lastAssistantMessage) {
           const metadata = getMetadata(lastAssistantMessage);
-          const pendingToolApprovals = metadata?.pendingToolApprovals;
-          if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
-            delete pendingToolApprovals[toolCallId];
-            if (metadata && Object.keys(pendingToolApprovals).length === 0) {
-              delete metadata.pendingToolApprovals;
+          const suspendedTools = metadata?.[metadataKey];
+          if (suspendedTools && typeof suspendedTools === "object") {
+            delete suspendedTools[toolName];
+            if (metadata && Object.keys(suspendedTools).length === 0) {
+              delete metadata[metadataKey];
             }
             try {
               await saveQueueManager.flushMessages(messageList, threadId, memoryConfig);
             } catch (error) {
-              console.error("Error removing tool approval metadata:", error);
+              console.error("Error removing tool suspension metadata:", error);
             }
           }
         }
@@ -10948,12 +11334,12 @@ function createToolCallStep({
           result: inputData.output
         };
       }
-      if (!tool) {
+      if (!tool2) {
         throw new Error(`Tool ${inputData.toolName} not found`);
       }
-      if (tool && "onInputAvailable" in tool) {
+      if (tool2 && "onInputAvailable" in tool2) {
         try {
-          await tool?.onInputAvailable?.({
+          await tool2?.onInputAvailable?.({
             toolCallId: inputData.toolCallId,
             input: inputData.args,
             messages: messageList.get.input.aiV5.model(),
@@ -10963,12 +11349,21 @@ function createToolCallStep({
           console.error("Error calling onInputAvailable", error);
         }
       }
-      if (!tool.execute) {
+      if (!tool2.execute) {
         return inputData;
       }
       try {
         const requireToolApproval = requestContext.get("__mastra_requireToolApproval");
-        if (requireToolApproval || tool.requireApproval) {
+        let resumeDataFromArgs = void 0;
+        let args = inputData.args;
+        if (typeof inputData.args === "object" && inputData.args !== null) {
+          const { resumeData: resumeDataFromInput, ...argsFromInput } = inputData.args;
+          args = argsFromInput;
+          resumeDataFromArgs = resumeDataFromInput;
+        }
+        const resumeData = resumeDataFromArgs ?? workflowResumeData;
+        const isResumeToolCall = !!resumeDataFromArgs;
+        if (requireToolApproval || tool2.requireApproval) {
           if (!resumeData) {
             controller.enqueue({
               type: "tool-call-approval",
@@ -10980,7 +11375,17 @@ function createToolCallStep({
                 args: inputData.args
               }
             });
-            addToolApprovalMetadata(inputData.toolCallId, inputData.toolName, inputData.args);
+            addToolMetadata({
+              toolCallId: inputData.toolCallId,
+              toolName: inputData.toolName,
+              args: inputData.args,
+              type: "approval",
+              resumeSchema: z8.object({
+                approved: z8.boolean().describe(
+                  "Controls if the tool call is approved or not, should be true when approved and false when declined"
+                )
+              })
+            });
             await flushMessagesBeforeSuspension();
             return suspend(
               {
@@ -10996,7 +11401,7 @@ function createToolCallStep({
               }
             );
           } else {
-            await removeToolApprovalMetadata(inputData.toolCallId);
+            await removeToolMetadata(inputData.toolName, "approval");
             if (!resumeData.approved) {
               return {
                 result: "Tool call was not approved by the user",
@@ -11004,6 +11409,8 @@ function createToolCallStep({
               };
             }
           }
+        } else if (isResumeToolCall) {
+          await removeToolMetadata(inputData.toolName, "suspension");
         }
         const toolOptions = {
           abortSignal: options?.abortSignal,
@@ -11012,18 +11419,33 @@ function createToolCallStep({
           outputWriter,
           // Pass current step span as parent for tool call spans
           tracingContext: modelSpanTracker?.getTracingContext(),
-          suspend: async (suspendPayload) => {
+          suspend: async (suspendPayload, options2) => {
             controller.enqueue({
               type: "tool-call-suspended",
               runId,
               from: "AGENT" /* AGENT */,
-              payload: { toolCallId: inputData.toolCallId, toolName: inputData.toolName, suspendPayload }
+              payload: {
+                toolCallId: inputData.toolCallId,
+                toolName: inputData.toolName,
+                suspendPayload,
+                args: inputData.args
+              }
+            });
+            addToolMetadata({
+              toolCallId: inputData.toolCallId,
+              toolName: inputData.toolName,
+              args,
+              suspendPayload,
+              type: "suspension",
+              resumeSchema: options2?.resumeSchema
             });
             await flushMessagesBeforeSuspension();
             return await suspend(
               {
                 toolCallSuspended: suspendPayload,
-                __streamState: streamState.serialize()
+                __streamState: streamState.serialize(),
+                toolName: inputData.toolName,
+                resumeLabel: options2?.resumeLabel
               },
               {
                 resumeLabel: inputData.toolCallId
@@ -11032,10 +11454,10 @@ function createToolCallStep({
           },
           resumeData
         };
-        const result = await tool.execute(inputData.args, toolOptions);
-        if (tool && "onOutput" in tool && typeof tool.onOutput === "function") {
+        const result = await tool2.execute(args, toolOptions);
+        if (tool2 && "onOutput" in tool2 && typeof tool2.onOutput === "function") {
           try {
-            await tool.onOutput({
+            await tool2.onOutput({
               toolCallId: inputData.toolCallId,
               toolName: inputData.toolName,
               output: result,
@@ -11075,6 +11497,25 @@ function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
     },
     llmExecutionStep
   );
+  let toolCallConcurrency = 10;
+  if (rest?.toolCallConcurrency) {
+    toolCallConcurrency = rest.toolCallConcurrency > 0 ? rest.toolCallConcurrency : 10;
+  }
+  const hasRequireToolApproval = !!rest.requireToolApproval;
+  let hasSuspendSchema = false;
+  let hasRequireApproval = false;
+  if (rest.tools) {
+    for (const tool2 of Object.values(rest.tools)) {
+      if (tool2?.hasSuspendSchema) {
+        hasSuspendSchema = true;
+      }
+      if (tool2?.requireApproval) {
+        hasRequireApproval = true;
+      }
+      if (hasSuspendSchema || hasRequireApproval) break;
+    }
+  }
+  const sequentialExecutionRequired = hasRequireToolApproval || hasSuspendSchema || hasRequireApproval;
   return createWorkflow({
     id: "executionWorkflow",
     inputSchema: llmIterationOutputSchema,
@@ -11104,7 +11545,7 @@ function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
       return typedInputData.output.toolCalls || [];
     },
     { id: "map-tool-calls" }
-  ).foreach(toolCallStep, { concurrency: 10 }).then(llmMappingStep).commit();
+  ).foreach(toolCallStep, { concurrency: sequentialExecutionRequired ? 1 : toolCallConcurrency }).then(llmMappingStep).commit();
 }
 
 // src/loop/workflows/agentic-loop/index.ts
@@ -11237,6 +11678,7 @@ function workflowLoopStream({
   streamState,
   agentId,
   toolCallId,
+  toolCallConcurrency,
   ...rest
 }) {
   return new ReadableStream$1({
@@ -11254,7 +11696,9 @@ function workflowLoopStream({
               format: 2,
               parts: [dataPart]
             },
-            createdAt: /* @__PURE__ */ new Date()
+            createdAt: /* @__PURE__ */ new Date(),
+            threadId: _internal?.threadId,
+            resourceId: _internal?.resourceId
           };
           messageList.add(message, "response");
         }
@@ -11274,6 +11718,8 @@ function workflowLoopStream({
         startTimestamp,
         streamState,
         agentId,
+        requireToolApproval,
+        toolCallConcurrency,
         ...rest
       });
       if (rest.mastra) {
@@ -11304,7 +11750,8 @@ function workflowLoopStream({
           runId,
           from: "AGENT" /* AGENT */,
           payload: {
-            id: agentId
+            id: agentId,
+            messageId
           }
         });
       }
@@ -11326,18 +11773,7 @@ function workflowLoopStream({
       });
       if (executionResult.status !== "success") {
         if (executionResult.status === "failed") {
-          let executionResultError = executionResult.error;
-          if (typeof executionResult.error === "string") {
-            const prependedErrorString = "Error: ";
-            if (executionResult.error.startsWith(`${prependedErrorString}${prependedErrorString}`)) {
-              executionResultError = executionResult.error.substring(
-                `${prependedErrorString}${prependedErrorString}`.length
-              );
-            } else if (executionResult.error.startsWith(prependedErrorString)) {
-              executionResultError = executionResult.error.substring(prependedErrorString.length);
-            }
-          }
-          const error = getErrorFromUnknown(executionResultError, {
+          const error = getErrorFromUnknown(executionResult.error, {
             fallbackMessage: "Unknown error in agent workflow stream"
           });
           controller.enqueue({
@@ -11350,9 +11786,13 @@ function workflowLoopStream({
             await rest.options?.onError?.({ error });
           }
         }
+        if (executionResult.status !== "suspended") {
+          await agenticLoopWorkflow.deleteWorkflowRunById(runId);
+        }
         controller.close();
         return;
       }
+      await agenticLoopWorkflow.deleteWorkflowRunById(runId);
       controller.enqueue({
         type: "finish",
         runId,
@@ -11387,6 +11827,7 @@ function loop({
   returnScorerData,
   requireToolApproval,
   agentId,
+  toolCallConcurrency,
   ...rest
 }) {
   let loggerToUse = logger || new ConsoleLogger({
@@ -11443,6 +11884,7 @@ function loop({
     messageId,
     agentId,
     requireToolApproval,
+    toolCallConcurrency,
     streamState: {
       serialize: serializeStreamState,
       deserialize: deserializeStreamState
@@ -11601,6 +12043,7 @@ var MastraLLMVNext = class extends MastraBase {
     tracingContext,
     messageList,
     requireToolApproval,
+    toolCallConcurrency,
     _internal,
     agentId,
     agentName,
@@ -11608,6 +12051,7 @@ var MastraLLMVNext = class extends MastraBase {
     requestContext,
     methodType,
     includeRawChunks,
+    autoResumeSuspendedTools,
     maxProcessorRetries
   }) {
     let stopWhenToUse;
@@ -11667,11 +12111,13 @@ var MastraLLMVNext = class extends MastraBase {
         returnScorerData,
         modelSpanTracker,
         requireToolApproval,
+        toolCallConcurrency,
         agentId,
         agentName,
         requestContext,
         methodType,
         includeRawChunks,
+        autoResumeSuspendedTools,
         maxProcessorRetries,
         options: {
           ...options,
@@ -11796,7 +12242,7 @@ var MastraLLMVNext = class extends MastraBase {
     }
   }
 };
-var PRIMITIVE_TYPES = z7.enum(["agent", "workflow", "none", "tool"]);
+var PRIMITIVE_TYPES = z8.enum(["agent", "workflow", "none", "tool"]);
 
 // src/loop/network/index.ts
 async function getRoutingAgent({ requestContext, agent }) {
@@ -11815,9 +12261,9 @@ async function getRoutingAgent({ requestContext, agent }) {
     )}`;
   }).join("\n");
   const memoryTools = await memoryToUse?.listTools?.();
-  const toolList = Object.entries({ ...toolsToUse, ...memoryTools }).map(([name, tool]) => {
-    return ` - **${name}**: ${tool.description}, input schema: ${JSON.stringify(
-      zodToJsonSchema$1(tool.inputSchema || z7.object({}))
+  const toolList = Object.entries({ ...toolsToUse, ...memoryTools }).map(([name, tool2]) => {
+    return ` - **${name}**: ${tool2.description}, input schema: ${JSON.stringify(
+      zodToJsonSchema$1(tool2.inputSchema || z8.object({}))
     )}`;
   }).join("\n");
   const instructions = `
@@ -11888,7 +12334,7 @@ async function prepareMemoryStep({
   messages,
   routingAgent,
   requestContext,
-  generateId: generateId3,
+  generateId: generateId2,
   tracingContext,
   memoryConfig
 }) {
@@ -11910,7 +12356,7 @@ async function prepareMemoryStep({
         memory.saveMessages({
           messages: [
             {
-              id: generateId3(),
+              id: generateId2(),
               type: "text",
               role: "user",
               content: { parts: [{ type: "text", text: messages }], format: 2 },
@@ -11977,43 +12423,43 @@ async function createNetworkLoop({
   requestContext,
   runId,
   agent,
-  generateId: generateId3,
+  generateId: generateId2,
   routingAgentOptions
 }) {
   const routingStep = createStep({
     id: "routing-agent-step",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string().optional(),
-      iteration: z7.number(),
-      threadId: z7.string().optional(),
-      threadResourceId: z7.string().optional(),
-      isOneOff: z7.boolean(),
-      verboseIntrospection: z7.boolean()
+      result: z8.string().optional(),
+      iteration: z8.number(),
+      threadId: z8.string().optional(),
+      threadResourceId: z8.string().optional(),
+      isOneOff: z8.boolean(),
+      verboseIntrospection: z8.boolean()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      selectionReason: z7.string(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      selectionReason: z8.string(),
+      iteration: z8.number()
     }),
     execute: async ({ inputData, getInitData, writer }) => {
       const initData = await getInitData();
-      const completionSchema = z7.object({
-        isComplete: z7.boolean(),
-        finalResult: z7.string(),
-        completionReason: z7.string()
+      const completionSchema = z8.object({
+        isComplete: z8.boolean(),
+        finalResult: z8.string(),
+        completionReason: z8.string()
       });
       const routingAgent = await getRoutingAgent({ requestContext, agent });
       let completionResult;
       const iterationCount = (inputData.iteration ?? -1) + 1;
-      const stepId = generateId3();
+      const stepId = generateId2();
       await writer.write({
         type: "routing-agent-start",
         payload: {
@@ -12149,7 +12595,7 @@ async function createNetworkLoop({
           await memory?.saveMessages({
             messages: [
               {
-                id: generateId3(),
+                id: generateId2(),
                 type: "text",
                 role: "assistant",
                 content: {
@@ -12209,11 +12655,11 @@ ${completionResult?.object?.finalResult}` : ""}
       ];
       const options = {
         structuredOutput: {
-          schema: z7.object({
-            primitiveId: z7.string().describe("The id of the primitive to be called"),
+          schema: z8.object({
+            primitiveId: z8.string().describe("The id of the primitive to be called"),
             primitiveType: PRIMITIVE_TYPES.describe("The type of the primitive to be called"),
-            prompt: z7.string().describe("The json string or text value to be sent to the primitive"),
-            selectionReason: z7.string().describe("The reason you picked the primitive")
+            prompt: z8.string().describe("The json string or text value to be sent to the primitive"),
+            selectionReason: z8.string().describe("The reason you picked the primitive")
           })
         },
         requestContext,
@@ -12257,23 +12703,23 @@ ${completionResult?.object?.finalResult}` : ""}
   });
   const agentStep = createStep({
     id: "agent-execution-step",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      selectionReason: z7.string(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      selectionReason: z8.string(),
+      iteration: z8.number()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      iteration: z7.number()
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      iteration: z8.number()
     }),
     execute: async ({ inputData, writer, getInitData }) => {
       const agentsMap = await agent.listAgents({ requestContext });
@@ -12288,7 +12734,7 @@ ${completionResult?.object?.finalResult}` : ""}
         throw mastraError;
       }
       const agentId = agentForStep.id;
-      const stepId = generateId3();
+      const stepId = generateId2();
       await writer.write({
         type: "agent-execution-start",
         payload: {
@@ -12329,7 +12775,7 @@ ${completionResult?.object?.finalResult}` : ""}
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId3(),
+            id: generateId2(),
             type: "text",
             role: "assistant",
             content: {
@@ -12342,7 +12788,7 @@ ${completionResult?.object?.finalResult}` : ""}
                     primitiveType: inputData.primitiveType,
                     primitiveId: inputData.primitiveId,
                     input: inputData.prompt,
-                    finalResult: { text: await result.text, toolCalls: await result.toolCalls, messages }
+                    finalResult: { text: await result.text, messages }
                   })
                 }
               ],
@@ -12383,23 +12829,23 @@ ${completionResult?.object?.finalResult}` : ""}
   });
   const workflowStep = createStep({
     id: "workflow-execution-step",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      selectionReason: z7.string(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      selectionReason: z8.string(),
+      iteration: z8.number()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      iteration: z7.number()
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      iteration: z8.number()
     }),
     execute: async ({ inputData, writer, getInitData }) => {
       const workflowsMap = await agent.listWorkflows({ requestContext });
@@ -12429,7 +12875,7 @@ ${completionResult?.object?.finalResult}` : ""}
         );
         throw mastraError;
       }
-      const stepId = generateId3();
+      const stepId = generateId2();
       const run = await wf.createRun({ runId });
       const toolData = {
         workflowId: wf.id,
@@ -12482,7 +12928,7 @@ ${completionResult?.object?.finalResult}` : ""}
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId3(),
+            id: generateId2(),
             type: "text",
             role: "assistant",
             content: { parts: [{ type: "text", text: finalResult }], format: 2 },
@@ -12517,23 +12963,23 @@ ${completionResult?.object?.finalResult}` : ""}
   });
   const toolStep = createStep({
     id: "tool-execution-step",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      selectionReason: z7.string(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      selectionReason: z8.string(),
+      iteration: z8.number()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      iteration: z7.number()
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      iteration: z8.number()
     }),
     execute: async ({ inputData, getInitData, writer }) => {
       const initData = await getInitData();
@@ -12541,8 +12987,8 @@ ${completionResult?.object?.finalResult}` : ""}
       const memory = await agent.getMemory({ requestContext });
       const memoryTools = await memory?.listTools?.();
       const toolsMap = { ...agentTools, ...memoryTools };
-      let tool = toolsMap[inputData.primitiveId];
-      if (!tool) {
+      let tool2 = toolsMap[inputData.primitiveId];
+      if (!tool2) {
         const mastraError = new MastraError({
           id: "AGENT_NETWORK_TOOL_EXECUTION_STEP_INVALID_TASK_INPUT",
           domain: "AGENT_NETWORK" /* AGENT_NETWORK */,
@@ -12551,7 +12997,7 @@ ${completionResult?.object?.finalResult}` : ""}
         });
         throw mastraError;
       }
-      if (!tool.execute) {
+      if (!tool2.execute) {
         const mastraError = new MastraError({
           id: "AGENT_NETWORK_TOOL_EXECUTION_STEP_INVALID_TASK_INPUT",
           domain: "AGENT_NETWORK" /* AGENT_NETWORK */,
@@ -12560,7 +13006,7 @@ ${completionResult?.object?.finalResult}` : ""}
         });
         throw mastraError;
       }
-      const toolId = tool.id;
+      const toolId = tool2.id;
       let inputDataToUse;
       try {
         inputDataToUse = JSON.parse(inputData.prompt);
@@ -12576,7 +13022,7 @@ ${completionResult?.object?.finalResult}` : ""}
         );
         throw mastraError;
       }
-      const toolCallId = generateId3();
+      const toolCallId = generateId2();
       await writer?.write({
         type: "tool-execution-start",
         payload: {
@@ -12591,7 +13037,7 @@ ${completionResult?.object?.finalResult}` : ""}
         from: "NETWORK" /* NETWORK */,
         runId
       });
-      const finalResult = await tool.execute(
+      const finalResult = await tool2.execute(
         inputDataToUse,
         {
           requestContext,
@@ -12613,7 +13059,7 @@ ${completionResult?.object?.finalResult}` : ""}
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId3(),
+            id: generateId2(),
             type: "text",
             role: "assistant",
             content: {
@@ -12659,21 +13105,21 @@ ${completionResult?.object?.finalResult}` : ""}
   });
   const finishStep = createStep({
     id: "finish-step",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      selectionReason: z7.string(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      selectionReason: z8.string(),
+      iteration: z8.number()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean(),
-      iteration: z7.number()
+    outputSchema: z8.object({
+      task: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean(),
+      iteration: z8.number()
     }),
     execute: async ({ inputData, writer }) => {
       let endResult = inputData.result;
@@ -12698,29 +13144,29 @@ ${completionResult?.object?.finalResult}` : ""}
   });
   const networkWorkflow = createWorkflow({
     id: "Agent-Network-Outer-Workflow",
-    inputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string().optional(),
-      iteration: z7.number(),
-      threadId: z7.string().optional(),
-      threadResourceId: z7.string().optional(),
-      isOneOff: z7.boolean(),
-      verboseIntrospection: z7.boolean()
+      result: z8.string().optional(),
+      iteration: z8.number(),
+      threadId: z8.string().optional(),
+      threadResourceId: z8.string().optional(),
+      isOneOff: z8.boolean(),
+      verboseIntrospection: z8.boolean()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      completionReason: z7.string().optional(),
-      iteration: z7.number(),
-      threadId: z7.string().optional(),
-      threadResourceId: z7.string().optional(),
-      isOneOff: z7.boolean()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      completionReason: z8.string().optional(),
+      iteration: z8.number(),
+      threadId: z8.string().optional(),
+      threadResourceId: z8.string().optional(),
+      isOneOff: z8.boolean()
     }),
     options: {
       shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
@@ -12782,7 +13228,7 @@ async function networkLoop({
   runId,
   routingAgent,
   routingAgentOptions,
-  generateId: generateId3,
+  generateId: generateId2,
   maxIterations,
   threadId,
   resourceId,
@@ -12807,7 +13253,7 @@ async function networkLoop({
     runId,
     agent: routingAgent,
     routingAgentOptions: routingAgentOptionsWithoutMemory,
-    generateId: generateId3
+    generateId: generateId2
   });
   const finalStep = createStep({
     id: "final-step",
@@ -12829,26 +13275,26 @@ async function networkLoop({
   });
   const mainWorkflow = createWorkflow({
     id: "agent-loop-main-workflow",
-    inputSchema: z7.object({
-      iteration: z7.number(),
-      task: z7.string(),
-      primitiveId: z7.string(),
+    inputSchema: z8.object({
+      iteration: z8.number(),
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      result: z7.string().optional(),
-      threadId: z7.string().optional(),
-      threadResourceId: z7.string().optional(),
-      isOneOff: z7.boolean(),
-      verboseIntrospection: z7.boolean()
+      result: z8.string().optional(),
+      threadId: z8.string().optional(),
+      threadResourceId: z8.string().optional(),
+      isOneOff: z8.boolean(),
+      verboseIntrospection: z8.boolean()
     }),
-    outputSchema: z7.object({
-      task: z7.string(),
-      primitiveId: z7.string(),
+    outputSchema: z8.object({
+      task: z8.string(),
+      primitiveId: z8.string(),
       primitiveType: PRIMITIVE_TYPES,
-      prompt: z7.string(),
-      result: z7.string(),
-      isComplete: z7.boolean().optional(),
-      completionReason: z7.string().optional(),
-      iteration: z7.number()
+      prompt: z8.string(),
+      result: z8.string(),
+      isComplete: z8.boolean().optional(),
+      completionReason: z8.string().optional(),
+      iteration: z8.number()
     }),
     options: {
       shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
@@ -12866,7 +13312,7 @@ async function networkLoop({
     resourceId: resourceId || networkName,
     messages,
     routingAgent,
-    generateId: generateId3,
+    generateId: generateId2,
     tracingContext: routingAgentOptions?.tracingContext,
     memoryConfig: routingAgentMemoryOptions?.options
   });
@@ -12893,67 +13339,6 @@ async function networkLoop({
 
 // src/agent/agent-legacy.ts
 var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
-
-// src/agent/utils.ts
-async function tryGenerateWithJsonFallback(agent, prompt, options) {
-  if (!options.structuredOutput?.schema) {
-    throw new MastraError({
-      id: "STRUCTURED_OUTPUT_OPTIONS_REQUIRED",
-      domain: "AGENT" /* AGENT */,
-      category: "USER" /* USER */,
-      text: "structuredOutput is required to use tryGenerateWithJsonFallback"
-    });
-  }
-  try {
-    return await agent.generate(prompt, options);
-  } catch (error) {
-    console.warn("Error in tryGenerateWithJsonFallback. Attempting fallback.", error);
-    return await agent.generate(prompt, {
-      ...options,
-      structuredOutput: { ...options.structuredOutput, jsonPromptInjection: true }
-    });
-  }
-}
-async function tryStreamWithJsonFallback(agent, prompt, options) {
-  if (!options.structuredOutput?.schema) {
-    throw new MastraError({
-      id: "STRUCTURED_OUTPUT_OPTIONS_REQUIRED",
-      domain: "AGENT" /* AGENT */,
-      category: "USER" /* USER */,
-      text: "structuredOutput is required to use tryStreamWithJsonFallback"
-    });
-  }
-  try {
-    const result = await agent.stream(prompt, options);
-    const object = await result.object;
-    if (!object) {
-      throw new MastraError({
-        id: "STRUCTURED_OUTPUT_OBJECT_UNDEFINED",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        text: "structuredOutput object is undefined"
-      });
-    }
-    return result;
-  } catch (error) {
-    console.warn("Error in tryStreamWithJsonFallback. Attempting fallback.", error);
-    return await agent.stream(prompt, {
-      ...options,
-      structuredOutput: { ...options.structuredOutput, jsonPromptInjection: true }
-    });
-  }
-}
-function resolveThreadIdFromArgs(args) {
-  if (args?.memory?.thread) {
-    if (typeof args.memory.thread === "string") return { id: args.memory.thread };
-    if (typeof args.memory.thread === "object" && args.memory.thread.id)
-      return args.memory.thread;
-  }
-  if (args?.threadId) return { id: args.threadId };
-  return void 0;
-}
-
-// src/agent/agent-legacy.ts
 var AgentLegacyHandler = class {
   constructor(capabilities) {
     this.capabilities = capabilities;
@@ -14033,6 +14418,14 @@ function createMapResultsStep({
     };
     if (result.tripwire) {
       const agentModel = await capabilities.getModel({ requestContext: result.requestContext });
+      if (!isSupportedLanguageModel(agentModel)) {
+        throw new MastraError({
+          id: "MAP_RESULTS_STEP_UNSUPPORTED_MODEL",
+          domain: "AGENT" /* AGENT */,
+          category: "USER" /* USER */,
+          text: "Tripwire handling requires a v2/v3 model"
+        });
+      }
       const modelOutput = await getModelOutputForTripwire({
         tripwire: memoryData.tripwire,
         runId,
@@ -14331,7 +14724,8 @@ function createPrepareToolsStep({
         tracingContext: { currentSpan: agentSpan },
         outputWriter: options.outputWriter,
         methodType,
-        memoryConfig: options.memory?.options
+        memoryConfig: options.memory?.options,
+        autoResumeSuspendedTools: options.autoResumeSuspendedTools
       });
       return {
         convertedTools
@@ -14344,6 +14738,7 @@ function createStreamStep({
   runId,
   returnScorerData,
   requireToolApproval,
+  toolCallConcurrency,
   resumeContext,
   agentId,
   agentName,
@@ -14352,7 +14747,8 @@ function createStreamStep({
   saveQueueManager,
   memoryConfig,
   memory,
-  resourceId
+  resourceId,
+  autoResumeSuspendedTools
 }) {
   return createStep({
     id: "stream-text-step",
@@ -14377,6 +14773,7 @@ function createStreamStep({
         returnScorerData,
         tracingContext,
         requireToolApproval,
+        toolCallConcurrency,
         resumeContext,
         _internal: {
           generateId: capabilities.generateMessageId,
@@ -14389,7 +14786,8 @@ function createStreamStep({
         agentId,
         agentName,
         toolCallId,
-        methodType: modelMethodType
+        methodType: modelMethodType,
+        autoResumeSuspendedTools
       });
       return streamResult;
     }
@@ -14412,6 +14810,7 @@ function createPrepareStreamWorkflow({
   returnScorerData,
   saveQueueManager,
   requireToolApproval,
+  toolCallConcurrency,
   resumeContext,
   agentId,
   agentName,
@@ -14444,6 +14843,7 @@ function createPrepareStreamWorkflow({
     runId,
     returnScorerData,
     requireToolApproval,
+    toolCallConcurrency,
     resumeContext,
     agentId,
     agentName,
@@ -14452,7 +14852,8 @@ function createPrepareStreamWorkflow({
     saveQueueManager,
     memoryConfig,
     memory,
-    resourceId
+    resourceId,
+    autoResumeSuspendedTools: options.autoResumeSuspendedTools
   });
   const mapResultsStep = createMapResultsStep({
     capabilities,
@@ -14666,7 +15067,6 @@ var Agent = class extends MastraBase {
   }) {
     const inputProcessors = inputProcessorOverrides ?? await this.listResolvedInputProcessors(requestContext);
     const outputProcessors = outputProcessorOverrides ?? await this.listResolvedOutputProcessors(requestContext);
-    this.logger.debug("outputProcessors", outputProcessors);
     return new ProcessorRunner({
       inputProcessors,
       outputProcessors,
@@ -14706,7 +15106,8 @@ var Agent = class extends MastraBase {
       id: workflowId,
       inputSchema: ProcessorStepSchema,
       outputSchema: ProcessorStepSchema,
-      type: "processor"
+      type: "processor",
+      options: { validateInputs: false }
     });
     for (const processorOrWorkflow of validProcessors) {
       const step = isProcessorWorkflow(processorOrWorkflow) ? processorOrWorkflow : createStep(processorOrWorkflow);
@@ -15184,7 +15585,7 @@ var Agent = class extends MastraBase {
     const modelToUse = this.getModel({ modelConfig: model, requestContext });
     return resolveMaybePromise(modelToUse, (resolvedModel) => {
       let llm;
-      if (resolvedModel.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(resolvedModel)) {
         const modelsPromise = Array.isArray(this.model) && !model ? this.prepareModels(requestContext) : this.prepareModels(requestContext, resolvedModel);
         llm = modelsPromise.then((models) => {
           const enabledModels = models.filter((model2) => model2.enabled);
@@ -15373,11 +15774,11 @@ var Agent = class extends MastraBase {
   __registerMastra(mastra) {
     this.#mastra = mastra;
     if (this.#tools && typeof this.#tools === "object") {
-      Object.entries(this.#tools).forEach(([key, tool]) => {
+      Object.entries(this.#tools).forEach(([key, tool2]) => {
         try {
-          if (tool && typeof tool === "object" && "id" in tool) {
-            const toolKey = typeof tool.id === "string" ? tool.id : key;
-            mastra.addTool(tool, toolKey);
+          if (tool2 && typeof tool2 === "object" && "id" in tool2) {
+            const toolKey = typeof tool2.id === "string" ? tool2.id : key;
+            mastra.addTool(tool2, toolKey);
           }
         } catch (error) {
           if (error instanceof MastraError && error.id !== "MASTRA_ADD_TOOL_DUPLICATE_KEY") {
@@ -15448,7 +15849,7 @@ var Agent = class extends MastraBase {
     }
     const systemInstructions = await this.resolveTitleInstructions(requestContext, instructions);
     let text = "";
-    if (llm.getModel().specificationVersion === "v2") {
+    if (isSupportedLanguageModel(llm.getModel())) {
       const messageList = new MessageList().add(
         [
           {
@@ -15533,7 +15934,8 @@ var Agent = class extends MastraBase {
     requestContext,
     tracingContext,
     mastraProxy,
-    memoryConfig
+    memoryConfig,
+    autoResumeSuspendedTools
   }) {
     let convertedMemoryTools = {};
     if (this._agentNetworkAppend) {
@@ -15549,8 +15951,8 @@ var Agent = class extends MastraBase {
           runId
         }
       );
-      for (const [toolName, tool] of Object.entries(memoryTools)) {
-        const toolObj = tool;
+      for (const [toolName, tool2] of Object.entries(memoryTools)) {
+        const toolObj = tool2;
         const options = {
           name: toolName,
           runId,
@@ -15566,7 +15968,7 @@ var Agent = class extends MastraBase {
           tracingPolicy: this.#options?.tracingPolicy,
           requireApproval: toolObj.requireApproval
         };
-        const convertedToCoreTool = makeCoreTool(toolObj, options);
+        const convertedToCoreTool = makeCoreTool(toolObj, options, void 0, autoResumeSuspendedTools);
         convertedMemoryTools[toolName] = convertedToCoreTool;
       }
     }
@@ -15692,7 +16094,8 @@ var Agent = class extends MastraBase {
     requestContext,
     tracingContext,
     mastraProxy,
-    outputWriter
+    outputWriter,
+    autoResumeSuspendedTools
   }) {
     let toolsForRequest = {};
     this.logger.debug(`[Agents:${this.name}] - Assembling assigned tools`, { runId, threadId, resourceId });
@@ -15700,8 +16103,8 @@ var Agent = class extends MastraBase {
     const assignedTools = await this.listTools({ requestContext });
     const assignedToolEntries = Object.entries(assignedTools || {});
     const assignedCoreToolEntries = await Promise.all(
-      assignedToolEntries.map(async ([k, tool]) => {
-        if (!tool) {
+      assignedToolEntries.map(async ([k, tool2]) => {
+        if (!tool2) {
           return;
         }
         const options = {
@@ -15718,9 +16121,9 @@ var Agent = class extends MastraBase {
           model: await this.getModel({ requestContext }),
           outputWriter,
           tracingPolicy: this.#options?.tracingPolicy,
-          requireApproval: tool.requireApproval
+          requireApproval: tool2.requireApproval
         };
-        return [k, makeCoreTool(tool, options)];
+        return [k, makeCoreTool(tool2, options, void 0, autoResumeSuspendedTools)];
       })
     );
     const assignedToolEntriesConverted = Object.fromEntries(
@@ -15742,7 +16145,8 @@ var Agent = class extends MastraBase {
     toolsets,
     requestContext,
     tracingContext,
-    mastraProxy
+    mastraProxy,
+    autoResumeSuspendedTools
   }) {
     let toolsForRequest = {};
     const memory = await this.getMemory({ requestContext });
@@ -15752,8 +16156,8 @@ var Agent = class extends MastraBase {
         runId
       });
       for (const toolset of toolsFromToolsets) {
-        for (const [toolName, tool] of Object.entries(toolset)) {
-          const toolObj = tool;
+        for (const [toolName, tool2] of Object.entries(toolset)) {
+          const toolObj = tool2;
           const options = {
             name: toolName,
             runId,
@@ -15769,7 +16173,7 @@ var Agent = class extends MastraBase {
             tracingPolicy: this.#options?.tracingPolicy,
             requireApproval: toolObj.requireApproval
           };
-          const convertedToCoreTool = makeCoreTool(toolObj, options, "toolset");
+          const convertedToCoreTool = makeCoreTool(toolObj, options, "toolset", autoResumeSuspendedTools);
           toolsForRequest[toolName] = convertedToCoreTool;
         }
       }
@@ -15787,7 +16191,8 @@ var Agent = class extends MastraBase {
     requestContext,
     tracingContext,
     mastraProxy,
-    clientTools
+    clientTools,
+    autoResumeSuspendedTools
   }) {
     let toolsForRequest = {};
     const memory = await this.getMemory({ requestContext });
@@ -15796,8 +16201,8 @@ var Agent = class extends MastraBase {
       this.logger.debug(`[Agent:${this.name}] - Adding client tools ${Object.keys(clientTools || {}).join(", ")}`, {
         runId
       });
-      for (const [toolName, tool] of clientToolsForInput) {
-        const { execute: execute2, ...rest } = tool;
+      for (const [toolName, tool2] of clientToolsForInput) {
+        const { execute: execute2, ...rest } = tool2;
         const options = {
           name: toolName,
           runId,
@@ -15811,9 +16216,9 @@ var Agent = class extends MastraBase {
           tracingContext,
           model: await this.getModel({ requestContext }),
           tracingPolicy: this.#options?.tracingPolicy,
-          requireApproval: tool.requireApproval
+          requireApproval: tool2.requireApproval
         };
-        const convertedToCoreTool = makeCoreTool(rest, options, "client-tool");
+        const convertedToCoreTool = makeCoreTool(rest, options, "client-tool", autoResumeSuspendedTools);
         toolsForRequest[toolName] = convertedToCoreTool;
       }
     }
@@ -15829,7 +16234,8 @@ var Agent = class extends MastraBase {
     resourceId,
     requestContext,
     tracingContext,
-    methodType
+    methodType,
+    autoResumeSuspendedTools
   }) {
     const convertedAgentTools = {};
     const agents = await this.listAgents({ requestContext });
@@ -15982,7 +16388,12 @@ var Agent = class extends MastraBase {
           tracingContext,
           tracingPolicy: this.#options?.tracingPolicy
         };
-        convertedAgentTools[`agent-${agentName}`] = makeCoreTool(toolObj, options);
+        convertedAgentTools[`agent-${agentName}`] = makeCoreTool(
+          toolObj,
+          options,
+          void 0,
+          autoResumeSuspendedTools
+        );
       }
     }
     return convertedAgentTools;
@@ -15997,7 +16408,8 @@ var Agent = class extends MastraBase {
     resourceId,
     requestContext,
     tracingContext,
-    methodType
+    methodType,
+    autoResumeSuspendedTools
   }) {
     const convertedWorkflowTools = {};
     const workflows = await this.listWorkflows({ requestContext });
@@ -16026,16 +16438,17 @@ var Agent = class extends MastraBase {
           // current tool span onto the workflow to maintain continuity of the trace
           execute: async (inputData, context) => {
             try {
+              const { initialState, inputData: workflowInputData, suspendedToolRunId } = inputData;
+              const runIdToUse = suspendedToolRunId ?? runId;
               this.logger.debug(`[Agent:${this.name}] - Executing workflow as tool ${workflowName}`, {
                 name: workflowName,
                 description: workflow.description,
                 args: inputData,
-                runId,
+                runId: runIdToUse,
                 threadId,
                 resourceId
               });
-              const run = await workflow.createRun({ runId });
-              const { initialState, inputData: workflowInputData } = inputData;
+              const run = await workflow.createRun({ runId: runIdToUse });
               const { resumeData, suspend } = context?.agent ?? {};
               let result = void 0;
               if (methodType === "generate" || methodType === "generateLegacy") {
@@ -16094,10 +16507,24 @@ var Agent = class extends MastraBase {
               } else if (result?.status === "suspended") {
                 const suspendedStep = result?.suspended?.[0]?.[0];
                 const suspendPayload = result?.steps?.[suspendedStep]?.suspendPayload;
+                const suspendedStepIds = result?.suspended?.map((stepPath) => stepPath.join("."));
+                const firstSuspendedStepPath = [...result?.suspended?.[0] ?? []];
+                let wflowStep = workflow;
+                while (firstSuspendedStepPath.length > 0) {
+                  const key = firstSuspendedStepPath.shift();
+                  if (key) {
+                    if (!workflow.steps[key]) {
+                      this.logger.warn(`Suspended step '${key}' not found in workflow '${workflowName}'`);
+                      break;
+                    }
+                    wflowStep = workflow.steps[key];
+                  }
+                }
+                const resumeSchema = wflowStep?.resumeSchema;
                 if (suspendPayload?.__workflow_meta) {
                   delete suspendPayload.__workflow_meta;
                 }
-                return suspend?.(suspendPayload);
+                return suspend?.(suspendPayload, { resumeLabel: suspendedStepIds, resumeSchema });
               } else {
                 return {
                   error: `Workflow should never reach this path, workflow returned no status`,
@@ -16112,7 +16539,7 @@ var Agent = class extends MastraBase {
                   category: "USER" /* USER */,
                   details: {
                     agentName: this.name,
-                    runId: runId || "",
+                    runId: inputData.suspendedToolRunId || runId || "",
                     threadId: threadId || "",
                     resourceId: resourceId || ""
                   },
@@ -16140,7 +16567,12 @@ var Agent = class extends MastraBase {
           tracingContext,
           tracingPolicy: this.#options?.tracingPolicy
         };
-        convertedWorkflowTools[`workflow-${workflowName}`] = makeCoreTool(toolObj, options);
+        convertedWorkflowTools[`workflow-${workflowName}`] = makeCoreTool(
+          toolObj,
+          options,
+          void 0,
+          autoResumeSuspendedTools
+        );
       }
     }
     return convertedWorkflowTools;
@@ -16159,7 +16591,8 @@ var Agent = class extends MastraBase {
     tracingContext,
     outputWriter,
     methodType,
-    memoryConfig
+    memoryConfig,
+    autoResumeSuspendedTools
   }) {
     let mastraProxy = void 0;
     const logger = this.logger;
@@ -16173,7 +16606,8 @@ var Agent = class extends MastraBase {
       requestContext,
       tracingContext,
       mastraProxy,
-      outputWriter
+      outputWriter,
+      autoResumeSuspendedTools
     });
     const memoryTools = await this.listMemoryTools({
       runId,
@@ -16182,7 +16616,8 @@ var Agent = class extends MastraBase {
       requestContext,
       tracingContext,
       mastraProxy,
-      memoryConfig
+      memoryConfig,
+      autoResumeSuspendedTools
     });
     const toolsetTools = await this.listToolsets({
       runId,
@@ -16191,7 +16626,8 @@ var Agent = class extends MastraBase {
       requestContext,
       tracingContext,
       mastraProxy,
-      toolsets
+      toolsets,
+      autoResumeSuspendedTools
     });
     const clientSideTools = await this.listClientTools({
       runId,
@@ -16200,7 +16636,8 @@ var Agent = class extends MastraBase {
       requestContext,
       tracingContext,
       mastraProxy,
-      clientTools
+      clientTools,
+      autoResumeSuspendedTools
     });
     const agentTools = await this.listAgentTools({
       runId,
@@ -16208,7 +16645,8 @@ var Agent = class extends MastraBase {
       threadId,
       requestContext,
       methodType,
-      tracingContext
+      tracingContext,
+      autoResumeSuspendedTools
     });
     const workflowTools = await this.listWorkflowTools({
       runId,
@@ -16216,7 +16654,8 @@ var Agent = class extends MastraBase {
       threadId,
       requestContext,
       methodType,
-      tracingContext
+      tracingContext,
+      autoResumeSuspendedTools
     });
     return this.formatTools({
       ...assignedTools,
@@ -16362,7 +16801,7 @@ var Agent = class extends MastraBase {
         result[id] = scorerObject;
       }
     }
-    if (Object.keys(result).length === 0) {
+    if (Object.keys(result).length === 0 && Object.keys(overrideScorers).length > 0) {
       throw new MastraError({
         id: "AGENT_GENEREATE_SCORER_NOT_FOUND",
         domain: "AGENT" /* AGENT */,
@@ -16379,8 +16818,11 @@ var Agent = class extends MastraBase {
   async prepareModels(requestContext, model) {
     if (model || !Array.isArray(this.model)) {
       const modelToUse = model ?? this.model;
-      const resolvedModel = typeof modelToUse === "function" ? await modelToUse({ requestContext, mastra: this.#mastra }) : modelToUse;
-      if (resolvedModel?.specificationVersion !== "v2") {
+      const resolvedModel = await this.resolveModelConfig(
+        modelToUse,
+        requestContext
+      );
+      if (!isSupportedLanguageModel(resolvedModel)) {
         const mastraError = new MastraError({
           id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
           domain: "AGENT" /* AGENT */,
@@ -16388,26 +16830,30 @@ var Agent = class extends MastraBase {
           details: {
             agentName: this.name
           },
-          text: `[Agent:${this.name}] - Only v2 models are allowed when an array of models is provided`
+          text: `[Agent:${this.name}] - Only v2/v3 models are allowed when an array of models is provided`
         });
         this.logger.trackException(mastraError);
         this.logger.error(mastraError.toString());
         throw mastraError;
       }
+      let headers;
+      if (resolvedModel instanceof ModelRouterLanguageModel) {
+        headers = resolvedModel.config?.headers;
+      }
       return [
         {
           id: "main",
-          // TODO fix type check
           model: resolvedModel,
           maxRetries: this.maxRetries ?? 0,
-          enabled: true
+          enabled: true,
+          headers
         }
       ];
     }
     const models = await Promise.all(
       this.model.map(async (modelConfig) => {
         const model2 = await this.resolveModelConfig(modelConfig.model, requestContext);
-        if (!isV2Model(model2)) {
+        if (!isSupportedLanguageModel(model2)) {
           const mastraError = new MastraError({
             id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
             domain: "AGENT" /* AGENT */,
@@ -16415,7 +16861,7 @@ var Agent = class extends MastraBase {
             details: {
               agentName: this.name
             },
-            text: `[Agent:${this.name}] - Only v2 models are allowed when an array of models is provided`
+            text: `[Agent:${this.name}] - Only v2/v3 models are allowed when an array of models is provided`
           });
           this.logger.trackException(mastraError);
           this.logger.error(mastraError.toString());
@@ -16436,11 +16882,16 @@ var Agent = class extends MastraBase {
           this.logger.error(mastraError.toString());
           throw mastraError;
         }
+        let headers;
+        if (model2 instanceof ModelRouterLanguageModel) {
+          headers = model2.config?.headers;
+        }
         return {
           id: modelId,
           model: model2,
           maxRetries: modelConfig.maxRetries ?? 0,
-          enabled: modelConfig.enabled ?? true
+          enabled: modelConfig.enabled ?? true,
+          headers
         };
       })
     );
@@ -16450,7 +16901,11 @@ var Agent = class extends MastraBase {
    * Executes the agent call, handling tools, memory, and streaming.
    * @internal
    */
-  async #execute({ methodType, resumeContext, ...options }) {
+  async #execute({
+    methodType,
+    resumeContext,
+    ...options
+  }) {
     const existingSnapshot = resumeContext?.snapshot;
     let snapshotMemoryInfo;
     if (existingSnapshot) {
@@ -16567,6 +17022,7 @@ var Agent = class extends MastraBase {
       saveQueueManager,
       returnScorerData: options.returnScorerData,
       requireToolApproval: options.requireToolApproval,
+      toolCallConcurrency: options.toolCallConcurrency,
       resumeContext,
       agentId: this.id,
       agentName: this.name,
@@ -16764,6 +17220,10 @@ var Agent = class extends MastraBase {
   async network(messages, options) {
     const runId = options?.runId || this.#mastra?.generateId() || randomUUID();
     const requestContextToUse = options?.requestContext || new RequestContext();
+    const resourceIdFromContext = requestContextToUse.get(MASTRA_RESOURCE_ID_KEY);
+    const threadIdFromContext = requestContextToUse.get(MASTRA_THREAD_ID_KEY);
+    const threadId = threadIdFromContext || (typeof options?.memory?.thread === "string" ? options?.memory?.thread : options?.memory?.thread?.id);
+    const resourceId = resourceIdFromContext || options?.memory?.resource;
     return await networkLoop({
       networkName: this.name,
       requestContext: requestContextToUse,
@@ -16776,8 +17236,8 @@ var Agent = class extends MastraBase {
       generateId: () => this.#mastra?.generateId() || randomUUID(),
       maxIterations: options?.maxSteps || 1,
       messages,
-      threadId: typeof options?.memory?.thread === "string" ? options?.memory?.thread : options?.memory?.thread?.id,
-      resourceId: options?.memory?.resource
+      threadId,
+      resourceId
     });
   }
   async generate(messages, options) {
@@ -16792,14 +17252,14 @@ var Agent = class extends MastraBase {
       requestContext: mergedOptions.requestContext
     });
     const modelInfo = llm.getModel();
-    if (modelInfo.specificationVersion !== "v2") {
+    if (!isSupportedLanguageModel(modelInfo)) {
       const modelId = modelInfo.modelId || "unknown";
       const provider = modelInfo.provider || "unknown";
       throw new MastraError({
         id: "AGENT_GENERATE_V1_MODEL_NOT_SUPPORTED",
         domain: "AGENT" /* AGENT */,
         category: "USER" /* USER */,
-        text: `Agent "${this.name}" is using AI SDK v4 model (${provider}:${modelId}) which is not compatible with generate(). Please use AI SDK v5 models or call the generateLegacy() method instead. See https://mastra.ai/en/docs/streaming/overview for more information.`,
+        text: `Agent "${this.name}" is using AI SDK v4 model (${provider}:${modelId}) which is not compatible with generate(). Please use AI SDK v5+ models or call the generateLegacy() method instead. See https://mastra.ai/en/docs/streaming/overview for more information.`,
         details: {
           agentName: this.name,
           modelId,
@@ -16854,14 +17314,14 @@ var Agent = class extends MastraBase {
       requestContext: mergedOptions.requestContext
     });
     const modelInfo = llm.getModel();
-    if (modelInfo.specificationVersion !== "v2") {
+    if (!isSupportedLanguageModel(modelInfo)) {
       const modelId = modelInfo.modelId || "unknown";
       const provider = modelInfo.provider || "unknown";
       throw new MastraError({
         id: "AGENT_STREAM_V1_MODEL_NOT_SUPPORTED",
         domain: "AGENT" /* AGENT */,
         category: "USER" /* USER */,
-        text: `Agent "${this.name}" is using AI SDK v4 model (${provider}:${modelId}) which is not compatible with stream(). Please use AI SDK v5 models or call the streamLegacy() method instead. See https://mastra.ai/en/docs/streaming/overview for more information.`,
+        text: `Agent "${this.name}" is using AI SDK v4 model (${provider}:${modelId}) which is not compatible with stream(). Please use AI SDK v5+ models or call the streamLegacy() method instead. See https://mastra.ai/en/docs/streaming/overview for more information.`,
         details: {
           agentName: this.name,
           modelId,
@@ -16923,7 +17383,7 @@ var Agent = class extends MastraBase {
     const llm = await this.getLLM({
       requestContext: mergedStreamOptions.requestContext
     });
-    if (llm.getModel().specificationVersion !== "v2") {
+    if (!isSupportedLanguageModel(llm.getModel())) {
       throw new MastraError({
         id: "AGENT_STREAM_V1_MODEL_NOT_SUPPORTED",
         domain: "AGENT" /* AGENT */,
@@ -17153,17 +17613,17 @@ var ModerationProcessor = class _ModerationProcessor {
     const prompt = this.createModerationPrompt(content, isStream);
     try {
       const model = await this.moderationAgent.getModel();
-      const schema = z7.object({
-        category_scores: z7.array(
-          z7.object({
-            category: z7.enum(this.categories).describe("The moderation category being evaluated"),
-            score: z7.number().min(0).max(1).describe("Confidence score between 0 and 1 indicating how strongly the content matches this category")
+      const schema = z8.object({
+        category_scores: z8.array(
+          z8.object({
+            category: z8.enum(this.categories).describe("The moderation category being evaluated"),
+            score: z8.number().min(0).max(1).describe("Confidence score between 0 and 1 indicating how strongly the content matches this category")
           })
         ).describe("Array of flagged categories with their confidence scores").nullable(),
-        reason: z7.string().describe("Brief explanation of why content was flagged").nullable()
+        reason: z8.string().describe("Brief explanation of why content was flagged").nullable()
       });
       let response;
-      if (model.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(model)) {
         response = await this.moderationAgent.generate(prompt, {
           structuredOutput: {
             schema,
@@ -17368,22 +17828,22 @@ var PromptInjectionDetector = class _PromptInjectionDetector {
     try {
       const model = await this.detectionAgent.getModel();
       let response;
-      const baseSchema = z7.object({
-        categories: z7.array(
-          z7.object({
-            type: z7.enum(this.detectionTypes).describe("The type of attack detected from the list of detection types"),
-            score: z7.number().min(0).max(1).describe("Confidence level between 0 and 1 indicating how certain the detection is")
+      const baseSchema = z8.object({
+        categories: z8.array(
+          z8.object({
+            type: z8.enum(this.detectionTypes).describe("The type of attack detected from the list of detection types"),
+            score: z8.number().min(0).max(1).describe("Confidence level between 0 and 1 indicating how certain the detection is")
           })
         ).nullable(),
-        reason: z7.string().describe("The reason for the detection").nullable()
+        reason: z8.string().describe("The reason for the detection").nullable()
       });
       let schema = baseSchema;
       if (this.strategy === "rewrite") {
         schema = baseSchema.extend({
-          rewritten_content: z7.string().describe("The rewritten content that neutralizes the attack while preserving any legitimate user intent").nullable()
+          rewritten_content: z8.string().describe("The rewritten content that neutralizes the attack while preserving any legitimate user intent").nullable()
         });
       }
-      if (model.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(model)) {
         response = await this.detectionAgent.generate(prompt, {
           structuredOutput: {
             schema,
@@ -17608,30 +18068,30 @@ var PIIDetector = class _PIIDetector {
     const prompt = this.createDetectionPrompt(content);
     try {
       const model = await this.detectionAgent.getModel();
-      const baseDetectionSchema = z7.object({
-        type: z7.string().describe("Type of PII detected"),
-        value: z7.string().describe("The actual PII value found"),
-        confidence: z7.number().min(0).max(1).describe("Confidence of this detection"),
-        start: z7.number().describe("Start position in the text"),
-        end: z7.number().describe("End position in the text")
+      const baseDetectionSchema = z8.object({
+        type: z8.string().describe("Type of PII detected"),
+        value: z8.string().describe("The actual PII value found"),
+        confidence: z8.number().min(0).max(1).describe("Confidence of this detection"),
+        start: z8.number().describe("Start position in the text"),
+        end: z8.number().describe("End position in the text")
       });
       const detectionSchema = this.strategy === "redact" ? baseDetectionSchema.extend({
-        redacted_value: z7.string().describe("Redacted version of the value").nullable()
+        redacted_value: z8.string().describe("Redacted version of the value").nullable()
       }) : baseDetectionSchema;
-      const baseSchema = z7.object({
-        categories: z7.array(
-          z7.object({
-            type: z7.enum(this.detectionTypes).describe("The type of PII detected from the list of detection types"),
-            score: z7.number().min(0).max(1).describe("Confidence level between 0 and 1 indicating how certain the detection is")
+      const baseSchema = z8.object({
+        categories: z8.array(
+          z8.object({
+            type: z8.enum(this.detectionTypes).describe("The type of PII detected from the list of detection types"),
+            score: z8.number().min(0).max(1).describe("Confidence level between 0 and 1 indicating how certain the detection is")
           })
         ).describe("Array of detected PII types with their confidence scores").nullable(),
-        detections: z7.array(detectionSchema).describe("Array of specific PII detections with locations").nullable()
+        detections: z8.array(detectionSchema).describe("Array of specific PII detections with locations").nullable()
       });
       const schema = this.strategy === "redact" ? baseSchema.extend({
-        redacted_content: z7.string().describe("The content with all PII redacted according to the redaction method").nullable()
+        redacted_content: z8.string().describe("The content with all PII redacted according to the redaction method").nullable()
       }) : baseSchema;
       let response;
-      if (model.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(model)) {
         response = await this.detectionAgent.generate(prompt, {
           structuredOutput: {
             schema,
@@ -18086,14 +18546,14 @@ var LanguageDetector = class _LanguageDetector {
     try {
       const model = await this.detectionAgent.getModel();
       let response;
-      const baseSchema = z7.object({
-        iso_code: z7.string().describe("ISO language code").nullable(),
-        confidence: z7.number().min(0).max(1).describe("Detection confidence").nullable()
+      const baseSchema = z8.object({
+        iso_code: z8.string().describe("ISO language code").nullable(),
+        confidence: z8.number().min(0).max(1).describe("Detection confidence").nullable()
       });
       const schema = this.strategy === "translate" ? baseSchema.extend({
-        translated_text: z7.string().describe("Translated text").nullable()
+        translated_text: z8.string().describe("Translated text").nullable()
       }) : baseSchema;
-      if (model.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(model)) {
         response = await this.detectionAgent.generate(prompt, {
           structuredOutput: {
             schema
@@ -18771,7 +19231,7 @@ var SystemPromptScrubber = class {
       const schema = this.strategy === "redact" ? baseSchema.extend({
         redacted_content: z.string().describe("Redacted content").nullable()
       }) : baseSchema;
-      if (model.specificationVersion === "v2") {
+      if (isSupportedLanguageModel(model)) {
         result = await this.detectionAgent.generate(text, {
           structuredOutput: {
             schema,
@@ -20141,7 +20601,7 @@ var MockMemory = class extends MastraMemory {
       updateWorkingMemory: createTool({
         id: "update-working-memory",
         description: `Update the working memory with new information. Any data not included will be overwritten.`,
-        inputSchema: z7.object({ memory: z7.string() }),
+        inputSchema: z8.object({ memory: z8.string() }),
         execute: async (inputData, context) => {
           const threadId = context?.agent?.threadId;
           const resourceId = context?.agent?.resourceId;
@@ -20250,6 +20710,6 @@ var MockMemory = class extends MastraMemory {
   }
 };
 
-export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MemoryProcessor, MessageContentSchema, MessageHistory, MessagePartSchema, MockMemory, ModerationProcessor, PIIDetector, ProcessorInputPhaseSchema, ProcessorInputStepPhaseSchema, ProcessorMessageContentSchema, ProcessorMessageSchema, ProcessorOutputResultPhaseSchema, ProcessorOutputStepPhaseSchema, ProcessorOutputStreamPhaseSchema, ProcessorRunner, ProcessorState, ProcessorStepInputSchema, ProcessorStepOutputSchema, ProcessorStepSchema, PromptInjectionDetector, ReasoningPartSchema, Run, SemanticRecall, SourcePartSchema, StepStartPartSchema, StructuredOutputProcessor, SystemPromptScrubber, TextPartSchema, TokenLimiterProcessor, ToolCallFilter, ToolInvocationPartSchema, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, WorkingMemory, augmentWithInit, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createTimeTravelExecutionParams, createWorkflow, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, isProcessor, isProcessorWorkflow, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, resolveThreadIdFromArgs, runCountDeprecationMessage, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-2ULLRN4Y.js.map
-//# sourceMappingURL=chunk-2ULLRN4Y.js.map
+export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, EventEmitterPubSub, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MemoryProcessor, MessageContentSchema, MessageHistory, MessagePartSchema, MockMemory, ModerationProcessor, PIIDetector, ProcessorInputPhaseSchema, ProcessorInputStepPhaseSchema, ProcessorMessageContentSchema, ProcessorMessageSchema, ProcessorOutputResultPhaseSchema, ProcessorOutputStepPhaseSchema, ProcessorOutputStreamPhaseSchema, ProcessorRunner, ProcessorState, ProcessorStepInputSchema, ProcessorStepOutputSchema, ProcessorStepSchema, PromptInjectionDetector, ReasoningPartSchema, Run, SemanticRecall, SourcePartSchema, StepStartPartSchema, StructuredOutputProcessor, SystemPromptScrubber, TextPartSchema, TokenLimiterProcessor, ToolCallFilter, ToolInvocationPartSchema, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, WorkingMemory, augmentWithInit, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createTimeTravelExecutionParams, createWorkflow, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, hydrateSerializedStepErrors, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, resolveThreadIdFromArgs, runCountDeprecationMessage, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData, validateStepStateData, validateStepSuspendData };
+//# sourceMappingURL=chunk-QF4MHFSU.js.map
+//# sourceMappingURL=chunk-QF4MHFSU.js.map