@assistant-ui/core 0.3.12 → 0.3.14

package/src/utils/composite-context-provider.ts

@@ -2,23 +2,41 @@ import {
   type ModelContextProvider,
   mergeModelContexts,
 } from "../model-context/types";
+import { notifySubscribers as notifyStateSubscribers } from "../subscribable/subscribable";
+import type { Unsubscribe } from "../types/unsubscribe";
 
 export class CompositeContextProvider implements ModelContextProvider {
-  private _providers = new Set<ModelContextProvider>();
+  private _providers = new Map<symbol, ModelContextProvider>();
+  private _providerUnsubscribes = new Map<symbol, Unsubscribe | undefined>();
 
   getModelContext() {
-    return mergeModelContexts(this._providers);
+    return mergeModelContexts(new Set(this._providers.values()));
   }
 
   registerModelContextProvider(provider: ModelContextProvider) {
-    this._providers.add(provider);
-    const unsubscribe = provider.subscribe?.(() => {
-      this.notifySubscribers();
-    });
+    const id = Symbol();
+    this._providers.set(id, provider);
+    let unsubscribe: Unsubscribe | undefined;
+    try {
+      unsubscribe = provider.subscribe?.(() => {
+        this.notifySubscribers();
+      });
+    } catch (error) {
+      this._providers.delete(id);
+      try {
+        this.notifySubscribers();
+      } catch (notifyError) {
+        console.error(notifyError);
+      }
+      throw error;
+    }
+    this._providerUnsubscribes.set(id, unsubscribe);
     this.notifySubscribers();
     return () => {
-      this._providers.delete(provider);
+      this._providers.delete(id);
+      const unsubscribe = this._providerUnsubscribes.get(id);
       unsubscribe?.();
+      this._providerUnsubscribes.delete(id);
       this.notifySubscribers();
     };
   }
@@ -26,7 +44,7 @@ export class CompositeContextProvider implements ModelContextProvider {
   private _subscribers = new Set<() => void>();
 
   notifySubscribers() {
-    for (const callback of this._subscribers) callback();
+    notifyStateSubscribers(this._subscribers);
   }
 
   subscribe(callback: () => void) {

package/src/utils/notify-event-listeners.ts

@@ -1,8 +1,9 @@
-type EventListener = (payload?: unknown) => void;
+type EventListener<T> = (payload: T) => unknown;
 
-export const notifyEventListeners = (
-  listeners: Iterable<EventListener>,
-  payload: unknown,
+// A function payload is indistinguishable from a factory and gets invoked; wrap a function-typed payload in a factory.
+export const notifyEventListeners = <T>(
+  listeners: Iterable<EventListener<T>>,
+  payloadOrFactory: T | (() => T),
   errorContext: string,
 ) => {
   const reportError = (error: unknown) => {
@@ -14,7 +15,11 @@ export const notifyEventListeners = (
 
   for (const listener of listeners) {
     try {
-      const result = listener(payload) as unknown;
+      const result = listener(
+        typeof payloadOrFactory === "function"
+          ? (payloadOrFactory as () => T)()
+          : payloadOrFactory,
+      );
       if (
         result !== null &&
         (typeof result === "object" || typeof result === "function") &&

package/src/tests/default-thread-composer-runtime-core.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
-import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
-import type { AppendMessage, ThreadMessage } from "../types/message";
-
-const makeRuntime = (options?: {
-  messages?: ThreadMessage[];
-  composerMetadata?: Record<string, unknown>;
-}) => {
-  const append = vi.fn();
-  const runtime = {
-    append,
-    getModelContext: () => ({
-      ...(options?.composerMetadata
-        ? { unstable_composerMetadata: options.composerMetadata }
-        : {}),
-    }),
-    subscribe: () => () => {},
-    capabilities: { cancel: false },
-    messages: options?.messages ?? [],
-    isSendDisabled: false,
-    composer: { runConfig: {} },
-  } as unknown as Omit<ThreadRuntimeCore, "composer">;
-  return { runtime, append };
-};
-
-const snapshotMessage = (id: string, state: unknown): ThreadMessage =>
-  ({
-    id,
-    role: "user",
-    createdAt: new Date(),
-    content: [{ type: "text", text: "old" }],
-    attachments: [],
-    metadata: {
-      custom: { interactables: [{ id: "n1", name: "note", state }] },
-    },
-  }) as ThreadMessage;
-
-const live = (state: unknown) => ({
-  interactables: [{ id: "n1", name: "note", state }],
-});
-
-const send = async (runtime: Omit<ThreadRuntimeCore, "composer">) => {
-  const composer = new DefaultThreadComposerRuntimeCore(runtime);
-  composer.setText("hello");
-  await composer.send();
-};
-
-describe("DefaultThreadComposerRuntimeCore interactables snapshot gating", () => {
-  it("stamps a baseline on the first send of the thread", async () => {
-    const { runtime, append } = makeRuntime({
-      composerMetadata: live({ v: 1 }),
-    });
-    await send(runtime);
-    const appended = append.mock.calls[0]![0] as AppendMessage;
-    expect(appended.metadata?.custom?.interactables).toEqual([
-      { id: "n1", name: "note", state: { v: 1 } },
-    ]);
-  });
-
-  it("stamps nothing when the history already carries the live state", async () => {
-    const { runtime, append } = makeRuntime({
-      messages: [snapshotMessage("msg-1", { v: 1 })],
-      composerMetadata: live({ v: 1 }),
-    });
-    await send(runtime);
-    const appended = append.mock.calls[0]![0] as AppendMessage;
-    expect(appended.metadata?.custom?.interactables).toBeUndefined();
-  });
-
-  it("stamps the new state when it diverged from the latest snapshot", async () => {
-    const { runtime, append } = makeRuntime({
-      messages: [snapshotMessage("msg-1", { v: 1 })],
-      composerMetadata: live({ v: 2 }),
-    });
-    await send(runtime);
-    const appended = append.mock.calls[0]![0] as AppendMessage;
-    expect(appended.metadata?.custom?.interactables).toEqual([
-      { id: "n1", name: "note", state: { v: 2 } },
-    ]);
-  });
-});