@mastra/ai-sdk 0.0.0-1.x-tester-20251106055847

package/dist/index.cjs

@@ -0,0 +1,1335 @@
+'use strict';
+
+var server = require('@mastra/core/server');
+var ai = require('ai');
+var stream = require('@mastra/core/stream');
+
+// src/chat-route.ts
+
+// src/utils.ts
+var isDataChunkType = (chunk) => {
+  return chunk && typeof chunk === "object" && "type" in chunk && chunk.type?.startsWith("data-");
+};
+function safeParseErrorObject(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return String(obj);
+  }
+  try {
+    const stringified = JSON.stringify(obj);
+    if (stringified === "{}") {
+      return String(obj);
+    }
+    return stringified;
+  } catch {
+    return String(obj);
+  }
+}
+var isAgentExecutionDataChunkType = (chunk) => {
+  return chunk && typeof chunk === "object" && "type" in chunk && chunk.type?.startsWith("agent-execution-event-") && "payload" in chunk && typeof chunk.payload === "object" && "type" in chunk.payload && chunk.payload.type?.startsWith("data-");
+};
+var isWorkflowExecutionDataChunkType = (chunk) => {
+  return chunk && typeof chunk === "object" && "type" in chunk && chunk.type?.startsWith("workflow-execution-event-") && "payload" in chunk && typeof chunk.payload === "object" && "type" in chunk.payload && chunk.payload.type?.startsWith("data-");
+};
+
+// src/helpers.ts
+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":
+      if (chunk.payload.sourceType === "url") {
+        return {
+          type: "source",
+          sourceType: "url",
+          id: chunk.payload.id,
+          url: chunk.payload.url,
+          title: chunk.payload.title,
+          providerMetadata: chunk.payload.providerMetadata
+        };
+      } else {
+        return {
+          type: "source",
+          sourceType: "document",
+          id: chunk.payload.id,
+          mediaType: chunk.payload.mimeType,
+          title: chunk.payload.title,
+          filename: chunk.payload.filename,
+          providerMetadata: chunk.payload.providerMetadata
+        };
+      }
+    case "file":
+      if (mode === "generate") {
+        return {
+          type: "file",
+          file: new stream.DefaultGeneratedFile({
+            data: chunk.payload.data,
+            mediaType: chunk.payload.mimeType
+          })
+        };
+      }
+      return {
+        type: "file",
+        file: new stream.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: {
+          id: chunk.payload.id || "",
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: rest2.modelId || "",
+          ...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
+      };
+    case "object":
+      return {
+        type: "object",
+        object: chunk.object
+      };
+    default:
+      if (chunk.type && "payload" in chunk && chunk.payload) {
+        return {
+          type: chunk.type,
+          ...chunk.payload || {}
+        };
+      }
+      if ("type" in chunk && chunk.type?.startsWith("data-")) {
+        return chunk;
+      }
+      return;
+  }
+}
+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": {
+      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": {
+      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-output": {
+      if (part.output.from === "AGENT") {
+        return {
+          type: "tool-agent",
+          toolCallId: part.toolCallId,
+          payload: part.output
+        };
+      } else if (part.output.from === "WORKFLOW") {
+        return {
+          type: "tool-workflow",
+          toolCallId: part.toolCallId,
+          payload: part.output
+        };
+      } else if (part.output.from === "NETWORK") {
+        return {
+          type: "tool-network",
+          toolCallId: part.toolCallId,
+          payload: part.output
+        };
+      }
+      return;
+    }
+    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": {
+      {
+        return {
+          type: "start",
+          ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {},
+          ...responseMessageId != null ? { messageId: responseMessageId } : {}
+        };
+      }
+    }
+    case "finish": {
+      {
+        return {
+          type: "finish",
+          ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {}
+        };
+      }
+    }
+    case "abort": {
+      return part;
+    }
+    case "tool-input-end": {
+      return;
+    }
+    case "raw": {
+      return;
+    }
+    default: {
+      if (isDataChunkType(part)) {
+        if (!("data" in part)) {
+          throw new Error(
+            `UI Messages require a data property when using data- prefixed chunks 
+ ${JSON.stringify(part)}`
+          );
+        }
+        return part;
+      }
+      return;
+    }
+  }
+}
+
+// src/transformers.ts
+function WorkflowStreamToAISDKTransformer() {
+  const bufferedWorkflows = /* @__PURE__ */ new Map();
+  return new TransformStream({
+    start(controller) {
+      controller.enqueue({
+        type: "start"
+      });
+    },
+    flush(controller) {
+      controller.enqueue({
+        type: "finish"
+      });
+    },
+    transform(chunk, controller) {
+      const transformed = transformWorkflow(chunk, bufferedWorkflows);
+      if (transformed) controller.enqueue(transformed);
+    }
+  });
+}
+function AgentNetworkToAISDKTransformer() {
+  const bufferedNetworks = /* @__PURE__ */ new Map();
+  return new TransformStream({
+    start(controller) {
+      controller.enqueue({
+        type: "start"
+      });
+    },
+    flush(controller) {
+      controller.enqueue({
+        type: "finish"
+      });
+    },
+    transform(chunk, controller) {
+      const transformed = transformNetwork(chunk, bufferedNetworks);
+      if (transformed) controller.enqueue(transformed);
+    }
+  });
+}
+function AgentStreamToAISDKTransformer(lastMessageId) {
+  let bufferedSteps = /* @__PURE__ */ new Map();
+  return new TransformStream({
+    transform(chunk, controller) {
+      const part = convertMastraChunkToAISDKv5({ chunk, mode: "stream" });
+      const transformedChunk = convertFullStreamChunkToUIMessageStream({
+        part,
+        sendReasoning: false,
+        sendSources: false,
+        sendStart: true,
+        sendFinish: true,
+        responseMessageId: lastMessageId,
+        onError(error) {
+          return safeParseErrorObject(error);
+        }
+      });
+      if (transformedChunk) {
+        if (transformedChunk.type === "tool-agent") {
+          const payload = transformedChunk.payload;
+          const agentTransformed = transformAgent(payload, bufferedSteps);
+          if (agentTransformed) controller.enqueue(agentTransformed);
+        } else if (transformedChunk.type === "tool-workflow") {
+          const payload = transformedChunk.payload;
+          const workflowChunk = transformWorkflow(payload, bufferedSteps, true);
+          if (workflowChunk) controller.enqueue(workflowChunk);
+        } else if (transformedChunk.type === "tool-network") {
+          const payload = transformedChunk.payload;
+          const networkChunk = transformNetwork(payload, bufferedSteps, true);
+          if (networkChunk) controller.enqueue(networkChunk);
+        } else {
+          controller.enqueue(transformedChunk);
+        }
+      }
+    }
+  });
+}
+function transformAgent(payload, bufferedSteps) {
+  let hasChanged = false;
+  switch (payload.type) {
+    case "start":
+      bufferedSteps.set(payload.runId, {
+        id: payload.payload.id,
+        object: null,
+        finishReason: null,
+        usage: null,
+        warnings: [],
+        text: "",
+        reasoning: [],
+        sources: [],
+        files: [],
+        toolCalls: [],
+        toolResults: [],
+        request: {},
+        response: {
+          id: "",
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: "",
+          messages: []
+        },
+        providerMetadata: void 0,
+        steps: [],
+        status: "running"
+      });
+      hasChanged = true;
+      break;
+    case "finish":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        finishReason: payload.payload.stepResult.reason,
+        usage: payload.payload?.output?.usage,
+        warnings: payload.payload?.stepResult?.warnings,
+        steps: bufferedSteps.get(payload.runId).steps,
+        status: "finished"
+      });
+      hasChanged = true;
+      break;
+    case "text-delta":
+      const prevData = bufferedSteps.get(payload.runId);
+      bufferedSteps.set(payload.runId, {
+        ...prevData,
+        text: `${prevData.text}${payload.payload.text}`
+      });
+      hasChanged = true;
+      break;
+    case "reasoning-delta":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        reasoning: [...bufferedSteps.get(payload.runId).reasoning, payload.payload.text]
+      });
+      hasChanged = true;
+      break;
+    case "source":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        sources: [...bufferedSteps.get(payload.runId).sources, payload.payload]
+      });
+      hasChanged = true;
+      break;
+    case "file":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        files: [...bufferedSteps.get(payload.runId).files, payload.payload]
+      });
+      hasChanged = true;
+      break;
+    case "tool-call":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        toolCalls: [...bufferedSteps.get(payload.runId).toolCalls, payload.payload]
+      });
+      hasChanged = true;
+      break;
+    case "tool-result":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        toolResults: [...bufferedSteps.get(payload.runId).toolResults, payload.payload]
+      });
+      hasChanged = true;
+      break;
+    case "object-result":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        object: payload.object
+      });
+      hasChanged = true;
+      break;
+    case "object":
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        object: payload.object
+      });
+      hasChanged = true;
+      break;
+    case "step-finish":
+      const currentRun = bufferedSteps.get(payload.runId);
+      const stepResult = {
+        ...bufferedSteps.get(payload.runId),
+        stepType: currentRun.steps.length === 0 ? "initial" : "tool-result",
+        reasoningText: bufferedSteps.get(payload.runId).reasoning.join(""),
+        staticToolCalls: bufferedSteps.get(payload.runId).toolCalls.filter((part) => part.type === "tool-call" && part.payload?.dynamic === false),
+        dynamicToolCalls: bufferedSteps.get(payload.runId).toolCalls.filter((part) => part.type === "tool-call" && part.payload?.dynamic === true),
+        staticToolResults: bufferedSteps.get(payload.runId).toolResults.filter((part) => part.type === "tool-result" && part.payload?.dynamic === false),
+        dynamicToolResults: bufferedSteps.get(payload.runId).toolResults.filter((part) => part.type === "tool-result" && part.payload?.dynamic === true),
+        finishReason: payload.payload.stepResult.reason,
+        usage: payload.payload.output.usage,
+        warnings: payload.payload.stepResult.warnings || [],
+        response: {
+          id: payload.payload.id || "",
+          timestamp: payload.payload.metadata?.timestamp || /* @__PURE__ */ new Date(),
+          modelId: payload.payload.metadata?.modelId || payload.payload.metadata?.model || "",
+          ...bufferedSteps.get(payload.runId).response,
+          messages: bufferedSteps.get(payload.runId).response.messages || []
+        }
+      };
+      bufferedSteps.set(payload.runId, {
+        ...bufferedSteps.get(payload.runId),
+        usage: payload.payload.output.usage,
+        warnings: payload.payload.stepResult.warnings || [],
+        steps: [...bufferedSteps.get(payload.runId).steps, stepResult]
+      });
+      hasChanged = true;
+      break;
+  }
+  if (hasChanged) {
+    return {
+      type: "data-tool-agent",
+      id: payload.runId,
+      data: bufferedSteps.get(payload.runId)
+    };
+  }
+  return null;
+}
+function transformWorkflow(payload, bufferedWorkflows, isNested) {
+  switch (payload.type) {
+    case "workflow-start":
+      bufferedWorkflows.set(payload.runId, {
+        name: payload.payload.workflowId,
+        steps: {}
+      });
+      return {
+        type: isNested ? "data-tool-workflow" : "data-workflow",
+        id: payload.runId,
+        data: {
+          name: bufferedWorkflows.get(payload.runId).name,
+          status: "running",
+          steps: bufferedWorkflows.get(payload.runId).steps,
+          output: null
+        }
+      };
+    case "workflow-step-start": {
+      const current = bufferedWorkflows.get(payload.runId) || { name: "", steps: {} };
+      current.steps[payload.payload.id] = {
+        name: payload.payload.id,
+        status: payload.payload.status,
+        input: payload.payload.payload ?? null,
+        output: null,
+        suspendPayload: null,
+        resumePayload: null
+      };
+      bufferedWorkflows.set(payload.runId, current);
+      return {
+        type: isNested ? "data-tool-workflow" : "data-workflow",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "workflow-step-result": {
+      const current = bufferedWorkflows.get(payload.runId);
+      if (!current) return null;
+      current.steps[payload.payload.id] = {
+        ...current.steps[payload.payload.id],
+        status: payload.payload.status,
+        output: payload.payload.output ?? null
+      };
+      return {
+        type: isNested ? "data-tool-workflow" : "data-workflow",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "workflow-step-suspended": {
+      const current = bufferedWorkflows.get(payload.runId);
+      if (!current) return null;
+      current.steps[payload.payload.id] = {
+        ...current.steps[payload.payload.id],
+        status: payload.payload.status,
+        suspendPayload: payload.payload.suspendPayload ?? null,
+        resumePayload: payload.payload.resumePayload ?? null,
+        output: null
+      };
+      return {
+        type: isNested ? "data-tool-workflow" : "data-workflow",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "suspended",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "workflow-finish": {
+      const current = bufferedWorkflows.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-workflow" : "data-workflow",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          steps: current.steps,
+          output: payload.payload.output ?? null,
+          status: payload.payload.workflowStatus
+        }
+      };
+    }
+    default: {
+      if (isDataChunkType(payload)) {
+        if (!("data" in payload)) {
+          throw new Error(
+            `UI Messages require a data property when using data- prefixed chunks 
+ ${JSON.stringify(payload)}`
+          );
+        }
+        return payload;
+      }
+      return null;
+    }
+  }
+}
+function transformNetwork(payload, bufferedNetworks, isNested) {
+  switch (payload.type) {
+    case "routing-agent-start": {
+      if (!bufferedNetworks.has(payload.runId)) {
+        bufferedNetworks.set(payload.runId, {
+          name: payload.payload.agentId,
+          steps: [],
+          usage: null,
+          output: null
+        });
+      }
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          name: bufferedNetworks.get(payload.runId).name,
+          status: "running",
+          usage: null,
+          steps: bufferedNetworks.get(payload.runId).steps,
+          output: null
+        }
+      };
+    }
+    case "routing-agent-text-start": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: "text-start",
+        id: payload.runId
+      };
+    }
+    case "routing-agent-text-delta": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: "text-delta",
+        id: payload.runId,
+        delta: payload.payload.text
+      };
+    }
+    case "agent-execution-start": {
+      const current = bufferedNetworks.get(payload.runId) || { name: "", steps: [], usage: null, output: null };
+      current.steps.push({
+        name: payload.payload.agentId,
+        status: "running",
+        input: payload.payload.args || null,
+        output: null,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      bufferedNetworks.set(payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "running"
+        }
+      };
+    }
+    case "workflow-execution-start": {
+      const current = bufferedNetworks.get(payload.runId) || { name: "", steps: [], usage: null, output: null };
+      current.steps.push({
+        name: payload.payload.name,
+        status: "running",
+        input: payload.payload.args || null,
+        output: null,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      bufferedNetworks.set(payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "running"
+        }
+      };
+    }
+    case "tool-execution-start": {
+      const current = bufferedNetworks.get(payload.runId) || { name: "", steps: [], usage: null, output: null };
+      current.steps.push({
+        name: payload.payload.args?.toolName,
+        status: "running",
+        input: payload.payload.args?.args || null,
+        output: null,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      bufferedNetworks.set(payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "running"
+        }
+      };
+    }
+    case "agent-execution-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      current.steps.push({
+        name: payload.payload.agentId,
+        status: "success",
+        input: null,
+        output: payload.payload.result,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          usage: payload.payload?.usage ?? current.usage,
+          status: "running",
+          output: payload.payload.result ?? current.output
+        }
+      };
+    }
+    case "tool-execution-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      current.steps.push({
+        name: payload.payload.toolName,
+        status: "success",
+        input: null,
+        output: payload.payload.result,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "running",
+          output: payload.payload.result ?? current.output
+        }
+      };
+    }
+    case "workflow-execution-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      current.steps.push({
+        name: payload.payload.name,
+        status: "success",
+        input: null,
+        output: payload.payload.result,
+        suspendPayload: null,
+        resumePayload: null
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          usage: payload.payload?.usage ?? current.usage,
+          status: "running",
+          output: payload.payload.result ?? current.output
+        }
+      };
+    }
+    case "routing-agent-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "finished",
+          usage: payload.payload?.usage ?? current.usage,
+          output: payload.payload?.result ?? current.output
+        }
+      };
+    }
+    case "network-execution-event-step-finish": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          status: "finished",
+          output: payload.payload?.result ?? current.output
+        }
+      };
+    }
+    case "network-execution-event-finish": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          ...current,
+          usage: payload.payload?.usage ?? current.usage,
+          status: "finished",
+          output: payload.payload?.result ?? current.output
+        }
+      };
+    }
+    default: {
+      if (isDataChunkType(payload)) {
+        if (!("data" in payload)) {
+          throw new Error(
+            `UI Messages require a data property when using data- prefixed chunks 
+ ${JSON.stringify(payload)}`
+          );
+        }
+        return payload;
+      }
+      if (isAgentExecutionDataChunkType(payload)) {
+        if (!("data" in payload.payload)) {
+          throw new Error(
+            `UI Messages require a data property when using data- prefixed chunks 
+ ${JSON.stringify(payload)}`
+          );
+        }
+        return payload.payload;
+      }
+      if (isWorkflowExecutionDataChunkType(payload)) {
+        if (!("data" in payload.payload)) {
+          throw new Error(
+            `UI Messages require a data property when using data- prefixed chunks 
+ ${JSON.stringify(payload)}`
+          );
+        }
+        return payload.payload;
+      }
+      return null;
+    }
+  }
+}
+
+// src/convert-streams.ts
+function toAISdkV5Stream(stream, options = { from: "agent" }) {
+  const from = options?.from;
+  if (from === "workflow") {
+    return stream.pipeThrough(WorkflowStreamToAISDKTransformer());
+  }
+  if (from === "network") {
+    return stream.pipeThrough(AgentNetworkToAISDKTransformer());
+  }
+  const agentReadable = "fullStream" in stream ? stream.fullStream : stream;
+  return agentReadable.pipeThrough(AgentStreamToAISDKTransformer(options?.lastMessageId));
+}
+
+// src/chat-route.ts
+function chatRoute({
+  path = "/chat/:agentId",
+  agent,
+  defaultOptions
+}) {
+  if (!agent && !path.includes("/:agentId")) {
+    throw new Error("Path must include :agentId to route to the correct agent or pass the agent explicitly");
+  }
+  return server.registerApiRoute(path, {
+    method: "POST",
+    openapi: {
+      summary: "Chat with an agent",
+      description: "Send messages to an agent and stream the response in the AI SDK format",
+      tags: ["ai-sdk"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          description: "The ID of the agent to chat with",
+          schema: {
+            type: "string"
+          }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  description: "Array of messages in the conversation",
+                  items: {
+                    type: "object",
+                    properties: {
+                      role: {
+                        type: "string",
+                        enum: ["user", "assistant", "system"],
+                        description: "The role of the message sender"
+                      },
+                      content: {
+                        type: "string",
+                        description: "The content of the message"
+                      }
+                    },
+                    required: ["role", "content"]
+                  }
+                }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "Streaming response from the agent",
+          content: {
+            "text/plain": {
+              schema: {
+                type: "string",
+                description: "Server-sent events stream containing the agent response"
+              }
+            }
+          }
+        },
+        "400": {
+          description: "Bad request - invalid input",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  error: {
+                    type: "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "404": {
+          description: "Agent not found",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  error: {
+                    type: "string"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    handler: async (c) => {
+      const { messages, ...rest } = await c.req.json();
+      const mastra = c.get("mastra");
+      const requestContext = c.get("requestContext");
+      let agentToUse = agent;
+      if (!agent) {
+        const agentId = c.req.param("agentId");
+        agentToUse = agentId;
+      }
+      if (c.req.param("agentId") && agent) {
+        mastra.getLogger()?.warn(
+          `Fixed agent ID was set together with an agentId path parameter. This can lead to unexpected behavior.`
+        );
+      }
+      if (requestContext && defaultOptions?.requestContext) {
+        mastra.getLogger()?.warn(`"requestContext" set in the route options will be overridden by the request's "requestContext".`);
+      }
+      if (!agentToUse) {
+        throw new Error("Agent ID is required");
+      }
+      const agentObj = mastra.getAgent(agentToUse);
+      if (!agentObj) {
+        throw new Error(`Agent ${agentToUse} not found`);
+      }
+      const result = await agentObj.stream(messages, {
+        ...defaultOptions,
+        ...rest,
+        requestContext: requestContext || defaultOptions?.requestContext
+      });
+      let lastMessageId;
+      if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+        lastMessageId = messages[messages.length - 1].id;
+      }
+      const uiMessageStream = ai.createUIMessageStream({
+        originalMessages: messages,
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkV5Stream(result, { from: "agent", lastMessageId })) {
+            writer.write(part);
+          }
+        }
+      });
+      return ai.createUIMessageStreamResponse({
+        stream: uiMessageStream
+      });
+    }
+  });
+}
+function workflowRoute({
+  path = "/api/workflows/:workflowId/stream",
+  workflow
+}) {
+  if (!workflow && !path.includes("/:workflowId")) {
+    throw new Error("Path must include :workflowId to route to the correct workflow or pass the workflow explicitly");
+  }
+  return server.registerApiRoute(path, {
+    method: "POST",
+    openapi: {
+      summary: "Stream a workflow in AI SDK format",
+      description: "Starts a workflow run and streams events as AI SDK UIMessage chunks",
+      tags: ["ai-sdk"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          description: "The ID of the workflow to stream",
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object", additionalProperties: true },
+                requestContext: { type: "object", additionalProperties: true },
+                tracingOptions: { type: "object", additionalProperties: true }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "Workflow UIMessage event stream",
+          content: {
+            "text/plain": {
+              schema: { type: "string", description: "SSE stream" }
+            }
+          }
+        }
+      }
+    },
+    handler: async (c) => {
+      const { inputData, resumeData, ...rest } = await c.req.json();
+      const mastra = c.get("mastra");
+      let workflowToUse = workflow;
+      if (!workflow) {
+        const workflowId = c.req.param("workflowId");
+        workflowToUse = workflowId;
+      }
+      if (c.req.param("workflowId") && workflow) {
+        mastra.getLogger()?.warn(
+          `Fixed workflow ID was set together with a workflowId path parameter. This can lead to unexpected behavior.`
+        );
+      }
+      if (!workflowToUse) {
+        throw new Error("Workflow ID is required");
+      }
+      const workflowObj = mastra.getWorkflow(workflowToUse);
+      if (!workflowObj) {
+        throw new Error(`Workflow ${workflowToUse} not found`);
+      }
+      const run = await workflowObj.createRun();
+      const stream = resumeData ? run.resumeStream({ resumeData, ...rest }) : run.stream({ inputData, ...rest });
+      const uiMessageStream = ai.createUIMessageStream({
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkV5Stream(stream, { from: "workflow" })) {
+            writer.write(part);
+          }
+        }
+      });
+      return ai.createUIMessageStreamResponse({ stream: uiMessageStream });
+    }
+  });
+}
+function networkRoute({
+  path = "/network/:agentId",
+  agent,
+  defaultOptions
+}) {
+  if (!agent && !path.includes("/:agentId")) {
+    throw new Error("Path must include :agentId to route to the correct agent or pass the agent explicitly");
+  }
+  return server.registerApiRoute(path, {
+    method: "POST",
+    openapi: {
+      summary: "Execute an agent network and stream AI SDK events",
+      description: "Routes a request to an agent network and streams UIMessage chunks in AI SDK format",
+      tags: ["ai-sdk"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          description: "The ID of the routing agent to execute as a network",
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: { type: "array", items: { type: "object" } },
+                requestContext: { type: "object", additionalProperties: true },
+                runId: { type: "string" },
+                maxSteps: { type: "number" },
+                threadId: { type: "string" },
+                resourceId: { type: "string" },
+                modelSettings: { type: "object", additionalProperties: true },
+                tools: { type: "array", items: { type: "object" } }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "Streaming AI SDK UIMessage event stream for the agent network",
+          content: { "text/plain": { schema: { type: "string", description: "SSE stream" } } }
+        },
+        "404": {
+          description: "Agent not found",
+          content: {
+            "application/json": {
+              schema: { type: "object", properties: { error: { type: "string" } } }
+            }
+          }
+        }
+      }
+    },
+    handler: async (c) => {
+      const { messages, ...rest } = await c.req.json();
+      const mastra = c.get("mastra");
+      let agentToUse = agent;
+      if (!agent) {
+        const agentId = c.req.param("agentId");
+        agentToUse = agentId;
+      }
+      if (c.req.param("agentId") && agent) {
+        mastra.getLogger()?.warn(
+          `Fixed agent ID was set together with an agentId path parameter. This can lead to unexpected behavior.`
+        );
+      }
+      if (!agentToUse) {
+        throw new Error("Agent ID is required");
+      }
+      const agentObj = mastra.getAgent(agentToUse);
+      if (!agentObj) {
+        throw new Error(`Agent ${agentToUse} not found`);
+      }
+      const result = await agentObj.network(messages, {
+        ...defaultOptions,
+        ...rest
+      });
+      const uiMessageStream = ai.createUIMessageStream({
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkV5Stream(result, { from: "network" })) {
+            writer.write(part);
+          }
+        }
+      });
+      return ai.createUIMessageStreamResponse({ stream: uiMessageStream });
+    }
+  });
+}
+
+// src/to-ai-sdk-format.ts
+function toAISdkFormat() {
+  throw new Error(
+    'toAISdkFormat() has been deprecated. Please use toAISdkStream() instead.\n\nMigration:\n  import { toAISdkFormat } from "@mastra/ai-sdk";\n  // Change to:\n  import { toAISdkStream } from "@mastra/ai-sdk";\n\nThe function signature remains the same.'
+  );
+}
+
+exports.chatRoute = chatRoute;
+exports.networkRoute = networkRoute;
+exports.toAISdkFormat = toAISdkFormat;
+exports.toAISdkStream = toAISdkV5Stream;
+exports.workflowRoute = workflowRoute;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map