@assistant-ui/react 0.11.0 → 0.11.1

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

@@ -0,0 +1,58 @@
+import { resource, tapMemo } from "@assistant-ui/tap";
+import { AssistantEvents, Unsubscribe } from "../../types";
+
+type EventCallback<TEvent extends keyof AssistantEvents> = (
+  payload: AssistantEvents[TEvent],
+) => void;
+
+export type EventManager = {
+  on<TEvent extends keyof AssistantEvents>(
+    event: TEvent,
+    callback: EventCallback<TEvent>,
+  ): Unsubscribe;
+  emit<TEvent extends keyof AssistantEvents>(
+    event: TEvent,
+    payload: AssistantEvents[TEvent],
+  ): void;
+};
+
+export const EventManager = resource(() => {
+  const events = tapMemo(() => {
+    const listeners = new Map<string, Set<EventCallback<any>>>();
+
+    return {
+      on: <TEvent extends keyof AssistantEvents>(
+        event: TEvent,
+        callback: EventCallback<TEvent>,
+      ): Unsubscribe => {
+        if (!listeners.has(event)) {
+          listeners.set(event, new Set());
+        }
+
+        const eventListeners = listeners.get(event)!;
+        eventListeners.add(callback);
+
+        return () => {
+          eventListeners.delete(callback);
+          if (eventListeners.size === 0) {
+            listeners.delete(event);
+          }
+        };
+      },
+
+      emit: (event: keyof AssistantEvents, payload: any) => {
+        const eventListeners = listeners.get(event);
+        if (!eventListeners) return;
+
+        // make sure state updates flush
+        queueMicrotask(() => {
+          for (const callback of eventListeners) {
+            callback(payload);
+          }
+        });
+      },
+    } satisfies EventManager;
+  }, []);
+
+  return events;
+});

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

@@ -0,0 +1,27 @@
+import { resource } from "@assistant-ui/tap";
+import { tapApi } from "../../utils/tap-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 = tapApi<MessagePartClientApi>({
+      getState: () => runtimeState,
+
+      addToolResult: (result) => runtime.addToolResult(result),
+
+      __internal_getRuntime: () => runtime,
+    });
+
+    return {
+      key:
+        runtimeState.type === "tool-call"
+          ? "toolCallId-" + runtimeState.toolCallId
+          : undefined,
+      state: runtimeState,
+      api,
+    };
+  },
+);

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

@@ -0,0 +1,136 @@
+import {
+  resource,
+  tapInlineResource,
+  tapMemo,
+  tapState,
+} from "@assistant-ui/tap";
+import { tapApi } from "../../utils/tap-store";
+import { MessageRuntime } from "../runtime/MessageRuntime";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+import { ComposerClient } from "./ComposerRuntimeClient";
+import { MessagePartClient } from "./MessagePartRuntimeClient";
+import { tapLookupResources } from "../util-hooks/tapLookupResources";
+import { RefObject } from "react";
+import {
+  MessageClientState,
+  MessageClientApi,
+} from "../../client/types/Message";
+import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
+
+const MessageAttachmentClientByIndex = resource(
+  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
+    const attachmentRuntime = tapMemo(
+      () => runtime.getAttachmentByIndex(index),
+      [runtime, index],
+    );
+    return tapInlineResource(
+      AttachmentRuntimeClient({ runtime: attachmentRuntime }),
+    );
+  },
+);
+
+const MessagePartByIndex = resource(
+  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
+    const partRuntime = tapMemo(
+      () => runtime.getMessagePartByIndex(index),
+      [runtime, index],
+    );
+    return tapInlineResource(MessagePartClient({ runtime: partRuntime }));
+  },
+);
+
+export const MessageClient = resource(
+  ({
+    runtime,
+    threadIdRef,
+  }: {
+    runtime: MessageRuntime;
+    threadIdRef: RefObject<string>;
+  }) => {
+    const runtimeState = tapSubscribable(runtime);
+
+    const [isCopiedState, setIsCopied] = tapState(false);
+    const [isHoveringState, setIsHovering] = tapState(false);
+
+    const messageIdRef = tapMemo(
+      () => ({
+        get current() {
+          return runtime.getState().id;
+        },
+      }),
+      [runtime],
+    );
+
+    const composer = tapInlineResource(
+      ComposerClient({
+        runtime: runtime.composer,
+        threadIdRef,
+        messageIdRef,
+      }),
+    );
+
+    const parts = tapLookupResources(
+      runtimeState.content.map((_, idx) =>
+        MessagePartByIndex({ runtime, index: idx }, { key: idx }),
+      ),
+    );
+
+    const attachments = tapLookupResources(
+      runtimeState.attachments?.map((_, idx) =>
+        MessageAttachmentClientByIndex({ runtime, index: idx }, { key: idx }),
+      ) ?? [],
+    );
+
+    const state = tapMemo<MessageClientState>(() => {
+      return {
+        ...(runtimeState as MessageClientState),
+
+        parts: parts.state,
+        composer: composer.state,
+
+        isCopied: isCopiedState,
+        isHovering: isHoveringState,
+      };
+    }, [
+      runtimeState,
+      parts.state,
+      composer.state,
+      isCopiedState,
+      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: attachments.api,
+
+      setIsCopied,
+      setIsHovering,
+
+      __internal_getRuntime: () => runtime,
+    });
+
+    return {
+      key: runtimeState.id,
+      state,
+      api,
+    };
+  },
+);

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

