@assistant-ui/react 0.11.4 → 0.11.6

package/src/context/react/index.ts

@@ -54,3 +54,5 @@ export {
   useThreadListItemRuntime,
   useThreadListItem,
 } from "../../legacy-runtime/hooks/ThreadListItemContext";
+
+export { AssistantProvider } from "./AssistantApiContext";

package/src/legacy-runtime/AssistantRuntimeProvider.tsx

@@ -1,12 +1,10 @@
 "use client";
 
 import { FC, memo, PropsWithChildren } from "react";
-import { AssistantApiProvider } from "../context/react/AssistantApiContext";
+import { AssistantProvider } from "../context/react/AssistantApiContext";
 import { AssistantRuntime } from "./runtime/AssistantRuntime";
 import { AssistantRuntimeCore } from "./runtime-cores/core/AssistantRuntimeCore";
 import { useAssistantClient } from "../client/AssistantClient";
-
-import { ThreadViewportProvider } from "../context/providers/ThreadViewportProvider";
 import { ThreadListClient } from "./client/ThreadListRuntimeClient";
 
 export namespace AssistantProvider {
@@ -46,15 +44,3 @@ export const AssistantRuntimeProviderImpl: FC<AssistantProvider.Props> = ({
 };
 
 export const AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
-
-const AssistantProvider: FC<
-  PropsWithChildren<{ api: ReturnType<typeof useAssistantClient> }>
-> = ({ children, api }) => {
-  return (
-    <AssistantApiProvider api={api}>
-      {/* TODO temporarily allow accessing viewport state from outside the viewport */}
-      {/* TODO figure out if this behavior should be deprecated, since it is quite hacky */}
-      <ThreadViewportProvider>{children}</ThreadViewportProvider>
-    </AssistantApiProvider>
-  );
-};

package/src/legacy-runtime/client/AttachmentRuntimeClient.ts

@@ -7,16 +7,15 @@ import { tapSubscribable } from "../util-hooks/tapSubscribable";
 export const AttachmentRuntimeClient = resource(
   ({ runtime }: { runtime: AttachmentRuntime }) => {
     const state = tapSubscribable(runtime);
-    const api = tapApi<AttachmentClientApi>({
-      getState: () => state,
-      remove: runtime.remove,
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      state: state,
-      api,
-      key: state.id,
-    };
+    return tapApi<AttachmentClientApi>(
+      {
+        getState: () => state,
+        remove: runtime.remove,
+        __internal_getRuntime: () => runtime,
+      },
+      {
+        key: state.id,
+      },
+    );
   },
 );

package/src/legacy-runtime/client/ComposerRuntimeClient.ts

@@ -98,7 +98,7 @@ export const ComposerClient = resource(
       };
     }, [runtimeState, attachments.state]);
 
-    const api = tapApi<ComposerClientApi>({
+    return tapApi<ComposerClientApi>({
       getState: () => state,
 
       setText: runtime.setText,
@@ -126,10 +126,5 @@ export const ComposerClient = resource(
 
       __internal_getRuntime: () => runtime,
     });
-
-    return {
-      state,
-      api,
-    };
   },
 );

package/src/legacy-runtime/client/EventManagerRuntimeClient.ts

@@ -1,30 +1,41 @@
 import { resource, tapMemo } from "@assistant-ui/tap";
-import { AssistantEvents, Unsubscribe } from "../../types";
-
-type EventCallback<TEvent extends keyof AssistantEvents> = (
-  payload: AssistantEvents[TEvent],
-) => void;
+import { Unsubscribe } from "../../types/Unsubscribe";
+import {
+  AssistantEventMap,
+  AssistantEvent,
+  AssistantEventCallback,
+} from "../../types/EventTypes";
 
 export type EventManager = {
-  on<TEvent extends keyof AssistantEvents>(
+  on<TEvent extends AssistantEvent>(
     event: TEvent,
-    callback: EventCallback<TEvent>,
+    callback: AssistantEventCallback<TEvent>,
   ): Unsubscribe;
-  emit<TEvent extends keyof AssistantEvents>(
+  emit<TEvent extends Exclude<AssistantEvent, "*">>(
     event: TEvent,
-    payload: AssistantEvents[TEvent],
+    payload: AssistantEventMap[TEvent],
+  ): void;
+};
+
+type ListenerMap = Omit<
+  Map<AssistantEvent, Set<AssistantEventCallback<AssistantEvent>>>,
+  "get" | "set"
+> & {
+  get<TEvent extends AssistantEvent>(
+    event: TEvent,
+  ): Set<AssistantEventCallback<TEvent>> | undefined;
+  set<TEvent extends AssistantEvent>(
+    event: TEvent,
+    value: Set<AssistantEventCallback<TEvent>>,
   ): void;
 };
 
 export const EventManager = resource(() => {
   const events = tapMemo(() => {
-    const listeners = new Map<string, Set<EventCallback<any>>>();
+    const listeners: ListenerMap = new Map();
 
     return {
-      on: <TEvent extends keyof AssistantEvents>(
-        event: TEvent,
-        callback: EventCallback<TEvent>,
-      ): Unsubscribe => {
+      on: (event, callback) => {
         if (!listeners.has(event)) {
           listeners.set(event, new Set());
         }
@@ -40,14 +51,26 @@ export const EventManager = resource(() => {
         };
       },
 
-      emit: (event: keyof AssistantEvents, payload: any) => {
+      emit: (event, payload) => {
         const eventListeners = listeners.get(event);
-        if (!eventListeners) return;
+        const wildcardListeners = listeners.get("*");
+
+        if (!eventListeners && !wildcardListeners) return;
 
         // make sure state updates flush
         queueMicrotask(() => {
-          for (const callback of eventListeners) {
-            callback(payload);
+          // Emit to specific event listeners
+          if (eventListeners) {
+            for (const callback of eventListeners) {
+              callback(payload);
+            }
+          }
+
+          // Emit to wildcard listeners
+          if (wildcardListeners) {
+            for (const callback of wildcardListeners) {
+              callback({ event, payload });
+            }
           }
         });
       },

package/src/legacy-runtime/client/MessagePartRuntimeClient.ts

@@ -7,21 +7,20 @@ export const MessagePartClient = resource(
   ({ runtime }: { runtime: MessagePartRuntime }) => {
     const runtimeState = tapSubscribable(runtime);
 
-    const api = tapApi<MessagePartClientApi>({
-      getState: () => runtimeState,
+    return tapApi<MessagePartClientApi>(
+      {
+        getState: () => runtimeState,
 
-      addToolResult: (result) => runtime.addToolResult(result),
+        addToolResult: (result) => runtime.addToolResult(result),
 
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      key:
-        runtimeState.type === "tool-call"
-          ? "toolCallId-" + runtimeState.toolCallId
-          : undefined,
-      state: runtimeState,
-      api,
-    };
+        __internal_getRuntime: () => runtime,
+      },
+      {
+        key:
+          runtimeState.type === "tool-call"
+            ? "toolCallId-" + runtimeState.toolCallId
+            : undefined,
+      },
+    );
   },
 );

package/src/legacy-runtime/client/MessageRuntimeClient.ts

@@ -99,44 +99,43 @@ export const MessageClient = resource(
       isHoveringState,
     ]);
 
-    const api = tapApi<MessageClientApi>({
-      getState: () => state,
-
-      composer: composer.api,
-
-      reload: (config) => runtime.reload(config),
-      speak: () => runtime.speak(),
-      stopSpeaking: () => runtime.stopSpeaking(),
-      submitFeedback: (feedback) => runtime.submitFeedback(feedback),
-      switchToBranch: (options) => runtime.switchToBranch(options),
-      getCopyText: () => runtime.unstable_getCopyText(),
-
-      part: (selector) => {
-        if ("index" in selector) {
-          return parts.api({ index: selector.index });
-        } else {
-          return parts.api({ key: "toolCallId-" + selector.toolCallId });
-        }
-      },
-
-      attachment: (selector) => {
-        if ("id" in selector) {
-          return attachments.api({ key: selector.id });
-        } else {
-          return attachments.api(selector);
-        }
-      },
+    return tapApi<MessageClientApi>(
+      {
+        getState: () => state,
+
+        composer: composer.api,
+
+        reload: (config) => runtime.reload(config),
+        speak: () => runtime.speak(),
+        stopSpeaking: () => runtime.stopSpeaking(),
+        submitFeedback: (feedback) => runtime.submitFeedback(feedback),
+        switchToBranch: (options) => runtime.switchToBranch(options),
+        getCopyText: () => runtime.unstable_getCopyText(),
+
+        part: (selector) => {
+          if ("index" in selector) {
+            return parts.api({ index: selector.index });
+          } else {
+            return parts.api({ key: "toolCallId-" + selector.toolCallId });
+          }
+        },
 
-      setIsCopied,
-      setIsHovering,
+        attachment: (selector) => {
+          if ("id" in selector) {
+            return attachments.api({ key: selector.id });
+          } else {
+            return attachments.api(selector);
+          }
+        },
 
-      __internal_getRuntime: () => runtime,
-    });
+        setIsCopied,
+        setIsHovering,
 
-    return {
-      key: runtimeState.id,
-      state,
-      api,
-    };
+        __internal_getRuntime: () => runtime,
+      },
+      {
+        key: runtimeState.id,
+      },
+    );
   },
 );

package/src/legacy-runtime/client/ThreadListItemRuntimeClient.ts

@@ -38,23 +38,22 @@ export const ThreadListItemClient = resource(
       };
     }, [runtime, events]);
 
-    const api = tapApi<ThreadListItemClientApi>({
-      getState: () => runtimeState,
-      switchTo: runtime.switchTo,
-      rename: runtime.rename,
-      archive: runtime.archive,
-      unarchive: runtime.unarchive,
-      delete: runtime.delete,
-      generateTitle: runtime.generateTitle,
-      initialize: runtime.initialize,
-      detach: runtime.detach,
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      state: runtimeState,
-      api,
-      key: runtimeState.id,
-    };
+    return tapApi<ThreadListItemClientApi>(
+      {
+        getState: () => runtimeState,
+        switchTo: runtime.switchTo,
+        rename: runtime.rename,
+        archive: runtime.archive,
+        unarchive: runtime.unarchive,
+        delete: runtime.delete,
+        generateTitle: runtime.generateTitle,
+        initialize: runtime.initialize,
+        detach: runtime.detach,
+        __internal_getRuntime: () => runtime,
+      },
+      {
+        key: runtimeState.id,
+      },
+    );
   },
 );

package/src/legacy-runtime/client/ThreadListRuntimeClient.ts

@@ -43,7 +43,7 @@ export const ThreadListClient = resource(
     const state = tapMemo<ThreadListClientState>(() => {
       return {
         mainThreadId: runtimeState.mainThreadId,
-        newThreadId: runtimeState.newThread,
+        newThreadId: runtimeState.newThread ?? null,
         isLoading: runtimeState.isLoading,
         threadIds: runtimeState.threads,
         archivedThreadIds: runtimeState.archivedThreads,
@@ -53,7 +53,7 @@ export const ThreadListClient = resource(
       };
     }, [runtimeState, threadItems.state, main.state]);
 
-    const api = tapApi<ThreadListClientApi>({
+    return tapApi<ThreadListClientApi>({
       getState: () => state,
 
       thread: () => main.api,
@@ -81,10 +81,5 @@ export const ThreadListClient = resource(
         runtime.switchToNewThread();
       },
     });
-
-    return {
-      state,
-      api,
-    };
   },
 );

package/src/legacy-runtime/client/ThreadRuntimeClient.ts

@@ -111,7 +111,7 @@ export const ThreadClient = resource(
       };
     }, [runtimeState, messages, composer.state]);
 
-    const api = tapApi<ThreadClientApi>({
+    return tapApi<ThreadClientApi>({
       getState: () => state,
 
       composer: composer.api,
@@ -136,10 +136,5 @@ export const ThreadClient = resource(
 
       __internal_getRuntime: () => runtime,
     });
-
-    return {
-      state,
-      api,
-    };
   },
 );

package/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.tsx

@@ -173,7 +173,6 @@ export abstract class BaseComposerRuntimeCore
         ];
       else {
         this._attachments = [...this._attachments, a];
-        this._notifyEventSubscribers("attachment-add");
       }
 
       this._notifySubscribers();

package/src/types/EventTypes.ts

@@ -1,6 +1,5 @@
-export type EventSource<
-  T extends keyof AssistantEvents = keyof AssistantEvents,
-> = T extends `${infer Source}.${string}` ? Source : never;
+export type EventSource<T extends AssistantEvent = AssistantEvent> =
+  T extends `${infer Source}.${string}` ? Source : never;
 
 type ScopeConfig = {
   composer: "thread" | "message";
@@ -8,28 +7,28 @@ type ScopeConfig = {
   "thread-list-item": never;
 };
 
-export type SourceByScope<
-  TScope extends AssistantEventScope<keyof AssistantEvents>,
-> =
+export type SourceByScope<TScope extends AssistantEventScope<AssistantEvent>> =
   | (TScope extends "*" ? EventSource : never)
   | (TScope extends keyof ScopeConfig ? TScope : never)
   | {
       [K in keyof ScopeConfig]: TScope extends ScopeConfig[K] ? K : never;
     }[keyof ScopeConfig];
 
-export type AssistantEventScope<TEvent extends keyof AssistantEvents> =
+export type AssistantEventScope<TEvent extends AssistantEvent> =
   | "*"
   | EventSource<TEvent>
   | ScopeConfig[EventSource<TEvent>];
 
-export type AssistantEventSelector<TEvent extends keyof AssistantEvents> =
+export type AssistantEventSelector<TEvent extends AssistantEvent> =
   | TEvent
   | {
       scope: AssistantEventScope<TEvent>;
       event: TEvent;
     };
 
-export type AssistantEvents = {
+export type AssistantEvent = keyof AssistantEventMap;
+
+export type AssistantEventMap = {
   // Thread events (from ThreadRuntimeEventType)
   "thread.run-start": {
     threadId: string;
@@ -61,9 +60,17 @@ export type AssistantEvents = {
   "thread-list-item.switched-away": {
     threadId: string;
   };
+
+  // Catch-all
+  "*": {
+    [K in Exclude<keyof AssistantEventMap, "*">]: {
+      event: K;
+      payload: AssistantEventMap[K];
+    };
+  }[Exclude<keyof AssistantEventMap, "*">];
 };
 
-export const normalizeEventSelector = <TEvent extends keyof AssistantEvents>(
+export const normalizeEventSelector = <TEvent extends AssistantEvent>(
   selector: AssistantEventSelector<TEvent>,
 ) => {
   if (typeof selector === "string") {
@@ -81,8 +88,8 @@ export const normalizeEventSelector = <TEvent extends keyof AssistantEvents>(
 };
 
 export const checkEventScope = <
-  TEvent extends keyof AssistantEvents,
-  TExpectedScope extends AssistantEventScope<keyof AssistantEvents>,
+  TEvent extends AssistantEvent,
+  TExpectedScope extends AssistantEventScope<AssistantEvent>,
 >(
   expectedScope: TExpectedScope,
   scope: AssistantEventScope<TEvent>,
@@ -90,3 +97,7 @@ export const checkEventScope = <
 ): _event is Extract<TEvent, `${SourceByScope<TExpectedScope>}.${string}`> => {
   return scope === expectedScope;
 };
+
+export type AssistantEventCallback<TEvent extends AssistantEvent> = (
+  payload: AssistantEventMap[TEvent],
+) => void;

package/src/types/index.ts

@@ -54,5 +54,7 @@ export type { Unsubscribe } from "./Unsubscribe";
 export type {
   AssistantEventScope,
   AssistantEventSelector,
-  AssistantEvents,
+  AssistantEvent,
+  AssistantEventMap,
+  AssistantEventCallback,
 } from "./EventTypes";

package/src/utils/tap-store/tap-api.ts

@@ -34,15 +34,32 @@ class ReadonlyApiHandler<TApi extends ApiObject> implements ProxyHandler<TApi> {
   }
 }
 
-export const tapApi = <TApi extends ApiObject>(api: TApi) => {
+export const tapApi = <TApi extends ApiObject & { getState: () => any }>(
+  api: TApi,
+  options?: {
+    key?: string | undefined;
+  },
+) => {
   const ref = tapRef(() => api);
   tapEffect(() => {
     ref.current = api;
   });
 
-  return tapMemo(
+  const apiProxy = tapMemo(
     () =>
       new Proxy<TApi>({} as TApi, new ReadonlyApiHandler(() => ref.current)),
     [],
   );
+
+  const key = options?.key;
+  const state = api.getState();
+
+  return tapMemo(
+    () => ({
+      key,
+      state,
+      api: apiProxy,
+    }),
+    [state, key],
+  );
 };