@assistant-ui/core 0.3.13 → 0.3.15

package/src/tests/tools-scope-migration.test.tsx

@@ -0,0 +1,58 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { withKey } from "@assistant-ui/tap";
+import { useAui } from "@assistant-ui/store";
+import { Tools } from "../react/client/Tools";
+import { ModelContext } from "../store/clients/model-context-client";
+import type { Toolkit } from "../react/model-context/toolbox";
+
+type AnyClient = Record<string, any>;
+
+const toolkit = {
+  lookup: {
+    description: "look something up",
+    parameters: { type: "object", properties: {} },
+    execute: async () => "ok",
+  },
+} as unknown as Toolkit;
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("Tools model-context registration", () => {
+  it("migrates to a structurally replaced modelContext scope", async () => {
+    let aui!: AnyClient;
+    const Harness = ({ generation }: { generation: number }) => {
+      aui = useAui({
+        tools: Tools({ toolkit }),
+        modelContext: withKey(String(generation), ModelContext()),
+      } as never);
+      return null;
+    };
+    const view = render(<Harness generation={0} />);
+
+    expect(
+      Object.keys(aui.modelContext().getModelContext().tools ?? {}),
+    ).toContain("lookup");
+
+    // A rerender inside an outer act would not land until that act exits,
+    // so the swap happens first and only the scheduler wait is wrapped
+    view.rerender(<Harness generation={1} />);
+
+    // The registration lands one scheduler macrotask after the swap: the
+    // mount-time register marks the tap scheduler dirty, which defers the
+    // structural publish to the scheduler's drain. The remounted scope
+    // starts from fresh state, so the tools reappearing proves the
+    // registration migrated to the replacement instance.
+    await act(async () => {
+      await vi.waitFor(() =>
+        expect(
+          Object.keys(aui.modelContext().getModelContext().tools ?? {}),
+        ).toContain("lookup"),
+      );
+    });
+  });
+});

package/src/tests/useRemoteThreadListRuntime-controlled.test.tsx

@@ -173,6 +173,73 @@ describe("useRemoteThreadListRuntime controlled threadId", () => {
     expect(onThreadIdChange).not.toHaveBeenCalled();
   });
 
