@assistant-ui/react 0.12.10 → 0.12.11

package/src/client/ThreadMessageClient.tsx

@@ -1,178 +0,0 @@
-"use client";
-import {
-  resource,
-  tapMemo,
-  tapState,
-  tapInlineResource,
-  withKey,
-} from "@assistant-ui/tap";
-import { type ClientOutput, tapClientLookup } from "@assistant-ui/store";
-import { MessageState, PartState } from "../types/scopes";
-import {
-  ThreadAssistantMessagePart,
-  ThreadUserMessagePart,
-  Attachment,
-  ThreadMessage,
-} from "../types";
-import { NoOpComposerClient } from "./NoOpComposerClient";
-
-const ThreadMessagePartClient = resource(
-  ({
-    part,
-  }: {
-    part: ThreadAssistantMessagePart | ThreadUserMessagePart;
-  }): ClientOutput<"part"> => {
-    const state = tapMemo<PartState>(() => {
-      return {
-        ...part,
-        status: { type: "complete" },
-      };
-    }, [part]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        addToolResult: () => {
-          throw new Error("Not supported");
-        },
-        resumeToolCall: () => {
-          throw new Error("Not supported");
-        },
-      },
-    };
-  },
-);
-
-const ThreadMessageAttachmentClient = resource(
-  ({ attachment }: { attachment: Attachment }): ClientOutput<"attachment"> => {
-    return {
-      state: attachment,
-      methods: {
-        getState: () => attachment,
-        remove: () => {
-          throw new Error("Not supported");
-        },
-      },
-    };
-  },
-);
-export type ThreadMessageClientProps = {
-  message: ThreadMessage;
-  index: number;
-  isLast?: boolean;
-  branchNumber?: number;
-  branchCount?: number;
-};
-
-export const ThreadMessageClient = resource(
-  ({
-    message,
-    index,
-    isLast = true,
-    branchNumber = 1,
-    branchCount = 1,
-  }: ThreadMessageClientProps): ClientOutput<"message"> => {
-    const [isCopiedState, setIsCopied] = tapState(false);
-    const [isHoveringState, setIsHovering] = tapState(false);
-
-    const parts = tapClientLookup(
-      () =>
-        message.content.map((part, idx) =>
-          withKey(
-            "toolCallId" in part && part.toolCallId != null
-              ? `toolCallId-${part.toolCallId}`
-              : `index-${idx}`,
-            ThreadMessagePartClient({ part }),
-          ),
-        ),
-      [message.content],
-    );
-
-    const attachments = tapClientLookup(
-      () =>
-        (message.attachments ?? []).map((attachment) =>
-          withKey(attachment.id, ThreadMessageAttachmentClient({ attachment })),
-        ),
-      [message.attachments],
-    );
-
-    const composer = tapInlineResource(NoOpComposerClient({ type: "edit" }));
-
-    const state = tapMemo<MessageState>(() => {
-      return {
-        ...message,
-        parts: parts.state,
-        composer: composer.state,
-        parentId: null,
-        index,
-        isLast,
-        branchNumber,
-        branchCount,
-        speech: undefined,
-        submittedFeedback: message.metadata.submittedFeedback,
-        isCopied: isCopiedState,
-        isHovering: isHoveringState,
-      };
-    }, [
-      message,
-      index,
-      isCopiedState,
-      isHoveringState,
-      isLast,
-      parts.state,
-      composer.state,
-      branchNumber,
-      branchCount,
-    ]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        composer: composer.methods,
-        part: (selector) => {
-          if ("index" in selector) {
-            return parts.get({ index: selector.index });
-          } else {
-            return parts.get({ key: `toolCallId-${selector.toolCallId}` });
-          }
-        },
-        attachment: (selector) => {
-          if ("id" in selector) {
-            return attachments.get({ key: selector.id });
-          } else {
-            return attachments.get(selector);
-          }
-        },
-        reload: () => {
-          throw new Error("Not supported in ThreadMessageProvider");
-        },
-        speak: () => {
-          throw new Error("Not supported in ThreadMessageProvider");
-        },
-        stopSpeaking: () => {
-          throw new Error("Not supported in ThreadMessageProvider");
-        },
-        submitFeedback: () => {
-          throw new Error("Not supported in ThreadMessageProvider");
-        },
-        switchToBranch: () => {
-          throw new Error("Not supported in ThreadMessageProvider");
-        },
-        getCopyText: () => {
-          return message.content
-            .map((part) => {
-              if ("text" in part && typeof part.text === "string") {
-                return part.text;
-              }
-              return "";
-            })
-            .join("\n");
-        },
-        setIsCopied,
-        setIsHovering,
-      },
-    };
-  },
-);

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