@@ -0,0 +1,60 @@
+import { resource, tapEffect } from "@assistant-ui/tap";
+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();
+
+    // Bind thread list item events to event manager
+    tapEffect(() => {
+      const unsubscribers: Unsubscribe[] = [];
+
+      // Subscribe to thread list item events
+      const threadListItemEvents: ThreadListItemEventType[] = [
+        "switched-to",
+        "switched-away",
+      ];
+
+      for (const event of threadListItemEvents) {
+        const unsubscribe = runtime.unstable_on(event, () => {
+          events.emit(`thread-list-item.${event}`, {
+            threadId: runtime.getState()!.id,
+          });
+        });
+        unsubscribers.push(unsubscribe);
+      }
+
+      return () => {
+        for (const unsub of unsubscribers) unsub();
+      };
+    }, [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,
+    };
+  },
+);

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

@@ -0,0 +1,90 @@
+import { tapApi } from "../../utils/tap-store";
+import { resource, tapInlineResource, tapMemo } from "@assistant-ui/tap";
+import { ThreadListRuntime } from "../runtime/ThreadListRuntime";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+import { ThreadListItemClient } from "./ThreadListItemRuntimeClient";
+import { ThreadClient } from "./ThreadRuntimeClient";
+import { tapLookupResources } from "../util-hooks/tapLookupResources";
+import {
+  ThreadListClientState,
+  ThreadListClientApi,
+} from "../../client/types/ThreadList";
+
+const ThreadListItemClientById = resource(
+  ({ runtime, id }: { runtime: ThreadListRuntime; id: string }) => {
+    const threadListItemRuntime = tapMemo(
+      () => runtime.getItemById(id),
+      [runtime, id],
+    );
+    return tapInlineResource(
+      ThreadListItemClient({
+        runtime: threadListItemRuntime,
+      }),
+    );
+  },
+);
+
+export const ThreadListClient = resource(
+  ({ runtime }: { runtime: ThreadListRuntime }) => {
+    const runtimeState = tapSubscribable(runtime);
+
+    const main = tapInlineResource(
+      ThreadClient({
+        runtime: runtime.main,
+      }),
+    );
+
+    const threadItems = tapLookupResources(
+      Object.keys(runtimeState.threadItems).map((id) =>
+        ThreadListItemClientById({ runtime, id }, { key: id }),
+      ),
+    );
+
+    const state = tapMemo<ThreadListClientState>(() => {
+      return {
+        mainThreadId: runtimeState.mainThreadId,
+        newThreadId: runtimeState.newThread,
+        isLoading: runtimeState.isLoading,
+        threadIds: runtimeState.threads,
+        archivedThreadIds: runtimeState.archivedThreads,
+        threadItems: threadItems.state,
+
+        main: main.state,
+      };
+    }, [runtimeState, threadItems.state, main.state]);
+
+    const api = tapApi<ThreadListClientApi>({
+      getState: () => state,
+
+      thread: () => main.api,
+
+      item: (threadIdOrOptions) => {
+        if (threadIdOrOptions === "main") {
+          return threadItems.api({ key: state.mainThreadId });
+        }
+
+        if ("id" in threadIdOrOptions) {
+          return threadItems.api({ key: threadIdOrOptions.id });
+        }
+
+        const { index, archived = false } = threadIdOrOptions;
+        const id = archived
+          ? state.archivedThreadIds[index]!
+          : state.threadIds[index]!;
+        return threadItems.api({ key: id });
+      },
+
+      switchToThread: (threadId) => {
+        runtime.switchToThread(threadId);
+      },
+      switchToNewThread: () => {
+        runtime.switchToNewThread();
+      },
+    });
+
+    return {
+      state,
+      api,
+    };
+  },
+);

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

