@assistant-ui/core 0.3.2 → 0.3.3

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];
+};