+  it("reports the reset when an adapter change makes the runtime uncontrolled", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapterA}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapterB}
+        threadId={undefined}
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitFor(() => {
+      const state = runtimeRef.current!.threads.getState();
+      expect(state.mainThreadId).toBeDefined();
+      expect(runtimeRef.current!.threads.mainItem.getState().status).toBe(
+        "new",
+      );
+    });
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
+  it("does not echo a controlled target when the adapter changes", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapterA}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapterB}
+        threadId="thread-b"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-b");
+    expect(adapterB.fetch).toHaveBeenCalledWith("thread-b");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
   it("still emits runtime-initiated thread switches", async () => {
     const adapter = makeAdapter();
     const onThreadIdChange = vi.fn();

package/src/types/message.ts

@@ -304,7 +304,7 @@ export type ToolCallMessagePartStatus =
       /** The tool call is waiting for UI or human input before continuing. */
       readonly type: "requires-action";
       /** Reason the tool call requires action. */
-      readonly reason: "interrupt";
+      readonly reason: "tool-calls" | "interrupt";
     }
   | MessagePartStatus;
 

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

@@ -0,0 +1,139 @@
+import { describe, expect, it, vi } from "vitest";
+import { CompositeContextProvider } from "./composite-context-provider";
+
+describe("CompositeContextProvider", () => {
+  it("notifies every subscriber and rethrows when a registration subscriber throws", () => {
+    const composite = new CompositeContextProvider();
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+
+    composite.subscribe(() => {
+      throw error;
+    });
+    composite.subscribe(laterSubscriber);
+
+    expect(() =>
+      composite.registerModelContextProvider({
+        getModelContext: () => ({ system: "provider instructions" }),
+      }),
+    ).toThrow(error);
+
+    expect(composite.getModelContext().system).toBe("provider instructions");
+    expect(laterSubscriber).toHaveBeenCalledTimes(1);
+  });
+
+  it("rolls back providers that fail to subscribe", () => {
+    const composite = new CompositeContextProvider();
+    const error = new Error("subscription failed");
+    const observedSystems: Array<string | undefined> = [];
+
+    composite.subscribe(() => {
+      observedSystems.push(composite.getModelContext().system);
+    });
+
+    expect(() =>
+      composite.registerModelContextProvider({
+        getModelContext: () => ({ system: "provider instructions" }),
+        subscribe: (callback) => {
+          callback();
+          throw error;
+        },
+      }),
+    ).toThrow(error);
+
+    expect(composite.getModelContext().system).toBeUndefined();
+    expect(observedSystems).toEqual(["provider instructions", undefined]);
+  });
+
+  it("rethrows the provider subscription failure when a rollback subscriber throws", () => {
+    const composite = new CompositeContextProvider();
+    const subscriptionError = new Error("subscription failed");
+    const subscriberError = new Error("subscriber failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    composite.subscribe(() => {
+      throw subscriberError;
+    });
+
+    try {
+      expect(() =>
+        composite.registerModelContextProvider({
+          getModelContext: () => ({ system: "provider instructions" }),
+          subscribe: () => {
+            throw subscriptionError;
+          },
+        }),
+      ).toThrow(subscriptionError);
+
+      expect(composite.getModelContext().system).toBeUndefined();
+      expect(consoleError).toHaveBeenCalledWith(subscriberError);
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
+  it("preserves an earlier registration when a duplicate fails to subscribe", () => {
+    const composite = new CompositeContextProvider();
+    const error = new Error("subscription failed");
+    let subscriptionCount = 0;
+    const provider = {
+      getModelContext: () => ({ system: "provider instructions" }),
+      subscribe: () => {
+        subscriptionCount++;
+        if (subscriptionCount === 2) throw error;
+        return () => {};
+      },
+    };
+
+    const unregister = composite.registerModelContextProvider(provider);
+
+    expect(() => composite.registerModelContextProvider(provider)).toThrow(
+      error,
+    );
+    expect(composite.getModelContext().system).toBe("provider instructions");
+
+    unregister();
+    expect(composite.getModelContext().system).toBeUndefined();
+  });
+
+  it("keeps duplicate registrations independent", () => {
+    const composite = new CompositeContextProvider();
+    const provider = {
+      getModelContext: () => ({ system: "provider instructions" }),
+    };
+
+    const unregisterFirst = composite.registerModelContextProvider(provider);
+    const unregisterSecond = composite.registerModelContextProvider(provider);
+
+    unregisterFirst();
+    expect(composite.getModelContext().system).toBe("provider instructions");
+
+    unregisterSecond();
+    expect(composite.getModelContext().system).toBeUndefined();
+  });
+
+  it("notifies every subscriber and rethrows on provider updates", () => {
+    const composite = new CompositeContextProvider();
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    let publishUpdate = () => {};
+
+    composite.registerModelContextProvider({
+      getModelContext: () => ({ system: "provider instructions" }),
+      subscribe: (callback) => {
+        publishUpdate = callback;
+        return () => {};
+      },
+    });
+
+    composite.subscribe(() => {
+      throw error;
+    });
+    composite.subscribe(laterSubscriber);
+
+    expect(() => publishUpdate()).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledTimes(1);
+  });
+});

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/utils/silent-runtime-action.ts

@@ -0,0 +1,6 @@
+export const SILENT_RUNTIME_ACTION = Symbol.for(
+  "assistant-ui.silent-runtime-action",
+);
+
+export const isSilentRuntimeAction = (error: unknown): boolean =>
+  typeof error === "object" && error !== null && SILENT_RUNTIME_ACTION in error;