assistant-stream 0.1.6 → 0.1.8

package/dist/core/serialization/data-stream/DataStream.js

@@ -0,0 +1,332 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/serialization/data-stream/DataStream.ts
+var DataStream_exports = {};
+__export(DataStream_exports, {
+  DataStreamDecoder: () => DataStreamDecoder,
+  DataStreamEncoder: () => DataStreamEncoder
+});
+module.exports = __toCommonJS(DataStream_exports);
+var import_AssistantTransformStream = require("../../utils/stream/AssistantTransformStream.js");
+var import_PipeableTransformStream = require("../../utils/stream/PipeableTransformStream.js");
+var import_chunk_types = require("./chunk-types.js");
+var import_LineDecoderStream = require("../../utils/stream/LineDecoderStream.js");
+var import_serialization = require("./serialization.js");
+var import_AssistantMetaTransformStream = require("../../utils/stream/AssistantMetaTransformStream.js");
+var DataStreamEncoder = class extends import_PipeableTransformStream.PipeableTransformStream {
+  headers = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    "x-vercel-ai-data-stream": "v1"
+  });
+  constructor() {
+    super((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const type = chunk.type;
+          switch (type) {
+            case "part-start": {
+              const part = chunk.part;
+              if (part.type === "tool-call") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: import_chunk_types.DataStreamStreamChunkType.StartToolCall,
+                  value
+                });
+              }
+              if (part.type === "source") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: import_chunk_types.DataStreamStreamChunkType.Source,
+                  value
+                });
+              }
+              break;
+            }
+            case "text-delta": {
+              const part = chunk.meta;
+              switch (part.type) {
+                case "text": {
+                  controller.enqueue({
+                    type: import_chunk_types.DataStreamStreamChunkType.TextDelta,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "reasoning": {
+                  controller.enqueue({
+                    type: import_chunk_types.DataStreamStreamChunkType.ReasoningDelta,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "tool-call": {
+                  controller.enqueue({
+                    type: import_chunk_types.DataStreamStreamChunkType.ToolCallArgsTextDelta,
+                    value: {
+                      toolCallId: part.toolCallId,
+                      argsTextDelta: chunk.textDelta
+                    }
+                  });
+                  break;
+                }
+                default:
+                  throw new Error(
+                    `Unsupported part type for text-delta: ${part.type}`
+                  );
+              }
+              break;
+            }
+            case "result": {
+              const part = chunk.meta;
+              if (part.type !== "tool-call") {
+                throw new Error(
+                  `Result chunk on non-tool-call part not supported: ${part.type}`
+                );
+              }
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.ToolCallResult,
+                value: {
+                  toolCallId: part.toolCallId,
+                  result: chunk.result,
+                  artifact: chunk.artifact,
+                  ...chunk.isError ? { isError: chunk.isError } : {}
+                }
+              });
+              break;
+            }
+            case "step-start": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.StartStep,
+                value
+              });
+              break;
+            }
+            case "step-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.FinishStep,
+                value
+              });
+              break;
+            }
+            case "message-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.FinishMessage,
+                value
+              });
+              break;
+            }
+            case "error": {
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.Error,
+                value: chunk.error
+              });
+              break;
+            }
+            case "annotations": {
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.Annotation,
+                value: chunk.annotations
+              });
+              break;
+            }
+            case "data": {
+              controller.enqueue({
+                type: import_chunk_types.DataStreamStreamChunkType.Data,
+                value: chunk.data
+              });
+              break;
+            }
+            // TODO ignore for now
+            // in the future, we should create a handler that waits for text parts to finish before continuing
+            case "tool-call-args-text-finish":
+            case "part-finish":
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`Unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        }
+      });
+      return readable.pipeThrough(new import_AssistantMetaTransformStream.AssistantMetaTransformStream()).pipeThrough(transform).pipeThrough(new import_serialization.DataStreamChunkEncoder()).pipeThrough(new TextEncoderStream());
+    });
+  }
+};
+var TOOL_CALL_ARGS_CLOSING_CHUNKS = [
+  import_chunk_types.DataStreamStreamChunkType.StartToolCall,
+  import_chunk_types.DataStreamStreamChunkType.ToolCall,
+  import_chunk_types.DataStreamStreamChunkType.TextDelta,
+  import_chunk_types.DataStreamStreamChunkType.ReasoningDelta,
+  import_chunk_types.DataStreamStreamChunkType.Source,
+  import_chunk_types.DataStreamStreamChunkType.Error,
+  import_chunk_types.DataStreamStreamChunkType.FinishStep,
+  import_chunk_types.DataStreamStreamChunkType.FinishMessage
+];
+var DataStreamDecoder = class extends import_PipeableTransformStream.PipeableTransformStream {
+  constructor() {
+    super((readable) => {
+      const toolCallControllers = /* @__PURE__ */ new Map();
+      let activeToolCallArgsText;
+      const transform = new import_AssistantTransformStream.AssistantTransformStream({
+        transform(chunk, controller) {
+          const { type, value } = chunk;
+          if (TOOL_CALL_ARGS_CLOSING_CHUNKS.includes(type)) {
+            activeToolCallArgsText?.close();
+            activeToolCallArgsText = void 0;
+          }
+          switch (type) {
+            case import_chunk_types.DataStreamStreamChunkType.ReasoningDelta:
+              controller.appendReasoning(value);
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.TextDelta:
+              controller.appendText(value);
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.StartToolCall: {
+              const { toolCallId, toolName } = value;
+              const toolCallController = controller.addToolCallPart({
+                toolCallId,
+                toolName
+              });
+              toolCallControllers.set(toolCallId, toolCallController);
+              activeToolCallArgsText = toolCallController.argsText;
+              break;
+            }
+            case import_chunk_types.DataStreamStreamChunkType.ToolCallArgsTextDelta: {
+              const { toolCallId, argsTextDelta } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call with unknown id: " + toolCallId
+                );
+              toolCallController.argsText.append(argsTextDelta);
+              break;
+            }
+            case import_chunk_types.DataStreamStreamChunkType.ToolCallResult: {
+              const { toolCallId, artifact, result, isError } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call result with unknown id: " + toolCallId
+                );
+              toolCallController.setResponse({
+                artifact,
+                result,
+                isError
+              });
+              break;
+            }
+            case import_chunk_types.DataStreamStreamChunkType.ToolCall: {
+              const { toolCallId, toolName, args } = value;
+              let toolCallController = toolCallControllers.get(toolCallId);
+              if (toolCallController) {
+                toolCallController.argsText.close();
+              } else {
+                toolCallController = controller.addToolCallPart({
+                  toolCallId,
+                  toolName,
+                  args
+                });
+                toolCallControllers.set(toolCallId, toolCallController);
+              }
+              break;
+            }
+            case import_chunk_types.DataStreamStreamChunkType.FinishMessage:
+              controller.enqueue({
+                type: "message-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.StartStep:
+              controller.enqueue({
+                type: "step-start",
+                path: [],
+                ...value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.FinishStep:
+              controller.enqueue({
+                type: "step-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.Data:
+              controller.enqueue({
+                type: "data",
+                path: [],
+                data: value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.Annotation:
+              controller.enqueue({
+                type: "annotations",
+                path: [],
+                annotations: value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.Source:
+              controller.appendSource({
+                type: "source",
+                ...value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.Error:
+              controller.enqueue({
+                type: "error",
+                path: [],
+                error: value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.File:
+              controller.appendFile({
+                type: "file",
+                ...value
+              });
+              break;
+            case import_chunk_types.DataStreamStreamChunkType.ReasoningSignature:
+            case import_chunk_types.DataStreamStreamChunkType.RedactedReasoning:
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        },
+        flush() {
+          activeToolCallArgsText?.close();
+          activeToolCallArgsText = void 0;
+          toolCallControllers.forEach((controller) => controller.close());
+          toolCallControllers.clear();
+        }
+      });
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new import_LineDecoderStream.LineDecoderStream()).pipeThrough(new import_serialization.DataStreamChunkDecoder()).pipeThrough(transform);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataStreamDecoder,
+  DataStreamEncoder
+});
+//# sourceMappingURL=DataStream.js.map

package/dist/core/serialization/data-stream/DataStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/serialization/data-stream/DataStream.ts"],"sourcesContent":["import { AssistantStreamChunk } from \"../../AssistantStreamChunk\";\nimport { ToolCallStreamController } from \"../../modules/tool-call\";\nimport { AssistantTransformStream } from \"../../utils/stream/AssistantTransformStream\";\nimport { PipeableTransformStream } from \"../../utils/stream/PipeableTransformStream\";\nimport { DataStreamChunk, DataStreamStreamChunkType } from \"./chunk-types\";\nimport { LineDecoderStream } from \"../../utils/stream/LineDecoderStream\";\nimport {\n  DataStreamChunkDecoder,\n  DataStreamChunkEncoder,\n} from \"./serialization\";\nimport {\n  AssistantMetaStreamChunk,\n  AssistantMetaTransformStream,\n} from \"../../utils/stream/AssistantMetaTransformStream\";\nimport { TextStreamController } from \"../../modules/text\";\nimport { AssistantStreamEncoder } from \"../../AssistantStream\";\n\nexport class DataStreamEncoder\n  extends PipeableTransformStream<AssistantStreamChunk, Uint8Array>\n  implements AssistantStreamEncoder\n{\n  headers = new Headers({\n    \"Content-Type\": \"text/plain; charset=utf-8\",\n    \"x-vercel-ai-data-stream\": \"v1\",\n  });\n\n  constructor() {\n    super((readable) => {\n      const transform = new TransformStream<\n        AssistantMetaStreamChunk,\n        DataStreamChunk\n      >({\n        transform(chunk, controller) {\n          const type = chunk.type;\n          switch (type) {\n            case \"part-start\": {\n              const part = chunk.part;\n              if (part.type === \"tool-call\") {\n                const { type, ...value } = part;\n                controller.enqueue({\n                  type: DataStreamStreamChunkType.StartToolCall,\n                  value,\n                });\n              }\n              if (part.type === \"source\") {\n                const { type, ...value } = part;\n                controller.enqueue({\n                  type: DataStreamStreamChunkType.Source,\n                  value,\n                });\n              }\n              break;\n            }\n            case \"text-delta\": {\n              const part = chunk.meta;\n              switch (part.type) {\n                case \"text\": {\n                  controller.enqueue({\n                    type: DataStreamStreamChunkType.TextDelta,\n                    value: chunk.textDelta,\n                  });\n                  break;\n                }\n                case \"reasoning\": {\n                  controller.enqueue({\n                    type: DataStreamStreamChunkType.ReasoningDelta,\n                    value: chunk.textDelta,\n                  });\n                  break;\n                }\n                case \"tool-call\": {\n                  controller.enqueue({\n                    type: DataStreamStreamChunkType.ToolCallArgsTextDelta,\n                    value: {\n                      toolCallId: part.toolCallId,\n                      argsTextDelta: chunk.textDelta,\n                    },\n                  });\n                  break;\n                }\n                default:\n                  throw new Error(\n                    `Unsupported part type for text-delta: ${part.type}`,\n                  );\n              }\n              break;\n            }\n            case \"result\": {\n              // Only tool-call parts can have results.\n              const part = chunk.meta;\n              if (part.type !== \"tool-call\") {\n                throw new Error(\n                  `Result chunk on non-tool-call part not supported: ${part.type}`,\n                );\n              }\n              controller.enqueue({\n                type: DataStreamStreamChunkType.ToolCallResult,\n                value: {\n                  toolCallId: part.toolCallId,\n                  result: chunk.result,\n                  artifact: chunk.artifact,\n                  ...(chunk.isError ? { isError: chunk.isError } : {}),\n                },\n              });\n              break;\n            }\n            case \"step-start\": {\n              const { type, ...value } = chunk;\n              controller.enqueue({\n                type: DataStreamStreamChunkType.StartStep,\n                value,\n              });\n              break;\n            }\n            case \"step-finish\": {\n              const { type, ...value } = chunk;\n              controller.enqueue({\n                type: DataStreamStreamChunkType.FinishStep,\n                value,\n              });\n              break;\n            }\n            case \"message-finish\": {\n              const { type, ...value } = chunk;\n              controller.enqueue({\n                type: DataStreamStreamChunkType.FinishMessage,\n                value,\n              });\n              break;\n            }\n            case \"error\": {\n              controller.enqueue({\n                type: DataStreamStreamChunkType.Error,\n                value: chunk.error,\n              });\n              break;\n            }\n            case \"annotations\": {\n              controller.enqueue({\n                type: DataStreamStreamChunkType.Annotation,\n                value: chunk.annotations,\n              });\n              break;\n            }\n            case \"data\": {\n              controller.enqueue({\n                type: DataStreamStreamChunkType.Data,\n                value: chunk.data,\n              });\n              break;\n            }\n\n            // TODO ignore for now\n            // in the future, we should create a handler that waits for text parts to finish before continuing\n            case \"tool-call-args-text-finish\":\n            case \"part-finish\":\n              break;\n\n            default: {\n              const exhaustiveCheck: never = type;\n              throw new Error(`Unsupported chunk type: ${exhaustiveCheck}`);\n            }\n          }\n        },\n      });\n\n      return readable\n        .pipeThrough(new AssistantMetaTransformStream())\n        .pipeThrough(transform)\n        .pipeThrough(new DataStreamChunkEncoder())\n        .pipeThrough(new TextEncoderStream());\n    });\n  }\n}\n\nconst TOOL_CALL_ARGS_CLOSING_CHUNKS = [\n  DataStreamStreamChunkType.StartToolCall,\n  DataStreamStreamChunkType.ToolCall,\n  DataStreamStreamChunkType.TextDelta,\n  DataStreamStreamChunkType.ReasoningDelta,\n  DataStreamStreamChunkType.Source,\n  DataStreamStreamChunkType.Error,\n  DataStreamStreamChunkType.FinishStep,\n  DataStreamStreamChunkType.FinishMessage,\n];\n\nexport class DataStreamDecoder extends PipeableTransformStream<\n  Uint8Array,\n  AssistantStreamChunk\n> {\n  constructor() {\n    super((readable) => {\n      const toolCallControllers = new Map<string, ToolCallStreamController>();\n      let activeToolCallArgsText: TextStreamController | undefined;\n      const transform = new AssistantTransformStream<DataStreamChunk>({\n        transform(chunk, controller) {\n          const { type, value } = chunk;\n\n          if (TOOL_CALL_ARGS_CLOSING_CHUNKS.includes(type)) {\n            activeToolCallArgsText?.close();\n            activeToolCallArgsText = undefined;\n          }\n\n          switch (type) {\n            case DataStreamStreamChunkType.ReasoningDelta:\n              controller.appendReasoning(value);\n              break;\n\n            case DataStreamStreamChunkType.TextDelta:\n              controller.appendText(value);\n              break;\n\n            case DataStreamStreamChunkType.StartToolCall: {\n              const { toolCallId, toolName } = value;\n              const toolCallController = controller.addToolCallPart({\n                toolCallId,\n                toolName,\n              });\n              toolCallControllers.set(toolCallId, toolCallController);\n\n              activeToolCallArgsText = toolCallController.argsText;\n              break;\n            }\n\n            case DataStreamStreamChunkType.ToolCallArgsTextDelta: {\n              const { toolCallId, argsTextDelta } = value;\n              const toolCallController = toolCallControllers.get(toolCallId);\n              if (!toolCallController)\n                throw new Error(\n                  \"Encountered tool call with unknown id: \" + toolCallId,\n                );\n              toolCallController.argsText.append(argsTextDelta);\n              break;\n            }\n\n            case DataStreamStreamChunkType.ToolCallResult: {\n              const { toolCallId, artifact, result, isError } = value;\n              const toolCallController = toolCallControllers.get(toolCallId);\n              if (!toolCallController)\n                throw new Error(\n                  \"Encountered tool call result with unknown id: \" + toolCallId,\n                );\n              toolCallController.setResponse({\n                artifact,\n                result,\n                isError,\n              });\n              break;\n            }\n\n            case DataStreamStreamChunkType.ToolCall: {\n              const { toolCallId, toolName, args } = value;\n\n              let toolCallController = toolCallControllers.get(toolCallId);\n              if (toolCallController) {\n                toolCallController.argsText.close();\n              } else {\n                toolCallController = controller.addToolCallPart({\n                  toolCallId,\n                  toolName,\n                  args,\n                });\n                toolCallControllers.set(toolCallId, toolCallController);\n              }\n              break;\n            }\n\n            case DataStreamStreamChunkType.FinishMessage:\n              controller.enqueue({\n                type: \"message-finish\",\n                path: [],\n                ...value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.StartStep:\n              controller.enqueue({\n                type: \"step-start\",\n                path: [],\n                ...value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.FinishStep:\n              controller.enqueue({\n                type: \"step-finish\",\n                path: [],\n                ...value,\n              });\n              break;\n            case DataStreamStreamChunkType.Data:\n              controller.enqueue({\n                type: \"data\",\n                path: [],\n                data: value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.Annotation:\n              controller.enqueue({\n                type: \"annotations\",\n                path: [],\n                annotations: value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.Source:\n              controller.appendSource({\n                type: \"source\",\n                ...value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.Error:\n              controller.enqueue({\n                type: \"error\",\n                path: [],\n                error: value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.File:\n              controller.appendFile({\n                type: \"file\",\n                ...value,\n              });\n              break;\n\n            case DataStreamStreamChunkType.ReasoningSignature:\n            case DataStreamStreamChunkType.RedactedReasoning:\n              // ignore these for now\n              break;\n\n            default: {\n              const exhaustiveCheck: never = type;\n              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);\n            }\n          }\n        },\n        flush() {\n          activeToolCallArgsText?.close();\n          activeToolCallArgsText = undefined;\n          toolCallControllers.forEach((controller) => controller.close());\n          toolCallControllers.clear();\n        },\n      });\n\n      return readable\n        .pipeThrough(new TextDecoderStream())\n        .pipeThrough(new LineDecoderStream())\n        .pipeThrough(new DataStreamChunkDecoder())\n        .pipeThrough(transform);\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,sCAAyC;AACzC,qCAAwC;AACxC,yBAA2D;AAC3D,+BAAkC;AAClC,2BAGO;AACP,0CAGO;AAIA,IAAM,oBAAN,cACG,uDAEV;AAAA,EACE,UAAU,IAAI,QAAQ;AAAA,IACpB,gBAAgB;AAAA,IAChB,2BAA2B;AAAA,EAC7B,CAAC;AAAA,EAED,cAAc;AACZ,UAAM,CAAC,aAAa;AAClB,YAAM,YAAY,IAAI,gBAGpB;AAAA,QACA,UAAU,OAAO,YAAY;AAC3B,gBAAM,OAAO,MAAM;AACnB,kBAAQ,MAAM;AAAA,YACZ,KAAK,cAAc;AACjB,oBAAM,OAAO,MAAM;AACnB,kBAAI,KAAK,SAAS,aAAa;AAC7B,sBAAM,EAAE,MAAAA,OAAM,GAAG,MAAM,IAAI;AAC3B,2BAAW,QAAQ;AAAA,kBACjB,MAAM,6CAA0B;AAAA,kBAChC;AAAA,gBACF,CAAC;AAAA,cACH;AACA,kBAAI,KAAK,SAAS,UAAU;AAC1B,sBAAM,EAAE,MAAAA,OAAM,GAAG,MAAM,IAAI;AAC3B,2BAAW,QAAQ;AAAA,kBACjB,MAAM,6CAA0B;AAAA,kBAChC;AAAA,gBACF,CAAC;AAAA,cACH;AACA;AAAA,YACF;AAAA,YACA,KAAK,cAAc;AACjB,oBAAM,OAAO,MAAM;AACnB,sBAAQ,KAAK,MAAM;AAAA,gBACjB,KAAK,QAAQ;AACX,6BAAW,QAAQ;AAAA,oBACjB,MAAM,6CAA0B;AAAA,oBAChC,OAAO,MAAM;AAAA,kBACf,CAAC;AACD;AAAA,gBACF;AAAA,gBACA,KAAK,aAAa;AAChB,6BAAW,QAAQ;AAAA,oBACjB,MAAM,6CAA0B;AAAA,oBAChC,OAAO,MAAM;AAAA,kBACf,CAAC;AACD;AAAA,gBACF;AAAA,gBACA,KAAK,aAAa;AAChB,6BAAW,QAAQ;AAAA,oBACjB,MAAM,6CAA0B;AAAA,oBAChC,OAAO;AAAA,sBACL,YAAY,KAAK;AAAA,sBACjB,eAAe,MAAM;AAAA,oBACvB;AAAA,kBACF,CAAC;AACD;AAAA,gBACF;AAAA,gBACA;AACE,wBAAM,IAAI;AAAA,oBACR,yCAAyC,KAAK,IAAI;AAAA,kBACpD;AAAA,cACJ;AACA;AAAA,YACF;AAAA,YACA,KAAK,UAAU;AAEb,oBAAM,OAAO,MAAM;AACnB,kBAAI,KAAK,SAAS,aAAa;AAC7B,sBAAM,IAAI;AAAA,kBACR,qDAAqD,KAAK,IAAI;AAAA,gBAChE;AAAA,cACF;AACA,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC,OAAO;AAAA,kBACL,YAAY,KAAK;AAAA,kBACjB,QAAQ,MAAM;AAAA,kBACd,UAAU,MAAM;AAAA,kBAChB,GAAI,MAAM,UAAU,EAAE,SAAS,MAAM,QAAQ,IAAI,CAAC;AAAA,gBACpD;AAAA,cACF,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,cAAc;AACjB,oBAAM,EAAE,MAAAA,OAAM,GAAG,MAAM,IAAI;AAC3B,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC;AAAA,cACF,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,eAAe;AAClB,oBAAM,EAAE,MAAAA,OAAM,GAAG,MAAM,IAAI;AAC3B,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC;AAAA,cACF,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,kBAAkB;AACrB,oBAAM,EAAE,MAAAA,OAAM,GAAG,MAAM,IAAI;AAC3B,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC;AAAA,cACF,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,SAAS;AACZ,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC,OAAO,MAAM;AAAA,cACf,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,eAAe;AAClB,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC,OAAO,MAAM;AAAA,cACf,CAAC;AACD;AAAA,YACF;AAAA,YACA,KAAK,QAAQ;AACX,yBAAW,QAAQ;AAAA,gBACjB,MAAM,6CAA0B;AAAA,gBAChC,OAAO,MAAM;AAAA,cACf,CAAC;AACD;AAAA,YACF;AAAA;AAAA;AAAA,YAIA,KAAK;AAAA,YACL,KAAK;AACH;AAAA,YAEF,SAAS;AACP,oBAAM,kBAAyB;AAC/B,oBAAM,IAAI,MAAM,2BAA2B,eAAe,EAAE;AAAA,YAC9D;AAAA,UACF;AAAA,QACF;AAAA,MACF,CAAC;AAED,aAAO,SACJ,YAAY,IAAI,iEAA6B,CAAC,EAC9C,YAAY,SAAS,EACrB,YAAY,IAAI,4CAAuB,CAAC,EACxC,YAAY,IAAI,kBAAkB,CAAC;AAAA,IACxC,CAAC;AAAA,EACH;AACF;AAEA,IAAM,gCAAgC;AAAA,EACpC,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAAA,EAC1B,6CAA0B;AAC5B;AAEO,IAAM,oBAAN,cAAgC,uDAGrC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,aAAa;AAClB,YAAM,sBAAsB,oBAAI,IAAsC;AACtE,UAAI;AACJ,YAAM,YAAY,IAAI,yDAA0C;AAAA,QAC9D,UAAU,OAAO,YAAY;AAC3B,gBAAM,EAAE,MAAM,MAAM,IAAI;AAExB,cAAI,8BAA8B,SAAS,IAAI,GAAG;AAChD,oCAAwB,MAAM;AAC9B,qCAAyB;AAAA,UAC3B;AAEA,kBAAQ,MAAM;AAAA,YACZ,KAAK,6CAA0B;AAC7B,yBAAW,gBAAgB,KAAK;AAChC;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,WAAW,KAAK;AAC3B;AAAA,YAEF,KAAK,6CAA0B,eAAe;AAC5C,oBAAM,EAAE,YAAY,SAAS,IAAI;AACjC,oBAAM,qBAAqB,WAAW,gBAAgB;AAAA,gBACpD;AAAA,gBACA;AAAA,cACF,CAAC;AACD,kCAAoB,IAAI,YAAY,kBAAkB;AAEtD,uCAAyB,mBAAmB;AAC5C;AAAA,YACF;AAAA,YAEA,KAAK,6CAA0B,uBAAuB;AACpD,oBAAM,EAAE,YAAY,cAAc,IAAI;AACtC,oBAAM,qBAAqB,oBAAoB,IAAI,UAAU;AAC7D,kBAAI,CAAC;AACH,sBAAM,IAAI;AAAA,kBACR,4CAA4C;AAAA,gBAC9C;AACF,iCAAmB,SAAS,OAAO,aAAa;AAChD;AAAA,YACF;AAAA,YAEA,KAAK,6CAA0B,gBAAgB;AAC7C,oBAAM,EAAE,YAAY,UAAU,QAAQ,QAAQ,IAAI;AAClD,oBAAM,qBAAqB,oBAAoB,IAAI,UAAU;AAC7D,kBAAI,CAAC;AACH,sBAAM,IAAI;AAAA,kBACR,mDAAmD;AAAA,gBACrD;AACF,iCAAmB,YAAY;AAAA,gBAC7B;AAAA,gBACA;AAAA,gBACA;AAAA,cACF,CAAC;AACD;AAAA,YACF;AAAA,YAEA,KAAK,6CAA0B,UAAU;AACvC,oBAAM,EAAE,YAAY,UAAU,KAAK,IAAI;AAEvC,kBAAI,qBAAqB,oBAAoB,IAAI,UAAU;AAC3D,kBAAI,oBAAoB;AACtB,mCAAmB,SAAS,MAAM;AAAA,cACpC,OAAO;AACL,qCAAqB,WAAW,gBAAgB;AAAA,kBAC9C;AAAA,kBACA;AAAA,kBACA;AAAA,gBACF,CAAC;AACD,oCAAoB,IAAI,YAAY,kBAAkB;AAAA,cACxD;AACA;AAAA,YACF;AAAA,YAEA,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,GAAG;AAAA,cACL,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,GAAG;AAAA,cACL,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,GAAG;AAAA,cACL,CAAC;AACD;AAAA,YACF,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,MAAM;AAAA,cACR,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,aAAa;AAAA,cACf,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,aAAa;AAAA,gBACtB,MAAM;AAAA,gBACN,GAAG;AAAA,cACL,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,QAAQ;AAAA,gBACjB,MAAM;AAAA,gBACN,MAAM,CAAC;AAAA,gBACP,OAAO;AAAA,cACT,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAC7B,yBAAW,WAAW;AAAA,gBACpB,MAAM;AAAA,gBACN,GAAG;AAAA,cACL,CAAC;AACD;AAAA,YAEF,KAAK,6CAA0B;AAAA,YAC/B,KAAK,6CAA0B;AAE7B;AAAA,YAEF,SAAS;AACP,oBAAM,kBAAyB;AAC/B,oBAAM,IAAI,MAAM,2BAA2B,eAAe,EAAE;AAAA,YAC9D;AAAA,UACF;AAAA,QACF;AAAA,QACA,QAAQ;AACN,kCAAwB,MAAM;AAC9B,mCAAyB;AACzB,8BAAoB,QAAQ,CAAC,eAAe,WAAW,MAAM,CAAC;AAC9D,8BAAoB,MAAM;AAAA,QAC5B;AAAA,MACF,CAAC;AAED,aAAO,SACJ,YAAY,IAAI,kBAAkB,CAAC,EACnC,YAAY,IAAI,2CAAkB,CAAC,EACnC,YAAY,IAAI,4CAAuB,CAAC,EACxC,YAAY,SAAS;AAAA,IAC1B,CAAC;AAAA,EACH;AACF;","names":["type"]}

package/dist/core/serialization/data-stream/DataStream.mjs

@@ -0,0 +1,311 @@
+// src/core/serialization/data-stream/DataStream.ts
+import { AssistantTransformStream } from "../../utils/stream/AssistantTransformStream.mjs";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream.mjs";
+import { DataStreamStreamChunkType } from "./chunk-types.mjs";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream.mjs";
+import {
+  DataStreamChunkDecoder,
+  DataStreamChunkEncoder
+} from "./serialization.mjs";
+import {
+  AssistantMetaTransformStream
+} from "../../utils/stream/AssistantMetaTransformStream.mjs";
+var DataStreamEncoder = class extends PipeableTransformStream {
+  headers = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    "x-vercel-ai-data-stream": "v1"
+  });
+  constructor() {
+    super((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const type = chunk.type;
+          switch (type) {
+            case "part-start": {
+              const part = chunk.part;
+              if (part.type === "tool-call") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: DataStreamStreamChunkType.StartToolCall,
+                  value
+                });
+              }
+              if (part.type === "source") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: DataStreamStreamChunkType.Source,
+                  value
+                });
+              }
+              break;
+            }
+            case "text-delta": {
+              const part = chunk.meta;
+              switch (part.type) {
+                case "text": {
+                  controller.enqueue({
+                    type: DataStreamStreamChunkType.TextDelta,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "reasoning": {
+                  controller.enqueue({
+                    type: DataStreamStreamChunkType.ReasoningDelta,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "tool-call": {
+                  controller.enqueue({
+                    type: DataStreamStreamChunkType.ToolCallArgsTextDelta,
+                    value: {
+                      toolCallId: part.toolCallId,
+                      argsTextDelta: chunk.textDelta
+                    }
+                  });
+                  break;
+                }
+                default:
+                  throw new Error(
+                    `Unsupported part type for text-delta: ${part.type}`
+                  );
+              }
+              break;
+            }
+            case "result": {
+              const part = chunk.meta;
+              if (part.type !== "tool-call") {
+                throw new Error(
+                  `Result chunk on non-tool-call part not supported: ${part.type}`
+                );
+              }
+              controller.enqueue({
+                type: DataStreamStreamChunkType.ToolCallResult,
+                value: {
+                  toolCallId: part.toolCallId,
+                  result: chunk.result,
+                  artifact: chunk.artifact,
+                  ...chunk.isError ? { isError: chunk.isError } : {}
+                }
+              });
+              break;
+            }
+            case "step-start": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: DataStreamStreamChunkType.StartStep,
+                value
+              });
+              break;
+            }
+            case "step-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: DataStreamStreamChunkType.FinishStep,
+                value
+              });
+              break;
+            }
+            case "message-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: DataStreamStreamChunkType.FinishMessage,
+                value
+              });
+              break;
+            }
+            case "error": {
+              controller.enqueue({
+                type: DataStreamStreamChunkType.Error,
+                value: chunk.error
+              });
+              break;
+            }
+            case "annotations": {
+              controller.enqueue({
+                type: DataStreamStreamChunkType.Annotation,
+                value: chunk.annotations
+              });
+              break;
+            }
+            case "data": {
+              controller.enqueue({
+                type: DataStreamStreamChunkType.Data,
+                value: chunk.data
+              });
+              break;
+            }
+            // TODO ignore for now
+            // in the future, we should create a handler that waits for text parts to finish before continuing
+            case "tool-call-args-text-finish":
+            case "part-finish":
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`Unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        }
+      });
+      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform).pipeThrough(new DataStreamChunkEncoder()).pipeThrough(new TextEncoderStream());
+    });
+  }
+};
+var TOOL_CALL_ARGS_CLOSING_CHUNKS = [
+  DataStreamStreamChunkType.StartToolCall,
+  DataStreamStreamChunkType.ToolCall,
+  DataStreamStreamChunkType.TextDelta,
+  DataStreamStreamChunkType.ReasoningDelta,
+  DataStreamStreamChunkType.Source,
+  DataStreamStreamChunkType.Error,
+  DataStreamStreamChunkType.FinishStep,
+  DataStreamStreamChunkType.FinishMessage
+];
+var DataStreamDecoder = class extends PipeableTransformStream {
+  constructor() {
+    super((readable) => {
+      const toolCallControllers = /* @__PURE__ */ new Map();
+      let activeToolCallArgsText;
+      const transform = new AssistantTransformStream({
+        transform(chunk, controller) {
+          const { type, value } = chunk;
+          if (TOOL_CALL_ARGS_CLOSING_CHUNKS.includes(type)) {
+            activeToolCallArgsText?.close();
+            activeToolCallArgsText = void 0;
+          }
+          switch (type) {
+            case DataStreamStreamChunkType.ReasoningDelta:
+              controller.appendReasoning(value);
+              break;
+            case DataStreamStreamChunkType.TextDelta:
+              controller.appendText(value);
+              break;
+            case DataStreamStreamChunkType.StartToolCall: {
+              const { toolCallId, toolName } = value;
+              const toolCallController = controller.addToolCallPart({
+                toolCallId,
+                toolName
+              });
+              toolCallControllers.set(toolCallId, toolCallController);
+              activeToolCallArgsText = toolCallController.argsText;
+              break;
+            }
+            case DataStreamStreamChunkType.ToolCallArgsTextDelta: {
+              const { toolCallId, argsTextDelta } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call with unknown id: " + toolCallId
+                );
+              toolCallController.argsText.append(argsTextDelta);
+              break;
+            }
+            case DataStreamStreamChunkType.ToolCallResult: {
+              const { toolCallId, artifact, result, isError } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call result with unknown id: " + toolCallId
+                );
+              toolCallController.setResponse({
+                artifact,
+                result,
+                isError
+              });
+              break;
+            }
+            case DataStreamStreamChunkType.ToolCall: {
+              const { toolCallId, toolName, args } = value;
+              let toolCallController = toolCallControllers.get(toolCallId);
+              if (toolCallController) {
+                toolCallController.argsText.close();
+              } else {
+                toolCallController = controller.addToolCallPart({
+                  toolCallId,
+                  toolName,
+                  args
+                });
+                toolCallControllers.set(toolCallId, toolCallController);
+              }
+              break;
+            }
+            case DataStreamStreamChunkType.FinishMessage:
+              controller.enqueue({
+                type: "message-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case DataStreamStreamChunkType.StartStep:
+              controller.enqueue({
+                type: "step-start",
+                path: [],
+                ...value
+              });
+              break;
+            case DataStreamStreamChunkType.FinishStep:
+              controller.enqueue({
+                type: "step-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case DataStreamStreamChunkType.Data:
+              controller.enqueue({
+                type: "data",
+                path: [],
+                data: value
+              });
+              break;
+            case DataStreamStreamChunkType.Annotation:
+              controller.enqueue({
+                type: "annotations",
+                path: [],
+                annotations: value
+              });
+              break;
+            case DataStreamStreamChunkType.Source:
+              controller.appendSource({
+                type: "source",
+                ...value
+              });
+              break;
+            case DataStreamStreamChunkType.Error:
+              controller.enqueue({
+                type: "error",
+                path: [],
+                error: value
+              });
+              break;
+            case DataStreamStreamChunkType.File:
+              controller.appendFile({
+                type: "file",
+                ...value
+              });
+              break;
+            case DataStreamStreamChunkType.ReasoningSignature:
+            case DataStreamStreamChunkType.RedactedReasoning:
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        },
+        flush() {
+          activeToolCallArgsText?.close();
+          activeToolCallArgsText = void 0;
+          toolCallControllers.forEach((controller) => controller.close());
+          toolCallControllers.clear();
+        }
+      });
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new LineDecoderStream()).pipeThrough(new DataStreamChunkDecoder()).pipeThrough(transform);
+    });
+  }
+};
+export {
+  DataStreamDecoder,
+  DataStreamEncoder
+};
+//# sourceMappingURL=DataStream.mjs.map