@mastra/core 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/{chunk-IC2MIQBW.js → chunk-UVOQLIWL.js}

@@ -1,20 +1,20 @@
-import { DefaultVoice } from './chunk-EK7E4ETB.js';
+import { DefaultVoice } from './chunk-TX5GUG5Q.js';
 import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-YEQB4VUA.js';
-import { InMemoryStore } from './chunk-HJXEZSNI.js';
-import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-CISH55FP.js';
-import { createTextStreamResponse, createUIMessageStreamResponse, createUIMessageStream, parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-3RFSIHFR.js';
-import { generateId, asSchema, jsonSchema, APICallError, tool } from './chunk-7JGQWNV5.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-FT7DFPAL.js';
-import { MastraLLMV1 } from './chunk-AIJ6HPJG.js';
+import { InMemoryStore } from './chunk-3XY64RAM.js';
+import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-PSIJ6OSV.js';
+import { parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-K2LPTKSY.js';
+import { generateId, asSchema, jsonSchema, APICallError, tool } from './chunk-CPLRD2VP.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-YYNZEEOO.js';
+import { MastraLLMV1 } from './chunk-UL7TJCKA.js';
 import { PubSub } from './chunk-BVUMKER5.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, isZodType, deepMerge, selectFields, delay } from './chunk-3CZ42NBZ.js';
-import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-PC3FBUWH.js';
+import { isZodType, removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, selectFields, delay } from './chunk-5UVSKF5L.js';
+import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-C4CIC3LZ.js';
 import { MastraError, getErrorFromUnknown } from './chunk-FJEVLHJT.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
-import { Tool, createTool } from './chunk-KGE3KAM7.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 { Tool, createTool } from './chunk-N3PAHTKU.js';
+import { RequestContext, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from './chunk-Y22QMA7S.js';
+import { zodToJsonSchema } from './chunk-PJKCPRYF.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 import { RegisteredLogger, ConsoleLogger } from './chunk-NRUZYMHE.js';
 import { __commonJS, __toESM } from './chunk-7D4SUZUM.js';
@@ -23,9 +23,9 @@ import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { ReadableStream as ReadableStream$1, TransformStream, WritableStream as WritableStream$1 } from 'stream/web';
 import EventEmitter2, { EventEmitter } from 'events';
-import { getErrorMessage, TypeValidationError } from '@ai-sdk/provider-v5';
+import { TypeValidationError } from '@ai-sdk/provider-v5';
 import { OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, isZodType as isZodType$1, GoogleSchemaCompatLayer, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, MetaSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
-import { zodToJsonSchema } from '@mastra/schema-compat/zod-to-json';
+import { zodToJsonSchema as zodToJsonSchema$1 } from '@mastra/schema-compat/zod-to-json';
 import z4 from 'zod/v4';
 import { isEmpty } from 'radash';
 import { isAbortError, injectJsonInstructionIntoMessages } from '@ai-sdk/provider-utils-v5';
@@ -176,6 +176,7 @@ var MastraAgentNetworkStream = class extends ReadableStream$1 {
   #objectStreamController = null;
   #objectStream = null;
   #run;
+  runId;
   constructor({
     createStream,
     run
@@ -289,6 +290,7 @@ var MastraAgentNetworkStream = class extends ReadableStream$1 {
     });
     this.#run = run;
     this.#streamPromise = deferredPromise;
+    this.runId = run.runId;
     this.#objectPromise = objectDeferredPromise;
     this.#objectStream = new ReadableStream$1({
       start: (ctrl) => {
@@ -324,16 +326,6 @@ var MastraAgentNetworkStream = class extends ReadableStream$1 {
 };
 
 // src/stream/aisdk/v5/compat/ui-message.ts
-function getResponseUIMessageId({
-  originalMessages,
-  responseMessageId
-}) {
-  if (originalMessages == null) {
-    return void 0;
-  }
-  const lastMessage = originalMessages[originalMessages.length - 1];
-  return lastMessage?.role === "assistant" ? lastMessage.id : typeof responseMessageId === "function" ? responseMessageId() : responseMessageId;
-}
 function convertFullStreamChunkToUIMessageStream({
   part,
   messageMetadataValue,
@@ -592,7 +584,8 @@ var DelayedPromise = class {
 function isProviderTool(tool2) {
   if (typeof tool2 !== "object" || tool2 === null) return false;
   const t = tool2;
-  return typeof t.id === "string" && t.id.includes(".");
+  const isProviderType = t.type === "provider-defined" || t.type === "provider";
+  return isProviderType && typeof t.id === "string";
 }
 function getProviderToolName(providerId) {
   return providerId.split(".").slice(1).join(".");
@@ -1824,7 +1817,7 @@ function asJsonSchema(schema) {
     return schema;
   }
   if (isZodType$1(schema)) {
-    return zodToJsonSchema(schema);
+    return zodToJsonSchema$1(schema);
   }
   if (schema.jsonSchema) {
     return schema.jsonSchema;
@@ -2161,7 +2154,7 @@ var EnumFormatHandler = class extends BaseFormatHandler {
     }
     let enumValues;
     if (this.isZodSchema(this.schema)) {
-      const convertedSchema = zodToJsonSchema(this.schema);
+      const convertedSchema = zodToJsonSchema$1(this.schema);
       enumValues = convertedSchema?.enum;
     } else if (typeof this.schema === "object" && !this.schema.jsonSchema) {
       const wrappedSchema = jsonSchema(this.schema);
@@ -2330,7 +2323,7 @@ function createJsonTextStreamTransformer(schema) {
       if (chunk.type !== "object" || !chunk.object) {
         return;
       }
-      if (outputSchema?.outputFormat === "array") {
+      if (outputSchema?.outputFormat === "array" && Array.isArray(chunk.object)) {
         chunkCount++;
         if (chunkCount === 1) {
           if (chunk.object.length > 0) {
@@ -2877,6 +2870,7 @@ var MastraModelOutput = class extends MastraBase {
                       uiMessages: messageList.get.response.aiV5.ui()
                     };
                   }
+                  chunk.payload.response = response;
                 } else if (!self.#options.isLLMExecutionStep) {
                   this.resolvePromises({
                     text: self.#bufferedText.join(""),
@@ -3222,7 +3216,6 @@ var MastraModelOutput = class extends MastraBase {
     const steps = await this.steps;
     const textFromSteps = steps.map((step) => step.text || "").join("");
     const fullOutput = {
-      // Use text calculated from steps to properly exclude rejected responses
       text: textFromSteps,
       usage: await this.usage,
       steps,
@@ -3244,7 +3237,11 @@ var MastraModelOutput = class extends MastraBase {
       ...scoringData ? { scoringData } : {},
       traceId: this.traceId,
       runId: this.runId,
-      suspendPayload: await this.suspendPayload
+      suspendPayload: await this.suspendPayload,
+      // All messages from this execution (input + memory history + response)
+      messages: this.messageList.get.all.db(),
+      // Only messages loaded from memory (conversation history)
+      rememberedMessages: this.messageList.get.remembered.db()
     };
     return fullOutput;
   }
@@ -4342,294 +4339,6 @@ function normalizeFinishReason(finishReason) {
   return finishReason === "unknown" ? "other" : finishReason;
 }
 
-// src/stream/aisdk/v5/output.ts
-var AISDKV5OutputStream = class {
-  #modelOutput;
-  #options;
-  #messageList;
-  /**
-   * Trace ID used on the execution (if the execution was traced).
-   */
-  traceId;
-  constructor({
-    modelOutput,
-    options,
-    messageList
-  }) {
-    this.#modelOutput = modelOutput;
-    this.#options = options;
-    this.#messageList = messageList;
-    this.traceId = options.tracingContext?.currentSpan?.externalTraceId;
-  }
-  toTextStreamResponse(init) {
-    return createTextStreamResponse({
-      // Type assertion needed due to ReadableStream type mismatch between Node.js (stream/web) and DOM types
-      // Both have the same interface but TypeScript treats them as incompatible
-      textStream: this.#modelOutput.textStream,
-      ...init
-    });
-  }
-  toUIMessageStreamResponse({
-    generateMessageId,
-    originalMessages,
-    sendFinish,
-    sendReasoning,
-    sendSources,
-    onError,
-    sendStart,
-    messageMetadata,
-    onFinish,
-    ...init
-  } = {}) {
-    return createUIMessageStreamResponse({
-      stream: this.toUIMessageStream({
-        generateMessageId,
-        originalMessages,
-        sendFinish,
-        sendReasoning,
-        sendSources,
-        onError,
-        sendStart,
-        messageMetadata,
-        onFinish
-      }),
-      ...init
-    });
-  }
-  toUIMessageStream({
-    generateMessageId,
-    originalMessages,
-    sendFinish = true,
-    sendReasoning = true,
-    sendSources = false,
-    onError = getErrorMessage,
-    sendStart = true,
-    messageMetadata,
-    onFinish
-  } = {}) {
-    let responseMessageId = generateMessageId != null ? getResponseUIMessageId({
-      originalMessages,
-      responseMessageId: generateMessageId
-    }) : void 0;
-    return createUIMessageStream({
-      onError,
-      onFinish,
-      generateId: () => responseMessageId ?? generateMessageId?.() ?? generateId(),
-      execute: async ({ writer }) => {
-        for await (const part of this.fullStream) {
-          const messageMetadataValue = messageMetadata?.({ part });
-          const partType = part.type;
-          responseMessageId = this.#modelOutput.messageId;
-          const transformedChunk = convertFullStreamChunkToUIMessageStream({
-            part,
-            sendReasoning,
-            messageMetadataValue,
-            sendSources,
-            sendStart,
-            sendFinish,
-            responseMessageId,
-            onError
-          });
-          if (transformedChunk) {
-            writer.write(transformedChunk);
-          }
-          if (messageMetadataValue != null && partType !== "start" && partType !== "finish") {
-            writer.write({
-              type: "message-metadata",
-              messageMetadata: messageMetadataValue
-            });
-          }
-        }
-      }
-    });
-  }
-  async consumeStream(options) {
-    await this.#modelOutput.consumeStream(options);
-  }
-  get sources() {
-    return this.#modelOutput.sources.then(
-      (sources) => sources.map((source) => {
-        return convertMastraChunkToAISDKv5({
-          chunk: source
-        });
-      })
-    );
-  }
-  get files() {
-    return this.#modelOutput.files.then(
-      (files) => files.map((file) => {
-        if (file.type === "file") {
-          const result = convertMastraChunkToAISDKv5({
-            chunk: file
-          });
-          return result && "file" in result ? result.file : void 0;
-        }
-        return;
-      }).filter(Boolean)
-    );
-  }
-  get text() {
-    return this.#modelOutput.text;
-  }
-  /**
-   * Stream of valid JSON chunks. The final JSON result is validated against the output schema when the stream ends.
-   */
-  get objectStream() {
-    return this.#modelOutput.objectStream;
-  }
-  get toolCalls() {
-    return this.#modelOutput.toolCalls.then(
-      (toolCalls) => toolCalls.map((toolCall) => {
-        return convertMastraChunkToAISDKv5({
-          chunk: toolCall
-        });
-      })
-    );
-  }
-  get toolResults() {
-    return this.#modelOutput.toolResults.then(
-      (toolResults) => toolResults.map((toolResult) => {
-        return convertMastraChunkToAISDKv5({
-          chunk: toolResult
-        });
-      })
-    );
-  }
-  get reasoningText() {
-    return this.#modelOutput.reasoningText;
-  }
-  get reasoning() {
-    return this.#modelOutput.reasoning.then((reasoningChunk) => {
-      return reasoningChunk.map((reasoningPart) => {
-        return {
-          providerMetadata: reasoningPart.payload.providerMetadata,
-          text: reasoningPart.payload.text,
-          type: "reasoning"
-        };
-      });
-    });
-  }
-  get warnings() {
-    return this.#modelOutput.warnings;
-  }
-  get usage() {
-    return this.#modelOutput.usage;
-  }
-  get finishReason() {
-    return this.#modelOutput.finishReason;
-  }
-  get providerMetadata() {
-    return this.#modelOutput.providerMetadata;
-  }
-  get request() {
-    return this.#modelOutput.request;
-  }
-  get totalUsage() {
-    return this.#modelOutput.totalUsage;
-  }
-  get response() {
-    return this.#modelOutput.response.then((response) => ({
-      ...response
-    }));
-  }
-  get steps() {
-    return this.#modelOutput.steps.then((steps) => steps);
-  }
-  get content() {
-    return this.#messageList.get.response.aiV5.modelContent();
-  }
-  /**
-   * Stream of only text content, compatible with streaming text responses.
-   */
-  get textStream() {
-    return this.#modelOutput.textStream;
-  }
-  /**
-   * Stream of individual array elements when output schema is an array type.
-   */
-  get elementStream() {
-    return this.#modelOutput.elementStream;
-  }
-  /**
-   * Stream of all chunks in AI SDK v5 format.
-   */
-  get fullStream() {
-    let startEvent;
-    let hasStarted = false;
-    return this.#modelOutput.fullStream.pipeThrough(
-      new TransformStream({
-        transform(chunk, controller) {
-          if (chunk.type === "object") {
-            controller.enqueue(chunk);
-            return;
-          }
-          if (chunk.type === "step-start" && !startEvent) {
-            startEvent = convertMastraChunkToAISDKv5({
-              chunk
-            });
-            return;
-          } else if (chunk.type !== "error") {
-            hasStarted = true;
-          }
-          if (startEvent && hasStarted) {
-            controller.enqueue(startEvent);
-            startEvent = void 0;
-          }
-          if ("payload" in chunk) {
-            const transformedChunk = convertMastraChunkToAISDKv5({
-              chunk
-            });
-            if (transformedChunk) {
-              controller.enqueue(transformedChunk);
-            }
-          }
-        }
-      })
-    );
-  }
-  async getFullOutput() {
-    await this.consumeStream({
-      onError: (error) => {
-        throw error;
-      }
-    });
-    const object = await this.object;
-    const fullOutput = {
-      text: await this.#modelOutput.text,
-      usage: await this.#modelOutput.usage,
-      steps: await this.steps,
-      finishReason: await this.#modelOutput.finishReason,
-      warnings: await this.#modelOutput.warnings,
-      providerMetadata: await this.#modelOutput.providerMetadata,
-      request: await this.#modelOutput.request,
-      reasoning: await this.reasoning,
-      reasoningText: await this.reasoningText,
-      toolCalls: await this.toolCalls,
-      toolResults: await this.toolResults,
-      sources: await this.sources,
-      files: await this.files,
-      response: await this.response,
-      content: this.content,
-      totalUsage: await this.#modelOutput.totalUsage,
-      error: this.error,
-      tripwire: this.#modelOutput.tripwire,
-      traceId: this.traceId,
-      ...object ? { object } : {}
-    };
-    fullOutput.response.messages = this.#modelOutput.messageList.get.response.aiV5.model();
-    return fullOutput;
-  }
-  get tripwire() {
-    return this.#modelOutput.tripwire;
-  }
-  get error() {
-    return this.#modelOutput.error;
-  }
-  get object() {
-    return this.#modelOutput.object;
-  }
-};
-
 // src/agent/trip-wire.ts
 var TripWire = class extends Error {
   options;
@@ -5072,7 +4781,7 @@ async function validateStepInput({
 }) {
   let inputData = prevOutput;
   let validationError;
-  if (validateInputs) {
+  if (validateInputs && isZodType(step.inputSchema)) {
     const inputSchema = step.inputSchema;
     const validatedInput = await inputSchema.safeParseAsync(prevOutput);
     if (!validatedInput.success) {
@@ -5101,7 +4810,7 @@ async function validateStepResumeData({ resumeData, step }) {
   }
   let validationError;
   const resumeSchema = step.resumeSchema;
-  if (resumeSchema) {
+  if (resumeSchema && isZodType(resumeSchema)) {
     const validatedResumeData = await resumeSchema.safeParseAsync(resumeData);
     if (!validatedResumeData.success) {
       const errors = getZodErrors(validatedResumeData.error);
@@ -5132,7 +4841,7 @@ async function validateStepSuspendData({
   }
   let validationError;
   const suspendSchema = step.suspendSchema;
-  if (suspendSchema && validateInputs) {
+  if (suspendSchema && validateInputs && isZodType(suspendSchema)) {
     const validatedSuspendData = await suspendSchema.safeParseAsync(suspendData);
     if (!validatedSuspendData.success) {
       const errors = getZodErrors(validatedSuspendData.error);
@@ -5163,7 +4872,7 @@ async function validateStepStateData({
   }
   let validationError;
   const stateSchema = step.stateSchema;
-  if (stateSchema && validateInputs) {
+  if (stateSchema && validateInputs && isZodType(stateSchema)) {
     const validatedStateData = await stateSchema.safeParseAsync(stateData);
     if (!validatedStateData.success) {
       const errors = getZodErrors(validatedStateData.error);
@@ -5344,15 +5053,19 @@ async function executeParallel(engine, params) {
     disableScorers,
     perStep
   } = params;
-  const parallelSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_parallel" /* WORKFLOW_PARALLEL */,
-    name: `parallel: '${entry.steps.length} branches'`,
-    input: engine.getStepOutput(stepResults, prevStep),
-    attributes: {
-      branchCount: entry.steps.length,
-      parallelSteps: entry.steps.map((s) => s.type === "step" ? s.step.id : `control-${s.type}`)
+  const parallelSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.parallel.${executionContext.executionPath.join("-")}.span.start`,
+    options: {
+      type: "workflow_parallel" /* WORKFLOW_PARALLEL */,
+      name: `parallel: '${entry.steps.length} branches'`,
+      input: engine.getStepOutput(stepResults, prevStep),
+      attributes: {
+        branchCount: entry.steps.length,
+        parallelSteps: entry.steps.map((s) => s.type === "step" ? s.step.id : `control-${s.type}`)
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   const prevOutput = engine.getStepOutput(stepResults, prevStep);
   for (const [stepIndex, step] of entry.steps.entries()) {
@@ -5412,7 +5125,8 @@ async function executeParallel(engine, params) {
           suspendedPaths: executionContext.suspendedPaths,
           resumeLabels: executionContext.resumeLabels,
           retryConfig: executionContext.retryConfig,
-          state: executionContext.state
+          state: executionContext.state,
+          tracingIds: executionContext.tracingIds
         },
         tracingContext: {
           currentSpan: parallelSpan
@@ -5457,10 +5171,16 @@ async function executeParallel(engine, params) {
     };
   }
   if (execResults.status === "failed") {
-    parallelSpan?.error({ error: execResults.error });
+    await engine.errorChildSpan({
+      span: parallelSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.parallel.${executionContext.executionPath.join("-")}.span.error`,
+      errorOptions: { error: execResults.error }
+    });
   } else {
-    parallelSpan?.end({
-      output: execResults.output || execResults
+    await engine.endChildSpan({
+      span: parallelSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.parallel.${executionContext.executionPath.join("-")}.span.end`,
+      endOptions: { output: execResults.output || execResults }
     });
   }
   return execResults;
@@ -5486,26 +5206,34 @@ async function executeConditional(engine, params) {
     disableScorers,
     perStep
   } = params;
-  const conditionalSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_conditional" /* WORKFLOW_CONDITIONAL */,
-    name: `conditional: '${entry.conditions.length} conditions'`,
-    input: prevOutput,
-    attributes: {
-      conditionCount: entry.conditions.length
+  const conditionalSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.span.start`,
+    options: {
+      type: "workflow_conditional" /* WORKFLOW_CONDITIONAL */,
+      name: `conditional: '${entry.conditions.length} conditions'`,
+      input: prevOutput,
+      attributes: {
+        conditionCount: entry.conditions.length
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   let execResults;
   const truthyIndexes = (await Promise.all(
     entry.conditions.map(async (cond, index) => {
-      const evalSpan = conditionalSpan?.createChildSpan({
-        type: "workflow_conditional_eval" /* WORKFLOW_CONDITIONAL_EVAL */,
-        name: `condition '${index}'`,
-        input: prevOutput,
-        attributes: {
-          conditionIndex: index
+      const evalSpan = await engine.createChildSpan({
+        parentSpan: conditionalSpan,
+        operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.eval.${index}.span.start`,
+        options: {
+          type: "workflow_conditional_eval" /* WORKFLOW_CONDITIONAL_EVAL */,
+          name: `condition '${index}'`,
+          input: prevOutput,
+          attributes: {
+            conditionIndex: index
+          }
         },
-        tracingPolicy: engine.options?.tracingPolicy
+        executionContext
       });
       const operationId = `workflow.${workflowId}.conditional.${index}`;
       const context = createDeprecationProxy(
@@ -5522,8 +5250,8 @@ async function executeConditional(engine, params) {
           },
           getInitData: () => stepResults?.input,
           getStepResult: getStepResult.bind(null, stepResults),
-          bail: () => {
-          },
+          bail: (() => {
+          }),
           abort: () => {
             abortController?.abort();
           },
@@ -5549,10 +5277,14 @@ async function executeConditional(engine, params) {
       );
       try {
         const result = await engine.evaluateCondition(cond, index, context, operationId);
-        evalSpan?.end({
-          output: result !== null,
-          attributes: {
-            result: result !== null
+        await engine.endChildSpan({
+          span: evalSpan,
+          operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.eval.${index}.span.end`,
+          endOptions: {
+            output: result !== null,
+            attributes: {
+              result: result !== null
+            }
           }
         });
         return result;
@@ -5569,10 +5301,14 @@ async function executeConditional(engine, params) {
         );
         engine.getLogger()?.trackException(mastraError);
         engine.getLogger()?.error("Error evaluating condition: " + errorInstance.stack);
-        evalSpan?.error({
-          error: mastraError,
-          attributes: {
-            result: false
+        await engine.errorChildSpan({
+          span: evalSpan,
+          operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.eval.${index}.span.error`,
+          errorOptions: {
+            error: mastraError,
+            attributes: {
+              result: false
+            }
           }
         });
         return null;
@@ -5628,7 +5364,8 @@ async function executeConditional(engine, params) {
           suspendedPaths: executionContext.suspendedPaths,
           resumeLabels: executionContext.resumeLabels,
           retryConfig: executionContext.retryConfig,
-          state: executionContext.state
+          state: executionContext.state,
+          tracingIds: executionContext.tracingIds
         },
         tracingContext: {
           currentSpan: conditionalSpan
@@ -5674,10 +5411,16 @@ async function executeConditional(engine, params) {
     };
   }
   if (execResults.status === "failed") {
-    conditionalSpan?.error({ error: execResults.error });
+    await engine.errorChildSpan({
+      span: conditionalSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.span.error`,
+      errorOptions: { error: execResults.error }
+    });
   } else {
-    conditionalSpan?.end({
-      output: execResults.output || execResults
+    await engine.endChildSpan({
+      span: conditionalSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.conditional.${executionContext.executionPath.join("-")}.span.end`,
+      endOptions: { output: execResults.output || execResults }
     });
   }
   return execResults;
@@ -5704,14 +5447,18 @@ async function executeLoop(engine, params) {
     perStep
   } = params;
   const { step, condition } = entry;
-  const loopSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_loop" /* WORKFLOW_LOOP */,
-    name: `loop: '${entry.loopType}'`,
-    input: prevOutput,
-    attributes: {
-      loopType: entry.loopType
+  const loopSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.loop.${executionContext.executionPath.join("-")}.span.start`,
+    options: {
+      type: "workflow_loop" /* WORKFLOW_LOOP */,
+      name: `loop: '${entry.loopType}'`,
+      input: prevOutput,
+      attributes: {
+        loopType: entry.loopType
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   let isTrue = true;
   const prevIterationCount = stepResults[step.id]?.metadata?.iterationCount;
@@ -5754,21 +5501,29 @@ async function executeLoop(engine, params) {
       currentResume = void 0;
     }
     if (result.status !== "success") {
-      loopSpan?.end({
-        attributes: {
-          totalIterations: iteration
+      await engine.endChildSpan({
+        span: loopSpan,
+        operationId: `workflow.${workflowId}.run.${runId}.loop.${executionContext.executionPath.join("-")}.span.end.early`,
+        endOptions: {
+          attributes: {
+            totalIterations: iteration
+          }
         }
       });
       return result;
     }
-    const evalSpan = loopSpan?.createChildSpan({
-      type: "workflow_conditional_eval" /* WORKFLOW_CONDITIONAL_EVAL */,
-      name: `condition: '${entry.loopType}'`,
-      input: selectFields(result.output, ["stepResult", "output.text", "output.object", "messages"]),
-      attributes: {
-        conditionIndex: iteration
+    const evalSpan = await engine.createChildSpan({
+      parentSpan: loopSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.loop.${executionContext.executionPath.join("-")}.eval.${iteration}.span.start`,
+      options: {
+        type: "workflow_conditional_eval" /* WORKFLOW_CONDITIONAL_EVAL */,
+        name: `condition: '${entry.loopType}'`,
+        input: selectFields(result.output, ["stepResult", "output.text", "output.object", "messages"]),
+        attributes: {
+          conditionIndex: iteration
+        }
       },
-      tracingPolicy: engine.options?.tracingPolicy
+      executionContext
     });
     isTrue = await condition(
       createDeprecationProxy(
@@ -5786,8 +5541,8 @@ async function executeLoop(engine, params) {
           iterationCount: iteration + 1,
           getInitData: () => stepResults?.input,
           getStepResult: getStepResult.bind(null, stepResults),
-          bail: () => {
-          },
+          bail: (() => {
+          }),
           abort: () => {
             abortController?.abort();
           },
@@ -5812,15 +5567,23 @@ async function executeLoop(engine, params) {
         }
       )
     );
-    evalSpan?.end({
-      output: isTrue
+    await engine.endChildSpan({
+      span: evalSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.loop.${executionContext.executionPath.join("-")}.eval.${iteration}.span.end`,
+      endOptions: {
+        output: isTrue
+      }
     });
     iteration++;
   } while (entry.loopType === "dowhile" ? isTrue : !isTrue);
-  loopSpan?.end({
-    output: result.output,
-    attributes: {
-      totalIterations: iteration
+  await engine.endChildSpan({
+    span: loopSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.loop.${executionContext.executionPath.join("-")}.span.end`,
+    endOptions: {
+      output: result.output,
+      attributes: {
+        totalIterations: iteration
+      }
     }
   });
   return result;
@@ -5857,15 +5620,19 @@ async function executeForeach(engine, params) {
     ...startTime ? { startedAt: startTime } : {},
     ...resumeTime ? { resumedAt: resumeTime } : {}
   };
-  const loopSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_loop" /* WORKFLOW_LOOP */,
-    name: `loop: 'foreach'`,
-    input: prevOutput,
-    attributes: {
-      loopType: "foreach",
-      concurrency
+  const loopSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.foreach.${executionContext.executionPath.join("-")}.span.start`,
+    options: {
+      type: "workflow_loop" /* WORKFLOW_LOOP */,
+      name: `loop: 'foreach'`,
+      input: prevOutput,
+      attributes: {
+        loopType: "foreach",
+        concurrency
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   await pubsub.publish(`workflow.events.v2.${runId}`, {
     type: "watch",
@@ -6028,8 +5795,12 @@ async function executeForeach(engine, params) {
       }
     }
   });
-  loopSpan?.end({
-    output: results
+  await engine.endChildSpan({
+    span: loopSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.foreach.${executionContext.executionPath.join("-")}.span.end`,
+    endOptions: {
+      output: results
+    }
   });
   return {
     ...stepInfo,
@@ -6539,14 +6310,18 @@ async function executeSleep(engine, params) {
     tracingContext
   } = params;
   let { duration, fn } = entry;
-  const sleepSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_sleep" /* WORKFLOW_SLEEP */,
-    name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
-    attributes: {
-      durationMs: duration,
-      sleepType: fn ? "dynamic" : "fixed"
+  const sleepSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.sleep.${entry.id}.span.start`,
+    options: {
+      type: "workflow_sleep" /* WORKFLOW_SLEEP */,
+      name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
+      attributes: {
+        durationMs: duration,
+        sleepType: fn ? "dynamic" : "fixed"
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   if (fn) {
     const stepCallId = randomUUID();
@@ -6570,8 +6345,8 @@ async function executeSleep(engine, params) {
         // TODO: this function shouldn't have suspend probably?
         suspend: async (_suspendPayload) => {
         },
-        bail: () => {
-        },
+        bail: (() => {
+        }),
         abort: () => {
           abortController?.abort();
         },
@@ -6598,9 +6373,16 @@ async function executeSleep(engine, params) {
   }
   try {
     await engine.executeSleepDuration(!duration || duration < 0 ? 0 : duration, entry.id, workflowId);
-    sleepSpan?.end();
+    await engine.endChildSpan({
+      span: sleepSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.sleep.${entry.id}.span.end`
+    });
   } catch (e) {
-    sleepSpan?.error({ error: e });
+    await engine.errorChildSpan({
+      span: sleepSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.sleep.${entry.id}.span.error`,
+      errorOptions: { error: e }
+    });
     throw e;
   }
 }
@@ -6619,15 +6401,19 @@ async function executeSleepUntil(engine, params) {
     tracingContext
   } = params;
   let { date, fn } = entry;
-  const sleepUntilSpan = tracingContext.currentSpan?.createChildSpan({
-    type: "workflow_sleep" /* WORKFLOW_SLEEP */,
-    name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
-    attributes: {
-      untilDate: date,
-      durationMs: date ? Math.max(0, date.getTime() - Date.now()) : void 0,
-      sleepType: fn ? "dynamic" : "fixed"
+  const sleepUntilSpan = await engine.createChildSpan({
+    parentSpan: tracingContext.currentSpan,
+    operationId: `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.span.start`,
+    options: {
+      type: "workflow_sleep" /* WORKFLOW_SLEEP */,
+      name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
+      attributes: {
+        untilDate: date,
+        durationMs: date ? Math.max(0, date.getTime() - Date.now()) : void 0,
+        sleepType: fn ? "dynamic" : "fixed"
+      }
     },
-    tracingPolicy: engine.options?.tracingPolicy
+    executionContext
   });
   if (fn) {
     const stepCallId = randomUUID();
@@ -6651,8 +6437,8 @@ async function executeSleepUntil(engine, params) {
         // TODO: this function shouldn't have suspend probably?
         suspend: async (_suspendPayload) => {
         },
-        bail: () => {
-        },
+        bail: (() => {
+        }),
         abort: () => {
           abortController?.abort();
         },
@@ -6680,14 +6466,24 @@ async function executeSleepUntil(engine, params) {
     });
   }
   if (!date) {
-    sleepUntilSpan?.end();
+    await engine.endChildSpan({
+      span: sleepUntilSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.span.end.nodate`
+    });
     return;
   }
   try {
     await engine.executeSleepUntilDate(date, entry.id, workflowId);
-    sleepUntilSpan?.end();
+    await engine.endChildSpan({
+      span: sleepUntilSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.span.end`
+    });
   } catch (e) {
-    sleepUntilSpan?.error({ error: e });
+    await engine.errorChildSpan({
+      span: sleepUntilSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.sleepUntil.${entry.id}.span.error`,
+      errorOptions: { error: e }
+    });
     throw e;
   }
 }
@@ -6751,13 +6547,19 @@ async function executeStep(engine, params) {
     ...iterationCount ? { metadata: { iterationCount } } : {}
   };
   executionContext.activeStepsPath[step.id] = executionContext.executionPath;
-  const stepSpan = tracingContext.currentSpan?.createChildSpan({
-    name: `workflow step: '${step.id}'`,
-    type: "workflow_step" /* WORKFLOW_STEP */,
-    entityType: "workflow_step" /* WORKFLOW_STEP */,
-    entityId: step.id,
-    input: inputData,
-    tracingPolicy: engine.options?.tracingPolicy
+  const stepSpan = await engine.createStepSpan({
+    parentSpan: tracingContext.currentSpan,
+    stepId: step.id,
+    operationId: `workflow.${workflowId}.run.${runId}.step.${step.id}.span.start`,
+    options: {
+      name: `workflow step: '${step.id}'`,
+      type: "workflow_step" /* WORKFLOW_STEP */,
+      entityType: "workflow_step" /* WORKFLOW_STEP */,
+      entityId: step.id,
+      input: inputData,
+      tracingPolicy: engine.options?.tracingPolicy
+    },
+    executionContext
   });
   const operationId = `workflow.${workflowId}.run.${runId}.step.${step.id}.running_ev`;
   await engine.onStepExecutionStart({
@@ -6802,6 +6604,28 @@ async function executeStep(engine, params) {
       perStep
     });
     if (workflowResult !== null) {
+      if (stepSpan) {
+        if (workflowResult.status === "failed") {
+          await engine.errorStepSpan({
+            span: stepSpan,
+            operationId: `workflow.${workflowId}.run.${runId}.step.${step.id}.span.error`,
+            errorOptions: {
+              error: workflowResult.error instanceof Error ? workflowResult.error : new Error(String(workflowResult.error)),
+              attributes: { status: "failed" }
+            }
+          });
+        } else {
+          const output = workflowResult.status === "success" ? workflowResult.output : workflowResult.suspendOutput;
+          await engine.endStepSpan({
+            span: stepSpan,
+            operationId: `workflow.${workflowId}.run.${runId}.step.${step.id}.span.end`,
+            endOptions: {
+              output,
+              attributes: { status: workflowResult.status }
+            }
+          });
+        }
+      }
       const stepResult2 = { ...stepInfo, ...workflowResult };
       return {
         result: stepResult2,
@@ -6841,11 +6665,13 @@ async function executeStep(engine, params) {
         stateUpdate: null,
         requestContextUpdate: null
       };
+      const isNestedWorkflow = step.component === "WORKFLOW";
+      const mastraForStep = engine.mastra ? isNestedWorkflow ? engine.mastra : wrapMastra(engine.mastra, { currentSpan: stepSpan }) : void 0;
       const output = await runStep({
         runId,
         resourceId,
         workflowId,
-        mastra: engine.mastra ? wrapMastra(engine.mastra, { currentSpan: stepSpan }) : void 0,
+        mastra: mastraForStep,
         requestContext,
         inputData,
         state: executionContext.state,
@@ -6998,10 +6824,14 @@ async function executeStep(engine, params) {
     });
   }
   if (execResults.status != "failed") {
-    stepSpan?.end({
-      output: execResults.output,
-      attributes: {
-        status: execResults.status
+    await engine.endStepSpan({
+      span: stepSpan,
+      operationId: `workflow.${workflowId}.run.${runId}.step.${step.id}.span.end`,
+      endOptions: {
+        output: execResults.output,
+        attributes: {
+          status: execResults.status
+        }
       }
     });
   }
@@ -7224,35 +7054,108 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
   async executeWorkflowStep(_params) {
     return null;
   }
+  // =============================================================================
+  // Span Lifecycle Hooks
+  // These methods can be overridden by subclasses (e.g., Inngest) to make span
+  // creation/end durable across workflow replays.
+  // =============================================================================
   /**
-   * Execute a step with retry logic.
-   * Default engine: handles retries internally with a loop.
-   * Inngest engine: overrides to throw RetryAfterError for external retry handling.
+   * Create a child span for a workflow step.
+   * Override to add durability (e.g., Inngest memoization).
    *
-   * @param stepId - Unique identifier for the step (used for durability)
-   * @param runStep - The step execution function to run
-   * @param params - Retry parameters and context
-   * @returns Discriminated union: { ok: true, result: T } or { ok: false, error: ... }
+   * Default: creates span directly via parent span's createChildSpan.
+   *
+   * @param params - Parameters for span creation
+   * @returns The created span, or undefined if no parent span or tracing disabled
    */
-  async executeStepWithRetry(stepId, runStep, params) {
-    for (let i = 0; i < params.retries + 1; i++) {
-      if (i > 0 && params.delay) {
-        await new Promise((resolve) => setTimeout(resolve, params.delay));
-      }
-      try {
-        const result = await this.wrapDurableOperation(stepId, runStep);
-        return { ok: true, result };
-      } catch (e) {
-        if (i === params.retries) {
-          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 */,
+  async createStepSpan(params) {
+    return params.parentSpan?.createChildSpan(params.options);
+  }
+  /**
+   * End a workflow step span.
+   * Override to add durability (e.g., Inngest memoization).
+   *
+   * Default: calls span.end() directly.
+   *
+   * @param params - Parameters for ending the span
+   */
+  async endStepSpan(params) {
+    params.span?.end(params.endOptions);
+  }
+  /**
+   * Record an error on a workflow step span.
+   * Override to add durability (e.g., Inngest memoization).
+   *
+   * Default: calls span.error() directly.
+   *
+   * @param params - Parameters for recording the error
+   */
+  async errorStepSpan(params) {
+    params.span?.error(params.errorOptions);
+  }
+  /**
+   * Create a generic child span (for control-flow operations like parallel, conditional, loop).
+   * Override to add durability (e.g., Inngest memoization).
+   *
+   * Default: creates span directly via parent span's createChildSpan.
+   *
+   * @param params - Parameters for span creation
+   * @returns The created span, or undefined if no parent span or tracing disabled
+   */
+  async createChildSpan(params) {
+    return params.parentSpan?.createChildSpan(params.options);
+  }
+  /**
+   * End a generic child span (for control-flow operations).
+   * Override to add durability (e.g., Inngest memoization).
+   *
+   * Default: calls span.end() directly.
+   *
+   * @param params - Parameters for ending the span
+   */
+  async endChildSpan(params) {
+    params.span?.end(params.endOptions);
+  }
+  /**
+   * Record an error on a generic child span (for control-flow operations).
+   * Override to add durability (e.g., Inngest memoization).
+   *
+   * Default: calls span.error() directly.
+   *
+   * @param params - Parameters for recording the error
+   */
+  async errorChildSpan(params) {
+    params.span?.error(params.errorOptions);
+  }
+  /**
+   * Execute a step with retry logic.
+   * Default engine: handles retries internally with a loop.
+   * Inngest engine: overrides to throw RetryAfterError for external retry handling.
+   *
+   * @param stepId - Unique identifier for the step (used for durability)
+   * @param runStep - The step execution function to run
+   * @param params - Retry parameters and context
+   * @returns Discriminated union: { ok: true, result: T } or { ok: false, error: ... }
+   */
+  async executeStepWithRetry(stepId, runStep, params) {
+    for (let i = 0; i < params.retries + 1; i++) {
+      if (i > 0 && params.delay) {
+        await new Promise((resolve) => setTimeout(resolve, params.delay));
+      }
+      try {
+        const result = await this.wrapDurableOperation(stepId, runStep);
+        return { ok: true, result };
+      } catch (e) {
+        if (i === params.retries) {
+          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 }
             },
             errorInstance
@@ -7446,7 +7349,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         resumeLabels: {},
         retryConfig: { attempts, delay: delay2 },
         format: params.format,
-        state: lastState ?? initialState
+        state: lastState ?? initialState,
+        // Tracing IDs for durable span operations (Inngest)
+        tracingIds: params.tracingIds
       };
       lastExecutionContext = executionContext;
       lastOutput = await this.executeEntry({
@@ -7653,648 +7558,655 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
 function mapVariable(config) {
   return config;
 }
+function isAgent(input) {
+  return input instanceof Agent;
+}
+function isToolStep(input) {
+  return input instanceof Tool;
+}
+function isStepParams(input) {
+  return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof Agent) && !(input instanceof Tool);
+}
 function createStep(params, agentOrToolOptions) {
-  if (params instanceof Agent) {
-    const options = agentOrToolOptions ?? {};
-    const outputSchema = options?.structuredOutput?.schema ?? z.object({ text: z.string() });
-    const { retries, scorers, ...agentOptions } = options ?? {};
-    return {
-      id: params.id,
-      description: params.getDescription(),
-      // @ts-ignore
-      inputSchema: z.object({
-        prompt: z.string()
-        // resourceId: z.string().optional(),
-        // threadId: z.string().optional(),
-      }),
-      // @ts-ignore
-      outputSchema,
-      retries,
-      scorers,
-      execute: async ({
-        inputData,
-        runId,
-        [PUBSUB_SYMBOL]: pubsub,
-        [STREAM_FORMAT_SYMBOL]: streamFormat,
-        requestContext,
-        tracingContext,
-        abortSignal,
-        abort,
-        writer
-      }) => {
-        let streamPromise = {};
-        streamPromise.promise = new Promise((resolve, reject) => {
-          streamPromise.resolve = resolve;
-          streamPromise.reject = reject;
-        });
-        let structuredResult = null;
-        const toolData = {
-          name: params.name,
-          args: inputData
-        };
-        let stream;
-        if ((await params.getModel()).specificationVersion === "v1") {
-          const { fullStream } = await params.streamLegacy(inputData.prompt, {
-            ...agentOptions ?? {},
-            // resourceId: inputData.resourceId,
-            // threadId: inputData.threadId,
-            requestContext,
-            tracingContext,
-            onFinish: (result) => {
-              const resultWithObject = result;
-              if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
-                structuredResult = resultWithObject.object;
-              }
-              streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
-            },
-            abortSignal
-          });
-          stream = fullStream;
-        } else {
-          const modelOutput = await params.stream(inputData.prompt, {
-            ...agentOptions ?? {},
-            requestContext,
-            tracingContext,
-            onFinish: (result) => {
-              const resultWithObject = result;
-              if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
-                structuredResult = resultWithObject.object;
-              }
-              streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
-            },
-            abortSignal
-          });
-          stream = modelOutput.fullStream;
-        }
-        let tripwireChunk = null;
-        if (streamFormat === "legacy") {
-          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") {
-              tripwireChunk = chunk;
-              break;
+  if (isAgent(params)) {
+    return createStepFromAgent(params, agentOrToolOptions);
+  }
+  if (isToolStep(params)) {
+    return createStepFromTool(params, agentOrToolOptions);
+  }
+  if (isStepParams(params)) {
+    return createStepFromParams(params);
+  }
+  if (isProcessor(params)) {
+    return createStepFromProcessor(params);
+  }
+  throw new Error("Invalid input: expected StepParams, Agent, ToolStep, or Processor");
+}
+function createStepFromParams(params) {
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    stateSchema: params.stateSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    scorers: params.scorers,
+    retries: params.retries,
+    execute: params.execute.bind(params)
+  };
+}
+function createStepFromAgent(params, agentOrToolOptions) {
+  const options = agentOrToolOptions ?? {};
+  const outputSchema = options?.structuredOutput?.schema ?? z.object({ text: z.string() });
+  const { retries, scorers, ...agentOptions } = options ?? {};
+  return {
+    id: params.id,
+    description: params.getDescription(),
+    inputSchema: z.object({
+      prompt: z.string()
+    }),
+    outputSchema,
+    retries,
+    scorers,
+    execute: async ({
+      inputData,
+      runId,
+      [PUBSUB_SYMBOL]: pubsub,
+      [STREAM_FORMAT_SYMBOL]: streamFormat,
+      requestContext,
+      tracingContext,
+      abortSignal,
+      abort,
+      writer
+    }) => {
+      let streamPromise = {};
+      streamPromise.promise = new Promise((resolve, reject) => {
+        streamPromise.resolve = resolve;
+        streamPromise.reject = reject;
+      });
+      let structuredResult = null;
+      const toolData = {
+        name: params.name,
+        args: inputData
+      };
+      let stream;
+      if ((await params.getModel()).specificationVersion === "v1") {
+        const { fullStream } = await params.streamLegacy(inputData.prompt, {
+          ...agentOptions,
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
             }
-            if (chunk.type === "text-delta") {
-              await pubsub.publish(`workflow.events.v2.${runId}`, {
-                type: "watch",
-                runId,
-                data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
-              });
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
+          },
+          abortSignal
+        });
+        stream = fullStream;
+      } else {
+        const modelOutput = await params.stream(inputData.prompt, {
+          ...agentOptions,
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
             }
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
+          },
+          abortSignal
+        });
+        stream = modelOutput.fullStream;
+      }
+      let tripwireChunk = null;
+      if (streamFormat === "legacy") {
+        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") {
+            tripwireChunk = chunk;
+            break;
           }
-          await pubsub.publish(`workflow.events.v2.${runId}`, {
-            type: "watch",
-            runId,
-            data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
-          });
-        } else {
-          for await (const chunk of stream) {
-            await writer.write(chunk);
-            if (chunk.type === "tripwire") {
-              tripwireChunk = chunk;
-              break;
-            }
+          if (chunk.type === "text-delta") {
+            await pubsub.publish(`workflow.events.v2.${runId}`, {
+              type: "watch",
+              runId,
+              data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
+            });
           }
         }
-        if (tripwireChunk) {
-          throw new TripWire(
-            tripwireChunk.payload?.reason || "Agent tripwire triggered",
-            {
-              retry: tripwireChunk.payload?.retry,
-              metadata: tripwireChunk.payload?.metadata
-            },
-            tripwireChunk.payload?.processorId
-          );
-        }
-        if (abortSignal.aborted) {
-          return abort();
-        }
-        if (structuredResult !== null) {
-          return structuredResult;
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
+        });
+      } else {
+        for await (const chunk of stream) {
+          await writer.write(chunk);
+          if (chunk.type === "tripwire") {
+            tripwireChunk = chunk;
+            break;
+          }
         }
-        return {
-          text: await streamPromise.promise
-        };
-      },
-      component: params.component
-    };
+      }
+      if (tripwireChunk) {
+        throw new TripWire(
+          tripwireChunk.payload?.reason || "Agent tripwire triggered",
+          {
+            retry: tripwireChunk.payload?.retry,
+            metadata: tripwireChunk.payload?.metadata
+          },
+          tripwireChunk.payload?.processorId
+        );
+      }
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      if (structuredResult !== null) {
+        return structuredResult;
+      }
+      return {
+        text: await streamPromise.promise
+      };
+    },
+    component: params.component
+  };
+}
+function createStepFromTool(params, toolOpts) {
+  if (!params.inputSchema || !params.outputSchema) {
+    throw new Error("Tool must have input and output schemas defined");
   }
-  if (params instanceof Tool) {
-    const toolOpts = agentOrToolOptions;
-    if (!params.inputSchema || !params.outputSchema) {
-      throw new Error("Tool must have input and output schemas defined");
-    }
-    return {
-      // TODO: tool probably should have strong id type
-      // @ts-ignore
-      id: params.id,
-      description: params.description,
-      inputSchema: params.inputSchema,
-      outputSchema: params.outputSchema,
-      resumeSchema: params.resumeSchema,
-      suspendSchema: params.suspendSchema,
-      retries: toolOpts?.retries,
-      scorers: toolOpts?.scorers,
-      execute: async ({
-        inputData,
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    retries: toolOpts?.retries,
+    scorers: toolOpts?.scorers,
+    execute: async ({
+      inputData,
+      mastra,
+      requestContext,
+      tracingContext,
+      suspend,
+      resumeData,
+      runId,
+      workflowId,
+      state,
+      setState
+    }) => {
+      const toolContext = {
         mastra,
         requestContext,
         tracingContext,
-        suspend,
         resumeData,
-        runId,
-        workflowId,
-        state,
-        setState
-      }) => {
-        const toolContext = {
-          mastra,
-          requestContext,
-          tracingContext,
+        workflow: {
+          runId,
+          suspend,
           resumeData,
-          workflow: {
-            runId,
-            suspend,
-            resumeData,
-            workflowId,
-            state,
-            setState
-          }
-        };
-        return params.execute(inputData, toolContext);
-      },
-      component: "TOOL"
-    };
-  }
-  if (isProcessor(params)) {
-    const processor = params;
-    const getProcessorEntityType = (phase) => {
-      switch (phase) {
-        case "input":
-          return "input_processor" /* INPUT_PROCESSOR */;
-        case "inputStep":
-          return "input_step_processor" /* INPUT_STEP_PROCESSOR */;
-        case "outputStream":
-        case "outputResult":
-          return "output_processor" /* OUTPUT_PROCESSOR */;
-        case "outputStep":
-          return "output_step_processor" /* OUTPUT_STEP_PROCESSOR */;
-        default:
-          return "output_processor" /* OUTPUT_PROCESSOR */;
-      }
-    };
-    const getSpanNamePrefix = (phase) => {
-      switch (phase) {
-        case "input":
-          return "input processor";
-        case "inputStep":
-          return "input step processor";
-        case "outputStream":
-          return "output stream processor";
-        case "outputResult":
-          return "output processor";
-        case "outputStep":
-          return "output step processor";
-        default:
-          return "processor";
-      }
-    };
-    const hasPhaseMethod = (phase) => {
-      switch (phase) {
-        case "input":
-          return !!processor.processInput;
-        case "inputStep":
-          return !!processor.processInputStep;
-        case "outputStream":
-          return !!processor.processOutputStream;
-        case "outputResult":
-          return !!processor.processOutputResult;
-        case "outputStep":
-          return !!processor.processOutputStep;
-        default:
-          return false;
+          workflowId,
+          state,
+          setState
+        }
+      };
+      return params.execute(inputData, toolContext);
+    },
+    component: "TOOL"
+  };
+}
+function createStepFromProcessor(processor) {
+  const getProcessorEntityType = (phase) => {
+    switch (phase) {
+      case "input":
+        return "input_processor" /* INPUT_PROCESSOR */;
+      case "inputStep":
+        return "input_step_processor" /* INPUT_STEP_PROCESSOR */;
+      case "outputStream":
+      case "outputResult":
+        return "output_processor" /* OUTPUT_PROCESSOR */;
+      case "outputStep":
+        return "output_step_processor" /* OUTPUT_STEP_PROCESSOR */;
+      default:
+        return "output_processor" /* OUTPUT_PROCESSOR */;
+    }
+  };
+  const getSpanNamePrefix = (phase) => {
+    switch (phase) {
+      case "input":
+        return "input processor";
+      case "inputStep":
+        return "input step processor";
+      case "outputStream":
+        return "output stream processor";
+      case "outputResult":
+        return "output processor";
+      case "outputStep":
+        return "output step processor";
+      default:
+        return "processor";
+    }
+  };
+  const hasPhaseMethod = (phase) => {
+    switch (phase) {
+      case "input":
+        return !!processor.processInput;
+      case "inputStep":
+        return !!processor.processInputStep;
+      case "outputStream":
+        return !!processor.processOutputStream;
+      case "outputResult":
+        return !!processor.processOutputResult;
+      case "outputStep":
+        return !!processor.processOutputStep;
+      default:
+        return false;
+    }
+  };
+  return {
+    id: `processor:${processor.id}`,
+    description: processor.name ?? `Processor ${processor.id}`,
+    inputSchema: ProcessorStepInputSchema,
+    outputSchema: ProcessorStepOutputSchema,
+    execute: async ({ inputData, requestContext, tracingContext }) => {
+      const input = inputData;
+      const {
+        phase,
+        messages,
+        messageList,
+        stepNumber,
+        systemMessages,
+        part,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      } = input;
+      const abort = (reason, options) => {
+        throw new TripWire(reason || `Tripwire triggered by ${processor.id}`, options, processor.id);
+      };
+      if (!hasPhaseMethod(phase)) {
+        return input;
       }
-    };
-    return {
-      // @ts-ignore - processor overload has specific id type
-      id: `processor:${processor.id}`,
-      description: processor.name ?? `Processor ${processor.id}`,
-      // @ts-ignore - Use discriminated union for input (better UI experience)
-      inputSchema: ProcessorStepSchema,
-      // @ts-ignore - Use flexible schema for output (allows any phase combination)
-      outputSchema: ProcessorStepOutputSchema,
-      execute: async ({
-        inputData,
+      const currentSpan = tracingContext?.currentSpan;
+      const parentSpan = phase === "inputStep" || phase === "outputStep" ? currentSpan?.findParent("model_step" /* MODEL_STEP */) || currentSpan : currentSpan?.findParent("agent_run" /* AGENT_RUN */) || currentSpan;
+      const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
+        type: "processor_run" /* PROCESSOR_RUN */,
+        name: `${getSpanNamePrefix(phase)}: ${processor.id}`,
+        entityType: getProcessorEntityType(phase),
+        entityId: processor.id,
+        entityName: processor.name ?? processor.id,
+        input: { phase, messageCount: messages?.length },
+        attributes: {
+          processorExecutor: "workflow",
+          // Read processorIndex from processor (set in combineProcessorsIntoWorkflow)
+          processorIndex: processor.processorIndex
+        }
+      }) : void 0;
+      const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : tracingContext;
+      const baseContext = {
+        abort,
+        retryCount: retryCount ?? 0,
         requestContext,
-        tracingContext
-      }) => {
-        const input = inputData;
-        const {
-          phase,
-          messages,
-          messageList,
-          stepNumber,
-          systemMessages,
-          part,
-          streamParts,
-          state,
-          finishReason,
-          toolCalls,
-          text,
-          retryCount,
-          // inputStep phase fields for model/tools configuration
-          model,
-          tools,
-          toolChoice,
-          activeTools,
-          providerOptions,
-          modelSettings,
-          structuredOutput,
-          steps
-        } = input;
-        const abort = (reason, options) => {
-          throw new TripWire(reason || `Tripwire triggered by ${processor.id}`, options, processor.id);
-        };
-        if (!hasPhaseMethod(phase)) {
-          return input;
-        }
-        const currentSpan = tracingContext?.currentSpan;
-        const parentSpan = phase === "inputStep" || phase === "outputStep" ? currentSpan?.findParent("model_step" /* MODEL_STEP */) || currentSpan : currentSpan?.findParent("agent_run" /* AGENT_RUN */) || currentSpan;
-        const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
-          type: "processor_run" /* PROCESSOR_RUN */,
-          name: `${getSpanNamePrefix(phase)}: ${processor.id}`,
-          entityType: getProcessorEntityType(phase),
-          entityId: processor.id,
-          entityName: processor.name ?? processor.id,
-          input: { phase, messageCount: messages?.length },
-          attributes: {
-            processorExecutor: "workflow",
-            // Read processorIndex from processor (set in combineProcessorsIntoWorkflow)
-            processorIndex: processor.processorIndex
-          }
-        }) : void 0;
-        const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : tracingContext;
-        const baseContext = {
-          abort,
-          retryCount: retryCount ?? 0,
-          requestContext,
-          tracingContext: processorTracingContext
-        };
-        const passThrough = {
-          phase,
-          // Auto-create MessageList from messages if not provided
-          // This enables running processor workflows from the UI where messageList can't be serialized
-          messageList: messageList ?? (Array.isArray(messages) ? new MessageList().add(messages, "input").addSystem(systemMessages ?? []) : void 0),
-          stepNumber,
-          systemMessages,
-          streamParts,
-          state,
-          finishReason,
-          toolCalls,
-          text,
-          retryCount,
-          // inputStep phase fields for model/tools configuration
-          model,
-          tools,
-          toolChoice,
-          activeTools,
-          providerOptions,
-          modelSettings,
-          structuredOutput,
-          steps
-        };
-        const executePhaseWithSpan = async (fn) => {
-          try {
-            const result = await fn();
-            processorSpan?.end({ output: result });
-            return result;
-          } catch (error) {
-            if (error instanceof TripWire) {
-              processorSpan?.end({ output: { tripwire: error.message } });
-            } else {
-              processorSpan?.error({ error, endSpan: true });
-            }
-            throw error;
+        tracingContext: processorTracingContext
+      };
+      const passThrough = {
+        phase,
+        // Auto-create MessageList from messages if not provided
+        // This enables running processor workflows from the UI where messageList can't be serialized
+        messageList: messageList ?? (Array.isArray(messages) ? new MessageList().add(messages, "input").addSystem(systemMessages ?? []) : void 0),
+        stepNumber,
+        systemMessages,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      };
+      const executePhaseWithSpan = async (fn) => {
+        try {
+          const result = await fn();
+          processorSpan?.end({ output: result });
+          return result;
+        } catch (error) {
+          if (error instanceof TripWire) {
+            processorSpan?.end({ output: { tripwire: error.message } });
+          } else {
+            processorSpan?.error({ error, endSpan: true });
           }
-        };
-        return executePhaseWithSpan(async () => {
-          switch (phase) {
-            case "input": {
-              if (processor.processInput) {
-                if (!passThrough.messageList) {
+          throw error;
+        }
+      };
+      return executePhaseWithSpan(async () => {
+        switch (phase) {
+          case "input": {
+            if (processor.processInput) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInput phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInput({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                systemMessages: systemMessages ?? []
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
                   throw new MastraError({
                     category: "USER" /* USER */,
                     domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                    id: "PROCESSOR_MISSING_MESSAGE_LIST",
-                    text: `Processor ${processor.id} requires messageList or messages for processInput phase`
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
                   });
                 }
-                const idsBeforeProcessing = messages.map((m) => m.id);
-                const check = passThrough.messageList.makeMessageSourceChecker();
-                const result = await processor.processInput({
-                  ...baseContext,
-                  messages,
-                  messageList: passThrough.messageList,
-                  systemMessages: systemMessages ?? []
-                });
-                if (result instanceof MessageList) {
-                  if (result !== passThrough.messageList) {
-                    throw new MastraError({
-                      category: "USER" /* USER */,
-                      domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                      id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
-                      text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
-                    });
-                  }
-                  return {
-                    ...passThrough,
-                    messages: result.get.all.db(),
-                    systemMessages: result.getAllSystemMessages()
-                  };
-                } else if (Array.isArray(result)) {
-                  ProcessorRunner.applyMessagesToMessageList(
-                    result,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "input"
-                  );
-                  return { ...passThrough, messages: result };
-                } else if (result && "messages" in result && "systemMessages" in result) {
-                  const typedResult = result;
-                  ProcessorRunner.applyMessagesToMessageList(
-                    typedResult.messages,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "input"
-                  );
-                  passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
-                  return {
-                    ...passThrough,
-                    messages: typedResult.messages,
-                    systemMessages: typedResult.systemMessages
-                  };
-                }
-                return { ...passThrough, messages };
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
               }
               return { ...passThrough, messages };
             }
-            case "inputStep": {
-              if (processor.processInputStep) {
-                if (!passThrough.messageList) {
-                  throw new MastraError({
-                    category: "USER" /* USER */,
-                    domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                    id: "PROCESSOR_MISSING_MESSAGE_LIST",
-                    text: `Processor ${processor.id} requires messageList or messages for processInputStep phase`
-                  });
-                }
-                const idsBeforeProcessing = messages.map((m) => m.id);
-                const check = passThrough.messageList.makeMessageSourceChecker();
-                const result = await processor.processInputStep({
+            return { ...passThrough, messages };
+          }
+          case "inputStep": {
+            if (processor.processInputStep) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInputStep phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                systemMessages: systemMessages ?? [],
+                // Pass model/tools configuration fields - types match ProcessInputStepArgs
+                model,
+                tools,
+                toolChoice,
+                activeTools,
+                providerOptions,
+                modelSettings,
+                structuredOutput,
+                steps: steps ?? []
+              });
+              const validatedResult = await ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
+                messageList: passThrough.messageList,
+                processor,
+                stepNumber: stepNumber ?? 0
+              });
+              if (validatedResult.messages) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  validatedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check
+                );
+              }
+              if (validatedResult.systemMessages) {
+                passThrough.messageList.replaceAllSystemMessages(validatedResult.systemMessages);
+              }
+              return { ...passThrough, messages, ...validatedResult };
+            }
+            return { ...passThrough, messages };
+          }
+          case "outputStream": {
+            if (processor.processOutputStream) {
+              const spanKey = `__outputStreamSpan_${processor.id}`;
+              const mutableState = state ?? {};
+              let processorSpan2 = mutableState[spanKey];
+              if (!processorSpan2 && parentSpan) {
+                processorSpan2 = parentSpan.createChildSpan({
+                  type: "processor_run" /* PROCESSOR_RUN */,
+                  name: `output stream processor: ${processor.id}`,
+                  entityType: "output_processor" /* OUTPUT_PROCESSOR */,
+                  entityId: processor.id,
+                  entityName: processor.name ?? processor.id,
+                  input: { phase, streamParts: [] },
+                  attributes: {
+                    processorExecutor: "workflow",
+                    processorIndex: processor.processorIndex
+                  }
+                });
+                mutableState[spanKey] = processorSpan2;
+              }
+              if (processorSpan2) {
+                processorSpan2.input = {
+                  phase,
+                  streamParts: streamParts ?? [],
+                  totalChunks: (streamParts ?? []).length
+                };
+              }
+              const processorTracingContext2 = processorSpan2 ? { currentSpan: processorSpan2 } : baseContext.tracingContext;
+              let result;
+              try {
+                result = await processor.processOutputStream({
                   ...baseContext,
-                  messages,
-                  messageList: passThrough.messageList,
-                  stepNumber: stepNumber ?? 0,
-                  systemMessages: systemMessages ?? [],
-                  // Pass model/tools configuration fields - types match ProcessInputStepArgs
-                  model,
-                  tools,
-                  toolChoice,
-                  activeTools,
-                  providerOptions,
-                  modelSettings,
-                  structuredOutput,
-                  steps: steps ?? []
-                });
-                const validatedResult = await ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
-                  messageList: passThrough.messageList,
-                  processor,
-                  stepNumber: stepNumber ?? 0
+                  tracingContext: processorTracingContext2,
+                  part,
+                  streamParts: streamParts ?? [],
+                  state: mutableState,
+                  messageList: passThrough.messageList
+                  // Optional for stream processing
                 });
-                if (validatedResult.messages) {
-                  ProcessorRunner.applyMessagesToMessageList(
-                    validatedResult.messages,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check
-                  );
+                if (part && part.type === "finish") {
+                  processorSpan2?.end({ output: result });
+                  delete mutableState[spanKey];
                 }
-                if (validatedResult.systemMessages) {
-                  passThrough.messageList.replaceAllSystemMessages(validatedResult.systemMessages);
+              } catch (error) {
+                if (error instanceof TripWire) {
+                  processorSpan2?.end({ output: { tripwire: error.message } });
+                } else {
+                  processorSpan2?.error({ error, endSpan: true });
                 }
-                return { ...passThrough, messages, ...validatedResult };
+                delete mutableState[spanKey];
+                throw error;
               }
-              return { ...passThrough, messages };
+              return { ...passThrough, state: mutableState, part: result };
             }
-            case "outputStream": {
-              if (processor.processOutputStream) {
-                const spanKey = `__outputStreamSpan_${processor.id}`;
-                const mutableState = state ?? {};
-                let processorSpan2 = mutableState[spanKey];
-                if (!processorSpan2 && parentSpan) {
-                  processorSpan2 = parentSpan.createChildSpan({
-                    type: "processor_run" /* PROCESSOR_RUN */,
-                    name: `output stream processor: ${processor.id}`,
-                    entityType: "output_processor" /* OUTPUT_PROCESSOR */,
-                    entityId: processor.id,
-                    entityName: processor.name ?? processor.id,
-                    input: { phase, streamParts: [] },
-                    attributes: {
-                      processorExecutor: "workflow",
-                      processorIndex: processor.processorIndex
-                    }
-                  });
-                  mutableState[spanKey] = processorSpan2;
-                }
-                if (processorSpan2) {
-                  processorSpan2.input = {
-                    phase,
-                    streamParts: streamParts ?? [],
-                    totalChunks: (streamParts ?? []).length
-                  };
-                }
-                const processorTracingContext2 = processorSpan2 ? { currentSpan: processorSpan2 } : baseContext.tracingContext;
-                let result;
-                try {
-                  result = await processor.processOutputStream({
-                    ...baseContext,
-                    tracingContext: processorTracingContext2,
-                    part,
-                    streamParts: streamParts ?? [],
-                    state: mutableState,
-                    messageList: passThrough.messageList
-                    // Optional for stream processing
-                  });
-                  if (part && part.type === "finish") {
-                    processorSpan2?.end({ output: result });
-                    delete mutableState[spanKey];
-                  }
-                } catch (error) {
-                  if (error instanceof TripWire) {
-                    processorSpan2?.end({ output: { tripwire: error.message } });
-                  } else {
-                    processorSpan2?.error({ error, endSpan: true });
-                  }
-                  delete mutableState[spanKey];
-                  throw error;
-                }
-                return { ...passThrough, state: mutableState, part: result };
+            return { ...passThrough, part };
+          }
+          case "outputResult": {
+            if (processor.processOutputResult) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputResult phase`
+                });
               }
-              return { ...passThrough, part };
-            }
-            case "outputResult": {
-              if (processor.processOutputResult) {
-                if (!passThrough.messageList) {
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputResult({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
                   throw new MastraError({
                     category: "USER" /* USER */,
                     domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                    id: "PROCESSOR_MISSING_MESSAGE_LIST",
-                    text: `Processor ${processor.id} requires messageList or messages for processOutputResult phase`
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
                   });
                 }
-                const idsBeforeProcessing = messages.map((m) => m.id);
-                const check = passThrough.messageList.makeMessageSourceChecker();
-                const result = await processor.processOutputResult({
-                  ...baseContext,
-                  messages,
-                  messageList: passThrough.messageList
-                });
-                if (result instanceof MessageList) {
-                  if (result !== passThrough.messageList) {
-                    throw new MastraError({
-                      category: "USER" /* USER */,
-                      domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                      id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
-                      text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
-                    });
-                  }
-                  return {
-                    ...passThrough,
-                    messages: result.get.all.db(),
-                    systemMessages: result.getAllSystemMessages()
-                  };
-                } else if (Array.isArray(result)) {
-                  ProcessorRunner.applyMessagesToMessageList(
-                    result,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "response"
-                  );
-                  return { ...passThrough, messages: result };
-                } else if (result && "messages" in result && "systemMessages" in result) {
-                  const typedResult = result;
-                  ProcessorRunner.applyMessagesToMessageList(
-                    typedResult.messages,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "response"
-                  );
-                  passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
-                  return {
-                    ...passThrough,
-                    messages: typedResult.messages,
-                    systemMessages: typedResult.systemMessages
-                  };
-                }
-                return { ...passThrough, messages };
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
               }
               return { ...passThrough, messages };
             }
-            case "outputStep": {
-              if (processor.processOutputStep) {
-                if (!passThrough.messageList) {
+            return { ...passThrough, messages };
+          }
+          case "outputStep": {
+            if (processor.processOutputStep) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputStep phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                finishReason,
+                toolCalls,
+                text,
+                systemMessages: systemMessages ?? [],
+                steps: steps ?? []
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
                   throw new MastraError({
                     category: "USER" /* USER */,
                     domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                    id: "PROCESSOR_MISSING_MESSAGE_LIST",
-                    text: `Processor ${processor.id} requires messageList or messages for processOutputStep phase`
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
                   });
                 }
-                const idsBeforeProcessing = messages.map((m) => m.id);
-                const check = passThrough.messageList.makeMessageSourceChecker();
-                const result = await processor.processOutputStep({
-                  ...baseContext,
-                  messages,
-                  messageList: passThrough.messageList,
-                  stepNumber: stepNumber ?? 0,
-                  finishReason,
-                  toolCalls,
-                  text,
-                  systemMessages: systemMessages ?? [],
-                  steps: steps ?? []
-                });
-                if (result instanceof MessageList) {
-                  if (result !== passThrough.messageList) {
-                    throw new MastraError({
-                      category: "USER" /* USER */,
-                      domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
-                      id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
-                      text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
-                    });
-                  }
-                  return {
-                    ...passThrough,
-                    messages: result.get.all.db(),
-                    systemMessages: result.getAllSystemMessages()
-                  };
-                } else if (Array.isArray(result)) {
-                  ProcessorRunner.applyMessagesToMessageList(
-                    result,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "response"
-                  );
-                  return { ...passThrough, messages: result };
-                } else if (result && "messages" in result && "systemMessages" in result) {
-                  const typedResult = result;
-                  ProcessorRunner.applyMessagesToMessageList(
-                    typedResult.messages,
-                    passThrough.messageList,
-                    idsBeforeProcessing,
-                    check,
-                    "response"
-                  );
-                  passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
-                  return {
-                    ...passThrough,
-                    messages: typedResult.messages,
-                    systemMessages: typedResult.systemMessages
-                  };
-                }
-                return { ...passThrough, messages };
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
               }
               return { ...passThrough, messages };
             }
-            default:
-              return { ...passThrough, messages };
+            return { ...passThrough, messages };
           }
-        });
-      },
-      component: "PROCESSOR"
-    };
-  }
-  return {
-    id: params.id,
-    description: params.description,
-    inputSchema: params.inputSchema,
-    stateSchema: params.stateSchema,
-    outputSchema: params.outputSchema,
-    resumeSchema: params.resumeSchema,
-    suspendSchema: params.suspendSchema,
-    scorers: params.scorers,
-    retries: params.retries,
-    execute: params.execute.bind(params)
+          default:
+            return { ...passThrough, messages };
+        }
+      });
+    },
+    component: "PROCESSOR"
   };
 }
 function cloneStep(step, opts) {
@@ -8422,6 +8334,9 @@ var Workflow = class extends MastraBase {
    * Adds a step to the workflow
    * @param step The step to add to the workflow
    * @returns The workflow instance for chaining
+   *
+   * The step's inputSchema must be satisfied by the previous step's output (or workflow input for first step).
+   * This means: TPrevSchema must be assignable to TStepInput
    */
   then(step) {
     this.stepFlow.push({ type: "step", step });
@@ -8444,7 +8359,7 @@ var Workflow = class extends MastraBase {
    * @returns The workflow instance for chaining
    */
   sleep(duration) {
-    const id = `sleep_${this.#mastra?.generateId() || randomUUID()}`;
+    const id = `sleep_${this.#mastra?.generateId({ idType: "step", source: "workflow", entityId: this.id, stepType: "sleep" }) || randomUUID()}`;
     const opts = typeof duration === "function" ? { type: "sleep", id, fn: duration } : { type: "sleep", id, duration };
     const serializedOpts = typeof duration === "function" ? { type: "sleep", id, fn: duration.toString() } : { type: "sleep", id, duration };
     this.stepFlow.push(opts);
@@ -8465,7 +8380,7 @@ var Workflow = class extends MastraBase {
    * @returns The workflow instance for chaining
    */
   sleepUntil(date) {
-    const id = `sleep_${this.#mastra?.generateId() || randomUUID()}`;
+    const id = `sleep_${this.#mastra?.generateId({ idType: "step", source: "workflow", entityId: this.id, stepType: "sleep-until" }) || randomUUID()}`;
     const opts = typeof date === "function" ? { type: "sleepUntil", id, fn: date } : { type: "sleepUntil", id, date };
     const serializedOpts = typeof date === "function" ? { type: "sleepUntil", id, fn: date.toString() } : { type: "sleepUntil", id, date };
     this.stepFlow.push(opts);
@@ -8494,7 +8409,7 @@ var Workflow = class extends MastraBase {
   map(mappingConfig, stepOptions) {
     if (typeof mappingConfig === "function") {
       const mappingStep2 = createStep({
-        id: stepOptions?.id || `mapping_${this.#mastra?.generateId() || randomUUID()}`,
+        id: stepOptions?.id || `mapping_${this.#mastra?.generateId({ idType: "step", source: "workflow", entityId: this.id, stepType: "mapping" }) || randomUUID()}`,
         inputSchema: z.any(),
         outputSchema: z.any(),
         execute: mappingConfig
@@ -8532,7 +8447,7 @@ var Workflow = class extends MastraBase {
       {}
     );
     const mappingStep = createStep({
-      id: stepOptions?.id || `mapping_${this.#mastra?.generateId() || randomUUID()}`,
+      id: stepOptions?.id || `mapping_${this.#mastra?.generateId({ idType: "step", source: "workflow", entityId: this.id, stepType: "mapping" }) || randomUUID()}`,
       inputSchema: z.any(),
       outputSchema: z.any(),
       execute: async (ctx) => {
@@ -8747,7 +8662,12 @@ var Workflow = class extends MastraBase {
     if (!this.executionGraph.steps) {
       throw new Error("Uncommitted step flow changes detected. Call .commit() to register the steps.");
     }
-    const runIdToUse = options?.runId || this.#mastra?.generateId() || randomUUID();
+    const runIdToUse = options?.runId || this.#mastra?.generateId({
+      idType: "run",
+      source: "workflow",
+      entityId: this.id,
+      resourceId: options?.resourceId
+    }) || randomUUID();
     const run = this.#runs.get(runIdToUse) ?? new Run({
       workflowId: this.id,
       stateSchema: this.stateSchema,
@@ -8788,6 +8708,7 @@ var Workflow = class extends MastraBase {
           runId: runIdToUse,
           status: "pending",
           value: {},
+          // @ts-ignore
           context: this.#nestedWorkflowInput ? { input: this.#nestedWorkflowInput } : {},
           activePaths: [],
           activeStepsPath: {},
@@ -9263,13 +9184,11 @@ var Run = class {
   }
   async _validateInput(inputData) {
     let inputDataToUse = inputData;
-    if (this.validateInputs && this.inputSchema) {
+    if (this.validateInputs && this.inputSchema && isZodType(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")
-        );
+        throw new Error("Invalid input data: \n" + errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n"));
       }
       inputDataToUse = validatedInputData.data;
     }
@@ -9279,7 +9198,7 @@ var Run = class {
     let initialStateToUse = initialState;
     if (this.validateInputs) {
       let stateSchema = this.stateSchema;
-      if (stateSchema) {
+      if (stateSchema && isZodType(stateSchema)) {
         const validatedInitialState = await stateSchema.safeParseAsync(initialState);
         if (!validatedInitialState.success) {
           const errors = getZodErrors(validatedInitialState.error);
@@ -9294,14 +9213,12 @@ var Run = class {
   }
   async _validateResumeData(resumeData, suspendedStep) {
     let resumeDataToUse = resumeData;
-    if (suspendedStep && suspendedStep.resumeSchema && this.validateInputs) {
+    if (suspendedStep && suspendedStep.resumeSchema && this.validateInputs && isZodType(suspendedStep.resumeSchema)) {
       const resumeSchema = suspendedStep.resumeSchema;
       const validatedResumeData = await resumeSchema.safeParseAsync(resumeData);
       if (!validatedResumeData.success) {
         const errors = getZodErrors(validatedResumeData.error);
-        throw new Error(
-          "Invalid resume data: \n" + errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n")
-        );
+        throw new Error("Invalid resume data: \n" + errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n"));
       }
       resumeDataToUse = validatedResumeData.data;
     }
@@ -9309,7 +9226,7 @@ var Run = class {
   }
   async _validateTimetravelInputData(inputData, step) {
     let inputDataToUse = inputData;
-    if (step && step.inputSchema && this.validateInputs) {
+    if (step && step.inputSchema && this.validateInputs && isZodType(step.inputSchema)) {
       const inputSchema = step.inputSchema;
       const validatedInputData = await inputSchema.safeParseAsync(inputData);
       if (!validatedInputData.success) {
@@ -9518,13 +9435,6 @@ var Run = class {
     }
     return this.streamOutput.fullStream;
   }
-  async streamAsync({
-    inputData,
-    requestContext,
-    perStep
-  } = {}) {
-    return this.stream({ inputData, requestContext, perStep });
-  }
   /**
    * Starts the workflow execution with the provided input as a stream
    * @param input The input data for the workflow
@@ -9539,7 +9449,7 @@ var Run = class {
     initialState,
     outputOptions,
     perStep
-  } = {}) {
+  }) {
     if (this.closeStreamAction && this.streamOutput) {
       return this.streamOutput;
     }
@@ -10177,9 +10087,9 @@ var Run = class {
   }
 };
 var languageModelUsageSchema = z10.object({
-  inputTokens: z10.number(),
-  outputTokens: z10.number(),
-  totalTokens: z10.number(),
+  inputTokens: z10.number().optional(),
+  outputTokens: z10.number().optional(),
+  totalTokens: z10.number().optional(),
   reasoningTokens: z10.number().optional(),
   cachedInputTokens: z10.number().optional()
 });
@@ -11263,7 +11173,7 @@ Analyse the suspended tools: ${JSON.stringify(suspendedTools)}, using the messag
           output: {
             text: text2,
             toolCalls: [],
-            usage: usage2 ?? inputData.output?.usage,
+            usage: usage2 ?? inputData.output.usage,
             steps: []
           },
           messages: {
@@ -11423,7 +11333,6 @@ Analyse the suspended tools: ${JSON.stringify(suspendedTools)}, using the messag
           text,
           toolCalls: shouldRetry ? [] : toolCalls,
           // Clear tool calls on retry
-          tools: stepTools,
           usage: usage ?? inputData.output?.usage,
           steps,
           ...object ? { object } : {}
@@ -11799,11 +11708,15 @@ function createToolCallStep({
                 toolCallId: inputData.toolCallId,
                 toolName: inputData.toolName,
                 args: inputData.args,
-                resumeSchema: z10.object({
-                  approved: z10.boolean().describe(
-                    "Controls if the tool call is approved or not, should be true when approved and false when declined"
+                resumeSchema: JSON.stringify(
+                  zodToJsonSchema$1(
+                    z10.object({
+                      approved: z10.boolean().describe(
+                        "Controls if the tool call is approved or not, should be true when approved and false when declined"
+                      )
+                    })
                   )
-                })
+                )
               }
             });
             addToolMetadata({
@@ -11811,11 +11724,15 @@ function createToolCallStep({
               toolName: inputData.toolName,
               args: inputData.args,
               type: "approval",
-              resumeSchema: z10.object({
-                approved: z10.boolean().describe(
-                  "Controls if the tool call is approved or not, should be true when approved and false when declined"
+              resumeSchema: JSON.stringify(
+                zodToJsonSchema$1(
+                  z10.object({
+                    approved: z10.boolean().describe(
+                      "Controls if the tool call is approved or not, should be true when approved and false when declined"
+                    )
+                  })
                 )
-              })
+              )
             });
             await flushMessagesBeforeSuspension();
             return suspend(
@@ -11912,7 +11829,11 @@ function createToolCallStep({
 }
 
 // src/loop/workflows/agentic-execution/index.ts
-function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
+function createAgenticExecutionWorkflow({
+  models,
+  _internal,
+  ...rest
+}) {
   const llmExecutionStep = createLLMExecutionStep({
     models,
     _internal,
@@ -12278,7 +12199,13 @@ function loop({
   const firstModel = models[0];
   let runIdToUse = runId;
   if (!runIdToUse) {
-    runIdToUse = idGenerator?.() || crypto.randomUUID();
+    runIdToUse = idGenerator?.({
+      idType: "run",
+      source: "agent",
+      entityId: agentId,
+      threadId: _internal?.threadId,
+      resourceId: _internal?.resourceId
+    }) || crypto.randomUUID();
   }
   const internalToUse = {
     now: _internal?.now || (() => Date.now()),
@@ -12873,6 +12800,8 @@ Primitives already executed: ${completedPrimitives.join(", ")}` : "";
 
     If no primitive (type = 'none'), the task is complete because we can't run any primitive to further task completion.
 
+    Also, if the ${context.selectedPrimitive.type} ${context.selectedPrimitive.id} has declined the tool call in its response, then the task is complete as the primitive tool-call was declined by the user.
+
     IMPORTANT: If the above result is from an AGENT PRIMITIVE and it is a suitable final result itself considering the original task, then finalResult should be an empty string or undefined.
     
     If the task is complete and the result is not from an AGENT PRIMITIVE, always generate a finalResult.
@@ -13360,6 +13289,26 @@ var MastraLLMVNext = class extends MastraBase {
 var PRIMITIVE_TYPES = z10.enum(["agent", "workflow", "none", "tool"]);
 
 // src/loop/network/index.ts
+function filterMessagesForSubAgent(messages) {
+  return messages.filter((msg) => {
+    if (msg.role === "user") return true;
+    if (msg.role === "assistant") {
+      const parts = msg.content?.parts ?? [];
+      for (const part of parts) {
+        if (part?.type === "text" && part?.text) {
+          try {
+            const parsed = JSON.parse(part.text);
+            if (parsed.isNetwork) return false;
+            if (parsed.primitiveId && parsed.selectionReason) return false;
+          } catch {
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  });
+}
 async function getRoutingAgent({
   requestContext,
   agent,
@@ -13376,13 +13325,13 @@ async function getRoutingAgent({
   }).join("\n");
   const workflowList = Object.entries(workflowsToUse).map(([name, workflow]) => {
     return ` - **${name}**: ${workflow.description}, input schema: ${JSON.stringify(
-      zodToJsonSchema$1(workflow.inputSchema)
+      zodToJsonSchema(workflow.inputSchema)
     )}`;
   }).join("\n");
   const memoryTools = await memoryToUse?.listTools?.();
   const toolList = Object.entries({ ...toolsToUse, ...memoryTools }).map(([name, tool2]) => {
     return ` - **${name}**: ${tool2.description}, input schema: ${JSON.stringify(
-      zodToJsonSchema$1(tool2.inputSchema || z10.object({}))
+      zodToJsonSchema("inputSchema" in tool2 ? tool2.inputSchema : z10.object({}))
     )}`;
   }).join("\n");
   const additionalInstructionsSection = routingConfig?.additionalInstructions ? `
@@ -13479,7 +13428,13 @@ async function prepareMemoryStep({
         memory.saveMessages({
           messages: [
             {
-              id: generateId2(),
+              id: generateId2({
+                idType: "message",
+                source: "agent",
+                threadId: thread?.id,
+                resourceId: thread?.resourceId,
+                role: "user"
+              }),
               type: "text",
               role: "user",
               content: { parts: [{ type: "text", text: messages }], format: 2 },
@@ -13509,7 +13464,7 @@ async function prepareMemoryStep({
     const mostRecentUserMessage = routingAgent.getMostRecentUserMessage(uiMessages);
     userMessage = mostRecentUserMessage?.content;
   }
-  if (thread?.title?.startsWith("New Thread") && memory) {
+  if (thread && memory) {
     const config = memory.getMergedThreadConfig(memoryConfig || {});
     const {
       shouldGenerate,
@@ -13517,25 +13472,33 @@ async function prepareMemoryStep({
       instructions: titleInstructions
     } = routingAgent.resolveTitleGenerationConfig(config?.generateTitle);
     if (shouldGenerate && userMessage) {
-      promises.push(
-        routingAgent.genTitle(
-          userMessage,
-          requestContext,
-          tracingContext || { currentSpan: void 0 },
-          titleModel,
-          titleInstructions
-        ).then((title) => {
-          if (title) {
-            return memory.createThread({
-              threadId: thread.id,
-              resourceId: thread.resourceId,
-              memoryConfig,
-              title,
-              metadata: thread.metadata
-            });
-          }
-        })
-      );
+      const existingMessages = await memory.recall({
+        threadId: thread.id,
+        resourceId: thread.resourceId
+      });
+      const existingUserMessages = existingMessages.messages.filter((m) => m.role === "user");
+      const isFirstUserMessage = existingUserMessages.length === 0;
+      if (isFirstUserMessage) {
+        promises.push(
+          routingAgent.genTitle(
+            userMessage,
+            requestContext,
+            tracingContext || { currentSpan: void 0 },
+            titleModel,
+            titleInstructions
+          ).then((title) => {
+            if (title) {
+              return memory.createThread({
+                threadId: thread.id,
+                resourceId: thread.resourceId,
+                memoryConfig,
+                title,
+                metadata: thread.metadata
+              });
+            }
+          })
+        );
+      }
     }
   }
   await Promise.all(promises);
@@ -13597,13 +13560,18 @@ async function createNetworkLoop({
       result: z10.string(),
       isComplete: z10.boolean().optional(),
       selectionReason: z10.string(),
-      iteration: z10.number()
+      iteration: z10.number(),
+      conversationContext: z10.array(z10.any()).optional()
     }),
     execute: async ({ inputData, getInitData, writer }) => {
       const initData = await getInitData();
       const routingAgent = await getRoutingAgent({ requestContext, agent, routingConfig: routing });
       const iterationCount = (inputData.iteration ?? -1) + 1;
-      const stepId = generateId2();
+      const stepId = generateId2({
+        idType: "step",
+        source: "agent",
+        stepType: "routing-agent"
+      });
       await writer.write({
         type: "routing-agent-start",
         payload: {
@@ -13676,7 +13644,7 @@ async function createNetworkLoop({
         ...routingAgentOptions
       };
       const result = await tryGenerateWithJsonFallback(routingAgent, prompt, options);
-      const object = result.object;
+      const object = await result.object;
       const isComplete = object.primitiveId === "none" && object.primitiveType === "none";
       if (isComplete && object.selectionReason) {
         await writer.write({
@@ -13692,6 +13660,7 @@ async function createNetworkLoop({
           runId
         });
       }
+      const conversationContext = filterMessagesForSubAgent(result.rememberedMessages ?? []);
       const endPayload = {
         task: inputData.task,
         result: isComplete ? object.selectionReason : "",
@@ -13701,7 +13670,8 @@ async function createNetworkLoop({
         isComplete,
         selectionReason: object.selectionReason,
         iteration: iterationCount,
-        runId: stepId
+        runId: stepId,
+        conversationContext
       };
       await writer.write({
         type: "routing-agent-end",
@@ -13725,7 +13695,8 @@ async function createNetworkLoop({
       result: z10.string(),
       isComplete: z10.boolean().optional(),
       selectionReason: z10.string(),
-      iteration: z10.number()
+      iteration: z10.number(),
+      conversationContext: z10.array(z10.any()).optional()
     }),
     outputSchema: z10.object({
       task: z10.string(),
@@ -13735,7 +13706,7 @@ async function createNetworkLoop({
       isComplete: z10.boolean().optional(),
       iteration: z10.number()
     }),
-    execute: async ({ inputData, writer, getInitData }) => {
+    execute: async ({ inputData, writer, getInitData, suspend, resumeData }) => {
       const agentsMap = await agent.listAgents({ requestContext });
       const agentForStep = agentsMap[inputData.primitiveId];
       if (!agentForStep) {
@@ -13748,7 +13719,12 @@ async function createNetworkLoop({
         throw mastraError;
       }
       const agentId = agentForStep.id;
-      const stepId = generateId2();
+      const stepId = generateId2({
+        idType: "step",
+        source: "agent",
+        entityId: agentId,
+        stepType: "agent-execution"
+      });
       await writer.write({
         type: "agent-execution-start",
         payload: {
@@ -13762,17 +13738,35 @@ async function createNetworkLoop({
       const initData = await getInitData();
       const threadId = initData?.threadId || runId;
       const resourceId = initData?.threadResourceId || networkName;
-      const agentHasOwnMemory = agentForStep.hasOwnMemory();
-      const result = await agentForStep.stream(inputData.prompt, {
+      const conversationContext = inputData.conversationContext ?? [];
+      const messagesForSubAgent = [
+        ...conversationContext,
+        { role: "user", content: inputData.prompt }
+      ];
+      const result = await (resumeData ? agentForStep.resumeStream(resumeData, {
+        requestContext,
+        runId,
+        memory: {
+          thread: threadId,
+          resource: resourceId,
+          options: {
+            lastMessages: 0
+          }
+        }
+      }) : agentForStep.stream(messagesForSubAgent, {
         requestContext,
         runId,
-        ...agentHasOwnMemory ? {
-          memory: {
-            thread: threadId,
-            resource: resourceId
+        memory: {
+          thread: threadId,
+          resource: resourceId,
+          options: {
+            lastMessages: 0
           }
-        } : {}
-      });
+        }
+      }));
+      let requireApprovalMetadata;
+      let suspendedTools;
+      let toolCallDeclined = false;
       for await (const chunk of result.fullStream) {
         await writer.write({
           type: `agent-execution-event-${chunk.type}`,
@@ -13783,13 +13777,60 @@ async function createNetworkLoop({
           from: "NETWORK" /* NETWORK */,
           runId
         });
+        if (chunk.type === "tool-call-approval") {
+          requireApprovalMetadata = {
+            ...requireApprovalMetadata ?? {},
+            [inputData.primitiveId]: {
+              resumeSchema: chunk.payload.resumeSchema,
+              args: { prompt: inputData.prompt },
+              toolName: inputData.primitiveId,
+              toolCallId: inputData.primitiveId,
+              runId,
+              type: "approval",
+              primitiveType: "agent",
+              primitiveId: inputData.primitiveId
+            }
+          };
+        }
+        if (chunk.type === "tool-call-suspended") {
+          suspendedTools = {
+            ...suspendedTools ?? {},
+            [inputData.primitiveId]: {
+              suspendPayload: chunk.payload.suspendPayload,
+              resumeSchema: chunk.payload.resumeSchema,
+              toolName: inputData.primitiveId,
+              toolCallId: inputData.primitiveId,
+              args: { prompt: inputData.prompt },
+              runId,
+              type: "suspension",
+              primitiveType: "agent",
+              primitiveId: inputData.primitiveId
+            }
+          };
+        }
+        if (chunk.type === "tool-result") {
+          if (chunk.payload.result === "Tool call was not approved by the user") {
+            toolCallDeclined = true;
+          }
+        }
       }
       const memory = await agent.getMemory({ requestContext });
       const messages = result.messageList.get.all.v1();
+      let finalText = await result.text;
+      if (toolCallDeclined) {
+        finalText = finalText + "\n\nTool call was not approved by the user";
+      }
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId2(),
+            id: generateId2({
+              idType: "message",
+              source: "agent",
+              entityId: agentId,
+              threadId: initData?.threadId || runId,
+              resourceId: initData?.threadResourceId || networkName,
+              role: "assistant"
+            }),
             type: "text",
             role: "assistant",
             content: {
@@ -13802,11 +13843,17 @@ async function createNetworkLoop({
                     primitiveType: inputData.primitiveType,
                     primitiveId: inputData.primitiveId,
                     input: inputData.prompt,
-                    finalResult: { text: await result.text, messages }
+                    finalResult: { text: finalText, messages }
                   })
                 }
               ],
-              format: 2
+              format: 2,
+              ...requireApprovalMetadata || suspendedTools ? {
+                metadata: {
+                  ...requireApprovalMetadata ? { requireApprovalMetadata } : {},
+                  ...suspendedTools ? { suspendedTools } : {}
+                }
+              } : {}
             },
             createdAt: /* @__PURE__ */ new Date(),
             threadId: initData?.threadId || runId,
@@ -13814,31 +13861,64 @@ async function createNetworkLoop({
           }
         ]
       });
-      const endPayload = {
-        task: inputData.task,
-        agentId,
-        result: await result.text,
-        isComplete: false,
-        iteration: inputData.iteration,
-        runId: stepId
-      };
-      await writer.write({
-        type: "agent-execution-end",
-        payload: {
-          ...endPayload,
-          usage: await result.usage
-        },
-        from: "NETWORK" /* NETWORK */,
-        runId
-      });
-      return {
-        task: inputData.task,
-        primitiveId: inputData.primitiveId,
-        primitiveType: inputData.primitiveType,
-        result: await result.text,
-        isComplete: false,
-        iteration: inputData.iteration
-      };
+      if (requireApprovalMetadata || suspendedTools) {
+        await writer.write({
+          type: requireApprovalMetadata ? "agent-execution-approval" : "agent-execution-suspended",
+          payload: {
+            args: { prompt: inputData.prompt },
+            agentId,
+            runId: stepId,
+            toolName: inputData.primitiveId,
+            toolCallId: inputData.primitiveId,
+            usage: await result.usage,
+            selectionReason: inputData.selectionReason,
+            ...requireApprovalMetadata ? {
+              resumeSchema: requireApprovalMetadata[inputData.primitiveId].resumeSchema
+            } : {},
+            ...suspendedTools ? {
+              resumeSchema: suspendedTools[inputData.primitiveId].resumeSchema,
+              suspendPayload: suspendedTools[inputData.primitiveId].suspendPayload
+            } : {}
+          },
+          from: "NETWORK" /* NETWORK */,
+          runId
+        });
+        return await suspend({
+          ...requireApprovalMetadata ? { requireToolApproval: requireApprovalMetadata[inputData.primitiveId] } : {},
+          ...suspendedTools ? {
+            toolCallSuspended: suspendedTools[inputData.primitiveId].suspendPayload,
+            args: inputData.prompt,
+            agentId
+          } : {},
+          runId: stepId
+        });
+      } else {
+        const endPayload = {
+          task: inputData.task,
+          agentId,
+          result: finalText,
+          isComplete: false,
+          iteration: inputData.iteration,
+          runId: stepId
+        };
+        await writer.write({
+          type: "agent-execution-end",
+          payload: {
+            ...endPayload,
+            usage: await result.usage
+          },
+          from: "NETWORK" /* NETWORK */,
+          runId
+        });
+        return {
+          task: inputData.task,
+          primitiveId: inputData.primitiveId,
+          primitiveType: inputData.primitiveType,
+          result: finalText,
+          isComplete: false,
+          iteration: inputData.iteration
+        };
+      }
     }
   });
   const workflowStep = createStep({
@@ -13851,7 +13931,8 @@ async function createNetworkLoop({
       result: z10.string(),
       isComplete: z10.boolean().optional(),
       selectionReason: z10.string(),
-      iteration: z10.number()
+      iteration: z10.number(),
+      conversationContext: z10.array(z10.any()).optional()
     }),
     outputSchema: z10.object({
       task: z10.string(),
@@ -13861,7 +13942,7 @@ async function createNetworkLoop({
       isComplete: z10.boolean().optional(),
       iteration: z10.number()
     }),
-    execute: async ({ inputData, writer, getInitData }) => {
+    execute: async ({ inputData, writer, getInitData, suspend, resumeData, mastra }) => {
       const workflowsMap = await agent.listWorkflows({ requestContext });
       const workflowId = inputData.primitiveId;
       const wf = workflowsMap[workflowId];
@@ -13889,7 +13970,12 @@ async function createNetworkLoop({
         );
         throw mastraError;
       }
-      const stepId = generateId2();
+      const stepId = generateId2({
+        idType: "step",
+        source: "workflow",
+        entityId: wf.id,
+        stepType: "workflow-execution"
+      });
       const run = await wf.createRun({ runId });
       const toolData = {
         workflowId: wf.id,
@@ -13902,7 +13988,10 @@ async function createNetworkLoop({
         from: "NETWORK" /* NETWORK */,
         runId
       });
-      const stream = run.stream({
+      const stream = resumeData ? run.resumeStream({
+        resumeData,
+        requestContext
+      }) : run.stream({
         inputData: input,
         requestContext
       });
@@ -13924,6 +14013,33 @@ async function createNetworkLoop({
       if (!workflowState?.status || workflowState?.status === "failed") {
         runSuccess = false;
       }
+      let resumeSchema;
+      let suspendPayload;
+      if (workflowState?.status === "suspended") {
+        const suspendedStep = workflowState?.suspended?.[0]?.[0];
+        suspendPayload = workflowState?.steps?.[suspendedStep]?.suspendPayload;
+        if (suspendPayload?.__workflow_meta) {
+          delete suspendPayload.__workflow_meta;
+        }
+        const firstSuspendedStepPath = [...workflowState?.suspended?.[0] ?? []];
+        let wflowStep = wf;
+        while (firstSuspendedStepPath.length > 0) {
+          const key = firstSuspendedStepPath.shift();
+          if (key) {
+            if (!wflowStep.steps[key]) {
+              mastra?.getLogger()?.warn(`Suspended step '${key}' not found in workflow '${workflowId}'`);
+              break;
+            }
+            wflowStep = wflowStep.steps[key];
+          }
+        }
+        const wflowStepSchema = wflowStep?.resumeSchema;
+        if (wflowStepSchema) {
+          resumeSchema = JSON.stringify(zodToJsonSchema(wflowStepSchema));
+        } else {
+          resumeSchema = "";
+        }
+      }
       const finalResult = JSON.stringify({
         isNetwork: true,
         primitiveType: inputData.primitiveType,
@@ -13942,37 +14058,86 @@ async function createNetworkLoop({
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId2(),
+            id: generateId2({
+              idType: "message",
+              source: "workflow",
+              entityId: wf.id,
+              threadId: initData?.threadId || runId,
+              resourceId: initData?.threadResourceId || networkName,
+              role: "assistant"
+            }),
             type: "text",
             role: "assistant",
-            content: { parts: [{ type: "text", text: finalResult }], format: 2 },
-            createdAt: /* @__PURE__ */ new Date(),
-            threadId: initData?.threadId || runId,
-            resourceId: initData?.threadResourceId || networkName
-          }
-        ]
-      });
-      const endPayload = {
-        task: inputData.task,
-        primitiveId: inputData.primitiveId,
-        primitiveType: inputData.primitiveType,
-        result: finalResult,
-        isComplete: false,
-        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 */,
-        runId
+            content: {
+              parts: [{ type: "text", text: finalResult }],
+              format: 2,
+              ...suspendPayload ? {
+                metadata: {
+                  suspendedTools: {
+                    [inputData.primitiveId]: {
+                      args: input,
+                      suspendPayload,
+                      runId,
+                      type: "suspension",
+                      resumeSchema,
+                      workflowId,
+                      primitiveType: "workflow",
+                      primitiveId: inputData.primitiveId,
+                      toolName: inputData.primitiveId,
+                      toolCallId: inputData.primitiveId
+                    }
+                  }
+                }
+              } : {}
+            },
+            createdAt: /* @__PURE__ */ new Date(),
+            threadId: initData?.threadId || runId,
+            resourceId: initData?.threadResourceId || networkName
+          }
+        ]
       });
-      return endPayload;
+      if (suspendPayload) {
+        await writer?.write({
+          type: "workflow-execution-suspended",
+          payload: {
+            args: input,
+            workflowId,
+            suspendPayload,
+            resumeSchema,
+            name: wf.name,
+            runId: stepId,
+            usage: await stream.usage,
+            selectionReason: inputData.selectionReason,
+            toolName: inputData.primitiveId,
+            toolCallId: inputData.primitiveId
+          },
+          from: "NETWORK" /* NETWORK */,
+          runId
+        });
+        return suspend({ ...toolData, workflowSuspended: suspendPayload });
+      } else {
+        const endPayload = {
+          task: inputData.task,
+          primitiveId: inputData.primitiveId,
+          primitiveType: inputData.primitiveType,
+          result: finalResult,
+          isComplete: false,
+          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 */,
+          runId
+        });
+        return endPayload;
+      }
     }
   });
   const toolStep = createStep({
@@ -13985,7 +14150,8 @@ async function createNetworkLoop({
       result: z10.string(),
       isComplete: z10.boolean().optional(),
       selectionReason: z10.string(),
-      iteration: z10.number()
+      iteration: z10.number(),
+      conversationContext: z10.array(z10.any()).optional()
     }),
     outputSchema: z10.object({
       task: z10.string(),
@@ -13995,8 +14161,12 @@ async function createNetworkLoop({
       isComplete: z10.boolean().optional(),
       iteration: z10.number()
     }),
-    execute: async ({ inputData, getInitData, writer }) => {
+    resumeSchema: z10.object({
+      approved: z10.boolean().describe("Controls if the tool call is approved or not, should be true when approved and false when declined")
+    }),
+    execute: async ({ inputData, getInitData, writer, resumeData, mastra, suspend }) => {
       const initData = await getInitData();
+      const logger = mastra?.getLogger();
       const agentTools = await agent.listTools({ requestContext });
       const memory = await agent.getMemory({ requestContext });
       const memoryTools = await memory?.listTools?.();
@@ -14036,7 +14206,12 @@ async function createNetworkLoop({
         );
         throw mastraError;
       }
-      const toolCallId = generateId2();
+      const toolCallId = generateId2({
+        idType: "step",
+        source: "agent",
+        entityId: toolId,
+        stepType: "tool-execution"
+      });
       await writer?.write({
         type: "tool-execution-start",
         payload: {
@@ -14051,6 +14226,140 @@ async function createNetworkLoop({
         from: "NETWORK" /* NETWORK */,
         runId
       });
+      let toolRequiresApproval = tool2.requireApproval;
+      if (tool2.needsApprovalFn) {
+        try {
+          const needsApprovalResult = await tool2.needsApprovalFn(inputDataToUse);
+          toolRequiresApproval = needsApprovalResult;
+        } catch (error) {
+          logger?.error(`Error evaluating needsApprovalFn for tool ${toolId}:`, error);
+          toolRequiresApproval = true;
+        }
+      }
+      if (toolRequiresApproval) {
+        if (!resumeData) {
+          const requireApprovalResumeSchema = JSON.stringify(
+            zodToJsonSchema(
+              z10.object({
+                approved: z10.boolean().describe(
+                  "Controls if the tool call is approved or not, should be true when approved and false when declined"
+                )
+              })
+            )
+          );
+          await memory?.saveMessages({
+            messages: [
+              {
+                id: generateId2(),
+                type: "text",
+                role: "assistant",
+                content: {
+                  parts: [
+                    {
+                      type: "text",
+                      text: JSON.stringify({
+                        isNetwork: true,
+                        selectionReason: inputData.selectionReason,
+                        primitiveType: inputData.primitiveType,
+                        primitiveId: inputData.primitiveId,
+                        finalResult: { result: "", toolCallId },
+                        input: inputDataToUse
+                      })
+                    }
+                  ],
+                  format: 2,
+                  metadata: {
+                    mode: "network",
+                    requireApprovalMetadata: {
+                      [inputData.primitiveId]: {
+                        toolCallId,
+                        toolName: inputData.primitiveId,
+                        args: inputDataToUse,
+                        type: "approval",
+                        resumeSchema: requireApprovalResumeSchema,
+                        runId,
+                        primitiveType: "tool",
+                        primitiveId: inputData.primitiveId
+                      }
+                    }
+                  }
+                },
+                createdAt: /* @__PURE__ */ new Date(),
+                threadId: initData.threadId || runId,
+                resourceId: initData.threadResourceId || networkName
+              }
+            ]
+          });
+          await writer?.write({
+            type: "tool-execution-approval",
+            payload: {
+              toolName: inputData.primitiveId,
+              toolCallId,
+              args: inputDataToUse,
+              selectionReason: inputData.selectionReason,
+              resumeSchema: requireApprovalResumeSchema,
+              runId
+            }
+          });
+          return suspend({
+            requireToolApproval: {
+              toolName: inputData.primitiveId,
+              args: inputDataToUse,
+              toolCallId
+            }
+          });
+        } else {
+          if (!resumeData.approved) {
+            const rejectionResult = "Tool call was not approved by the user";
+            await memory?.saveMessages({
+              messages: [
+                {
+                  id: generateId2(),
+                  type: "text",
+                  role: "assistant",
+                  content: {
+                    parts: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          isNetwork: true,
+                          selectionReason: inputData.selectionReason,
+                          primitiveType: inputData.primitiveType,
+                          primitiveId: inputData.primitiveId,
+                          finalResult: { result: rejectionResult, toolCallId },
+                          input: inputDataToUse
+                        })
+                      }
+                    ],
+                    format: 2
+                  },
+                  createdAt: /* @__PURE__ */ new Date(),
+                  threadId: initData.threadId || runId,
+                  resourceId: initData.threadResourceId || networkName
+                }
+              ]
+            });
+            const endPayload2 = {
+              task: inputData.task,
+              primitiveId: inputData.primitiveId,
+              primitiveType: inputData.primitiveType,
+              result: rejectionResult,
+              isComplete: false,
+              iteration: inputData.iteration,
+              toolCallId,
+              toolName: toolId
+            };
+            await writer?.write({
+              type: "tool-execution-end",
+              payload: endPayload2,
+              from: "NETWORK" /* NETWORK */,
+              runId
+            });
+            return endPayload2;
+          }
+        }
+      }
+      let toolSuspendPayload;
       const finalResult = await tool2.execute(
         inputDataToUse,
         {
@@ -14059,7 +14368,67 @@ async function createNetworkLoop({
           agent: {
             resourceId: initData.threadResourceId || networkName,
             toolCallId,
-            threadId: initData.threadId
+            threadId: initData.threadId,
+            suspend: async (suspendPayload, suspendOptions) => {
+              await memory?.saveMessages({
+                messages: [
+                  {
+                    id: generateId2(),
+                    type: "text",
+                    role: "assistant",
+                    content: {
+                      parts: [
+                        {
+                          type: "text",
+                          text: JSON.stringify({
+                            isNetwork: true,
+                            selectionReason: inputData.selectionReason,
+                            primitiveType: inputData.primitiveType,
+                            primitiveId: toolId,
+                            finalResult: { result: "", toolCallId },
+                            input: inputDataToUse
+                          })
+                        }
+                      ],
+                      format: 2,
+                      metadata: {
+                        mode: "network",
+                        suspendedTools: {
+                          [inputData.primitiveId]: {
+                            toolCallId,
+                            toolName: inputData.primitiveId,
+                            args: inputDataToUse,
+                            suspendPayload,
+                            type: "suspension",
+                            resumeSchema: suspendOptions?.resumeSchema ?? JSON.stringify(zodToJsonSchema(tool2.resumeSchema)),
+                            runId,
+                            primitiveType: "tool",
+                            primitiveId: inputData.primitiveId
+                          }
+                        }
+                      }
+                    },
+                    createdAt: /* @__PURE__ */ new Date(),
+                    threadId: initData.threadId || runId,
+                    resourceId: initData.threadResourceId || networkName
+                  }
+                ]
+              });
+              await writer?.write({
+                type: "tool-execution-suspended",
+                payload: {
+                  toolName: inputData.primitiveId,
+                  toolCallId,
+                  args: inputDataToUse,
+                  resumeSchema: suspendOptions?.resumeSchema ?? JSON.stringify(zodToJsonSchema(tool2.resumeSchema)),
+                  suspendPayload,
+                  runId,
+                  selectionReason: inputData.selectionReason
+                }
+              });
+              toolSuspendPayload = suspendPayload;
+            },
+            resumeData
           },
           runId,
           memory,
@@ -14070,10 +14439,25 @@ async function createNetworkLoop({
         },
         { toolCallId, messages: [] }
       );
+      if (toolSuspendPayload) {
+        return await suspend({
+          toolCallSuspended: toolSuspendPayload,
+          toolName: inputData.primitiveId,
+          args: inputDataToUse,
+          toolCallId
+        });
+      }
       await memory?.saveMessages({
         messages: [
           {
-            id: generateId2(),
+            id: generateId2({
+              idType: "message",
+              source: "agent",
+              entityId: toolId,
+              threadId: initData.threadId,
+              resourceId: initData.threadResourceId || networkName,
+              role: "assistant"
+            }),
             type: "text",
             role: "assistant",
             content: {
@@ -14100,7 +14484,7 @@ async function createNetworkLoop({
       });
       const endPayload = {
         task: inputData.task,
-        primitiveId: toolId,
+        primitiveId: inputData.primitiveId,
         primitiveType: inputData.primitiveType,
         result: finalResult,
         isComplete: false,
@@ -14127,7 +14511,8 @@ async function createNetworkLoop({
       result: z10.string(),
       isComplete: z10.boolean().optional(),
       selectionReason: z10.string(),
-      iteration: z10.number()
+      iteration: z10.number(),
+      conversationContext: z10.array(z10.any()).optional()
     }),
     outputSchema: z10.object({
       task: z10.string(),
@@ -14250,6 +14635,9 @@ async function networkLoop({
   validation,
   routing,
   onIterationComplete,
+  resumeData,
+  autoResumeSuspendedTools,
+  mastra,
   structuredOutput
 }) {
   const memoryToUse = await routingAgent.getMemory({ requestContext });
@@ -14264,11 +14652,84 @@ async function networkLoop({
       }
     });
   }
+  const task = getLastMessage(messages);
+  let resumeDataFromTask;
+  let runIdFromTask;
+  if (autoResumeSuspendedTools && threadId) {
+    let lastAssistantMessage;
+    let requireApprovalMetadata;
+    let suspendedTools;
+    const memory = await routingAgent.getMemory({ requestContext });
+    const threadExists = await memory?.getThreadById({ threadId });
+    if (threadExists) {
+      const recallResult = await memory?.recall({
+        threadId,
+        resourceId: resourceId || networkName
+      });
+      if (recallResult && recallResult.messages?.length > 0) {
+        const messages2 = [...recallResult.messages]?.reverse()?.filter((message) => message.role === "assistant");
+        lastAssistantMessage = messages2[0];
+      }
+      if (lastAssistantMessage) {
+        const { metadata } = lastAssistantMessage.content;
+        if (metadata?.requireApprovalMetadata) {
+          requireApprovalMetadata = metadata.requireApprovalMetadata;
+        }
+        if (metadata?.suspendedTools) {
+          suspendedTools = metadata.suspendedTools;
+        }
+        if (requireApprovalMetadata || suspendedTools) {
+          const suspendedToolsArr = Object.values({ ...suspendedTools, ...requireApprovalMetadata });
+          const firstSuspendedTool = suspendedToolsArr[0];
+          if (firstSuspendedTool.resumeSchema) {
+            try {
+              const llm = await routingAgent.getLLM({ requestContext });
+              const systemInstructions = `
+            You are an assistant used to resume a suspended tool call.
+            Your job is to construct the resumeData for the tool call using the messages available to you and the schema passed.
+            You will generate an object that matches this schema: ${firstSuspendedTool.resumeSchema}.
+            The resumeData generated should be a JSON value that is constructed from the messages, using the schema as guide. The JSON value is stringified.
+
+            {
+              "resumeData": "string"
+            }
+          `;
+              const messageList = new MessageList();
+              messageList.addSystem(systemInstructions);
+              messageList.add(task, "user");
+              const result = llm.stream({
+                methodType: "generate",
+                requestContext,
+                messageList,
+                agentId: routingAgent.id,
+                tracingContext: routingAgentOptions?.tracingContext,
+                structuredOutput: {
+                  schema: z10.object({
+                    resumeData: z10.string()
+                  })
+                }
+              });
+              const object = await result.object;
+              const resumeDataFromLLM = JSON.parse(object.resumeData);
+              if (Object.keys(resumeDataFromLLM).length > 0) {
+                resumeDataFromTask = resumeDataFromLLM;
+                runIdFromTask = firstSuspendedTool.runId;
+              }
+            } catch (error) {
+              mastra?.getLogger()?.error(`Error generating resume data for network agent ${routingAgent.id}`, error);
+            }
+          }
+        }
+      }
+    }
+  }
+  const runIdToUse = runIdFromTask ?? runId;
+  const resumeDataToUse = resumeDataFromTask ?? resumeData;
   const { memory: routingAgentMemoryOptions, ...routingAgentOptionsWithoutMemory } = routingAgentOptions || {};
   const { networkWorkflow } = await createNetworkLoop({
     networkName,
     requestContext,
-    runId,
+    runId: runIdToUse,
     agent: routingAgent,
     routingAgentOptions: routingAgentOptionsWithoutMemory,
     generateId: generateId2,
@@ -14293,7 +14754,7 @@ async function networkLoop({
     execute: async ({ inputData, writer }) => {
       const configuredScorers = validation?.scorers || [];
       const memory = await routingAgent.getMemory({ requestContext });
-      const recallResult = memory ? await memory.recall({ threadId: inputData.threadId || runId }) : { messages: [] };
+      const recallResult = memory ? await memory.recall({ threadId: inputData.threadId || runIdToUse }) : { messages: [] };
       const completionContext = {
         iteration: inputData.iteration,
         maxIterations,
@@ -14306,7 +14767,7 @@ async function networkLoop({
         primitivePrompt: inputData.prompt,
         primitiveResult: inputData.result,
         networkName,
-        runId,
+        runId: runIdToUse,
         threadId: inputData.threadId,
         resourceId: inputData.threadResourceId,
         customContext: requestContext?.toJSON?.()
@@ -14315,7 +14776,7 @@ async function networkLoop({
       await writer?.write({
         type: "network-validation-start",
         payload: {
-          runId,
+          runId: runIdToUse,
           iteration: inputData.iteration,
           checksCount: hasConfiguredScorers ? configuredScorers.length : 1
         },
@@ -14341,7 +14802,7 @@ async function networkLoop({
               {
                 writer,
                 stepId: generateId2(),
-                runId
+                runId: runIdToUse
               }
             );
             generatedFinalResult = structuredResult.text;
@@ -14350,13 +14811,13 @@ async function networkLoop({
             generatedFinalResult = await generateFinalResult(routingAgentToUse, completionContext, {
               writer,
               stepId: generateId2(),
-              runId
+              runId: runIdToUse
             });
           }
           await saveFinalResultIfProvided({
             memory: await routingAgent.getMemory({ requestContext }),
             finalResult: generatedFinalResult,
-            threadId: inputData.threadId || runId,
+            threadId: inputData.threadId || runIdToUse,
             resourceId: inputData.threadResourceId || networkName,
             generateId: generateId2
           });
@@ -14370,7 +14831,7 @@ async function networkLoop({
         const defaultResult = await runDefaultCompletionCheck(routingAgentToUse, completionContext, {
           writer,
           stepId: generateId2(),
-          runId
+          runId: runIdToUse
         });
         completionResult = {
           complete: defaultResult.passed,
@@ -14400,13 +14861,13 @@ async function networkLoop({
           await saveFinalResultIfProvided({
             memory: await routingAgent.getMemory({ requestContext }),
             finalResult: generatedFinalResult || defaultResult.finalResult,
-            threadId: inputData.threadId || runId,
+            threadId: inputData.threadId || runIdToUse,
             resourceId: inputData.threadResourceId || networkName,
             generateId: generateId2
           });
         }
       }
-      const maxIterationReached = inputData.iteration >= maxIterations;
+      const maxIterationReached = maxIterations && inputData.iteration >= maxIterations;
       await writer?.write({
         type: "network-validation-end",
         payload: {
@@ -14420,7 +14881,7 @@ async function networkLoop({
           maxIterationReached: !!maxIterationReached
         },
         from: "NETWORK" /* NETWORK */,
-        runId
+        runId: runIdToUse
       });
       const isComplete = completionResult.complete;
       if (onIterationComplete) {
@@ -14457,7 +14918,7 @@ async function networkLoop({
                 }
               },
               createdAt: /* @__PURE__ */ new Date(),
-              threadId: inputData.threadId || runId,
+              threadId: inputData.threadId || runIdToUse,
               resourceId: inputData.threadResourceId || networkName
             }
           ]
@@ -14514,13 +14975,13 @@ async function networkLoop({
       const finalData = {
         ...restInputData,
         ...structuredObject !== void 0 ? { object: structuredObject } : {},
-        ...inputData.iteration >= maxIterations ? { completionReason: `Max iterations reached: ${maxIterations}` } : {}
+        ...maxIterations && inputData.iteration >= maxIterations ? { completionReason: `Max iterations reached: ${maxIterations}` } : {}
       };
       await writer?.write({
         type: "network-execution-event-finish",
         payload: finalData,
         from: "NETWORK" /* NETWORK */,
-        runId
+        runId: runIdToUse
       });
       return finalData;
     }
@@ -14565,11 +15026,16 @@ async function networkLoop({
   }).dountil(iterationWithValidation, async ({ inputData }) => {
     const llmComplete = inputData.isComplete === true;
     const validationOk = inputData.validationPassed !== false;
-    const maxReached = Boolean(inputData.iteration >= maxIterations);
+    const maxReached = Boolean(maxIterations && inputData.iteration >= maxIterations);
     return llmComplete && validationOk || maxReached;
   }).then(finalStep).commit();
+  const mastraInstance = routingAgent.getMastraInstance();
+  if (mastraInstance) {
+    mainWorkflow.__registerMastra(mastraInstance);
+    networkWorkflow.__registerMastra(mastraInstance);
+  }
   const run = await mainWorkflow.createRun({
-    runId
+    runId: runIdToUse
   });
   const { thread } = await prepareMemoryStep({
     requestContext,
@@ -14581,10 +15047,14 @@ async function networkLoop({
     tracingContext: routingAgentOptions?.tracingContext,
     memoryConfig: routingAgentMemoryOptions?.options
   });
-  const task = getLastMessage(messages);
   return new MastraAgentNetworkStream({
     run,
     createStream: () => {
+      if (resumeDataToUse) {
+        return run.resumeStream({
+          resumeData: resumeDataToUse
+        }).fullStream;
+      }
       return run.stream({
         inputData: {
           task,
@@ -14862,29 +15332,29 @@ var AgentLegacyHandler = class {
               });
             }
             const promises = [];
-            if (thread2.title?.startsWith("New Thread")) {
-              const config = memory.getMergedThreadConfig(memoryConfig2);
-              const userMessage = this.capabilities.getMostRecentUserMessage(messageList.get.all.ui());
-              const {
-                shouldGenerate,
-                model: titleModel,
-                instructions: titleInstructions
-              } = this.capabilities.resolveTitleGenerationConfig(config?.generateTitle);
-              if (shouldGenerate && userMessage) {
-                promises.push(
-                  this.capabilities.genTitle(userMessage, requestContext, { currentSpan: agentSpan }, titleModel, titleInstructions).then((title) => {
-                    if (title) {
-                      return memory.createThread({
-                        threadId: thread2.id,
-                        resourceId,
-                        memoryConfig: memoryConfig2,
-                        title,
-                        metadata: thread2.metadata
-                      });
-                    }
-                  })
-                );
-              }
+            const config = memory.getMergedThreadConfig(memoryConfig2);
+            const userMessage = this.capabilities.getMostRecentUserMessage(messageList.get.all.ui());
+            const {
+              shouldGenerate,
+              model: titleModel,
+              instructions: titleInstructions
+            } = this.capabilities.resolveTitleGenerationConfig(config?.generateTitle);
+            const rememberedUserMessages = messageList.get.remembered.db().filter((m) => m.role === "user");
+            const isFirstUserMessage = rememberedUserMessages.length === 0;
+            if (shouldGenerate && isFirstUserMessage && userMessage) {
+              promises.push(
+                this.capabilities.genTitle(userMessage, requestContext, { currentSpan: agentSpan }, titleModel, titleInstructions).then((title) => {
+                  if (title) {
+                    return memory.createThread({
+                      threadId: thread2.id,
+                      resourceId,
+                      memoryConfig: memoryConfig2,
+                      title,
+                      metadata: thread2.metadata
+                    });
+                  }
+                })
+              );
             }
             if (promises.length > 0) {
               await Promise.all(promises);
@@ -14998,7 +15468,13 @@ var AgentLegacyHandler = class {
         `[Agent:${this.capabilities.name}] - No memory is configured but resourceId and threadId were passed in args. This will not work.`
       );
     }
-    const runId = args.runId || this.capabilities.mastra?.generateId() || randomUUID();
+    const runId = args.runId || this.capabilities.mastra?.generateId({
+      idType: "run",
+      source: "agent",
+      entityId: this.capabilities.id,
+      threadId: threadFromArgs?.id,
+      resourceId
+    }) || randomUUID();
     const instructions = args.instructions || await this.capabilities.getInstructions({ requestContext });
     const llm = await this.capabilities.getLLM({ requestContext });
     const memory = await this.capabilities.getMemory({ requestContext });
@@ -15643,11 +16119,7 @@ function createMapResultsStep({
   agentId,
   methodType
 }) {
-  return async ({
-    inputData,
-    bail,
-    tracingContext
-  }) => {
+  return async ({ inputData, bail, tracingContext }) => {
     const toolsData = inputData["prepare-tools-step"];
     const memoryData = inputData["prepare-memory-step"];
     const result = {
@@ -15806,7 +16278,7 @@ var coreToolSchema = z.object({
     // Zod schema or other schema types - validated at tool execution
   ]),
   outputSchema: z.union([z.record(z.string(), z.any()), z.any()]).optional(),
-  execute: z.function(z.tuple([z.any(), z.any()]), z.promise(z.any())).optional(),
+  execute: z.optional(z.function(z.tuple([z.any(), z.any()]), z.promise(z.any()))),
   type: z.union([z.literal("function"), z.literal("provider-defined"), z.undefined()]).optional(),
   args: z.record(z.string(), z.any()).optional()
 });
@@ -16021,12 +16493,10 @@ function createStreamStep({
 }) {
   return createStep({
     id: "stream-text-step",
+    // @ts-ignore
     inputSchema: z.any(),
     // tried to type this in various ways but it's too complex
-    outputSchema: z.union([
-      z.instanceof(MastraModelOutput),
-      z.instanceof(AISDKV5OutputStream)
-    ]),
+    outputSchema: z.instanceof(MastraModelOutput),
     execute: async ({ inputData, tracingContext }) => {
       const validatedInputData = inputData;
       capabilities.logger.debug(`Starting agent ${capabilities.agentName} llm stream call`, {
@@ -16139,10 +16609,7 @@ function createPrepareStreamWorkflow({
   return createWorkflow({
     id: "execution-workflow",
     inputSchema: z.object({}),
-    outputSchema: z.union([
-      z.instanceof(MastraModelOutput),
-      z.instanceof(AISDKV5OutputStream)
-    ]),
+    outputSchema: z.instanceof(MastraModelOutput),
     steps: [prepareToolsStep, prepareMemoryStep2, streamStep],
     options: {
       tracingPolicy: {
@@ -16324,6 +16791,11 @@ var Agent = class extends MastraBase {
         this.logger.error(mastraError.toString());
         throw mastraError;
       }
+      Object.entries(agents || {}).forEach(([_agentName, agent]) => {
+        if (this.#mastra) {
+          agent.__registerMastra(this.#mastra);
+        }
+      });
       return agents;
     });
   }
@@ -16793,9 +17265,7 @@ var Agent = class extends MastraBase {
    * console.log(options.maxSteps); // 5
    * ```
    */
-  getDefaultOptions({
-    requestContext = new RequestContext()
-  } = {}) {
+  getDefaultOptions({ requestContext = new RequestContext() } = {}) {
     if (typeof this.#defaultOptions !== "function") {
       return this.#defaultOptions;
     }
@@ -17596,8 +18066,17 @@ var Agent = class extends MastraBase {
               });
               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}`;
+              const subAgentThreadId = inputData.threadId || context?.mastra?.generateId({
+                idType: "thread",
+                source: "agent",
+                entityId: agentName,
+                resourceId
+              }) || randomUUID();
+              const subAgentResourceId = inputData.resourceId || context?.mastra?.generateId({
+                idType: "generic",
+                source: "agent",
+                entityId: agentName
+              }) || `${slugify.default(this.id)}-${agentName}`;
               if ((methodType === "generate" || methodType === "generateLegacy") && supportedLanguageModelSpecifications.includes(modelVersion)) {
                 if (!agent.hasOwnMemory() && this.#memory) {
                   agent.__setMemory(this.#memory);
@@ -17757,6 +18236,7 @@ var Agent = class extends MastraBase {
           mastra: this.#mastra,
           // manually wrap workflow tools with tracing, so that we can pass the
           // current tool span onto the workflow to maintain continuity of the trace
+          // @ts-ignore
           execute: async (inputData, context) => {
             try {
               const { initialState, inputData: workflowInputData, suspendedToolRunId } = inputData;
@@ -17834,18 +18314,21 @@ var Agent = class extends MastraBase {
                 while (firstSuspendedStepPath.length > 0) {
                   const key = firstSuspendedStepPath.shift();
                   if (key) {
-                    if (!workflow.steps[key]) {
+                    if (!wflowStep.steps[key]) {
                       this.logger.warn(`Suspended step '${key}' not found in workflow '${workflowName}'`);
                       break;
                     }
-                    wflowStep = workflow.steps[key];
+                    wflowStep = wflowStep.steps[key];
                   }
                 }
                 const resumeSchema = wflowStep?.resumeSchema;
                 if (suspendPayload?.__workflow_meta) {
                   delete suspendPayload.__workflow_meta;
                 }
-                return suspend?.(suspendPayload, { resumeLabel: suspendedStepIds, resumeSchema });
+                return suspend?.(suspendPayload, {
+                  resumeLabel: suspendedStepIds,
+                  resumeSchema: resumeSchema ? JSON.stringify(zodToJsonSchema(resumeSchema)) : void 0
+                });
               } else {
                 return {
                   error: `Workflow should never reach this path, workflow returned no status`,
@@ -18222,11 +18705,7 @@ 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) {
@@ -18242,10 +18721,12 @@ var Agent = class extends MastraBase {
     const resourceIdFromContext = requestContext.get(MASTRA_RESOURCE_ID_KEY);
     const threadIdFromContext = requestContext.get(MASTRA_THREAD_ID_KEY);
     const threadFromArgs = threadIdFromContext ? { id: threadIdFromContext } : resolveThreadIdFromArgs({
-      threadId: options.threadId || snapshotMemoryInfo?.threadId,
-      memory: options.memory
+      memory: {
+        ...options.memory,
+        thread: options.memory?.thread || snapshotMemoryInfo?.threadId
+      }
     });
-    const resourceId = resourceIdFromContext || options.memory?.resource || options.resourceId || snapshotMemoryInfo?.resourceId;
+    const resourceId = resourceIdFromContext || options.memory?.resource || snapshotMemoryInfo?.resourceId;
     const memoryConfig = options.memory?.options;
     if (resourceId && threadFromArgs && !this.hasOwnMemory()) {
       this.logger.warn(
@@ -18253,7 +18734,7 @@ var Agent = class extends MastraBase {
       );
     }
     const llm = await this.getLLM({ requestContext, model: options.model });
-    if ("structuredOutput" in options && options.structuredOutput && options.structuredOutput.schema) {
+    if ("structuredOutput" in options && options.structuredOutput?.schema) {
       let structuredOutputModel = llm.getModel();
       if (options.structuredOutput?.model) {
         structuredOutputModel = await this.resolveModelConfig(
@@ -18274,14 +18755,18 @@ var Agent = class extends MastraBase {
           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
-            );
+            options.structuredOutput.schema = compatLayer.processZodType(options.structuredOutput.schema);
           }
         }
       }
     }
-    const runId = options.runId || this.#mastra?.generateId() || randomUUID();
+    const runId = options.runId || this.#mastra?.generateId({
+      idType: "run",
+      source: "agent",
+      entityId: this.id,
+      threadId: threadFromArgs?.id,
+      resourceId
+    }) || randomUUID();
     const instructions = options.instructions || await this.getInstructions({ requestContext });
     const agentSpan = getOrCreateSpan({
       type: "agent_run" /* AGENT_RUN */,
@@ -18432,15 +18917,17 @@ var Agent = class extends MastraBase {
             resourceId: thread.resourceId
           });
         }
-        if (thread.title?.startsWith("New Thread")) {
-          const config = memory.getMergedThreadConfig(memoryConfig);
+        const config = memory.getMergedThreadConfig(memoryConfig);
+        const {
+          shouldGenerate,
+          model: titleModel,
+          instructions: titleInstructions
+        } = this.resolveTitleGenerationConfig(config.generateTitle);
+        const rememberedUserMessages = messageList.get.remembered.db().filter((m) => m.role === "user");
+        const isFirstUserMessage = rememberedUserMessages.length === 0;
+        if (shouldGenerate && isFirstUserMessage) {
           const userMessage = this.getMostRecentUserMessage(messageList.get.all.ui());
-          const {
-            shouldGenerate,
-            model: titleModel,
-            instructions: titleInstructions
-          } = this.resolveTitleGenerationConfig(config.generateTitle);
-          if (shouldGenerate && userMessage) {
+          if (userMessage) {
             const title = await this.genTitle(
               userMessage,
               requestContext,
@@ -18518,15 +19005,53 @@ var Agent = class extends MastraBase {
       }
     });
   }
+  async network(messages, options) {
+    const requestContextToUse = options?.requestContext || new RequestContext();
+    const defaultNetworkOptions = await this.getDefaultNetworkOptions({ requestContext: requestContextToUse });
+    const mergedOptions = {
+      ...defaultNetworkOptions,
+      ...options,
+      // Deep merge nested objects
+      routing: { ...defaultNetworkOptions?.routing, ...options?.routing },
+      completion: { ...defaultNetworkOptions?.completion, ...options?.completion }
+    };
+    const runId = mergedOptions?.runId || this.#mastra?.generateId() || randomUUID();
+    const resourceIdFromContext = requestContextToUse.get(MASTRA_RESOURCE_ID_KEY);
+    const threadIdFromContext = requestContextToUse.get(MASTRA_THREAD_ID_KEY);
+    const threadId = threadIdFromContext || (typeof mergedOptions?.memory?.thread === "string" ? mergedOptions?.memory?.thread : mergedOptions?.memory?.thread?.id);
+    const resourceId = resourceIdFromContext || mergedOptions?.memory?.resource;
+    return await networkLoop({
+      networkName: this.name,
+      requestContext: requestContextToUse,
+      runId,
+      routingAgent: this,
+      routingAgentOptions: {
+        modelSettings: mergedOptions?.modelSettings,
+        memory: mergedOptions?.memory
+      },
+      generateId: (context) => this.#mastra?.generateId(context) || randomUUID(),
+      maxIterations: mergedOptions?.maxSteps || 1,
+      messages,
+      threadId,
+      resourceId,
+      validation: mergedOptions?.completion,
+      routing: mergedOptions?.routing,
+      onIterationComplete: mergedOptions?.onIterationComplete,
+      autoResumeSuspendedTools: mergedOptions?.autoResumeSuspendedTools,
+      mastra: this.#mastra,
+      structuredOutput: mergedOptions?.structuredOutput
+    });
+  }
   /**
-   * Executes a network loop where multiple agents can collaborate to handle messages.
+   * Resumes a suspended network loop where multiple agents can collaborate to handle messages.
    * The routing agent delegates tasks to appropriate sub-agents based on the conversation.
    *
    * @experimental
    *
    * @example
    * ```typescript
-   * const result = await agent.network('Find the weather in Tokyo and plan an activity', {
+   * const result = await agent.resumeNetwork({ approved: true }, {
+   *   runId: 'previous-run-id',
    *   memory: {
    *     thread: 'user-123',
    *     resource: 'my-app'
@@ -18539,7 +19064,8 @@ var Agent = class extends MastraBase {
    * }
    * ```
    */
-  async network(messages, options) {
+  async resumeNetwork(resumeData, options) {
+    const runId = options.runId;
     const requestContextToUse = options?.requestContext || new RequestContext();
     const defaultNetworkOptions = await this.getDefaultNetworkOptions({ requestContext: requestContextToUse });
     const mergedOptions = {
@@ -18549,7 +19075,6 @@ var Agent = class extends MastraBase {
       routing: { ...defaultNetworkOptions?.routing, ...options?.routing },
       completion: { ...defaultNetworkOptions?.completion, ...options?.completion }
     };
-    const runId = mergedOptions?.runId || this.#mastra?.generateId() || randomUUID();
     const resourceIdFromContext = requestContextToUse.get(MASTRA_RESOURCE_ID_KEY);
     const threadIdFromContext = requestContextToUse.get(MASTRA_THREAD_ID_KEY);
     const threadId = threadIdFromContext || (typeof mergedOptions?.memory?.thread === "string" ? mergedOptions?.memory?.thread : mergedOptions?.memory?.thread?.id);
@@ -18563,17 +19088,55 @@ var Agent = class extends MastraBase {
         modelSettings: mergedOptions?.modelSettings,
         memory: mergedOptions?.memory
       },
-      generateId: () => this.#mastra?.generateId() || randomUUID(),
+      generateId: (context) => this.#mastra?.generateId(context) || randomUUID(),
       maxIterations: mergedOptions?.maxSteps || 1,
-      messages,
+      messages: [],
       threadId,
       resourceId,
+      resumeData,
       validation: mergedOptions?.completion,
       routing: mergedOptions?.routing,
       onIterationComplete: mergedOptions?.onIterationComplete,
-      structuredOutput: options?.structuredOutput ?? defaultNetworkOptions?.structuredOutput
+      autoResumeSuspendedTools: mergedOptions?.autoResumeSuspendedTools,
+      mastra: this.#mastra
     });
   }
+  /**
+   * Approves a pending network tool call and resumes execution.
+   * Used when `tool.requireApproval` is enabled to allow the agent to proceed with a tool call.
+   *
+   * @example
+   * ```typescript
+   * const stream = await agent.approveNetworkToolCall({
+   *   runId: 'pending-run-id'
+   * });
+   *
+   * for await (const chunk of stream) {
+   *   console.log(chunk);
+   * }
+   * ```
+   */
+  async approveNetworkToolCall(options) {
+    return this.resumeNetwork({ approved: true }, options);
+  }
+  /**
+   * Declines a pending network tool call and resumes execution.
+   * Used when `tool.requireApproval` is enabled to allow the agent to proceed with a tool call.
+   *
+   * @example
+   * ```typescript
+   * const stream = await agent.declineNetworkToolCall({
+   *   runId: 'pending-run-id'
+   * });
+   *
+   * for await (const chunk of stream) {
+   *   console.log(chunk);
+   * }
+   * ```
+   */
+  async declineNetworkToolCall(options) {
+    return this.resumeNetwork({ approved: false }, options);
+  }
   async generate(messages, options) {
     const defaultOptions = await this.getDefaultOptions({
       requestContext: options?.requestContext
@@ -18693,19 +19256,6 @@ var Agent = class extends MastraBase {
     }
     return result.result;
   }
-  /**
-   * Resumes a previously suspended stream execution.
-   * Used to continue execution after a suspension point (e.g., tool approval, workflow suspend).
-   *
-   * @example
-   * ```typescript
-   * // Resume after suspension
-   * const stream = await agent.resumeStream(
-   *   { approved: true },
-   *   { runId: 'previous-run-id' }
-   * );
-   * ```
-   */
   async resumeStream(resumeData, streamOptions) {
     const defaultOptions = await this.getDefaultOptions({
       requestContext: streamOptions?.requestContext
@@ -20273,35 +20823,71 @@ var TokenLimiterProcessor = class _TokenLimiterProcessor {
    * Process input messages to limit them to the configured token limit.
    * This filters historical messages to fit within the token budget,
    * prioritizing the most recent messages.
+   *
+   * Uses messageList.get.all.db() to access ALL messages (memory + input),
+   * not just the input messages passed in the messages parameter.
+   * System messages are accessed via args.systemMessages (they're stored separately).
+   * Removes filtered messages directly from messageList and returns it.
    */
   async processInput(args) {
-    const { messages } = args;
+    const { messageList, systemMessages: coreSystemMessages } = args;
+    const messages = messageList?.get.all.db() ?? args.messages;
     const limit = this.maxTokens;
     if (!messages || messages.length === 0) {
-      return messages;
+      throw new TripWire("TokenLimiterProcessor: No messages to process. Cannot send LLM a request with no messages.", {
+        retry: false
+      });
     }
-    const systemMessages = messages.filter((msg) => msg.role === "system");
-    const nonSystemMessages = messages.filter((msg) => msg.role !== "system");
     let systemTokens = 0;
-    for (const msg of systemMessages) {
-      systemTokens += this.countInputMessageTokens(msg);
+    if (coreSystemMessages && coreSystemMessages.length > 0) {
+      for (const msg of coreSystemMessages) {
+        systemTokens += this.countCoreSystemMessageTokens(msg);
+      }
     }
+    const nonSystemMessages = messages;
     if (systemTokens + _TokenLimiterProcessor.TOKENS_PER_CONVERSATION >= limit) {
-      return systemMessages;
+      throw new TripWire(
+        "TokenLimiterProcessor: System messages alone exceed token limit. Requests cannot be completed by removing system messages.",
+        { retry: false, metadata: { systemTokens, limit } }
+      );
     }
     const remainingBudget = limit - systemTokens - _TokenLimiterProcessor.TOKENS_PER_CONVERSATION;
-    const result = [];
+    const messagesToKeep = [];
     let currentTokens = 0;
     for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
       const message = nonSystemMessages[i];
       if (!message) continue;
       const messageTokens = this.countInputMessageTokens(message);
       if (currentTokens + messageTokens <= remainingBudget) {
-        result.unshift(message);
+        messagesToKeep.unshift(message);
         currentTokens += messageTokens;
       }
     }
-    return [...systemMessages, ...result];
+    if (messageList) {
+      const keepIds = new Set(messagesToKeep.map((m) => m.id));
+      const idsToRemove = messages.filter((m) => !keepIds.has(m.id)).map((m) => m.id);
+      if (idsToRemove.length > 0) {
+        messageList.removeByIds(idsToRemove);
+      }
+      return messageList;
+    }
+    return messagesToKeep;
+  }
+  /**
+   * Count tokens for a system message (CoreMessageV4 from args.systemMessages).
+   * This method only accepts system messages with string content and will throw otherwise.
+   */
+  countCoreSystemMessageTokens(message) {
+    if (message.role !== "system") {
+      throw new Error(
+        `countCoreSystemMessageTokens can only be used with system messages, received role: ${message.role}`
+      );
+    }
+    if (typeof message.content !== "string") {
+      throw new Error("countCoreSystemMessageTokens: System message content must be a string");
+    }
+    const tokenString = message.role + message.content;
+    return this.encoder.encode(tokenString).length + _TokenLimiterProcessor.TOKENS_PER_MESSAGE;
   }
   /**
    * Count tokens for an input message, including overhead for message structure
@@ -21209,6 +21795,9 @@ var SemanticRecall = class {
   embedderOptions;
   // xxhash-wasm hasher instance (initialized as a promise)
   hasher = xxhash();
+  // Cache for index dimension validation (per-process)
+  // Prevents redundant API calls when index already validated
+  indexValidationCache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.storage = options.storage;
     this.vector = options.vector;
@@ -21434,17 +22023,19 @@ ${result}
   }
   /**
    * Ensure vector index exists with correct dimensions
+   * Uses in-memory cache to avoid redundant validation calls
    */
   async ensureVectorIndex(indexName, dimension) {
-    const indexes = await this.vector.listIndexes();
-    const indexExists = indexes.includes(indexName);
-    if (!indexExists) {
-      await this.vector.createIndex({
-        indexName,
-        dimension,
-        metric: "cosine"
-      });
+    const cached = this.indexValidationCache.get(indexName);
+    if (cached?.dimension === dimension) {
+      return;
     }
+    await this.vector.createIndex({
+      indexName,
+      dimension,
+      metric: "cosine"
+    });
+    this.indexValidationCache.set(indexName, { dimension });
   }
   /**
    * Process output messages to create embeddings for messages being saved
@@ -21822,7 +22413,11 @@ https://mastra.ai/en/docs/memory/overview`
     saveThread = true
   }) {
     const thread = {
-      id: threadId || this.generateId(),
+      id: threadId || this.generateId({
+        idType: "thread",
+        source: "memory",
+        resourceId
+      }),
       title: title || `New Thread ${(/* @__PURE__ */ new Date()).toISOString()}`,
       resourceId,
       createdAt: /* @__PURE__ */ new Date(),
@@ -21848,10 +22443,11 @@ https://mastra.ai/en/docs/memory/overview`
   }
   /**
    * Generates a unique identifier
+   * @param context - Optional context information for deterministic ID generation
    * @returns A unique string ID
    */
-  generateId() {
-    return this.#mastra?.generateId() || crypto.randomUUID();
+  generateId(context) {
+    return this.#mastra?.generateId(context) || crypto.randomUUID();
   }
   /**
    * Get input processors for this memory instance
@@ -22181,7 +22777,7 @@ var MockMemory = class extends MastraMemory {
         const schema = workingMemoryConfig.schema;
         let convertedSchema;
         if (isZodObject(schema)) {
-          convertedSchema = zodToJsonSchema(schema);
+          convertedSchema = zodToJsonSchema$1(schema);
         } else {
           convertedSchema = schema;
         }
@@ -22243,6 +22839,6 @@ var MockMemory = class extends MastraMemory {
   }
 };
 
-export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, EventEmitterPubSub, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MastraScorer, 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, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, augmentWithInit, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatValidationFeedback, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, globalEmbeddingCache, hydrateSerializedStepErrors, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runValidation, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-IC2MIQBW.js.map
-//# sourceMappingURL=chunk-IC2MIQBW.js.map
+export { Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, EventEmitterPubSub, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MastraScorer, 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, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, augmentWithInit, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatValidationFeedback, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, globalEmbeddingCache, hydrateSerializedStepErrors, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runValidation, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData, validateStepStateData, validateStepSuspendData };
+//# sourceMappingURL=chunk-UVOQLIWL.js.map
+//# sourceMappingURL=chunk-UVOQLIWL.js.map