assistant-stream 0.3.25 → 0.3.27

package/src/core/{object/ObjectStream.test.ts → gorp/GorpStream.test.ts}

@@ -1,11 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { createObjectStream } from "./createObjectStream";
-import {
-  ObjectStreamEncoder,
-  ObjectStreamDecoder,
-} from "./ObjectStreamResponse";
+import { createGorpStream } from "./createGorpStream";
+import { GorpStreamEncoder, GorpStreamDecoder } from "./GorpStreamResponse";
 import type { ReadonlyJSONValue } from "../../utils";
-import type { ObjectStreamChunk } from "./types";
+import type { GorpStreamChunk } from "./types";
 
 // Helper function to collect all chunks from a stream
 async function collectChunks<T>(stream: ReadableStream<T>): Promise<T[]> {
@@ -27,10 +24,10 @@ async function collectChunks<T>(stream: ReadableStream<T>): Promise<T[]> {
 
 // Helper function to encode and decode a stream
 async function encodeAndDecode(
-  stream: ReadableStream<ObjectStreamChunk>,
-): Promise<ReadableStream<ObjectStreamChunk>> {
+  stream: ReadableStream<GorpStreamChunk>,
+): Promise<ReadableStream<GorpStreamChunk>> {
   // Encode the stream to Uint8Array (simulating network transmission)
-  const encodedStream = stream.pipeThrough(new ObjectStreamEncoder());
+  const encodedStream = stream.pipeThrough(new GorpStreamEncoder());
 
   // Collect all encoded chunks
   const encodedChunks = await collectChunks(encodedStream);
@@ -45,14 +42,58 @@ async function encodeAndDecode(
     },
   });
 
-  // Decode the stream back to ObjectStreamChunk
-  return reconstructedStream.pipeThrough(new ObjectStreamDecoder());
+  // Decode the stream back to GorpStreamChunk
+  return reconstructedStream.pipeThrough(new GorpStreamDecoder());
 }
 
