assistant-stream 0.3.26 → 0.3.27

package/src/core/serialization/assistant-transport/AssistantTransport.ts

@@ -1,3 +1,4 @@
+import sjson from "secure-json-parse";
 import type { AssistantStreamChunk } from "../../AssistantStreamChunk";
 import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream";
 import {
@@ -6,6 +7,70 @@ import {
 } from "../../utils/stream/SSEEventDecoderStream";
 import type { AssistantStreamEncoder } from "../../AssistantStream";
 
+type ChunkFields = Record<string, unknown>;
+
+type ChunkRule = {
+  kind: "message" | "part-addressed";
+  valid: (chunk: ChunkFields) => boolean;
+};
+
+const noFields = () => true;
+const requiredObject = (key: string) => (c: ChunkFields) => {
+  const value = c[key];
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const requiredString = (key: string) => (c: ChunkFields) =>
+  typeof c[key] === "string";
+const requiredArray = (key: string) => (c: ChunkFields) =>
+  Array.isArray(c[key]);
+const optionalBoolean = (key: string) => (c: ChunkFields) =>
+  c[key] === undefined || typeof c[key] === "boolean";
+
+const KNOWN_CHUNK_TYPES: Record<AssistantStreamChunk["type"], ChunkRule> = {
+  "part-start": { kind: "message", valid: requiredObject("part") },
+  "part-finish": { kind: "part-addressed", valid: noFields },
+  "tool-call-args-text-finish": { kind: "part-addressed", valid: noFields },
+  "text-delta": { kind: "part-addressed", valid: requiredString("textDelta") },
+  annotations: { kind: "message", valid: requiredArray("annotations") },
+  data: { kind: "message", valid: requiredArray("data") },
+  "step-start": { kind: "message", valid: noFields },
+  "step-finish": { kind: "message", valid: requiredString("finishReason") },
+  "message-finish": { kind: "message", valid: requiredString("finishReason") },
+  result: { kind: "part-addressed", valid: optionalBoolean("isError") },
+  error: { kind: "message", valid: noFields },
+  "update-state": { kind: "message", valid: requiredArray("operations") },
+};
+
+const parseChunk = (data: string): AssistantStreamChunk | string => {
+  let value: unknown;
+  try {
+    value = sjson.parse(data);
+  } catch {
+    return "unparseable";
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "not-an-object";
+  const { type, path } = value as { type?: unknown; path?: unknown };
+  if (
+    typeof type !== "string" ||
+    !Object.prototype.hasOwnProperty.call(KNOWN_CHUNK_TYPES, type)
+  )
+    return "unknown-type";
+  const rule = KNOWN_CHUNK_TYPES[type as AssistantStreamChunk["type"]];
+  if (!rule.valid(value as Record<string, unknown>))
+    return `invalid-fields:${type}`;
+  if (path === undefined) {
+    if (rule.kind !== "message") return `missing-path:${type}`;
+    return { ...value, path: [] } as unknown as AssistantStreamChunk;
+  }
+  if (
+    !Array.isArray(path) ||
+    !path.every((entry) => Number.isInteger(entry) && entry >= 0)
+  )
+    return "invalid-path";
+  return value as AssistantStreamChunk;
+};
+
 /**
  * AssistantTransportEncoder encodes AssistantStreamChunks into SSE format
  * and emits [DONE] when the stream completes.
@@ -49,6 +114,7 @@ export class AssistantTransportDecoder extends PipeableTransformStream<
   constructor() {
     super((readable) => {
       let receivedDone = false;
+      const warnedReasons = new Set<string>();
 
       return readable
         .pipeThrough(new TextDecoderStream())
@@ -64,7 +130,17 @@ export class AssistantTransportDecoder extends PipeableTransformStream<
                     // Stop processing when we encounter [DONE]
                     controller.terminate();
                   } else {
-                    controller.enqueue(JSON.parse(event.data));
+                    const chunk = parseChunk(event.data);
+                    if (typeof chunk === "string") {
+                      if (!warnedReasons.has(chunk)) {
+                        warnedReasons.add(chunk);
+                        console.warn(
+                          `Dropped invalid assistant-transport chunk (${chunk}): ${event.data.slice(0, 200)}`,
+                        );
+                      }
+                    } else {
+                      controller.enqueue(chunk);
+                    }
                   }
                   break;
                 default:

package/src/core/serialization/data-stream/chunk-types.ts

@@ -2,7 +2,7 @@ import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
 } from "../../../utils/json/json-value";
-import type { ObjectStreamOperation } from "../../object/types";
+import type { GorpStreamOperation } from "../../gorp/types";
 
 export type DataStreamChunk = {
   [K in DataStreamStreamChunkType]: {
@@ -100,7 +100,7 @@ type DataStreamStreamChunkValue = {
   [DataStreamStreamChunkType.File]: { data: string; mimeType: string };
 
   // aui-extensions
-  [DataStreamStreamChunkType.AuiUpdateStateOperations]: ObjectStreamOperation[];
+  [DataStreamStreamChunkType.AuiUpdateStateOperations]: GorpStreamOperation[];
   [DataStreamStreamChunkType.AuiTextDelta]: {
     textDelta: string;
     parentId: string;

package/src/core/serialization/ui-message-stream/UIMessageStream.test.ts

@@ -575,4 +575,115 @@ describe("UIMessageStreamDecoder", () => {
     // Should not throw, should complete successfully
     expect(chunks.some((c) => c.type === "message-finish")).toBe(true);
   });
+
+  it("drops frames that are not objects with a string type", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const invalidFrames = [
+      "null",
+      "5",
+      '"text"',
+      "[1,2]",
+      '{"foo":1}',
+      '{"type":5}',
+    ];
+    const events = [
+      ...invalidFrames,
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-delta", id: "t", delta: "ok" }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    expect(warn.mock.calls.map((c) => c[0])).toEqual(
+      invalidFrames.map((f) => `Dropped invalid UIMessageStream chunk: ${f}`),
+    );
+    expect(chunks.some((c) => c.type === "text-delta")).toBe(true);
+    warn.mockRestore();
+  });
+
+  it("drops frames that are not valid JSON", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const invalidFrames = ['{"type":"te', "not json"];
+    const events = [
+      ...invalidFrames,
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-delta", id: "t", delta: "ok" }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    expect(warn.mock.calls.map((c) => c[0])).toEqual(
+      invalidFrames.map((f) => `Dropped invalid UIMessageStream chunk: ${f}`),
+    );
+    expect(chunks.some((c) => c.type === "text-delta")).toBe(true);
+    warn.mockRestore();
+  });
+
+  it("ignores a tool-call-delta arriving after tool-result", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_abc",
+        toolName: "weather",
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"city":"NYC"}' }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_abc",
+        result: { temp: 72 },
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"late":true}' }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    const argDeltas = chunks.filter((c) => c.type === "text-delta");
+    expect(argDeltas).toHaveLength(1);
+    expect(chunks.some((c) => c.type === "result")).toBe(true);
+  });
+
+  it("keeps the active tool call writable when another call receives its result", async () => {
+    const events = [
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_a",
+        toolName: "first",
+      }),
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_b",
+        toolName: "second",
+      }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_a",
+        result: { ok: true },
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"x":1}' }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    const argDeltas = chunks.filter(
+      (c): c is AssistantStreamChunk & { type: "text-delta" } =>
+        c.type === "text-delta",
+    );
+    expect(argDeltas).toHaveLength(2);
+    const byPath = new Map(argDeltas.map((c) => [c.path[0], c.textDelta]));
+    expect(byPath.get(0)).toBe("{}");
+    expect(byPath.get(1)).toBe('{"x":1}');
+  });
 });

package/src/core/serialization/ui-message-stream/UIMessageStream.ts

@@ -149,6 +149,9 @@ export class UIMessageStreamDecoder extends PipeableTransformStream<
                   `Encountered tool result with unknown id: ${chunk.toolCallId}`,
                 );
               }
+              if (toolCallController.argsText === activeToolCallArgsText) {
+                activeToolCallArgsText = undefined;
+              }
               toolCallController.setResponse({
                 result: chunk.result,
                 isError: chunk.isError ?? false,
@@ -222,7 +225,23 @@ export class UIMessageStreamDecoder extends PipeableTransformStream<
                 return;
               }
 
-              const chunk = JSON.parse(event.data);
+              let chunk;
+              try {
+                chunk = JSON.parse(event.data);
+              } catch {
+                chunk = undefined;
+              }
+              if (
+                typeof chunk !== "object" ||
+                chunk === null ||
+                Array.isArray(chunk) ||
+                typeof chunk.type !== "string"
+              ) {
+                console.warn(
+                  `Dropped invalid UIMessageStream chunk: ${event.data.slice(0, 200)}`,
+                );
+                return;
+              }
               if (
                 chunk.type === "text-delta" &&
                 chunk.textDelta === undefined

package/src/core/tool/ToolExecutionStream.ts

@@ -51,6 +51,7 @@ export class ToolExecutionStream extends PipeableTransformStream<
       string,
       ToolCallReaderImpl<ReadonlyJSONObject, ReadonlyJSONValue>
     >();
+    const toolCallIdsWithBackendResult = new Set<string>();
 
     super((readable) => {
       const transform = new TransformStream<
@@ -109,6 +110,7 @@ export class ToolExecutionStream extends PipeableTransformStream<
                   modelContent: chunk.modelContent,
                 }),
               );
+              toolCallIdsWithBackendResult.add(toolCallId);
               break;
             }
             case "tool-call-args-text-finish": {
@@ -123,6 +125,11 @@ export class ToolExecutionStream extends PipeableTransformStream<
               // resolve. Awaited so the close settles before the writer is reused.
               await streamController.finishArgsText();
 
+              // A backend result is authoritative. Closing the args stream still
+              // emits this finish chunk, but must not parse stale/incomplete args,
+              // execute the frontend tool, or enqueue a second result.
+              if (toolCallIdsWithBackendResult.has(toolCallId)) break;
+
               let isExecuting = false;
               const promise = withPromiseOrValue(
                 () => {
@@ -206,10 +213,13 @@ export class ToolExecutionStream extends PipeableTransformStream<
                 toolCallPromise.then(() => {
                   toolCallPromises.delete(toolCallId);
                   toolCallControllers.delete(toolCallId);
+                  toolCallIdsWithBackendResult.delete(toolCallId);
 
                   controller.enqueue(chunk);
                 });
               } else {
+                toolCallControllers.delete(toolCallId);
+                toolCallIdsWithBackendResult.delete(toolCallId);
                 controller.enqueue(chunk);
               }
             }

package/src/core/tool/toolResultStream.test.ts

@@ -17,6 +17,56 @@ const createDelayedTool = (delay: number, result?: string): Tool => ({
 });
 
 describe("unstable_runPendingTools", () => {
+  it("removes the abort listener after tool execution settles", async () => {
+    const abortController = new AbortController();
+    const addEventListener = vi.spyOn(
+      abortController.signal,
+      "addEventListener",
+    );
+    const removeEventListener = vi.spyOn(
+      abortController.signal,
+      "removeEventListener",
+    );
+    const message: AssistantMessage = {
+      role: "assistant",
+      status: { type: "requires-action", reason: "tool-calls" },
+      parts: [
+        {
+          type: "tool-call",
+          toolCallId: "1",
+          toolName: "tool",
+          args: {},
+        } as ToolCallPart,
+      ],
+      content: [],
+      metadata: {
+        unstable_state: {},
+        unstable_data: [],
+        unstable_annotations: [],
+        steps: [],
+        custom: {},
+      },
+    };
+
+    await unstable_runPendingTools(
+      message,
+      {
+        tool: {
+          parameters: { type: "object", properties: {} },
+          execute: async () => "done",
+        },
+      },
+      abortController.signal,
+      async () => {},
+    );
+
+    expect(addEventListener).toHaveBeenCalledOnce();
+    expect(removeEventListener).toHaveBeenCalledWith(
+      "abort",
+      addEventListener.mock.calls[0]![1],
+    );
+  });
+
   describe("parallel execution", () => {
     it("should run tool calls in parallel", async () => {
       const tool1 = createDelayedTool(100, "Tool 1");

package/src/core/tool/toolResultStream.ts

@@ -59,9 +59,10 @@ function getToolResponse(
 
     // Create abort promise that resolves after 2 microtasks
     // This gives tools that handle abort a chance to win the race
+    let onAbort!: () => void;
     const abortPromise = new Promise<ToolResponse<ReadonlyJSONValue>>(
       (resolve) => {
-        const onAbort = () => {
+        onAbort = () => {
           queueMicrotask(() => {
             queueMicrotask(() => {
               resolve(
@@ -116,7 +117,11 @@ function getToolResponse(
       return response;
     })();
 
-    return Promise.race([executePromise, abortPromise]);
+    try {
+      return await Promise.race([executePromise, abortPromise]);
+    } finally {
+      abortSignal.removeEventListener("abort", onAbort);
+    }
   };
 
   return getResult(tool.execute);

package/src/core/utils/stream/merge.ts

@@ -9,9 +9,18 @@ type MergeStreamItem = {
 export const createMergeStream = () => {
   const list: MergeStreamItem[] = [];
   let sealed = false;
+  let cancelled = false;
+  let errored = false;
   let controller: ReadableStreamDefaultController<AssistantStreamChunk>;
   let currentPull: ReturnType<typeof promiseWithResolvers<void>> | undefined;
 
+  const cancelAllReaders = () => {
+    list.forEach((item) => {
+      void item.reader.cancel().catch(() => undefined);
+    });
+    list.length = 0;
+  };
+
   const handlePull = (item: MergeStreamItem) => {
     if (!item.promise) {
       // TODO for most streams, we can directly pipeTo to avoid the microTask queue
@@ -23,6 +32,8 @@ export const createMergeStream = () => {
         .read()
         .then(({ done, value }) => {
           item.promise = undefined;
+          if (cancelled || errored) return;
+
           if (done) {
             list.splice(list.indexOf(item), 1);
             if (sealed && list.length === 0) {
@@ -36,12 +47,11 @@ export const createMergeStream = () => {
           currentPull = undefined;
         })
         .catch((e) => {
-          console.error(e);
+          if (cancelled || errored) return;
 
-          list.forEach((item) => {
-            item.reader.cancel();
-          });
-          list.length = 0;
+          errored = true;
+          console.error(e);
+          cancelAllReaders();
 
           controller.error(e);
 
@@ -64,10 +74,10 @@ export const createMergeStream = () => {
       return currentPull.promise;
     },
     cancel() {
-      list.forEach((item) => {
-        item.reader.cancel();
-      });
-      list.length = 0;
+      cancelled = true;
+      cancelAllReaders();
+      currentPull?.resolve();
+      currentPull = undefined;
     },
   });
 
@@ -76,11 +86,23 @@ export const createMergeStream = () => {
     isSealed() {
       return sealed;
     },
+    isCancelled() {
+      return cancelled;
+    },
+    isErrored() {
+      return errored;
+    },
     seal() {
+      if (cancelled || errored) return;
       sealed = true;
       if (list.length === 0) controller.close();
     },
     addStream(stream: ReadableStream<AssistantStreamChunk>) {
+      if (cancelled || errored) {
+        void stream.cancel().catch(() => undefined);
+        return;
+      }
+
       if (sealed)
         throw new Error(
           "Cannot add streams after the run callback has settled.",

package/src/gorp.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import * as entry from "./index";
+
+describe("assistant-transport state exports", () => {
+  it("exposes the assistant-transport surface and no gorp-shaped names", () => {
+    expect(typeof entry.AssistantTransportDeltaTracker).toBe("function");
+    expect(typeof entry.createObjectStream).toBe("function");
+    expect(typeof entry.ObjectStreamResponse).toBe("function");
+    expect(typeof entry.fromObjectStreamResponse).toBe("function");
+    for (const name of Object.keys(entry)) {
+      expect(name.toLowerCase()).not.toContain("gorp");
+    }
+  });
+
+  it("streams operations end to end through the SSE wire", async () => {
+    const stream = entry.createObjectStream({
+      execute: (controller) => {
+        controller.enqueue([
+          { type: "set", path: ["message"], value: "Hello" },
+        ]);
+        controller.enqueue([
+          { type: "append-text", path: ["message"], value: " World" },
+        ]);
+      },
+    });
+
+    const response = new entry.ObjectStreamResponse(stream);
+    const decoded = entry.fromObjectStreamResponse(response);
+
+    const tracker = new entry.AssistantTransportDeltaTracker();
+    const reader = decoded.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      tracker.append(value.operations);
+      expect(tracker.state).toEqual(value.snapshot);
+    }
+
+    expect(tracker.state).toEqual({ message: "Hello World" });
+    expect(tracker.isChangedAt(["message"])).toBe(true);
+  });
+});

package/src/index.ts

@@ -62,12 +62,27 @@ export {
 export type { TextStreamController } from "./core/modules/text";
 export type { ToolCallStreamController } from "./core/modules/tool-call";
 
-export { createObjectStream } from "./core/object/createObjectStream";
-export {
-  ObjectStreamResponse,
-  fromObjectStreamResponse,
-} from "./core/object/ObjectStreamResponse";
-export type { ObjectStreamChunk } from "./core/object/types";
+import { createGorpStream } from "./core/gorp/createGorpStream";
+import {
+  GorpStreamResponse,
+  fromGorpStreamResponse,
+} from "./core/gorp/GorpStreamResponse";
+import type { GorpStreamChunk } from "./core/gorp/types";
+import { GorpStreamDeltaTracker } from "./core/gorp/GorpStreamDeltaTracker";
+
+export { GorpStreamDeltaTracker as AssistantTransportDeltaTracker };
+export type { AssistantTransportStateOperation } from "./core/gorp/types";
+
+/** @deprecated Use the assistant-transport surface instead. */
+export const createObjectStream = createGorpStream;
+/** @deprecated Use the assistant-transport surface instead. */
+export const ObjectStreamResponse = GorpStreamResponse;
+/** @deprecated Use the assistant-transport surface instead. */
+export type ObjectStreamResponse = GorpStreamResponse;
+/** @deprecated Use the assistant-transport surface instead. */
+export const fromObjectStreamResponse = fromGorpStreamResponse;
+/** @deprecated Use the assistant-transport surface instead. */
+export type ObjectStreamChunk = GorpStreamChunk;
 
 export {
   toGenericMessages,

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");
+  });
 });