assistant-stream 0.3.25 → 0.3.27

package/src/resumable/ResumableStreamContext.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createResumableStreamContext } from "./ResumableStreamContext";
 import { ResumableStreamError } from "./errors";
 import { createInMemoryResumableStreamStore } from "./stores/InMemoryResumableStreamStore";
@@ -8,6 +8,10 @@ const dec = new TextDecoder();
 
 const bytes = (s: string): Uint8Array => enc.encode(s);
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 async function collect(stream: ReadableStream<Uint8Array>): Promise<string> {
   const reader = stream.getReader();
   let out = "";
@@ -271,4 +275,115 @@ describe("createResumableStreamContext", () => {
     expect(errors[0]!.id).toBe("a");
     expect((errors[0]!.error as Error).message).toBe("boom");
   });
+
+  it("continues acquisition when onAcquire throws", async () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const hookError = new Error("acquire observer failed");
+    const store = createInMemoryResumableStreamStore();
+    const ctx = createResumableStreamContext({
+      store,
+      onAcquire: () => {
+        throw hookError;
+      },
+    });
+
+    const stream = await ctx.run("a", () => makeStringStream(["hello"]));
+
+    expect(await collect(stream)).toBe("hello");
+    expect(await ctx.status("a")).toBe("done");
+    expect(consoleError).toHaveBeenCalledWith(
+      "resumable stream onAcquire hook failed:",
+      hookError,
+    );
+  });
+
+  it("continues streaming when onAppend throws", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const store = createInMemoryResumableStreamStore();
+    const ctx = createResumableStreamContext({
+      store,
+      onAppend: () => {
+        throw new Error("append observer failed");
+      },
+    });
+
+    const stream = await ctx.run("a", () =>
+      makeStringStream(["hello ", "world"]),
+    );
+
+    expect(await collect(stream)).toBe("hello world");
+    expect(await ctx.status("a")).toBe("done");
+  });
+
+  it("continues streaming when async onAppend rejects", async () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const hookError = new Error("async append observer failed");
+    const store = createInMemoryResumableStreamStore();
+    const ctx = createResumableStreamContext({
+      store,
+      onAppend: async () => {
+        throw hookError;
+      },
+    });
+
+    const stream = await ctx.run("a", () => makeStringStream(["hello"]));
+
+    expect(await collect(stream)).toBe("hello");
+    expect(await ctx.status("a")).toBe("done");
+    await vi.waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "resumable stream onAppend hook failed:",
+        hookError,
+      );
+    });
+  });
+
+  it("keeps successful completion when onFinalize throws", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const onError = vi.fn();
+    const onFinalize = vi.fn(() => {
+      throw new Error("finalize observer failed");
+    });
+    const store = createInMemoryResumableStreamStore();
+    const ctx = createResumableStreamContext({ store, onError, onFinalize });
+
+    const stream = await ctx.run("a", () => makeStringStream(["hello"]));
+
+    expect(await collect(stream)).toBe("hello");
+    expect(await ctx.status("a")).toBe("done");
+    expect(onFinalize).toHaveBeenCalledOnce();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("finalizes producer errors when onError throws", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const tasks: Promise<unknown>[] = [];
+    const store = createInMemoryResumableStreamStore();
+    const ctx = createResumableStreamContext({
+      store,
+      waitUntil: (task) => tasks.push(task),
+      onError: () => {
+        throw new Error("error observer failed");
+      },
+    });
+    const producerError = new Error("producer failed");
+
+    const stream = await ctx.run(
+      "a",
+      () =>
+        new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.error(producerError);
+          },
+        }),
+    );
+    await Promise.allSettled(tasks);
+
+    expect(await ctx.status("a")).toBe("error");
+    await expect(collect(stream)).rejects.toThrow("producer failed");
+  });
 });

package/src/resumable/ResumableStreamContext.ts

@@ -1,4 +1,5 @@
 import { ResumableStreamError } from "./errors";
