assistant-stream 0.3.26 → 0.3.27

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/dist/core/object/ObjectStreamAccumulator.d.ts

@@ -1,15 +0,0 @@
-import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
-import "../../utils.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;UACH;cAEI,eAAc;MAItB,SAAK;EAIT,OAAO,cAAc;iBAON;iBAuBA"}

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,16 +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,4BAA4B,wBACvC,mBACA;;;cAgDW,4BAA4B,wBACvC,WAAW,cACX;;;cAyBW,6BAA6B;cAC5B,MAAM,eAAe;;cAYtB,2BACX,UAAU,aACT,eAAe"}

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")?.split(";", 1)[0]?.trim().toLowerCase() !== "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  const mediaType = response.headers\n    .get(\"Content-Type\")\n    ?.split(\";\", 1)[0]\n    ?.trim()\n    .toLowerCase();\n  if (mediaType !== \"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;CAM3D,IALkB,SAAS,QACxB,IAAI,cAAc,CAAC,EAClB,MAAM,KAAK,CAAC,CAAC,CAAC,EAAE,EAChB,KAAK,CAAC,CACP,YAAY,MACG,qBAChB,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,16 +0,0 @@
-import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
-import "../../utils.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;WACM,aAAa;EAEtB,QAAQ,qBAAqB;;KAwD1B;EACH,UAAU,YAAY,kCAAkC;EACxD,eAAe;;cAGJ,uBAAsB,SAAA,gBAGhC,8BAAyB,eAAA"}

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.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/object/types.ts"],"mappings":";;;KAEY;WAEG;WACA;WACA,OAAO;;WAGP;WACA;WACA;;KAGH;WACD,UAAU;WACV,qBAAqB"}

package/src/core/object/ObjectStreamResponse.ts

@@ -1,114 +0,0 @@
-import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream";
-import { ObjectStreamAccumulator } from "./ObjectStreamAccumulator";
-import { SSEDecoder, SSEEncoder } from "../utils/stream/SSE";
-import type { ObjectStreamChunk, ObjectStreamOperation } from "./types";
-
-export class ObjectStreamEncoder extends PipeableTransformStream<
-  ObjectStreamChunk,
-  Uint8Array
-> {
-  constructor() {
-    super((readable) =>
-      readable
-        .pipeThrough(
-          (() => {
-            class ObjectStreamTransformer implements Transformer<
-              ObjectStreamChunk,
-              readonly ObjectStreamOperation[]
-            > {
-              #isFirstChunk = true;
-
-              start() {
-                // Nothing needed here since we initialize in the field declaration
-              }
-
-              transform(
-                chunk: ObjectStreamChunk,
-                controller: TransformStreamDefaultController<
-                  readonly ObjectStreamOperation[]
-                >,
-              ) {
-                if (
-                  this.#isFirstChunk &&
-                  chunk.snapshot &&
-                  Object.keys(chunk.snapshot).length > 0
-                ) {
-                  // For the first chunk, if there's an initial state that's not empty,
-                  // prepend a set operation for the initial state
-                  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()),
-    );
-  }
-}
-
-export class ObjectStreamDecoder extends PipeableTransformStream<
-  Uint8Array<ArrayBuffer>,
-  ObjectStreamChunk
-> {
-  constructor() {
-    const accumulator = new ObjectStreamAccumulator();
-    super((readable) =>
-      readable
-        .pipeThrough(new SSEDecoder<readonly ObjectStreamOperation[]>())
-        .pipeThrough(
-          new TransformStream<
-            readonly ObjectStreamOperation[],
-            ObjectStreamChunk
-          >({
-            transform(operations, controller) {
-              accumulator.append(operations);
-              controller.enqueue({
-                snapshot: accumulator.state,
-                operations,
-              });
-            },
-          }),
-        ),
-    );
-  }
-}
-
-export class ObjectStreamResponse extends Response {
-  constructor(body: ReadableStream<ObjectStreamChunk>) {
-    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",
-      }),
-    });
-  }
-}
-
-export const fromObjectStreamResponse = (
-  response: Response,
-): ReadableStream<ObjectStreamChunk> => {
-  if (!response.ok)
-    throw new Error(`Response failed, status ${response.status}`);
-  if (!response.body) throw new Error("Response body is null");
-  const mediaType = response.headers
-    .get("Content-Type")
-    ?.split(";", 1)[0]
-    ?.trim()
-    .toLowerCase();
-  if (mediaType !== "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());
-};