@mastra/ai-sdk 0.0.0-toolOptionTypes-20250917085558 → 0.0.0-usechat-duplicate-20251016110554

package/dist/index.cjs

@@ -1,8 +1,877 @@
 'use strict';
 
 var server = require('@mastra/core/server');
+var ai = require('ai');
+var stream = require('@mastra/core/stream');
 
-// src/index.ts
+// src/chat-route.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 || {}
+        };
+      }
+      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: {
+      const exhaustiveCheck = partType;
+      throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// 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() {
+  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: chunk.runId,
+        onError() {
+          return "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
+      };
+      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-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:
+      return null;
+  }
+}
+function transformNetwork(payload, bufferedNetworks, isNested) {
+  switch (payload.type) {
+    case "routing-agent-start": {
+      if (!bufferedNetworks.has(payload.payload.runId)) {
+        bufferedNetworks.set(payload.payload.runId, {
+          name: payload.payload.agentId,
+          steps: []
+        });
+      }
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: bufferedNetworks.get(payload.payload.runId).name,
+          status: "running",
+          steps: bufferedNetworks.get(payload.payload.runId).steps,
+          output: null
+        }
+      };
+    }
+    case "agent-execution-start": {
+      const current = bufferedNetworks.get(payload.payload.runId) || { name: "", steps: [] };
+      current.steps.push({
+        name: payload.payload.agentId,
+        status: "running",
+        input: payload.payload.args || null,
+        output: null
+      });
+      bufferedNetworks.set(payload.payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "workflow-execution-start": {
+      const current = bufferedNetworks.get(payload.payload.runId) || { name: "", steps: [] };
+      current.steps.push({
+        name: payload.payload.name,
+        status: "running",
+        input: payload.payload.args || null,
+        output: null
+      });
+      bufferedNetworks.set(payload.payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "tool-execution-start": {
+      const current = bufferedNetworks.get(payload.payload.runId) || { name: "", steps: [] };
+      current.steps.push({
+        name: payload.payload.args?.toolName,
+        status: "running",
+        input: payload.payload.args?.args || null,
+        output: null
+      });
+      bufferedNetworks.set(payload.payload.runId, current);
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    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
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: payload.payload.result ?? null
+        }
+      };
+    }
+    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
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: payload.payload.result ?? null
+        }
+      };
+    }
+    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
+      });
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: payload.payload.result ?? null
+        }
+      };
+    }
+    case "routing-agent-end": {
+      const current = bufferedNetworks.get(payload.payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "finished",
+          steps: current.steps,
+          output: payload.payload?.result ?? null
+        }
+      };
+    }
+    case "network-execution-event-step-finish": {
+      const current = bufferedNetworks.get(payload.payload.runId);
+      if (!current) return null;
+      return {
+        type: isNested ? "data-tool-network" : "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "finished",
+          steps: current.steps,
+          output: payload.payload?.result ?? null
+        }
+      };
+    }
+    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: {
+          name: current.name,
+          status: "finished",
+          steps: current.steps,
+          output: payload.payload?.result ?? null
+        }
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/to-ai-sdk-format.ts
+function toAISdkFormat(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());
+}
+
+// src/chat-route.ts
 function chatRoute({
   path = "/chat/:agentId",
   agent,
@@ -107,6 +976,7 @@ function chatRoute({
     handler: async (c) => {
       const { messages, ...rest } = await c.req.json();
       const mastra = c.get("mastra");
+      const runtimeContext = c.get("runtimeContext");
       let agentToUse = agent;
       if (!agent) {
         const agentId = c.req.param("agentId");
@@ -117,6 +987,9 @@ function chatRoute({
           `Fixed agent ID was set together with an agentId path parameter. This can lead to unexpected behavior.`
         );
       }
+      if (runtimeContext && defaultOptions?.runtimeContext) {
+        mastra.getLogger()?.warn(`"runtimeContext" set in the route options will be overridden by the request's "runtimeContext".`);
+      }
       if (!agentToUse) {
         throw new Error("Agent ID is required");
       }
@@ -124,16 +997,205 @@ function chatRoute({
       if (!agentObj) {
         throw new Error(`Agent ${agentToUse} not found`);
       }
-      const result = await agentObj.streamVNext(messages, {
+      const result = await agentObj.stream(messages, {
         ...defaultOptions,
         ...rest,
-        format: "aisdk"
+        runtimeContext: runtimeContext || defaultOptions?.runtimeContext
+      });
+      const uiMessageStream = ai.createUIMessageStream({
+        originalMessages: messages,
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkFormat(result, { from: "agent" })) {
+            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 },
+                runtimeContext: { 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, ...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.createRunAsync();
+      const stream = run.streamVNext({ inputData, ...rest });
+      const uiMessageStream = ai.createUIMessageStream({
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkFormat(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" } },
+                runtimeContext: { type: "object", additionalProperties: true },
+                runId: { type: "string" },
+                maxSteps: { type: "number" },
+                threadId: { type: "string" },
+                resourceId: { type: "string" },
+                modelSettings: { type: "object", additionalProperties: true },
+                telemetry: { 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 toAISdkFormat(result, { from: "network" })) {
+            writer.write(part);
+          }
+        }
       });
-      return result.toUIMessageStreamResponse();
+      return ai.createUIMessageStreamResponse({ stream: uiMessageStream });
     }
   });
 }
 
 exports.chatRoute = chatRoute;
+exports.networkRoute = networkRoute;
+exports.toAISdkFormat = toAISdkFormat;
+exports.workflowRoute = workflowRoute;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map