@mastra/core 1.26.0-alpha.11 → 1.26.0-alpha.13

package/dist/{chunk-72TFCXLB.js → chunk-DLDGEMBE.js}

@@ -8,7 +8,7 @@ import { generateId, APICallError, tool, asSchema } from './chunk-6PALJNKG.js';
 import { noopLogger } from './chunk-7BVF2WMQ.js';
 import { EventEmitterPubSub } from './chunk-II5FASYS.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-BQN6OA5U.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-T5WE2PEP.js';
 import { MastraLLMV1 } from './chunk-YHOV4F62.js';
 import { removeUndefinedValues, safeStringify, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, generateEmptyFromSchema, selectFields, ensureSerializable, delay } from './chunk-XYWVTGZY.js';
 import { resolveObservabilityContext, createObservabilityContext, wrapMastra } from './chunk-WA5YOVRJ.js';
@@ -18,7 +18,7 @@ import { MastraError, getErrorFromUnknown } from './chunk-FJEVLHJT.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
 import { createTool, Tool, isProviderTool, isMastraTool, getProviderToolName, isProviderDefinedTool } from './chunk-O3JJ5ZPY.js';
 import { toStandardSchema, standardSchemaToJSONSchema, isStandardSchemaWithJSON } from './chunk-6SRTDZ7S.js';
-import { RequestContext, MASTRA_THREAD_ID_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_VERSIONS_KEY, mergeVersionOverrides } from './chunk-AJVVIFTH.js';
+import { MASTRA_THREAD_ID_KEY, MASTRA_RESOURCE_ID_KEY, RequestContext, MASTRA_VERSIONS_KEY, mergeVersionOverrides } from './chunk-AJVVIFTH.js';
 import { MastraBase } from './chunk-WENZPAHS.js';
 import { RegisteredLogger, ConsoleLogger } from './chunk-DBBWTK24.js';
 import { generateBackgroundTaskSystemPrompt, resolveBackgroundConfig, createBackgroundTask } from './chunk-VMEECRDJ.js';
@@ -749,6 +749,10 @@ var StructuredOutputProcessor = class {
   name = "Structured Output";
   schema;
   structuringAgent;
+  structuringModel;
+  structuringInstructions;
+  agent;
+  useAgent = false;
   errorStrategy;
   fallbackValue;
   isStructuringAgentStreamStarted = false;
@@ -773,49 +777,56 @@ var StructuredOutputProcessor = class {
       });
     }
     this.schema = options.schema;
+    this.structuringModel = options.model;
+    this.useAgent = options.useAgent ?? false;
     this.errorStrategy = options.errorStrategy ?? "strict";
     this.fallbackValue = options.fallbackValue;
     this.jsonPromptInjection = options.jsonPromptInjection;
     this.providerOptions = options.providerOptions;
     this.logger = options.logger;
+    this.structuringInstructions = options.instructions || this.generateInstructions();
     this.structuringAgent = new Agent({
       id: "structured-output-structurer",
       name: "structured-output-structurer",
-      instructions: options.instructions || this.generateInstructions(),
+      instructions: this.structuringInstructions,
       model: options.model
     });
   }
   __registerMastra(mastra) {
     this.structuringAgent.__registerMastra(mastra);
   }
+  setAgent(agent) {
+    this.agent = agent;
+  }
   async processOutputStream(args) {
-    const { part, state, streamParts, abort, ...rest } = args;
+    const { part, state, streamParts, abort, requestContext, messageList, ...rest } = args;
     const observabilityContext = resolveObservabilityContext(rest);
     const controller = state.controller;
     switch (part.type) {
       case "finish":
-        await this.processAndEmitStructuredOutput(streamParts, controller, abort, observabilityContext);
+        await this.processAndEmitStructuredOutput(
+          streamParts,
+          controller,
+          abort,
+          observabilityContext,
+          requestContext,
+          messageList
+        );
         return part;
       default:
         return part;
     }
   }
