@assistant-ui/core 0.3.20 → 0.3.21

package/src/store/clients/model-context-client.test.ts

@@ -41,10 +41,10 @@ describe("ModelContext", () => {
     try {
       sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
+        .register(provider({ config: { modelName: "gpt-6-luna" } }));
       await tick();
 
-      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
+      expect(sub.getValue().getState().modelName).toBe("gpt-6-luna");
     } finally {
       unmount();
     }
@@ -71,13 +71,13 @@ describe("ModelContext", () => {
     try {
       sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
+        .register(provider({ config: { modelName: "gpt-6-luna" } }));
       await tick();
       const before = sub.getValue().getState();
 
       sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
+        .register(provider({ config: { modelName: "gpt-6-luna" } }));
       await tick();
       const after = sub.getValue().getState();
 
@@ -92,9 +92,9 @@ describe("ModelContext", () => {
     try {
       const unsubscribe = sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
+        .register(provider({ config: { modelName: "gpt-6-luna" } }));
       await tick();
-      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
+      expect(sub.getValue().getState().modelName).toBe("gpt-6-luna");
 
       unsubscribe();
       await tick();
@@ -110,9 +110,9 @@ describe("ModelContext", () => {
     try {
       sub
         .getValue()
-        .register(provider({ config: { modelName: "gpt-5.6-luna" } }));
+        .register(provider({ config: { modelName: "gpt-6-luna" } }));
 
-      expect(sub.getValue().getState().modelName).toBe("gpt-5.6-luna");
+      expect(sub.getValue().getState().modelName).toBe("gpt-6-luna");
     } finally {
       unmount();
     }

package/src/store/clients/no-op-composer-client.ts

@@ -23,6 +23,8 @@ const useNoOpComposerClient = ({
       dictation: undefined,
       quote: undefined,
       queue: [],
+      submission: undefined,
+      inTransit: undefined,
     };
   }, [type]);
 

package/src/store/clients/submission-message.ts

@@ -0,0 +1,27 @@
+import type { ComposerSubmission } from "../../runtime/interfaces/composer-runtime-core";
+import type { ThreadMessage } from "../../types/message";
+import { fromThreadMessageLike } from "../../runtime/utils/thread-message-like";
+
+/**
+ * The thread row for a submission. Its attachments stay on the submission,
+ * because a message only carries attachments it was delivered with.
+ */
+export const submissionThreadMessage = (
+  submission: ComposerSubmission,
+): ThreadMessage =>
+  fromThreadMessageLike(
+    {
+      role: submission.role,
+      // A system message is always exactly one text part.
+      content:
+        submission.role === "system" || submission.text
+          ? [{ type: "text", text: submission.text }]
+          : [],
+      attachments: [],
+      metadata: {
+        custom: { ...(submission.quote ? { quote: submission.quote } : {}) },
+      },
+    },
+    submission.id,
+    { type: "complete", reason: "unknown" },
+  );

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

@@ -81,4 +81,43 @@ describe("ThreadMessageClient", () => {
       type: "complete",
     });
   });
+
+  it("resolves interaction recording for historical messages", async () => {
+    const message: ThreadAssistantMessage = {
+      id: "message-1",
+      role: "assistant",
+      createdAt: new Date(0),
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "weather",
+          args: {},
+          argsText: "{}",
+        },
+      ],
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+    };
+    const root = createTapRoot(function ThreadMessageRoot() {
+      return useResource(ThreadMessageClient({ message, index: 0 }));
+    });
+
+    try {
+      await expect(
+        root.getValue().part({ index: 0 }).unstable_recordInteraction!({
+          type: "action",
+          payload: {},
+        }),
+      ).resolves.toBeUndefined();
+    } finally {
+      root.unmount();
+    }
+  });
 });

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

@@ -4,10 +4,11 @@ import type {
   ThreadMessage,
 } from "../../types/message";
 import type { Attachment } from "../../types/attachment";
+import type { ComposerSubmission } from "../../runtime/interfaces/composer-runtime-core";
 import { useMemo, useState } from "react";
-import { useResource, resource, withKey } from "@assistant-ui/tap";
+import { resource, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
-import { useClientLookup } from "@assistant-ui/store/client";
+import { useClientLookup, useClientResource } from "@assistant-ui/store/client";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
@@ -44,6 +45,7 @@ const useThreadMessagePartClient = ({
     respondToToolApproval: () => {
       throw new Error("Not supported");
     },
+    unstable_recordInteraction: async () => {},
   };
 };
 
@@ -71,6 +73,8 @@ export type ThreadMessageClientProps = {
   isLast?: boolean;
   branchNumber?: number;
   branchCount?: number;
+  /** Set when this row is a composer submission rather than a thread message. */
+  submission?: ComposerSubmission | undefined;
 };
 
 const useThreadMessageClient = ({
@@ -79,6 +83,7 @@ const useThreadMessageClient = ({
   isLast = true,
   branchNumber = 1,
   branchCount = 1,
+  submission,
 }: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
@@ -98,15 +103,15 @@ const useThreadMessageClient = ({
   );
 
   const attachments = useClientLookup(
-    (message.attachments ?? []).map((attachment) =>
+    (submission?.attachments ?? message.attachments ?? []).map((attachment) =>
       withKey(attachment.id, ThreadMessageAttachmentClient({ attachment }), [
         attachment,
       ]),
     ),
   );
 
-  const composer = useResource(NoOpComposerClient({ type: "edit" }));
-  const composerState = composer.getState();
+  const composer = useClientResource(NoOpComposerClient({ type: "edit" }));
+  const composerState = composer.state;
 
   const state = useMemo<MessageState>(() => {
     return {
@@ -121,9 +126,11 @@ const useThreadMessageClient = ({
       speech: undefined,
       isCopied: isCopiedState,
       isHovering: isHoveringState,
+      submission,
     };
   }, [
     message,
+    submission,
     index,
     isCopiedState,
     isHoveringState,
@@ -136,7 +143,7 @@ const useThreadMessageClient = ({
 
   return {
     getState: () => state,
-    composer: () => composer,
+    composer: () => composer.methods,
     part: (selector) => {
       if ("index" in selector) {
         return parts.get({ index: selector.index });

package/src/store/index.ts

@@ -1,5 +1,5 @@
-/// <reference path="./scope-registration.ts" />
-/// <reference path="../react/types/store-augmentation.ts" />
+/// <reference path="./scope-registration.ts" preserve="true" />
+/// <reference path="../react/types/store-augmentation.ts" preserve="true" />
 
 // scopes
 export type {

package/src/store/internal.ts

@@ -16,6 +16,7 @@ export {
   composerInputDisabled,
   composerSendDisabled,
   messageErrorText,
+  suggestionSendMode,
   suggestionTriggerDisabled,
   threadListLoadMoreDisabled,
 } from "./primitive-predicates";

package/src/store/primitive-predicates.test.ts

@@ -8,6 +8,7 @@ import {
   composerCancelDisabled,
   composerInputDisabled,
   composerSendDisabled,
+  suggestionSendMode,
   suggestionTriggerDisabled,
 } from "./primitive-predicates";
 
@@ -50,6 +51,26 @@ describe("primitive predicates", () => {
     ).toBe(true);
   });
 
+  it("composerSendDisabled leaves a spoken reply in progress to canSend while a voice session is connected", () => {
+    const voice = { status: { type: "running" }, canSendText: true };
+    expect(
+      composerSendDisabled(
+        state({
+          composer: { canSend: true },
+          thread: { isRunning: true, capabilities: { queue: false }, voice },
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      composerSendDisabled(
+        state({
+          composer: { canSend: false },
+          thread: { isRunning: true, capabilities: { queue: false }, voice },
+        }),
+      ),
+    ).toBe(true);
+  });
+
   it("actionBarReloadDisabled rejects user messages, busy threads, and runtimes without reload", () => {
     const thread = {
       isRunning: false,
@@ -178,6 +199,69 @@ describe("primitive predicates", () => {
       ),
     ).toBe(false);
   });
+
+  it("suggestionTriggerDisabled follows canSendText instead of the run while a voice session is connected", () => {
+    const thread = {
+      isDisabled: false,
+      isRunning: true,
+      capabilities: { queue: false },
+    };
+    expect(
+      suggestionTriggerDisabled(
+        state({ thread: { ...thread, voice: { canSendText: true } } }),
+        true,
+      ),
+    ).toBe(false);
+    expect(
+      suggestionTriggerDisabled(
+        state({
+          thread: {
+            ...thread,
+            isRunning: false,
+            voice: { canSendText: false },
+          },
+        }),
+        true,
+      ),
+    ).toBe(true);
+    expect(
+      suggestionTriggerDisabled(
+        state({ thread: { ...thread, voice: { canSendText: false } } }),
+        false,
+      ),
+    ).toBe(false);
+  });
+
+  it("suggestionSendMode queues only a text run with queue support", () => {
+    const idle = { isRunning: false, capabilities: { queue: false } };
+    expect(suggestionSendMode(state(idle))).toBe("now");
+    expect(suggestionSendMode(state({ ...idle, isRunning: true }))).toBe(
+      "blocked",
+    );
+    expect(
+      suggestionSendMode(
+        state({ isRunning: true, capabilities: { queue: true } }),
+      ),
+    ).toBe("queued");
+    expect(
+      suggestionSendMode(
+        state({
+          isRunning: true,
+          capabilities: { queue: true },
+          voice: { canSendText: true },
+        }),
+      ),
+    ).toBe("now");
+    expect(
+      suggestionSendMode(
+        state({
+          isRunning: false,
+          capabilities: { queue: true },
+          voice: { canSendText: false },
+        }),
+      ),
+    ).toBe("blocked");
+  });
   it("composerCancelDisabled, composerInputDisabled, and actionBarEditDisabled mirror their fields", () => {
     expect(
       composerCancelDisabled(state({ composer: { canCancel: true } })),
@@ -239,5 +323,24 @@ describe("primitive predicates", () => {
         }),
       ),
     ).toBe(false);
+    expect(
+      actionBarEditDisabled(
+        state({
+          optional: { ...editable.optional, message: { submission: {} } },
+          composer: { isEditing: false },
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      actionBarEditDisabled(
+        state({
+          optional: {
+            ...editable.optional,
+            message: { submission: undefined },
+          },
+          composer: { isEditing: false },
+        }),
+      ),
+    ).toBe(false);
   });
 });

package/src/store/primitive-predicates.ts

@@ -11,7 +11,10 @@ import type { AssistantState } from "@assistant-ui/store";
  */
 
 export const composerSendDisabled = (s: AssistantState): boolean =>
-  !s.composer.canSend || (s.thread.isRunning && !s.thread.capabilities.queue);
+  !s.composer.canSend ||
+  (s.thread.isRunning &&
+    !s.thread.capabilities.queue &&
+    s.thread.voice === undefined);
 
 export const composerCancelDisabled = (s: AssistantState): boolean =>
   !s.composer.canCancel;
@@ -21,6 +24,7 @@ export const composerInputDisabled = (s: AssistantState): boolean =>
 
 export const actionBarEditDisabled = (s: AssistantState): boolean =>
   s.composer.isEditing ||
+  s.optional.message?.submission !== undefined ||
   s.optional.thread?.voice !== undefined ||
   s.optional.thread?.capabilities.edit === false;
 
@@ -47,12 +51,20 @@ export const branchPickerNextDisabled = (s: AssistantState): boolean =>
   !s.thread.capabilities.switchToBranch ||
   (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun);
 
+export const suggestionSendMode = (
+  thread: AssistantState["thread"],
+): "now" | "queued" | "blocked" => {
+  if (thread.voice !== undefined)
+    return thread.voice.canSendText ? "now" : "blocked";
+  if (!thread.isRunning) return "now";
+  return thread.capabilities.queue ? "queued" : "blocked";
+};
+
 export const suggestionTriggerDisabled = (
   s: AssistantState,
   send: boolean,
 ): boolean =>
-  s.thread.isDisabled ||
-  (send && s.thread.isRunning && !s.thread.capabilities.queue);
+  s.thread.isDisabled || (send && suggestionSendMode(s.thread) === "blocked");
 
 export const messageErrorText = (
   s: AssistantState,

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -12,6 +12,7 @@ import type { QueueItemState } from "../scopes/queue-item";
 import type { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 import { useSubscribable } from "./useSubscribable";
+import { runCleanups } from "../../subscribable/subscribable";
 
 const useComposerAttachmentClientByIndex = ({
   runtime,
@@ -118,9 +119,7 @@ const useComposerClient = ({
       }),
     );
 
-    return () => {
-      for (const unsub of unsubscribers) unsub();
-    };
+    return () => runCleanups(unsubscribers);
   }, [runtime, emit, threadIdRef, messageIdRef]);
 
   const attachments = useClientLookup(
@@ -165,6 +164,8 @@ const useComposerClient = ({
       dictation: runtimeState.dictation,
       quote: runtimeState.quote,
       queue,
+      submission: runtimeState.submission,
+      inTransit: runtimeState.inTransit,
     };
   }, [runtimeState, attachments.state, queue]);
 

package/src/store/runtime-clients/message-part-runtime-client.test.ts

@@ -0,0 +1,42 @@
+import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { describe, expect, it } from "vitest";
+import type {
+  MessagePartRuntime,
+  MessagePartState,
+} from "../../runtime/api/message-part-runtime";
+import { MessagePartClient } from "./message-part-runtime-client";
+
+describe("MessagePartClient", () => {
+  it("omits recording when the runtime does not provide it", () => {
+    const state: MessagePartState = {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "weather",
+      args: {},
+      argsText: "{}",
+      status: { type: "complete" },
+    };
+    const runtime: MessagePartRuntime = {
+      path: {
+        ref: "threads.main.messages[0].content[0]",
+        threadSelector: { type: "main" },
+        messageSelector: { type: "index", index: 0 },
+        messagePartSelector: { type: "index", index: 0 },
+      },
+      getState: () => state,
+      subscribe: () => () => {},
+      addToolResult: () => {},
+      resumeToolCall: () => {},
+      respondToToolApproval: async () => {},
+    };
+    const root = createTapRoot(function MessagePartClientRoot() {
+      return useResource(MessagePartClient({ runtime }));
+    });
+
+    try {
+      expect(root.getValue().unstable_recordInteraction).toBeUndefined();
+    } finally {
+      root.unmount();
+    }
+  });
+});

package/src/store/runtime-clients/message-part-runtime-client.ts

@@ -16,6 +16,10 @@ const useMessagePartClient = ({
     resumeToolCall: (payload) => runtime.resumeToolCall(payload),
     respondToToolApproval: (response) =>
       runtime.respondToToolApproval(response),
+    ...(runtime.unstable_recordInteraction && {
+      unstable_recordInteraction: (input) =>
+        runtime.unstable_recordInteraction!(input),
+    }),
     __internal_getRuntime: () => runtime,
   };
 };

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

@@ -52,10 +52,13 @@ const useMessageClient = ({
   runtime,
   threadIdRef,
   threadId,
+  isLast,
 }: {
   runtime: MessageRuntime;
   threadIdRef: { current: string };
   threadId: string;
+  /** False when the thread renders a message the runtime does not hold after this one. */
+  isLast?: false | undefined;
 }): ClientOutput<"message"> => {
   const runtimeState = useSubscribable(runtime);
   const emit = useAssistantEmit();
@@ -127,6 +130,7 @@ const useMessageClient = ({
   const state = useMemo<MessageState>(() => {
     return {
       ...(runtimeState as MessageState),
+      ...(isLast === false ? { isLast } : {}),
 
       parts: parts.state,
       composer: composer.state,
@@ -136,6 +140,7 @@ const useMessageClient = ({
     };
   }, [
     runtimeState,
+    isLast,
     parts.state,
     composer.state,
     isCopiedState,