@assistant-ui/react 0.5.92 → 0.5.94

package/src/primitives/message/MessageContent.tsx

@@ -0,0 +1,179 @@
+"use client";
+
+import { type ComponentType, type FC, memo, useMemo } from "react";
+import {
+  useContentPart,
+  useContentPartRuntime,
+  useToolUIs,
+} from "../../context";
+import {
+  useMessage,
+  useMessageRuntime,
+} from "../../context/react/MessageContext";
+import { ContentPartRuntimeProvider } from "../../context/providers/ContentPartRuntimeProvider";
+import { ContentPartPrimitiveText } from "../contentPart/ContentPartText";
+import { ContentPartPrimitiveImage } from "../contentPart/ContentPartImage";
+import { ContentPartPrimitiveDisplay } from "../contentPart/ContentPartDisplay";
+import type {
+  Unstable_AudioContentPartComponent,
+  EmptyContentPartComponent,
+  ImageContentPartComponent,
+  TextContentPartComponent,
+  ToolCallContentPartComponent,
+  ToolCallContentPartProps,
+  UIContentPartComponent,
+} from "../../types/ContentPartComponentTypes";
+import { ContentPartPrimitiveInProgress } from "../contentPart/ContentPartInProgress";
+import { EMPTY_CONTENT } from "../../api/MessageRuntime";
+
+/**
+ * @deprecated Use `MessagePrimitive.Content.Props` instead. This will be removed in 0.6.
+ */
+export type MessagePrimitiveContentProps = MessagePrimitiveContent.Props;
+
+export namespace MessagePrimitiveContent {
+  export type Props = {
+    components?:
+      | {
+          Empty?: EmptyContentPartComponent | undefined;
+          Text?: TextContentPartComponent | undefined;
+          Image?: ImageContentPartComponent | undefined;
+          Unstable_Audio?: Unstable_AudioContentPartComponent | undefined;
+          UI?: UIContentPartComponent | undefined;
+          tools?:
+            | {
+                by_name?:
+                  | Record<string, ToolCallContentPartComponent | undefined>
+                  | undefined;
+                Fallback?: ComponentType<ToolCallContentPartProps> | undefined;
+              }
+            | undefined;
+        }
+      | undefined;
+  };
+}
+
+const ToolUIDisplay = ({
+  UI,
+  ...props
+}: {
+  UI: ToolCallContentPartComponent | undefined;
+} & ToolCallContentPartProps) => {
+  const Render = useToolUIs((s) => s.getToolUI(props.toolName)) ?? UI;
+  if (!Render) return null;
+  return <Render {...props} />;
+};
+
+const defaultComponents = {
+  Text: () => (
+    <p style={{ whiteSpace: "pre-line" }}>
+      <ContentPartPrimitiveText />
+      <ContentPartPrimitiveInProgress>
+        <span style={{ fontFamily: "revert" }}>{" \u25CF"}</span>
+      </ContentPartPrimitiveInProgress>
+    </p>
+  ),
+  Image: () => <ContentPartPrimitiveImage />,
+  Unstable_Audio: () => null,
+  UI: () => <ContentPartPrimitiveDisplay />,
+} satisfies MessagePrimitiveContent.Props["components"];
+
+type MessageContentPartComponentProps = {
+  components: MessagePrimitiveContent.Props["components"];
+};
+
+const MessageContentPartComponent: FC<MessageContentPartComponentProps> = ({
+  components: {
+    Text = defaultComponents.Text,
+    Empty,
+    Image = defaultComponents.Image,
+    UI = defaultComponents.UI,
+    Unstable_Audio: Audio = defaultComponents.Unstable_Audio,
+    tools: { by_name = {}, Fallback = undefined } = {},
+  } = {},
+}) => {
+  const contentPartRuntime = useContentPartRuntime();
+
+  const part = useContentPart();
+
+  const type = part.type;
+  if (type === "tool-call") {
+    const Tool = by_name[part.toolName] || Fallback;
+    const addResult = (result: any) => contentPartRuntime.addToolResult(result);
+    return (
+      <ToolUIDisplay {...part} part={part} UI={Tool} addResult={addResult} />
+    );
+  }
+
+  if (part.status.type === "requires-action")
+    throw new Error("Encountered unexpected requires-action status");
+
+  switch (type) {
+    case "text":
+      // TODO this relies on deprecated .part field
+      if (part.part === EMPTY_CONTENT && !!Empty) {
+        return <Empty status={part.status} />;
+      }
+
+      return <Text {...part} part={part} />;
+
+    case "image":
+      // eslint-disable-next-line jsx-a11y/alt-text
+      return <Image {...part} part={part} />;
+
+    case "audio":
+      return <Audio {...part} part={part} />;
+
+    case "ui":
+      return <UI {...part} part={part} />;
+
+    default:
+      const unhandledType: never = type;
+      throw new Error(`Unknown content part type: ${unhandledType}`);
+  }
+};
+
+type MessageContentPartProps = {
+  partIndex: number;
+  components: MessagePrimitiveContent.Props["components"];
+};
+
+const MessageContentPartImpl: FC<MessageContentPartProps> = ({
+  partIndex,
+  components,
+}) => {
+  const messageRuntime = useMessageRuntime();
+  const runtime = useMemo(
+    () => messageRuntime.getContentPartByIndex(partIndex),
+    [messageRuntime, partIndex],
+  );
+
+  return (
+    <ContentPartRuntimeProvider runtime={runtime}>
+      <MessageContentPartComponent components={components} />
+    </ContentPartRuntimeProvider>
+  );
+};
+
+const MessageContentPart = memo(
+  MessageContentPartImpl,
+  (prev, next) =>
+    prev.partIndex === next.partIndex &&
+    prev.components?.Text === next.components?.Text &&
+    prev.components?.Image === next.components?.Image &&
+    prev.components?.Unstable_Audio === next.components?.Unstable_Audio &&
+    prev.components?.UI === next.components?.UI &&
+    prev.components?.tools === next.components?.tools,
+);
+
+export const MessagePrimitiveContent: FC<MessagePrimitiveContent.Props> = ({
+  components,
+}) => {
+  const contentLength = useMessage((s) => s.content.length) || 1;
+
+  return Array.from({ length: contentLength }, (_, index) => (
+    <MessageContentPart key={index} partIndex={index} components={components} />
+  ));
+};
+
+MessagePrimitiveContent.displayName = "MessagePrimitive.Content";