@@ -1,19 +0,0 @@
-import { resource } from "@assistant-ui/tap";
-import { type ClientOutput } from "@assistant-ui/store";
-import { AttachmentRuntime } from "../runtime";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-
-export const AttachmentRuntimeClient = resource(
-  ({ runtime }: { runtime: AttachmentRuntime }): ClientOutput<"attachment"> => {
-    const state = tapSubscribable(runtime);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        remove: runtime.remove,
-        __internal_getRuntime: () => runtime,
-      },
-    };
-  },
-);

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

@@ -1,138 +0,0 @@
-import {
-  resource,
-  tapMemo,
-  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 { ComposerRuntimeEventType } from "../runtime-cores/core/ComposerRuntimeCore";
-import { ComposerState } from "../../types/scopes";
-import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-
-const ComposerAttachmentClientByIndex = resource(
-  ({ runtime, index }: { runtime: ComposerRuntime; index: number }) => {
-    const attachmentRuntime = tapMemo(
-      () => runtime.getAttachmentByIndex(index),
-      [runtime, index],
-    );
-
-    return tapInlineResource(
-      AttachmentRuntimeClient({
-        runtime: attachmentRuntime,
-      }),
-    );
-  },
-);
-
-export const ComposerClient = resource(
-  ({
-    threadIdRef,
-    messageIdRef,
-    runtime,
-  }: {
-    threadIdRef: tapRef.RefObject<string>;
-    messageIdRef?: tapRef.RefObject<string>;
-    runtime: ComposerRuntime;
-  }): ClientOutput<"composer"> => {
-    const runtimeState = tapSubscribable(runtime);
-    const emit = tapAssistantEmit();
-
-    // Bind composer events to event manager
-    tapEffect(() => {
-      const unsubscribers: Unsubscribe[] = [];
-
-      // Subscribe to composer events
-      const composerEvents: ComposerRuntimeEventType[] = [
-        "send",
-        "attachmentAdd",
-      ];
-
-      for (const event of composerEvents) {
-        const unsubscribe = runtime.unstable_on(event, () => {
-          emit(`composer.${event}`, {
-            threadId: threadIdRef.current,
-            ...(messageIdRef && { messageId: messageIdRef.current }),
-          });
-        });
-        unsubscribers.push(unsubscribe);
-      }
-
-      return () => {
-        for (const unsub of unsubscribers) unsub();
-      };
-    }, [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<ComposerState>(() => {
-      return {
-        text: runtimeState.text,
-        role: runtimeState.role,
-        attachments: attachments.state,
-        runConfig: runtimeState.runConfig,
-        isEditing: runtimeState.isEditing,
-        canCancel: runtimeState.canCancel,
-        attachmentAccept: runtimeState.attachmentAccept,
-        isEmpty: runtimeState.isEmpty,
-        type: runtimeState.type ?? "thread",
-        dictation: runtimeState.dictation,
-        quote: runtimeState.quote,
-      };
-    }, [runtimeState, attachments.state]);
-
-    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,
-        setQuote: runtime.setQuote,
-        attachment: (selector) => {
-          if ("id" in selector) {
-            return attachments.get({ key: selector.id });
-          } else {
-            return attachments.get(selector);
-          }
-        },
-        __internal_getRuntime: () => runtime,
-      },
-    };
-  },
-);

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

@@ -1,20 +0,0 @@
-import { resource } from "@assistant-ui/tap";
-import { type ClientOutput } from "@assistant-ui/store";
-import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-
-export const MessagePartClient = resource(
-  ({ runtime }: { runtime: MessagePartRuntime }): ClientOutput<"part"> => {
-    const state = tapSubscribable(runtime);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        addToolResult: (result) => runtime.addToolResult(result),
-        resumeToolCall: (payload) => runtime.resumeToolCall(payload),
-        __internal_getRuntime: () => runtime,
-      },
-    };
-  },
-);

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