-  async processAndEmitStructuredOutput(streamParts, controller, abort, observabilityContext) {
+  async processAndEmitStructuredOutput(streamParts, controller, abort, observabilityContext, requestContext, messageList) {
     if (this.isStructuringAgentStreamStarted) return;
     this.isStructuringAgentStreamStarted = true;
     try {
-      const structuringPrompt = this.buildStructuringPrompt(streamParts);
-      const prompt = `Extract and structure the key information from the following text according to the specified schema. Keep the original meaning and details:
-
-${structuringPrompt}`;
-      const structuringAgentStream = await this.structuringAgent.stream(prompt, {
-        structuredOutput: {
-          schema: this.schema,
-          jsonPromptInjection: this.jsonPromptInjection
-        },
-        providerOptions: this.providerOptions,
-        ...observabilityContext
-      });
+      const structuringAgentStream = await this.getStructuringStream(
+        streamParts,
+        requestContext,
+        messageList,
+        observabilityContext
+      );
       const excludedChunkTypes = [
         "start",
         "finish",
@@ -845,7 +856,7 @@ ${structuringPrompt}`;
                 fallback: true
               }
             };
-            controller.enqueue(fallbackChunk);
+            controller?.enqueue(fallbackChunk);
             break;
           }
         }
@@ -855,12 +866,69 @@ ${structuringPrompt}`;
             from: "structured-output"
           }
         };
-        controller.enqueue(newChunk);
+        controller?.enqueue(newChunk);
       }
     } catch (error) {
       this.handleError("Structured output processing failed", error, abort);
     }
   }
+  /**
+   * Get the structuring stream, using the explicit agent with model override and
+   * read-only memory when request context provides thread info, falling back to the bare internal agent.
+   */
+  async getStructuringStream(streamParts, requestContext, messageList, observabilityContext) {
+    const requestThreadId = requestContext?.get(MASTRA_THREAD_ID_KEY);
+    const requestResourceId = requestContext?.get(MASTRA_RESOURCE_ID_KEY);
+    const serializedMemoryInfo = messageList?.serialize().memoryInfo;
+    const threadId = typeof requestThreadId === "string" ? requestThreadId : typeof serializedMemoryInfo?.threadId === "string" ? serializedMemoryInfo.threadId : void 0;
+    const resourceId = typeof requestResourceId === "string" ? requestResourceId : typeof serializedMemoryInfo?.resourceId === "string" ? serializedMemoryInfo.resourceId : void 0;
+    if (this.useAgent && this.agent && threadId) {
+      const promptMessage = {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: `Extract and structure information from the conversation so far. keep the original meaning and details. Rely on the provided text and conversation history`
+          }
+        ]
+      };
+      const messages = [
+        ...messageList?.get?.input?.db() || [],
+        ...messageList?.get?.response?.db() || [],
+        promptMessage
+      ];
+      const structuringRequestContext = requestContext ? new RequestContext(requestContext.entries()) : void 0;
+      return this.agent.stream(messages, {
+        model: this.structuringModel,
+        requestContext: structuringRequestContext,
+        toolChoice: "none",
+        structuredOutput: {
+          schema: this.schema,
+          jsonPromptInjection: this.jsonPromptInjection
+        },
+        memory: {
+          thread: threadId,
+          ...resourceId ? { resource: resourceId } : {},
+          options: { readOnly: true }
+        },
+        providerOptions: this.providerOptions,
+        ...observabilityContext
+      });
+    }
+    return this.structuringAgent.stream(
+      `Extract and structure the key information from the following text according to the specified schema. Keep the original meaning and details. Rely on the provided text and conversation history.
+
+${this.buildStructuringPrompt(streamParts)}`,
+      {
+        structuredOutput: {
+          schema: this.schema,
+          jsonPromptInjection: this.jsonPromptInjection
+        },
+        providerOptions: this.providerOptions,
+        ...observabilityContext
+      }
+    );
+  }
   /**
    * Build a structured markdown prompt from stream parts
    * Collects chunks by type and formats them in a consistent structure
@@ -3231,11 +3299,12 @@ var MastraModelOutput = class extends MastraBase {
             } else {
               if (!processorStates.has(STRUCTURED_OUTPUT_PROCESSOR_NAME)) {
                 const processorIndex = processorRunner.outputProcessors.findIndex(
-                  (p) => p.name === STRUCTURED_OUTPUT_PROCESSOR_NAME
+                  (p) => p.id === STRUCTURED_OUTPUT_PROCESSOR_NAME
                 );
                 if (processorIndex !== -1) {
+                  const structuredOutputProcessor = processorRunner.outputProcessors[processorIndex];
                   const structuredOutputProcessorState = new ProcessorState({
-                    processorName: STRUCTURED_OUTPUT_PROCESSOR_NAME,
+                    processorName: structuredOutputProcessor?.name ?? STRUCTURED_OUTPUT_PROCESSOR_NAME,
                     tracingContext: options.tracingContext,
                     processorIndex,
                     createSpan: true
@@ -14166,7 +14235,7 @@ function execute({
       schema: responseFormat.schema
     });
   }
-  if (structuredOutputMode === "processor" && responseFormat?.type === "json" && responseFormat?.schema) {
+  if (structuredOutputMode === "processor" && responseFormat?.type === "json" && responseFormat?.schema && !structuredOutput?.useAgent) {
     prompt = injectJsonInstructionIntoMessages({
       messages: inputMessages,
       schema: responseFormat.schema,
@@ -14346,15 +14415,10 @@ var AgenticRunState = class {
         modelVersion: model.specificationVersion,
         modelProvider: model.provider
       },
-      isReasoning: false,
-      isStreaming: false,
       providerOptions: void 0,
-      hasToolCallStreaming: false,
       hasErrored: false,
       apiError: void 0,
       deferredErrorChunk: void 0,
-      reasoningBuffers: /* @__PURE__ */ new Map(),
-      textDeltas: [],
       stepResult: void 0
     };
   }
