@assistant-ui/core 0.3.2 → 0.3.3

package/src/react/runtimes/cloud/auiV0.ts

@@ -1,13 +1,8 @@
 import type {
-  DataMessagePart,
-  FileMessagePart,
-  ImageMessagePart,
   MessageStatus,
   SourceProviderMetadata,
   ThreadMessage,
-  TextMessagePart,
   ToolApprovalOption,
-  Unstable_AudioMessagePart,
 } from "../../../types/message";
 import type { CompleteAttachment } from "../../../types/attachment";
 import { fromThreadMessageLike } from "../../../runtime/utils/thread-message-like";
@@ -85,11 +80,33 @@ type AuiV0MessagePart =
     };
 
 type AuiV0AttachmentPart =
-  | TextMessagePart
-  | ImageMessagePart
-  | FileMessagePart
-  | Unstable_AudioMessagePart
-  | DataMessagePart<ReadonlyJSONValue>;
+  | {
+      readonly type: "text";
+      readonly text: string;
+    }
+  | {
+      readonly type: "image";
+      readonly image: string;
+      readonly filename?: string;
+    }
+  | {
+      readonly type: "file";
+      readonly data: string;
+      readonly mimeType: string;
+      readonly filename?: string;
+    }
+  | {
+      readonly type: "audio";
+      readonly audio: {
+        readonly data: string;
+        readonly format: "mp3" | "wav";
+      };
+    }
+  | {
+      readonly type: "data";
+      readonly name: string;
+      readonly data: ReadonlyJSONValue;
+    };
 
 type AuiV0Attachment = {
   readonly id: string;
@@ -125,16 +142,38 @@ const encodeAttachmentPart = (
   const type = part.type;
   switch (type) {
     case "text":
+      return { type: "text", text: part.text };
+
     case "image":
+      return {
+        type: "image",
+        image: part.image,
+        ...(part.filename != null ? { filename: part.filename } : undefined),
+      };
+
     case "file":
+      return {
+        type: "file",
+        data: part.data,
+        mimeType: part.mimeType,
+        ...(part.filename != null ? { filename: part.filename } : undefined),
+      };
+
     case "audio":
-      return part;
+      return {
+        type: "audio",
+        audio: { data: part.audio.data, format: part.audio.format },
+      };
 
     case "data": {
       if (!isJSONValue(part.data)) {
         console.warn(`attachment data is not JSON! ${JSON.stringify(part)}`);
       }
-      return { ...part, data: part.data as ReadonlyJSONValue };
+      return {
+        type: "data",
+        name: part.name,
+        data: part.data as ReadonlyJSONValue,
+      };
     }
 
     default: {

package/src/runtime/api/message-runtime.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import type { CompleteAttachment } from "../../types/attachment";
+import type { ThreadAssistantMessage } from "../../types/message";
 import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
 import {
   MessageRuntimeImpl,
+  toMessagePartStatus,
   type MessageState,
   type MessageStateBinding,
 } from "./message-runtime";
@@ -63,6 +65,144 @@ const threadBinding = {
   subscribe: () => () => {},
 } as unknown as ThreadRuntimeCoreBinding;
 
+const createAssistantMessage = (
+  content: ThreadAssistantMessage["content"],
+  status: ThreadAssistantMessage["status"],
+): ThreadAssistantMessage => ({
+  id: "message-1",
+  role: "assistant",
+  createdAt: new Date(0),
+  content,
+  status,
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+});
+
+describe("toMessagePartStatus", () => {
+  it("honours a supplied running status on a non-last part", () => {
+    const message = createAssistantMessage(
+      [
+        { type: "text", text: "first", status: { type: "running" } },
+        { type: "text", text: "last" },
+      ],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "running",
+    });
+  });
+
+  it("honours a supplied complete status on the last part", () => {
+    const message = createAssistantMessage(
+      [{ type: "reasoning", text: "done", status: { type: "complete" } }],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("ignores supplied statuses after the message completes", () => {
+    const message = createAssistantMessage(
+      [{ type: "text", text: "truncated", status: { type: "running" } }],
+      { type: "complete", reason: "stop" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "complete",
+      reason: "stop",
+    });
+  });
+
+  it("falls back to positional statuses for statusless running parts", () => {
+    const message = createAssistantMessage(
+      [
+        { type: "text", text: "first" },
+        { type: "reasoning", text: "last" },
+      ],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "complete",
+    });
+    expect(toMessagePartStatus(message, 1, message.content[1]!)).toEqual({
+      type: "running",
+    });
+  });
+
+  it("preserves tool-call status derivation", () => {
+    const unresolved = createAssistantMessage(
+      [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "weather",
+          args: {},
+          argsText: "{}",
+        },
+      ],
+      { type: "running" },
+    );
+    const resolved = createAssistantMessage(
+      [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "weather",
+          args: {},
+          argsText: "{}",
+          result: "sunny",
+        },
+      ],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(unresolved, 0, unresolved.content[0]!)).toEqual({
+      type: "running",
+    });
+    expect(toMessagePartStatus(resolved, 0, resolved.content[0]!)).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("normalizes supplied upstream statuses", () => {
+    const upstreamComplete = {
+      type: "text",
+      text: "done",
+      status: { type: "complete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+    const upstreamIncomplete = {
+      type: "reasoning",
+      text: "interrupted",
+      status: {
+        type: "incomplete",
+        reason: "unknown",
+        error: "upstream error",
+      },
+    } as unknown as ThreadAssistantMessage["content"][number];
+    const message = createAssistantMessage(
+      [upstreamComplete, upstreamIncomplete],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "complete",
+    });
+    expect(toMessagePartStatus(message, 1, message.content[1]!)).toEqual({
+      type: "incomplete",
+      reason: "other",
+    });
+  });
+});
+
 describe("MessageRuntimeImpl paths", () => {
   it("appends nested selectors to the message path", () => {
     const runtime = new MessageRuntimeImpl(messageBinding, threadBinding);

package/src/runtime/api/message-runtime.ts

@@ -8,6 +8,10 @@ import type {
 } from "../../types/message";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { MessagePartStatus, RunConfig } from "../../types/message";
+import {
+  COMPLETE_STATUS,
+  normalizePartStatus,
+} from "../../utils/normalizePartStatus";
 import { getThreadMessageText } from "../../utils/text";
 import { NestedSubscriptionSubject } from "../../subscribable/subscribable";
 import {
@@ -32,10 +36,6 @@ import type { MessageRuntimePath } from "./paths";
 import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
 import type { MessageStateBinding } from "./bindings";
 
-const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
-  type: "complete",
-});
-
 export const toMessagePartStatus = (
   message: ThreadMessage,
   partIndex: number,
@@ -51,6 +51,11 @@ export const toMessagePartStatus = (
     }
   }
 
+  if (message.status.type === "running") {
+    const status = normalizePartStatus(part);
+    if (status) return status;
+  }
+
   const isLastPart = partIndex === Math.max(0, message.content.length - 1);
   if (message.status.type === "requires-action") return COMPLETE_STATUS;
   return isLastPart ? (message.status as MessagePartStatus) : COMPLETE_STATUS;
@@ -70,7 +75,7 @@ const getMessagePartState = (
   return Object.freeze({
     ...part,
     ...{ [symbolInnerMessage]: (part as any)[symbolInnerMessage] },
-    status,
+    status: status as MessagePartStatus,
   });
 };
 

package/src/store/clients/chain-of-thought-client.ts

@@ -5,12 +5,8 @@ import type {
   ChainOfThoughtState,
   ChainOfThoughtPart,
 } from "../scopes/chain-of-thought";
-import type { MessagePartStatus } from "../../types/message";
 import type { PartMethods } from "../scopes/part";
-
-const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
-  type: "complete",
-});
+import { getGroupStatus } from "../../utils/getGroupStatus";
 
 const useChainOfThoughtClient = ({
   parts,
@@ -22,8 +18,7 @@ const useChainOfThoughtClient = ({
   const [collapsed, setCollapsed] = useState(true);
 
   const status = useMemo(() => {
-    const lastPart = parts[parts.length - 1];
-    return lastPart?.status ?? COMPLETE_STATUS;
+    return getGroupStatus(parts);
   }, [parts]);
 
   const state = useMemo<ChainOfThoughtState>(

package/src/store/clients/thread-message-client.test.ts

@@ -0,0 +1,84 @@
+import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { describe, expect, it } from "vitest";
+import type { ThreadAssistantMessage } from "../../types/message";
+import { ThreadMessageClient } from "./thread-message-client";
+
+describe("ThreadMessageClient", () => {
+  const getPartStatus = (
+    part: ThreadAssistantMessage["content"][number],
+    status: ThreadAssistantMessage["status"],
+  ) => {
+    const message: ThreadAssistantMessage = {
+      id: "message-1",
+      role: "assistant",
+      createdAt: new Date(0),
+      content: [part],
+      status,
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+    };
+    const root = createTapRoot(function ThreadMessageRoot() {
+      return useResource(ThreadMessageClient({ message, index: 0 }));
+    });
+
+    try {
+      return root.getValue().getState().parts[0]?.status;
+    } finally {
+      root.unmount();
+    }
+  };
+
+  it("preserves a running part status on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "running",
+    });
+  });
+
+  it("normalizes an unknown incomplete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "incomplete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "incomplete",
+      reason: "other",
+    });
+  });
+
+  it("normalizes an upstream complete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "complete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("marks parts complete on a non-running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "complete", reason: "stop" })).toEqual({
+      type: "complete",
+    });
+  });
+});

package/src/store/clients/thread-message-client.ts

@@ -11,19 +11,27 @@ import { useClientLookup } from "@assistant-ui/store";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
+import {
+  COMPLETE_STATUS,
+  normalizePartStatus,
+} from "../../utils/normalizePartStatus";
 import { getThreadMessageText } from "../../utils/text";
 
 const useThreadMessagePartClient = ({
   part,
+  isMessageRunning,
 }: {
   part: ThreadAssistantMessagePart | ThreadUserMessagePart;
+  isMessageRunning: boolean;
 }): ClientOutput<"part"> => {
   const state = useMemo<PartState>(() => {
     return {
       ...part,
-      status: { type: "complete" },
+      status: isMessageRunning
+        ? (normalizePartStatus(part) ?? COMPLETE_STATUS)
+        : COMPLETE_STATUS,
     };
-  }, [part]);
+  }, [part, isMessageRunning]);
 
   return {
     getState: () => state,
@@ -74,6 +82,8 @@ const useThreadMessageClient = ({
 }: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
+  const isMessageRunning =
+    message.role === "assistant" && message.status.type === "running";
 
   const parts = useClientLookup(
     message.content.map((part, idx) =>
@@ -81,8 +91,8 @@ const useThreadMessageClient = ({
         "toolCallId" in part && part.toolCallId != null
           ? `toolCallId-${part.toolCallId}`
           : `index-${idx}`,
-        ThreadMessagePartClient({ part }),
-        [part],
+        ThreadMessagePartClient({ part, isMessageRunning }),
+        [part, isMessageRunning],
       ),
     ),
   );

package/src/tests/auiV0Encode.test.ts

@@ -155,6 +155,99 @@ describe("auiV0Encode", () => {
       },
     ]);
   });
+
+  it("drops per-part status from message parts in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "reasoning", text: "thinking", status: { type: "complete" } },
+        { type: "text", text: "answer", status: { type: "running" } },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      { type: "reasoning", text: "thinking" },
+      { type: "text", text: "answer" },
+    ]);
+  });
+
+  it("drops per-part status from attachment content in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review this" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "document",
+          name: "notes.txt",
+          status: { type: "complete" },
+          content: [
+            { type: "text", text: "notes", status: { type: "running" } },
+          ],
+        },
+      ],
+    });
+
+    expect(encoded.attachments?.[0]?.content).toEqual([
+      { type: "text", text: "notes" },
+    ]);
+  });
+
+  it("preserves every attachment content field the wire shape carries in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review these" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "file",
+          name: "bundle",
+          status: { type: "complete" },
+          content: [
+            {
+              type: "image",
+              image: "data:image/png;base64,iVBORw0KGgo=",
+              filename: "shot.png",
+            },
+            {
+              type: "audio",
+              audio: { data: "data:audio/mp3;base64,SUQzAw==", format: "mp3" },
+            },
+            { type: "data", name: "telemetry", data: { runs: 3 } },
+          ],
+        },
+      ],
+    });
+
+    expect(encoded.attachments?.[0]?.content).toEqual([
+      {
+        type: "image",
+        image: "data:image/png;base64,iVBORw0KGgo=",
+        filename: "shot.png",
+      },
+      {
+        type: "audio",
+        audio: { data: "data:audio/mp3;base64,SUQzAw==", format: "mp3" },
+      },
+      { type: "data", name: "telemetry", data: { runs: 3 } },
+    ]);
+  });
 });
 
 describe("auiV0Decode", () => {

package/src/types/index.ts

@@ -18,6 +18,7 @@ export type {
   ThreadAssistantMessagePart,
   // Message status
   MessagePartStatus,
+  MessagePartStreamStatus,
   ToolCallMessagePartStatus,
   MessageStatus,
   // Thread messages

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