package/src/primitives/message/MessageIf.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import type { FC, PropsWithChildren } from "react";
+import {
+  UseMessageIfProps,
+  useMessageIf,
+} from "../../primitive-hooks/message/useMessageIf";
+
+/**
+ * @deprecated Use `MessagePrimitive.If.Props` instead. This will be removed in 0.6.
+ */
+export type MessagePrimitiveIfProps = MessagePrimitiveIf.Props;
+
+export namespace MessagePrimitiveIf {
+  export type Props = PropsWithChildren<UseMessageIfProps>;
+}
+
+export const MessagePrimitiveIf: FC<MessagePrimitiveIf.Props> = ({
+  children,
+  ...query
+}) => {
+  const result = useMessageIf(query);
+  return result ? children : null;
+};
+
+MessagePrimitiveIf.displayName = "MessagePrimitive.If";

package/src/primitives/message/MessageInProgress.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { Primitive } from "@radix-ui/react-primitive";
+import { ComponentPropsWithoutRef, FC } from "react";
+
+type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
+
+/**
+ * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead. This will be removed in 0.6.
+ */
+export type MessagePrimitiveInProgressProps = PrimitiveSpanProps;
+
+/**
+ * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead. This will be removed in 0.6.
+ */
+export const MessagePrimitiveInProgress: FC<
+  MessagePrimitiveInProgressProps
+> = () => {
+  return null;
+};
+
+MessagePrimitiveInProgress.displayName = "MessagePrimitive.InProgress";

