@assistant-ui/core 0.3.18 → 0.3.20

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

@@ -83,7 +83,13 @@ export type MessageRuntime = {
    * @deprecated This API is still under active development and might change without notice.
    */
   stopSpeaking(): void;
-  submitFeedback({ type }: { type: "positive" | "negative" }): void;
+  submitFeedback({
+    type,
+    comment,
+  }: {
+    type: "positive" | "negative";
+    comment?: string;
+  }): void;
   switchToBranch({
     position,
     branchId,
@@ -197,11 +203,18 @@ export class MessageRuntimeImpl implements MessageRuntime {
     }
   }
 
-  public submitFeedback({ type }: { type: "positive" | "negative" }) {
+  public submitFeedback({
+    type,
+    comment,
+  }: {
+    type: "positive" | "negative";
+    comment?: string;
+  }) {
     const state = this._core.getState();
     this._threadBinding.getState().submitFeedback({
       messageId: state.id,
       type,
+      ...(comment !== undefined ? { comment } : undefined),
     });
   }
 

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

@@ -1,7 +1,13 @@
 import { describe, expect, it, vi } from "vitest";
 import { LocalRuntimeCore } from "../../runtimes/local/local-runtime-core";
 import { ExternalStoreRuntimeCore } from "../../runtimes/external-store/external-store-runtime-core";
+import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore";
 import { AssistantRuntimeImpl } from "./assistant-runtime";
+import {
+  ThreadRuntimeImpl,
+  type ThreadListItemRuntimeBinding,
+  type ThreadRuntimeCoreBinding,
+} from "./thread-runtime";
 
 describe("ThreadRuntime.append", () => {
   it.each([
@@ -76,3 +82,55 @@ describe("ThreadRuntime.append with an external store", () => {
     expect(onNew).not.toHaveBeenCalled();
   });
 });
+
+describe("ThreadRuntime state subscriptions", () => {
+  it("tears down every source before reconnecting after an error", () => {
+    const core = new ReadonlyThreadRuntimeCore();
+    const cleanupError = new Error("thread cleanup failed");
+    const threadCleanup = vi.fn(() => {
+      throw cleanupError;
+    });
+    const itemCleanup = vi.fn();
+    let threadSubscriptions = 0;
+    let itemSubscriptions = 0;
+    const path = {
+      ref: "test.thread",
+      threadSelector: { type: "main" as const },
+    };
+    const runtime = new ThreadRuntimeImpl(
+      {
+        path,
+        getState: () => core,
+        subscribe: () => {
+          threadSubscriptions += 1;
+          return threadCleanup;
+        },
+        outerSubscribe: () => () => {},
+      } satisfies ThreadRuntimeCoreBinding,
+      {
+        path,
+        getState: () => ({
+          id: "test",
+          remoteId: undefined,
+          externalId: undefined,
+          isMain: true,
+          isRunning: false,
+          status: "regular",
+          title: undefined,
+        }),
+        subscribe: () => {
+          itemSubscriptions += 1;
+          return itemCleanup;
+        },
+      } satisfies ThreadListItemRuntimeBinding,
+    );
+
+    const unsubscribe = runtime.subscribe(() => {});
+    expect(() => unsubscribe()).toThrow(cleanupError);
+    expect(itemCleanup).toHaveBeenCalledOnce();
+
+    runtime.subscribe(() => {});
+    expect(threadSubscriptions).toBe(2);
+    expect(itemSubscriptions).toBe(2);
+  });
+});

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

@@ -18,6 +18,7 @@ import {
 } from "./message-runtime";
 import { NestedSubscriptionSubject } from "../../subscribable/subscribable";
 import {
+  runCleanups,
   ShallowMemoizeSubject,
   SKIP_UPDATE,
 } from "../../subscribable/subscribable";
@@ -372,10 +373,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
       subscribe: (callback) => {
         const sub1 = threadBinding.subscribe(callback);
         const sub2 = threadListItemBinding.subscribe(callback);
-        return () => {
-          sub1();
-          sub2();
-        };
+        return () => runCleanups([sub1, sub2]);
       },
     });
 

package/src/runtime/base/base-composer-runtime-core.ts

@@ -167,7 +167,7 @@ export abstract class BaseComposerRuntimeCore
     const adapter = this.getAttachmentAdapter();
     if (adapter) {
       const pending = this._attachments.filter((a) => !isAttachmentComplete(a));
-      await Promise.all(pending.map((a) => adapter.remove(a)));
+      await Promise.all(pending.map(async (a) => adapter.remove(a)));
     }
   }
 
@@ -203,6 +203,10 @@ export abstract class BaseComposerRuntimeCore
 
   public async clearAttachments() {
     this._cancelAllAttachmentAdds();
+    if (this._isSending) {
+      for (const attachment of this._attachments)
+        this._removedDuringSend.add(attachment.id);
+    }
     const task = this._onClearAttachments();
     this.setAttachments([]);
 
@@ -213,8 +217,13 @@ export abstract class BaseComposerRuntimeCore
     if (!this.canSend || this._isSending) return;
 
     if (this._dictationSession) {
-      this._dictationSession.cancel();
-      this._cleanupDictation();
+      try {
+        this._dictationSession.cancel();
+      } catch (error) {
+        console.error("[assistant-ui] Dictation session cancel threw", error);
+      } finally {
+        this._cleanupDictation();
+      }
     }
 
     const adapter = this.getAttachmentAdapter();
@@ -636,14 +645,11 @@ export abstract class BaseComposerRuntimeCore
       throw new Error("Dictation adapter not configured");
     }
 
+    const isReplacing = this._dictationSession !== undefined;
     if (this._dictationSession) {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
-      }
-      this._dictationUnsubscribes = [];
       const oldSession = this._dictationSession;
-      oldSession.stop().catch(() => {});
-      this._dictationSession = undefined;
+      this._cleanupDictation({ notify: false });
+      this._stopDictationSession(oldSession);
     }
 
     const inputDisabled = adapter.disableInputDuringDictation ?? false;
@@ -651,7 +657,22 @@ export abstract class BaseComposerRuntimeCore
     this._dictationBaseText = this._text;
     this._currentInterimText = "";
 
-    const session = adapter.listen();
+    let session: DictationAdapter.Session;
+    try {
+      session = adapter.listen();
+    } catch (error) {
+      if (isReplacing) {
+        try {
+          this._notifySubscribers();
+        } catch (notifyError) {
+          console.error(
+            "[assistant-ui] Dictation replacement rollback notification threw",
+            notifyError,
+          );
+        }
+      }
+      throw error;
+    }
     this._dictationSession = session;
     const sessionId = ++this._dictationSessionIdCounter;
     this._activeDictationSessionId = sessionId;
@@ -729,27 +750,59 @@ export abstract class BaseComposerRuntimeCore
     const session = this._dictationSession;
     const sessionId = this._activeDictationSessionId;
     const cleanup = () => this._cleanupDictation({ sessionId });
-    void session.stop().then(cleanup, cleanup);
+    this._stopDictationSession(session, cleanup);
   }
 