@@ -0,0 +1,145 @@
+import { ThreadRuntimeEventType } from "../runtime-cores/core/ThreadRuntimeCore";
+import { ThreadRuntime } from "../runtime/ThreadRuntime";
+import {
+  resource,
+  tapInlineResource,
+  tapMemo,
+  tapEffect,
+  RefObject,
+} from "@assistant-ui/tap";
+import { ComposerClient } from "./ComposerRuntimeClient";
+import { MessageClient } from "./MessageRuntimeClient";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+import { tapApi } from "../../utils/tap-store";
+import { tapLookupResources } from "../util-hooks/tapLookupResources";
+import { Unsubscribe } from "../../types";
+import { tapEvents } from "../../client/EventContext";
+import { ThreadClientState, ThreadClientApi } from "../../client/types/Thread";
+
+const MessageClientById = resource(
+  ({
+    runtime,
+    id,
+    threadIdRef,
+  }: {
+    runtime: ThreadRuntime;
+    id: string;
+    threadIdRef: RefObject<string>;
+  }) => {
+    const messageRuntime = tapMemo(
+      () => runtime.getMessageById(id),
+      [runtime, id],
+    );
+
+    return tapInlineResource(
+      MessageClient({ runtime: messageRuntime, threadIdRef }),
+    );
+  },
+);
+
+export const ThreadClient = resource(
+  ({ runtime }: { runtime: ThreadRuntime }) => {
+    const runtimeState = tapSubscribable(runtime);
+
+    const events = tapEvents();
+
+    // Bind thread events to event manager
+    tapEffect(() => {
+      const unsubscribers: Unsubscribe[] = [];
+
+      // Subscribe to thread events
+      const threadEvents: ThreadRuntimeEventType[] = [
+        "run-start",
+        "run-end",
+        "initialize",
+        "model-context-update",
+      ];
+
+      for (const event of threadEvents) {
+        const unsubscribe = runtime.unstable_on(event, () => {
+          const threadId = runtime.getState()?.threadId || "unknown";
+          events.emit(`thread.${event}`, {
+            threadId,
+          });
+        });
+        unsubscribers.push(unsubscribe);
+      }
+
+      return () => {
+        for (const unsub of unsubscribers) unsub();
+      };
+    }, [runtime]);
+
+    const threadIdRef = tapMemo(
+      () => ({
+        get current() {
+          return runtime.getState()!.threadId;
+        },
+      }),
+      [runtime],
+    );
+
+    const composer = tapInlineResource(
+      ComposerClient({
+        runtime: runtime.composer,
+        threadIdRef,
+      }),
+    );
+
+    const messages = tapLookupResources(
+      runtimeState.messages.map((m) =>
+        MessageClientById(
+          { runtime: runtime, id: m.id, threadIdRef },
+          { key: m.id },
+        ),
+      ),
+    );
+
+    const state = tapMemo<ThreadClientState>(() => {
+      return {
+        isDisabled: runtimeState.isDisabled,
+        isLoading: runtimeState.isLoading,
+        isRunning: runtimeState.isRunning,
+        capabilities: runtimeState.capabilities,
+        state: runtimeState.state,
+        suggestions: runtimeState.suggestions,
+        extras: runtimeState.extras,
+        speech: runtimeState.speech,
+
+        composer: composer.state,
+        messages: messages.state,
+      };
+    }, [runtimeState, messages, composer.state]);
+
+    const api = tapApi<ThreadClientApi>({
+      getState: () => state,
+
+      composer: composer.api,
+
+      append: runtime.append,
+      startRun: runtime.startRun,
+      unstable_resumeRun: runtime.unstable_resumeRun,
+      cancelRun: runtime.cancelRun,
+      getModelContext: runtime.getModelContext,
+      export: runtime.export,
+      import: runtime.import,
+      reset: runtime.reset,
+      stopSpeaking: runtime.stopSpeaking,
+
+      message: (selector) => {
+        if ("id" in selector) {
+          return messages.api({ key: selector.id });
+        } else {
+          return messages.api(selector);
+        }
+      },
+
+      __internal_getRuntime: () => runtime,
+    });
+
+    return {
+      state,
+      api,
+    };
+  },
+);