+import { withPromiseOrValue } from "../core/utils/withPromiseOrValue";
 import type {
   ResumableStreamRole,
   ResumableStreamStatus,
@@ -42,6 +43,21 @@ export interface ResumableStreamContext {
   delete(streamId: string): Promise<void>;
 }
 
+const invokeObservabilityHook = <TArgs extends unknown[]>(
+  name: string,
+  hook: ((...args: TArgs) => void) | undefined,
+  ...args: TArgs
+): void => {
+  if (!hook) return;
+  void withPromiseOrValue(
+    () => hook(...args),
+    () => {},
+    (error) => {
+      console.error(`resumable stream ${name} hook failed:`, error);
+    },
+  );
+};
+
 export function createResumableStreamContext(
   options: ResumableStreamContextOptions,
 ): ResumableStreamContext {
@@ -53,7 +69,7 @@ export function createResumableStreamContext(
   return {
     async run(streamId, makeStream) {
       const role = await store.acquire(streamId, acquireOptions);
-      onAcquire?.(streamId, role);
+      invokeObservabilityHook("onAcquire", onAcquire, streamId, role);
       if (role === "producer") {
         startProducerTask(store, streamId, makeStream, {
           waitUntil,
@@ -119,13 +135,18 @@ function startProducerTask(
         const { done, value } = await reader.read();
         if (done) break;
         await store.append(streamId, value);
-        onAppend?.(streamId, value.byteLength);
+        invokeObservabilityHook(
+          "onAppend",
+          onAppend,
+          streamId,
+          value.byteLength,
+        );
       }
       await store.finalize(streamId, "done");
-      onFinalize?.(streamId, "done");
+      invokeObservabilityHook("onFinalize", onFinalize, streamId, "done");
     } catch (err) {
       cancelled = true;
-      onError?.(streamId, err);
+      invokeObservabilityHook("onError", onError, streamId, err);
       const message = err instanceof Error ? err.message : String(err);
       try {
         await reader?.cancel(err);
@@ -134,7 +155,13 @@ function startProducerTask(
       }
       try {
         await store.finalize(streamId, "error", message);
-        onFinalize?.(streamId, "error", message);
+        invokeObservabilityHook(
+          "onFinalize",
+          onFinalize,
+          streamId,
+          "error",
+          message,
+        );
       } catch (finalizeErr) {
         console.error("resumable stream finalize failed:", finalizeErr);
       }

package/src/resumable/createResumableAssistantStreamResponse.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import {
   RESUMABLE_STREAM_ID_HEADER,
   createResumableAssistantStreamResponse,
@@ -140,25 +140,6 @@ describe("createResumableAssistantStreamResponse", () => {
   });
 
   describe("producer crash", () => {
-    let suppressed: unknown[];
-    let original: NodeJS.UnhandledRejectionListener[];
-    const swallow: NodeJS.UnhandledRejectionListener = (reason) => {
-      suppressed.push(reason);
-    };
-
-    beforeEach(() => {
-      suppressed = [];
-      original = process.listeners("unhandledRejection");
-      for (const l of original) process.off("unhandledRejection", l);
-      process.on("unhandledRejection", swallow);
-    });
-
-    afterEach(async () => {
-      await new Promise((r) => setTimeout(r, 20));
-      process.off("unhandledRejection", swallow);
-      for (const l of original) process.on("unhandledRejection", l);
-    });
-
     it("synchronous callback throw is encoded into the body and finalizes the stream", async () => {
       const ctx = createResumableStreamContext({
         store: createInMemoryResumableStreamStore(),
@@ -184,11 +165,6 @@ describe("createResumableAssistantStreamResponse", () => {
       expect(replay).not.toBeNull();
       const replayBytes = await new Response(replay).arrayBuffer();
       expect(new Uint8Array(replayBytes)).toEqual(new Uint8Array(firstBytes));
-
-      while (suppressed.length === 0) {
-        await new Promise((r) => setTimeout(r, 5));
-      }
-      expect(suppressed.map((e) => (e as Error).message)).toContain("boom");
     });
   });
 

package/src/utils/AsyncIterableStream.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from "vitest";
+import { asAsyncIterableStream } from "./AsyncIterableStream";
+
+const forcePolyfilledIterator = <T>(
+  stream: ReadableStream<T>,
+): AsyncIterable<T> & ReadableStream<T> => {
+  Object.defineProperty(stream, Symbol.asyncIterator, {
+    configurable: true,
+    value: undefined,
+    writable: true,
+  });
+  return asAsyncIterableStream(stream);
+};
+
+describe("asAsyncIterableStream", () => {
+  it("cancels the source when iteration stops early", async () => {
+    const cancel = vi.fn();
+    const stream = forcePolyfilledIterator(
+      new ReadableStream<string>({
+        start(controller) {
+          controller.enqueue("first");
+          controller.enqueue("second");
+        },
+        cancel,
+      }),
+    );
+
+    const values: string[] = [];
+    for await (const value of stream) {
+      values.push(value);
+      break;
+    }
+
+    expect(values).toEqual(["first"]);
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(stream.locked).toBe(false);
+  });
+
+  it("does not cancel a fully consumed source", async () => {
+    const cancel = vi.fn();
+    const stream = forcePolyfilledIterator(
+      new ReadableStream<string>({
+        start(controller) {
+          controller.enqueue("first");
+          controller.enqueue("second");
+          controller.close();
+        },
+        cancel,
+      }),
+    );
+
+    const values: string[] = [];
+    for await (const value of stream) {
+      values.push(value);
+    }
+
+    expect(values).toEqual(["first", "second"]);
+    expect(cancel).not.toHaveBeenCalled();
+    expect(stream.locked).toBe(false);
+  });
+});

package/src/utils/AsyncIterableStream.ts

@@ -4,14 +4,29 @@ async function* streamGeneratorPolyfill<T>(
   this: ReadableStream<T>,
 ): AsyncGenerator<T, undefined, unknown> {
   const reader = this.getReader();
+  let shouldCancel = true;
   try {
     while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+      let result: ReadableStreamReadResult<T>;
+      try {
+        result = await reader.read();
+      } catch (error) {
+        shouldCancel = false;
+        throw error;
+      }
+      if (result.done) {
+        shouldCancel = false;
+        break;
+      }
+      const { value } = result;
       yield value;
     }
   } finally {
-    reader.releaseLock();
+    try {
+      if (shouldCancel) await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
   }
 }
 

package/src/utils.ts

@@ -15,3 +15,7 @@ export type {
 
 export { AssistantTransformStream } from "./core/utils/stream/AssistantTransformStream";
 export { AssistantMetaTransformStream } from "./core/utils/stream/AssistantMetaTransformStream";
+export {
+  SSEEventDecoder,
+  type SSEEvent,
+} from "./core/utils/stream/SSEEventDecoder";

package/dist/core/object/ObjectStreamAccumulator.d.ts

@@ -1,15 +0,0 @@
-import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
-import { ObjectStreamOperation } from "./types.js";
-
-//#region src/core/object/ObjectStreamAccumulator.d.ts
-declare class ObjectStreamAccumulator {
-  private _state;
-  constructor(initialValue?: ReadonlyJSONValue);
-  get state(): ReadonlyJSONValue;
-  append(ops: readonly ObjectStreamOperation[]): void;
-  private static apply;
-  private static updatePath;
-}
-//#endregion
-export { ObjectStreamAccumulator };
-//# sourceMappingURL=ObjectStreamAccumulator.d.ts.map

package/dist/core/object/ObjectStreamAccumulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectStreamAccumulator.d.ts","names":[],"sources":["../../../src/core/object/ObjectStreamAccumulator.ts"],"mappings":";;;;cAGa,uBAAA;EAAA,QACH,MAAA;cAEI,YAAA,GAAc,iBAAA;EAAA,IAItB,KAAA,IAAK,iBAAA;EAIT,MAAA,CAAO,GAAA,WAAc,qBAAA;EAAA,eAON,KAAA;EAAA,eAuBA,UAAA;AAAA"}

package/dist/core/object/ObjectStreamAccumulator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectStreamAccumulator.js","names":["_exhaustiveCheck"],"sources":["../../../src/core/object/ObjectStreamAccumulator.ts"],"sourcesContent":["import type { ReadonlyJSONValue, ReadonlyJSONObject } from \"../../utils\";\nimport type { ObjectStreamOperation } from \"./types\";\n\nexport class ObjectStreamAccumulator {\n  private _state: ReadonlyJSONValue;\n\n  constructor(initialValue: ReadonlyJSONValue = null) {\n    this._state = initialValue;\n  }\n\n  get state() {\n    return this._state;\n  }\n\n  append(ops: readonly ObjectStreamOperation[]) {\n    this._state = ops.reduce(\n      (state, op) => ObjectStreamAccumulator.apply(state, op),\n      this._state,\n    );\n  }\n\n  private static apply(state: ReadonlyJSONValue, op: ObjectStreamOperation) {\n    const type = op.type;\n    switch (type) {\n      case \"set\":\n        return ObjectStreamAccumulator.updatePath(\n          state,\n          op.path,\n          () => op.value,\n        );\n      case \"append-text\":\n        return ObjectStreamAccumulator.updatePath(state, op.path, (current) => {\n          if (typeof current !== \"string\")\n            throw new Error(`Expected string at path [${op.path.join(\", \")}]`);\n          return current + op.value;\n        });\n\n      default: {\n        const _exhaustiveCheck: never = type;\n        throw new Error(`Invalid operation type: ${_exhaustiveCheck}`);\n      }\n    }\n  }\n\n  private static updatePath(\n    state: ReadonlyJSONValue | undefined,\n    path: readonly string[],\n    updater: (current: ReadonlyJSONValue | undefined) => ReadonlyJSONValue,\n  ): ReadonlyJSONValue {\n    if (path.length === 0) return updater(state);\n\n    // Initialize state as empty object if it's null and we're trying to set a property\n    state ??= {};\n\n    if (typeof state !== \"object\") {\n      throw new Error(`Invalid path: [${path.join(\", \")}]`);\n    }\n\n    const [key, ...rest] = path as [string, ...(readonly string[])];\n    if (Array.isArray(state)) {\n      const idx = Number(key);\n      if (Number.isNaN(idx))\n        throw new Error(`Expected array index at [${path.join(\", \")}]`);\n      if (idx > state.length || idx < 0)\n        throw new Error(`Insert array index out of bounds`);\n\n      const nextState = [...state];\n      nextState[idx] = ObjectStreamAccumulator.updatePath(\n        nextState[idx],\n        rest,\n        updater,\n      );\n\n      return nextState;\n    }\n\n    const nextState = { ...(state as ReadonlyJSONObject) };\n    nextState[key] = ObjectStreamAccumulator.updatePath(\n      nextState[key],\n      rest,\n      updater,\n    );\n\n    return nextState;\n  }\n}\n"],"mappings":";AAGA,IAAa,0BAAb,MAAa,wBAAwB;CACnC;CAEA,YAAY,eAAkC,MAAM;EAClD,KAAK,SAAS;CAChB;CAEA,IAAI,QAAQ;EACV,OAAO,KAAK;CACd;CAEA,OAAO,KAAuC;EAC5C,KAAK,SAAS,IAAI,QACf,OAAO,OAAO,wBAAwB,MAAM,OAAO,EAAE,GACtD,KAAK,MACP;CACF;CAEA,OAAe,MAAM,OAA0B,IAA2B;EACxE,MAAM,OAAO,GAAG;EAChB,QAAQ,MAAR;GACE,KAAK,OACH,OAAO,wBAAwB,WAC7B,OACA,GAAG,YACG,GAAG,KACX;GACF,KAAK,eACH,OAAO,wBAAwB,WAAW,OAAO,GAAG,OAAO,YAAY;IACrE,IAAI,OAAO,YAAY,UACrB,MAAM,IAAI,MAAM,4BAA4B,GAAG,KAAK,KAAK,IAAI,EAAE,EAAE;IACnE,OAAO,UAAU,GAAG;GACtB,CAAC;GAEH,SAEE,MAAM,IAAI,MAAM,2BAA2BA,MAAkB;EAEjE;CACF;CAEA,OAAe,WACb,OACA,MACA,SACmB;EACnB,IAAI,KAAK,WAAW,GAAG,OAAO,QAAQ,KAAK;EAG3C,UAAU,CAAC;EAEX,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,MAAM,kBAAkB,KAAK,KAAK,IAAI,EAAE,EAAE;EAGtD,MAAM,CAAC,KAAK,GAAG,QAAQ;EACvB,IAAI,MAAM,QAAQ,KAAK,GAAG;GACxB,MAAM,MAAM,OAAO,GAAG;GACtB,IAAI,OAAO,MAAM,GAAG,GAClB,MAAM,IAAI,MAAM,4BAA4B,KAAK,KAAK,IAAI,EAAE,EAAE;GAChE,IAAI,MAAM,MAAM,UAAU,MAAM,GAC9B,MAAM,IAAI,MAAM,kCAAkC;GAEpD,MAAM,YAAY,CAAC,GAAG,KAAK;GAC3B,UAAU,OAAO,wBAAwB,WACvC,UAAU,MACV,MACA,OACF;GAEA,OAAO;EACT;EAEA,MAAM,YAAY,EAAE,GAAI,MAA6B;EACrD,UAAU,OAAO,wBAAwB,WACvC,UAAU,MACV,MACA,OACF;EAEA,OAAO;CACT;AACF"}

package/dist/core/object/ObjectStreamResponse.d.ts

@@ -1,17 +0,0 @@
-import { ObjectStreamChunk } from "./types.js";
-import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream.js";
-
-//#region src/core/object/ObjectStreamResponse.d.ts
-declare class ObjectStreamEncoder extends PipeableTransformStream<ObjectStreamChunk, Uint8Array> {
-  constructor();
-}
-declare class ObjectStreamDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, ObjectStreamChunk> {
-  constructor();
-}
-declare class ObjectStreamResponse extends Response {
-  constructor(body: ReadableStream<ObjectStreamChunk>);
-}
-declare const fromObjectStreamResponse: (response: Response) => ReadableStream<ObjectStreamChunk>;
-//#endregion
-export { ObjectStreamDecoder, ObjectStreamEncoder, ObjectStreamResponse, fromObjectStreamResponse };
-//# sourceMappingURL=ObjectStreamResponse.d.ts.map

package/dist/core/object/ObjectStreamResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectStreamResponse.d.ts","names":[],"sources":["../../../src/core/object/ObjectStreamResponse.ts"],"mappings":";;;;cAKa,mBAAA,SAA4B,uBAAA,CACvC,iBAAA,EACA,UAAA;;;cAgDW,mBAAA,SAA4B,uBAAA,CACvC,UAAA,CAAW,WAAA,GACX,iBAAA;;;cAyBW,oBAAA,SAA6B,QAAA;cAC5B,IAAA,EAAM,cAAA,CAAe,iBAAA;AAAA;AAAA,cAYtB,wBAAA,GACX,QAAA,EAAU,QAAA,KACT,cAAA,CAAe,iBAAA"}

package/dist/core/object/ObjectStreamResponse.js

@@ -1,57 +0,0 @@
-import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream.js";
-import { ObjectStreamAccumulator } from "./ObjectStreamAccumulator.js";
-import { SSEDecoder, SSEEncoder } from "../utils/stream/SSE.js";
-//#region src/core/object/ObjectStreamResponse.ts
-var ObjectStreamEncoder = class extends PipeableTransformStream {
-	constructor() {
-		super((readable) => readable.pipeThrough((() => {
-			class ObjectStreamTransformer {
-				#isFirstChunk = true;
-				start() {}
-				transform(chunk, controller) {
-					if (this.#isFirstChunk && chunk.snapshot && Object.keys(chunk.snapshot).length > 0) controller.enqueue([{
-						type: "set",
-						path: [],
-						value: chunk.snapshot
-					}, ...chunk.operations]);
-					else controller.enqueue(chunk.operations);
-					this.#isFirstChunk = false;
-				}
-			}
-			return new TransformStream(new ObjectStreamTransformer());
-		})()).pipeThrough(new SSEEncoder()));
-	}
-};
-var ObjectStreamDecoder = class extends PipeableTransformStream {
-	constructor() {
-		const accumulator = new ObjectStreamAccumulator();
-		super((readable) => readable.pipeThrough(new SSEDecoder()).pipeThrough(new TransformStream({ transform(operations, controller) {
-			accumulator.append(operations);
-			controller.enqueue({
-				snapshot: accumulator.state,
-				operations
-			});
-		} })));
-	}
-};
-var ObjectStreamResponse = class extends Response {
-	constructor(body) {
-		super(body.pipeThrough(new ObjectStreamEncoder()), { headers: new Headers({
-			"Content-Type": "text/event-stream",
-			"Cache-Control": "no-cache",
-			Connection: "keep-alive",
-			"Assistant-Stream-Format": "object-stream/v0"
-		}) });
-	}
-};
-const fromObjectStreamResponse = (response) => {
-	if (!response.ok) throw new Error(`Response failed, status ${response.status}`);
-	if (!response.body) throw new Error("Response body is null");
-	if (response.headers.get("Content-Type") !== "text/event-stream") throw new Error("Response is not an event stream");
-	if (response.headers.get("Assistant-Stream-Format") !== "object-stream/v0") throw new Error("Unsupported Assistant-Stream-Format header");
-	return response.body.pipeThrough(new ObjectStreamDecoder());
-};
-//#endregion
-export { ObjectStreamDecoder, ObjectStreamEncoder, ObjectStreamResponse, fromObjectStreamResponse };
-
-//# sourceMappingURL=ObjectStreamResponse.js.map

package/dist/core/object/ObjectStreamResponse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectStreamResponse.js","names":["#isFirstChunk"],"sources":["../../../src/core/object/ObjectStreamResponse.ts"],"sourcesContent":["import { PipeableTransformStream } from \"../utils/stream/PipeableTransformStream\";\nimport { ObjectStreamAccumulator } from \"./ObjectStreamAccumulator\";\nimport { SSEDecoder, SSEEncoder } from \"../utils/stream/SSE\";\nimport type { ObjectStreamChunk, ObjectStreamOperation } from \"./types\";\n\nexport class ObjectStreamEncoder extends PipeableTransformStream<\n  ObjectStreamChunk,\n  Uint8Array\n> {\n  constructor() {\n    super((readable) =>\n      readable\n        .pipeThrough(\n          (() => {\n            class ObjectStreamTransformer implements Transformer<\n              ObjectStreamChunk,\n              readonly ObjectStreamOperation[]\n            > {\n              #isFirstChunk = true;\n\n              start() {\n                // Nothing needed here since we initialize in the field declaration\n              }\n\n              transform(\n                chunk: ObjectStreamChunk,\n                controller: TransformStreamDefaultController<\n                  readonly ObjectStreamOperation[]\n                >,\n              ) {\n                if (\n                  this.#isFirstChunk &&\n                  chunk.snapshot &&\n                  Object.keys(chunk.snapshot).length > 0\n                ) {\n                  // For the first chunk, if there's an initial state that's not empty,\n                  // prepend a set operation for the initial state\n                  controller.enqueue([\n                    { type: \"set\", path: [], value: chunk.snapshot },\n                    ...chunk.operations,\n                  ]);\n                } else {\n                  controller.enqueue(chunk.operations);\n                }\n                this.#isFirstChunk = false;\n              }\n            }\n            return new TransformStream(new ObjectStreamTransformer());\n          })(),\n        )\n        .pipeThrough(new SSEEncoder()),\n    );\n  }\n}\n\nexport class ObjectStreamDecoder extends PipeableTransformStream<\n  Uint8Array<ArrayBuffer>,\n  ObjectStreamChunk\n> {\n  constructor() {\n    const accumulator = new ObjectStreamAccumulator();\n    super((readable) =>\n      readable\n        .pipeThrough(new SSEDecoder<readonly ObjectStreamOperation[]>())\n        .pipeThrough(\n          new TransformStream<\n            readonly ObjectStreamOperation[],\n            ObjectStreamChunk\n          >({\n            transform(operations, controller) {\n              accumulator.append(operations);\n              controller.enqueue({\n                snapshot: accumulator.state,\n                operations,\n              });\n            },\n          }),\n        ),\n    );\n  }\n}\n\nexport class ObjectStreamResponse extends Response {\n  constructor(body: ReadableStream<ObjectStreamChunk>) {\n    super(body.pipeThrough(new ObjectStreamEncoder()), {\n      headers: new Headers({\n        \"Content-Type\": \"text/event-stream\",\n        \"Cache-Control\": \"no-cache\",\n        Connection: \"keep-alive\",\n        \"Assistant-Stream-Format\": \"object-stream/v0\",\n      }),\n    });\n  }\n}\n\nexport const fromObjectStreamResponse = (\n  response: Response,\n): ReadableStream<ObjectStreamChunk> => {\n  if (!response.ok)\n    throw new Error(`Response failed, status ${response.status}`);\n  if (!response.body) throw new Error(\"Response body is null\");\n  if (response.headers.get(\"Content-Type\") !== \"text/event-stream\") {\n    throw new Error(\"Response is not an event stream\");\n  }\n  if (response.headers.get(\"Assistant-Stream-Format\") !== \"object-stream/v0\") {\n    throw new Error(\"Unsupported Assistant-Stream-Format header\");\n  }\n  return response.body.pipeThrough(new ObjectStreamDecoder());\n};\n"],"mappings":";;;;AAKA,IAAa,sBAAb,cAAyC,wBAGvC;CACA,cAAc;EACZ,OAAO,aACL,SACG,mBACQ;GACL,MAAM,wBAGJ;IACA,gBAAgB;IAEhB,QAAQ,CAER;IAEA,UACE,OACA,YAGA;KACA,IACE,KAAKA,iBACL,MAAM,YACN,OAAO,KAAK,MAAM,QAAQ,CAAC,CAAC,SAAS,GAIrC,WAAW,QAAQ,CACjB;MAAE,MAAM;MAAO,MAAM,CAAC;MAAG,OAAO,MAAM;KAAS,GAC/C,GAAG,MAAM,UACX,CAAC;UAED,WAAW,QAAQ,MAAM,UAAU;KAErC,KAAKA,gBAAgB;IACvB;GACF;GACA,OAAO,IAAI,gBAAgB,IAAI,wBAAwB,CAAC;EAC1D,EAAA,CAAG,CACL,CAAC,CACA,YAAY,IAAI,WAAW,CAAC,CACjC;CACF;AACF;AAEA,IAAa,sBAAb,cAAyC,wBAGvC;CACA,cAAc;EACZ,MAAM,cAAc,IAAI,wBAAwB;EAChD,OAAO,aACL,SACG,YAAY,IAAI,WAA6C,CAAC,CAAC,CAC/D,YACC,IAAI,gBAGF,EACA,UAAU,YAAY,YAAY;GAChC,YAAY,OAAO,UAAU;GAC7B,WAAW,QAAQ;IACjB,UAAU,YAAY;IACtB;GACF,CAAC;EACH,EACF,CAAC,CACH,CACJ;CACF;AACF;AAEA,IAAa,uBAAb,cAA0C,SAAS;CACjD,YAAY,MAAyC;EACnD,MAAM,KAAK,YAAY,IAAI,oBAAoB,CAAC,GAAG,EACjD,SAAS,IAAI,QAAQ;GACnB,gBAAgB;GAChB,iBAAiB;GACjB,YAAY;GACZ,2BAA2B;EAC7B,CAAC,EACH,CAAC;CACH;AACF;AAEA,MAAa,4BACX,aACsC;CACtC,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,2BAA2B,SAAS,QAAQ;CAC9D,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,uBAAuB;CAC3D,IAAI,SAAS,QAAQ,IAAI,cAAc,MAAM,qBAC3C,MAAM,IAAI,MAAM,iCAAiC;CAEnD,IAAI,SAAS,QAAQ,IAAI,yBAAyB,MAAM,oBACtD,MAAM,IAAI,MAAM,4CAA4C;CAE9D,OAAO,SAAS,KAAK,YAAY,IAAI,oBAAoB,CAAC;AAC5D"}

package/dist/core/object/createObjectStream.d.ts

@@ -1,19 +0,0 @@
-import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
-import { ObjectStreamChunk, ObjectStreamOperation } from "./types.js";
-
-//#region src/core/object/createObjectStream.d.ts
-type ObjectStreamController = {
-  readonly abortSignal: AbortSignal;
-  enqueue(operations: readonly ObjectStreamOperation[]): void;
-};
-type CreateObjectStreamOptions = {
-  execute: (controller: ObjectStreamController) => void | PromiseLike<void>;
-  defaultValue?: ReadonlyJSONValue;
-};
-declare const createObjectStream: ({
-  execute,
-  defaultValue
-}: CreateObjectStreamOptions) => ReadableStream<ObjectStreamChunk>;
-//#endregion
-export { createObjectStream };
-//# sourceMappingURL=createObjectStream.d.ts.map

package/dist/core/object/createObjectStream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createObjectStream.d.ts","names":[],"sources":["../../../src/core/object/createObjectStream.ts"],"mappings":";;;;KAKK,sBAAA;EAAA,SACM,WAAA,EAAa,WAAA;EAEtB,OAAA,CAAQ,UAAA,WAAqB,qBAAqB;AAAA;AAAA,KAwD/C,yBAAA;EACH,OAAA,GAAU,UAAA,EAAY,sBAAA,YAAkC,WAAA;EACxD,YAAA,GAAe,iBAAA;AAAA;AAAA,cAGJ,kBAAA;EAAsB,OAAA;EAAA;AAAA,GAGhC,yBAAA,KAAyB,cAAA,CAAA,iBAAA"}

package/dist/core/object/createObjectStream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createObjectStream.js","names":[],"sources":["../../../src/core/object/createObjectStream.ts"],"sourcesContent":["import type { ReadonlyJSONValue } from \"../../utils\";\nimport { withPromiseOrValue } from \"../utils/withPromiseOrValue\";\nimport { ObjectStreamAccumulator } from \"./ObjectStreamAccumulator\";\nimport type { ObjectStreamOperation, ObjectStreamChunk } from \"./types\";\n\ntype ObjectStreamController = {\n  readonly abortSignal: AbortSignal;\n\n  enqueue(operations: readonly ObjectStreamOperation[]): void;\n};\n\nclass ObjectStreamControllerImpl implements ObjectStreamController {\n  private _controller: ReadableStreamDefaultController<ObjectStreamChunk>;\n  private _abortController = new AbortController();\n  private _accumulator: ObjectStreamAccumulator;\n\n  get abortSignal() {\n    return this._abortController.signal;\n  }\n\n  constructor(\n    controller: ReadableStreamDefaultController<ObjectStreamChunk>,\n    defaultValue: ReadonlyJSONValue,\n  ) {\n    this._controller = controller;\n    this._accumulator = new ObjectStreamAccumulator(defaultValue);\n  }\n\n  enqueue(operations: readonly ObjectStreamOperation[]) {\n    this._accumulator.append(operations);\n\n    this._controller.enqueue({\n      snapshot: this._accumulator.state,\n      operations,\n    });\n  }\n\n  __internalError(error: unknown) {\n    this._controller.error(error);\n  }\n\n  __internalClose() {\n    this._controller.close();\n  }\n\n  __internalCancel(reason?: unknown) {\n    this._abortController.abort(reason);\n  }\n}\n\nconst getStreamControllerPair = (defaultValue: ReadonlyJSONValue) => {\n  let controller!: ObjectStreamControllerImpl;\n  const stream = new ReadableStream<ObjectStreamChunk>({\n    start(c) {\n      controller = new ObjectStreamControllerImpl(c, defaultValue);\n    },\n    cancel(reason: unknown) {\n      controller.__internalCancel(reason);\n    },\n  });\n\n  return [stream, controller] as const;\n};\n\ntype CreateObjectStreamOptions = {\n  execute: (controller: ObjectStreamController) => void | PromiseLike<void>;\n  defaultValue?: ReadonlyJSONValue;\n};\n\nexport const createObjectStream = ({\n  execute,\n  defaultValue = {},\n}: CreateObjectStreamOptions) => {\n  const [stream, controller] = getStreamControllerPair(defaultValue);\n\n  withPromiseOrValue(\n    () => execute(controller),\n    () => {\n      controller.__internalClose();\n    },\n    (e: unknown) => {\n      controller.__internalError(e);\n    },\n  );\n\n  return stream;\n};\n"],"mappings":";;;AAWA,IAAM,6BAAN,MAAmE;CACjE;CACA,mBAA2B,IAAI,gBAAgB;CAC/C;CAEA,IAAI,cAAc;EAChB,OAAO,KAAK,iBAAiB;CAC/B;CAEA,YACE,YACA,cACA;EACA,KAAK,cAAc;EACnB,KAAK,eAAe,IAAI,wBAAwB,YAAY;CAC9D;CAEA,QAAQ,YAA8C;EACpD,KAAK,aAAa,OAAO,UAAU;EAEnC,KAAK,YAAY,QAAQ;GACvB,UAAU,KAAK,aAAa;GAC5B;EACF,CAAC;CACH;CAEA,gBAAgB,OAAgB;EAC9B,KAAK,YAAY,MAAM,KAAK;CAC9B;CAEA,kBAAkB;EAChB,KAAK,YAAY,MAAM;CACzB;CAEA,iBAAiB,QAAkB;EACjC,KAAK,iBAAiB,MAAM,MAAM;CACpC;AACF;AAEA,MAAM,2BAA2B,iBAAoC;CACnE,IAAI;CAUJ,OAAO,CAAC,IATW,eAAkC;EACnD,MAAM,GAAG;GACP,aAAa,IAAI,2BAA2B,GAAG,YAAY;EAC7D;EACA,OAAO,QAAiB;GACtB,WAAW,iBAAiB,MAAM;EACpC;CACF,CAEa,GAAG,UAAU;AAC5B;AAOA,MAAa,sBAAsB,EACjC,SACA,eAAe,CAAC,QACe;CAC/B,MAAM,CAAC,QAAQ,cAAc,wBAAwB,YAAY;CAEjE,yBACQ,QAAQ,UAAU,SAClB;EACJ,WAAW,gBAAgB;CAC7B,IACC,MAAe;EACd,WAAW,gBAAgB,CAAC;CAC9B,CACF;CAEA,OAAO;AACT"}

package/dist/core/object/types.d.ts

@@ -1,18 +0,0 @@
-import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
-//#region src/core/object/types.d.ts
-type ObjectStreamOperation = {
-  readonly type: "set";
-  readonly path: readonly string[];
-  readonly value: ReadonlyJSONValue;
-} | {
-  readonly type: "append-text";
-  readonly path: readonly string[];
-  readonly value: string;
-};
-type ObjectStreamChunk = {
-  readonly snapshot: ReadonlyJSONValue;
-  readonly operations: readonly ObjectStreamOperation[];
-};
-//#endregion
-export { ObjectStreamChunk, ObjectStreamOperation };
-//# sourceMappingURL=types.d.ts.map

package/dist/core/object/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/object/types.ts"],"mappings":";;KAEY,qBAAA;EAAA,SAEG,IAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,EAAO,iBAAiB;AAAA;EAAA,SAGxB,IAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGH,iBAAA;EAAA,SACD,QAAA,EAAU,iBAAA;EAAA,SACV,UAAA,WAAqB,qBAAqB;AAAA"}

package/dist/utils/json/is-json.d.ts

@@ -1,9 +0,0 @@
-import { ReadonlyJSONArray, ReadonlyJSONObject, ReadonlyJSONValue } from "./json-value.js";
-
-//#region src/utils/json/is-json.d.ts
-declare function isJSONValue(value: unknown): value is ReadonlyJSONValue;
-declare function isJSONArray(value: unknown): value is ReadonlyJSONArray;
-declare function isJSONObject(value: unknown): value is ReadonlyJSONObject;
-//#endregion
-export { isJSONArray, isJSONObject, isJSONValue };
-//# sourceMappingURL=is-json.d.ts.map

package/dist/utils/json/is-json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-json.d.ts","names":[],"sources":["../../../src/utils/json/is-json.ts"],"mappings":";;;iBAMgB,WAAA,CAAY,KAAA,YAAiB,KAAA,IAAS,iBAAiB;AAAA,iBAuBvD,WAAA,CAAY,KAAA,YAAiB,KAAA,IAAS,iBAAiB;AAAA,iBAIvD,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,kBAAkB"}

package/dist/utils/json/is-json.js

@@ -1,17 +0,0 @@
-//#region src/utils/json/is-json.ts
-function isJSONValue(value) {
-	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
-	if (Array.isArray(value)) return value.every(isJSONValue);
-	if (typeof value === "object") return Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val));
-	return false;
-}
-function isJSONArray(value) {
-	return Array.isArray(value) && value.every(isJSONValue);
-}
-function isJSONObject(value) {
-	return value != null && typeof value === "object" && !Array.isArray(value) && Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val));
-}
-//#endregion
-export { isJSONArray, isJSONObject, isJSONValue };
-
-//# sourceMappingURL=is-json.js.map

package/dist/utils/json/is-json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-json.js","names":[],"sources":["../../../src/utils/json/is-json.ts"],"sourcesContent":["import type {\n  ReadonlyJSONArray,\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from \"./json-value\";\n\nexport function isJSONValue(value: unknown): value is ReadonlyJSONValue {\n  if (\n    value === null ||\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    return true;\n  }\n\n  if (Array.isArray(value)) {\n    return value.every(isJSONValue);\n  }\n\n  if (typeof value === \"object\") {\n    return Object.entries(value).every(\n      ([key, val]) => typeof key === \"string\" && isJSONValue(val),\n    );\n  }\n\n  return false;\n}\n\nexport function isJSONArray(value: unknown): value is ReadonlyJSONArray {\n  return Array.isArray(value) && value.every(isJSONValue);\n}\n\nexport function isJSONObject(value: unknown): value is ReadonlyJSONObject {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.entries(value).every(\n      ([key, val]) => typeof key === \"string\" && isJSONValue(val),\n    )\n  );\n}\n"],"mappings":";AAMA,SAAgB,YAAY,OAA4C;CACtE,IACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,WAEjB,OAAO;CAGT,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,WAAW;CAGhC,IAAI,OAAO,UAAU,UACnB,OAAO,OAAO,QAAQ,KAAK,CAAC,CAAC,OAC1B,CAAC,KAAK,SAAS,OAAO,QAAQ,YAAY,YAAY,GAAG,CAC5D;CAGF,OAAO;AACT;AAEA,SAAgB,YAAY,OAA4C;CACtE,OAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,WAAW;AACxD;AAEA,SAAgB,aAAa,OAA6C;CACxE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,KAAK,KACpB,OAAO,QAAQ,KAAK,CAAC,CAAC,OACnB,CAAC,KAAK,SAAS,OAAO,QAAQ,YAAY,YAAY,GAAG,CAC5D;AAEJ"}