@@ -14369,6 +14433,265 @@ var AgenticRunState = class {
   }
 };
 
+// src/loop/workflows/agentic-execution/build-messages-from-chunks.ts
+function buildMessagesFromChunks({
+  chunks,
+  messageId,
+  responseModelMetadata,
+  tools
+}) {
+  const parts = [];
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    if (chunk.type === "tool-result" && chunk.payload.result != null) {
+      const p = chunk.payload;
+      toolResults.set(p.toolCallId, {
+        result: p.result,
+        args: p.args,
+        providerMetadata: p.providerMetadata,
+        providerExecuted: p.providerExecuted,
+        toolName: p.toolName
+      });
+    }
+  }
+  const textSpans = /* @__PURE__ */ new Map();
+  const reasoningSpans = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    switch (chunk.type) {
+      // ── Text span ──────────────────────────────────────────────
+      case "text-start": {
+        const p = chunk.payload;
+        if (!textSpans.has(p.id)) {
+          textSpans.set(p.id, {
+            deltas: [],
+            providerMetadata: p.providerMetadata
+          });
+        } else {
+          const existing = textSpans.get(p.id);
+          if (p.providerMetadata) {
+            existing.providerMetadata = p.providerMetadata;
+          }
+        }
+        break;
+      }
+      case "text-delta": {
+        const p = chunk.payload;
+        let span = textSpans.get(p.id);
+        if (!span) {
+          span = { deltas: [], providerMetadata: p.providerMetadata };
+          textSpans.set(p.id, span);
+        }
+        span.deltas.push(p.text);
+        if (p.providerMetadata) {
+          span.providerMetadata = p.providerMetadata;
+        }
+        break;
+      }
+      case "text-end": {
+        const pEnd = chunk.payload;
+        const span = textSpans.get(pEnd.id);
+        if (span) {
+          if (pEnd.providerMetadata) {
+            span.providerMetadata = pEnd.providerMetadata;
+          }
+          const text = span.deltas.join("");
+          if (text.length > 0) {
+            parts.push({
+              type: "text",
+              text,
+              ...span.providerMetadata ? { providerMetadata: span.providerMetadata } : {}
+            });
+          }
+          textSpans.delete(pEnd.id);
+        }
+        break;
+      }
+      // ── Reasoning span ─────────────────────────────────────────
+      case "reasoning-start": {
+        const p = chunk.payload;
+        const isRedacted = Object.values(p.providerMetadata || {}).some((v) => v?.redactedData);
+        if (!reasoningSpans.has(p.id)) {
+          reasoningSpans.set(p.id, {
+            deltas: [],
+            providerMetadata: p.providerMetadata,
+            redacted: isRedacted
+          });
+        } else {
+          const existing = reasoningSpans.get(p.id);
+          if (p.providerMetadata) {
+            existing.providerMetadata = p.providerMetadata;
+          }
+          if (isRedacted) {
+            existing.redacted = true;
+          }
+        }
+        break;
+      }
+      case "reasoning-delta": {
+        const p = chunk.payload;
+        let span = reasoningSpans.get(p.id);
+        if (!span) {
+          span = { deltas: [], providerMetadata: p.providerMetadata, redacted: false };
+          reasoningSpans.set(p.id, span);
+        }
+        span.deltas.push(p.text);
+        if (p.providerMetadata) {
+          span.providerMetadata = p.providerMetadata;
+        }
+        break;
+      }
+      case "reasoning-end": {
+        const p = chunk.payload;
+        const span = reasoningSpans.get(p.id);
+        if (span) {
+          if (p.providerMetadata) {
+            span.providerMetadata = p.providerMetadata;
+          }
+          if (span.redacted) {
+            parts.push({
+              type: "reasoning",
+              reasoning: "",
+              details: [{ type: "redacted", data: "" }],
+              providerMetadata: span.providerMetadata
+            });
+          } else {
+            parts.push({
+              type: "reasoning",
+              reasoning: "",
+              details: [{ type: "text", text: span.deltas.join("") }],
+              providerMetadata: span.providerMetadata
+            });
+          }
+          reasoningSpans.delete(p.id);
+        }
+        break;
+      }
+      // Redacted reasoning can appear as a standalone chunk (not wrapped in start/end)
+      case "redacted-reasoning": {
+        const p = chunk.payload;
+        parts.push({
+          type: "reasoning",
+          reasoning: "",
+          details: [{ type: "redacted", data: "" }],
+          providerMetadata: p.providerMetadata
+        });
+        break;
+      }
+      // ── Source ──────────────────────────────────────────────────
+      case "source": {
+        const p = chunk.payload;
+        parts.push({
+          type: "source",
+          source: {
+            sourceType: "url",
+            id: p.id,
+            url: p.url || "",
+            title: p.title,
+            providerMetadata: p.providerMetadata
+          }
+        });
+        break;
+      }
+      // ── File ───────────────────────────────────────────────────
+      case "file": {
+        const p = chunk.payload;
+        parts.push({
+          type: "file",
+          data: p.data,
+          mimeType: p.mimeType,
+          ...p.providerMetadata ? { providerMetadata: p.providerMetadata } : {}
+        });
+        break;
+      }
+      // ── Tool call ──────────────────────────────────────────────
+      case "tool-call": {
+        const p = chunk.payload;
+        const toolDef = tools?.[p.toolName] || findProviderToolByName(tools, p.toolName);
+        const providerExecuted = inferProviderExecuted(p.providerExecuted, toolDef);
+        const result = toolResults.get(p.toolCallId);
+        if (result) {
+          const resultProviderExecuted = inferProviderExecuted(result.providerExecuted, toolDef);
+          parts.push({
+            type: "tool-invocation",
+            toolInvocation: {
+              state: "result",
+              toolCallId: p.toolCallId,
+              toolName: p.toolName,
+              args: p.args,
+              result: result.result
+            },
+            providerMetadata: result.providerMetadata ?? p.providerMetadata,
+            providerExecuted: resultProviderExecuted
+          });
+        } else {
+          parts.push({
+            type: "tool-invocation",
+            toolInvocation: {
+              state: "call",
+              toolCallId: p.toolCallId,
+              toolName: p.toolName,
+              args: p.args
+            },
+            providerMetadata: p.providerMetadata,
+            providerExecuted
+          });
+        }
+        break;
+      }
+    }
+  }
+  for (const [_id, span] of reasoningSpans) {
+    if (span.redacted) {
+      parts.push({
+        type: "reasoning",
+        reasoning: "",
+        details: [{ type: "redacted", data: "" }],
+        providerMetadata: span.providerMetadata
+      });
+    } else {
+      const text = span.deltas.join("");
+      parts.push({
+        type: "reasoning",
+        reasoning: "",
+        details: [{ type: "text", text }],
+        providerMetadata: span.providerMetadata
+      });
+    }
+  }
+  for (const [, span] of textSpans) {
+    const text = span.deltas.join("");
+    if (text.length > 0) {
+      parts.push({
+        type: "text",
+        text,
+        ...span.providerMetadata ? { providerMetadata: span.providerMetadata } : {}
+      });
+    }
+  }
+  const finalParts = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.type === "text" && finalParts.length > 0 && finalParts[finalParts.length - 1]?.type === "tool-invocation") {
+      finalParts.push({ type: "step-start" });
+    }
+    finalParts.push(part);
+  }
+  if (finalParts.length === 0) {
+    return [];
+  }
+  const message = {
+    id: messageId,
+    role: "assistant",
+    content: {
+      format: 2,
+      parts: finalParts,
+      ...responseModelMetadata
+    },
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  return [message];
+}
+
 // src/loop/workflows/agentic-execution/llm-execution-step.ts
 function buildResponseModelMetadata(runState, model) {
   const metadata = {};
@@ -14381,39 +14704,12 @@ function buildResponseModelMetadata(runState, model) {
   }
   return Object.keys(metadata).length > 0 ? { metadata } : void 0;
 }
