@assistant-ui/react 0.10.50 → 0.11.1

package/src/legacy-runtime/runtime-cores/remote-thread-list/EMPTY_THREAD_CORE.tsx

@@ -0,0 +1,170 @@
+import { ThreadRuntimeCore } from "../../../internal";
+
+const EMPTY_THREAD_ERROR = new Error(
+  "This is the empty thread, a placeholder for the main thread. You cannot perform any actions on this thread instance. This error is probably because you tried to call a thread method in your render function. Call the method inside a `useEffect` hook instead.",
+);
+export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
+  getMessageById() {
+    return undefined;
+  },
+
+  getBranches() {
+    return [];
+  },
+
+  switchToBranch() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  append() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  startRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  resumeRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  cancelRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  addToolResult() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  speak() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  stopSpeaking() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  getSubmittedFeedback() {
+    return undefined;
+  },
+
+  submitFeedback() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  getModelContext() {
+    return {};
+  },
+
+  composer: {
+    attachments: [],
+    attachmentAccept: "*",
+
+    async addAttachment() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    async removeAttachment() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    isEditing: true,
+
+    canCancel: false,
+    isEmpty: true,
+
+    text: "",
+
+    setText() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    role: "user",
+
+    setRole() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    runConfig: {},
+
+    setRunConfig() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    async reset() {
+      // noop
+    },
+
+    async clearAttachments() {
+      // noop
+    },
+
+    send() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    cancel() {
+      // noop
+    },
+
+    subscribe() {
+      return () => {};
+    },
+
+    unstable_on() {
+      return () => {};
+    },
+  },
+
+  getEditComposer() {
+    return undefined;
+  },
+
+  beginEdit() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  speech: undefined,
+
+  capabilities: {
+    switchToBranch: false,
+    edit: false,
+    reload: false,
+    cancel: false,
+    unstable_copy: false,
+    speech: false,
+    attachments: false,
+    feedback: false,
+  },
+
+  isDisabled: false,
+  isLoading: false,
+
+  messages: [],
+
+  state: null,
+
+  suggestions: [],
+
+  extras: undefined,
+
+  subscribe() {
+    return () => {};
+  },
+
+  import() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  export() {
+    return { messages: [] };
+  },
+
+  reset() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  unstable_on() {
+    return () => {};
+  },
+};

package/src/legacy-runtime/runtime-cores/remote-thread-list/RemoteThreadListHookInstanceManager.tsx

@@ -0,0 +1,164 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+"use client";
+
+import {
+  FC,
+  useCallback,
+  useRef,
+  useEffect,
+  memo,
+  PropsWithChildren,
+  ComponentType,
+} from "react";
+import { UseBoundStore, StoreApi, create } from "zustand";
+import {
+  useAssistantState,
+  useAssistantApi,
+  ThreadListItemByIdProvider,
+} from "../../../context";
+import { ThreadRuntimeCore, ThreadRuntimeImpl } from "../../../internal";
+import { BaseSubscribable } from "./BaseSubscribable";
+import { AssistantRuntime } from "../../runtime";
+
+type RemoteThreadListHook = () => AssistantRuntime;
+
+type RemoteThreadListHookInstance = {
+  runtime?: ThreadRuntimeCore;
+};
+export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
+  private useRuntimeHook: UseBoundStore<
+    StoreApi<{ useRuntime: RemoteThreadListHook }>
+  >;
+  private instances = new Map<string, RemoteThreadListHookInstance>();
+  private useAliveThreadsKeysChanged = create(() => ({}));
+
+  constructor(runtimeHook: RemoteThreadListHook) {
+    super();
+    this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));
+  }
+
+  public startThreadRuntime(threadId: string) {
+    if (!this.instances.has(threadId)) {
+      this.instances.set(threadId, {});
+      this.useAliveThreadsKeysChanged.setState({}, true);
+    }
+
+    return new Promise<ThreadRuntimeCore>((resolve, reject) => {
+      const callback = () => {
+        const instance = this.instances.get(threadId);
+        if (!instance) {
+          dispose();
+          reject(new Error("Thread was deleted before runtime was started"));
+        } else if (!instance.runtime) {
+          return; // misc update
+        } else {
+          dispose();
+          resolve(instance.runtime);
+        }
+      };
+      const dispose = this.subscribe(callback);
+      callback();
+    });
+  }
+
+  public getThreadRuntimeCore(threadId: string) {
+    const instance = this.instances.get(threadId);
+    if (!instance) return undefined;
+    return instance.runtime;
+  }
+
+  public stopThreadRuntime(threadId: string) {
+    this.instances.delete(threadId);
+    this.useAliveThreadsKeysChanged.setState({}, true);
+  }
+
+  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {
+    const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;
+    if (prevRuntimeHook !== newRuntimeHook) {
+      this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);
+    }
+  }
+
+  private _InnerActiveThreadProvider: FC = () => {
+    const id = useAssistantState(({ threadListItem }) => threadListItem.id);
+
+    const { useRuntime } = this.useRuntimeHook();
+    const runtime = useRuntime();
+
+    const threadBinding = (runtime.thread as ThreadRuntimeImpl)
+      .__internal_threadBinding;
+
+    const updateRuntime = useCallback(() => {
+      const aliveThread = this.instances.get(id);
+      if (!aliveThread)
+        throw new Error("Thread not found. This is a bug in assistant-ui.");
+
+      aliveThread.runtime = threadBinding.getState();
+
+      if (isMounted) {
+        this._notifySubscribers();
+      }
+    }, [id, threadBinding]);
+
+    const isMounted = useRef(false);
+    if (!isMounted.current) {
+      updateRuntime();
+    }
+
+    useEffect(() => {
+      isMounted.current = true;
+      updateRuntime();
+      return threadBinding.outerSubscribe(updateRuntime);
+    }, [threadBinding, updateRuntime]);
+
+    // auto initialize thread
+    const api = useAssistantApi();
+    useEffect(() => {
+      return runtime.threads.main.unstable_on("initialize", () => {
+        const state = api.threadListItem().getState();
+        if (state.status === "new") {
+          api.threadListItem().initialize();
+
+          // auto generate a title after first run
+          const dispose = runtime.thread.unstable_on("run-end", () => {
+            dispose();
+
+            api.threadListItem().generateTitle();
+          });
+        }
+      });
+    }, [runtime, api]);
+
+    return null;
+  };
+
+  private _OuterActiveThreadProvider: FC<{
+    threadId: string;
+    provider: ComponentType<PropsWithChildren>;
+    // eslint-disable-next-line react/display-name
+  }> = memo(({ threadId, provider: Provider }) => {
+    // Runtime is provided by ThreadListItemByIdProvider
+
+    return (
+      <ThreadListItemByIdProvider id={threadId}>
+        <Provider>
+          <this._InnerActiveThreadProvider />
+        </Provider>
+      </ThreadListItemByIdProvider>
+    );
+  });
+
+  public __internal_RenderThreadRuntimes: FC<{
+    provider: ComponentType<PropsWithChildren>;
+  }> = ({ provider }) => {
+    this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change
+
+    return Array.from(this.instances.keys()).map((threadId) => (
+      <this._OuterActiveThreadProvider
+        key={threadId}
+        threadId={threadId}
+        provider={provider}
+      />
+    ));
+  };
+}