@mastra/core 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/{chunk-CKGIPST2.js → chunk-XBO6W7LZ.js}

@@ -1,14 +1,14 @@
-import { DefaultVoice } from './chunk-UIZSWUKP.js';
+import { DefaultVoice } from './chunk-NZAXAFI3.js';
 import { STREAM_FORMAT_SYMBOL, EMITTER_SYMBOL } from './chunk-NLNKQD2T.js';
-import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-BAMR7HKO.js';
-import { resolveModelConfig } from './chunk-MCUX2D5Q.js';
-import { MastraLLMV1 } from './chunk-JXESKY4A.js';
+import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-YDFX3JR2.js';
+import { resolveModelConfig } from './chunk-D7CJ4HIQ.js';
+import { MastraLLMV1 } from './chunk-B5J5HYDN.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { removeUndefinedValues, selectFields, ensureToolProperties, makeCoreTool, createMastraProxy, delay } from './chunk-D6EDHNGV.js';
+import { removeUndefinedValues, selectFields, ensureToolProperties, makeCoreTool, createMastraProxy, isZodType, delay } from './chunk-PC6EKOWK.js';
 import { wrapMastra, getOrCreateSpan } from './chunk-KIZIOFZC.js';
 import { MastraError, getErrorFromUnknown } from './chunk-JJ5O45LH.js';
-import { ToolStream } from './chunk-HGNRQ3OG.js';
-import { Tool, createTool } from './chunk-KEURQGCQ.js';
+import { ToolStream } from './chunk-5O52O25J.js';
+import { Tool, createTool } from './chunk-XIDKHXNR.js';
 import { RequestContext } from './chunk-GRBGQ2GE.js';
 import { zodToJsonSchema } from './chunk-PJKCPRYF.js';
 import { MastraBase } from './chunk-S6URFGCZ.js';
@@ -20,8 +20,8 @@ import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { getErrorMessage, TypeValidationError } from '@ai-sdk/provider-v5';
 import { generateId, createTextStreamResponse, createUIMessageStreamResponse, createUIMessageStream, asSchema, parsePartialJson, isDeepEqualData, jsonSchema, APICallError, tool, stepCountIs } from 'ai-v5';