package/src/primitives/message/MessageRoot.tsx

@@ -0,0 +1,62 @@
+"use client";
+
+import { Primitive } from "@radix-ui/react-primitive";
+import {
+  type ElementRef,
+  forwardRef,
+  ComponentPropsWithoutRef,
+  useCallback,
+} from "react";
+import { useMessageUtilsStore } from "../../context/react/MessageContext";
+import { useManagedRef } from "../../utils/hooks/useManagedRef";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+
+const useIsHoveringRef = () => {
+  const messageUtilsStore = useMessageUtilsStore();
+  const callbackRef = useCallback(
+    (el: HTMLElement) => {
+      const setIsHovering = messageUtilsStore.getState().setIsHovering;
+
+      const handleMouseEnter = () => {
+        setIsHovering(true);
+      };
+      const handleMouseLeave = () => {
+        setIsHovering(false);
+      };
+
+      el.addEventListener("mouseenter", handleMouseEnter);
+      el.addEventListener("mouseleave", handleMouseLeave);
+
+      return () => {
+        el.removeEventListener("mouseenter", handleMouseEnter);
+        el.removeEventListener("mouseleave", handleMouseLeave);
+        setIsHovering(false);
+      };
+    },
+    [messageUtilsStore],
+  );
+
+  return useManagedRef(callbackRef);
+};
+
+/**
+ * @deprecated Use `MessagePrimitive.Root.Props` instead. This will be removed in 0.6.
+ */
+export type MessagePrimitiveRootProps = MessagePrimitiveRoot.Props;
+
+export namespace MessagePrimitiveRoot {
+  export type Element = ElementRef<typeof Primitive.div>;
+  export type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
+}
+
+export const MessagePrimitiveRoot = forwardRef<
+  MessagePrimitiveRoot.Element,
+  MessagePrimitiveRoot.Props
+>((props, forwardRef) => {
+  const isHoveringRef = useIsHoveringRef();
+  const ref = useComposedRefs<HTMLDivElement>(forwardRef, isHoveringRef);
+
+  return <Primitive.div {...props} ref={ref} />;
+});
+
+MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";

package/src/primitives/message/index.ts

@@ -0,0 +1,5 @@
+export { MessagePrimitiveRoot as Root } from "./MessageRoot";
+export { MessagePrimitiveIf as If } from "./MessageIf";
+export { MessagePrimitiveContent as Content } from "./MessageContent";
+export { MessagePrimitiveInProgress as InProgress } from "./MessageInProgress";
+export { MessagePrimitiveAttachments as Attachments } from "./MessageAttachments";

package/src/primitives/message/types.ts

@@ -0,0 +1,4 @@
+export type { MessagePrimitiveRootProps } from "./MessageRoot";
+export type { MessagePrimitiveIfProps } from "./MessageIf";
+export type { MessagePrimitiveContentProps } from "./MessageContent";
+export type { MessagePrimitiveInProgressProps } from "./MessageInProgress";

