@assistant-ui/core 0.3.19 → 0.3.20

package/src/react/adapters/LocalStorageThreadListAdapter.test.ts

@@ -95,6 +95,94 @@ describe("parseStoredMessageRepository", () => {
     expect(repo.headId).toBe("message-2");
   });
 
+  it("preserves modality on user and assistant messages", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          {
+            message: {
+              ...storedMessage("voice-user"),
+              metadata: { modality: "voice", custom: {} },
+            },
+            parentId: null,
+          },
+          {
+            message: {
+              ...storedMessage("voice-assistant", "assistant"),
+              metadata: { modality: "voice", custom: {} },
+            },
+            parentId: "voice-user",
+          },
+        ],
+      }),
+    );
+
+    expect(
+      repo.messages.map(({ message }) => message.metadata.modality),
+    ).toEqual(["voice", "voice"]);
+  });
+
+  it("restores submitted feedback with and without a comment", () => {
+    const assistant = (id: string, submittedFeedback: unknown) => ({
+      message: {
+        ...storedMessage(id, "assistant"),
+        metadata: { submittedFeedback, custom: {} },
+      },
+      parentId: null,
+    });
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          assistant("commented", {
+            type: "negative",
+            comment: "Quoted the wrong date",
+          }),
+          assistant("legacy", { type: "positive" }),
+          assistant("blank", { type: "positive", comment: "" }),
+          assistant("invalid", { type: "neutral", comment: "ignored" }),
+        ],
+      }),
+    );
+
+    expect(
+      repo.messages.map(({ message }) => message.metadata.submittedFeedback),
+    ).toStrictEqual([
+      { type: "negative", comment: "Quoted the wrong date" },
+      { type: "positive" },
+      { type: "positive" },
+      undefined,
+    ]);
+  });
+
+  it("omits modality when it is missing, unsupported, or on a system message", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          {
+            message: {
+              ...storedMessage("system", "system"),
+              content: [{ type: "text", text: "Be brief" }],
+              metadata: { modality: "voice", custom: {} },
+            },
+            parentId: null,
+          },
+          { message: storedMessage("typed-user"), parentId: "system" },
+          {
+            message: {
+              ...storedMessage("video-assistant", "assistant"),
+              metadata: { modality: "video", custom: {} },
+            },
+            parentId: "typed-user",
+          },
+        ],
+      }),
+    );
+
+    expect(
+      repo.messages.map(({ message }) => "modality" in message.metadata),
+    ).toEqual([false, false, false]);
+  });
+
   it("drops a head id that points at a skipped message", () => {
     const repo = parseStoredMessageRepository(
       JSON.stringify({
@@ -191,6 +279,35 @@ describe("parseStoredMessageRepository", () => {
     expect(answer?.content).toEqual([{ type: "future-part", value: 1 }]);
   });
 
+  it("keeps an attachment part type it does not know", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        headId: "question",
+        messages: [
+          {
+            message: {
+              ...storedMessage("question"),
+              attachments: [
+                {
+                  id: "attachment-1",
+                  type: "document",
+                  name: "notes.txt",
+                  status: { type: "complete" },
+                  content: [{ type: "future-part", value: 1 }],
+                },
+              ],
+            },
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(repo.messages[0]?.message.attachments?.[0]?.content).toEqual([
+      { type: "future-part", value: 1 },
+    ]);
+  });
+
   it("drops known parts that are missing a required field", () => {
     const parts = {
       text: { type: "text", text: "hi" },

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -9,15 +9,13 @@ import {
 } from "react";
 import { useAui } from "@assistant-ui/store";
 import type {
-  CompleteAttachment,
+  MessageModality,
   RemoteThreadInitializeResponse,
   RemoteThreadListAdapter,
   RemoteThreadListResponse,
   RemoteThreadMetadata,
-  ThreadAssistantMessagePart,
   ThreadHistoryAdapter,
   ThreadMessage,
-  ThreadUserMessagePart,
   RunConfig,
 } from "../../index";
 import type {
@@ -25,6 +23,13 @@ import type {
   ExportedMessageRepositoryItem,
 } from "../../internal";
 import { isRecord } from "../../utils/json/is-json";
+import {
+  MAX_STORED_MESSAGE_DEPTH,
+  isStoredMessagePart,
+  isStoredMessageRole,
+  parseStoredAttachment,
+  parseStoredDate,
+} from "../../runtime/utils/stored-message-parts";
 import {
   RuntimeAdapterProvider,
   type RuntimeAdapters,
@@ -112,56 +117,12 @@ const parseStoredThread = (value: unknown): StoredThreadMetadata | null => {
   };
 };
 
-const parseDate = (value: unknown): Date | null => {
-  if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
-  if (typeof value !== "string" && typeof value !== "number") return null;
-
-  const date = new Date(value);
-  return Number.isNaN(date.getTime()) ? null : date;
-};
+const messageModalities = {
+  voice: true,
+} satisfies Record<MessageModality, true>;
 
-const isMessageRole = (value: unknown): value is ThreadMessage["role"] =>
-  value === "system" || value === "user" || value === "assistant";
-
-const MAX_STORED_MESSAGE_DEPTH = 100;
-
-const storedPartGuards = {
-  text: (part) => typeof part.text === "string",
-  reasoning: (part) =>
-    typeof part.text === "string" || typeof part.unstable_summary === "string",
-  image: (part) => typeof part.image === "string",
-  file: (part) =>
-    typeof part.data === "string" && typeof part.mimeType === "string",
-  audio: (part) =>
-    isRecord(part.audio) &&
-    typeof part.audio.data === "string" &&
-    typeof part.audio.format === "string",
-  data: (part) => typeof part.name === "string",
-  source: (part) =>
-    typeof part.id === "string" &&
-    (part.sourceType === "url"
-      ? typeof part.url === "string"
-      : part.sourceType === "document" &&
-        typeof part.title === "string" &&
-        typeof part.mediaType === "string"),
-  "generative-ui": (part) => isRecord(part.spec),
-  "tool-call": (part) =>
-    typeof part.toolCallId === "string" &&
-    typeof part.toolName === "string" &&
-    isRecord(part.args) &&
-    typeof part.argsText === "string",
-} satisfies Record<
-  (ThreadUserMessagePart | ThreadAssistantMessagePart)["type"],
-  (part: Record<string, unknown>) => boolean
->;
-
-const isStoredMessagePart = (
-  value: unknown,
-): value is Record<string, unknown> & { type: string } =>
-  isRecord(value) &&
-  typeof value.type === "string" &&
-  (!Object.hasOwn(storedPartGuards, value.type) ||
-    storedPartGuards[value.type as keyof typeof storedPartGuards](value));
+const isMessageModality = (value: unknown): value is MessageModality =>
+  typeof value === "string" && Object.hasOwn(messageModalities, value);
 
 const parseStoredMessageParts = (
   content: unknown[],
@@ -184,40 +145,25 @@ const parseStoredMessageParts = (
     ];
   });
 
-const parseStoredAttachment = (value: unknown): CompleteAttachment | null => {
-  if (
-    !isRecord(value) ||
-    typeof value.id !== "string" ||
-    typeof value.type !== "string" ||
-    typeof value.name !== "string" ||
-    !isRecord(value.status) ||
-    value.status.type !== "complete" ||
-    !Array.isArray(value.content)
-  ) {
-    return null;
-  }
-
-  return {
-    ...value,
-    content: value.content.filter(isStoredMessagePart),
-  } as CompleteAttachment;
-};
-
 const parseStoredThreadMessage = (
   value: unknown,
   depth: number,
 ): ThreadMessage | null => {
   if (depth > MAX_STORED_MESSAGE_DEPTH) return null;
   if (!isRecord(value) || typeof value.id !== "string") return null;
-  if (!isMessageRole(value.role)) return null;
+  if (!isStoredMessageRole(value.role)) return null;
   if (!Array.isArray(value.content)) return null;
 
-  const createdAt = parseDate(value.createdAt);
+  const createdAt = parseStoredDate(value.createdAt);
   if (!createdAt) return null;
 
   const metadata = value.metadata;
   if (!isRecord(metadata) || !isRecord(metadata.custom)) return null;
 
+  const modality = isMessageModality(metadata.modality)
+    ? metadata.modality
+    : undefined;
+
   if (value.role === "assistant") {
     const status = value.status;
     if (!isRecord(status) || typeof status.type !== "string") return null;
@@ -226,6 +172,7 @@ const parseStoredThreadMessage = (
       ? metadata.submittedFeedback
       : undefined;
     const submittedFeedbackType = submittedFeedback?.type;
+    const submittedFeedbackComment = submittedFeedback?.comment;
 
     return {
       id: value.id,
@@ -253,6 +200,10 @@ const parseStoredThreadMessage = (
           ? {
               submittedFeedback: {
                 type: submittedFeedbackType,
+                ...(typeof submittedFeedbackComment === "string" &&
+                submittedFeedbackComment !== ""
+                  ? { comment: submittedFeedbackComment }
+                  : undefined),
               },
             }
           : undefined),
@@ -266,6 +217,7 @@ const parseStoredThreadMessage = (
         ...(metadata.isOptimistic === true
           ? { isOptimistic: true }
           : undefined),
+        ...(modality !== undefined ? { modality } : undefined),
         custom: metadata.custom,
       },
     };
@@ -281,12 +233,13 @@ const parseStoredThreadMessage = (
       ) as StoredUserMessage["content"],
       attachments: Array.isArray(value.attachments)
         ? value.attachments.flatMap((item) => {
-            const attachment = parseStoredAttachment(item);
+            const attachment = parseStoredAttachment(item, isStoredMessagePart);
             return attachment ? [attachment] : [];
           })
         : [],
       createdAt,
       metadata: {
+        ...(modality !== undefined ? { modality } : undefined),
         custom: metadata.custom,
       },
     };

package/src/react/client/Interactables.test.ts

@@ -147,7 +147,10 @@ const reg = (
   id,
   name: "note",
   description: "a note",
-  stateSchema: { type: "object", properties: {} } as never,
+  stateSchema: {
+    type: "object",
+    properties: {},
+  } satisfies Unstable_InteractableRegistration["stateSchema"],
   initialState: { v: 0 },
   ...overrides,
 });
@@ -328,13 +331,13 @@ describe("Interactables registration", () => {
 
   it("refreshes cached tool parameters while another anchor remains", async () => {
     const schemaA = {
-      type: "object" as const,
+      type: "object",
       properties: { first: { type: "string" } },
-    };
+    } satisfies Unstable_InteractableRegistration["stateSchema"];
     const schemaB = {
-      type: "object" as const,
+      type: "object",
       properties: { second: { type: "number" } },
-    };
+    } satisfies Unstable_InteractableRegistration["stateSchema"];
     root = mount({ threadMessages: [createCall("n1")] });
     const first = root.getValue().register(reg("n1", { stateSchema: schemaA }));
     const second = root
@@ -516,7 +519,9 @@ describe("Interactables persistence save", () => {
 
   it("keeps edits queued during an in-flight flush with the outgoing adapter", async () => {
     const saveResolvers: Array<() => void> = [];
-    const firstSave = vi.fn(
+    const firstSave = vi.fn<
+      (state: Unstable_InteractablePersistedState) => Promise<void>
+    >(
       () =>
         new Promise<void>((resolve) => {
           saveResolvers.push(resolve);
@@ -547,7 +552,7 @@ describe("Interactables persistence save", () => {
     await flushMicrotasks();
     expect(flushed).toBe(false);
     expect(firstSave).toHaveBeenCalledTimes(2);
-    expect(firstSave.mock.calls[1]![0]).toEqual({
+    expect(firstSave.mock.calls[1]?.[0]).toEqual({
       n1: { name: "note", state: { v: 2 } },
     });
     expect(secondSave).not.toHaveBeenCalled();

package/src/react/client/RemoteThreadList.concurrent.test.tsx

@@ -220,9 +220,15 @@ describe("RemoteThreadList concurrent rendering", () => {
     const unsubscribe = client.on(
       "threads.selectionChanged" as never,
       (() => {
-        selectionToolIds.push(
-          Object.keys(client.thread.getModelContext().tools)[0]!,
-        );
+        const tools = client.thread.getModelContext().tools;
+        if (tools === undefined) {
+          throw new Error("Expected thread model context tools");
+        }
+        const toolId = Object.keys(tools)[0];
+        if (toolId === undefined) {
+          throw new Error("Expected thread model context tool");
+        }
+        selectionToolIds.push(toolId);
       }) as never,
     );
 

package/src/react/client/RemoteThreadList.test.ts

@@ -8,7 +8,10 @@ import {
   type AssistantConfigSource,
 } from "@assistant-ui/store/client";
 import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
-import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
+import type {
+  RemoteThreadListAdapter,
+  RemoteThreadMetadata,
+} from "../../runtimes/remote-thread-list/types";
 import {
   useRuntimeAdapters,
   type RuntimeAdapters,
@@ -828,11 +831,7 @@ describe("RemoteThreadList", () => {
   });
 
   const deleteDuringAdapterSwap = async (
-    replacementThreads: readonly {
-      status: "regular";
-      remoteId: string;
-      title: string;
-    }[],
+    replacementThreads: RemoteThreadMetadata[],
   ) => {
     const removal = deferred<void>();
     const onDelete = vi.fn();

package/src/react/interactables-legacy/Interactables.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
 import type {
+  InteractablePersistedState,
   InteractablePersistenceAdapter,
   InteractableRegistration,
 } from "./scopes";
@@ -89,7 +90,10 @@ const reg = (id: string): InteractableRegistration => ({
   id,
   name: "note",
   description: "a note",
-  stateSchema: { type: "object", properties: {} } as never,
+  stateSchema: {
+    type: "object",
+    properties: {},
+  } satisfies InteractableRegistration["stateSchema"],
   initialState: { v: 0 },
 });
 
@@ -154,7 +158,9 @@ describe("legacy Interactables persistence", () => {
 
   it("keeps edits queued during an in-flight flush with the outgoing adapter", async () => {
     const saveResolvers: Array<() => void> = [];
-    const firstSave = vi.fn(
+    const firstSave = vi.fn<
+      (state: InteractablePersistedState) => Promise<void>
+    >(
       () =>
         new Promise<void>((resolve) => {
           saveResolvers.push(resolve);
@@ -177,7 +183,7 @@ describe("legacy Interactables persistence", () => {
     saveResolvers[0]!();
     await flushMicrotasks();
     expect(firstSave).toHaveBeenCalledTimes(2);
-    expect(firstSave.mock.calls[1]![0]).toEqual({
+    expect(firstSave.mock.calls[1]?.[0]).toEqual({
       n1: { name: "note", state: { v: 2 } },
     });
     expect(firstSave.mock.calls.at(-1)?.[0]).toEqual({

package/src/react/interactables-legacy/useAssistantInteractable.test.tsx

@@ -2,6 +2,17 @@
 
 import { cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import type { InteractableStateSchema } from "./scopes";
+
+type JsonSchema = Exclude<InteractableStateSchema, { "~standard": unknown }>;
+type StandardSchemaWithJsonSchema = Extract<
+  InteractableStateSchema,
+  { "~standard": unknown }
+> & {
+  "~standard": {
+    jsonSchema: { input: () => JsonSchema; output: () => JsonSchema };
+  };
+};
 
 const mocks = vi.hoisted(() => {
   const unregister = vi.fn();
@@ -28,17 +39,20 @@ afterEach(() => {
 describe("useAssistantInteractable", () => {
   it("refreshes the registration when its JSON schema changes", async () => {
     const schemaA = {
-      type: "object" as const,
+      type: "object",
       properties: { first: { type: "string" } },
-    };
+    } satisfies InteractableStateSchema;
     const schemaB = {
-      type: "object" as const,
+      type: "object",
       properties: { second: { type: "number" } },
-    };
+    } satisfies InteractableStateSchema;
     const initialA = { first: "one" };
     const initialB = { second: 2 };
 
-    const hook = renderHook(
+    const hook = renderHook<
+      unknown,
+      { stateSchema: InteractableStateSchema; initialState: unknown }
+    >(
       ({ stateSchema, initialState }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",
@@ -69,20 +83,23 @@ describe("useAssistantInteractable", () => {
   });
 
   it("stabilizes equivalent rebuilt standard schemas", async () => {
-    const createSchema = (property: string) => ({
+    const createSchema = (property: string): StandardSchemaWithJsonSchema => ({
       "~standard": {
-        version: 1 as const,
+        version: 1,
         vendor: "test",
-        validate: (value: unknown) => ({ value }),
-        toJSONSchema: () => ({
-          type: "object" as const,
-          properties: { [property]: { type: "string" as const } },
-        }),
+        validate: () => ({ value: {} }),
+        jsonSchema: {
+          input: () => ({
+            type: "object",
+            properties: { [property]: { type: "string" } },
+          }),
+          output: () => ({ type: "object" }),
+        },
       },
     });
     const firstSchema = createSchema("value");
 
-    const hook = renderHook(
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
       ({ stateSchema }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",
@@ -106,15 +123,16 @@ describe("useAssistantInteractable", () => {
   });
 
   it("keeps unsupported standard schemas from failing during render", async () => {
-    const createSchema = () => ({
-      "~standard": {
-        version: 1 as const,
-        vendor: "test",
-        validate: (value: unknown) => ({ value }),
-      },
-    });
-
-    const hook = renderHook(
+    const createSchema = () =>
+      ({
+        "~standard": {
+          version: 1 as const,
+          vendor: "test",
+          validate: () => ({ value: {} }),
+        },
+      }) satisfies InteractableStateSchema;
+
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
       ({ stateSchema }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",