assistant-stream 0.1.5 → 0.1.7

package/dist/core/utils/stream/AssistantMetaTransformStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/AssistantMetaTransformStream.ts"],"sourcesContent":["import { AssistantStreamChunk, PartInit } from \"../../AssistantStreamChunk\";\n\n/**\n * For chunk types that are associated with a part,\n * we require a non‑nullable meta field.\n */\nexport type AssistantMetaStreamChunk =\n  | (AssistantStreamChunk & {\n      type: \"text-delta\" | \"part-finish\";\n      meta: PartInit;\n    })\n  | (AssistantStreamChunk & {\n      type: \"result\" | \"tool-call-args-text-finish\";\n      meta: PartInit & { type: \"tool-call\" };\n    })\n  | (AssistantStreamChunk & {\n      type: Exclude<\n        AssistantStreamChunk[\"type\"],\n        \"text-delta\" | \"result\" | \"tool-call-args-text-finish\" | \"part-finish\"\n      >;\n    });\nexport class AssistantMetaTransformStream extends TransformStream<\n  AssistantStreamChunk,\n  AssistantMetaStreamChunk\n> {\n  constructor() {\n    // We use an array to record parts as they are introduced.\n    const parts: PartInit[] = [];\n\n    super({\n      transform(chunk, controller) {\n        // For chunks that introduce a new part.\n        if (chunk.type === \"part-start\") {\n          if (chunk.path.length !== 0) {\n            controller.error(new Error(\"Nested parts are not supported\"));\n            return;\n          }\n          parts.push(chunk.part);\n          controller.enqueue(chunk);\n          return;\n        }\n\n        // For chunks that expect an associated part.\n        if (\n          chunk.type === \"text-delta\" ||\n          chunk.type === \"result\" ||\n          chunk.type === \"part-finish\" ||\n          chunk.type === \"tool-call-args-text-finish\"\n        ) {\n          if (chunk.path.length !== 1) {\n            controller.error(\n              new Error(`${chunk.type} chunks must have a path of length 1`),\n            );\n            return;\n          }\n          const idx = chunk.path[0]!;\n          if (idx < 0 || idx >= parts.length) {\n            controller.error(new Error(`Invalid path index: ${idx}`));\n            return;\n          }\n          const part = parts[idx]!;\n\n          controller.enqueue({\n            ...chunk,\n            meta: part as any, // TODO\n          });\n          return;\n        }\n\n        controller.enqueue(chunk);\n      },\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,IAAM,+BAAN,cAA2C,gBAGhD;AAAA,EACA,cAAc;AAEZ,UAAM,QAAoB,CAAC;AAE3B,UAAM;AAAA,MACJ,UAAU,OAAO,YAAY;AAE3B,YAAI,MAAM,SAAS,cAAc;AAC/B,cAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,uBAAW,MAAM,IAAI,MAAM,gCAAgC,CAAC;AAC5D;AAAA,UACF;AACA,gBAAM,KAAK,MAAM,IAAI;AACrB,qBAAW,QAAQ,KAAK;AACxB;AAAA,QACF;AAGA,YACE,MAAM,SAAS,gBACf,MAAM,SAAS,YACf,MAAM,SAAS,iBACf,MAAM,SAAS,8BACf;AACA,cAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,uBAAW;AAAA,cACT,IAAI,MAAM,GAAG,MAAM,IAAI,sCAAsC;AAAA,YAC/D;AACA;AAAA,UACF;AACA,gBAAM,MAAM,MAAM,KAAK,CAAC;AACxB,cAAI,MAAM,KAAK,OAAO,MAAM,QAAQ;AAClC,uBAAW,MAAM,IAAI,MAAM,uBAAuB,GAAG,EAAE,CAAC;AACxD;AAAA,UACF;AACA,gBAAM,OAAO,MAAM,GAAG;AAEtB,qBAAW,QAAQ;AAAA,YACjB,GAAG;AAAA,YACH,MAAM;AAAA;AAAA,UACR,CAAC;AACD;AAAA,QACF;AAEA,mBAAW,QAAQ,KAAK;AAAA,MAC1B;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/AssistantMetaTransformStream.mjs

@@ -0,0 +1,44 @@
+// src/core/utils/stream/AssistantMetaTransformStream.ts
+var AssistantMetaTransformStream = class extends TransformStream {
+  constructor() {
+    const parts = [];
+    super({
+      transform(chunk, controller) {
+        if (chunk.type === "part-start") {
+          if (chunk.path.length !== 0) {
+            controller.error(new Error("Nested parts are not supported"));
+            return;
+          }
+          parts.push(chunk.part);
+          controller.enqueue(chunk);
+          return;
+        }
+        if (chunk.type === "text-delta" || chunk.type === "result" || chunk.type === "part-finish" || chunk.type === "tool-call-args-text-finish") {
+          if (chunk.path.length !== 1) {
+            controller.error(
+              new Error(`${chunk.type} chunks must have a path of length 1`)
+            );
+            return;
+          }
+          const idx = chunk.path[0];
+          if (idx < 0 || idx >= parts.length) {
+            controller.error(new Error(`Invalid path index: ${idx}`));
+            return;
+          }
+          const part = parts[idx];
+          controller.enqueue({
+            ...chunk,
+            meta: part
+            // TODO
+          });
+          return;
+        }
+        controller.enqueue(chunk);
+      }
+    });
+  }
+};
+export {
+  AssistantMetaTransformStream
+};
+//# sourceMappingURL=AssistantMetaTransformStream.mjs.map