package/src/primitives/thread/ThreadEmpty.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import type { FC, PropsWithChildren } from "react";
+import { useThreadEmpty } from "../../primitive-hooks";
+
+/**
+ * @deprecated Use `ThreadPrimitive.Empty.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveEmptyProps = ThreadPrimitiveEmpty.Props;
+
+export namespace ThreadPrimitiveEmpty {
+  export type Props = PropsWithChildren;
+}
+
+export const ThreadPrimitiveEmpty: FC<ThreadPrimitiveEmpty.Props> = ({
+  children,
+}) => {
+  const empty = useThreadEmpty();
+  return empty ? children : null;
+};
+
+ThreadPrimitiveEmpty.displayName = "ThreadPrimitive.Empty";

package/src/primitives/thread/ThreadIf.tsx

@@ -0,0 +1,26 @@
+"use client";
+
+import type { FC, PropsWithChildren } from "react";
+import {
+  UseThreadIfProps,
+  useThreadIf,
+} from "../../primitive-hooks/thread/useThreadIf";
+
+/**
+ * @deprecated Use `ThreadPrimitive.If.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveIfProps = ThreadPrimitiveIf.Props;
+
+export namespace ThreadPrimitiveIf {
+  export type Props = PropsWithChildren<UseThreadIfProps>;
+}
+
+export const ThreadPrimitiveIf: FC<ThreadPrimitiveIf.Props> = ({
+  children,
+  ...query
+}) => {
+  const result = useThreadIf(query);
+  return result ? children : null;
+};
+
+ThreadPrimitiveIf.displayName = "ThreadPrimitive.If";

package/src/primitives/thread/ThreadMessages.tsx

@@ -0,0 +1,164 @@
+"use client";
+
+import { type ComponentType, type FC, memo, useMemo } from "react";
+import { useThread, useThreadRuntime } from "../../context/react/ThreadContext";
+import { MessageRuntimeProvider } from "../../context/providers/MessageRuntimeProvider";
+import { useEditComposer, useMessage } from "../../context";
+import { ThreadMessage as ThreadMessageType } from "../../types";
+
+/**
+ * @deprecated Use `ThreadPrimitive.Messages.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveMessagesProps = ThreadPrimitiveMessages.Props;
+
+export namespace ThreadPrimitiveMessages {
+  export type Props = {
+    components:
+      | {
+          Message: ComponentType;
+          EditComposer?: ComponentType | undefined;
+          UserEditComposer?: ComponentType | undefined;
+          AssistantEditComposer?: ComponentType | undefined;
+          SystemEditComposer?: ComponentType | undefined;
+          UserMessage?: ComponentType | undefined;
+          AssistantMessage?: ComponentType | undefined;
+          SystemMessage?: ComponentType | undefined;
+        }
+      | {
+          Message?: ComponentType | undefined;
+          EditComposer?: ComponentType | undefined;
+          UserEditComposer?: ComponentType | undefined;
+          AssistantEditComposer?: ComponentType | undefined;
+          SystemEditComposer?: ComponentType | undefined;
+          UserMessage: ComponentType;
+          AssistantMessage: ComponentType;
+          SystemMessage?: ComponentType | undefined;
+        };
+  };
+}
+
+const isComponentsSame = (
+  prev: ThreadPrimitiveMessages.Props["components"],
+  next: ThreadPrimitiveMessages.Props["components"],
+) => {
+  return (
+    prev.Message === next.Message &&
+    prev.EditComposer === next.EditComposer &&
+    prev.UserEditComposer === next.UserEditComposer &&
+    prev.AssistantEditComposer === next.AssistantEditComposer &&
+    prev.SystemEditComposer === next.SystemEditComposer &&
+    prev.UserMessage === next.UserMessage &&
+    prev.AssistantMessage === next.AssistantMessage &&
+    prev.SystemMessage === next.SystemMessage
+  );
+};
+
+const DEFAULT_SYSTEM_MESSAGE = () => null;
+
+const getComponent = (
+  components: ThreadPrimitiveMessages.Props["components"],
+  role: ThreadMessageType["role"],
+  isEditing: boolean,
+) => {
+  switch (role) {
+    case "user":
+      if (isEditing) {
+        return (
+          components.UserEditComposer ??
+          components.EditComposer ??
+          components.UserMessage ??
+          (components.Message as ComponentType)
+        );
+      } else {
+        return components.UserMessage ?? (components.Message as ComponentType);
+      }
+    case "assistant":
+      if (isEditing) {
+        return (
+          components.AssistantEditComposer ??
+          components.EditComposer ??
+          components.AssistantMessage ??
+          (components.Message as ComponentType)
+        );
+      } else {
+        return (
+          components.AssistantMessage ?? (components.Message as ComponentType)
+        );
+      }
+    case "system":
+      if (isEditing) {
+        return (
+          components.SystemEditComposer ??
+          components.EditComposer ??
+          components.SystemMessage ??
+          (components.Message as ComponentType)
+        );
+      } else {
+        return components.SystemMessage ?? DEFAULT_SYSTEM_MESSAGE;
+      }
+    default:
+      const _exhaustiveCheck: never = role;
+      throw new Error(`Unknown message role: ${_exhaustiveCheck}`);
+  }
+};
+
+type ThreadMessageComponentProps = {
+  components: ThreadPrimitiveMessages.Props["components"];
+};
+
+const ThreadMessageComponent: FC<ThreadMessageComponentProps> = ({
+  components,
+}) => {
+  const role = useMessage((m) => m.role);
+  const isEditing = useEditComposer((c) => c.isEditing);
+  const Component = getComponent(components, role, isEditing);
+
+  return <Component />;
+};
+
+type ThreadMessageProps = {
+  messageIndex: number;
+  components: ThreadPrimitiveMessages.Props["components"];
+};
+
+const ThreadMessageImpl: FC<ThreadMessageProps> = ({
+  messageIndex,
+  components,
+}) => {
+  const threadRuntime = useThreadRuntime();
+  const runtime = useMemo(
+    () => threadRuntime.getMesssageByIndex(messageIndex),
+    [threadRuntime, messageIndex],
+  );
+
+  return (
+    <MessageRuntimeProvider runtime={runtime}>
+      <ThreadMessageComponent components={components} />
+    </MessageRuntimeProvider>
+  );
+};
+
+const ThreadMessage = memo(
+  ThreadMessageImpl,
+  (prev, next) =>
+    prev.messageIndex === next.messageIndex &&
+    isComponentsSame(prev.components, next.components),
+);
+
+export const ThreadPrimitiveMessagesImpl: FC<ThreadPrimitiveMessages.Props> = ({
+  components,
+}) => {
+  const messagesLength = useThread((t) => t.messages.length);
+  if (messagesLength === 0) return null;
+
+  return Array.from({ length: messagesLength }, (_, index) => (
+    <ThreadMessage key={index} messageIndex={index} components={components} />
+  ));
+};
+
+ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
+
+export const ThreadPrimitiveMessages = memo(
+  ThreadPrimitiveMessagesImpl,
+  (prev, next) => isComponentsSame(prev.components, next.components),
+);

package/src/primitives/thread/ThreadRoot.tsx

@@ -0,0 +1,23 @@
+"use client";
+
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ElementRef, forwardRef, ComponentPropsWithoutRef } from "react";
+
+/**
+ * @deprecated Use `ThreadPrimitive.Root.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveRootProps = ThreadPrimitiveRoot.Props;
+
+export namespace ThreadPrimitiveRoot {
+  export type Element = ElementRef<typeof Primitive.div>;
+  export type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
+}
+
+export const ThreadPrimitiveRoot = forwardRef<
+  ThreadPrimitiveRoot.Element,
+  ThreadPrimitiveRoot.Props
+>((props, ref) => {
+  return <Primitive.div {...props} ref={ref} />;
+});
+
+ThreadPrimitiveRoot.displayName = "ThreadPrimitive.Root";

package/src/primitives/thread/ThreadScrollToBottom.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadScrollToBottom } from "../../primitive-hooks/thread/useThreadScrollToBottom";
+
+/**
+ * @deprecated Use `ThreadPrimitive.ScrollToBottom.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveScrollToBottomProps =
+  ThreadPrimitiveScrollToBottom.Props;
+
+export namespace ThreadPrimitiveScrollToBottom {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadScrollToBottom>;
+}
+
+export const ThreadPrimitiveScrollToBottom = createActionButton(
+  "ThreadPrimitive.ScrollToBottom",
+  useThreadScrollToBottom,
+);

package/src/primitives/thread/ThreadSuggestion.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadSuggestion } from "../../primitive-hooks/thread/useThreadSuggestion";
+
+/**
+ * @deprecated Use `ThreadPrimitive.Suggestion.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveSuggestionProps = ThreadPrimitiveSuggestion.Props;
+
+export namespace ThreadPrimitiveSuggestion {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadSuggestion>;
+}
+
+export const ThreadPrimitiveSuggestion = createActionButton(
+  "ThreadPrimitive.Suggestion",
+  useThreadSuggestion,
+  ["prompt", "autoSend", "method"],
+);

package/src/primitives/thread/ThreadViewport.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ElementRef, forwardRef, ComponentPropsWithoutRef } from "react";
+import {
+  UseThreadViewportAutoScrollProps,
+  useThreadViewportAutoScroll,
+} from "../../primitive-hooks/thread/useThreadViewportAutoScroll";
+
+/**
+ * @deprecated Use `ThreadPrimitive.Viewport.Props` instead. This will be removed in 0.6.
+ */
+export type ThreadPrimitiveViewportProps = ThreadPrimitiveViewport.Props;
+
+export namespace ThreadPrimitiveViewport {
+  export type Element = ElementRef<typeof Primitive.div>;
+  export type Props = ComponentPropsWithoutRef<typeof Primitive.div> &
+    UseThreadViewportAutoScrollProps;
+}
+
+export const ThreadPrimitiveViewport = forwardRef<
+  ThreadPrimitiveViewport.Element,
+  ThreadPrimitiveViewport.Props
+>(({ autoScroll, children, ...rest }, forwardedRef) => {
+  const autoScrollRef = useThreadViewportAutoScroll<HTMLDivElement>({
+    autoScroll,
+  });
+
+  const ref = useComposedRefs(forwardedRef, autoScrollRef);
+
+  return (
+    <Primitive.div {...rest} ref={ref}>
+      {children}
+    </Primitive.div>
+  );
+});
+
+ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";