@@ -1,151 +0,0 @@
-import {
-  withKey,
-  resource,
-  tapInlineResource,
-  tapMemo,
-  tapState,
-} from "@assistant-ui/tap";
-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 { RefObject } from "react";
-import { MessageState } from "../../types/scopes";
-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>;
-  }): ClientOutput<"message"> => {
-    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 = tapClientResource(
-      ComposerClient({
-        runtime: runtime.composer,
-        threadIdRef,
-        messageIdRef,
-      }),
-    );
-
-    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 = tapClientLookup(
-      () =>
-        (runtimeState.attachments ?? []).map((attachment, idx) =>
-          withKey(
-            attachment.id,
-            MessageAttachmentClientByIndex({ runtime, index: idx }),
-          ),
-        ),
-      [runtimeState.attachments, runtime],
-    );
-
-    const state = tapMemo<MessageState>(() => {
-      return {
-        ...(runtimeState as MessageState),
-
-        parts: parts.state,
-        composer: composer.state,
-
-        isCopied: isCopiedState,
-        isHovering: isHoveringState,
-      };
-    }, [
-      runtimeState,
-      parts.state,
-      composer.state,
-      isCopiedState,
-      isHoveringState,
-    ]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-
-        composer: composer.methods,
-
-        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.get({ index: selector.index });
-          } else {
-            return parts.get({ key: `toolCallId-${selector.toolCallId}` });
-          }
-        },
-
-        attachment: (selector) => {
-          if ("id" in selector) {
-            return attachments.get({ key: selector.id });
-          } else {
-            return attachments.get(selector);
-          }
-        },
-
-        setIsCopied,
-        setIsHovering,
-
-        __internal_getRuntime: () => runtime,
-      },
-    };
-  },
-);

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

@@ -1,59 +0,0 @@
-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 { tapSubscribable } from "../util-hooks/tapSubscribable";
-
-export const ThreadListItemClient = resource(
-  ({
-    runtime,
-  }: {
-    runtime: ThreadListItemRuntime;
-  }): ClientOutput<"threadListItem"> => {
-    const state = tapSubscribable(runtime);
-    const emit = tapAssistantEmit();
-
-    // Bind thread list item events to event manager
-    tapEffect(() => {
-      const unsubscribers: Unsubscribe[] = [];
-
-      // Subscribe to thread list item events
-      const threadListItemEvents: ThreadListItemEventType[] = [
-        "switchedTo",
-        "switchedAway",
-      ];
-
-      for (const event of threadListItemEvents) {
-        const unsubscribe = runtime.unstable_on(event, () => {
-          emit(`threadListItem.${event}`, {
-            threadId: runtime.getState()!.id,
-          });
-        });
-        unsubscribers.push(unsubscribe);
-      }
-
-      return () => {
-        for (const unsub of unsubscribers) unsub();
-      };
-    }, [runtime, emit]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        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,
-      },
-    };
-  },
-);

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

@@ -1,100 +0,0 @@
-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 { ThreadsState } from "../../types/scopes";
-import type { AssistantRuntime } from "../runtime/AssistantRuntime";
-
-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,
-    __internal_assistantRuntime,
-  }: {
-    runtime: ThreadListRuntime;
-    __internal_assistantRuntime: AssistantRuntime;
-  }): ClientOutput<"threads"> => {
-    const runtimeState = tapSubscribable(runtime);
-
-    const main = tapClientResource(
-      ThreadClient({
-        runtime: runtime.main,
-      }),
-    );
-
-    const threadItems = tapClientLookup(
-      () =>
-        Object.keys(runtimeState.threadItems).map((id) =>
-          withKey(id, ThreadListItemClientById({ runtime, id })),
-        ),
-      [runtimeState.threadItems, runtime],
-    );
-
-    const state = tapMemo<ThreadsState>(() => {
-      return {
-        mainThreadId: runtimeState.mainThreadId,
-        newThreadId: runtimeState.newThreadId ?? null,
-        isLoading: runtimeState.isLoading,
-        threadIds: runtimeState.threadIds,
-        archivedThreadIds: runtimeState.archivedThreadIds,
-        threadItems: threadItems.state,
-
-        main: main.state,
-      };
-    }, [runtimeState, threadItems.state, main.state]);
-
-    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.get({ key: threadIdOrOptions.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,
-      },
-    };
-  },
-);