package/dist/core/utils/stream/AssistantMetaTransformStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/AssistantMetaTransformStream.ts"],"sourcesContent":["import { AssistantStreamChunk, PartInit } from \"../../AssistantStreamChunk\";\n\n/**\n * For chunk types that are associated with a part,\n * we require a non‑nullable meta field.\n */\nexport type AssistantMetaStreamChunk =\n  | (AssistantStreamChunk & {\n      type: \"text-delta\" | \"part-finish\";\n      meta: PartInit;\n    })\n  | (AssistantStreamChunk & {\n      type: \"result\" | \"tool-call-args-text-finish\";\n      meta: PartInit & { type: \"tool-call\" };\n    })\n  | (AssistantStreamChunk & {\n      type: Exclude<\n        AssistantStreamChunk[\"type\"],\n        \"text-delta\" | \"result\" | \"tool-call-args-text-finish\" | \"part-finish\"\n      >;\n    });\nexport class AssistantMetaTransformStream extends TransformStream<\n  AssistantStreamChunk,\n  AssistantMetaStreamChunk\n> {\n  constructor() {\n    // We use an array to record parts as they are introduced.\n    const parts: PartInit[] = [];\n\n    super({\n      transform(chunk, controller) {\n        // For chunks that introduce a new part.\n        if (chunk.type === \"part-start\") {\n          if (chunk.path.length !== 0) {\n            controller.error(new Error(\"Nested parts are not supported\"));\n            return;\n          }\n          parts.push(chunk.part);\n          controller.enqueue(chunk);\n          return;\n        }\n\n        // For chunks that expect an associated part.\n        if (\n          chunk.type === \"text-delta\" ||\n          chunk.type === \"result\" ||\n          chunk.type === \"part-finish\" ||\n          chunk.type === \"tool-call-args-text-finish\"\n        ) {\n          if (chunk.path.length !== 1) {\n            controller.error(\n              new Error(`${chunk.type} chunks must have a path of length 1`),\n            );\n            return;\n          }\n          const idx = chunk.path[0]!;\n          if (idx < 0 || idx >= parts.length) {\n            controller.error(new Error(`Invalid path index: ${idx}`));\n            return;\n          }\n          const part = parts[idx]!;\n\n          controller.enqueue({\n            ...chunk,\n            meta: part as any, // TODO\n          });\n          return;\n        }\n\n        controller.enqueue(chunk);\n      },\n    });\n  }\n}\n"],"mappings":";AAqBO,IAAM,+BAAN,cAA2C,gBAGhD;AAAA,EACA,cAAc;AAEZ,UAAM,QAAoB,CAAC;AAE3B,UAAM;AAAA,MACJ,UAAU,OAAO,YAAY;AAE3B,YAAI,MAAM,SAAS,cAAc;AAC/B,cAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,uBAAW,MAAM,IAAI,MAAM,gCAAgC,CAAC;AAC5D;AAAA,UACF;AACA,gBAAM,KAAK,MAAM,IAAI;AACrB,qBAAW,QAAQ,KAAK;AACxB;AAAA,QACF;AAGA,YACE,MAAM,SAAS,gBACf,MAAM,SAAS,YACf,MAAM,SAAS,iBACf,MAAM,SAAS,8BACf;AACA,cAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,uBAAW;AAAA,cACT,IAAI,MAAM,GAAG,MAAM,IAAI,sCAAsC;AAAA,YAC/D;AACA;AAAA,UACF;AACA,gBAAM,MAAM,MAAM,KAAK,CAAC;AACxB,cAAI,MAAM,KAAK,OAAO,MAAM,QAAQ;AAClC,uBAAW,MAAM,IAAI,MAAM,uBAAuB,GAAG,EAAE,CAAC;AACxD;AAAA,UACF;AACA,gBAAM,OAAO,MAAM,GAAG;AAEtB,qBAAW,QAAQ;AAAA,YACjB,GAAG;AAAA,YACH,MAAM;AAAA;AAAA,UACR,CAAC;AACD;AAAA,QACF;AAEA,mBAAW,QAAQ,KAAK;AAAA,MAC1B;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/AssistantTransformStream.d.ts

@@ -0,0 +1,15 @@
+import { AssistantStreamChunk } from "../../AssistantStreamChunk";
+import { AssistantStreamController } from "../../modules/assistant-stream";
+type AssistantTransformerFlushCallback = (controller: AssistantStreamController) => void | PromiseLike<void>;
+type AssistantTransformerStartCallback = (controller: AssistantStreamController) => void | PromiseLike<void>;
+type AssistantTransformerTransformCallback<I> = (chunk: I, controller: AssistantStreamController) => void | PromiseLike<void>;
+type AssistantTransformer<I> = {
+    flush?: AssistantTransformerFlushCallback;
+    start?: AssistantTransformerStartCallback;
+    transform?: AssistantTransformerTransformCallback<I>;
+};
+export declare class AssistantTransformStream<I> extends TransformStream<I, AssistantStreamChunk> {
+    constructor(transformer: AssistantTransformer<I>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<AssistantStreamChunk>);
+}
+export {};
+//# sourceMappingURL=AssistantTransformStream.d.ts.map

