@assistant-ui/core 0.3.18 → 0.3.19

package/src/utils/abortable-iterable.ts

@@ -1,24 +1,28 @@
 const done = <T>(): IteratorResult<T> => ({ done: true, value: undefined });
 
-/** Resolves at cancellation, so an await on a stream can stop being the only way out. */
-const whenAborted = (signal: AbortSignal): Promise<undefined> =>
-  new Promise((resolve) => {
-    if (signal.aborted) return resolve(undefined);
-    signal.addEventListener("abort", () => resolve(undefined), { once: true });
-  });
-
 export const openAbortableIterable = async <T>(
   source: AsyncIterable<T> | Promise<AsyncIterable<T>>,
   signal: AbortSignal,
 ): Promise<AsyncIterable<T> | undefined> => {
   const opened = Promise.resolve(source);
-  const iterable = await Promise.race([opened, whenAborted(signal)]);
-  if (!iterable) {
-    void opened
-      .then((late) => late[Symbol.asyncIterator]().return?.(undefined))
-      .catch(() => {});
+  let release = () => {};
+  const aborted = new Promise<undefined>((resolve) => {
+    const onAbort = () => resolve(undefined);
+    if (signal.aborted) return onAbort();
+    signal.addEventListener("abort", onAbort, { once: true });
+    release = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    const iterable = await Promise.race([opened, aborted]);
+    if (!iterable) {
+      void opened
+        .then((late) => late[Symbol.asyncIterator]().return?.(undefined))
+        .catch(() => {});
+    }
+    return iterable;
+  } finally {
+    release();
   }
-  return iterable;
 };
 
 /**
@@ -40,7 +44,10 @@ export const abortableIterable = <T>(
 ): AsyncIterable<T> => ({
   [Symbol.asyncIterator]: () => {
     const iterator = source[Symbol.asyncIterator]();
+    let finished = false;
     const finalize = () => {
+      if (finished) return;
+      finished = true;
       try {
         iterator.return?.(undefined)?.catch(() => {});
       } catch {
@@ -53,7 +60,7 @@ export const abortableIterable = <T>(
         return this;
       },
       next: () => {
-        if (signal.aborted) {
+        if (finished || signal.aborted) {
           finalize();
           return Promise.resolve(done<T>());
         }
@@ -68,17 +75,21 @@ export const abortableIterable = <T>(
           signal.addEventListener("abort", onAbort, { once: true });
           const release = () => signal.removeEventListener("abort", onAbort);
 
-          iterator.next().then(
-            (result) => {
+          const onError = (error: unknown) => {
+            release();
+            finalize();
+            reject(error);
+          };
+          try {
+            void iterator.next().then((result) => {
               release();
+              if (finished) return resolve(done<T>());
+              if (result.done) finished = true;
               resolve(result);
-            },
-            (error: unknown) => {
-              release();
-              finalize();
-              reject(error);
-            },
-          );
+            }, onError);
+          } catch (error) {
+            onError(error);
+          }
         });
       },
       // The consumer breaks out of the loop to stop a cancelled run, so this is

package/src/utils/getGroupStatus.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { getGroupStatus } from "./getGroupStatus";
+import type {
+  MessagePartStatus,
+  ToolCallMessagePartStatus,
+} from "../types/message";
+import { getGroupStatus, getGroupSummary } from "./getGroupStatus";
+
+type Status = MessagePartStatus | ToolCallMessagePartStatus;
+
+const part = (status: Status) => ({ status });
 
 describe("getGroupStatus", () => {
   it("reports running when the first member is running and the last is complete", () => {
@@ -10,7 +18,6 @@ describe("getGroupStatus", () => {
     const status = getGroupStatus(parts);
 
     expect(status).toEqual({ type: "running" });
-    expect(getGroupStatus(parts, [0, 1])).toBe(status);
     expect(status).toBe(getGroupStatus([{ status: { type: "running" } }]));
     expect(Object.isFrozen(status)).toBe(true);
   });
@@ -27,10 +34,69 @@ describe("getGroupStatus", () => {
 
   it("matches the positional outcome for statusless adapters", () => {
     expect(
-      getGroupStatus(
+      getGroupSummary(
         [{ status: { type: "complete" } }, { status: { type: "running" } }],
         [0, 1],
-      ),
+      ).status,
     ).toEqual({ type: "running" });
   });
 });
+
+describe("getGroupSummary", () => {
+  it("tallies every status over the requested indices and reports running when any part runs", () => {
+    const summary = getGroupSummary(
+      [
+        part({ type: "complete" }),
+        part({ type: "running" }),
+        part({ type: "incomplete", reason: "error" }),
+        part({ type: "requires-action", reason: "tool-calls" }),
+      ],
+      [0, 1, 2, 3],
+    );
+
+    expect(summary.counts).toEqual({
+      running: 1,
+      complete: 1,
+      incomplete: 1,
+      requiresAction: 1,
+    });
+    expect(
+      Object.values(summary.counts).reduce((sum, count) => sum + count),
+    ).toBe(4);
+    expect(summary.status).toEqual({ type: "running" });
+  });
+
+  it("uses the last status when no part runs and treats missing parts as complete", () => {
+    const summary = getGroupSummary(
+      [
+        undefined,
+        part({ type: "incomplete", reason: "cancelled" }),
+        part({ type: "requires-action", reason: "interrupt" }),
+      ],
+      [0, 1, 2],
+    );
+
+    expect(summary.counts).toEqual({
+      running: 0,
+      complete: 1,
+      incomplete: 1,
+      requiresAction: 1,
+    });
+    expect(summary.status).toEqual({
+      type: "requires-action",
+      reason: "interrupt",
+    });
+  });
+
+  it("returns complete with zero counts for empty indices", () => {
+    expect(getGroupSummary([], [])).toEqual({
+      status: { type: "complete" },
+      counts: {
+        running: 0,
+        complete: 0,
+        incomplete: 0,
+        requiresAction: 0,
+      },
+    });
+  });
+});

package/src/utils/getGroupStatus.ts

@@ -10,22 +10,45 @@ type PartWithStatus = {
 
 export const getGroupStatus = (
   parts: readonly (PartWithStatus | undefined)[],
-  indices?: readonly number[],
 ): MessagePartStatus | ToolCallMessagePartStatus => {
-  if (indices) {
-    for (const index of indices) {
-      if (parts[index]?.status.type === "running") return RUNNING_STATUS;
-    }
-
-    const lastIndex = indices.at(-1);
-    return lastIndex === undefined
-      ? COMPLETE_STATUS
-      : (parts[lastIndex]?.status ?? COMPLETE_STATUS);
-  }
-
   for (const part of parts) {
     if (part?.status.type === "running") return RUNNING_STATUS;
   }
 
   return parts.at(-1)?.status ?? COMPLETE_STATUS;
 };
+
+export const getGroupSummary = (
+  parts: readonly (PartWithStatus | undefined)[],
+  indices: readonly number[],
+) => {
+  const counts = {
+    running: 0,
+    complete: 0,
+    incomplete: 0,
+    requiresAction: 0,
+  };
+  let status: MessagePartStatus | ToolCallMessagePartStatus = COMPLETE_STATUS;
+  let isRunning = false;
+
+  for (const index of indices) {
+    status = parts[index]?.status ?? COMPLETE_STATUS;
+    switch (status.type) {
+      case "running":
+        counts.running++;
+        isRunning = true;
+        break;
+      case "complete":
+        counts.complete++;
+        break;
+      case "incomplete":
+        counts.incomplete++;
+        break;
+      case "requires-action":
+        counts.requiresAction++;
+        break;
+    }
+  }
+
+  return { status: isRunning ? RUNNING_STATUS : status, counts };
+};

package/src/utils/wire-media.test.ts

@@ -20,6 +20,16 @@ describe("resolveImageMediaType", () => {
     );
   });
 
+  it("ignores a wildcard image content type", () => {
+    expect(resolveImageMediaType(JPEG, "image/*")).toBe("image/jpeg");
+  });
+
+  it("ignores a wildcard data url media type", () => {
+    expect(resolveImageMediaType(`data:image/*;base64,${JPEG}`)).toBe(
+      "image/jpeg",
+    );
+  });
+
   it("takes the data url declaration when it is an image type", () => {
     expect(
       resolveImageMediaType("data:image/svg+xml,%3Csvg%3E%3C/svg%3E"),

package/src/utils/wire-media.ts

@@ -14,10 +14,14 @@ export function resolveImageMediaType(
   image: string,
   contentType?: string | undefined,
 ): string {
-  if (contentType?.startsWith("image/")) return contentType;
+  if (contentType?.startsWith("image/") && !contentType.includes("*")) {
+    return contentType;
+  }
 
   const declared = dataUrlMediaType(image);
-  if (declared?.startsWith("image/")) return declared;
+  if (declared?.startsWith("image/") && !declared.includes("*")) {
+    return declared;
+  }
 
   // Read through a data URL envelope too, so a generic one such as
   // `application/octet-stream` does not mask the format. A url of any other