package/src/primitives/thread/index.ts

@@ -0,0 +1,7 @@
+export { ThreadPrimitiveRoot as Root } from "./ThreadRoot";
+export { ThreadPrimitiveEmpty as Empty } from "./ThreadEmpty";
+export { ThreadPrimitiveIf as If } from "./ThreadIf";
+export { ThreadPrimitiveViewport as Viewport } from "./ThreadViewport";
+export { ThreadPrimitiveMessages as Messages } from "./ThreadMessages";
+export { ThreadPrimitiveScrollToBottom as ScrollToBottom } from "./ThreadScrollToBottom";
+export { ThreadPrimitiveSuggestion as Suggestion } from "./ThreadSuggestion";

package/src/primitives/thread/types.ts

@@ -0,0 +1,7 @@
+export type { ThreadPrimitiveRootProps } from "./ThreadRoot";
+export type { ThreadPrimitiveEmptyProps } from "./ThreadEmpty";
+export type { ThreadPrimitiveIfProps } from "./ThreadIf";
+export type { ThreadPrimitiveViewportProps } from "./ThreadViewport";
+export type { ThreadPrimitiveMessagesProps } from "./ThreadMessages";
+export type { ThreadPrimitiveScrollToBottomProps } from "./ThreadScrollToBottom";
+export type { ThreadPrimitiveSuggestionProps } from "./ThreadSuggestion";

package/src/runtimes/attachment/AttachmentAdapter.ts

@@ -0,0 +1,23 @@
+import {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+  PendingAttachmentStatus,
+  CompleteAttachmentStatus,
+} from "../../types/AttachmentTypes";
+
+export type AttachmentAdapter = {
+  accept: string;
+
+  add(state: {
+    file: File;
+  }): Promise<
+    Omit<PendingAttachment, "status"> & { status?: PendingAttachmentStatus }
+  >;
+  remove(attachment: Attachment): Promise<void>;
+  send(
+    attachment: PendingAttachment,
+  ): Promise<
+    Omit<CompleteAttachment, "status"> & { status?: CompleteAttachmentStatus }
+  >;
+};