package/dist/core/utils/stream/AssistantTransformStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantTransformStream.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/stream/AssistantTransformStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EACL,yBAAyB,EAE1B,MAAM,gCAAgC,CAAC;AAExC,KAAK,iCAAiC,GAAG,CACvC,UAAU,EAAE,yBAAyB,KAClC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;AAE9B,KAAK,iCAAiC,GAAG,CACvC,UAAU,EAAE,yBAAyB,KAClC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;AAE9B,KAAK,qCAAqC,CAAC,CAAC,IAAI,CAC9C,KAAK,EAAE,CAAC,EACR,UAAU,EAAE,yBAAyB,KAClC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;AAE9B,KAAK,oBAAoB,CAAC,CAAC,IAAI;IAC7B,KAAK,CAAC,EAAE,iCAAiC,CAAC;IAC1C,KAAK,CAAC,EAAE,iCAAiC,CAAC;IAC1C,SAAS,CAAC,EAAE,qCAAqC,CAAC,CAAC,CAAC,CAAC;CACtD,CAAC;AAEF,qBAAa,wBAAwB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAC9D,CAAC,EACD,oBAAoB,CACrB;gBAEG,WAAW,EAAE,oBAAoB,CAAC,CAAC,CAAC,EACpC,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EACrC,gBAAgB,CAAC,EAAE,eAAe,CAAC,oBAAoB,CAAC;CAyC3D"}

package/dist/core/utils/stream/AssistantTransformStream.js

