@assistant-ui/core 0.1.1 → 0.1.3

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.ts

@@ -0,0 +1,101 @@
+import type { AssistantCloud } from "assistant-cloud";
+import type {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+  ThreadUserMessagePart,
+} from "../../../types";
+import type { AttachmentAdapter } from "../../../adapters/attachment";
+
+const guessAttachmentType = (
+  contentType: string,
+): "image" | "document" | "file" => {
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("text/")) return "document";
+  return "file";
+};
+
+export class CloudFileAttachmentAdapter implements AttachmentAdapter {
+  public accept = "*";
+
+  constructor(private cloud: AssistantCloud) {}
+
+  private uploadedUrls = new Map<string, string>();
+
+  public async *add({
+    file,
+  }: {
+    file: File;
+  }): AsyncGenerator<PendingAttachment, void> {
+    const id = crypto.randomUUID();
+    const type = guessAttachmentType(file.type);
+    let attachment: PendingAttachment = {
+      id,
+      type,
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "running", reason: "uploading", progress: 0 },
+    };
+    yield attachment;
+
+    try {
+      const { signedUrl, publicUrl } =
+        await this.cloud.files.generatePresignedUploadUrl({
+          filename: file.name,
+        });
+      await fetch(signedUrl, {
+        method: "PUT",
+        body: file,
+        headers: {
+          "Content-Type": file.type,
+        },
+        mode: "cors",
+      });
+      this.uploadedUrls.set(id, publicUrl);
+      attachment = {
+        ...attachment,
+        status: { type: "requires-action", reason: "composer-send" },
+      };
+      yield attachment;
+    } catch {
+      attachment = {
+        ...attachment,
+        status: { type: "incomplete", reason: "error" },
+      };
+      yield attachment;
+    }
+  }
+
+  public async remove(attachment: Attachment): Promise<void> {
+    this.uploadedUrls.delete(attachment.id);
+  }
+
+  public async send(
+    attachment: PendingAttachment,
+  ): Promise<CompleteAttachment> {
+    const url = this.uploadedUrls.get(attachment.id);
+    if (!url) throw new Error("Attachment not uploaded");
+    this.uploadedUrls.delete(attachment.id);
+
+    let content: ThreadUserMessagePart[];
+    if (attachment.type === "image") {
+      content = [{ type: "image", image: url, filename: attachment.name }];
+    } else {
+      content = [
+        {
+          type: "file",
+          data: url,
+          mimeType: attachment.contentType ?? "",
+          filename: attachment.name,
+        },
+      ];
+    }
+
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content,
+    };
+  }
+}

package/src/react/runtimes/cloud/auiV0.ts