-import z5, { z } from 'zod';
 import { OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, GoogleSchemaCompatLayer, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, MetaSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
+import z5, { z } from 'zod';
 import { isEmpty } from 'radash';
 import { isAbortError, injectJsonInstructionIntoMessages } from '@ai-sdk/provider-utils-v5';
 import { Tiktoken } from 'js-tiktoken/lite';
@@ -422,14 +422,22 @@ function prepareToolsAndToolChoice({
               inputSchema: asSchema(sdkTool.inputSchema).jsonSchema,
               providerOptions: sdkTool.providerOptions
             };
-          case "provider-defined":
+          case "provider-defined": {
+            const providerId = sdkTool.id;
+            let providerToolName = name;
+            if (providerId && providerId.includes(".")) {
+              providerToolName = providerId.split(".").slice(1).join(".");
+            } else if (providerId) {
+              providerToolName = providerId;
+            }
             return {
               type: "provider-defined",
-              name,
+              name: providerToolName,
               // TODO: as any seems wrong here. are there cases where we don't have an id?
-              id: sdkTool.id,
+              id: providerId,
               args: sdkTool.args
             };
+          }
           default: {
             const exhaustiveCheck = toolType;
             throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
@@ -935,7 +943,8 @@ async function validateStepInput({
       const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
       validationError = new Error("Step input validation failed: \n" + errorMessages);
     } else {
-      inputData = isEmpty(validatedInput.data) ? prevOutput : validatedInput.data;
+      const isEmptyData = isEmpty(validatedInput.data);
+      inputData = isEmptyData ? prevOutput : validatedInput.data;
     }
   }
   return { inputData, validationError };
@@ -958,6 +967,27 @@ async function validateStepResumeData({ resumeData, step }) {
   }
   return { resumeData, validationError };
 }
+async function validateStepSuspendData({
+  suspendData,
+  step
+}) {
+  if (!suspendData) {
+    return { suspendData: void 0, validationError: void 0 };
+  }
+  let validationError;
+  const suspendSchema = step.suspendSchema;
+  if (suspendSchema) {
+    const validatedSuspendData = await suspendSchema.safeParseAsync(suspendData);
+    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);
+    } else {
+      suspendData = validatedSuspendData.data;
+    }
+  }
+  return { suspendData, validationError };
+}
 function getResumeLabelsByStepId(resumeLabels, stepId) {
   return Object.entries(resumeLabels).filter(([_, value]) => value.stepId === stepId).reduce(
     (acc, [key, value]) => {
@@ -1646,6 +1676,13 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           getInitData: () => stepResults?.input,
           getStepResult: getStepResult.bind(this, stepResults),
           suspend: async (suspendPayload, suspendOptions) => {
+            const { suspendData, validationError: validationError2 } = await validateStepSuspendData({
+              suspendData: suspendPayload,
+              step
+            });
+            if (validationError2) {
+              throw validationError2;
+            }
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
             if (suspendOptions?.resumeLabel) {
               const resumeLabel = Array.isArray(suspendOptions.resumeLabel) ? suspendOptions.resumeLabel : [suspendOptions.resumeLabel];
@@ -1656,7 +1693,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
                 };
               }
             }
-            suspended = { payload: suspendPayload };
+            suspended = { payload: suspendData };
           },
           bail: (result2) => {
             bailed = { payload: result2 };
@@ -2952,7 +2989,7 @@ function mapVariable(config) {
 function createStep(params, agentOptions) {
   if (params instanceof Agent) {
     return {
-      id: params.name,
+      id: params.id,
       description: params.getDescription(),
       // @ts-ignore
       inputSchema: z.object({
@@ -3055,6 +3092,8 @@ function createStep(params, agentOptions) {
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
+      resumeSchema: params.resumeSchema,
+      suspendSchema: params.suspendSchema,
       execute: async ({
         inputData,
         mastra,
@@ -3071,10 +3110,11 @@ function createStep(params, agentOptions) {
           mastra,
           requestContext,
           tracingContext,
-          suspend,
           resumeData,
           workflow: {
             runId,
+            suspend,
+            resumeData,
             workflowId,
             state,
             setState
@@ -3535,6 +3575,7 @@ var Workflow = class extends MastraBase {
     const run = this.#runs.get(runIdToUse) ?? new Run({
       workflowId: this.id,
       stateSchema: this.stateSchema,
+      inputSchema: this.inputSchema,
       runId: runIdToUse,
       resourceId: options?.resourceId,
       executionEngine: this.executionEngine,
@@ -3894,6 +3935,7 @@ var Run = class {
   closeStreamAction;
   executionResults;
   stateSchema;
+  inputSchema;
   cleanup;
   retryConfig;
   constructor(params) {
@@ -3912,6 +3954,7 @@ var Run = class {
     this.workflowSteps = params.workflowSteps;
     this.validateInputs = params.validateInputs;
     this.stateSchema = params.stateSchema;
+    this.inputSchema = params.inputSchema;
     this.workflowRunStatus = "pending";
     this.workflowEngineType = params.workflowEngineType;
   }
@@ -3928,29 +3971,16 @@ var Run = class {
     this.abortController?.abort();
   }
   async _validateInput(inputData) {
-    const firstEntry = this.executionGraph.steps[0];
     let inputDataToUse = inputData;
-    if (firstEntry && this.validateInputs) {
-      let inputSchema;
-      if (firstEntry.type === "step" || firstEntry.type === "foreach" || firstEntry.type === "loop") {
-        const step = firstEntry.step;
-        inputSchema = step.inputSchema;
-      } else if (firstEntry.type === "conditional" || firstEntry.type === "parallel") {
-        const firstStep = firstEntry.steps[0];
-        if (firstStep && firstStep.type === "step") {
-          inputSchema = firstStep.step.inputSchema;
-        }
-      }
-      if (inputSchema) {
-        const validatedInputData = await inputSchema.safeParseAsync(inputData);
-        if (!validatedInputData.success) {
-          const errors = getZodErrors(validatedInputData.error);
-          throw new Error(
-            "Invalid input data: \n" + errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n")
-          );
-        }
-        inputDataToUse = validatedInputData.data;
+    if (this.validateInputs && this.inputSchema) {
+      const validatedInputData = await this.inputSchema.safeParseAsync(inputData);
+      if (!validatedInputData.success) {
+        const errors = getZodErrors(validatedInputData.error);
+        throw new Error(
+          "Invalid input data: \n" + errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n")
+        );
       }
+      inputDataToUse = validatedInputData.data;
     }
     return inputDataToUse;
   }
@@ -5721,23 +5751,22 @@ async function processOutputStream({
       if (runState.state.textDeltas.length) {
         const textStartPayload = chunk.payload;
         const providerMetadata = textStartPayload.providerMetadata ?? runState.state.providerOptions;
-        messageList.add(
-          {
-            id: messageId,
-            role: "assistant",
-            content: [
-              providerMetadata ? {
+        const message = {
+          id: messageId,
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: [
+              {
                 type: "text",
                 text: runState.state.textDeltas.join(""),
-                providerOptions: providerMetadata
-              } : {
-                type: "text",
-                text: runState.state.textDeltas.join("")
+                ...providerMetadata ? { providerMetadata } : {}
               }
             ]
           },
-          "response"
-        );
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        messageList.add(message, "response");
       }
       runState.setState({
         isStreaming: false,
@@ -5817,20 +5846,23 @@ async function processOutputStream({
           providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
         });
         if (Object.values(chunk.payload.providerMetadata || {}).find((v) => v?.redactedData)) {
-          messageList.add(
-            {
-              id: messageId,
-              role: "assistant",
-              content: [
+          const message = {
+            id: messageId,
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: [
                 {
                   type: "reasoning",
-                  text: "",
-                  providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+                  reasoning: "",
+                  details: [{ type: "redacted", data: "" }],
+                  providerMetadata: chunk.payload.providerMetadata ?? runState.state.providerOptions
                 }
               ]
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
           if (isControllerOpen(controller)) {
             controller.enqueue(chunk);
           }
@@ -5856,20 +5888,23 @@ async function processOutputStream({
       }
       case "reasoning-end": {
         if (runState.state.reasoningDeltas.length > 0) {
-          messageList.add(
-            {
-              id: messageId,
-              role: "assistant",
-              content: [
+          const message = {
+            id: messageId,
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: [
                 {
                   type: "reasoning",
-                  text: runState.state.reasoningDeltas.join(""),
-                  providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+                  reasoning: "",
+                  details: [{ type: "text", text: runState.state.reasoningDeltas.join("") }],
+                  providerMetadata: chunk.payload.providerMetadata ?? runState.state.providerOptions
                 }
               ]
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
         }
         runState.setState({
           isReasoning: false,
@@ -5881,25 +5916,31 @@ async function processOutputStream({
         break;
       }
       case "file":
-        messageList.add(
-          {
+        {
+          const message = {
             id: messageId,
             role: "assistant",
-            content: [
-              {
-                type: "file",
-                data: chunk.payload.data,
-                mimeType: chunk.payload.mimeType
-              }
-            ]
-          },
-          "response"
-        );
-        controller.enqueue(chunk);
+            content: {
+              format: 2,
+              parts: [
+                {
+                  type: "file",
+                  // @ts-expect-error
+                  data: chunk.payload.data,
+                  // TODO: incorrect string type
+                  mimeType: chunk.payload.mimeType
+                }
+              ]
+            },
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
+          controller.enqueue(chunk);
+        }
         break;
       case "source":
-        messageList.add(
-          {
+        {
+          const message = {
             id: messageId,
             role: "assistant",
             content: {
@@ -5918,10 +5959,10 @@ async function processOutputStream({
               ]
             },
             createdAt: /* @__PURE__ */ new Date()
-          },
-          "response"
-        );
-        controller.enqueue(chunk);
+          };
+          messageList.add(message, "response");
+          controller.enqueue(chunk);
+        }
         break;
       case "finish":
         runState.setState({
@@ -6260,24 +6301,27 @@ function createLLMExecutionStep({
         return chunk.payload;
       });
       if (toolCalls.length > 0) {
-        const assistantContent = [
-          ...toolCalls.map((toolCall) => {
-            return {
-              type: "tool-call",
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              args: toolCall.args
-            };
-          })
-        ];
-        messageList.add(
-          {
-            id: messageId,
-            role: "assistant",
-            content: assistantContent
+        const message = {
+          id: messageId,
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: toolCalls.map((toolCall) => {
+              return {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "call",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  args: toolCall.args
+                },
+                ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
+              };
+            })
           },
-          "response"
-        );
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        messageList.add(message, "response");
       }
       const finishReason = runState?.state?.stepResult?.reason ?? outputStream._getImmediateFinishReason();
       const hasErrored = runState.state.hasErrored;
@@ -6359,24 +6403,28 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
             };
             rest.controller.enqueue(chunk);
           });
-          rest.messageList.add(
-            {
-              id: toolResultMessageId,
-              role: "tool",
-              content: errorResults.map((toolCall) => {
+          const msg = {
+            id: toolResultMessageId || "",
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: errorResults.map((toolCallErrorResult) => {
                 return {
-                  type: "tool-result",
-                  args: toolCall.args,
-                  toolCallId: toolCall.toolCallId,
-                  toolName: toolCall.toolName,
-                  result: {
-                    tool_execution_error: toolCall.error?.message ?? toolCall.error
-                  }
+                  type: "tool-invocation",
+                  toolInvocation: {
+                    state: "result",
+                    toolCallId: toolCallErrorResult.toolCallId,
+                    toolName: toolCallErrorResult.toolName,
+                    args: toolCallErrorResult.args,
+                    result: toolCallErrorResult.error?.message ?? toolCallErrorResult.error
+                  },
+                  ...toolCallErrorResult.providerMetadata ? { providerMetadata: toolCallErrorResult.providerMetadata } : {}
                 };
               })
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          rest.messageList.add(msg, "response");
         }
         initialResult.stepResult.isContinued = false;
         return bail(initialResult);
@@ -6404,24 +6452,30 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
               })
             });
           }
-          const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
-          rest.messageList.add(
-            {
-              id: toolResultMessageId,
-              role: "tool",
-              content: inputData.map((toolCall2) => {
-                return {
-                  type: "tool-result",
-                  args: toolCall2.args,
-                  toolCallId: toolCall2.toolCallId,
-                  toolName: toolCall2.toolName,
-                  result: toolCall2.result
-                };
-              })
-            },
-            "response"
-          );
         }
+        const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+        const toolResultMessage = {
+          id: toolResultMessageId || "",
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: inputData.map((toolCall) => {
+              return {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  args: toolCall.args,
+                  result: toolCall.result
+                },
+                ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
+              };
+            })
+          },
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        rest.messageList.add(toolResultMessage, "response");
         return {
           ...initialResult,
           messages: {
@@ -6444,13 +6498,87 @@ function createToolCallStep({
   controller,
   runId,
   streamState,
-  modelSpanTracker
+  modelSpanTracker,
+  _internal
 }) {
   return createStep({
     id: "toolCallStep",
     inputSchema: toolCallInputSchema,
     outputSchema: toolCallOutputSchema,
     execute: async ({ inputData, suspend, resumeData, requestContext }) => {
+      const addToolApprovalMetadata = (toolCallId, toolName, args) => {
+        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] = {
+            toolName,
+            args,
+            type: "approval",
+            runId
+            // Store the runId so we can resume after page refresh
+          };
+          lastAssistantMessage.content.metadata = metadata;
+        }
+      };
+      const removeToolApprovalMetadata = async (toolCallId) => {
+        const { saveQueueManager, memoryConfig, threadId } = _internal || {};
+        if (!saveQueueManager || !threadId) {
+          return;
+        }
+        const getMetadata = (message) => {
+          const content = message.content;
+          if (!content) return void 0;
+          const metadata = typeof content.metadata === "object" && content.metadata !== null ? content.metadata : void 0;
+          return metadata;
+        };
+        const allMessages = messageList.get.all.db();
+        const lastAssistantMessage = [...allMessages].reverse().find((msg) => {
+          const metadata = getMetadata(msg);
+          const pendingToolApprovals = metadata?.pendingToolApprovals;
+          return !!pendingToolApprovals?.[toolCallId];
+        });
+        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;
+            }
+            try {
+              await saveQueueManager.flushMessages(messageList, threadId, memoryConfig);
+            } catch (error) {
+              console.error("Error removing tool approval metadata:", error);
+            }
+          }
+        }
+      };
+      const flushMessagesBeforeSuspension = async () => {
+        const { saveQueueManager, memoryConfig, threadId, resourceId, memory } = _internal || {};
+        if (!saveQueueManager || !threadId) {
+          return;
+        }
+        try {
+          if (memory && !_internal.threadExists && resourceId) {
+            const thread = await memory.getThreadById?.({ threadId });
+            if (!thread) {
+              await memory.createThread?.({
+                threadId,
+                resourceId,
+                memoryConfig
+              });
+            }
+            _internal.threadExists = true;
+          }
+          await saveQueueManager.flushMessages(messageList, threadId, memoryConfig);
+        } catch (error) {
+          console.error("Error flushing messages before suspension:", error);
+        }
+      };
       if (inputData.providerExecuted) {
         return {
           ...inputData,
@@ -6490,6 +6618,8 @@ function createToolCallStep({
                 args: inputData.args
               }
             });
+            addToolApprovalMetadata(inputData.toolCallId, inputData.toolName, inputData.args);
+            await flushMessagesBeforeSuspension();
             return suspend(
               {
                 requireToolApproval: {
@@ -6504,6 +6634,7 @@ function createToolCallStep({
               }
             );
           } else {
+            await removeToolApprovalMetadata(inputData.toolCallId);
             if (!resumeData.approved) {
               return {
                 result: "Tool call was not approved by the user",
@@ -6526,6 +6657,7 @@ function createToolCallStep({
               from: "AGENT" /* AGENT */,
               payload: { toolCallId: inputData.toolCallId, toolName: inputData.toolName, suspendPayload }
             });
+            await flushMessagesBeforeSuspension();
             return await suspend(
               {
                 toolCallSuspended: suspendPayload,
@@ -6539,6 +6671,18 @@ function createToolCallStep({
           resumeData
         };
         const result = await tool.execute(inputData.args, toolOptions);
+        if (tool && "onOutput" in tool && typeof tool.onOutput === "function") {
+          try {
+            await tool.onOutput({
+              toolCallId: inputData.toolCallId,
+              toolName: inputData.toolName,
+              output: result,
+              abortSignal: options?.abortSignal
+            });
+          } catch (error) {
+            console.error("Error calling onOutput", error);
+          }
+        }
         return { result, ...inputData };
       } catch (error) {
         return {
@@ -6558,6 +6702,7 @@ function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
     ...rest
   });
   const toolCallStep = createToolCallStep({
+    _internal,
     ...rest
   });
   const llmMappingStep = createLLMMappingStep(
@@ -6582,6 +6727,16 @@ function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
       validateInputs: false
     }
   }).then(llmExecutionStep).map(
+    async ({ inputData }) => {
+      const typedInputData = inputData;
+      const responseMessages = typedInputData.messages.nonUser;
+      if (responseMessages && responseMessages.length > 0) {
+        rest.messageList.add(responseMessages, "response");
+      }
+      return typedInputData;
+    },
+    { id: "add-response-to-messagelist" }
+  ).map(
     async ({ inputData }) => {
       const typedInputData = inputData;
       return typedInputData.output.toolCalls || [];
@@ -6845,7 +7000,13 @@ function loop({
   const internalToUse = {
     now: _internal?.now || (() => Date.now()),
     generateId: _internal?.generateId || (() => generateId()),
-    currentDate: _internal?.currentDate || (() => /* @__PURE__ */ new Date())
+    currentDate: _internal?.currentDate || (() => /* @__PURE__ */ new Date()),
+    saveQueueManager: _internal?.saveQueueManager,
+    memoryConfig: _internal?.memoryConfig,
+    threadId: _internal?.threadId,
+    resourceId: _internal?.resourceId,
+    memory: _internal?.memory,
+    threadExists: _internal?.threadExists
   };
   let startTimestamp = internalToUse.now?.();
   const messageId = rest.experimental_generateMessageId?.() || internalToUse.generateId?.();
@@ -7031,7 +7192,8 @@ var MastraLLMVNext = class extends MastraBase {
     _internal,
     agentId,
     toolCallId,
-    methodType
+    methodType,
+    includeRawChunks
   }) {
     let stopWhenToUse;
     if (maxSteps && typeof maxSteps === "number") {
@@ -7089,6 +7251,7 @@ var MastraLLMVNext = class extends MastraBase {
         requireToolApproval,
         agentId,
         methodType,
+        includeRawChunks,
         options: {
           ...options,
           onStepFinish: async (props) => {
@@ -7126,7 +7289,8 @@ var MastraLLMVNext = class extends MastraBase {
               usage: props?.usage,
               runId
             });
-            if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
+            const remainingTokens = parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"] ?? "", 10);
+            if (!isNaN(remainingTokens) && remainingTokens > 0 && remainingTokens < 2e3) {
               this.logger.warn("Rate limit approaching, waiting 10 seconds", { runId });
               await delay(10 * 1e3);
             }
@@ -7522,11 +7686,13 @@ async function createNetworkLoop({
       const routingAgent = await getRoutingAgent({ requestContext, agent });
       let completionResult;
       const iterationCount = (inputData.iteration ?? -1) + 1;
+      const stepId = generateId3();
       await writer.write({
         type: "routing-agent-start",
         payload: {
+          networkId: agent.id,
           agentId: routingAgent.id,
-          runId,
+          runId: stepId,
           inputData: {
             ...inputData,
             iteration: iterationCount
@@ -7572,7 +7738,7 @@ async function createNetworkLoop({
         await writer.write({
           type: "routing-agent-text-start",
           payload: {
-            runId
+            runId: stepId
           },
           from: "NETWORK" /* NETWORK */,
           runId
@@ -7586,6 +7752,7 @@ async function createNetworkLoop({
             await writer.write({
               type: "routing-agent-text-delta",
               payload: {
+                runId: stepId,
                 text: currentSlice
               },
               from: "NETWORK" /* NETWORK */,
@@ -7614,6 +7781,7 @@ async function createNetworkLoop({
               await writer.write({
                 type: "routing-agent-text-delta",
                 payload: {
+                  runId: stepId,
                   text: currentSlice
                 },
                 from: "NETWORK" /* NETWORK */,
@@ -7634,7 +7802,7 @@ async function createNetworkLoop({
             isComplete: true,
             selectionReason: completionResult.object.completionReason || "",
             iteration: iterationCount,
-            runId
+            runId: stepId
           };
           await writer.write({
             type: "routing-agent-end",
@@ -7736,7 +7904,7 @@ ${completionResult?.object?.finalResult}` : ""}
         isComplete: object.primitiveId === "none" && object.primitiveType === "none",
         selectionReason: object.selectionReason,
         iteration: iterationCount,
-        runId
+        runId: stepId
       };
       await writer.write({
         type: "routing-agent-end",
@@ -7772,23 +7940,24 @@ ${completionResult?.object?.finalResult}` : ""}
     }),
     execute: async ({ inputData, writer, getInitData }) => {
       const agentsMap = await agent.listAgents({ requestContext });
-      const agentId = inputData.primitiveId;
-      const agentForStep = agentsMap[agentId];
+      const agentForStep = agentsMap[inputData.primitiveId];
       if (!agentForStep) {
         const mastraError = new MastraError({
           id: "AGENT_NETWORK_AGENT_EXECUTION_STEP_INVALID_TASK_INPUT",
           domain: "AGENT_NETWORK" /* AGENT_NETWORK */,
           category: "USER" /* USER */,
-          text: `Agent ${agentId} not found`
+          text: `Agent ${inputData.primitiveId} not found`
         });
         throw mastraError;
       }
+      const agentId = agentForStep.id;
+      const stepId = generateId3();
       await writer.write({
         type: "agent-execution-start",
         payload: {
-          agentId: inputData.primitiveId,
+          agentId,
           args: inputData,
-          runId
+          runId: stepId
         },
         from: "NETWORK" /* NETWORK */,
         runId
@@ -7800,9 +7969,12 @@ ${completionResult?.object?.finalResult}` : ""}
       for await (const chunk of result.fullStream) {
         await writer.write({
           type: `agent-execution-event-${chunk.type}`,
-          payload: chunk,
-          runId: chunk.runId,
-          from: "NETWORK" /* NETWORK */
+          payload: {
+            ...chunk,
+            runId: stepId
+          },
+          from: "NETWORK" /* NETWORK */,
+          runId
         });
       }
       const memory = await agent.getMemory({ requestContext });
@@ -7838,10 +8010,11 @@ ${completionResult?.object?.finalResult}` : ""}
       });
       const endPayload = {
         task: inputData.task,
-        agentId: inputData.primitiveId,
+        agentId,
         result: await result.text,
         isComplete: false,
-        iteration: inputData.iteration
+        iteration: inputData.iteration,
+        runId: stepId
       };
       await writer.write({
         type: "agent-execution-end",
@@ -7910,11 +8083,12 @@ ${completionResult?.object?.finalResult}` : ""}
         );
         throw mastraError;
       }
+      const stepId = generateId3();
       const run = await wf.createRun({ runId });
       const toolData = {
-        name: wf.name,
+        workflowId: wf.id,
         args: inputData,
-        runId
+        runId: stepId
       };
       await writer?.write({
         type: "workflow-execution-start",
@@ -7927,13 +8101,16 @@ ${completionResult?.object?.finalResult}` : ""}
         requestContext
       });
       let chunks = [];
-      for await (const chunk of stream) {
+      for await (const chunk of stream.fullStream) {
         chunks.push(chunk);
         await writer?.write({
           type: `workflow-execution-event-${chunk.type}`,
-          payload: chunk,
-          runId: chunk.runId,
-          from: "NETWORK" /* NETWORK */
+          payload: {
+            ...chunk,
+            runId: stepId
+          },
+          from: "NETWORK" /* NETWORK */,
+          runId
         });
       }
       let runSuccess = true;
@@ -7975,13 +8152,15 @@ ${completionResult?.object?.finalResult}` : ""}
         primitiveType: inputData.primitiveType,
         result: finalResult,
         isComplete: false,
-        iteration: inputData.iteration,
-        name: wf.name
+        iteration: inputData.iteration
       };
       await writer?.write({
         type: "workflow-execution-end",
         payload: {
           ...endPayload,
+          result: workflowState,
+          name: wf.name,
+          runId: stepId,
           usage: await stream.usage
         },
         from: "NETWORK" /* NETWORK */,
@@ -8016,14 +8195,13 @@ ${completionResult?.object?.finalResult}` : ""}
       const memory = await agent.getMemory({ requestContext });
       const memoryTools = await memory?.listTools?.();
       const toolsMap = { ...agentTools, ...memoryTools };
-      const toolId = inputData.primitiveId;
-      let tool = toolsMap[toolId];
+      let tool = toolsMap[inputData.primitiveId];
       if (!tool) {
         const mastraError = new MastraError({
           id: "AGENT_NETWORK_TOOL_EXECUTION_STEP_INVALID_TASK_INPUT",
           domain: "AGENT_NETWORK" /* AGENT_NETWORK */,
           category: "USER" /* USER */,
-          text: `Tool ${toolId} not found`
+          text: `Tool ${inputData.primitiveId} not found`
         });
         throw mastraError;
       }
@@ -8032,10 +8210,11 @@ ${completionResult?.object?.finalResult}` : ""}
           id: "AGENT_NETWORK_TOOL_EXECUTION_STEP_INVALID_TASK_INPUT",
           domain: "AGENT_NETWORK" /* AGENT_NETWORK */,
           category: "USER" /* USER */,
-          text: `Tool ${toolId} does not have an execute function`
+          text: `Tool ${inputData.primitiveId} does not have an execute function`
         });
         throw mastraError;
       }
+      const toolId = tool.id;
       let inputDataToUse;
       try {
         inputDataToUse = JSON.parse(inputData.prompt);
@@ -11847,6 +12026,7 @@ function createMapResultsStep({
       stopWhen: result.stopWhen,
       maxSteps: result.maxSteps,
       providerOptions: result.providerOptions,
+      includeRawChunks: options.includeRawChunks,
       options: {
         ...options.prepareStep && { prepareStep: options.prepareStep },
         onFinish: async (payload) => {
@@ -12202,7 +12382,11 @@ function createStreamStep({
   resumeContext,
   agentId,
   toolCallId,
-  methodType
+  methodType,
+  saveQueueManager,
+  memoryConfig,
+  memory,
+  resourceId
 }) {
   return createStep({
     id: "stream-text-step",
@@ -12229,7 +12413,12 @@ function createStreamStep({
         requireToolApproval,
         resumeContext,
         _internal: {
-          generateId: capabilities.generateMessageId
+          generateId: capabilities.generateMessageId,
+          saveQueueManager,
+          memoryConfig,
+          threadId: validatedInputData.threadId,
+          resourceId,
+          memory
         },
         agentId,
         toolCallId,
@@ -12290,7 +12479,11 @@ function createPrepareStreamWorkflow({
     resumeContext,
     agentId,
     toolCallId,
-    methodType
+    methodType,
+    saveQueueManager,
+    memoryConfig,
+    memory,
+    resourceId
   });
   const mapResultsStep = createMapResultsStep({
     capabilities,
@@ -13331,7 +13524,8 @@ var Agent = class extends MastraBase {
           requestContext,
           tracingContext,
           model: await this.getModel({ requestContext }),
-          tracingPolicy: this.#options?.tracingPolicy
+          tracingPolicy: this.#options?.tracingPolicy,
+          requireApproval: toolObj.requireApproval
         };
         const convertedToCoreTool = makeCoreTool(toolObj, options);
         convertedMemoryTools[toolName] = convertedToCoreTool;
@@ -13529,7 +13723,8 @@ var Agent = class extends MastraBase {
             requestContext,
             tracingContext,
             model: await this.getModel({ requestContext }),
-            tracingPolicy: this.#options?.tracingPolicy
+            tracingPolicy: this.#options?.tracingPolicy,
+            requireApproval: toolObj.requireApproval
           };
           const convertedToCoreTool = makeCoreTool(toolObj, options, "toolset");
           toolsForRequest[toolName] = convertedToCoreTool;
@@ -13572,7 +13767,8 @@ var Agent = class extends MastraBase {
           requestContext,
           tracingContext,
           model: await this.getModel({ requestContext }),
-          tracingPolicy: this.#options?.tracingPolicy
+          tracingPolicy: this.#options?.tracingPolicy,
+          requireApproval: tool.requireApproval
         };
         const convertedToCoreTool = makeCoreTool(rest, options, "client-tool");
         toolsForRequest[toolName] = convertedToCoreTool;
@@ -13597,7 +13793,11 @@ var Agent = class extends MastraBase {
     if (Object.keys(agents).length > 0) {
       for (const [agentName, agent] of Object.entries(agents)) {
         const agentInputSchema = z.object({
-          prompt: z.string().describe("The prompt to send to the agent")
+          prompt: z.string().describe("The prompt to send to the agent"),
+          threadId: z.string().optional().describe("Thread ID for conversation continuity for memory messages"),
+          resourceId: z.string().optional().describe("Resource/user identifier for memory messages"),
+          instructions: z.string().optional().describe("Custom instructions to override agent defaults"),
+          maxSteps: z.number().optional().describe("Maximum number of execution steps for the sub-agent")
         });
         const agentOutputSchema = z.object({
           text: z.string().describe("The response from the agent"),
@@ -13611,7 +13811,6 @@ var Agent = class extends MastraBase {
           inputSchema: agentInputSchema,
           outputSchema: agentOutputSchema,
           mastra: this.#mastra,
-          // BREAKING CHANGE v1.0: New tool signature - first param is inputData, second is context
           // manually wrap agent tools with tracing, so that we can pass the
           // current tool span onto the agent to maintain continuity of the trace
           execute: async (inputData, context) => {
@@ -13624,16 +13823,18 @@ var Agent = class extends MastraBase {
                 resourceId
               });
               let result;
+              const slugify = await import('@sindresorhus/slugify');
+              const subAgentThreadId = inputData.threadId || context?.mastra?.generateId() || randomUUID();
+              const subAgentResourceId = inputData.resourceId || context?.mastra?.generateId() || `${slugify.default(this.id)}-${agentName}`;
               if ((methodType === "generate" || methodType === "generateLegacy") && modelVersion === "v2") {
                 if (!agent.hasOwnMemory() && this.#memory) {
                   agent.__setMemory(this.#memory);
                 }
-                const subAgentThreadId = randomUUID();
-                const slugify = await import('@sindresorhus/slugify');
-                const subAgentResourceId = `${slugify.default(this.id)}-${agentName}`;
                 const generateResult = await agent.generate(inputData.prompt, {
                   requestContext,
                   tracingContext: context?.tracingContext,
+                  ...inputData.instructions && { instructions: inputData.instructions },
+                  ...inputData.maxSteps && { maxSteps: inputData.maxSteps },
                   ...resourceId && threadId ? {
                     memory: {
                       resource: subAgentResourceId,
@@ -13652,12 +13853,11 @@ var Agent = class extends MastraBase {
                 if (!agent.hasOwnMemory() && this.#memory) {
                   agent.__setMemory(this.#memory);
                 }
-                const subAgentThreadId = randomUUID();
-                const slugify = await import('@sindresorhus/slugify');
-                const subAgentResourceId = `${slugify.default(this.id)}-${agentName}`;
                 const streamResult = await agent.stream(inputData.prompt, {
                   requestContext,
                   tracingContext: context?.tracingContext,
+                  ...inputData.instructions && { instructions: inputData.instructions },
+                  ...inputData.maxSteps && { maxSteps: inputData.maxSteps },
                   ...resourceId && threadId ? {
                     memory: {
                       resource: subAgentResourceId,
@@ -13668,7 +13868,11 @@ var Agent = class extends MastraBase {
                 let fullText = "";
                 for await (const chunk of streamResult.fullStream) {
                   if (context?.writer) {
-                    await context.writer.write(chunk);
+                    if (chunk.type.startsWith("data-")) {
+                      await context.writer.custom(chunk);
+                    } else {
+                      await context.writer.write(chunk);
+                    }
                   }
                   if (chunk.type === "text-delta") {
                     fullText += chunk.payload.text;
@@ -13683,7 +13887,11 @@ var Agent = class extends MastraBase {
                 let fullText = "";
                 for await (const chunk of streamResult.fullStream) {
                   if (context?.writer) {
-                    await context.writer.write(chunk);
+                    if (chunk.type.startsWith("data-")) {
+                      await context.writer.custom(chunk);
+                    } else {
+                      await context.writer.write(chunk);
+                    }
                   }
                   if (chunk.type === "text-delta") {
                     fullText += chunk.textDelta;
@@ -13750,13 +13958,25 @@ var Agent = class extends MastraBase {
     const workflows = await this.listWorkflows({ requestContext });
     if (Object.keys(workflows).length > 0) {
       for (const [workflowName, workflow] of Object.entries(workflows)) {
+        const extendedInputSchema = z.object({
+          inputData: workflow.inputSchema,
+          ...workflow.stateSchema ? { initialState: workflow.stateSchema } : {}
+        });
         const toolObj = createTool({
           id: `workflow-${workflowName}`,
           description: workflow.description || `Workflow: ${workflowName}`,
-          inputSchema: workflow.inputSchema,
-          outputSchema: z.object({ result: workflow.outputSchema, runId: z.string() }),
+          inputSchema: extendedInputSchema,
+          outputSchema: z.union([
+            z.object({
+              result: workflow.outputSchema,
+              runId: z.string().describe("Unique identifier for the workflow run")
+            }),
+            z.object({
+              runId: z.string().describe("Unique identifier for the workflow run"),
+              error: z.string().describe("Error message if workflow execution failed")
+            })
+          ]),
           mastra: this.#mastra,
-          // BREAKING CHANGE v1.0: New tool signature - first param is inputData, second is context
           // manually wrap workflow tools with tracing, so that we can pass the
           // current tool span onto the workflow to maintain continuity of the trace
           execute: async (inputData, context) => {
@@ -13770,16 +13990,18 @@ var Agent = class extends MastraBase {
                 resourceId
               });
               const run = await workflow.createRun();
-              let result;
+              const { initialState, inputData: workflowInputData } = inputData;
+              let result = void 0;
               if (methodType === "generate" || methodType === "generateLegacy") {
                 result = await run.start({
-                  inputData,
+                  inputData: workflowInputData,
                   requestContext,
-                  tracingContext: context?.tracingContext
+                  tracingContext: context?.tracingContext,
+                  ...initialState && { initialState }
                 });
               } else if (methodType === "streamLegacy") {
                 const streamResult = run.streamLegacy({
-                  inputData,
+                  inputData: workflowInputData,
                   requestContext,
                   tracingContext: context?.tracingContext
                 });
@@ -13792,17 +14014,36 @@ var Agent = class extends MastraBase {
                 result = await streamResult.getWorkflowState();
               } else if (methodType === "stream") {
                 const streamResult = run.stream({
-                  inputData,
+                  inputData: workflowInputData,
                   requestContext,
-                  tracingContext: context?.tracingContext
+                  tracingContext: context?.tracingContext,
+                  ...initialState && { initialState }
                 });
                 if (context?.writer) {
                   await streamResult.fullStream.pipeTo(context.writer);
                 }
                 result = await streamResult.result;
               }
-              const workflowOutput = result?.result || result;
-              return { result: workflowOutput, runId: run.runId };
+              if (result?.status === "success") {
+                const workflowOutput = result?.result || result;
+                return { result: workflowOutput, runId: run.runId };
+              } else if (result?.status === "failed") {
+                const workflowOutputError = result?.error;
+                return {
+                  error: workflowOutputError?.message || String(workflowOutputError) || "Workflow execution failed",
+                  runId: run.runId
+                };
+              } else if (result?.status === "suspended") {
+                return {
+                  error: `Workflow ended with status: "suspended". This is not currently handled in the basic agent workflow tool transformation. To achieve this you'll need to write your own tool that uses a workflow internally.`,
+                  runId: run.runId
+                };
+              } else {
+                return {
+                  error: `Workflow should never reach this path, workflow returned no status`,
+                  runId: run.runId
+                };
+              }
             } catch (err) {
               const mastraError = new MastraError(
                 {
@@ -14177,6 +14418,34 @@ var Agent = class extends MastraBase {
       );
     }
     const llm = await this.getLLM({ requestContext, model: options.model });
+    if ("structuredOutput" in options && options.structuredOutput && options.structuredOutput.schema) {
+      let structuredOutputModel = llm.getModel();
+      if (options.structuredOutput?.model) {
+        structuredOutputModel = await this.resolveModelConfig(
+          options.structuredOutput?.model,
+          requestContext
+        );
+      }
+      const targetProvider = structuredOutputModel.provider;
+      const targetModelId = structuredOutputModel.modelId;
+      if (targetProvider.includes("openai") || targetModelId.includes("openai")) {
+        if (isZodType(options.structuredOutput.schema) && targetModelId) {
+          const modelInfo = {
+            provider: targetProvider,
+            modelId: targetModelId,
+            supportsStructuredOutputs: false
+            // Set to false to enable transform
+          };
+          const isReasoningModel = /^o[1-5]/.test(targetModelId);
+          const compatLayer = isReasoningModel ? new OpenAIReasoningSchemaCompatLayer(modelInfo) : new OpenAISchemaCompatLayer(modelInfo);
+          if (compatLayer.shouldApply() && options.structuredOutput.schema) {
+            options.structuredOutput.schema = compatLayer.processZodType(
+              options.structuredOutput.schema
+            );
+          }
+        }
+      }
+    }
     const runId = options.runId || this.#mastra?.generateId() || randomUUID();
     const instructions = options.instructions || await this.getInstructions({ requestContext });
     const agentSpan = getOrCreateSpan({
@@ -16493,6 +16762,6 @@ var MastraModelOutput = class extends MastraBase {
   }
 };
 
-export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, LanguageDetector, MastraAgentNetworkStream, MastraModelOutput, ModerationProcessor, PIIDetector, ProcessorState, PromptInjectionDetector, Run, StructuredOutputProcessor, SystemPromptScrubber, TokenLimiterProcessor, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, cloneStep, cloneWorkflow, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createTimeTravelExecutionParams, createWorkflow, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, loop, mapVariable, resolveThreadIdFromArgs, runCountDeprecationMessage, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData };
-//# sourceMappingURL=chunk-CKGIPST2.js.map
-//# sourceMappingURL=chunk-CKGIPST2.js.map
+export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, LanguageDetector, MastraAgentNetworkStream, MastraModelOutput, ModerationProcessor, PIIDetector, ProcessorState, PromptInjectionDetector, Run, StructuredOutputProcessor, SystemPromptScrubber, TokenLimiterProcessor, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, cloneStep, cloneWorkflow, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createTimeTravelExecutionParams, createWorkflow, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, loop, mapVariable, resolveThreadIdFromArgs, runCountDeprecationMessage, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData, validateStepSuspendData };
+//# sourceMappingURL=chunk-XBO6W7LZ.js.map
+//# sourceMappingURL=chunk-XBO6W7LZ.js.map