@@ -0,0 +1,69 @@
+"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/utils/stream/AssistantTransformStream.ts
+var AssistantTransformStream_exports = {};
+__export(AssistantTransformStream_exports, {
+  AssistantTransformStream: () => AssistantTransformStream
+});
+module.exports = __toCommonJS(AssistantTransformStream_exports);
+var import_assistant_stream = require("../../modules/assistant-stream.js");
+var AssistantTransformStream = class extends TransformStream {
+  constructor(transformer, writableStrategy, readableStrategy) {
+    const [stream, runController] = (0, import_assistant_stream.createAssistantStreamController)();
+    let runPipeTask;
+    super(
+      {
+        start(controller) {
+          runPipeTask = stream.pipeTo(
+            new WritableStream({
+              write(chunk) {
+                controller.enqueue(chunk);
+              },
+              abort(reason) {
+                controller.error(reason);
+              },
+              close() {
+                controller.terminate();
+              }
+            })
+          ).catch((error) => {
+            controller.error(error);
+          });
+          return transformer.start?.(runController);
+        },
+        transform(chunk) {
+          return transformer.transform?.(chunk, runController);
+        },
+        async flush() {
+          await transformer.flush?.(runController);
+          runController.close();
+          await runPipeTask;
+        }
+      },
+      writableStrategy,
+      readableStrategy
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssistantTransformStream
+});
+//# sourceMappingURL=AssistantTransformStream.js.map

package/dist/core/utils/stream/AssistantTransformStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/AssistantTransformStream.ts"],"sourcesContent":["import { AssistantStreamChunk } from \"../../AssistantStreamChunk\";\nimport {\n  AssistantStreamController,\n  createAssistantStreamController,\n} from \"../../modules/assistant-stream\";\n\ntype AssistantTransformerFlushCallback = (\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformerStartCallback = (\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformerTransformCallback<I> = (\n  chunk: I,\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformer<I> = {\n  flush?: AssistantTransformerFlushCallback;\n  start?: AssistantTransformerStartCallback;\n  transform?: AssistantTransformerTransformCallback<I>;\n};\n\nexport class AssistantTransformStream<I> extends TransformStream<\n  I,\n  AssistantStreamChunk\n> {\n  constructor(\n    transformer: AssistantTransformer<I>,\n    writableStrategy?: QueuingStrategy<I>,\n    readableStrategy?: QueuingStrategy<AssistantStreamChunk>,\n  ) {\n    const [stream, runController] = createAssistantStreamController();\n\n    let runPipeTask: Promise<void>;\n    super(\n      {\n        start(controller) {\n          runPipeTask = stream\n            .pipeTo(\n              new WritableStream({\n                write(chunk) {\n                  controller.enqueue(chunk);\n                },\n                abort(reason?: any) {\n                  controller.error(reason);\n                },\n                close() {\n                  controller.terminate();\n                },\n              }),\n            )\n            .catch((error) => {\n              controller.error(error);\n            });\n\n          return transformer.start?.(runController);\n        },\n        transform(chunk) {\n          return transformer.transform?.(chunk, runController);\n        },\n        async flush() {\n          await transformer.flush?.(runController);\n          runController.close();\n          await runPipeTask;\n        },\n      },\n      writableStrategy,\n      readableStrategy,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,8BAGO;AAqBA,IAAM,2BAAN,cAA0C,gBAG/C;AAAA,EACA,YACE,aACA,kBACA,kBACA;AACA,UAAM,CAAC,QAAQ,aAAa,QAAI,yDAAgC;AAEhE,QAAI;AACJ;AAAA,MACE;AAAA,QACE,MAAM,YAAY;AAChB,wBAAc,OACX;AAAA,YACC,IAAI,eAAe;AAAA,cACjB,MAAM,OAAO;AACX,2BAAW,QAAQ,KAAK;AAAA,cAC1B;AAAA,cACA,MAAM,QAAc;AAClB,2BAAW,MAAM,MAAM;AAAA,cACzB;AAAA,cACA,QAAQ;AACN,2BAAW,UAAU;AAAA,cACvB;AAAA,YACF,CAAC;AAAA,UACH,EACC,MAAM,CAAC,UAAU;AAChB,uBAAW,MAAM,KAAK;AAAA,UACxB,CAAC;AAEH,iBAAO,YAAY,QAAQ,aAAa;AAAA,QAC1C;AAAA,QACA,UAAU,OAAO;AACf,iBAAO,YAAY,YAAY,OAAO,aAAa;AAAA,QACrD;AAAA,QACA,MAAM,QAAQ;AACZ,gBAAM,YAAY,QAAQ,aAAa;AACvC,wBAAc,MAAM;AACpB,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/core/utils/stream/AssistantTransformStream.mjs

@@ -0,0 +1,46 @@
+// src/core/utils/stream/AssistantTransformStream.ts
+import {
+  createAssistantStreamController
+} from "../../modules/assistant-stream.mjs";
+var AssistantTransformStream = class extends TransformStream {
+  constructor(transformer, writableStrategy, readableStrategy) {
+    const [stream, runController] = createAssistantStreamController();
+    let runPipeTask;
+    super(
+      {
+        start(controller) {
+          runPipeTask = stream.pipeTo(
+            new WritableStream({
+              write(chunk) {
+                controller.enqueue(chunk);
+              },
+              abort(reason) {
+                controller.error(reason);
+              },
+              close() {
+                controller.terminate();
+              }
+            })
+          ).catch((error) => {
+            controller.error(error);
+          });
+          return transformer.start?.(runController);
+        },
+        transform(chunk) {
+          return transformer.transform?.(chunk, runController);
+        },
+        async flush() {
+          await transformer.flush?.(runController);
+          runController.close();
+          await runPipeTask;
+        }
+      },
+      writableStrategy,
+      readableStrategy
+    );
+  }
+};
+export {
+  AssistantTransformStream
+};
+//# sourceMappingURL=AssistantTransformStream.mjs.map

package/dist/core/utils/stream/AssistantTransformStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/AssistantTransformStream.ts"],"sourcesContent":["import { AssistantStreamChunk } from \"../../AssistantStreamChunk\";\nimport {\n  AssistantStreamController,\n  createAssistantStreamController,\n} from \"../../modules/assistant-stream\";\n\ntype AssistantTransformerFlushCallback = (\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformerStartCallback = (\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformerTransformCallback<I> = (\n  chunk: I,\n  controller: AssistantStreamController,\n) => void | PromiseLike<void>;\n\ntype AssistantTransformer<I> = {\n  flush?: AssistantTransformerFlushCallback;\n  start?: AssistantTransformerStartCallback;\n  transform?: AssistantTransformerTransformCallback<I>;\n};\n\nexport class AssistantTransformStream<I> extends TransformStream<\n  I,\n  AssistantStreamChunk\n> {\n  constructor(\n    transformer: AssistantTransformer<I>,\n    writableStrategy?: QueuingStrategy<I>,\n    readableStrategy?: QueuingStrategy<AssistantStreamChunk>,\n  ) {\n    const [stream, runController] = createAssistantStreamController();\n\n    let runPipeTask: Promise<void>;\n    super(\n      {\n        start(controller) {\n          runPipeTask = stream\n            .pipeTo(\n              new WritableStream({\n                write(chunk) {\n                  controller.enqueue(chunk);\n                },\n                abort(reason?: any) {\n                  controller.error(reason);\n                },\n                close() {\n                  controller.terminate();\n                },\n              }),\n            )\n            .catch((error) => {\n              controller.error(error);\n            });\n\n          return transformer.start?.(runController);\n        },\n        transform(chunk) {\n          return transformer.transform?.(chunk, runController);\n        },\n        async flush() {\n          await transformer.flush?.(runController);\n          runController.close();\n          await runPipeTask;\n        },\n      },\n      writableStrategy,\n      readableStrategy,\n    );\n  }\n}\n"],"mappings":";AACA;AAAA,EAEE;AAAA,OACK;AAqBA,IAAM,2BAAN,cAA0C,gBAG/C;AAAA,EACA,YACE,aACA,kBACA,kBACA;AACA,UAAM,CAAC,QAAQ,aAAa,IAAI,gCAAgC;AAEhE,QAAI;AACJ;AAAA,MACE;AAAA,QACE,MAAM,YAAY;AAChB,wBAAc,OACX;AAAA,YACC,IAAI,eAAe;AAAA,cACjB,MAAM,OAAO;AACX,2BAAW,QAAQ,KAAK;AAAA,cAC1B;AAAA,cACA,MAAM,QAAc;AAClB,2BAAW,MAAM,MAAM;AAAA,cACzB;AAAA,cACA,QAAQ;AACN,2BAAW,UAAU;AAAA,cACvB;AAAA,YACF,CAAC;AAAA,UACH,EACC,MAAM,CAAC,UAAU;AAChB,uBAAW,MAAM,KAAK;AAAA,UACxB,CAAC;AAEH,iBAAO,YAAY,QAAQ,aAAa;AAAA,QAC1C;AAAA,QACA,UAAU,OAAO;AACf,iBAAO,YAAY,YAAY,OAAO,aAAa;AAAA,QACrD;AAAA,QACA,MAAM,QAAQ;AACZ,gBAAM,YAAY,QAAQ,aAAa;AACvC,wBAAc,MAAM;AACpB,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/core/utils/stream/LineDecoderStream.d.ts

@@ -0,0 +1,5 @@
+export declare class LineDecoderStream extends TransformStream<string, string> {
+    private buffer;
+    constructor();
+}
+//# sourceMappingURL=LineDecoderStream.d.ts.map

package/dist/core/utils/stream/LineDecoderStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LineDecoderStream.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/stream/LineDecoderStream.ts"],"names":[],"mappings":"AAAA,qBAAa,iBAAkB,SAAQ,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;IACpE,OAAO,CAAC,MAAM,CAAM;;CA2BrB"}