-describe("ObjectStream serialization and deserialization", () => {
+describe("GorpStream serialization and deserialization", () => {
+  it("does not settle the stream after cancellation", async () => {
+    let finishExecution!: () => void;
+    let abortSignal!: AbortSignal;
+    const execution = new Promise<void>((resolve) => {
+      finishExecution = resolve;
+    });
+    const stream = createGorpStream({
+      execute: (controller) => {
+        abortSignal = controller.abortSignal;
+        return execution;
+      },
+    });
+    const reader = stream.getReader();
+
+    await reader.cancel("consumer stopped");
+
+    expect(abortSignal.aborted).toBe(true);
+    expect(abortSignal.reason).toBe("consumer stopped");
+
+    finishExecution();
+    await execution;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+
+  it("should discard an unterminated SSE event", async () => {
+    const operations: GorpStreamChunk["operations"] = [
+      { type: "set", path: ["status"], value: "complete" },
+    ];
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(
+          new TextEncoder().encode(`data: ${JSON.stringify(operations)}\n`),
+        );
+        controller.close();
+      },
+    });
+
+    const chunks = await collectChunks(
+      stream.pipeThrough(new GorpStreamDecoder()),
+    );
+
+    expect(chunks).toEqual([]);
+  });
+
   it("should correctly serialize and deserialize simple objects", async () => {
     // Create an object stream with simple operations
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["name"], value: "John" },
@@ -76,7 +117,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle nested objects", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["user", "profile", "name"], value: "Jane" },
@@ -108,7 +149,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle arrays", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["items"], value: [] },
@@ -129,7 +170,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle mixed arrays and objects", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["users"], value: [] },
@@ -156,7 +197,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle append-text operations", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["message"], value: "Hello" },
@@ -176,8 +217,48 @@ describe("ObjectStream serialization and deserialization", () => {
     });
   });
 
+  it("does not apply first-chunk operations twice", async () => {
+    const stream = createGorpStream({
+      defaultValue: { message: "Hello" },
+      execute: (controller) => {
+        controller.enqueue([
+          { type: "append-text", path: ["message"], value: " world" },
+        ]);
+        controller.enqueue([
+          { type: "append-text", path: ["message"], value: "!" },
+        ]);
+      },
+    });
+
+    const decodedStream = await encodeAndDecode(stream);
+    const chunks = await collectChunks(decodedStream);
+
+    expect(chunks).toEqual([
+      {
+        snapshot: { message: "Hello world" },
+        operations: [
+          {
+            type: "set",
+            path: [],
+            value: { message: "Hello world" },
+          },
+        ],
+      },
+      {
+        snapshot: { message: "Hello world!" },
+        operations: [
+          {
+            type: "append-text",
+            path: ["message"],
+            value: "!",
+          },
+        ],
+      },
+    ]);
+  });
+
   it("should correctly handle special characters and Unicode", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           {
@@ -209,7 +290,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle null and undefined values", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["nullValue"], value: null },
@@ -232,7 +313,7 @@ describe("ObjectStream serialization and deserialization", () => {
 
   it("should correctly handle large nested structures", async () => {
     // Create a deep nested structure
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["level1"], value: {} },
@@ -270,7 +351,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle operations in multiple enqueue calls", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         // First batch of operations
         controller.enqueue([
@@ -319,7 +400,7 @@ describe("ObjectStream serialization and deserialization", () => {
   });
 
   it("should correctly handle overwriting existing values", async () => {
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       execute: (controller) => {
         controller.enqueue([
           { type: "set", path: ["value"], value: "initial" },
@@ -351,7 +432,7 @@ describe("ObjectStream serialization and deserialization", () => {
       },
     };
 
-    const stream = createObjectStream({
+    const stream = createGorpStream({
       defaultValue: initialValue,
       execute: (controller) => {
         controller.enqueue([

package/src/core/gorp/GorpStreamAccumulator.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator";
+
+describe("GorpStreamAccumulator", () => {
+  it("rejects unsafe path segments", () => {
+    for (const path of [
+      ["__proto__", "polluted"],
+      ["constructor", "prototype", "polluted"],
+      ["a", "__proto__"],
+    ]) {
+      const acc = new GorpStreamAccumulator({});
+      expect(() => acc.append([{ type: "set", path, value: true }])).toThrow(
+        /Unsafe gorp path segment/,
+      );
+    }
+    expect(({} as { polluted?: unknown }).polluted).toBeUndefined();
+  });
+
+  it("treats inherited keys as absent when navigating", () => {
+    const acc = new GorpStreamAccumulator({});
+    acc.append([{ type: "set", path: ["toString", "x"], value: 1 }]);
+    expect(acc.state).toEqual({ toString: { x: 1 } });
+
+    const append = new GorpStreamAccumulator({ toString: "hi" });
+    append.append([{ type: "append-text", path: ["toString"], value: "!" }]);
+    expect(append.state).toEqual({ toString: "hi!" });
+  });
+});

package/src/core/{object/ObjectStreamAccumulator.ts → gorp/GorpStreamAccumulator.ts}

@@ -1,7 +1,8 @@
 import type { ReadonlyJSONValue, ReadonlyJSONObject } from "../../utils";
-import type { ObjectStreamOperation } from "./types";
+import { assertSafePathSegment } from "./changeTree";
+import type { GorpStreamOperation } from "./types";
 
-export class ObjectStreamAccumulator {
+export class GorpStreamAccumulator {
   private _state: ReadonlyJSONValue;
 
   constructor(initialValue: ReadonlyJSONValue = null) {
@@ -12,24 +13,20 @@ export class ObjectStreamAccumulator {
     return this._state;
   }
 
-  append(ops: readonly ObjectStreamOperation[]) {
+  append(ops: readonly GorpStreamOperation[]) {
     this._state = ops.reduce(
-      (state, op) => ObjectStreamAccumulator.apply(state, op),
+      (state, op) => GorpStreamAccumulator.apply(state, op),
       this._state,
     );
   }
 
-  private static apply(state: ReadonlyJSONValue, op: ObjectStreamOperation) {
+  private static apply(state: ReadonlyJSONValue, op: GorpStreamOperation) {
     const type = op.type;
     switch (type) {
       case "set":
-        return ObjectStreamAccumulator.updatePath(
-          state,
-          op.path,
-          () => op.value,
-        );
+        return GorpStreamAccumulator.updatePath(state, op.path, () => op.value);
       case "append-text":
-        return ObjectStreamAccumulator.updatePath(state, op.path, (current) => {
+        return GorpStreamAccumulator.updatePath(state, op.path, (current) => {
           if (typeof current !== "string")
             throw new Error(`Expected string at path [${op.path.join(", ")}]`);
           return current + op.value;
@@ -57,6 +54,7 @@ export class ObjectStreamAccumulator {
     }
 
     const [key, ...rest] = path as [string, ...(readonly string[])];
+    assertSafePathSegment(key);
     if (Array.isArray(state)) {
       const idx = Number(key);
       if (Number.isNaN(idx))
@@ -65,8 +63,8 @@ export class ObjectStreamAccumulator {
         throw new Error(`Insert array index out of bounds`);
 
       const nextState = [...state];
-      nextState[idx] = ObjectStreamAccumulator.updatePath(
-        nextState[idx],
+      nextState[idx] = GorpStreamAccumulator.updatePath(
+        Object.hasOwn(nextState, idx) ? nextState[idx] : undefined,
         rest,
         updater,
       );
@@ -75,8 +73,8 @@ export class ObjectStreamAccumulator {
     }
 
     const nextState = { ...(state as ReadonlyJSONObject) };
-    nextState[key] = ObjectStreamAccumulator.updatePath(
-      nextState[key],
+    nextState[key] = GorpStreamAccumulator.updatePath(
+      Object.hasOwn(nextState, key) ? nextState[key] : undefined,
       rest,
       updater,
     );

package/src/core/gorp/GorpStreamDeltaTracker.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import { GorpStreamDeltaTracker } from "./GorpStreamDeltaTracker";
+import { createGorpStream } from "./createGorpStream";
+import type { ReadonlyJSONObject } from "../../utils";
+
+describe("GorpStreamDeltaTracker frames", () => {
+  it("reports ops of the current frame in getChangedKeys", () => {
+    const tracker = new GorpStreamDeltaTracker({ items: {} });
+    tracker.append([
+      { type: "set", path: ["items", "a"], value: { name: "alpha" } },
+    ]);
+    expect(tracker.getChangedKeys(["items"])).toEqual(["a"]);
+    expect((tracker.state as ReadonlyJSONObject).items).toEqual({
+      a: { name: "alpha" },
+    });
+  });
+
+  it("opens a separate frame per append", () => {
+    const tracker = new GorpStreamDeltaTracker({ items: {} });
+    tracker.append([
+      { type: "set", path: ["items", "a"], value: { name: "alpha" } },
+    ]);
+    tracker.append([
+      { type: "set", path: ["items", "b"], value: { name: "beta" } },
+    ]);
+    expect(tracker.getChangedKeys(["items"])).toEqual(["b"]);
+    expect(tracker.isChangedAt(["items", "a"])).toBe(false);
+  });
+
+  it("reports an empty change set before the first append and after an empty append", () => {
+    const tracker = new GorpStreamDeltaTracker({ count: 0 });
+    expect(tracker.isChangedAt([])).toBe(false);
+    expect(tracker.isChangedAt(["count"])).toBe(false);
+    expect(tracker.getChangedKeys([])).toEqual([]);
+    tracker.append([{ type: "set", path: ["count"], value: 1 }]);
+    expect(tracker.isChangedAt([])).toBe(true);
+    tracker.append([]);
+    expect(tracker.isChangedAt([])).toBe(false);
+    expect(tracker.isChangedAt(["count"])).toBe(false);
+    expect(tracker.getChangedKeys([])).toEqual([]);
+  });
+});
+
+describe("GorpStreamDeltaTracker isChangedAt", () => {
+  it("returns truthy for any path inside a marked subtree", () => {
+    const tracker = new GorpStreamDeltaTracker();
+    tracker.append([{ type: "set", path: [], value: { items: {} } }]);
+    expect(tracker.isChangedAt([])).toBe(true);
+    expect(tracker.isChangedAt(["items"])).toBe(true);
+    expect(tracker.isChangedAt(["items", "anything", "deep"])).toBe(true);
+  });
+
+  it("returns true for ancestors of a changed path and false for siblings", () => {
+    const tracker = new GorpStreamDeltaTracker({ a: { b: "x" }, c: "y" });
+    tracker.append([{ type: "set", path: ["a", "b"], value: "z" }]);
+    expect(tracker.isChangedAt([])).toBe(true);
+    expect(tracker.isChangedAt(["a"])).toBe(true);
+    expect(tracker.isChangedAt(["a", "b"])).toBe(true);
+    expect(tracker.isChangedAt(["c"])).toBe(false);
+  });
+
+  it("marks append-text targets as changed", () => {
+    const tracker = new GorpStreamDeltaTracker({ message: "Hello" });
+    tracker.append([{ type: "append-text", path: ["message"], value: "!" }]);
+    expect(tracker.isChangedAt(["message"])).toBe(true);
+    expect(tracker.getChangedKeys([])).toEqual(["message"]);
+    expect((tracker.state as ReadonlyJSONObject).message).toBe("Hello!");
+  });
+});
+
+describe("GorpStreamDeltaTracker getChangedKeys", () => {
+  it("diffs keys against the previous frame when a subtree is fully replaced", () => {
+    const tracker = new GorpStreamDeltaTracker({ count: 0, items: {} });
+    tracker.append([
+      { type: "set", path: ["items", "a"], value: { name: "alpha" } },
+    ]);
+    tracker.append([
+      { type: "set", path: ["items", "b"], value: { name: "beta" } },
+    ]);
+    tracker.append([
+      {
+        type: "set",
+        path: [],
+        value: {
+          count: 99,
+          items: { b: { name: "beta-new" }, c: { name: "gamma" } },
+        },
+      },
+    ]);
+    expect(tracker.getChangedKeys(["items"])).toEqual(["b", "c", "a"]);
+  });
+
+  it("returns interior node keys for a partially changed subtree", () => {
+    const tracker = new GorpStreamDeltaTracker({ items: { a: 1, b: 2 } });
+    tracker.append([
+      { type: "set", path: ["items", "a"], value: 10 },
+      { type: "set", path: ["items", "c"], value: 3 },
+    ]);
+    expect(tracker.getChangedKeys(["items"])).toEqual(["a", "c"]);
+    expect(tracker.getChangedKeys([])).toEqual(["items"]);
+    expect(tracker.getChangedKeys(["other"])).toEqual([]);
+  });
+
+  it("diffs keys when the previous value at a replaced path was not an object", () => {
+    const tracker = new GorpStreamDeltaTracker({ value: "initial" });
+    tracker.append([{ type: "set", path: ["value"], value: { nested: true } }]);
+    expect(tracker.getChangedKeys(["value"])).toEqual(["nested"]);
+  });
+});
+
+describe("GorpStreamDeltaTracker inherited object members", () => {
+  it("does not treat inherited members as changes on a fresh tracker", () => {
+    const tracker = new GorpStreamDeltaTracker({ items: {} });
+    expect(tracker.isChangedAt(["toString"])).toBe(false);
+    expect(tracker.isChangedAt(["hasOwnProperty"])).toBe(false);
+    expect(tracker.getChangedKeys(["toString"])).toEqual([]);
+  });
+
+  it("does not treat inherited members as changes on a populated tree", () => {
+    const tracker = new GorpStreamDeltaTracker({ items: {} });
+    tracker.append([{ type: "set", path: ["items", "a"], value: 1 }]);
+    expect(tracker.isChangedAt(["toString"])).toBe(false);
+    expect(tracker.isChangedAt(["items", "toString"])).toBe(false);
+    expect(tracker.isChangedAt(["items", "valueOf", "deep"])).toBe(false);
+    expect(tracker.getChangedKeys([])).toEqual(["items"]);
+    expect(tracker.getChangedKeys(["items"])).toEqual(["a"]);
+  });
+});
+
+describe("GorpStreamDeltaTracker failed append", () => {
+  it("leaves state and the change frame untouched when an operation throws", () => {
+    const tracker = new GorpStreamDeltaTracker({ count: 5, message: "hi" });
+    tracker.append([{ type: "set", path: ["message"], value: "hello" }]);
+    const stateBefore = tracker.state;
+
+    expect(() =>
+      tracker.append([
+        { type: "set", path: ["other"], value: 1 },
+        { type: "append-text", path: ["count"], value: "!" },
+      ]),
+    ).toThrow(/Expected string/);
+
+    expect(tracker.state).toBe(stateBefore);
+    expect(tracker.isChangedAt(["message"])).toBe(true);
+    expect(tracker.isChangedAt(["other"])).toBe(false);
+    expect(tracker.isChangedAt(["count"])).toBe(false);
+    expect(tracker.getChangedKeys([])).toEqual(["message"]);
+  });
+});
+
+describe("GorpStreamDeltaTracker streamed accumulation", () => {
+  it("tracks one frame per streamed chunk", async () => {
+    const stream = createGorpStream({
+      execute: (controller) => {
+        controller.enqueue([
+          { type: "set", path: ["user"], value: { name: "Initial" } },
+        ]);
+        controller.enqueue([
+          { type: "set", path: ["user", "name"], value: "Updated" },
+          { type: "set", path: ["user", "email"], value: "user@example.com" },
+        ]);
+        controller.enqueue([
+          { type: "set", path: ["status"], value: "complete" },
+        ]);
+      },
+    });
+
+    const tracker = new GorpStreamDeltaTracker();
+    const frames: string[][] = [];
+    for await (const chunk of stream) {
+      tracker.append(chunk.operations);
+      frames.push(tracker.getChangedKeys(["user"]));
+      expect(tracker.state).toEqual(chunk.snapshot);
+    }
+
+    expect(frames).toEqual([["name"], ["name", "email"], []]);
+    expect(tracker.state).toEqual({
+      user: { name: "Updated", email: "user@example.com" },
+      status: "complete",
+    });
+  });
+});

package/src/core/gorp/GorpStreamDeltaTracker.ts

@@ -0,0 +1,55 @@
+import type { ReadonlyJSONValue } from "../../utils";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator";
+import type { GorpStreamOperation } from "./types";
+import {
+  type ChangeNode,
+  createChangeNode,
+  diffKeys,
+  lookupChange,
+  lookupValue,
+  markChanged,
+} from "./changeTree";
+
+export class GorpStreamDeltaTracker {
+  private readonly accumulator: GorpStreamAccumulator;
+  private previousState: ReadonlyJSONValue;
+  private changes: ChangeNode = createChangeNode();
+
+  constructor(initialValue: ReadonlyJSONValue = null) {
+    this.accumulator = new GorpStreamAccumulator(initialValue);
+    this.previousState = this.accumulator.state;
+  }
+
+  get state(): ReadonlyJSONValue {
+    return this.accumulator.state;
+  }
+
+  append(operations: readonly GorpStreamOperation[]): void {
+    const previousState = this.accumulator.state;
+    let changes: ChangeNode = createChangeNode();
+    for (const op of operations) {
+      changes = markChanged(changes, op.path);
+    }
+    this.accumulator.append(operations);
+    this.previousState = previousState;
+    this.changes = changes;
+  }
+
+  isChangedAt(path: readonly string[]): boolean {
+    const node = lookupChange(this.changes, path);
+    if (node === true) return true;
+    return node !== false && Object.keys(node).length > 0;
+  }
+
+  getChangedKeys(path: readonly string[]): string[] {
+    const node = lookupChange(this.changes, path);
+    if (node === false) return [];
+    if (node === true) {
+      return diffKeys(
+        lookupValue(this.accumulator.state, path),
+        lookupValue(this.previousState, path),
+      );
+    }
+    return Object.keys(node);
+  }
+}

package/src/core/gorp/GorpStreamResponse.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { fromGorpStreamResponse } from "./GorpStreamResponse";
+
+const createResponse = (contentType?: string) => {
+  const headers = new Headers({
+    "Assistant-Stream-Format": "object-stream/v0",
+  });
+  if (contentType) headers.set("Content-Type", contentType);
+
+  return new Response(new Uint8Array(), { headers });
+};
+
+describe("fromGorpStreamResponse", () => {
+  it.each([
+    "text/event-stream",
+    "text/event-stream; charset=utf-8",
+    "Text/Event-Stream; Charset=UTF-8",
+  ])("accepts the event-stream content type %s", (contentType) => {
+    expect(() =>
+      fromGorpStreamResponse(createResponse(contentType)),
+    ).not.toThrow();
+  });
+
+  it.each([undefined, "application/json", "text/event-streaming"])(
+    "rejects the content type %s",
+    (contentType) => {
+      expect(() => fromGorpStreamResponse(createResponse(contentType))).toThrow(
+        "Response is not an event stream",
+      );
+    },
+  );
+});

package/src/core/gorp/GorpStreamResponse.ts

@@ -0,0 +1,88 @@
+import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator";
+import { SSEDecoder, SSEEncoder } from "../utils/stream/SSE";
+import type { GorpStreamChunk, GorpStreamOperation } from "./types";
+
+export class GorpStreamEncoder extends PipeableTransformStream<
+  GorpStreamChunk,
+  Uint8Array
+> {
+  constructor() {
+    let isFirstChunk = true;
+    super((readable) =>
+      readable
+        .pipeThrough(
+          new TransformStream<GorpStreamChunk, readonly GorpStreamOperation[]>({
+            transform(chunk, controller) {
+              if (isFirstChunk) {
+                controller.enqueue([
+                  { type: "set", path: [], value: chunk.snapshot },
+                ]);
+              } else {
+                controller.enqueue(chunk.operations);
+              }
+              isFirstChunk = false;
+            },
+          }),
+        )
+        .pipeThrough(new SSEEncoder()),
+    );
+  }
+}
+
+export class GorpStreamDecoder extends PipeableTransformStream<
+  Uint8Array<ArrayBuffer>,
+  GorpStreamChunk
+> {
+  constructor() {
+    const accumulator = new GorpStreamAccumulator();
+    super((readable) =>
+      readable
+        .pipeThrough(new SSEDecoder<readonly GorpStreamOperation[]>())
+        .pipeThrough(
+          new TransformStream<readonly GorpStreamOperation[], GorpStreamChunk>({
+            transform(operations, controller) {
+              accumulator.append(operations);
+              controller.enqueue({
+                snapshot: accumulator.state,
+                operations,
+              });
+            },
+          }),
+        ),
+    );
+  }
+}
+
+export class GorpStreamResponse extends Response {
+  constructor(body: ReadableStream<GorpStreamChunk>) {
+    super(body.pipeThrough(new GorpStreamEncoder()), {
+      headers: new Headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Assistant-Stream-Format": "object-stream/v0",
+      }),
+    });
+  }
+}
+
+export const fromGorpStreamResponse = (
+  response: Response,
+): ReadableStream<GorpStreamChunk> => {
+  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 GorpStreamDecoder());
+};