@assistant-ui/react 0.10.48 → 0.10.50

package/package.json

@@ -28,7 +28,7 @@
     "conversational-ui",
     "conversational-ai"
   ],
-  "version": "0.10.48",
+  "version": "0.10.50",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cloud/AssistantCloudThreadHistoryAdapter.tsx

@@ -14,6 +14,12 @@ import {
 import { GenericThreadHistoryAdapter } from "../runtimes/adapters/thread-history/ThreadHistoryAdapter";
 import { ReadonlyJSONObject } from "assistant-stream/utils";
 
+// Global WeakMap to store message ID mappings across adapter instances
+const globalMessageIdMapping = new WeakMap<
+  ThreadListItemRuntime,
+  Record<string, string | Promise<string>>
+>();
+
 class FormattedThreadHistoryAdapter<TMessage, TStorageFormat>
   implements GenericThreadHistoryAdapter<TMessage>
 {
@@ -52,7 +58,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     private threadListItemRuntime: ThreadListItemRuntime,
   ) {}
 
-  private _getIdForLocalId: Record<string, string | Promise<string>> = {};
+  private get _getIdForLocalId(): Record<string, string | Promise<string>> {
+    if (!globalMessageIdMapping.has(this.threadListItemRuntime)) {
+      globalMessageIdMapping.set(this.threadListItemRuntime, {});
+    }
+    return globalMessageIdMapping.get(this.threadListItemRuntime)!;
+  }
 
   withFormat<TMessage, TStorageFormat>(
     formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,

package/src/runtimes/adapters/RuntimeAdapterProvider.tsx

@@ -2,11 +2,13 @@
 
 import { createContext, FC, ReactNode, useContext } from "react";
 import { ThreadHistoryAdapter } from "./thread-history/ThreadHistoryAdapter";
+import { AttachmentAdapter } from "./attachment/AttachmentAdapter";
 import { ModelContextProvider } from "../../model-context";
 
 export type RuntimeAdapters = {
   modelContext?: ModelContextProvider;
   history?: ThreadHistoryAdapter;
+  attachments?: AttachmentAdapter;
 };
 
 const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);

package/src/runtimes/adapters/attachment/CloudFileAttachmentAdapter.ts

@@ -0,0 +1,101 @@
+import type { AssistantCloud } from "assistant-cloud";
+import {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+} from "../../../types/AttachmentTypes";
+import { ThreadUserMessagePart } from "../../../types/MessagePartTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+
+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/runtimes/adapters/attachment/index.ts

@@ -2,3 +2,4 @@ export type { AttachmentAdapter } from "./AttachmentAdapter";
 export { SimpleImageAttachmentAdapter } from "./SimpleImageAttachmentAdapter";
 export { SimpleTextAttachmentAdapter } from "./SimpleTextAttachmentAdapter";
 export { CompositeAttachmentAdapter } from "./CompositeAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

package/src/runtimes/remote-thread-list/adapter/cloud.tsx

@@ -13,6 +13,7 @@ import { RemoteThreadListAdapter } from "../types";
 import { useAssistantCloudThreadHistoryAdapter } from "../../../cloud/AssistantCloudThreadHistoryAdapter";
 import { RuntimeAdapterProvider } from "../../adapters/RuntimeAdapterProvider";
 import { InMemoryThreadListAdapter } from "./in-memory";
+import { CloudFileAttachmentAdapter } from "../../adapters";
 
 type ThreadData = {
   externalId: string;
@@ -47,7 +48,21 @@ export const useCloudThreadListAdapter = (
           return adapterRef.current.cloud ?? autoCloud!;
         },
       });
-      const adapters = useMemo(() => ({ history }), [history]);
+      const attachments = useMemo(
+        () =>
+          new CloudFileAttachmentAdapter(
+            adapterRef.current.cloud ?? autoCloud!,
+          ),
+        [adapterRef.current.cloud],
+      );
+
+      const adapters = useMemo(
+        () => ({
+          history,
+          attachments,
+        }),
+        [history],
+      );
 
       return (
         <RuntimeAdapterProvider adapters={adapters}>