package/dist/core/utils/stream/LineDecoderStream.js

@@ -0,0 +1,52 @@
+"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/utils/stream/LineDecoderStream.ts
+var LineDecoderStream_exports = {};
+__export(LineDecoderStream_exports, {
+  LineDecoderStream: () => LineDecoderStream
+});
+module.exports = __toCommonJS(LineDecoderStream_exports);
+var LineDecoderStream = class extends TransformStream {
+  buffer = "";
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+          controller.enqueue(lines[i]);
+        }
+        this.buffer = lines[lines.length - 1] || "";
+      },
+      flush: () => {
+        if (this.buffer) {
+          throw new Error(
+            `Stream ended with an incomplete line: "${this.buffer}"`
+          );
+        }
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LineDecoderStream
+});
+//# sourceMappingURL=LineDecoderStream.js.map

package/dist/core/utils/stream/LineDecoderStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/LineDecoderStream.ts"],"sourcesContent":["export class LineDecoderStream extends TransformStream<string, string> {\n  private buffer = \"\";\n\n  constructor() {\n    super({\n      transform: (chunk, controller) => {\n        this.buffer += chunk;\n        const lines = this.buffer.split(\"\\n\");\n\n        // Process all complete lines\n        for (let i = 0; i < lines.length - 1; i++) {\n          controller.enqueue(lines[i]);\n        }\n\n        // Keep the last incomplete line in the buffer\n        this.buffer = lines[lines.length - 1] || \"\";\n      },\n      flush: () => {\n        // If there's content in the buffer when the stream ends, it means\n        // the stream ended with an incomplete line (no trailing newline)\n        if (this.buffer) {\n          throw new Error(\n            `Stream ended with an incomplete line: \"${this.buffer}\"`,\n          );\n        }\n      },\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAM,oBAAN,cAAgC,gBAAgC;AAAA,EAC7D,SAAS;AAAA,EAEjB,cAAc;AACZ,UAAM;AAAA,MACJ,WAAW,CAAC,OAAO,eAAe;AAChC,aAAK,UAAU;AACf,cAAM,QAAQ,KAAK,OAAO,MAAM,IAAI;AAGpC,iBAAS,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACzC,qBAAW,QAAQ,MAAM,CAAC,CAAC;AAAA,QAC7B;AAGA,aAAK,SAAS,MAAM,MAAM,SAAS,CAAC,KAAK;AAAA,MAC3C;AAAA,MACA,OAAO,MAAM;AAGX,YAAI,KAAK,QAAQ;AACf,gBAAM,IAAI;AAAA,YACR,0CAA0C,KAAK,MAAM;AAAA,UACvD;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/LineDecoderStream.mjs

@@ -0,0 +1,27 @@
+// src/core/utils/stream/LineDecoderStream.ts
+var LineDecoderStream = class extends TransformStream {
+  buffer = "";
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+          controller.enqueue(lines[i]);
+        }
+        this.buffer = lines[lines.length - 1] || "";
+      },
+      flush: () => {
+        if (this.buffer) {
+          throw new Error(
+            `Stream ended with an incomplete line: "${this.buffer}"`
+          );
+        }
+      }
+    });
+  }
+};
+export {
+  LineDecoderStream
+};
+//# sourceMappingURL=LineDecoderStream.mjs.map

package/dist/core/utils/stream/LineDecoderStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/LineDecoderStream.ts"],"sourcesContent":["export class LineDecoderStream extends TransformStream<string, string> {\n  private buffer = \"\";\n\n  constructor() {\n    super({\n      transform: (chunk, controller) => {\n        this.buffer += chunk;\n        const lines = this.buffer.split(\"\\n\");\n\n        // Process all complete lines\n        for (let i = 0; i < lines.length - 1; i++) {\n          controller.enqueue(lines[i]);\n        }\n\n        // Keep the last incomplete line in the buffer\n        this.buffer = lines[lines.length - 1] || \"\";\n      },\n      flush: () => {\n        // If there's content in the buffer when the stream ends, it means\n        // the stream ended with an incomplete line (no trailing newline)\n        if (this.buffer) {\n          throw new Error(\n            `Stream ended with an incomplete line: \"${this.buffer}\"`,\n          );\n        }\n      },\n    });\n  }\n}\n"],"mappings":";AAAO,IAAM,oBAAN,cAAgC,gBAAgC;AAAA,EAC7D,SAAS;AAAA,EAEjB,cAAc;AACZ,UAAM;AAAA,MACJ,WAAW,CAAC,OAAO,eAAe;AAChC,aAAK,UAAU;AACf,cAAM,QAAQ,KAAK,OAAO,MAAM,IAAI;AAGpC,iBAAS,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACzC,qBAAW,QAAQ,MAAM,CAAC,CAAC;AAAA,QAC7B;AAGA,aAAK,SAAS,MAAM,MAAM,SAAS,CAAC,KAAK;AAAA,MAC3C;AAAA,MACA,OAAO,MAAM;AAGX,YAAI,KAAK,QAAQ;AACf,gBAAM,IAAI;AAAA,YACR,0CAA0C,KAAK,MAAM;AAAA,UACvD;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/PipeableTransformStream.d.ts

@@ -0,0 +1,4 @@
+export declare class PipeableTransformStream<I, O> extends TransformStream<I, O> {
+    constructor(transform: (readable: ReadableStream<I>) => ReadableStream<O>);
+}
+//# sourceMappingURL=PipeableTransformStream.d.ts.map

