@assistant-ui/core 0.3.1 → 0.3.3

package/src/types/message.ts

@@ -14,6 +14,7 @@ export type PartProviderMetadata = {
 export type TextMessagePart = {
   readonly type: "text";
   readonly text: string;
+  readonly status?: MessagePartStreamStatus;
   readonly providerMetadata?: PartProviderMetadata;
   readonly parentId?: string;
 };
@@ -21,6 +22,7 @@ export type TextMessagePart = {
 export type ReasoningMessagePart = {
   readonly type: "reasoning";
   readonly text: string;
+  readonly status?: MessagePartStreamStatus;
   readonly providerMetadata?: PartProviderMetadata;
   readonly parentId?: string;
 };
@@ -266,6 +268,23 @@ export type MessagePartStatus =
       readonly error?: unknown;
     };
 
+export type MessagePartStreamStatus =
+  | {
+      readonly type: "running";
+    }
+  | {
+      readonly type: "complete";
+    }
+  | {
+      readonly type: "incomplete";
+      readonly reason:
+        | "cancelled"
+        | "length"
+        | "content-filter"
+        | "other"
+        | "error";
+    };
+
 export type ToolCallMessagePartStatus =
   | {
       /** The tool call is waiting for UI or human input before continuing. */

package/src/utils/data-url.test.ts

@@ -20,8 +20,32 @@ describe("parseDataUrl", () => {
     expect(parseDataUrl("data:text/plain,hello")).toBeNull();
   });
 
-  it("returns null for data URLs with an empty payload", () => {
-    expect(parseDataUrl("data:image/png;base64,")).toBeNull();
+  it("parses a data URL with an empty payload as zero-byte data", () => {
+    expect(parseDataUrl("data:image/png;base64,")).toEqual({
+      mimeType: "image/png",
+      data: "",
+    });
+  });
+
+  it("parses an uppercase scheme", () => {
+    expect(parseDataUrl("DATA:image/png;base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+  });
+
+  it("parses a mixed-case scheme and base64 token", () => {
+    expect(parseDataUrl("Data:image/png;Base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+  });
+
+  it("lowercases the captured mime type", () => {
+    expect(parseDataUrl("data:IMAGE/PNG;base64,aGVsbG8=")).toEqual({
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
   });
 
   it("returns null for plain strings", () => {

package/src/utils/data-url.ts

@@ -3,7 +3,7 @@ export const httpUrlPattern = /^https?:\/\//i;
 export function parseDataUrl(
   value: string,
 ): { mimeType: string; data: string } | null {
-  const match = value.match(/^data:([^;,]+)(?:;[^;,]+)*;base64,(.+)$/);
+  const match = value.match(/^data:([^;,]+)(?:;[^;,]+)*;base64,(.*)$/i);
   if (!match) return null;
-  return { mimeType: match[1]!, data: match[2]! };
+  return { mimeType: match[1]!.toLowerCase(), data: match[2]! };
 }

package/src/utils/getGroupStatus.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { getGroupStatus } from "./getGroupStatus";
+
+describe("getGroupStatus", () => {
+  it("reports running when the first member is running and the last is complete", () => {
+    const parts = [
+      { status: { type: "running" as const } },
+      { status: { type: "complete" as const } },
+    ];
+    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);
+  });
+
+  it("reports the last status when every member is complete", () => {
+    const status = { type: "complete" } as const;
+
+    expect(getGroupStatus([{ status }, { status }])).toBe(status);
+  });
+
+  it("reports complete for an empty group", () => {
+    expect(getGroupStatus([])).toEqual({ type: "complete" });
+  });
+
+  it("matches the positional outcome for statusless adapters", () => {
+    expect(
+      getGroupStatus(
+        [{ status: { type: "complete" } }, { status: { type: "running" } }],
+        [0, 1],
+      ),
+    ).toEqual({ type: "running" });
+  });
+});

package/src/utils/getGroupStatus.ts

@@ -0,0 +1,31 @@
+import type {
+  MessagePartStatus,
+  ToolCallMessagePartStatus,
+} from "../types/message";
+import { COMPLETE_STATUS, RUNNING_STATUS } from "./normalizePartStatus";
+
+type PartWithStatus = {
+  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+
+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;
+};

package/src/utils/normalizePartStatus.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import type { ThreadAssistantMessagePart } from "../types/message";
+import { normalizePartStatus } from "./normalizePartStatus";
+
+const partWithStatus = (status: unknown): ThreadAssistantMessagePart =>
+  ({
+    type: "text",
+    text: "text",
+    status,
+  }) as unknown as ThreadAssistantMessagePart;
+
+describe("normalizePartStatus", () => {
+  it("returns a frozen running status", () => {
+    const status = normalizePartStatus(partWithStatus({ type: "running" }));
+
+    expect(status).toEqual({ type: "running" });
+    expect(status).toBe(
+      normalizePartStatus(partWithStatus({ type: "running" })),
+    );
+    expect(Object.isFrozen(status)).toBe(true);
+  });
+
+  it("normalizes a complete status without a reason", () => {
+    expect(normalizePartStatus(partWithStatus({ type: "complete" }))).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("drops an upstream complete reason", () => {
+    expect(
+      normalizePartStatus(
+        partWithStatus({ type: "complete", reason: "unknown" }),
+      ),
+    ).toEqual({ type: "complete" });
+  });
+
+  it.each(["cancelled", "length", "content-filter", "other", "error"] as const)(
+    "preserves the incomplete reason %s",
+    (reason) => {
+      expect(
+        normalizePartStatus(partWithStatus({ type: "incomplete", reason })),
+      ).toEqual({ type: "incomplete", reason });
+    },
+  );
+
+  it("coerces an unrecognized incomplete reason to other", () => {
+    expect(
+      normalizePartStatus(
+        partWithStatus({ type: "incomplete", reason: "unknown" }),
+      ),
+    ).toEqual({ type: "incomplete", reason: "other" });
+  });
+
+  it("returns undefined for an unknown status type", () => {
+    expect(
+      normalizePartStatus(partWithStatus({ type: "unknown" })),
+    ).toBeUndefined();
+  });
+});

package/src/utils/normalizePartStatus.ts

@@ -0,0 +1,55 @@
+import type {
+  MessagePartStatus,
+  MessagePartStreamStatus,
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+} from "../types/message";
+
+export const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
+  type: "complete",
+});
+export const RUNNING_STATUS: MessagePartStatus = Object.freeze({
+  type: "running",
+});
+type IncompleteMessagePartStatus = Extract<
+  MessagePartStreamStatus,
+  { readonly type: "incomplete" }
+>;
+const INCOMPLETE_STATUSES: Readonly<
+  Record<IncompleteMessagePartStatus["reason"], IncompleteMessagePartStatus>
+> = Object.freeze({
+  cancelled: Object.freeze({ type: "incomplete", reason: "cancelled" }),
+  length: Object.freeze({ type: "incomplete", reason: "length" }),
+  "content-filter": Object.freeze({
+    type: "incomplete",
+    reason: "content-filter",
+  }),
+  other: Object.freeze({ type: "incomplete", reason: "other" }),
+  error: Object.freeze({ type: "incomplete", reason: "error" }),
+});
+
+export const normalizePartStatus = (
+  part: ThreadUserMessagePart | ThreadAssistantMessagePart,
+): MessagePartStatus | undefined => {
+  const status = (part as { readonly status?: unknown }).status;
+  if (!status || typeof status !== "object") return undefined;
+
+  const { type } = status as { readonly type?: unknown };
+  if (type === "running") return RUNNING_STATUS;
+  if (type === "complete") return COMPLETE_STATUS;
+  if (type !== "incomplete") return undefined;
+
+  const { reason } = status as {
+    readonly reason?: unknown;
+  };
+  const normalizedReason: IncompleteMessagePartStatus["reason"] =
+    reason === "cancelled" ||
+    reason === "length" ||
+    reason === "content-filter" ||
+    reason === "other" ||
+    reason === "error"
+      ? reason
+      : "other";
+
+  return INCOMPLETE_STATUSES[normalizedReason];
+};