@mastra/core 0.13.2 → 0.14.0-alpha.1

package/dist/loop/index.cjs

@@ -0,0 +1,2848 @@
+'use strict';
+
+var chunkCSTWQQ3C_cjs = require('../chunk-CSTWQQ3C.cjs');
+var chunkRJCNC57P_cjs = require('../chunk-RJCNC57P.cjs');
+var chunkKXCUCBEI_cjs = require('../chunk-KXCUCBEI.cjs');
+var chunkV5WKCX3G_cjs = require('../chunk-V5WKCX3G.cjs');
+var aiV5 = require('ai-v5');
+var web = require('stream/web');
+var providerV5 = require('@ai-sdk/provider-v5');
+var api = require('@opentelemetry/api');
+var z = require('zod');
+var providerUtilsV5 = require('@ai-sdk/provider-utils-v5');
+var providerUtils = require('@ai-sdk/provider-utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var z__default = /*#__PURE__*/_interopDefault(z);
+
+function convertFullStreamChunkToUIMessageStream({
+  part,
+  messageMetadataValue,
+  sendReasoning,
+  sendSources,
+  onError,
+  sendStart,
+  sendFinish,
+  responseMessageId
+}) {
+  const partType = part.type;
+  switch (partType) {
+    case "text-start": {
+      return {
+        type: "text-start",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "text-delta": {
+      return {
+        type: "text-delta",
+        id: part.id,
+        delta: part.text,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "text-end": {
+      return {
+        type: "text-end",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "reasoning-start": {
+      return {
+        type: "reasoning-start",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "reasoning-delta": {
+      if (sendReasoning) {
+        return {
+          type: "reasoning-delta",
+          id: part.id,
+          delta: part.text,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        };
+      }
+      return;
+    }
+    case "reasoning-end": {
+      return {
+        type: "reasoning-end",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "file": {
+      return {
+        type: "file",
+        mediaType: part.file.mediaType,
+        url: `data:${part.file.mediaType};base64,${part.file.base64}`
+      };
+    }
+    case "source": {
+      if (sendSources && part.sourceType === "url") {
+        return {
+          type: "source-url",
+          sourceId: part.id,
+          url: part.url,
+          title: part.title,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        };
+      }
+      if (sendSources && part.sourceType === "document") {
+        return {
+          type: "source-document",
+          sourceId: part.id,
+          mediaType: part.mediaType,
+          title: part.title,
+          filename: part.filename,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        };
+      }
+      return;
+    }
+    case "tool-input-start": {
+      return {
+        type: "tool-input-start",
+        toolCallId: part.id,
+        toolName: part.toolName,
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+        ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+      };
+    }
+    case "tool-input-delta": {
+      return {
+        type: "tool-input-delta",
+        toolCallId: part.id,
+        inputTextDelta: part.delta
+      };
+    }
+    case "tool-call": {
+      return {
+        type: "tool-input-available",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input,
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+        ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+      };
+    }
+    case "tool-result": {
+      return {
+        type: "tool-output-available",
+        toolCallId: part.toolCallId,
+        output: part.output,
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+        ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+      };
+    }
+    case "tool-error": {
+      return {
+        type: "tool-output-error",
+        toolCallId: part.toolCallId,
+        errorText: onError(part.error),
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+        ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+      };
+    }
+    case "error": {
+      return {
+        type: "error",
+        errorText: onError(part.error)
+      };
+    }
+    case "start-step": {
+      return { type: "start-step" };
+    }
+    case "finish-step": {
+      return { type: "finish-step" };
+    }
+    case "start": {
+      if (sendStart) {
+        return {
+          type: "start",
+          ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {},
+          ...responseMessageId != null ? { messageId: responseMessageId } : {}
+        };
+      }
+      return;
+    }
+    case "finish": {
+      if (sendFinish) {
+        return {
+          type: "finish",
+          ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {}
+        };
+      }
+      return;
+    }
+    case "abort": {
+      return part;
+    }
+    case "tool-input-end": {
+      return;
+    }
+    case "raw": {
+      return;
+    }
+    default: {
+      const exhaustiveCheck = partType;
+      throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
+    }
+  }
+}
+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 prepareToolsAndToolChoice({
+  tools,
+  toolChoice,
+  activeTools
+}) {
+  if (Object.keys(tools || {}).length === 0) {
+    return {
+      tools: void 0,
+      toolChoice: void 0
+    };
+  }
+  const filteredTools = activeTools != null ? Object.entries(tools || {}).filter(([name]) => activeTools.includes(name)) : Object.entries(tools || {});
+  return {
+    tools: filteredTools.map(([name, tool]) => {
+      try {
+        let inputSchema;
+        if ("inputSchema" in tool) {
+          inputSchema = tool.inputSchema;
+        } else if ("parameters" in tool) {
+          inputSchema = tool.parameters;
+        }
+        const sdkTool = aiV5.tool({
+          type: "function",
+          ...tool,
+          inputSchema
+        });
+        const toolType = sdkTool?.type ?? "function";
+        switch (toolType) {
+          case void 0:
+          case "dynamic":
+          case "function":
+            return {
+              type: "function",
+              name,
+              description: sdkTool.description,
+              inputSchema: aiV5.asSchema(sdkTool.inputSchema).jsonSchema,
+              providerOptions: sdkTool.providerOptions
+            };
+          case "provider-defined":
+            return {
+              type: "provider-defined",
+              name,
+              // TODO: as any seems wrong here. are there cases where we don't have an id?
+              id: sdkTool.id,
+              args: sdkTool.args
+            };
+          default: {
+            const exhaustiveCheck = toolType;
+            throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+          }
+        }
+      } catch (e) {
+        console.error("Error preparing tool", e);
+        return null;
+      }
+    }).filter((tool) => tool !== null),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
+}
+var DelayedPromise = class {
+  status = {
+    type: "pending"
+  };
+  _promise;
+  _resolve = void 0;
+  _reject = void 0;
+  get promise() {
+    if (this._promise) {
+      return this._promise;
+    }
+    this._promise = new Promise((resolve, reject) => {
+      if (this.status.type === "resolved") {
+        resolve(this.status.value);
+      } else if (this.status.type === "rejected") {
+        reject(this.status.error);
+      }
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+    return this._promise;
+  }
+  resolve(value) {
+    this.status = { type: "resolved", value };
+    if (this._promise) {
+      this._resolve?.(value);
+    }
+  }
+  reject(error) {
+    this.status = { type: "rejected", error };
+    if (this._promise) {
+      this._reject?.(error);
+    }
+  }
+};
+function getOutputSchema({ schema, output }) {
+  if (output === "no-schema") {
+    return void 0;
+  }
+  const jsonSchema = schema ? aiV5.asSchema(schema).jsonSchema : void 0;
+  if (!jsonSchema) {
+    return void 0;
+  }
+  if (output === "array") {
+    const { $schema, ...itemSchema } = jsonSchema;
+    const arrayOutputSchema = {
+      $schema,
+      type: "object",
+      properties: {
+        elements: { type: "array", items: itemSchema }
+      },
+      required: ["elements"],
+      additionalProperties: false
+    };
+    return arrayOutputSchema;
+  }
+  return jsonSchema;
+}
+function getResponseFormat(options) {
+  if (!options?.output && options?.schema || options?.output === "object" || options?.output === "array" || options?.output === "no-schema") {
+    return {
+      type: "json",
+      schema: getOutputSchema({ schema: options?.schema, output: options?.output }),
+      name: options?.schemaName,
+      description: options?.schemaDescription
+    };
+  }
+  return {
+    type: "text"
+  };
+}
+function createObjectStreamTransformer({
+  objectOptions,
+  onFinish,
+  onError
+}) {
+  let textAccumulatedText = "";
+  let textPreviousObject = void 0;
+  let textPreviousFilteredArray;
+  const responseFormat = getResponseFormat(objectOptions);
+  return new web.TransformStream({
+    async transform(chunk, controller) {
+      if (!objectOptions) {
+        controller.enqueue(chunk);
+        return;
+      }
+      if (responseFormat.type === "json" && chunk.type === "text-delta" && typeof chunk.payload.text === "string") {
+        if (objectOptions?.output === "array") {
+          textAccumulatedText += chunk.payload.text;
+          const { value: currentObjectJson, state: parseState } = await aiV5.parsePartialJson(textAccumulatedText);
+          if (currentObjectJson !== void 0 && !aiV5.isDeepEqualData(textPreviousObject, currentObjectJson)) {
+            const rawElements = currentObjectJson?.elements || [];
+            const filteredElements = [];
+            for (let i = 0; i < rawElements.length; i++) {
+              const element = rawElements[i];
+              if (i === rawElements.length - 1 && parseState !== "successful-parse") {
+                if (element && typeof element === "object" && Object.keys(element).length > 0) {
+                  filteredElements.push(element);
+                }
+              } else {
+                if (element && typeof element === "object" && Object.keys(element).length > 0) {
+                  filteredElements.push(element);
+                }
+              }
+            }
+            if (!aiV5.isDeepEqualData(textPreviousFilteredArray, filteredElements)) {
+              textPreviousFilteredArray = [...filteredElements];
+              controller.enqueue({
+                type: "object",
+                object: filteredElements
+              });
+            }
+            textPreviousObject = currentObjectJson;
+          }
+        } else if (objectOptions?.output === "no-schema" || !objectOptions?.output) {
+          textAccumulatedText += chunk.payload.text;
+          const { value: currentObjectJson } = await aiV5.parsePartialJson(textAccumulatedText);
+          if (currentObjectJson !== void 0 && typeof currentObjectJson === "object" && !aiV5.isDeepEqualData(textPreviousObject, currentObjectJson)) {
+            textPreviousObject = currentObjectJson;
+            controller.enqueue({
+              type: "object",
+              object: currentObjectJson
+            });
+          }
+        }
+      }
+      controller.enqueue(chunk);
+    },
+    // TODO: validate against the provided schema,
+    // TODO: then call onFinish(data) if valid or call onError(err) if invalid
+    // TODO: so that the object promise can be resolved/rejected
+    flush() {
+      if (responseFormat.type === "json") {
+        if (objectOptions?.output === "array") {
+          onFinish(textPreviousFilteredArray);
+        } else {
+          onFinish(textPreviousObject);
+        }
+        if (!textPreviousObject && !textPreviousFilteredArray) {
+          onError("No object generated: could not parse the response.");
+        }
+      }
+    }
+  });
+}
+function createJsonTextStreamTransformer(objectOptions) {
+  let previousArrayLength = 0;
+  let hasStartedArray = false;
+  return new web.TransformStream({
+    transform(chunk, controller) {
+      if (chunk.type !== "object") {
+        return;
+      }
+      if (objectOptions?.output === "array") {
+        if (!hasStartedArray) {
+          controller.enqueue("[");
+          hasStartedArray = true;
+        }
+        for (let i = previousArrayLength; i < chunk.object.length; i++) {
+          const elementJson = JSON.stringify(chunk.object[i]);
+          if (i > 0) {
+            controller.enqueue("," + elementJson);
+          } else {
+            controller.enqueue(elementJson);
+          }
+        }
+        previousArrayLength = chunk.object.length;
+      } else {
+        controller.enqueue(JSON.stringify(chunk.object));
+      }
+    },
+    flush(controller) {
+      if (hasStartedArray && objectOptions?.output === "array") {
+        controller.enqueue("]");
+      }
+    }
+  });
+}
+
+// src/stream/aisdk/v5/output-helpers.ts
+var DefaultStepResult = class {
+  content;
+  finishReason;
+  usage;
+  warnings;
+  request;
+  response;
+  providerMetadata;
+  constructor({
+    content,
+    finishReason,
+    usage,
+    warnings,
+    request,
+    response,
+    providerMetadata
+  }) {
+    this.content = content;
+    this.finishReason = finishReason;
+    this.usage = usage;
+    this.warnings = warnings;
+    this.request = request;
+    this.response = response;
+    this.providerMetadata = providerMetadata;
+  }
+  get text() {
+    return this.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+  }
+  get reasoning() {
+    return this.content.filter((part) => part.type === "reasoning");
+  }
+  get reasoningText() {
+    return this.reasoning.length === 0 ? void 0 : this.reasoning.map((part) => part.text).join("");
+  }
+  get files() {
+    return this.content.filter((part) => part.type === "file").map((part) => part.file);
+  }
+  get sources() {
+    return this.content.filter((part) => part.type === "source");
+  }
+  get toolCalls() {
+    return this.content.filter((part) => part.type === "tool-call");
+  }
+  get staticToolCalls() {
+    return this.toolCalls.filter((toolCall) => toolCall.dynamic === false);
+  }
+  get dynamicToolCalls() {
+    return this.toolCalls.filter((toolCall) => toolCall.dynamic === true);
+  }
+  get toolResults() {
+    return this.content.filter((part) => part.type === "tool-result");
+  }
+  get staticToolResults() {
+    return this.toolResults.filter((toolResult) => toolResult.dynamic === false);
+  }
+  get dynamicToolResults() {
+    return this.toolResults.filter((toolResult) => toolResult.dynamic === true);
+  }
+};
+function reasoningDetailsFromMessages(messages) {
+  return messages.flatMap((msg) => {
+    if (msg.content?.parts && Array.isArray(msg.content.parts)) {
+      return msg.content.parts;
+    }
+    return [];
+  }).filter((part) => part.type === `reasoning`).flatMap((part) => {
+    return {
+      type: "reasoning",
+      text: part.reasoning,
+      details: part.details
+    };
+  });
+}
+function transformSteps({ steps }) {
+  return steps.map((step) => {
+    return new DefaultStepResult({
+      content: step.content,
+      warnings: step.warnings ?? [],
+      providerMetadata: step.providerMetadata,
+      finishReason: step.finishReason,
+      response: {
+        ...step.response
+      },
+      request: step.request,
+      usage: step.usage
+    });
+  });
+}
+
+// src/stream/aisdk/v5/transform.ts
+function convertFullStreamChunkToMastra(value, ctx) {
+  switch (value.type) {
+    case "response-metadata":
+      return {
+        type: "response-metadata",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: value
+      };
+    case "text-start":
+      return {
+        type: "text-start",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          id: value.id,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "text-delta":
+      if (value.delta) {
+        return {
+          type: "text-delta",
+          runId: ctx.runId,
+          from: "AGENT",
+          payload: {
+            id: value.id,
+            providerMetadata: value.providerMetadata,
+            text: value.delta
+          }
+        };
+      }
+      return;
+    case "text-end":
+      return {
+        type: "text-end",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: value
+      };
+    case "reasoning-start":
+      return {
+        type: "reasoning-start",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          id: value.id,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "reasoning-delta":
+      return {
+        type: "reasoning-delta",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          id: value.id,
+          providerMetadata: value.providerMetadata,
+          text: value.delta
+        }
+      };
+    case "reasoning-end":
+      return {
+        type: "reasoning-end",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          id: value.id,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "source":
+      return {
+        type: "source",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          id: value.id,
+          sourceType: value.sourceType,
+          title: value.title,
+          mimeType: value.sourceType === "document" ? value.mediaType : void 0,
+          filename: value.sourceType === "document" ? value.filename : void 0,
+          url: value.sourceType === "url" ? value.url : void 0,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "file":
+      return {
+        type: "file",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          data: value.data,
+          base64: typeof value.data === "string" ? value.data : void 0,
+          mimeType: value.mediaType
+        }
+      };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          toolCallId: value.toolCallId,
+          toolName: value.toolName,
+          args: value.input ? JSON.parse(value.input) : void 0,
+          providerExecuted: value.providerExecuted,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "tool-result":
+      return {
+        type: "tool-result",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          toolCallId: value.toolCallId,
+          toolName: value.toolName,
+          result: value.result,
+          isError: value.isError,
+          providerExecuted: value.providerExecuted,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "tool-input-start":
+      return {
+        type: "tool-call-input-streaming-start",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          toolCallId: value.id,
+          toolName: value.toolName,
+          providerExecuted: value.providerExecuted,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "tool-input-delta":
+      if (value.delta) {
+        return {
+          type: "tool-call-delta",
+          runId: ctx.runId,
+          from: "AGENT",
+          payload: {
+            argsTextDelta: value.delta,
+            toolCallId: value.id,
+            providerMetadata: value.providerMetadata
+          }
+        };
+      }
+      return;
+    case "tool-input-end":
+      return {
+        type: "tool-call-input-streaming-end",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          toolCallId: value.id,
+          providerMetadata: value.providerMetadata
+        }
+      };
+    case "finish":
+      const { finishReason, usage, providerMetadata, messages, ...rest } = value;
+      return {
+        type: "finish",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: {
+          stepResult: {
+            reason: value.finishReason
+          },
+          output: {
+            usage: {
+              ...value.usage ?? {},
+              totalTokens: value?.usage?.totalTokens ?? (value.usage?.inputTokens ?? 0) + (value.usage?.outputTokens ?? 0)
+            }
+          },
+          metadata: {
+            providerMetadata: value.providerMetadata
+          },
+          messages,
+          ...rest
+        }
+      };
+    case "error":
+      return {
+        type: "error",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: value
+      };
+    case "raw":
+      return {
+        type: "raw",
+        runId: ctx.runId,
+        from: "AGENT",
+        payload: value.rawValue
+      };
+  }
+  return;
+}
+function convertMastraChunkToAISDKv5({
+  chunk,
+  mode = "stream"
+}) {
+  switch (chunk.type) {
+    case "start":
+      return {
+        type: "start"
+      };
+    case "step-start":
+      const { messageId: _messageId, ...rest } = chunk.payload;
+      return {
+        type: "start-step",
+        request: rest.request,
+        warnings: rest.warnings
+      };
+    case "raw":
+      return {
+        type: "raw",
+        rawValue: chunk.payload
+      };
+    case "finish": {
+      return {
+        type: "finish",
+        finishReason: chunk.payload.stepResult.reason,
+        totalUsage: chunk.payload.output.usage
+      };
+    }
+    case "reasoning-start":
+      return {
+        type: "reasoning-start",
+        id: chunk.payload.id,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "reasoning-delta":
+      return {
+        type: "reasoning-delta",
+        id: chunk.payload.id,
+        text: chunk.payload.text,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "reasoning-signature":
+      throw new Error('AISDKv5 chunk type "reasoning-signature" not supported');
+    // return {
+    //   type: 'reasoning-signature' as const,
+    //   id: chunk.payload.id,
+    //   signature: chunk.payload.signature,
+    // };
+    case "redacted-reasoning":
+      throw new Error('AISDKv5 chunk type "redacted-reasoning" not supported');
+    // return {
+    //   type: 'redacted-reasoning',
+    //   id: chunk.payload.id,
+    //   data: chunk.payload.data,
+    // };
+    case "reasoning-end":
+      return {
+        type: "reasoning-end",
+        id: chunk.payload.id,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "source":
+      return {
+        type: "source",
+        id: chunk.payload.id,
+        sourceType: chunk.payload.sourceType,
+        filename: chunk.payload.filename,
+        mediaType: chunk.payload.mimeType,
+        title: chunk.payload.title,
+        url: chunk.payload.url,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "file":
+      if (mode === "generate") {
+        return {
+          type: "file",
+          file: new chunkRJCNC57P_cjs.DefaultGeneratedFile({
+            data: chunk.payload.data,
+            mediaType: chunk.payload.mimeType
+          })
+        };
+      }
+      return {
+        type: "file",
+        file: new chunkRJCNC57P_cjs.DefaultGeneratedFileWithType({
+          data: chunk.payload.data,
+          mediaType: chunk.payload.mimeType
+        })
+      };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: chunk.payload.toolCallId,
+        providerMetadata: chunk.payload.providerMetadata,
+        providerExecuted: chunk.payload.providerExecuted,
+        toolName: chunk.payload.toolName,
+        input: chunk.payload.args
+      };
+    case "tool-call-input-streaming-start":
+      return {
+        type: "tool-input-start",
+        id: chunk.payload.toolCallId,
+        toolName: chunk.payload.toolName,
+        dynamic: !!chunk.payload.dynamic,
+        providerMetadata: chunk.payload.providerMetadata,
+        providerExecuted: chunk.payload.providerExecuted
+      };
+    case "tool-call-input-streaming-end":
+      return {
+        type: "tool-input-end",
+        id: chunk.payload.toolCallId,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "tool-call-delta":
+      return {
+        type: "tool-input-delta",
+        id: chunk.payload.toolCallId,
+        delta: chunk.payload.argsTextDelta,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "step-finish": {
+      const { request: _request, providerMetadata, ...rest2 } = chunk.payload.metadata;
+      return {
+        type: "finish-step",
+        response: rest2,
+        usage: chunk.payload.output.usage,
+        // ?
+        finishReason: chunk.payload.stepResult.reason,
+        providerMetadata
+      };
+    }
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: chunk.payload.id,
+        text: chunk.payload.text,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "text-end":
+      return {
+        type: "text-end",
+        id: chunk.payload.id,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "text-start":
+      return {
+        type: "text-start",
+        id: chunk.payload.id,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+    case "tool-result":
+      return {
+        type: "tool-result",
+        input: chunk.payload.args,
+        toolCallId: chunk.payload.toolCallId,
+        providerExecuted: chunk.payload.providerExecuted,
+        toolName: chunk.payload.toolName,
+        output: chunk.payload.result
+        // providerMetadata: chunk.payload.providerMetadata, // AI v5 types don't show this?
+      };
+    case "tool-error":
+      return {
+        type: "tool-error",
+        error: chunk.payload.error,
+        input: chunk.payload.args,
+        toolCallId: chunk.payload.toolCallId,
+        providerExecuted: chunk.payload.providerExecuted,
+        toolName: chunk.payload.toolName
+        // providerMetadata: chunk.payload.providerMetadata, // AI v5 types don't show this?
+      };
+    case "abort":
+      return {
+        type: "abort"
+      };
+    case "error":
+      return {
+        type: "error",
+        error: chunk.payload.error
+      };
+  }
+}
+
+// src/stream/aisdk/v5/output.ts
+var AISDKV5OutputStream = class {
+  #modelOutput;
+  #options;
+  #messageList;
+  constructor({
+    modelOutput,
+    options,
+    messageList
+  }) {
+    this.#modelOutput = modelOutput;
+    this.#options = options;
+    this.#messageList = messageList;
+  }
+  toTextStreamResponse(init) {
+    return aiV5.createTextStreamResponse({
+      textStream: this.#modelOutput.textStream,
+      ...init
+    });
+  }
+  toUIMessageStreamResponse({
+    // @ts-ignore
+    generateMessageId,
+    originalMessages,
+    sendFinish,
+    sendReasoning,
+    sendSources,
+    onError,
+    sendStart,
+    messageMetadata,
+    onFinish,
+    ...init
+  } = {}) {
+    return aiV5.createUIMessageStreamResponse({
+      stream: this.toUIMessageStream({
+        // @ts-ignore
+        generateMessageId,
+        originalMessages,
+        sendFinish,
+        sendReasoning,
+        sendSources,
+        onError,
+        sendStart,
+        messageMetadata,
+        onFinish
+      }),
+      ...init
+    });
+  }
+  toUIMessageStream({
+    // @ts-ignore
+    generateMessageId,
+    originalMessages,
+    sendFinish = true,
+    sendReasoning = true,
+    sendSources = false,
+    onError = providerV5.getErrorMessage,
+    sendStart = true,
+    messageMetadata,
+    onFinish
+  } = {}) {
+    const responseMessageId = generateMessageId != null ? getResponseUIMessageId({
+      originalMessages,
+      responseMessageId: generateMessageId
+    }) : void 0;
+    return aiV5.createUIMessageStream({
+      onError,
+      onFinish,
+      generateId: () => responseMessageId ?? generateMessageId?.(),
+      execute: async ({ writer }) => {
+        for await (const part of this.fullStream) {
+          const messageMetadataValue = messageMetadata?.({ part });
+          const partType = part.type;
+          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) {
+    try {
+      await aiV5.consumeStream({
+        stream: this.fullStream.pipeThrough(
+          new web.TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+            }
+          })
+        ),
+        onError: options?.onError
+      });
+    } catch (error) {
+      console.log("consumeStream error", error);
+      options?.onError?.(error);
+    }
+  }
+  get sources() {
+    return this.#modelOutput.sources.map((source) => {
+      return convertMastraChunkToAISDKv5({
+        chunk: source
+      });
+    });
+  }
+  get files() {
+    return this.#modelOutput.files.map((file) => {
+      if (file.type === "file") {
+        return convertMastraChunkToAISDKv5({
+          chunk: file
+        })?.file;
+      }
+      return;
+    }).filter(Boolean);
+  }
+  get generateTextFiles() {
+    return this.#modelOutput.files.map((file) => {
+      if (file.type === "file") {
+        return convertMastraChunkToAISDKv5({
+          chunk: file,
+          mode: "generate"
+        })?.file;
+      }
+      return;
+    }).filter(Boolean);
+  }
+  get toolCalls() {
+    return this.#modelOutput.toolCalls.map((toolCall) => {
+      return convertMastraChunkToAISDKv5({
+        chunk: toolCall
+      });
+    });
+  }
+  get toolResults() {
+    return this.#modelOutput.toolResults.map((toolResult) => {
+      return convertMastraChunkToAISDKv5({
+        chunk: toolResult
+      });
+    });
+  }
+  get reasoningText() {
+    return this.#modelOutput.reasoningText;
+  }
+  get reasoning() {
+    return this.#modelOutput.reasoningDetails;
+  }
+  get response() {
+    return {
+      ...this.#modelOutput.response
+    };
+  }
+  get steps() {
+    return transformSteps({ steps: this.#modelOutput.steps });
+  }
+  get generateTextSteps() {
+    return transformSteps({ steps: this.#modelOutput.steps });
+  }
+  get content() {
+    return this.#messageList.get.response.aiV5.modelContent();
+  }
+  get fullStream() {
+    let startEvent;
+    let hasStarted = false;
+    const fullStream = this.#modelOutput.fullStream;
+    return fullStream.pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          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;
+          }
+          const transformedChunk = convertMastraChunkToAISDKv5({
+            chunk
+          });
+          if (transformedChunk) {
+            controller.enqueue(transformedChunk);
+          }
+        }
+      })
+    );
+  }
+  async getFullOutput() {
+    await this.consumeStream();
+    let object;
+    if (this.#options.objectOptions) {
+      object = await this.object;
+    }
+    return {
+      text: this.#modelOutput.text,
+      usage: this.#modelOutput.usage,
+      steps: this.generateTextSteps,
+      finishReason: this.#modelOutput.finishReason,
+      warnings: this.#modelOutput.warnings,
+      providerMetadata: this.#modelOutput.providerMetadata,
+      request: this.#modelOutput.request,
+      reasoning: this.reasoning,
+      reasoningText: this.reasoningText,
+      toolCalls: this.toolCalls,
+      toolResults: this.toolResults,
+      sources: this.sources,
+      files: this.generateTextFiles,
+      response: this.response,
+      content: this.content,
+      totalUsage: this.#modelOutput.totalUsage,
+      ...object ? { object } : {}
+      // experimental_output: // TODO
+    };
+  }
+  get object() {
+    return this.#modelOutput.object;
+  }
+};
+
+// src/stream/base/output.ts
+var MastraModelOutput = class extends chunkKXCUCBEI_cjs.MastraBase {
+  #aisdkv5;
+  #baseStream;
+  #bufferedSteps = [];
+  #bufferedReasoningDetails = {};
+  #bufferedByStep = {
+    text: "",
+    reasoning: "",
+    sources: [],
+    files: [],
+    toolCalls: [],
+    toolResults: [],
+    msgCount: 0
+  };
+  #bufferedText = [];
+  #bufferedTextChunks = {};
+  #bufferedSources = [];
+  #bufferedReasoning = [];
+  #bufferedFiles = [];
+  #toolCallArgsDeltas = {};
+  #toolCallDeltaIdNameMap = {};
+  #toolCalls = [];
+  #toolResults = [];
+  #warnings = [];
+  #finishReason;
+  #providerMetadata;
+  #response;
+  #request;
+  #usageCount = {};
+  #objectPromise = new DelayedPromise();
+  runId;
+  #options;
+  constructor({
+    stream,
+    options,
+    model,
+    messageList
+  }) {
+    super({ component: "LLM", name: "MastraModelOutput" });
+    this.#options = options;
+    this.runId = options.runId;
+    const self = this;
+    this.#baseStream = stream.pipeThrough(
+      new web.TransformStream({
+        transform: async (chunk, controller) => {
+          switch (chunk.type) {
+            case "source":
+              self.#bufferedSources.push(chunk);
+              self.#bufferedByStep.sources.push(chunk);
+              break;
+            case "text-delta":
+              self.#bufferedText.push(chunk.payload.text);
+              self.#bufferedByStep.text += chunk.payload.text;
+              if (chunk.payload.id) {
+                const ary = self.#bufferedTextChunks[chunk.payload.id] ?? [];
+                ary.push(chunk.payload.text);
+                self.#bufferedTextChunks[chunk.payload.id] = ary;
+              }
+              break;
+            case "tool-call-input-streaming-start":
+              self.#toolCallDeltaIdNameMap[chunk.payload.toolCallId] = chunk.payload.toolName;
+              break;
+            case "tool-call-delta":
+              if (!self.#toolCallArgsDeltas[chunk.payload.toolCallId]) {
+                self.#toolCallArgsDeltas[chunk.payload.toolCallId] = [];
+              }
+              self.#toolCallArgsDeltas?.[chunk.payload.toolCallId]?.push(chunk.payload.argsTextDelta);
+              chunk.payload.toolName ||= self.#toolCallDeltaIdNameMap[chunk.payload.toolCallId];
+              break;
+            case "file":
+              self.#bufferedFiles.push(chunk);
+              self.#bufferedByStep.files.push(chunk);
+              break;
+            case "reasoning-start":
+              self.#bufferedReasoningDetails[chunk.payload.id] = {
+                type: "reasoning",
+                text: "",
+                providerMetadata: chunk.payload.providerMetadata
+              };
+              break;
+            case "reasoning-delta": {
+              self.#bufferedReasoning.push(chunk.payload.text);
+              self.#bufferedByStep.reasoning += chunk.payload.text;
+              const bufferedReasoning = self.#bufferedReasoningDetails[chunk.payload.id];
+              if (bufferedReasoning) {
+                bufferedReasoning.text += chunk.payload.text;
+                if (chunk.payload.providerMetadata) {
+                  bufferedReasoning.providerMetadata = chunk.payload.providerMetadata;
+                }
+              }
+              break;
+            }
+            case "reasoning-end": {
+              const bufferedReasoning = self.#bufferedReasoningDetails[chunk.payload.id];
+              if (chunk.payload.providerMetadata && bufferedReasoning) {
+                bufferedReasoning.providerMetadata = chunk.payload.providerMetadata;
+              }
+              break;
+            }
+            case "tool-call":
+              self.#toolCalls.push(chunk);
+              self.#bufferedByStep.toolCalls.push(chunk);
+              if (chunk.payload?.output?.from === "AGENT" && chunk.payload?.output?.type === "finish") {
+                const finishPayload = chunk.payload?.output.payload;
+                self.updateUsageCount(finishPayload.usage);
+              }
+              break;
+            case "tool-result":
+              self.#toolResults.push(chunk);
+              self.#bufferedByStep.toolResults.push(chunk);
+              break;
+            case "step-finish": {
+              self.updateUsageCount(chunk.payload.output.usage);
+              self.#warnings = chunk.payload.stepResult.warnings;
+              if (chunk.payload.metadata.request) {
+                self.#request = chunk.payload.metadata.request;
+              }
+              const reasoningDetails = reasoningDetailsFromMessages(
+                chunk.payload.messages.all.slice(self.#bufferedByStep.msgCount)
+              );
+              const { providerMetadata, request, ...otherMetadata } = chunk.payload.metadata;
+              const stepResult = {
+                stepType: self.#bufferedSteps.length === 0 ? "initial" : "tool-result",
+                text: self.#bufferedByStep.text,
+                reasoning: self.#bufferedByStep.reasoning || void 0,
+                sources: self.#bufferedByStep.sources,
+                files: self.#bufferedByStep.files,
+                toolCalls: self.#bufferedByStep.toolCalls,
+                toolResults: self.#bufferedByStep.toolResults,
+                warnings: self.warnings,
+                reasoningDetails,
+                providerMetadata,
+                experimental_providerMetadata: providerMetadata,
+                isContinued: chunk.payload.stepResult.isContinued,
+                logprobs: chunk.payload.stepResult.logprobs,
+                finishReason: chunk.payload.stepResult.reason,
+                response: { ...otherMetadata, messages: chunk.payload.messages.nonUser },
+                request,
+                usage: chunk.payload.output.usage,
+                // TODO: need to be able to pass a step id into this fn to get the content for a specific step id
+                content: messageList.get.response.aiV5.stepContent()
+              };
+              await options?.onStepFinish?.(stepResult);
+              self.#bufferedSteps.push(stepResult);
+              self.#bufferedByStep = {
+                text: "",
+                reasoning: "",
+                sources: [],
+                files: [],
+                toolCalls: [],
+                toolResults: [],
+                msgCount: chunk.payload.messages.all.length
+              };
+              break;
+            }
+            case "finish":
+              if (chunk.payload.stepResult.reason) {
+                self.#finishReason = chunk.payload.stepResult.reason;
+              }
+              if (chunk.payload.metadata) {
+                const { providerMetadata, request, ...otherMetadata } = chunk.payload.metadata;
+                self.#providerMetadata = chunk.payload.metadata.providerMetadata;
+                self.#response = {
+                  ...otherMetadata,
+                  messages: chunk.payload.messages?.all ?? []
+                };
+              }
+              this.populateUsageCount(chunk.payload.output.usage);
+              chunk.payload.output.usage = self.totalUsage;
+              const baseFinishStep = self.#bufferedSteps[self.#bufferedSteps.length - 1];
+              if (baseFinishStep) {
+                let onFinishPayload = {};
+                messageList.add(chunk.payload.messages.all, "response");
+                if (model.version === "v2") {
+                  onFinishPayload = {
+                    text: baseFinishStep.text,
+                    warnings: baseFinishStep.warnings ?? [],
+                    finishReason: chunk.payload.stepResult.reason,
+                    // TODO: we should add handling for step IDs in message list so you can retrieve step content by step id. And on finish should the content here be from all steps?
+                    content: messageList.get.response.aiV5.stepContent(),
+                    request: this.request,
+                    reasoning: this.aisdk.v5.reasoning,
+                    reasoningText: !this.aisdk.v5.reasoningText ? void 0 : this.aisdk.v5.reasoningText,
+                    sources: this.aisdk.v5.sources,
+                    files: this.aisdk.v5.files,
+                    steps: transformSteps({ steps: this.#bufferedSteps }),
+                    response: { ...this.response, messages: messageList.get.response.aiV5.model() },
+                    usage: chunk.payload.output.usage,
+                    totalUsage: self.totalUsage,
+                    toolCalls: this.aisdk.v5.toolCalls,
+                    toolResults: this.aisdk.v5.toolResults,
+                    staticToolCalls: this.aisdk.v5.toolCalls.filter((toolCall) => toolCall.dynamic === false),
+                    staticToolResults: this.aisdk.v5.toolResults.filter(
+                      (toolResult) => toolResult.dynamic === false
+                    ),
+                    dynamicToolCalls: this.aisdk.v5.toolCalls.filter((toolCall) => toolCall.dynamic === true),
+                    dynamicToolResults: this.aisdk.v5.toolResults.filter(
+                      (toolResult) => toolResult.dynamic === true
+                    )
+                  };
+                }
+                await options?.onFinish?.(onFinishPayload);
+              }
+              if (options?.rootSpan) {
+                options.rootSpan.setAttributes({
+                  ...baseFinishStep?.usage.reasoningTokens ? {
+                    "stream.usage.reasoningTokens": baseFinishStep.usage.reasoningTokens
+                  } : {},
+                  ...baseFinishStep?.usage.totalTokens ? {
+                    "stream.usage.totalTokens": baseFinishStep.usage.totalTokens
+                  } : {},
+                  ...baseFinishStep?.usage.inputTokens ? {
+                    "stream.usage.inputTokens": baseFinishStep.usage.inputTokens
+                  } : {},
+                  ...baseFinishStep?.usage.outputTokens ? {
+                    "stream.usage.outputTokens": baseFinishStep.usage.outputTokens
+                  } : {},
+                  ...baseFinishStep?.usage.cachedInputTokens ? {
+                    "stream.usage.cachedInputTokens": baseFinishStep.usage.cachedInputTokens
+                  } : {},
+                  ...baseFinishStep?.providerMetadata ? { "stream.response.providerMetadata": JSON.stringify(baseFinishStep?.providerMetadata) } : {},
+                  ...baseFinishStep?.finishReason ? { "stream.response.finishReason": baseFinishStep?.finishReason } : {},
+                  ...options?.telemetry_settings?.recordOutputs !== false ? { "stream.response.text": baseFinishStep?.text } : {},
+                  ...baseFinishStep?.toolCalls && options?.telemetry_settings?.recordOutputs !== false ? {
+                    "stream.response.toolCalls": JSON.stringify(
+                      baseFinishStep?.toolCalls?.map((chunk2) => {
+                        return {
+                          type: "tool-call",
+                          toolCallId: chunk2.payload.toolCallId,
+                          args: chunk2.payload.args,
+                          toolName: chunk2.payload.toolName
+                        };
+                      })
+                    )
+                  } : {}
+                });
+                options.rootSpan.end();
+              }
+              break;
+          }
+          controller.enqueue(chunk);
+        }
+      })
+    );
+    this.#aisdkv5 = new AISDKV5OutputStream({
+      modelOutput: this,
+      messageList,
+      options: {
+        toolCallStreaming: options?.toolCallStreaming,
+        objectOptions: options?.objectOptions
+      }
+    });
+  }
+  get text() {
+    return this.#bufferedText.join("");
+  }
+  get reasoning() {
+    return this.#bufferedReasoning.join("");
+  }
+  get reasoningText() {
+    return this.reasoning;
+  }
+  get reasoningDetails() {
+    return Object.values(this.#bufferedReasoningDetails || {});
+  }
+  get sources() {
+    return this.#bufferedSources;
+  }
+  get files() {
+    return this.#bufferedFiles;
+  }
+  get steps() {
+    return this.#bufferedSteps;
+  }
+  teeStream() {
+    const [stream1, stream2] = this.#baseStream.tee();
+    this.#baseStream = stream2;
+    return stream1;
+  }
+  get fullStream() {
+    const self = this;
+    let fullStream = this.teeStream();
+    return fullStream.pipeThrough(
+      createObjectStreamTransformer({
+        objectOptions: self.#options.objectOptions,
+        onFinish: (data) => self.#objectPromise.resolve(data),
+        onError: (error) => self.#objectPromise.reject(error)
+      })
+    ).pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === "raw" && !self.#options.includeRawChunks) {
+            return;
+          }
+          controller.enqueue(chunk);
+        }
+      })
+    );
+  }
+  get finishReason() {
+    return this.#finishReason;
+  }
+  get toolCalls() {
+    return this.#toolCalls;
+  }
+  get toolResults() {
+    return this.#toolResults;
+  }
+  get usage() {
+    return this.#usageCount;
+  }
+  get warnings() {
+    return this.#warnings;
+  }
+  get providerMetadata() {
+    return this.#providerMetadata;
+  }
+  get response() {
+    return this.#response;
+  }
+  get request() {
+    return this.#request;
+  }
+  updateUsageCount(usage) {
+    if (!usage) {
+      return;
+    }
+    for (const [key, value] of Object.entries(usage)) {
+      this.#usageCount[key] = (this.#usageCount[key] ?? 0) + (value ?? 0);
+    }
+  }
+  populateUsageCount(usage) {
+    if (!usage) {
+      return;
+    }
+    for (const [key, value] of Object.entries(usage)) {
+      if (!this.#usageCount[key]) {
+        this.#usageCount[key] = value;
+      }
+    }
+  }
+  async consumeStream(options) {
+    try {
+      await aiV5.consumeStream({
+        stream: this.fullStream.pipeThrough(
+          new web.TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+            }
+          })
+        ),
+        onError: options?.onError
+      });
+    } catch (error) {
+      console.log("consumeStream error", error);
+      options?.onError?.(error);
+    }
+  }
+  async getFullOutput() {
+    await this.consumeStream();
+    let object;
+    if (this.#options.objectOptions) {
+      object = await this.object;
+    }
+    return {
+      text: this.text,
+      usage: this.usage,
+      steps: this.steps,
+      finishReason: this.finishReason,
+      warnings: this.warnings,
+      providerMetadata: this.providerMetadata,
+      request: this.request,
+      reasoning: this.reasoning,
+      reasoningText: this.reasoningText,
+      toolCalls: this.toolCalls,
+      toolResults: this.toolResults,
+      sources: this.sources,
+      files: this.files,
+      response: this.response,
+      totalUsage: this.totalUsage,
+      object
+      // experimental_output: // TODO
+    };
+  }
+  get totalUsage() {
+    let total = 0;
+    for (const [key, value] of Object.entries(this.#usageCount)) {
+      if (key !== "totalTokens" && value && !key.startsWith("cached")) {
+        total += value;
+      }
+    }
+    return {
+      ...this.#usageCount,
+      totalTokens: total
+    };
+  }
+  get aisdk() {
+    return {
+      v5: this.#aisdkv5
+    };
+  }
+  get objectStream() {
+    const self = this;
+    if (!self.#options.objectOptions) {
+      throw new Error("objectStream requires objectOptions");
+    }
+    return this.fullStream.pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === "object") {
+            controller.enqueue(chunk.object);
+          }
+        }
+      })
+    );
+  }
+  get elementStream() {
+    let publishedElements = 0;
+    const self = this;
+    if (!self.#options.objectOptions) {
+      throw new Error("elementStream requires objectOptions");
+    }
+    return this.fullStream.pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          switch (chunk.type) {
+            case "object": {
+              const array = chunk.object;
+              if (Array.isArray(array)) {
+                for (; publishedElements < array.length; publishedElements++) {
+                  controller.enqueue(array[publishedElements]);
+                }
+              }
+              break;
+            }
+          }
+        }
+      })
+    );
+  }
+  get textStream() {
+    const self = this;
+    if (self.#options.objectOptions) {
+      const responseFormat = getResponseFormat(self.#options.objectOptions);
+      if (responseFormat?.type === "json") {
+        return this.fullStream.pipeThrough(createJsonTextStreamTransformer(self.#options.objectOptions));
+      }
+    }
+    return this.teeStream().pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === "text-delta") {
+            controller.enqueue(chunk.payload.text);
+          }
+        }
+      })
+    );
+  }
+  get object() {
+    return this.#objectPromise.promise;
+  }
+};
+
+// src/loop/telemetry/noop.ts
+var noopSpanContext = {
+  traceId: "",
+  spanId: "",
+  traceFlags: 0
+};
+var noopSpan = {
+  spanContext() {
+    return noopSpanContext;
+  },
+  setAttribute() {
+    return this;
+  },
+  setAttributes() {
+    return this;
+  },
+  addEvent() {
+    return this;
+  },
+  addLink() {
+    return this;
+  },
+  addLinks() {
+    return this;
+  },
+  setStatus() {
+    return this;
+  },
+  updateName() {
+    return this;
+  },
+  end() {
+    return this;
+  },
+  isRecording() {
+    return false;
+  },
+  recordException() {
+    return this;
+  }
+};
+var noopTracer = {
+  startSpan() {
+    return noopSpan;
+  },
+  startActiveSpan(name, arg1, arg2, arg3) {
+    if (typeof arg1 === "function") {
+      return arg1(noopSpan);
+    }
+    if (typeof arg2 === "function") {
+      return arg2(noopSpan);
+    }
+    if (typeof arg3 === "function") {
+      return arg3(noopSpan);
+    }
+  }
+};
+
+// src/loop/telemetry/index.ts
+function getTracer({
+  isEnabled = false,
+  tracer
+} = {}) {
+  if (!isEnabled) {
+    return noopTracer;
+  }
+  if (tracer) {
+    return tracer;
+  }
+  return api.trace.getTracer("mastra");
+}
+function assembleOperationName({
+  operationId,
+  telemetry
+}) {
+  return {
+    "mastra.operationId": operationId,
+    "operation.name": `${operationId}${telemetry?.functionId != null ? ` ${telemetry.functionId}` : ""}`,
+    ...telemetry?.functionId ? { "resource.name": telemetry?.functionId } : {}
+  };
+}
+function getTelemetryAttributes({
+  model,
+  settings,
+  telemetry,
+  headers
+}) {
+  return {
+    "aisdk.model.provider": model.provider,
+    "aisdk.model.id": model.modelId,
+    // settings:
+    ...Object.entries(settings).reduce((attributes, [key, value]) => {
+      attributes[`stream.settings.${key}`] = value;
+      return attributes;
+    }, {}),
+    // add metadata as attributes:
+    ...Object.entries(telemetry?.metadata ?? {}).reduce((attributes, [key, value]) => {
+      attributes[`stream.telemetry.metadata.${key}`] = value;
+      return attributes;
+    }, {}),
+    // request headers
+    ...Object.entries(headers ?? {}).reduce((attributes, [key, value]) => {
+      if (value !== void 0) {
+        attributes[`stream.request.headers.${key}`] = value;
+      }
+      return attributes;
+    }, {})
+  };
+}
+function getRootSpan({
+  operationId,
+  model,
+  modelSettings,
+  telemetry_settings,
+  headers
+}) {
+  const tracer = getTracer({
+    isEnabled: telemetry_settings?.isEnabled,
+    tracer: telemetry_settings?.tracer
+  });
+  const baseTelemetryAttributes = getTelemetryAttributes({
+    model: {
+      modelId: model.modelId,
+      provider: model.provider
+    },
+    settings: modelSettings ?? {
+      maxRetries: 2
+    },
+    telemetry: telemetry_settings,
+    headers
+  });
+  const rootSpan = tracer.startSpan(operationId).setAttributes({
+    ...assembleOperationName({
+      operationId,
+      telemetry: telemetry_settings
+    }),
+    ...baseTelemetryAttributes
+  });
+  return {
+    rootSpan
+  };
+}
+
+// src/stream/base/input.ts
+var MastraModelInput = class extends chunkKXCUCBEI_cjs.MastraBase {
+  initialize({ runId, createStream, onResult }) {
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          const stream2 = await createStream();
+          onResult({
+            warnings: stream2.warnings,
+            request: stream2.request,
+            rawResponse: stream2.rawResponse || stream2.response || {}
+          });
+          await self.transform({
+            runId,
+            stream: stream2.stream,
+            controller
+          });
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+    return stream;
+  }
+};
+
+// src/stream/aisdk/v5/input.ts
+var AISDKV5InputStream = class extends MastraModelInput {
+  constructor({ component, name }) {
+    super({ component, name });
+  }
+  async transform({
+    runId,
+    stream,
+    controller
+  }) {
+    for await (const chunk of stream) {
+      const transformedChunk = convertFullStreamChunkToMastra(chunk, { runId });
+      if (transformedChunk) {
+        controller.enqueue(transformedChunk);
+      }
+    }
+  }
+};
+
+// src/stream/aisdk/v5/execute.ts
+function execute({
+  runId,
+  model,
+  providerOptions,
+  inputMessages,
+  tools,
+  toolChoice,
+  options,
+  onResult,
+  modelStreamSpan,
+  telemetry_settings,
+  includeRawChunks,
+  modelSettings,
+  objectOptions
+}) {
+  const v5 = new AISDKV5InputStream({
+    component: "LLM",
+    name: model.modelId
+  });
+  const toolsAndToolChoice = prepareToolsAndToolChoice({
+    tools,
+    toolChoice,
+    activeTools: options?.activeTools
+  });
+  if (modelStreamSpan && toolsAndToolChoice?.tools?.length && telemetry_settings?.recordOutputs !== false) {
+    modelStreamSpan.setAttributes({
+      "stream.prompt.tools": toolsAndToolChoice?.tools?.map((tool) => JSON.stringify(tool))
+    });
+  }
+  const stream = v5.initialize({
+    runId,
+    onResult,
+    createStream: async () => {
+      try {
+        const stream2 = await model.doStream({
+          ...toolsAndToolChoice,
+          prompt: inputMessages,
+          providerOptions,
+          abortSignal: options?.abortSignal,
+          includeRawChunks,
+          responseFormat: objectOptions ? getResponseFormat(objectOptions) : void 0,
+          ...modelSettings
+        });
+        return stream2;
+      } catch (error) {
+        console.error("Error creating stream", error);
+        if (providerUtils.isAbortError(error) && options?.abortSignal?.aborted) {
+          console.log("Abort error", error);
+        }
+        return {
+          stream: new ReadableStream({
+            start: async (controller) => {
+              controller.enqueue({
+                type: "error",
+                error
+              });
+              controller.close();
+            }
+          }),
+          warnings: [],
+          request: {},
+          rawResponse: {}
+        };
+      }
+    }
+  });
+  return stream;
+}
+
+// src/loop/workflow/run-state.ts
+var AgenticRunState = class {
+  #state;
+  constructor({ _internal, model }) {
+    this.#state = {
+      responseMetadata: {
+        id: _internal?.generateId?.(),
+        timestamp: _internal?.currentDate?.(),
+        modelId: model.modelId,
+        headers: void 0
+      },
+      isReasoning: false,
+      isStreaming: false,
+      providerOptions: void 0,
+      hasToolCallStreaming: false,
+      hasErrored: false,
+      reasoningDeltas: [],
+      textDeltas: [],
+      stepResult: void 0
+    };
+  }
+  setState(state) {
+    this.#state = {
+      ...this.#state,
+      ...state
+    };
+  }
+  get state() {
+    return this.#state;
+  }
+};
+var llmIterationOutputSchema = z__default.default.object({
+  messageId: z__default.default.string(),
+  messages: z__default.default.object({
+    all: z__default.default.array(z__default.default.any()),
+    user: z__default.default.array(z__default.default.any()),
+    nonUser: z__default.default.array(z__default.default.any())
+  }),
+  output: z__default.default.any(),
+  metadata: z__default.default.any(),
+  stepResult: z__default.default.any().optional()
+});
+var toolCallInputSchema = z__default.default.object({
+  toolCallId: z__default.default.string(),
+  toolName: z__default.default.string(),
+  args: z__default.default.any(),
+  providerMetadata: z__default.default.any()
+});
+var toolCallOutputSchema = toolCallInputSchema.extend({
+  result: z__default.default.any(),
+  error: z__default.default.any().optional()
+});
+
+// src/loop/workflow/llm-execution.ts
+async function processOutputStream({
+  tools,
+  messageId,
+  messageList,
+  outputStream,
+  runState,
+  options,
+  controller,
+  responseFromModel,
+  includeRawChunks
+}) {
+  for await (const chunk of outputStream.fullStream) {
+    if (!chunk) {
+      continue;
+    }
+    if (chunk.type == "object") {
+      continue;
+    }
+    if (chunk.type !== "reasoning-delta" && chunk.type !== "reasoning-signature" && chunk.type !== "redacted-reasoning" && runState.state.isReasoning) {
+      if (runState.state.reasoningDeltas.length) {
+        messageList.add(
+          {
+            id: messageId,
+            role: "assistant",
+            content: [
+              {
+                type: "reasoning",
+                text: runState.state.reasoningDeltas.join(""),
+                signature: chunk.payload.signature,
+                providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+              }
+            ]
+          },
+          "response"
+        );
+      }
+      runState.setState({
+        isReasoning: false,
+        reasoningDeltas: []
+      });
+    }
+    if (chunk.type !== "text-delta" && chunk.type !== "tool-call" && runState.state.isStreaming) {
+      if (runState.state.textDeltas.length) {
+        messageList.add(
+          {
+            id: messageId,
+            role: "assistant",
+            content: [
+              chunk.payload.providerMetadata ?? runState.state.providerOptions ? {
+                type: "text",
+                text: runState.state.textDeltas.join(""),
+                providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+              } : {
+                type: "text",
+                text: runState.state.textDeltas.join("")
+              }
+            ]
+          },
+          "response"
+        );
+      }
+      runState.setState({
+        isStreaming: false,
+        textDeltas: []
+      });
+    }
+    switch (chunk.type) {
+      case "response-metadata":
+        runState.setState({
+          responseMetadata: {
+            id: chunk.payload.id,
+            timestamp: chunk.payload.timestamp,
+            modelId: chunk.payload.modelId,
+            headers: chunk.payload.headers
+          }
+        });
+        break;
+      case "text-delta": {
+        const textDeltasFromState = runState.state.textDeltas;
+        textDeltasFromState.push(chunk.payload.text);
+        runState.setState({
+          textDeltas: textDeltasFromState,
+          isStreaming: true
+        });
+        controller.enqueue(chunk);
+        break;
+      }
+      case "tool-call-input-streaming-start": {
+        const tool = tools?.[chunk.payload.toolName] || Object.values(tools || {})?.find((tool2) => `id` in tool2 && tool2.id === chunk.payload.toolName);
+        if (tool && "onInputStart" in tool) {
+          try {
+            await tool?.onInputStart?.({
+              toolCallId: chunk.payload.toolCallId,
+              messages: messageList.get.input.aiV5.model()?.map((message) => ({
+                role: message.role,
+                content: message.content
+              })),
+              abortSignal: options?.abortSignal
+            });
+          } catch (error) {
+            console.error("Error calling onInputStart", error);
+          }
+        }
+        controller.enqueue(chunk);
+        break;
+      }
+      case "tool-call-delta": {
+        const tool = tools?.[chunk.payload.toolName] || Object.values(tools || {})?.find((tool2) => `id` in tool2 && tool2.id === chunk.payload.toolName);
+        if (tool && "onInputDelta" in tool) {
+          try {
+            await tool?.onInputDelta?.({
+              inputTextDelta: chunk.payload.argsTextDelta,
+              toolCallId: chunk.payload.toolCallId,
+              messages: messageList.get.input.aiV5.model()?.map((message) => ({
+                role: message.role,
+                content: message.content
+              })),
+              abortSignal: options?.abortSignal
+            });
+          } catch (error) {
+            console.error("Error calling onInputDelta", error);
+          }
+        }
+        controller.enqueue(chunk);
+        break;
+      }
+      case "reasoning-start": {
+        runState.setState({
+          providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+        });
+        if (Object.values(chunk.payload.providerMetadata || {}).find((v) => v?.redactedData)) {
+          messageList.add(
+            {
+              id: messageId,
+              role: "assistant",
+              content: [
+                {
+                  type: "reasoning",
+                  text: "",
+                  providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+                }
+              ]
+            },
+            "response"
+          );
+          controller.enqueue(chunk);
+          break;
+        }
+        controller.enqueue(chunk);
+        break;
+      }
+      case "reasoning-delta": {
+        const reasoningDeltasFromState = runState.state.reasoningDeltas;
+        reasoningDeltasFromState.push(chunk.payload.text);
+        runState.setState({
+          isReasoning: true,
+          reasoningDeltas: reasoningDeltasFromState,
+          providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+        });
+        controller.enqueue(chunk);
+        break;
+      }
+      case "file":
+        messageList.add(
+          {
+            id: messageId,
+            role: "assistant",
+            content: [
+              {
+                type: "file",
+                data: chunk.payload.data,
+                mimeType: chunk.payload.mimeType
+              }
+            ]
+          },
+          "response"
+        );
+        controller.enqueue(chunk);
+        break;
+      case "source":
+        messageList.add(
+          {
+            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
+                  }
+                }
+              ]
+            },
+            createdAt: /* @__PURE__ */ new Date()
+          },
+          "response"
+        );
+        controller.enqueue(chunk);
+        break;
+      case "finish":
+        runState.setState({
+          providerOptions: chunk.payload.metadata.providerMetadata,
+          stepResult: {
+            reason: chunk.payload.reason,
+            logprobs: chunk.payload.logprobs,
+            warnings: responseFromModel.warnings,
+            totalUsage: chunk.payload.totalUsage,
+            headers: responseFromModel.rawResponse?.headers,
+            messageId,
+            isContinued: !["stop", "error"].includes(chunk.payload.reason),
+            request: responseFromModel.request
+          }
+        });
+        break;
+      case "error":
+        if (providerUtilsV5.isAbortError(chunk.payload.error) && options?.abortSignal?.aborted) {
+          break;
+        }
+        runState.setState({
+          hasErrored: true
+        });
+        controller.enqueue(chunk);
+        runState.setState({
+          stepResult: {
+            isContinued: false,
+            reason: "error"
+          }
+        });
+        await options?.onError?.({ error: chunk.payload.error });
+        break;
+      default:
+        controller.enqueue(chunk);
+    }
+    if ([
+      "text-delta",
+      "reasoning-delta",
+      "source",
+      "tool-call",
+      "tool-call-input-streaming-start",
+      "tool-call-delta",
+      "raw"
+    ].includes(chunk.type)) {
+      const transformedChunk = convertMastraChunkToAISDKv5({
+        chunk
+      });
+      if (chunk.type === "raw" && !includeRawChunks) {
+        return;
+      }
+      await options?.onChunk?.({ chunk: transformedChunk });
+    }
+    if (runState.state.hasErrored) {
+      break;
+    }
+  }
+}
+function createLLMExecutionStep({
+  model,
+  _internal,
+  messageId,
+  runId,
+  modelStreamSpan,
+  telemetry_settings,
+  tools,
+  toolChoice,
+  messageList,
+  includeRawChunks,
+  modelSettings,
+  providerOptions,
+  options,
+  toolCallStreaming,
+  controller,
+  objectOptions
+}) {
+  return chunkCSTWQQ3C_cjs.createStep({
+    id: "llm-execution",
+    inputSchema: llmIterationOutputSchema,
+    outputSchema: llmIterationOutputSchema,
+    execute: async ({ inputData, bail }) => {
+      const runState = new AgenticRunState({
+        _internal,
+        model
+      });
+      console.log("Starting LLM Execution Step");
+      let modelResult;
+      let warnings;
+      let request;
+      let rawResponse;
+      switch (model.specificationVersion) {
+        case "v2": {
+          modelResult = execute({
+            runId,
+            model,
+            providerOptions,
+            inputMessages: messageList.get.all.aiV5.llmPrompt(),
+            tools,
+            toolChoice,
+            options,
+            modelSettings,
+            telemetry_settings,
+            includeRawChunks,
+            objectOptions,
+            onResult: ({
+              warnings: warningsFromStream,
+              request: requestFromStream,
+              rawResponse: rawResponseFromStream
+            }) => {
+              warnings = warningsFromStream;
+              request = requestFromStream || {};
+              rawResponse = rawResponseFromStream;
+              controller.enqueue({
+                runId,
+                from: "AGENT",
+                type: "step-start",
+                payload: {
+                  request: request || {},
+                  warnings: [],
+                  messageId
+                }
+              });
+            },
+            modelStreamSpan
+          });
+          break;
+        }
+        default: {
+          throw new Error(`Unsupported model version: ${model.specificationVersion}`);
+        }
+      }
+      const outputStream = new MastraModelOutput({
+        model: {
+          modelId: model.modelId,
+          provider: model.provider,
+          version: model.specificationVersion
+        },
+        stream: modelResult,
+        messageList,
+        options: {
+          runId,
+          rootSpan: modelStreamSpan,
+          toolCallStreaming,
+          telemetry_settings,
+          includeRawChunks,
+          objectOptions
+        }
+      });
+      try {
+        await processOutputStream({
+          outputStream,
+          includeRawChunks,
+          tools,
+          messageId,
+          messageList,
+          runState,
+          options,
+          controller,
+          responseFromModel: {
+            warnings,
+            request,
+            rawResponse
+          }
+        });
+      } catch (error) {
+        console.log("Error in LLM Execution Step", error);
+        if (providerUtilsV5.isAbortError(error) && options?.abortSignal?.aborted) {
+          await options?.onAbort?.({
+            steps: inputData?.output?.steps ?? []
+          });
+          controller.enqueue({ type: "abort", runId, from: "AGENT", payload: {} });
+          const usage2 = outputStream.usage;
+          const responseMetadata2 = runState.state.responseMetadata;
+          const text2 = outputStream.text;
+          return bail({
+            messageId,
+            stepResult: {
+              reason: "abort",
+              warnings,
+              isContinued: false
+            },
+            metadata: {
+              providerMetadata: providerOptions,
+              ...responseMetadata2,
+              headers: rawResponse?.headers,
+              request
+            },
+            output: {
+              text: text2,
+              toolCalls: [],
+              usage: usage2 ?? inputData.output?.usage,
+              steps: []
+            },
+            messages: {
+              all: messageList.get.all.v3(),
+              user: messageList.get.input.v3(),
+              nonUser: messageList.get.response.v3()
+            }
+          });
+        }
+        runState.setState({
+          hasErrored: true,
+          stepResult: {
+            isContinued: false,
+            reason: "error"
+          }
+        });
+      }
+      const toolCalls = outputStream.toolCalls?.map((chunk) => {
+        return chunk.payload;
+      });
+      if (toolCalls.length > 0) {
+        const assistantContent = [
+          ...toolCalls.map((toolCall) => {
+            return {
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              args: toolCall.args
+            };
+          })
+        ];
+        messageList.add(
+          {
+            id: messageId,
+            role: "assistant",
+            content: assistantContent
+          },
+          "response"
+        );
+      }
+      const finishReason = runState?.state?.stepResult?.reason ?? outputStream.finishReason;
+      const hasErrored = runState.state.hasErrored;
+      const usage = outputStream.usage;
+      const responseMetadata = runState.state.responseMetadata;
+      const text = outputStream.text;
+      const steps = inputData.output?.steps || [];
+      steps.push(
+        new DefaultStepResult({
+          warnings: outputStream.warnings,
+          providerMetadata: providerOptions,
+          finishReason: runState.state.stepResult?.reason,
+          content: messageList.get.response.aiV5.modelContent(),
+          // @ts-ignore this is how it worked internally for transformResponse which was removed TODO: how should this actually work?
+          response: { ...responseMetadata, messages: messageList.get.response.aiV5.model() },
+          request,
+          usage: outputStream.usage
+        })
+      );
+      const messages = {
+        all: messageList.get.all.aiV5.model(),
+        user: messageList.get.input.aiV5.model(),
+        nonUser: messageList.get.response.aiV5.model()
+      };
+      return {
+        messageId,
+        stepResult: {
+          reason: hasErrored ? "error" : finishReason,
+          warnings,
+          isContinued: !["stop", "error"].includes(finishReason)
+        },
+        metadata: {
+          providerMetadata: runState.state.providerOptions,
+          ...responseMetadata,
+          headers: rawResponse?.headers,
+          request
+        },
+        output: {
+          text,
+          toolCalls,
+          usage: usage ?? inputData.output?.usage,
+          steps
+        },
+        messages
+      };
+    }
+  });
+}
+
+// src/loop/workflow/tool-call-step.ts
+function createToolCallStep({
+  tools,
+  messageList,
+  options,
+  telemetry_settings
+}) {
+  return chunkCSTWQQ3C_cjs.createStep({
+    id: "toolCallStep",
+    inputSchema: toolCallInputSchema,
+    outputSchema: toolCallOutputSchema,
+    execute: async ({ inputData }) => {
+      const tool = tools?.[inputData.toolName] || Object.values(tools || {})?.find((tool2) => `id` in tool2 && tool2.id === inputData.toolName);
+      if (!tool) {
+        throw new Error(`Tool ${inputData.toolName} not found`);
+      }
+      if (tool && "onInputAvailable" in tool) {
+        try {
+          await tool?.onInputAvailable?.({
+            toolCallId: inputData.toolCallId,
+            input: inputData.args,
+            messages: messageList.get.input.aiV5.model(),
+            abortSignal: options?.abortSignal
+          });
+        } catch (error) {
+          console.error("Error calling onInputAvailable", error);
+        }
+      }
+      if (!tool.execute) {
+        return inputData;
+      }
+      const tracer = getTracer({
+        isEnabled: telemetry_settings?.isEnabled,
+        tracer: telemetry_settings?.tracer
+      });
+      const span = tracer.startSpan("mastra.stream.toolCall").setAttributes({
+        ...assembleOperationName({
+          operationId: "mastra.stream.toolCall",
+          telemetry: telemetry_settings
+        }),
+        "stream.toolCall.toolName": inputData.toolName,
+        "stream.toolCall.toolCallId": inputData.toolCallId,
+        "stream.toolCall.args": JSON.stringify(inputData.args)
+      });
+      try {
+        const result = await tool.execute(inputData.args, {
+          abortSignal: options?.abortSignal,
+          toolCallId: inputData.toolCallId,
+          messages: messageList.get.input.aiV5.model()
+        });
+        span.setAttributes({
+          "stream.toolCall.result": JSON.stringify(result)
+        });
+        span.end();
+        return { result, ...inputData };
+      } catch (error) {
+        span.setStatus({
+          code: 2,
+          message: error?.message ?? error
+        });
+        span.recordException(error);
+        return {
+          error,
+          ...inputData
+        };
+      }
+    }
+  });
+}
+
+// src/loop/workflow/outer-llm-step.ts
+function createOuterLLMWorkflow({
+  model,
+  telemetry_settings,
+  _internal,
+  modelStreamSpan,
+  ...rest
+}) {
+  const llmExecutionStep = createLLMExecutionStep({
+    model,
+    _internal,
+    modelStreamSpan,
+    telemetry_settings,
+    ...rest
+  });
+  const toolCallStep = createToolCallStep({
+    telemetry_settings,
+    ...rest
+  });
+  const messageList = rest.messageList;
+  const llmMappingStep = chunkCSTWQQ3C_cjs.createStep({
+    id: "llmExecutionMappingStep",
+    inputSchema: z__default.default.array(toolCallOutputSchema),
+    outputSchema: llmIterationOutputSchema,
+    execute: async ({ inputData, getStepResult, bail }) => {
+      const initialResult = getStepResult(llmExecutionStep);
+      if (inputData?.every((toolCall) => toolCall?.result === void 0)) {
+        const errorResults = inputData.filter((toolCall) => toolCall?.error);
+        const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+        if (errorResults?.length) {
+          errorResults.forEach((toolCall) => {
+            const chunk = {
+              type: "tool-error",
+              runId: rest.runId,
+              from: "AGENT",
+              payload: {
+                error: toolCall.error,
+                args: toolCall.args,
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                result: toolCall.result,
+                providerMetadata: toolCall.providerMetadata
+              }
+            };
+            rest.controller.enqueue(chunk);
+          });
+          rest.messageList.add(
+            {
+              id: toolResultMessageId,
+              role: "tool",
+              content: errorResults.map((toolCall) => {
+                return {
+                  type: "tool-result",
+                  args: toolCall.args,
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  result: {
+                    tool_execution_error: toolCall.error?.message ?? toolCall.error
+                  }
+                };
+              })
+            },
+            "response"
+          );
+        }
+        initialResult.stepResult.isContinued = false;
+        return bail(initialResult);
+      }
+      if (inputData?.length) {
+        for (const toolCall of inputData) {
+          const chunk = {
+            type: "tool-result",
+            runId: rest.runId,
+            from: "AGENT",
+            payload: {
+              args: toolCall.args,
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              result: toolCall.result,
+              providerMetadata: toolCall.providerMetadata
+            }
+          };
+          rest.controller.enqueue(chunk);
+          if (model.specificationVersion === "v2") {
+            await rest.options?.onChunk?.({
+              chunk: convertMastraChunkToAISDKv5({
+                chunk
+              })
+            });
+          }
+          const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+          messageList.add(
+            {
+              id: toolResultMessageId,
+              role: "tool",
+              content: inputData.map((toolCall2) => {
+                return {
+                  type: "tool-result",
+                  args: toolCall2.args,
+                  toolCallId: toolCall2.toolCallId,
+                  toolName: toolCall2.toolName,
+                  result: toolCall2.result
+                };
+              })
+            },
+            "response"
+          );
+        }
+        return {
+          ...initialResult,
+          messages: {
+            all: messageList.get.all.v3(),
+            user: messageList.get.input.v3(),
+            nonUser: messageList.get.response.v3()
+          }
+        };
+      }
+    }
+  });
+  return chunkCSTWQQ3C_cjs.createWorkflow({
+    id: "executionWorkflow",
+    inputSchema: llmIterationOutputSchema,
+    outputSchema: z__default.default.any()
+  }).then(llmExecutionStep).map(({ inputData }) => {
+    if (modelStreamSpan && telemetry_settings?.recordOutputs !== false && inputData.output.toolCalls?.length) {
+      modelStreamSpan.setAttribute(
+        "stream.response.toolCalls",
+        JSON.stringify(
+          inputData.output.toolCalls?.map((toolCall) => {
+            return {
+              toolCallId: toolCall.toolCallId,
+              args: toolCall.args,
+              toolName: toolCall.toolName
+            };
+          })
+        )
+      );
+    }
+    return inputData.output.toolCalls || [];
+  }).foreach(toolCallStep).then(llmMappingStep).commit();
+}
+
+// src/loop/workflow/stream.ts
+function workflowLoopStream({
+  telemetry_settings,
+  model,
+  toolChoice,
+  modelSettings,
+  _internal,
+  modelStreamSpan,
+  ...rest
+}) {
+  return new web.ReadableStream({
+    start: async (controller) => {
+      const messageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+      modelStreamSpan.setAttributes({
+        ...telemetry_settings?.recordInputs !== false ? {
+          "stream.prompt.toolChoice": toolChoice ? JSON.stringify(toolChoice) : "auto"
+        } : {}
+      });
+      const outerLLMWorkflow = createOuterLLMWorkflow({
+        messageId,
+        model,
+        telemetry_settings,
+        _internal,
+        modelSettings,
+        toolChoice,
+        modelStreamSpan,
+        controller,
+        ...rest
+      });
+      const mainWorkflow = chunkCSTWQQ3C_cjs.createWorkflow({
+        id: "agentic-loop",
+        inputSchema: llmIterationOutputSchema,
+        outputSchema: z__default.default.any()
+      }).dowhile(outerLLMWorkflow, async ({ inputData }) => {
+        let hasFinishedSteps = false;
+        if (rest.stopWhen) {
+          const conditions = await Promise.all(
+            (Array.isArray(rest.stopWhen) ? rest.stopWhen : [rest.stopWhen]).map((condition) => {
+              return condition({
+                steps: inputData.output.steps
+              });
+            })
+          );
+          const hasStopped = conditions.some((condition) => condition);
+          hasFinishedSteps = hasStopped;
+        }
+        inputData.stepResult.isContinued = hasFinishedSteps ? false : inputData.stepResult.isContinued;
+        if (inputData.stepResult.reason !== "abort") {
+          controller.enqueue({
+            type: "step-finish",
+            runId: rest.runId,
+            from: "AGENT",
+            payload: inputData
+          });
+        }
+        modelStreamSpan.setAttributes({
+          "stream.response.id": inputData.metadata.id,
+          "stream.response.model": model.modelId,
+          ...inputData.metadata.providerMetadata ? { "stream.response.providerMetadata": JSON.stringify(inputData.metadata.providerMetadata) } : {},
+          "stream.response.finishReason": inputData.stepResult.reason,
+          "stream.usage.inputTokens": inputData.output.usage?.inputTokens,
+          "stream.usage.outputTokens": inputData.output.usage?.outputTokens,
+          "stream.usage.totalTokens": inputData.output.usage?.totalTokens,
+          ...telemetry_settings?.recordOutputs !== false ? {
+            "stream.response.text": inputData.output.text,
+            "stream.prompt.messages": JSON.stringify(rest.messageList.get.input.aiV5.model())
+          } : {}
+        });
+        modelStreamSpan.end();
+        const reason = inputData.stepResult.reason;
+        if (reason === void 0) {
+          return false;
+        }
+        return inputData.stepResult.isContinued;
+      }).map(({ inputData }) => {
+        const toolCalls = rest.messageList.get.response.v3().filter((message) => message.role === "tool");
+        inputData.output.toolCalls = toolCalls;
+        return inputData;
+      }).commit();
+      const msToFirstChunk = _internal?.now?.() - rest.startTimestamp;
+      modelStreamSpan.addEvent("ai.stream.firstChunk", {
+        "ai.response.msToFirstChunk": msToFirstChunk
+      });
+      modelStreamSpan.setAttributes({
+        "stream.response.timestamp": new Date(rest.startTimestamp).toISOString(),
+        "stream.response.msToFirstChunk": msToFirstChunk
+      });
+      controller.enqueue({
+        type: "start",
+        runId: rest.runId,
+        from: "AGENT",
+        payload: {}
+      });
+      const run = await mainWorkflow.createRunAsync({
+        runId: rest.runId
+      });
+      const executionResult = await run.start({
+        inputData: {
+          messageId,
+          messages: {
+            all: rest.messageList.get.input.aiV5.model(),
+            user: rest.messageList.get.input.aiV5.model(),
+            nonUser: []
+          }
+        }
+      });
+      if (executionResult.status !== "success") {
+        controller.close();
+        return;
+      }
+      if (executionResult.result.stepResult.reason === "abort") {
+        console.log("aborted_result", JSON.stringify(executionResult.result, null, 2));
+        controller.close();
+        return;
+      }
+      controller.enqueue({
+        type: "finish",
+        runId: rest.runId,
+        from: "AGENT",
+        payload: executionResult.result
+      });
+      const msToFinish = (_internal?.now?.() ?? Date.now()) - rest.startTimestamp;
+      modelStreamSpan.addEvent("ai.stream.finish");
+      modelStreamSpan.setAttributes({
+        "stream.response.msToFinish": msToFinish,
+        "stream.response.avgOutputTokensPerSecond": 1e3 * (executionResult?.result?.output?.usage?.outputTokens ?? 0) / msToFinish
+      });
+      controller.close();
+    }
+  });
+}
+
+// src/loop/loop.ts
+function loop({
+  model,
+  logger,
+  runId,
+  idGenerator,
+  telemetry_settings,
+  messageList,
+  includeRawChunks,
+  modelSettings,
+  tools,
+  _internal,
+  ...rest
+}) {
+  let loggerToUse = logger || new chunkV5WKCX3G_cjs.ConsoleLogger({
+    level: "debug"
+  });
+  let runIdToUse = runId;
+  if (!runIdToUse) {
+    runIdToUse = idGenerator?.() || crypto.randomUUID();
+  }
+  const internalToUse = {
+    now: _internal?.now || (() => Date.now()),
+    generateId: _internal?.generateId || (() => aiV5.generateId()),
+    currentDate: _internal?.currentDate || (() => /* @__PURE__ */ new Date())
+  };
+  let startTimestamp = internalToUse.now?.();
+  const { rootSpan } = getRootSpan({
+    operationId: `mastra.stream`,
+    model: {
+      modelId: model.modelId,
+      provider: model.provider
+    },
+    modelSettings,
+    headers: modelSettings?.headers ?? rest.headers,
+    telemetry_settings
+  });
+  rootSpan.setAttributes({
+    ...telemetry_settings?.recordOutputs !== false ? {
+      "stream.prompt.messages": JSON.stringify(messageList.get.input.aiV5.model())
+    } : {}
+  });
+  const { rootSpan: modelStreamSpan } = getRootSpan({
+    operationId: `mastra.stream.aisdk.doStream`,
+    model: {
+      modelId: model.modelId,
+      provider: model.provider
+    },
+    modelSettings,
+    headers: modelSettings?.headers ?? rest.headers,
+    telemetry_settings
+  });
+  const workflowLoopProps = {
+    model,
+    runId: runIdToUse,
+    logger: loggerToUse,
+    startTimestamp,
+    messageList,
+    includeRawChunks: !!includeRawChunks,
+    _internal: internalToUse,
+    tools,
+    modelStreamSpan,
+    telemetry_settings,
+    ...rest
+  };
+  const streamFn = workflowLoopStream(workflowLoopProps);
+  return new MastraModelOutput({
+    model: {
+      modelId: model.modelId,
+      provider: model.provider,
+      version: model.specificationVersion
+    },
+    stream: streamFn,
+    messageList,
+    options: {
+      runId: runIdToUse,
+      telemetry_settings,
+      rootSpan,
+      toolCallStreaming: rest.toolCallStreaming,
+      onFinish: rest.options?.onFinish,
+      onStepFinish: rest.options?.onStepFinish,
+      includeRawChunks: !!includeRawChunks,
+      objectOptions: rest.objectOptions
+    }
+  });
+}
+
+exports.loop = loop;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map