@mastra/ai-sdk 0.0.0-toolOptionTypes-20250917085558 → 0.0.0-unified-sidebar-20251010130811

package/dist/index.js

@@ -1,6 +1,823 @@
 import { registerApiRoute } from '@mastra/core/server';
+import { createUIMessageStream, createUIMessageStreamResponse } from 'ai';
+import { DefaultGeneratedFile, DefaultGeneratedFileWithType } from '@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 DefaultGeneratedFile({
+            data: chunk.payload.data,
+            mediaType: chunk.payload.mimeType
+          })
+        };
+      }
+      return {
+        type: "file",
+        file: new 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({
+        data: JSON.stringify({
+          type: "start",
+          messageId: "1"
+        })
+      });
+    },
+    flush(controller) {
+      controller.enqueue({
+        data: JSON.stringify({
+          type: "finish"
+        })
+      });
+      controller.enqueue({
+        data: "[DONE]"
+      });
+    },
+    transform(chunk, controller) {
+      const transformed = transformWorkflow(chunk, bufferedWorkflows);
+      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);
+          if (workflowChunk) controller.enqueue(workflowChunk);
+        } else if (transformedChunk.type === "tool-network") {
+          const payload = transformedChunk.payload;
+          const networkChunk = transformNetwork(payload, bufferedSteps);
+          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) {
+  switch (payload.type) {
+    case "workflow-start":
+      bufferedWorkflows.set(payload.runId, {
+        name: payload.payload.workflowId,
+        steps: {}
+      });
+      return {
+        type: "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: "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: "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: "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) {
+  switch (payload.type) {
+    case "routing-agent-start": {
+      bufferedNetworks.set(payload.payload.runId, {
+        name: payload.payload.agentId,
+        steps: []
+      });
+      return {
+        type: "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: "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: "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: "data-network",
+        id: payload.payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "agent-execution-end":
+    case "tool-execution-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: "data-network",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "workflow-execution-end": {
+      const current = bufferedNetworks.get(payload.runId);
+      if (!current) return null;
+      return {
+        type: "data-network",
+        id: payload.runId,
+        data: {
+          name: current.name,
+          status: "running",
+          steps: current.steps,
+          output: null
+        }
+      };
+    }
+    case "routing-agent-end": {
+      const current = bufferedNetworks.get(payload.payload.runId);
+      if (!current) return null;
+      return {
+        type: "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: "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: "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) {
+  return stream.fullStream.pipeThrough(AgentStreamToAISDKTransformer());
+}
+
+// src/chat-route.ts
 function chatRoute({
   path = "/chat/:agentId",
   agent,
@@ -122,16 +939,24 @@ 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"
+        ...rest
+      });
+      const uiMessageStream = createUIMessageStream({
+        execute: async ({ writer }) => {
+          for await (const part of toAISdkFormat(result)) {
+            writer.write(part);
+          }
+        }
+      });
+      return createUIMessageStreamResponse({
+        stream: uiMessageStream
       });
-      return result.toUIMessageStreamResponse();
     }
   });
 }
 
-export { chatRoute };
+export { WorkflowStreamToAISDKTransformer, chatRoute, toAISdkFormat };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map