@@ -0,0 +1,160 @@
+import type { MessageStatus, ThreadMessage } from "../../../types";
+import { fromThreadMessageLike } from "../../../runtime/utils/thread-message-like";
+import { CloudMessage } from "assistant-cloud";
+import { isJSONValue } from "../../../utils/json/is-json";
+import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
+
+type AuiV0MessagePart =
+  | {
+      readonly type: "text";
+      readonly text: string;
+    }
+  | {
+      readonly type: "reasoning";
+      readonly text: string;
+    }
+  | {
+      readonly type: "source";
+      readonly sourceType: "url";
+      readonly id: string;
+      readonly url: string;
+      readonly title?: string;
+    }
+  | {
+      readonly type: "tool-call";
+      readonly toolCallId: string;
+      readonly toolName: string;
+      readonly args: ReadonlyJSONObject;
+      readonly result?: ReadonlyJSONValue;
+      readonly isError?: true;
+    }
+  | {
+      readonly type: "tool-call";
+      readonly toolCallId: string;
+      readonly toolName: string;
+      readonly argsText: string;
+      readonly result?: ReadonlyJSONValue;
+      readonly isError?: true;
+    }
+  | {
+      readonly type: "image";
+      readonly image: string;
+    }
+  | {
+      readonly type: "file";
+      readonly data: string;
+      readonly mimeType: string;
+      readonly filename?: string;
+    };
+
+type AuiV0Message = {
+  readonly role: "assistant" | "user" | "system";
+  readonly status?: MessageStatus;
+  readonly content: readonly AuiV0MessagePart[];
+  readonly metadata: {
+    readonly unstable_state?: ReadonlyJSONValue;
+    readonly unstable_annotations: readonly ReadonlyJSONValue[];
+    readonly unstable_data: readonly ReadonlyJSONValue[];
+    readonly steps: readonly {
+      readonly usage?: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+      };
+    }[];
+    readonly custom: ReadonlyJSONObject;
+  };
+};
+
+export function auiV0Encode(message: ThreadMessage): AuiV0Message {
+  // TODO attachments are currently intentionally ignored
+  // info: ID and createdAt are ignored (we use the server value instead)
+
+  const status: MessageStatus | undefined =
+    message.status?.type === "running"
+      ? { type: "incomplete", reason: "cancelled" }
+      : message.status;
+
+  return {
+    role: message.role,
+    content: message.content.map((part) => {
+      const type = part.type;
+      switch (type) {
+        case "text":
+          return { type: "text", text: part.text };
+
+        case "reasoning":
+          return { type: "reasoning", text: part.text };
+
+        case "source":
+          return {
+            type: "source",
+            sourceType: part.sourceType,
+            id: part.id,
+            url: part.url,
+            ...(part.title ? { title: part.title } : undefined),
+          };
+
+        case "tool-call": {
+          if (!isJSONValue(part.result)) {
+            console.warn(
+              `tool-call result is not JSON! ${JSON.stringify(part)}`,
+            );
+          }
+          return {
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            ...(JSON.stringify(part.args) === part.argsText
+              ? { args: part.args }
+              : { argsText: part.argsText }),
+            ...(part.result
+              ? { result: part.result as ReadonlyJSONValue }
+              : undefined),
+            ...(part.isError ? { isError: true } : undefined),
+          };
+        }
+
+        case "image":
+          return { type: "image", image: part.image };
+
+        case "file":
+          return {
+            type: "file",
+            data: part.data,
+            mimeType: part.mimeType,
+            ...(part.filename ? { filename: part.filename } : undefined),
+          };
+
+        default: {
+          const unhandledType: "audio" | "data" = type;
+          throw new Error(
+            `Message part type not supported by aui/v0: ${unhandledType}`,
+          );
+        }
+      }
+    }),
+    metadata: message.metadata as AuiV0Message["metadata"],
+    ...(status ? { status } : undefined),
+  };
+}
+
+export function auiV0Decode(
+  cloudMessage: CloudMessage & { format: "aui/v0" },
+): ExportedMessageRepositoryItem {
+  const payload = cloudMessage.content as unknown as AuiV0Message;
+  const message = fromThreadMessageLike(
+    {
+      id: cloudMessage.id,
+      createdAt: cloudMessage.created_at,
+      ...payload,
+    },
+    cloudMessage.id,
+    { type: "complete", reason: "unknown" },
+  );
+
+  return {
+    parentId: cloudMessage.parent_id,
+    message,
+  };
+}

package/src/react/runtimes/cloud/index.ts