-function flushReasoningBuffer({
-  buffer,
-  messageId,
-  messageList,
-  runState,
-  model
-}) {
-  const message = {
-    id: messageId,
-    role: "assistant",
-    content: {
-      format: 2,
-      parts: [
-        {
-          type: "reasoning",
-          reasoning: "",
-          details: [{ type: "text", text: buffer.deltas.join("") }],
-          providerMetadata: buffer.providerMetadata
-        }
-      ],
-      ...buildResponseModelMetadata(runState, model)
-    },
-    createdAt: /* @__PURE__ */ new Date()
-  };
-  messageList.add(message, "response");
-}
 async function processOutputStream({
   tools,
   messageId,
   messageList,
   outputStream,
   runState,
-  model,
   options,
   controller,
   responseFromModel,
@@ -14423,6 +14719,7 @@ async function processOutputStream({
   transportResolver
 }) {
   let transportSet = false;
+  const collectedChunks = [];
   for await (const chunk of outputStream._getBaseStream()) {
     if (options?.abortSignal?.aborted) {
       break;
@@ -14441,60 +14738,7 @@ async function processOutputStream({
       controller.enqueue(chunk);
       continue;
     }
-    if (chunk.type !== "text-delta" && // not 100% sure about this being the right fix.
-    // basically for some llm providers they add response-metadata after each text-delta
-    // we then flush the chunks by calling messageList.add (a few lines down)
-    // this results in a bunch of weird separated text chunks on the message instead of combined chunks
-    // easiest solution here is to just not flush for response-metadata
-    // BUT does this cause other issues?
-    // Alternative solution: in message list allow combining text deltas together when the message source is "response" and the text parts are directly next to each other
-    // simple solution for now is to not flush text deltas on response-metadata
-    chunk.type !== "response-metadata" && // Don't flush on source chunks - OpenAI web search interleaves source citations
-    // with text-deltas, all sharing the same itemId. Flushing creates multiple parts
-    // with duplicate itemIds, causing "Duplicate item found" errors on the next request.
-    chunk.type !== "source" && runState.state.isStreaming) {
-      if (runState.state.textDeltas.length) {
-        const textStartPayload = chunk.payload;
-        const providerMetadata = textStartPayload.providerMetadata ?? runState.state.providerOptions;
-        const message = {
-          id: messageId,
-          role: "assistant",
-          content: {
-            format: 2,
-            parts: [
-              {
-                type: "text",
-                text: runState.state.textDeltas.join(""),
-                ...providerMetadata ? { providerMetadata } : {}
-              }
-            ],
-            ...buildResponseModelMetadata(runState, model)
-          },
-          createdAt: /* @__PURE__ */ new Date()
-        };
-        messageList.add(message, "response");
-      }
-      runState.setState({
-        isStreaming: false,
-        textDeltas: []
-      });
-    }
-    if (chunk.type !== "reasoning-start" && chunk.type !== "reasoning-delta" && chunk.type !== "reasoning-end" && chunk.type !== "redacted-reasoning" && chunk.type !== "reasoning-signature" && chunk.type !== "response-metadata" && chunk.type !== "text-start" && runState.state.isReasoning) {
-      for (const buffer of runState.state.reasoningBuffers.values()) {
-        flushReasoningBuffer({
-          buffer,
-          messageId,
-          messageList,
-          runState,
-          model
-        });
-      }
-      runState.setState({
-        isReasoning: false,
-        reasoningBuffers: /* @__PURE__ */ new Map(),
-        providerOptions: void 0
-      });
-    }
+    collectedChunks.push({ type: chunk.type, payload: chunk.payload });
     switch (chunk.type) {
       case "response-metadata":
         runState.setState({
@@ -14506,32 +14750,6 @@ async function processOutputStream({
           }
         });
         break;
-      case "text-start": {
-        if (chunk.payload.providerMetadata) {
-          runState.setState({
-            providerOptions: chunk.payload.providerMetadata
-          });
-        }
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "text-delta": {
-        const textDeltasFromState = runState.state.textDeltas;
-        textDeltasFromState.push(chunk.payload.text);
-        runState.setState({
-          textDeltas: textDeltasFromState,
-          isStreaming: true
-        });
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "text-end": {
-        runState.setState({
-          providerOptions: void 0
-        });
-        safeEnqueue(controller, chunk);
-        break;
-      }
       case "tool-call-input-streaming-start": {
         const tool2 = tools?.[chunk.payload.toolName] || Object.values(tools || {})?.find((tool3) => `id` in tool3 && tool3.id === chunk.payload.toolName);
         if (tool2 && "onInputStart" in tool2) {
@@ -14565,145 +14783,6 @@ async function processOutputStream({
         safeEnqueue(controller, chunk);
         break;
       }
-      case "tool-call-input-streaming-end": {
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "reasoning-start": {
-        const reasoningBuffers = new Map(runState.state.reasoningBuffers);
-        reasoningBuffers.set(chunk.payload.id, {
-          deltas: reasoningBuffers.get(chunk.payload.id)?.deltas ?? [],
-          providerMetadata: chunk.payload.providerMetadata ?? reasoningBuffers.get(chunk.payload.id)?.providerMetadata
-        });
-        runState.setState({
-          isReasoning: true,
-          reasoningBuffers,
-          providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
-        });
-        if (Object.values(chunk.payload.providerMetadata || {}).find((v) => v?.redactedData)) {
-          const message = {
-            id: messageId,
-            role: "assistant",
-            content: {
-              format: 2,
-              parts: [
-                {
-                  type: "reasoning",
-                  reasoning: "",
-                  details: [{ type: "redacted", data: "" }],
-                  providerMetadata: chunk.payload.providerMetadata ?? runState.state.providerOptions
-                }
-              ],
-              ...buildResponseModelMetadata(runState, model)
-            },
-            createdAt: /* @__PURE__ */ new Date()
-          };
-          messageList.add(message, "response");
-          safeEnqueue(controller, chunk);
-          break;
-        }
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "reasoning-delta": {
-        const reasoningBuffers = new Map(runState.state.reasoningBuffers);
-        const existingBuffer = reasoningBuffers.get(chunk.payload.id);
-        const buffer = {
-          deltas: [...existingBuffer?.deltas ?? [], chunk.payload.text],
-          providerMetadata: chunk.payload.providerMetadata ?? existingBuffer?.providerMetadata
-        };
-        reasoningBuffers.set(chunk.payload.id, buffer);
-        runState.setState({
-          isReasoning: true,
-          reasoningBuffers,
-          providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
-        });
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "reasoning-end": {
-        if (!runState.state.isReasoning) {
-          safeEnqueue(controller, chunk);
-          break;
-        }
-        const reasoningBuffers = new Map(runState.state.reasoningBuffers);
-        const buffer = reasoningBuffers.get(chunk.payload.id);
-        if (!buffer) {
-          safeEnqueue(controller, chunk);
-          break;
-        }
-        flushReasoningBuffer({
-          buffer: {
-            deltas: buffer.deltas,
-            providerMetadata: chunk.payload.providerMetadata ?? buffer.providerMetadata
-          },
-          messageId,
-          messageList,
-          runState,
-          model
-        });
-        reasoningBuffers.delete(chunk.payload.id);
-        const nextProviderOptions = Array.from(reasoningBuffers.values()).at(-1)?.providerMetadata;
-        runState.setState({
-          isReasoning: reasoningBuffers.size > 0,
-          reasoningBuffers,
-          providerOptions: nextProviderOptions
-        });
-        safeEnqueue(controller, chunk);
-        break;
-      }
-      case "file":
-        {
-          const message = {
-            id: messageId,
-            role: "assistant",
-            content: {
-              format: 2,
-              parts: [
-                {
-                  type: "file",
-                  // @ts-expect-error - data type mismatch, see TODO
-                  data: chunk.payload.data,
-                  // TODO: incorrect string type
-                  mimeType: chunk.payload.mimeType,
-                  ...chunk.payload.providerMetadata ? { providerMetadata: chunk.payload.providerMetadata } : {}
-                }
-              ],
-              ...buildResponseModelMetadata(runState, model)
-            },
-            createdAt: /* @__PURE__ */ new Date()
-          };
-          messageList.add(message, "response");
-          safeEnqueue(controller, chunk);
-        }
-        break;
-      case "source":
-        {
-          const message = {
-            id: messageId,
-            role: "assistant",
-            content: {
-              format: 2,
-              parts: [
-                {
-                  type: "source",
-                  source: {
-                    sourceType: "url",
-                    id: chunk.payload.id,
-                    url: chunk.payload.url || "",
-                    title: chunk.payload.title,
-                    providerMetadata: chunk.payload.providerMetadata
-                  }
-                }
-              ],
-              ...buildResponseModelMetadata(runState, model)
-            },
-            createdAt: /* @__PURE__ */ new Date()
-          };
-          messageList.add(message, "response");
-          safeEnqueue(controller, chunk);
-        }
-        break;
       case "finish":
         runState.setState({
           providerOptions: chunk.payload.metadata?.providerMetadata ?? chunk.payload.providerMetadata,
@@ -14737,8 +14816,6 @@ async function processOutputStream({
           deferredErrorChunk: chunk
         });
         break;
-      // Provider-executed tool results (e.g. web_search). Client tool results
-      // are handled by llm-mapping-step after execution.
       case "tool-result": {
         if (chunk.payload.result != null) {
           const resultToolDef = tools?.[chunk.payload.toolName] || findProviderToolByName(tools, chunk.payload.toolName);
@@ -14758,34 +14835,6 @@ async function processOutputStream({
         safeEnqueue(controller, chunk);
         break;
       }
-      case "tool-call": {
-        const toolDef = tools?.[chunk.payload.toolName] || findProviderToolByName(tools, chunk.payload.toolName);
-        const inferredProviderExecuted = inferProviderExecuted(chunk.payload.providerExecuted, toolDef);
-        const toolCallPart = {
-          type: "tool-invocation",
-          toolInvocation: {
-            state: "call",
-            toolCallId: chunk.payload.toolCallId,
-            toolName: chunk.payload.toolName,
-            args: chunk.payload.args
-          },
-          providerMetadata: chunk.payload.providerMetadata,
-          providerExecuted: inferredProviderExecuted
-        };
-        const message = {
-          id: messageId,
-          role: "assistant",
-          content: {
-            format: 2,
-            parts: [toolCallPart],
-            ...buildResponseModelMetadata(runState, model)
-          },
-          createdAt: /* @__PURE__ */ new Date()
-        };
-        messageList.add(message, "response");
-        safeEnqueue(controller, chunk);
-        break;
-      }
       default:
         safeEnqueue(controller, chunk);
     }
@@ -14808,6 +14857,7 @@ async function processOutputStream({
       break;
     }
   }
+  return collectedChunks;
 }
 function executeStreamWithFallbackModels(models, logger, startIndex = 0) {
   return async (callback) => {
@@ -15244,14 +15294,13 @@ ${bgPrompt}`;
           transportResolver = () => routerModel._getStreamTransport();
         }
         try {
-          await processOutputStream({
+          const collectedChunks = await processOutputStream({
             outputStream: outputStream2,
             includeRawChunks,
             tools: currentStep.tools,
             messageId: currentStep.messageId,
             messageList,
             runState: runState2,
-            model: currentStep.model,
             options,
             controller,
             responseFromModel: {
@@ -15263,6 +15312,26 @@ ${bgPrompt}`;
             transportRef: _internal?.transportRef,
             transportResolver
           });
+          const builtMessages = buildMessagesFromChunks({
+            chunks: collectedChunks,
+            messageId: currentStep.messageId,
+            responseModelMetadata: buildResponseModelMetadata(runState2, currentStep.model),
+            tools: currentStep.tools
+          });
+          for (const msg of builtMessages) {
+            messageList.add(msg, "response");
+          }
+          const bufferedObject = outputStream2._getImmediateObject();
+          if (bufferedObject !== void 0) {
+            const responseMessages = messageList.get.response.db();
+            const lastAssistant = [...responseMessages].reverse().find((m) => m.role === "assistant");
+            if (lastAssistant) {
+              if (!lastAssistant.content.metadata) {
+                lastAssistant.content.metadata = {};
+              }
+              lastAssistant.content.metadata.structuredOutput = bufferedObject;
+            }
+          }
         } catch (error) {
           const provider = model?.provider;
           const modelIdStr = model?.modelId;
@@ -20928,6 +20997,9 @@ function createMapResultsStep({
       if (capabilities.mastra) {
         structuredProcessor.__registerMastra(capabilities.mastra);
       }
+      if (options.structuredOutput.useAgent) {
+        structuredProcessor.setAgent(capabilities.agent);
+      }
       effectiveOutputProcessors = effectiveOutputProcessors ? [...effectiveOutputProcessors, structuredProcessor] : [structuredProcessor];
     }
     const effectiveInputProcessors = capabilities.inputProcessors ? typeof capabilities.inputProcessors === "function" ? await capabilities.inputProcessors({
@@ -25183,6 +25255,7 @@ ${effectiveInstructions}`;
       memory
     });
     const capabilities = {
+      agent: this,
       agentName: this.name,
       logger: this.logger,
       getMemory: this.getMemory.bind(this),
@@ -30656,5 +30729,5 @@ var MockMemory = class extends MastraMemory {
 };
 
 export { Agent, AgentChannels, AgentsMDInjector, BaseProcessor, BatchPartsProcessor, ChatChannelProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MastraScorer, MastraStateAdapter, MemoryProcessor, MessageContentSchema, MessageHistory, MessagePartSchema, MockMemory, ModerationProcessor, PIIDetector, PrefillErrorHandler, ProcessorInputPhaseSchema, ProcessorInputStepPhaseSchema, ProcessorMessageContentSchema, ProcessorMessageSchema, ProcessorOutputResultPhaseSchema, ProcessorOutputStepPhaseSchema, ProcessorOutputStreamPhaseSchema, ProcessorRunner, ProcessorState, ProcessorStepInputSchema, ProcessorStepOutputSchema, ProcessorStepSchema, PromptInjectionDetector, ReasoningPartSchema, Run, SYSTEM_REMINDER_END_TAG, SYSTEM_REMINDER_START_TAG, SemanticRecall, SkillSearchProcessor, SkillsProcessor, SourcePartSchema, StepStartPartSchema, StructuredOutputProcessor, SystemPromptScrubber, TextPartSchema, TokenLimiterProcessor, ToolCallFilter, ToolInvocationPartSchema, ToolSearchProcessor, TripWire, UnicodeNormalizer, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, WorkspaceInstructionsProcessor, augmentWithInit, cleanStepResult, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, filterSystemReminderMessages, formatCheckFeedback, formatCompletionFeedback, formatStreamCompletionFeedback, formatValidationFeedback, forwardAgentStreamChunk, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getThreadOMMetadata, globalEmbeddingCache, hydrateSerializedStepErrors, isObservationalMemoryEnabled, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, isSystemReminderMessage, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeSystemReminderTags, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runStreamCompletionScorers, runValidation, setThreadOMMetadata, summarizeActiveToolsForSpan, summarizeProcessorModelForSpan, summarizeProcessorResultForSpan, summarizeProcessorToolsForSpan, summarizeToolChoiceForSpan, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-72TFCXLB.js.map
-//# sourceMappingURL=chunk-72TFCXLB.js.map
+//# sourceMappingURL=chunk-DLDGEMBE.js.map
+//# sourceMappingURL=chunk-DLDGEMBE.js.map