@assistant-ui/core 0.3.19 → 0.3.21

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.test.ts

@@ -81,6 +81,31 @@ describe("CloudFileAttachmentAdapter", () => {
     });
   });
 
+  it("uses a binary MIME type when the browser cannot identify a file", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true });
+    vi.stubGlobal("fetch", fetchMock);
+    const adapter = new CloudFileAttachmentAdapter(makeCloud());
+    const file = new File(["hello"], "unknown.bin");
+    const attachments: PendingAttachment[] = [];
+
+    for await (const attachment of adapter.add({ file })) {
+      attachments.push(attachment);
+    }
+
+    expect(attachments[0]?.contentType).toBe("application/octet-stream");
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://storage.example/upload",
+      expect.objectContaining({
+        headers: { "Content-Type": "application/octet-stream" },
+      }),
+    );
+    const sent = await adapter.send(attachments.at(-1)!);
+    expect(sent.content[0]).toMatchObject({
+      type: "file",
+      mimeType: "application/octet-stream",
+    });
+  });
+
   it("marks the attachment incomplete when the upload returns an HTTP error", async () => {
     const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     vi.stubGlobal(
@@ -134,10 +159,12 @@ describe("CloudFileAttachmentAdapter", () => {
   });
 
   it("does not finish an upload removed while requesting its URL", async () => {
-    const presigned = deferred<{
-      signedUrl: string;
-      publicUrl: string;
-    }>();
+    const presigned =
+      deferred<
+        Awaited<
+          ReturnType<AssistantCloud["files"]["generatePresignedUploadUrl"]>
+        >
+      >();
     const cloud = makeCloud();
     vi.mocked(cloud.files.generatePresignedUploadUrl).mockReturnValue(
       presigned.promise,
@@ -155,7 +182,9 @@ describe("CloudFileAttachmentAdapter", () => {
 
     await adapter.remove(running.value!);
     presigned.resolve({
+      success: true,
       signedUrl: "https://storage.example/upload",
+      expiresAt: "2026-09-16T00:00:00.000Z",
       publicUrl: "https://cdn.example/file.png",
     });
 

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

@@ -7,6 +7,9 @@ import type {
 import type { ThreadUserMessagePart } from "../../../types/message";
 import type { AttachmentAdapter } from "../../../adapters/attachment";
 import { generateId } from "../../../utils/id";
+import { resolveFileMediaType } from "../../../utils/wire-media";
+
+const DEFAULT_CONTENT_TYPE = "application/octet-stream";
 
 const guessAttachmentType = (
   contentType: string,
@@ -40,11 +43,12 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
   }): AsyncGenerator<PendingAttachment, void> {
     const id = generateId();
     const type = guessAttachmentType(file.type);
+    const contentType = file.type || DEFAULT_CONTENT_TYPE;
     let attachment: PendingAttachment = {
       id,
       type,
       name: file.name,
-      contentType: file.type,
+      contentType,
       file,
       status: { type: "running", reason: "uploading", progress: 0 },
     };
@@ -66,7 +70,7 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
         method: "PUT",
         body: file,
         headers: {
-          "Content-Type": file.type,
+          "Content-Type": contentType,
         },
         mode: "cors",
         signal: controller.signal,
@@ -129,7 +133,7 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
         {
           type: "file",
           data: url,
-          mimeType: attachment.contentType ?? "",
+          mimeType: resolveFileMediaType(url, attachment.contentType),
           filename: attachment.name,
         },
       ];

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

@@ -1,5 +1,6 @@
 import type {
   MessageStatus,
+  PartProviderMetadata,
   SourceProviderMetadata,
   ThreadMessage,
   ToolCallMessagePartMcpMetadata,
@@ -7,18 +8,33 @@ import type {
   ToolApprovalDisplay,
   ToolApprovalOption,
   ReasoningMessagePart,
+  TextMessagePart,
+  ImageMessagePart,
+  FileMessagePart,
+  Unstable_ToolInteractionLog,
 } from "../../../types/message";
 import type { CompleteAttachment } from "../../../types/attachment";
 import {
   fromThreadMessageLike,
   type ThreadMessageLike,
 } from "../../../runtime/utils/thread-message-like";
+import { readToolInteractionLog } from "../../../runtime/utils/tool-interactions";
 import type { CloudMessage } from "assistant-cloud";
-import { isJSONValue } from "../../../utils/json/is-json";
+import { isJSONValue, isRecord } from "../../../utils/json/is-json";
+import {
+  MAX_STORED_MESSAGE_DEPTH,
+  isStoredAuiV0RolePart,
+  isStoredMessageStatus,
+  isStoredMessageRole,
+  parseStoredAttachment,
+  parseStoredDate,
+  parseStoredThreadSteps,
+} from "../../../runtime/utils/stored-message-parts";
 import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
 } from "assistant-stream/utils";
+import type { ToolModelContentPart } from "assistant-stream";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 
 type AuiV0ToolApproval = {
@@ -26,6 +42,7 @@ type AuiV0ToolApproval = {
   readonly prompt?: string;
   readonly display?: ToolApprovalDisplay;
   readonly allowFreeform?: boolean;
+  readonly dismissible?: boolean;
   readonly approved?: boolean;
   readonly reason?: string;
   readonly isAutomatic?: boolean;
@@ -39,6 +56,9 @@ type AuiV0MessagePart =
   | {
       readonly type: "text";
       readonly text: string;
+      readonly providerMetadata?: NonNullable<
+        TextMessagePart["providerMetadata"]
+      >;
       readonly parentId?: string;
     }
   | {
@@ -74,6 +94,10 @@ type AuiV0MessagePart =
   | {
       readonly type: "image";
       readonly image: string;
+      readonly filename?: string;
+      readonly providerMetadata?: NonNullable<
+        ImageMessagePart["providerMetadata"]
+      >;
     }
   | {
       readonly type: "file";
@@ -81,6 +105,9 @@ type AuiV0MessagePart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+      readonly providerMetadata?: NonNullable<
+        FileMessagePart["providerMetadata"]
+      >;
       readonly parentId?: string;
     }
   | {
@@ -107,6 +134,10 @@ type AuiV0ToolCallPart = {
   readonly toolCallId: string;
   readonly toolName: string;
   readonly result?: ReadonlyJSONValue;
+  readonly artifact?: ReadonlyJSONValue;
+  readonly modelContent?: readonly ToolModelContentPart[];
+  readonly providerMetadata?: PartProviderMetadata;
+  readonly isPreliminary?: true;
   readonly isError?: true;
   readonly interrupt?: {
     readonly type: "human";
@@ -117,18 +148,25 @@ type AuiV0ToolCallPart = {
   readonly approval?: AuiV0ToolApproval;
   readonly parentId?: string;
   readonly messages?: readonly AuiV0Message[];
+  readonly unstable_interactions?: Unstable_ToolInteractionLog;
 };
 
 type AuiV0AttachmentPart =
   | {
       readonly type: "text";
       readonly text: string;
+      readonly providerMetadata?: NonNullable<
+        TextMessagePart["providerMetadata"]
+      >;
       readonly parentId?: string;
     }
   | {
       readonly type: "image";
       readonly image: string;
       readonly filename?: string;
+      readonly providerMetadata?: NonNullable<
+        ImageMessagePart["providerMetadata"]
+      >;
     }
   | {
       readonly type: "file";
@@ -136,6 +174,9 @@ type AuiV0AttachmentPart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+      readonly providerMetadata?: NonNullable<
+        FileMessagePart["providerMetadata"]
+      >;
       readonly parentId?: string;
     }
   | {
@@ -190,6 +231,9 @@ const encodeAttachmentPart = (
       return {
         type: "text",
         text: part.text,
+        ...(part.providerMetadata !== undefined
+          ? { providerMetadata: part.providerMetadata }
+          : undefined),
         ...(part.parentId !== undefined
           ? { parentId: part.parentId }
           : undefined),
@@ -200,6 +244,9 @@ const encodeAttachmentPart = (
         type: "image",
         image: part.image,
         ...(part.filename != null ? { filename: part.filename } : undefined),
+        ...(part.providerMetadata !== undefined
+          ? { providerMetadata: part.providerMetadata }
+          : undefined),
       };
 
     case "file":
@@ -211,6 +258,9 @@ const encodeAttachmentPart = (
         ...(part.sourceType != null
           ? { sourceType: part.sourceType }
           : undefined),
+        ...(part.providerMetadata != null
+          ? { providerMetadata: part.providerMetadata }
+          : undefined),
         ...(part.parentId !== undefined
           ? { parentId: part.parentId }
           : undefined),
@@ -261,6 +311,67 @@ const encodeAttachments = (
   );
 };
 
+const serializableArtifact = (
+  artifact: unknown,
+): ReadonlyJSONValue | undefined => {
+  if (artifact === undefined) return undefined;
+  try {
+    const serialized = JSON.stringify(artifact);
+    return serialized === undefined ? undefined : JSON.parse(serialized);
+  } catch {
+    return undefined;
+  }
+};
+
+// Diagnostic only: names the data JSON.stringify silently loses (Map and Set
+// entries, symbol-keyed or non-enumerable own data, extra array properties,
+// undefined, functions, non-finite numbers). A wrapper that keeps its data
+// behind prototype getters or a Map from another realm has no own keys and is
+// indistinguishable from an empty object here, so it passes exactly as it does
+// on main.
+const hasLosslessJSONShape = (value: unknown, depth = 0): boolean => {
+  if (depth > 100) return false;
+  if (value === undefined || typeof value === "function") return false;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || value === null) return true;
+  // A toJSON is the value's own serializer, so whatever it emits is intended.
+  if (typeof (value as { toJSON?: unknown }).toJSON === "function") return true;
+  if ((value instanceof Map || value instanceof Set) && value.size > 0) {
+    return false;
+  }
+
+  if (Array.isArray(value)) {
+    if (Reflect.ownKeys(value).length !== value.length + 1) return false;
+    for (let index = 0; index < value.length; index++) {
+      if (
+        !Object.hasOwn(value, index) ||
+        !hasLosslessJSONShape(value[index], depth + 1)
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return Reflect.ownKeys(value).every(
+    (key) =>
+      typeof key === "string" &&
+      Object.getOwnPropertyDescriptor(value, key)?.enumerable === true &&
+      hasLosslessJSONShape((value as Record<string, unknown>)[key], depth + 1),
+  );
+};
+
+// Reading a getter a second time can throw where JSON.stringify's read did
+// not; a diagnostic that throws is reported as loss rather than failing the
+// write.
+const losesDataInJSON = (value: unknown): boolean => {
+  try {
+    return !hasLosslessJSONShape(value);
+  } catch {
+    return true;
+  }
+};
+
 export function auiV0Encode(message: ThreadMessage): AuiV0Message {
   // info: ID and createdAt are ignored (we use the server value instead)
   const status: MessageStatus | undefined =
@@ -278,6 +389,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
           return {
             type: "text",
             text: part.text,
+            ...(part.providerMetadata !== undefined
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
             ...(part.parentId !== undefined
               ? { parentId: part.parentId }
               : undefined),
@@ -333,11 +447,29 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
           };
 
         case "tool-call": {
-          if (part.result !== undefined && !isJSONValue(part.result)) {
+          // Persisting what JSON can carry keeps the tool call answered on
+          // reload; a part with no result is rejected by providers as an
+          // unanswered call, which is worse than a hollowed-out result.
+          const result = serializableArtifact(part.result);
+          if (
+            part.result !== undefined &&
+            (result === undefined || losesDataInJSON(part.result))
+          ) {
             console.warn(
-              `tool-call result is not JSON! ${JSON.stringify(part)}`,
+              result === undefined
+                ? `tool-call result for ${part.toolCallId} cannot be serialized as JSON; omitted`
+                : `tool-call result for ${part.toolCallId} loses data in JSON; persisted as its JSON form`,
             );
           }
+          const artifact = serializableArtifact(part.artifact);
+          if (part.artifact !== undefined && artifact === undefined) {
+            console.warn(
+              `tool-call artifact is not JSON for ${part.toolCallId}`,
+            );
+          }
+          const interactions = readToolInteractionLog(
+            part.unstable_interactions,
+          );
           return {
             type: "tool-call",
             toolCallId: part.toolCallId,
@@ -345,9 +477,15 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             ...(JSON.stringify(part.args) === part.argsText
               ? { args: part.args }
               : { argsText: part.argsText }),
-            ...(part.result !== undefined
-              ? { result: part.result as ReadonlyJSONValue }
+            ...(result !== undefined ? { result } : undefined),
+            ...(artifact !== undefined ? { artifact } : undefined),
+            ...(part.modelContent !== undefined
+              ? { modelContent: part.modelContent }
               : undefined),
+            ...(part.providerMetadata !== undefined
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
+            ...(part.isPreliminary ? { isPreliminary: true } : undefined),
             ...(part.isError ? { isError: true } : undefined),
             ...(part.interrupt !== undefined
               ? {
@@ -368,11 +506,23 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             ...(part.messages !== undefined
               ? { messages: part.messages.map(encodeNestedMessage) }
               : undefined),
+            ...(interactions !== undefined
+              ? { unstable_interactions: interactions }
+              : undefined),
           };
         }
 
         case "image":
-          return { type: "image", image: part.image };
+          return {
+            type: "image",
+            image: part.image,
+            ...(part.filename != null
+              ? { filename: part.filename }
+              : undefined),
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
+          };
 
         case "file":
           return {
@@ -381,6 +531,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             mimeType: part.mimeType,
             ...(part.filename ? { filename: part.filename } : undefined),
             ...(part.sourceType ? { sourceType: part.sourceType } : undefined),
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
             ...(part.parentId !== undefined
               ? { parentId: part.parentId }
               : undefined),
@@ -427,6 +580,122 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
   };
 }
 
+const readableAuiV0Parts = (
+  role: AuiV0Message["role"],
+  content: readonly unknown[],
+  depth: number,
+): AuiV0MessagePart[] =>
+  content.flatMap((part) => {
+    if (!isStoredAuiV0RolePart(role, part)) return [];
+    if (part.type !== "tool-call" || part.messages === undefined)
+      return [part as unknown as AuiV0MessagePart];
+
+    const { messages, ...toolCall } = part;
+    if (!Array.isArray(messages) || depth >= MAX_STORED_MESSAGE_DEPTH)
+      return [toolCall as unknown as AuiV0MessagePart];
+    return [
+      {
+        ...toolCall,
+        messages: messages.flatMap((message) => {
+          const nested = readableAuiV0Message(message, depth + 1);
+          return nested ? [nested] : [];
+        }),
+      } as unknown as AuiV0MessagePart,
+    ];
+  });
+
+const readableAuiV0Attachments = (
+  attachments: readonly unknown[],
+): AuiV0Attachment[] =>
+  attachments.flatMap((attachment) => {
+    const parsed = parseStoredAttachment(attachment, (value) =>
+      isStoredAuiV0RolePart("user", value),
+    );
+    return parsed ? [parsed as unknown as AuiV0Attachment] : [];
+  });
+
+const readableAuiV0Message = (
+  value: unknown,
+  depth: number,
+): AuiV0Message | null => {
+  if (
+    !isRecord(value) ||
+    !isStoredMessageRole(value.role) ||
+    !Array.isArray(value.content)
+  ) {
+    return null;
+  }
+
+  const { role } = value;
+  const content = readableAuiV0Parts(role, value.content, depth);
+  // fromThreadMessageLike takes a system row only with exactly one text part,
+  // so one that no longer matches after filtering is dropped here rather than
+  // costing the row or the tool call that carries it.
+  if (role === "system" && content.length !== 1) return null;
+
+  const { attachments, createdAt, status, metadata, ...rest } = value;
+  // decodeAuiV0Message turns a nested createdAt into a Date without checking
+  // it, and encodeNestedMessage later calls toISOString on the result, so an
+  // unparseable one would reject the next write to the message that holds it.
+  // Dropping the field falls back to the parent's timestamp.
+  const storedCreatedAt = parseStoredDate(createdAt);
+  const readableMetadata = !isRecord(metadata)
+    ? metadata
+    : role === "assistant"
+      ? { ...metadata, steps: parseStoredThreadSteps(metadata.steps) }
+      : { ...metadata, steps: undefined };
+
+  return {
+    ...rest,
+    ...(storedCreatedAt ? { createdAt } : undefined),
+    // fromThreadMessageLike throws on a status, a metadata.steps or an
+    // attachments list carried by a row whose role cannot hold one, and
+    // auiV0Encode only ever writes each onto the role that can, so dropping a
+    // misplaced field costs no valid data and saves the row.
+    ...(role === "assistant" && isStoredMessageStatus(status)
+      ? { status }
+      : undefined),
+    ...(metadata !== undefined ? { metadata: readableMetadata } : undefined),
+    content,
+    ...(role === "user" && Array.isArray(attachments)
+      ? { attachments: readableAuiV0Attachments(attachments) }
+      : undefined),
+  } as unknown as AuiV0Message;
+};
+
+/**
+ * Decodes a stored row, dropping the parts, attachments and nested messages
+ * that cannot be read back instead of rejecting the row, and returning null
+ * when the row itself is unreadable. Loading a thread must not fail because a
+ * single stored row is malformed.
+ */
+export function auiV0DecodeSafely(
+  cloudMessage: CloudMessage & { format: "aui/v0" },
+): ExportedMessageRepositoryItem | null {
+  try {
+    const payload = readableAuiV0Message(cloudMessage.content, 0);
+    if (!payload) throw new Error("stored row is not an aui/v0 message");
+
+    return {
+      parentId: cloudMessage.parent_id,
+      message: decodeAuiV0Message(
+        {
+          ...payload,
+          id: cloudMessage.id,
+          createdAt: cloudMessage.created_at,
+        },
+        cloudMessage.id,
+      ),
+    };
+  } catch (error) {
+    console.warn(
+      `aui/v0: dropping unreadable message ${cloudMessage.id}`,
+      error,
+    );
+    return null;
+  }
+}
+
 export function auiV0Decode(
   cloudMessage: CloudMessage & { format: "aui/v0" },
 ): ExportedMessageRepositoryItem {