Pass the defaultValue directly to getStreamControllerPair (i.e., getStreamControllerPair(defaultValue)) instead of wrapping it in an object, as the function expects a ReadonlyJSONValue.

Consider updating the array bounds check to use 'idx >= state.length' instead of 'idx > state.length' to prevent accidentally allowing an out-of-bounds index equal to the array length.

logic: Array index equal to length should be allowed for appending to array

style: Consider validating op.value is a string when current is undefined in append-text operation

logic: defaultValue is wrapped in an object unnecessarily - should be passed directly

logic: enqueue returns this but return type is void in interface - could cause type errors

logic: No validation for retry value being a positive number. Invalid values could cause reconnection issues.

style: JSON.stringify may throw for circular references or BigInts. Add try/catch to handle serialization errors.

The import path for ReadonlyJSONValue is incorrect. The type is actually defined in '../../utils/json/json-value.ts'.

Missing error handling for JSON.stringify which could throw on non-serializable data

The function getStreamControllerPair expects defaultValue directly, but is being passed an object with a defaultValue property

Magic string "json-v0.1" appears multiple times in the codebase and should be extracted as a constant

Potential bug: Passing an object { defaultValue } to getStreamControllerPair rather than the value itself. Likely use getStreamControllerPair(defaultValue).

JSON.parse errors are only logged here; consider propagating or handling the error to inform the consumer.

⚠️ Potential issue

SSE parsing breaks on CRLF line endings

LineDecoderStream splits on \n only, so CRLF lines arrive as
'data: {...}\r'. The trailing \r prevents the empty-line sentinel ("") from ever matching, so events never flush on Windows-style streams.

Minimal fix inside the event parser:

-  transform(line, controller) {
+  transform(rawLine, controller) {
+    const line = rawLine.replace(/\r$/, ""); // strip CR

-if (line === "") {
+if (line.length === 0) {

-const [field, ...rest] = line.split(":");
+const [field, ...rest] = line.split(":", 2);

(Using a max-split of 2 avoids unintended splits when value itself contains a colon.)

🛠️ Refactor suggestion

Replace this.updatePath with an explicit class reference in static context

Using this inside a static method is legal but usually discouraged and triggers Biome’s noThisInStatic rule.
Referencing the class directly removes the warning and clarifies intent.

-      const nextState = [...state];
-      nextState[idx] = this.updatePath(nextState[idx], rest, updater);
+      const nextState = [...state];
+      nextState[idx] = ObjectStreamAccumulator.updatePath(
+        nextState[idx],
+        rest,
+        updater,
+      );
 ...
-    const nextState = { ...(state as ReadonlyJSONObject) };
-    nextState[key] = this.updatePath(nextState[key], rest, updater);
+    const nextState = { ...(state as ReadonlyJSONObject) };
+    nextState[key] = ObjectStreamAccumulator.updatePath(
+      nextState[key],
+      rest,
+      updater,
+    );

Also applies to: 71-73

⚠️ Potential issue

Wrap the _exhaustiveCheck declaration to satisfy the no-switch-declarations rule

The const _exhaustiveCheck variable is declared in the default clause and therefore becomes visible to the other clauses, triggering the Biome noSwitchDeclarations lint error.
A minimal fix is to wrap the default body in a block.

-      default:
-        const _exhaustiveCheck: never = type;
-        throw new Error(`Invalid operation type: ${_exhaustiveCheck}`);
+      default: {
+        const _exhaustiveCheck: never = type;
+        throw new Error(`Invalid operation type: ${_exhaustiveCheck}`);
+      }

⚠️ Potential issue

Incorrect argument passed to getStreamControllerPair

getStreamControllerPair expects a ReadonlyJSONValue, but an object with a defaultValue property is supplied, causing the initial accumulator state to become { defaultValue: … }.

-  const [stream, controller] = getStreamControllerPair({ defaultValue });
+  const [stream, controller] = getStreamControllerPair(defaultValue);

Without this fix, every snapshot will be wrapped one level deeper than callers expect.

🛠️ Refactor suggestion

Relax strict equality on Content-Type header

Some servers append a charset (text/event-stream; charset=utf-8).
A strict comparison will reject perfectly valid responses.

-  if (response.headers.get("Content-Type") !== "text/event-stream") {
+  const contentType = response.headers.get("Content-Type") ?? "";
+  if (!contentType.startsWith("text/event-stream")) {
     throw new Error("Response is not an event stream");
   }

The same logic can be applied to the custom Assistant-Stream-Format header once the TODO is resolved.

Potential bug: Passing { defaultValue } instead of the raw defaultValue. Likely should call getStreamControllerPair(defaultValue) to avoid nesting.

For improved debugging, consider using op.type in the error message instead of _exhaustiveCheck in the default case.

BUG: Passing { defaultValue } wraps the default value in an extra object. Pass defaultValue directly to getStreamControllerPair.

The strict header check for Content-Type may fail if additional parameters (like charset) are included. Consider a more flexible check.