@assistant-ui/react 0.11.57 → 0.12.0

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

@@ -4,21 +4,20 @@ import {
   tapEffect,
   tapInlineResource,
   type tapRef,
+  withKey,
 } from "@assistant-ui/tap";
+import {
+  type ClientOutput,
+  tapAssistantEmit,
+  tapClientLookup,
+} from "@assistant-ui/store";
 import {
   ComposerRuntime,
   EditComposerRuntime,
 } from "../runtime/ComposerRuntime";
 import { Unsubscribe } from "../../types";
-
-import { tapApi } from "../../utils/tap-store";
 import { ComposerRuntimeEventType } from "../runtime-cores/core/ComposerRuntimeCore";
-import { tapEvents } from "../../client/EventContext";
-import {
-  ComposerClientState,
-  ComposerClientApi,
-} from "../../client/types/Composer";
-import { tapLookupResources } from "../../client/util-hooks/tapLookupResources";
+import { ComposerState } from "../../types/scopes";
 import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
 import { tapSubscribable } from "../util-hooks/tapSubscribable";
 
@@ -46,9 +45,9 @@ export const ComposerClient = resource(
     threadIdRef: tapRef.RefObject<string>;
     messageIdRef?: tapRef.RefObject<string>;
     runtime: ComposerRuntime;
-  }) => {
+  }): ClientOutput<"composer"> => {
     const runtimeState = tapSubscribable(runtime);
-    const events = tapEvents();
+    const emit = tapAssistantEmit();
 
     // Bind composer events to event manager
     tapEffect(() => {
@@ -57,12 +56,12 @@ export const ComposerClient = resource(
       // Subscribe to composer events
       const composerEvents: ComposerRuntimeEventType[] = [
         "send",
-        "attachment-add",
+        "attachmentAdd",
       ];
 
       for (const event of composerEvents) {
         const unsubscribe = runtime.unstable_on(event, () => {
-          events.emit(`composer.${event}`, {
+          emit(`composer.${event}`, {
             threadId: threadIdRef.current,
             ...(messageIdRef && { messageId: messageIdRef.current }),
           });
@@ -73,16 +72,23 @@ export const ComposerClient = resource(
       return () => {
         for (const unsub of unsubscribers) unsub();
       };
-    }, [runtime, events, threadIdRef, messageIdRef]);
-
-    const attachments = tapLookupResources(
-      runtimeState.attachments.map((attachment, idx) => [
-        attachment.id,
-        ComposerAttachmentClientByIndex({ runtime: runtime, index: idx }),
-      ]),
+    }, [runtime, emit, threadIdRef, messageIdRef]);
+
+    const attachments = tapClientLookup(
+      () =>
+        runtimeState.attachments.map((attachment, idx) =>
+          withKey(
+            attachment.id,
+            ComposerAttachmentClientByIndex({
+              runtime,
+              index: idx,
+            }),
+          ),
+        ),
+      [runtimeState.attachments, runtime],
     );
 
-    const state = tapMemo<ComposerClientState>(() => {
+    const state = tapMemo<ComposerState>(() => {
       return {
         text: runtimeState.text,
         role: runtimeState.role,
@@ -97,36 +103,34 @@ export const ComposerClient = resource(
       };
     }, [runtimeState, attachments.state]);
 
-    return tapApi<ComposerClientApi>({
-      getState: () => state,
-
-      setText: runtime.setText,
-      setRole: runtime.setRole,
-      setRunConfig: runtime.setRunConfig,
-      addAttachment: runtime.addAttachment,
-      reset: runtime.reset,
-
-      clearAttachments: runtime.clearAttachments,
-      send: runtime.send,
-      cancel: runtime.cancel,
-      beginEdit:
-        (runtime as EditComposerRuntime).beginEdit ??
-        (() => {
-          throw new Error("beginEdit is not supported in this runtime");
-        }),
-
-      startDictation: runtime.startDictation,
-      stopDictation: runtime.stopDictation,
-
-      attachment: (selector) => {
-        if ("id" in selector) {
-          return attachments.api({ key: selector.id });
-        } else {
-          return attachments.api(selector);
-        }
+    return {
+      state,
+      methods: {
+        getState: () => state,
+        setText: runtime.setText,
+        setRole: runtime.setRole,
+        setRunConfig: runtime.setRunConfig,
+        addAttachment: runtime.addAttachment,
+        reset: runtime.reset,
+        clearAttachments: runtime.clearAttachments,
+        send: runtime.send,
+        cancel: runtime.cancel,
+        beginEdit:
+          (runtime as EditComposerRuntime).beginEdit ??
+          (() => {
+            throw new Error("beginEdit is not supported in this runtime");
+          }),
+        startDictation: runtime.startDictation,
+        stopDictation: runtime.stopDictation,
+        attachment: (selector) => {
+          if ("id" in selector) {
+            return attachments.get({ key: selector.id });
+          } else {
+            return attachments.get(selector);
+          }
+        },
+        __internal_getRuntime: () => runtime,
       },
-
-      __internal_getRuntime: () => runtime,
-    });
+    };
   },
 );

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

@@ -1,25 +1,20 @@
 import { resource } from "@assistant-ui/tap";
-import { tapApi } from "../../utils/tap-store";
+import { type ClientOutput } from "@assistant-ui/store";
 import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
 import { tapSubscribable } from "../util-hooks/tapSubscribable";
-import { MessagePartClientApi } from "../../client/types/Part";
-export const MessagePartClient = resource(
-  ({ runtime }: { runtime: MessagePartRuntime }) => {
-    const runtimeState = tapSubscribable(runtime);
 
-    const api: MessagePartClientApi = {
-      getState: () => runtimeState,
+export const MessagePartClient = resource(
+  ({ runtime }: { runtime: MessagePartRuntime }): ClientOutput<"part"> => {
+    const state = tapSubscribable(runtime);
 
-      addToolResult: (result) => runtime.addToolResult(result),
-      resumeToolCall: (payload) => runtime.resumeToolCall(payload),
-      __internal_getRuntime: () => runtime,
+    return {
+      state,
+      methods: {
+        getState: () => state,
+        addToolResult: (result) => runtime.addToolResult(result),
+        resumeToolCall: (payload) => runtime.resumeToolCall(payload),
+        __internal_getRuntime: () => runtime,
+      },
     };
-
-    return tapApi<MessagePartClientApi>(api, {
-      key:
-        runtimeState.type === "tool-call"
-          ? `toolCallId-${runtimeState.toolCallId}`
-          : undefined,
-    });
   },
 );

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

@@ -1,20 +1,21 @@
 import {
+  withKey,
   resource,
   tapInlineResource,
   tapMemo,
   tapState,
 } from "@assistant-ui/tap";
-import { tapApi } from "../../utils/tap-store";
+import {
+  type ClientOutput,
+  tapClientLookup,
+  tapClientResource,
+} from "@assistant-ui/store";
 import { MessageRuntime } from "../runtime/MessageRuntime";
 import { tapSubscribable } from "../util-hooks/tapSubscribable";
 import { ComposerClient } from "./ComposerRuntimeClient";
 import { MessagePartClient } from "./MessagePartRuntimeClient";
-import { tapLookupResources } from "../../client/util-hooks/tapLookupResources";
 import { RefObject } from "react";
-import {
-  MessageClientState,
-  MessageClientApi,
-} from "../../client/types/Message";
+import { MessageState } from "../../types/scopes";
 import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
 
 const MessageAttachmentClientByIndex = resource(
@@ -46,7 +47,7 @@ export const MessageClient = resource(
   }: {
     runtime: MessageRuntime;
     threadIdRef: RefObject<string>;
-  }) => {
+  }): ClientOutput<"message"> => {
     const runtimeState = tapSubscribable(runtime);
 
     const [isCopiedState, setIsCopied] = tapState(false);
@@ -61,7 +62,7 @@ export const MessageClient = resource(
       [runtime],
     );
 
-    const composer = tapInlineResource(
+    const composer = tapClientResource(
       ComposerClient({
         runtime: runtime.composer,
         threadIdRef,
@@ -69,25 +70,33 @@ export const MessageClient = resource(
       }),
     );
 
-    const parts = tapLookupResources(
-      runtimeState.content.map((part, idx) => [
-        "toolCallId" in part && part.toolCallId != null
-          ? `toolCallId-${part.toolCallId}`
-          : `index-${idx}`,
-        MessagePartByIndex({ runtime, index: idx }),
-      ]),
+    const parts = tapClientLookup(
+      () =>
+        runtimeState.content.map((part, idx) =>
+          withKey(
+            "toolCallId" in part && part.toolCallId != null
+              ? `toolCallId-${part.toolCallId}`
+              : `index-${idx}`,
+            MessagePartByIndex({ runtime, index: idx }),
+          ),
+        ),
+      [runtimeState.content, runtime],
     );
 
-    const attachments = tapLookupResources(
-      runtimeState.attachments?.map((attachment, idx) => [
-        attachment.id,
-        MessageAttachmentClientByIndex({ runtime, index: idx }),
-      ]) ?? [],
+    const attachments = tapClientLookup(
+      () =>
+        (runtimeState.attachments ?? []).map((attachment, idx) =>
+          withKey(
+            attachment.id,
+            MessageAttachmentClientByIndex({ runtime, index: idx }),
+          ),
+        ),
+      [runtimeState.attachments, runtime],
     );
 
-    const state = tapMemo<MessageClientState>(() => {
+    const state = tapMemo<MessageState>(() => {
       return {
-        ...(runtimeState as MessageClientState),
+        ...(runtimeState as MessageState),
 
         parts: parts.state,
         composer: composer.state,
@@ -103,11 +112,12 @@ export const MessageClient = resource(
       isHoveringState,
     ]);
 
-    return tapApi<MessageClientApi>(
-      {
+    return {
+      state,
+      methods: {
         getState: () => state,
 
-        composer: composer.api,
+        composer: composer.methods,
 
         reload: (config) => runtime.reload(config),
         speak: () => runtime.speak(),
@@ -115,20 +125,19 @@ export const MessageClient = resource(
         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 });
+            return parts.get({ index: selector.index });
           } else {
-            return parts.api({ key: `toolCallId-${selector.toolCallId}` });
+            return parts.get({ key: `toolCallId-${selector.toolCallId}` });
           }
         },
 
         attachment: (selector) => {
           if ("id" in selector) {
-            return attachments.api({ key: selector.id });
+            return attachments.get({ key: selector.id });
           } else {
-            return attachments.api(selector);
+            return attachments.get(selector);
           }
         },
 
@@ -137,9 +146,6 @@ export const MessageClient = resource(
 
         __internal_getRuntime: () => runtime,
       },
-      {
-        key: runtimeState.id,
-      },
-    );
+    };
   },
 );

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

@@ -1,18 +1,20 @@
 import { resource, tapEffect } from "@assistant-ui/tap";
+import { type ClientOutput, tapAssistantEmit } from "@assistant-ui/store";
 import {
   ThreadListItemEventType,
   ThreadListItemRuntime,
 } from "../runtime/ThreadListItemRuntime";
 import { Unsubscribe } from "../../types";
-import { tapApi } from "../../utils/tap-store";
 import { tapSubscribable } from "../util-hooks/tapSubscribable";
-import { tapEvents } from "../../client/EventContext";
-import { ThreadListItemClientApi } from "../../client/types/ThreadListItem";
 
 export const ThreadListItemClient = resource(
-  ({ runtime }: { runtime: ThreadListItemRuntime }) => {
-    const runtimeState = tapSubscribable(runtime);
-    const events = tapEvents();
+  ({
+    runtime,
+  }: {
+    runtime: ThreadListItemRuntime;
+  }): ClientOutput<"threadListItem"> => {
+    const state = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
 
     // Bind thread list item events to event manager
     tapEffect(() => {
@@ -20,13 +22,13 @@ export const ThreadListItemClient = resource(
 
       // Subscribe to thread list item events
       const threadListItemEvents: ThreadListItemEventType[] = [
-        "switched-to",
-        "switched-away",
+        "switchedTo",
+        "switchedAway",
       ];
 
       for (const event of threadListItemEvents) {
         const unsubscribe = runtime.unstable_on(event, () => {
-          events.emit(`thread-list-item.${event}`, {
+          emit(`threadListItem.${event}`, {
             threadId: runtime.getState()!.id,
           });
         });
@@ -36,11 +38,12 @@ export const ThreadListItemClient = resource(
       return () => {
         for (const unsub of unsubscribers) unsub();
       };
-    }, [runtime, events]);
+    }, [runtime, emit]);
 
-    return tapApi<ThreadListItemClientApi>(
-      {
-        getState: () => runtimeState,
+    return {
+      state,
+      methods: {
+        getState: () => state,
         switchTo: runtime.switchTo,
         rename: runtime.rename,
         archive: runtime.archive,
@@ -51,9 +54,6 @@ export const ThreadListItemClient = resource(
         detach: runtime.detach,
         __internal_getRuntime: () => runtime,
       },
-      {
-        key: runtimeState.id,
-      },
-    );
+    };
   },
 );

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

@@ -1,14 +1,19 @@
-import { tapApi } from "../../utils/tap-store";
-import { resource, tapInlineResource, tapMemo } from "@assistant-ui/tap";
+import {
+  withKey,
+  resource,
+  tapInlineResource,
+  tapMemo,
+} from "@assistant-ui/tap";
+import {
+  type ClientOutput,
+  tapClientLookup,
+  tapClientResource,
+} from "@assistant-ui/store";
 import { ThreadListRuntime } from "../runtime/ThreadListRuntime";
 import { tapSubscribable } from "../util-hooks/tapSubscribable";
 import { ThreadListItemClient } from "./ThreadListItemRuntimeClient";
 import { ThreadClient } from "./ThreadRuntimeClient";
-import { tapLookupResources } from "../../client/util-hooks/tapLookupResources";
-import {
-  ThreadListClientState,
-  ThreadListClientApi,
-} from "../../client/types/ThreadList";
+import { ThreadsState } from "../../types/scopes";
 import type { AssistantRuntime } from "../runtime/AssistantRuntime";
 
 const ThreadListItemClientById = resource(
@@ -32,23 +37,24 @@ export const ThreadListClient = resource(
   }: {
     runtime: ThreadListRuntime;
     __internal_assistantRuntime: AssistantRuntime;
-  }) => {
+  }): ClientOutput<"threads"> => {
     const runtimeState = tapSubscribable(runtime);
 
-    const main = tapInlineResource(
+    const main = tapClientResource(
       ThreadClient({
         runtime: runtime.main,
       }),
     );
 
-    const threadItems = tapLookupResources(
-      Object.keys(runtimeState.threadItems).map((id) => [
-        id,
-        ThreadListItemClientById({ runtime, id }),
-      ]),
+    const threadItems = tapClientLookup(
+      () =>
+        Object.keys(runtimeState.threadItems).map((id) =>
+          withKey(id, ThreadListItemClientById({ runtime, id })),
+        ),
+      [runtimeState.threadItems, runtime],
     );
 
-    const state = tapMemo<ThreadListClientState>(() => {
+    const state = tapMemo<ThreadsState>(() => {
       return {
         mainThreadId: runtimeState.mainThreadId,
         newThreadId: runtimeState.newThread ?? null,
@@ -61,35 +67,34 @@ export const ThreadListClient = resource(
       };
     }, [runtimeState, threadItems.state, main.state]);
 
-    return tapApi<ThreadListClientApi>({
-      getState: () => state,
-
-      thread: () => main.api,
-
-      item: (threadIdOrOptions) => {
-        if (threadIdOrOptions === "main") {
-          return threadItems.api({ key: state.mainThreadId });
-        }
+    return {
+      state,
+      methods: {
+        getState: () => state,
+        thread: () => main.methods,
+        item: (threadIdOrOptions) => {
+          if (threadIdOrOptions === "main") {
+            return threadItems.get({ key: state.mainThreadId });
+          }
 
-        if ("id" in threadIdOrOptions) {
-          return threadItems.api({ key: threadIdOrOptions.id });
-        }
+          if ("id" in threadIdOrOptions) {
+            return threadItems.get({ key: threadIdOrOptions.id });
+          }
 
-        const { index, archived = false } = threadIdOrOptions;
-        const id = archived
-          ? state.archivedThreadIds[index]!
-          : state.threadIds[index]!;
-        return threadItems.api({ key: id });
+          const { index, archived = false } = threadIdOrOptions;
+          const id = archived
+            ? state.archivedThreadIds[index]!
+            : state.threadIds[index]!;
+          return threadItems.get({ key: id });
+        },
+        switchToThread: async (threadId) => {
+          await runtime.switchToThread(threadId);
+        },
+        switchToNewThread: async () => {
+          await runtime.switchToNewThread();
+        },
+        __internal_getAssistantRuntime: () => __internal_assistantRuntime,
       },
-
-      switchToThread: (threadId) => {
-        runtime.switchToThread(threadId);
-      },
-      switchToNewThread: () => {
-        runtime.switchToNewThread();
-      },
-
-      __internal_getAssistantRuntime: () => __internal_assistantRuntime,
-    });
+    };
   },
 );