@@ -0,0 +1,3 @@
+export { useCloudThreadListAdapter } from "./useCloudThreadListAdapter";
+export { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -0,0 +1,152 @@
+declare const process: { env: Record<string, string | undefined> };
+
+import {
+  FC,
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+} from "react";
+import { AssistantCloud } from "assistant-cloud";
+import type { RemoteThreadListAdapter } from "../../../runtimes/remote-thread-list/types";
+import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/adapter/in-memory";
+import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
+import { RuntimeAdapterProvider } from "../RuntimeAdapterProvider";
+import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
+
+type ThreadData = {
+  externalId: string | undefined;
+};
+
+type CloudThreadListAdapterOptions = {
+  cloud?: AssistantCloud | undefined;
+
+  create?: (() => Promise<ThreadData>) | undefined;
+  delete?: ((threadId: string) => Promise<void>) | undefined;
+};
+
+const baseUrl = process?.env?.["NEXT_PUBLIC_ASSISTANT_BASE_URL"];
+const autoCloud = baseUrl
+  ? new AssistantCloud({ baseUrl, anonymous: true })
+  : undefined;
+
+export const useCloudThreadListAdapter = (
+  adapter: CloudThreadListAdapterOptions,
+): RemoteThreadListAdapter => {
+  const adapterRef = useRef(adapter);
+  useEffect(() => {
+    adapterRef.current = adapter;
+  }, [adapter]);
+
+  const unstable_Provider = useCallback<FC<PropsWithChildren>>(
+    function Provider({ children }) {
+      const history = useAssistantCloudThreadHistoryAdapter({
+        get current() {
+          return adapterRef.current.cloud ?? autoCloud!;
+        },
+      });
+      const cloudInstance = adapterRef.current.cloud ?? autoCloud!;
+      const attachments = useMemo(
+        () => new CloudFileAttachmentAdapter(cloudInstance),
+        [cloudInstance],
+      );
+
+      const adapters = useMemo(
+        () => ({
+          history,
+          attachments,
+        }),
+        [history, attachments],
+      );
+
+      return (
+        <RuntimeAdapterProvider adapters={adapters}>
+          {children}
+        </RuntimeAdapterProvider>
+      );
+    },
+    [],
+  );
+
+  const cloud = adapter.cloud ?? autoCloud;
+  if (!cloud) {
+    const ref = adapterRef;
+    const inMemory = new InMemoryThreadListAdapter();
+    inMemory.initialize = async (threadId: string) => {
+      const result = await ref.current.create?.();
+      return { remoteId: threadId, externalId: result?.externalId };
+    };
+    return inMemory;
+  }
+
+  return {
+    list: async () => {
+      const { threads } = await cloud.threads.list();
+      return {
+        threads: threads.map((t) => ({
+          status: t.is_archived ? "archived" : "regular",
+          remoteId: t.id,
+          title: t.title,
+          externalId: t.external_id ?? undefined,
+        })),
+      };
+    },
+
+    initialize: async () => {
+      const createTask = adapter.create?.() ?? Promise.resolve();
+      const t = await createTask;
+      const external_id = t ? t.externalId : undefined;
+      const { thread_id: remoteId } = await cloud.threads.create({
+        last_message_at: new Date(),
+        external_id,
+      });
+
+      return { externalId: external_id, remoteId: remoteId };
+    },
+
+    rename: async (threadId, newTitle) => {
+      return cloud.threads.update(threadId, { title: newTitle });
+    },
+    archive: async (threadId) => {
+      return cloud.threads.update(threadId, { is_archived: true });
+    },
+    unarchive: async (threadId) => {
+      return cloud.threads.update(threadId, { is_archived: false });
+    },
+    delete: async (threadId) => {
+      await adapter.delete?.(threadId);
+      return cloud.threads.delete(threadId);
+    },
+
+    generateTitle: async (threadId, messages) => {
+      // Filter messages to only include content types the title generator understands
+      // (reasoning, source, etc. are not needed for title generation)
+      // TODO serialize these to a more efficient format
+      const filteredMessages = messages.map((msg) => ({
+        ...msg,
+        content: msg.content.filter(
+          (part) => part.type === "text" || part.type === "tool-call",
+        ),
+      }));
+
+      return cloud.runs.stream({
+        thread_id: threadId,
+        assistant_id: "system/thread_title",
+        messages: filteredMessages,
+      });
+    },
+
+    fetch: async (threadId: string) => {
+      const thread = await cloud.threads.get(threadId);
+      return {
+        status: thread.is_archived ? "archived" : "regular",
+        remoteId: thread.id,
+        title: thread.title,
+        externalId: thread.external_id ?? undefined,
+      };
+    },
+
+    unstable_Provider,
+  };
+};

package/src/react/runtimes/createMessageConverter.ts

@@ -0,0 +1,77 @@
+"use client";
+import type { ThreadMessage } from "../../types";
+import type { ThreadState } from "../../runtime/api/thread-runtime";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import {
+  useExternalMessageConverter,
+  convertExternalMessages,
+} from "./external-message-converter";
+import { getExternalStoreMessages } from "../../runtime/utils/external-store-message";
+
+export const createMessageConverter = <T extends object>(
+  callback: useExternalMessageConverter.Callback<T>,
+) => {
+  const result = {
+    useThreadMessages: ({
+      messages,
+      isRunning,
+      joinStrategy,
+      metadata,
+    }: {
+      messages: T[];
+      isRunning: boolean;
+      joinStrategy?: "concat-content" | "none" | undefined;
+      metadata?: useExternalMessageConverter.Metadata;
+    }) => {
+      return useExternalMessageConverter<T>({
+        callback,
+        messages,
+        isRunning,
+        joinStrategy,
+        metadata,
+      });
+    },
+    toThreadMessages: (
+      messages: T[],
+      isRunning = false,
+      metadata: useExternalMessageConverter.Metadata = {},
+    ) => {
+      return convertExternalMessages(messages, callback, isRunning, metadata);
+    },
+    toOriginalMessages: (
+      input: ThreadState | ThreadMessage | ThreadMessage["content"][number],
+    ) => {
+      const messages = getExternalStoreMessages(input);
+      if (messages.length === 0) throw new Error("No original messages found");
+      return messages;
+    },
+    toOriginalMessage: (
+      input: ThreadState | ThreadMessage | ThreadMessage["content"][number],
+    ) => {
+      const messages = result.toOriginalMessages(input);
+      return messages[0]!;
+    },
+    useOriginalMessage: () => {
+      const messageMessages = result.useOriginalMessages();
+      const first = messageMessages[0]!;
+      return first;
+    },
+    useOriginalMessages: () => {
+      const aui = useAui();
+      const partMessages = useAuiState((s) => {
+        if (aui.part.source) return getExternalStoreMessages(s.part);
+        return undefined;
+      });
+
+      const messageMessages = useAuiState<T[]>((s) =>
+        getExternalStoreMessages(s.message),
+      );
+
+      const messages = partMessages ?? messageMessages;
+      if (messages.length === 0) throw new Error("No original messages found");
+      return messages;
+    },
+  };
+
+  return result;
+};