package/src/legacy-runtime/cloud/AssistantCloudThreadHistoryAdapter.tsx

@@ -0,0 +1,185 @@
+import { RefObject, useState } from "react";
+import { ThreadHistoryAdapter } from "../runtime-cores/adapters/thread-history/ThreadHistoryAdapter";
+import { ExportedMessageRepositoryItem } from "../runtime-cores/utils/MessageRepository";
+import { AssistantCloud } from "assistant-cloud";
+import { auiV0Decode, auiV0Encode } from "./auiV0";
+import {
+  MessageFormatAdapter,
+  MessageFormatItem,
+  MessageFormatRepository,
+  MessageStorageEntry,
+} from "../runtime-cores/adapters/thread-history/MessageFormatAdapter";
+import { GenericThreadHistoryAdapter } from "../runtime-cores/adapters/thread-history/ThreadHistoryAdapter";
+import { ReadonlyJSONObject } from "assistant-stream/utils";
+import {
+  AssistantApi,
+  useAssistantApi,
+} from "../../context/react/AssistantApiContext";
+import { ThreadListItemClientApi } from "../../client/types/ThreadListItem";
+
+// Global WeakMap to store message ID mappings across adapter instances
+const globalMessageIdMapping = new WeakMap<
+  ThreadListItemClientApi,
+  Record<string, string | Promise<string>>
+>();
+
+class FormattedThreadHistoryAdapter<TMessage, TStorageFormat>
+  implements GenericThreadHistoryAdapter<TMessage>
+{
+  constructor(
+    private parent: AssistantCloudThreadHistoryAdapter,
+    private formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
+  ) {}
+
+  async append(item: MessageFormatItem<TMessage>) {
+    // Encode the message using the format adapter
+    const encoded = this.formatAdapter.encode(item);
+    const messageId = this.formatAdapter.getId(item.message);
+
+    // Delegate to parent's internal append method with the encoded format
+    return this.parent._appendWithFormat(
+      item.parentId,
+      messageId,
+      this.formatAdapter.format,
+      encoded,
+    );
+  }
+
+  async load(): Promise<MessageFormatRepository<TMessage>> {
+    // Delegate to parent's internal load method with format filter
+    return this.parent._loadWithFormat(
+      this.formatAdapter.format,
+      (message: MessageStorageEntry<TStorageFormat>) =>
+        this.formatAdapter.decode(message),
+    );
+  }
+}
+
+class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
+  constructor(
+    private cloudRef: RefObject<AssistantCloud>,
+    private store: AssistantApi,
+  ) {}
+
+  private get _getIdForLocalId(): Record<string, string | Promise<string>> {
+    if (!globalMessageIdMapping.has(this.store.threadListItem())) {
+      globalMessageIdMapping.set(this.store.threadListItem(), {});
+    }
+    return globalMessageIdMapping.get(this.store.threadListItem())!;
+  }
+
+  withFormat<TMessage, TStorageFormat>(
+    formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
+  ): GenericThreadHistoryAdapter<TMessage> {
+    return new FormattedThreadHistoryAdapter(this, formatAdapter);
+  }
+
+  async append({ parentId, message }: ExportedMessageRepositoryItem) {
+    const { remoteId } = await this.store.threadListItem().initialize();
+    const task = this.cloudRef.current.threads.messages
+      .create(remoteId, {
+        parent_id: parentId
+          ? ((await this._getIdForLocalId[parentId]) ?? parentId)
+          : null,
+        format: "aui/v0",
+        content: auiV0Encode(message),
+      })
+      .then(({ message_id }) => {
+        this._getIdForLocalId[message.id] = message_id;
+        return message_id;
+      });
+
+    this._getIdForLocalId[message.id] = task;
+
+    return task.then(() => {});
+  }
+
+  async load() {
+    const remoteId = this.store.threadListItem().getState().remoteId;
+    if (!remoteId) return { messages: [] };
+    const { messages } = await this.cloudRef.current.threads.messages.list(
+      remoteId,
+      {
+        format: "aui/v0",
+      },
+    );
+    const payload = {
+      messages: messages
+        .filter(
+          (m): m is typeof m & { format: "aui/v0" } => m.format === "aui/v0",
+        )
+        .map(auiV0Decode)
+        .reverse(),
+    };
+    return payload;
+  }
+
+  // Internal methods for FormattedThreadHistoryAdapter
+  async _appendWithFormat<T>(
+    parentId: string | null,
+    messageId: string,
+    format: string,
+    content: T,
+  ) {
+    const { remoteId } = await this.store.threadListItem().initialize();
+
+    const task = this.cloudRef.current.threads.messages
+      .create(remoteId, {
+        parent_id: parentId
+          ? ((await this._getIdForLocalId[parentId]) ?? parentId)
+          : null,
+        format,
+        content: content as ReadonlyJSONObject,
+      })
+      .then(({ message_id }) => {
+        this._getIdForLocalId[messageId] = message_id;
+        return message_id;
+      });
+
+    this._getIdForLocalId[messageId] = task;
+
+    return task.then(() => {});
+  }
+
+  async _loadWithFormat<TMessage, TStorageFormat>(
+    format: string,
+    decoder: (
+      message: MessageStorageEntry<TStorageFormat>,
+    ) => MessageFormatItem<TMessage>,
+  ): Promise<MessageFormatRepository<TMessage>> {
+    const remoteId = this.store.threadListItem().getState().remoteId;
+    if (!remoteId) return { messages: [] };
+
+    const { messages } = await this.cloudRef.current.threads.messages.list(
+      remoteId,
+      {
+        format,
+      },
+    );
+
+    return {
+      messages: messages
+        .filter((m) => m.format === format)
+        .map((m) =>
+          decoder({
+            id: m.id,
+            parent_id: m.parent_id,
+            format: m.format,
+            content: m.content as TStorageFormat,
+          }),
+        )
+        .reverse(),
+    };
+  }
+}
+
+export const useAssistantCloudThreadHistoryAdapter = (
+  cloudRef: RefObject<AssistantCloud>,
+): ThreadHistoryAdapter => {
+  const store = useAssistantApi();
+  const [adapter] = useState(
+    () => new AssistantCloudThreadHistoryAdapter(cloudRef, store),
+  );
+
+  return adapter;
+};