-  private _cleanupDictation(options?: { sessionId: number | undefined }): void {
+  private _stopDictationSession(
+    session: DictationAdapter.Session,
+    onSettled: () => void = () => {},
+  ): void {
+    let task: Promise<void>;
+    try {
+      task = session.stop();
+    } catch (error) {
+      console.error("[assistant-ui] Dictation session stop threw", error);
+      onSettled();
+      return;
+    }
+
+    void task.then(onSettled, (error) => {
+      console.error("[assistant-ui] Dictation session stop rejected", error);
+      onSettled();
+    });
+  }
+
+  private _cleanupDictation(options?: {
+    sessionId?: number | undefined;
+    notify?: boolean | undefined;
+  }): void {
     const isStaleSession =
       options?.sessionId !== undefined &&
       options.sessionId !== this._activeDictationSessionId;
     if (isStaleSession || this._isCleaningDictation) return;
 
     this._isCleaningDictation = true;
-    try {
-      for (const unsub of this._dictationUnsubscribes) {
-        unsub();
+    const runCleanup = (cleanup: () => void) => {
+      try {
+        cleanup();
+      } catch (error) {
+        console.error("[assistant-ui] Dictation cleanup threw", error);
       }
+    };
+
+    try {
+      const unsubscribes = this._dictationUnsubscribes;
       this._dictationUnsubscribes = [];
       this._dictationSession = undefined;
       this._activeDictationSessionId = undefined;
       this._dictation = undefined;
       this._dictationBaseText = "";
       this._currentInterimText = "";
-      this._notifySubscribers();
+
+      for (const unsubscribe of unsubscribes) runCleanup(unsubscribe);
+      if (options?.notify !== false) {
+        runCleanup(() => this._notifySubscribers());
+      }
     } finally {
       this._isCleaningDictation = false;
     }