package/dist/core/utils/stream/PipeableTransformStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipeableTransformStream.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/stream/PipeableTransformStream.ts"],"names":[],"mappings":"AAAA,qBAAa,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC1D,SAAS,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC;CAQ1E"}

package/dist/core/utils/stream/PipeableTransformStream.js

@@ -0,0 +1,40 @@
+"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/utils/stream/PipeableTransformStream.ts
+var PipeableTransformStream_exports = {};
+__export(PipeableTransformStream_exports, {
+  PipeableTransformStream: () => PipeableTransformStream
+});
+module.exports = __toCommonJS(PipeableTransformStream_exports);
+var PipeableTransformStream = class extends TransformStream {
+  constructor(transform) {
+    super();
+    const readable = transform(super.readable);
+    Object.defineProperty(this, "readable", {
+      value: readable,
+      writable: false
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PipeableTransformStream
+});
+//# sourceMappingURL=PipeableTransformStream.js.map

package/dist/core/utils/stream/PipeableTransformStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/PipeableTransformStream.ts"],"sourcesContent":["export class PipeableTransformStream<I, O> extends TransformStream<I, O> {\n  constructor(transform: (readable: ReadableStream<I>) => ReadableStream<O>) {\n    super();\n    const readable = transform(super.readable as unknown as ReadableStream<I>);\n    Object.defineProperty(this, \"readable\", {\n      value: readable,\n      writable: false,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAM,0BAAN,cAA4C,gBAAsB;AAAA,EACvE,YAAY,WAA+D;AACzE,UAAM;AACN,UAAM,WAAW,UAAU,MAAM,QAAwC;AACzE,WAAO,eAAe,MAAM,YAAY;AAAA,MACtC,OAAO;AAAA,MACP,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/PipeableTransformStream.mjs

@@ -0,0 +1,15 @@
+// src/core/utils/stream/PipeableTransformStream.ts
+var PipeableTransformStream = class extends TransformStream {
+  constructor(transform) {
+    super();
+    const readable = transform(super.readable);
+    Object.defineProperty(this, "readable", {
+      value: readable,
+      writable: false
+    });
+  }
+};
+export {
+  PipeableTransformStream
+};
+//# sourceMappingURL=PipeableTransformStream.mjs.map

package/dist/core/utils/stream/PipeableTransformStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/PipeableTransformStream.ts"],"sourcesContent":["export class PipeableTransformStream<I, O> extends TransformStream<I, O> {\n  constructor(transform: (readable: ReadableStream<I>) => ReadableStream<O>) {\n    super();\n    const readable = transform(super.readable as unknown as ReadableStream<I>);\n    Object.defineProperty(this, \"readable\", {\n      value: readable,\n      writable: false,\n    });\n  }\n}\n"],"mappings":";AAAO,IAAM,0BAAN,cAA4C,gBAAsB;AAAA,EACvE,YAAY,WAA+D;AACzE,UAAM;AACN,UAAM,WAAW,UAAU,MAAM,QAAwC;AACzE,WAAO,eAAe,MAAM,YAAY;AAAA,MACtC,OAAO;AAAA,MACP,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/core/utils/stream/UnderlyingReadable.d.ts

@@ -0,0 +1,6 @@
+export type UnderlyingReadable<TController> = {
+    start?: (controller: TController) => void;
+    pull?: (controller: TController) => void | PromiseLike<void>;
+    cancel?: UnderlyingSourceCancelCallback;
+};
+//# sourceMappingURL=UnderlyingReadable.d.ts.map

package/dist/core/utils/stream/UnderlyingReadable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnderlyingReadable.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/stream/UnderlyingReadable.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,CAAC,WAAW,IAAI;IAC5C,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAC7D,MAAM,CAAC,EAAE,8BAA8B,CAAC;CACzC,CAAC"}

package/dist/core/utils/stream/UnderlyingReadable.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/utils/stream/UnderlyingReadable.ts
+var UnderlyingReadable_exports = {};
+module.exports = __toCommonJS(UnderlyingReadable_exports);
+//# sourceMappingURL=UnderlyingReadable.js.map

package/dist/core/utils/stream/UnderlyingReadable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/UnderlyingReadable.ts"],"sourcesContent":["export type UnderlyingReadable<TController> = {\n  start?: (controller: TController) => void;\n  pull?: (controller: TController) => void | PromiseLike<void>;\n  cancel?: UnderlyingSourceCancelCallback;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/core/utils/stream/UnderlyingReadable.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=UnderlyingReadable.mjs.map

package/dist/core/utils/stream/UnderlyingReadable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/core/utils/stream/merge.d.ts

@@ -0,0 +1,9 @@
+import { AssistantStreamChunk } from "../../AssistantStreamChunk";
+export declare const createMergeStream: () => {
+    readable: ReadableStream<AssistantStreamChunk>;
+    isSealed(): boolean;
+    seal(): void;
+    addStream(stream: ReadableStream<AssistantStreamChunk>): void;
+    enqueue(chunk: AssistantStreamChunk): void;
+};
+//# sourceMappingURL=merge.d.ts.map

package/dist/core/utils/stream/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/stream/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAQlE,eAAO,MAAM,iBAAiB;;;;sBA0ER,cAAc,CAAC,oBAAoB,CAAC;mBAUvC,oBAAoB;CAWtC,CAAC"}

package/dist/core/utils/stream/merge.js

@@ -0,0 +1,110 @@
+"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/utils/stream/merge.ts
+var merge_exports = {};
+__export(merge_exports, {
+  createMergeStream: () => createMergeStream
+});
+module.exports = __toCommonJS(merge_exports);
+var import_promiseWithResolvers = require("../../../utils/promiseWithResolvers.js");
+var createMergeStream = () => {
+  const list = [];
+  let sealed = false;
+  let controller;
+  let currentPull;
+  const handlePull = (item) => {
+    if (!item.promise) {
+      item.promise = item.reader.read().then(({ done, value }) => {
+        item.promise = void 0;
+        if (done) {
+          list.splice(list.indexOf(item), 1);
+          if (sealed && list.length === 0) {
+            controller.close();
+          }
+        } else {
+          controller.enqueue(value);
+        }
+        currentPull?.resolve();
+        currentPull = void 0;
+      }).catch((e) => {
+        console.error(e);
+        list.forEach((item2) => {
+          item2.reader.cancel();
+        });
+        list.length = 0;
+        controller.error(e);
+        currentPull?.reject(e);
+        currentPull = void 0;
+      });
+    }
+  };
+  const readable = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    pull() {
+      currentPull = (0, import_promiseWithResolvers.promiseWithResolvers)();
+      list.forEach((item) => {
+        handlePull(item);
+      });
+      return currentPull.promise;
+    },
+    cancel() {
+      list.forEach((item) => {
+        item.reader.cancel();
+      });
+      list.length = 0;
+    }
+  });
+  return {
+    readable,
+    isSealed() {
+      return sealed;
+    },
+    seal() {
+      sealed = true;
+      if (list.length === 0) controller.close();
+    },
+    addStream(stream) {
+      if (sealed)
+        throw new Error(
+          "Cannot add streams after the run callback has settled."
+        );
+      const item = { reader: stream.getReader() };
+      list.push(item);
+      handlePull(item);
+    },
+    enqueue(chunk) {
+      this.addStream(
+        new ReadableStream({
+          start(c) {
+            c.enqueue(chunk);
+            c.close();
+          }
+        })
+      );
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMergeStream
+});
+//# sourceMappingURL=merge.js.map

package/dist/core/utils/stream/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/utils/stream/merge.ts"],"sourcesContent":["import { AssistantStreamChunk } from \"../../AssistantStreamChunk\";\nimport { promiseWithResolvers } from \"../../../utils/promiseWithResolvers\";\n\ntype MergeStreamItem = {\n  reader: ReadableStreamDefaultReader<AssistantStreamChunk>;\n  promise?: Promise<unknown> | undefined;\n};\n\nexport const createMergeStream = () => {\n  const list: MergeStreamItem[] = [];\n  let sealed = false;\n  let controller: ReadableStreamDefaultController<AssistantStreamChunk>;\n  let currentPull: ReturnType<typeof promiseWithResolvers<void>> | undefined;\n\n  const handlePull = (item: MergeStreamItem) => {\n    if (!item.promise) {\n      // TODO for most streams, we can directly pipeTo to avoid the microTask queue\n      // add an option to eagerly pipe the stream to the merge stream\n      // ideally, using assitant-stream w sync run method + piping to a sync WritableStream runs in the same microtask\n      // this is useful because we often use AssistantStreams internally as a serialization utility, e. g. AssistantTransformStream\n      // idea: avoid reader.read() by instead using a WritableStream & if (!hasPendingPull) await waitForPull()?\n      item.promise = item.reader\n        .read()\n        .then(({ done, value }) => {\n          item.promise = undefined;\n          if (done) {\n            list.splice(list.indexOf(item), 1);\n            if (sealed && list.length === 0) {\n              controller.close();\n            }\n          } else {\n            controller.enqueue(value);\n          }\n\n          currentPull?.resolve();\n          currentPull = undefined;\n        })\n        .catch((e) => {\n          console.error(e);\n\n          list.forEach((item) => {\n            item.reader.cancel();\n          });\n          list.length = 0;\n\n          controller.error(e);\n\n          currentPull?.reject(e);\n          currentPull = undefined;\n        });\n    }\n  };\n\n  const readable = new ReadableStream<AssistantStreamChunk>({\n    start(c) {\n      controller = c;\n    },\n    pull() {\n      currentPull = promiseWithResolvers();\n      list.forEach((item) => {\n        handlePull(item);\n      });\n\n      return currentPull.promise;\n    },\n    cancel() {\n      list.forEach((item) => {\n        item.reader.cancel();\n      });\n      list.length = 0;\n    },\n  });\n\n  return {\n    readable,\n    isSealed() {\n      return sealed;\n    },\n    seal() {\n      sealed = true;\n      if (list.length === 0) controller.close();\n    },\n    addStream(stream: ReadableStream<AssistantStreamChunk>) {\n      if (sealed)\n        throw new Error(\n          \"Cannot add streams after the run callback has settled.\",\n        );\n\n      const item = { reader: stream.getReader() };\n      list.push(item);\n      handlePull(item);\n    },\n    enqueue(chunk: AssistantStreamChunk) {\n      this.addStream(\n        new ReadableStream({\n          start(c) {\n            c.enqueue(chunk);\n            c.close();\n          },\n        }),\n      );\n    },\n  };\n};\n\n// TODO\n// export class SpanContainerMerger {\n//   public get isSealed() {\n//     return this.mergeStream.isSealed();\n//   }\n\n//   public get readable() {\n//     return this.mergeStream.readable;\n//   }\n\n//   private subAllocator = new Counter();\n//   private mergeStream = createMergeStream();\n\n//   constructor() {\n//     // id 0 is auto allocated\n//     this.subAllocator.up();\n//   }\n\n//   add(stream: ReadableStream<AssistantStreamChunk>) {\n//     this.mergeStream.addStream(\n//       stream.pipeThrough(new SpanParentEncoder(this.subAllocator)),\n//     );\n//   }\n\n//   enqueue(chunk: AssistantStreamChunk & { parentId: 0 }) {\n//     this.mergeStream.addStream(\n//       new ReadableStream({\n//         start(c) {\n//           c.enqueue(chunk);\n//           c.close();\n//         },\n//       }),\n//     );\n//   }\n\n//   seal() {\n//     this.mergeStream.seal();\n//   }\n// }\n\n// export class SpanContainerSplitter {\n//   public writable;\n\n//   private isSealed = false;\n//   private writers = new Map<\n//     number,\n//     WritableStreamDefaultWriter<AssistantStreamChunk>\n//   >();\n\n//   private closeTasks: Promise<void>[] = [];\n\n//   private allocator = new Counter();\n//   private subAllocator = new Counter();\n\n//   constructor() {\n//     // id 0 is auto-allocated\n//     this.allocator.up();\n\n//     this.writable = new WritableStream({\n//       write: (chunk) => {\n//         const { type, parentId } = chunk;\n\n//         const writer = this.writers.get(parentId);\n//         if (writer === undefined) throw new Error(\"Parent id not found\");\n\n//         writer.write(chunk);\n\n//         if (type === \"span\") {\n//           // allocate a new span id\n//           this.writers.set(this.allocator.up(), writer);\n//         }\n//         if (type === \"finish\") {\n//           this.writers.delete(parentId);\n//           writer.close();\n\n//           if (this.writers.size === 0) {\n//             const closeTask = this.writable.close();\n//             this.closeTasks.push(closeTask);\n//             closeTask.then(() => {\n//               this.closeTasks.splice(this.closeTasks.indexOf(closeTask), 1);\n//             });\n//           }\n//         }\n//       },\n//       close: async () => {\n//         if (this.writers.size > 0) throw new Error(\"Not all writers closed\");\n\n//         // await and throw on any errors\n//         await Promise.all(this.closeTasks);\n//       },\n//     });\n//   }\n\n//   add(stream: WritableStream<AssistantStreamChunk>) {\n//     if (this.isSealed) throw new Error(\"Cannot add streams after sealing\");\n\n//     const decoder = new SpanParentDecoder(this.subAllocator);\n//     decoder.readable.pipeTo(stream);\n\n//     this.writers.set(this.allocator.up(), decoder.writable.getWriter());\n//   }\n\n//   seal() {\n//     this.isSealed = true;\n//     if (this.writers.size === 0) this.writable.close();\n//   }\n// }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kCAAqC;AAO9B,IAAM,oBAAoB,MAAM;AACrC,QAAM,OAA0B,CAAC;AACjC,MAAI,SAAS;AACb,MAAI;AACJ,MAAI;AAEJ,QAAM,aAAa,CAAC,SAA0B;AAC5C,QAAI,CAAC,KAAK,SAAS;AAMjB,WAAK,UAAU,KAAK,OACjB,KAAK,EACL,KAAK,CAAC,EAAE,MAAM,MAAM,MAAM;AACzB,aAAK,UAAU;AACf,YAAI,MAAM;AACR,eAAK,OAAO,KAAK,QAAQ,IAAI,GAAG,CAAC;AACjC,cAAI,UAAU,KAAK,WAAW,GAAG;AAC/B,uBAAW,MAAM;AAAA,UACnB;AAAA,QACF,OAAO;AACL,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAEA,qBAAa,QAAQ;AACrB,sBAAc;AAAA,MAChB,CAAC,EACA,MAAM,CAAC,MAAM;AACZ,gBAAQ,MAAM,CAAC;AAEf,aAAK,QAAQ,CAACA,UAAS;AACrB,UAAAA,MAAK,OAAO,OAAO;AAAA,QACrB,CAAC;AACD,aAAK,SAAS;AAEd,mBAAW,MAAM,CAAC;AAElB,qBAAa,OAAO,CAAC;AACrB,sBAAc;AAAA,MAChB,CAAC;AAAA,IACL;AAAA,EACF;AAEA,QAAM,WAAW,IAAI,eAAqC;AAAA,IACxD,MAAM,GAAG;AACP,mBAAa;AAAA,IACf;AAAA,IACA,OAAO;AACL,wBAAc,kDAAqB;AACnC,WAAK,QAAQ,CAAC,SAAS;AACrB,mBAAW,IAAI;AAAA,MACjB,CAAC;AAED,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,SAAS;AACP,WAAK,QAAQ,CAAC,SAAS;AACrB,aAAK,OAAO,OAAO;AAAA,MACrB,CAAC;AACD,WAAK,SAAS;AAAA,IAChB;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,WAAW;AACT,aAAO;AAAA,IACT;AAAA,IACA,OAAO;AACL,eAAS;AACT,UAAI,KAAK,WAAW,EAAG,YAAW,MAAM;AAAA,IAC1C;AAAA,IACA,UAAU,QAA8C;AACtD,UAAI;AACF,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAEF,YAAM,OAAO,EAAE,QAAQ,OAAO,UAAU,EAAE;AAC1C,WAAK,KAAK,IAAI;AACd,iBAAW,IAAI;AAAA,IACjB;AAAA,IACA,QAAQ,OAA6B;AACnC,WAAK;AAAA,QACH,IAAI,eAAe;AAAA,UACjB,MAAM,GAAG;AACP,cAAE,QAAQ,KAAK;AACf,cAAE,MAAM;AAAA,UACV;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;","names":["item"]}