@assistant-ui/react-ai-sdk 0.9.7 → 0.10.2

package/src/ui/utils/convertMessage.ts

@@ -0,0 +1,158 @@
+import { Message } from "@ai-sdk/ui-utils";
+import { unstable_createMessageConverter } from "@assistant-ui/react";
+import { SourceContentPart } from "@assistant-ui/react";
+import { FileContentPart } from "@assistant-ui/react";
+import { ReasoningContentPart } from "@assistant-ui/react";
+import { ToolCallContentPart } from "@assistant-ui/react";
+import { TextContentPart } from "@assistant-ui/react";
+import { CompleteAttachment } from "@assistant-ui/react";
+
+export const AISDKMessageConverter = unstable_createMessageConverter(
+  (message: Message) => {
+    switch (message.role) {
+      case "user":
+        return {
+          role: "user",
+          id: message.id,
+          createdAt: message.createdAt,
+          content: message.content,
+
+          attachments: message.experimental_attachments?.map(
+            (attachment, idx) =>
+              ({
+                id: idx.toString(),
+                type: "file",
+                name: attachment.name ?? attachment.url,
+                content: [],
+                contentType: attachment.contentType ?? "unknown/unknown",
+                status: { type: "complete" },
+              }) satisfies CompleteAttachment,
+          ),
+        };
+
+      case "system":
+        return {
+          role: "system",
+          id: message.id,
+          createdAt: message.createdAt,
+          content: message.content,
+        };
+
+      case "assistant":
+        return {
+          role: "assistant",
+          id: message.id,
+          createdAt: message.createdAt,
+          content:
+            message.parts
+              ?.filter((p) => p.type !== "step-start")
+              .map((part) => {
+                const type = part.type;
+                switch (type) {
+                  case "text":
+                    return {
+                      type: "text",
+                      text: part.text,
+                    } satisfies TextContentPart;
+                  case "tool-invocation":
+                    return {
+                      type: "tool-call",
+                      toolName: part.toolInvocation.toolName,
+                      toolCallId: part.toolInvocation.toolCallId,
+                      argsText: JSON.stringify(part.toolInvocation.args),
+                      args: part.toolInvocation.args,
+                      result:
+                        part.toolInvocation.state === "result" &&
+                        part.toolInvocation.result,
+                    } satisfies ToolCallContentPart;
+                  case "reasoning":
+                    return {
+                      type: "reasoning",
+                      text: part.reasoning,
+                    } satisfies ReasoningContentPart;
+
+                  case "source":
+                    return {
+                      type: "source",
+                      ...part.source,
+                    } satisfies SourceContentPart;
+
+                  case "file":
+                    return {
+                      type: "file",
+                      data: part.data,
+                      mimeType: part.mimeType,
+                    } satisfies FileContentPart;
+
+                  default: {
+                    const _unsupported: never = type;
+                    throw new Error(
+                      `You have a message with an unsupported part type. The type ${_unsupported} is not supported.`,
+                    );
+                  }
+                }
+              }) ??
+            (message.content
+              ? [
+                  {
+                    type: "text",
+                    text: message.content,
+                  } satisfies TextContentPart,
+                ]
+              : []),
+          metadata: {
+            unstable_annotations: message.annotations,
+            unstable_data: Array.isArray(message.data)
+              ? message.data
+              : message.data
+                ? [message.data]
+                : undefined,
+          },
+        };
+
+      case "data": {
+        type MaybeSupportedDataMessage =
+          | { type?: "unsafe_other" }
+          | ToolCallContentPart
+          | {
+              type: "tool-result";
+              toolCallId: string;
+              result: any;
+            };
+
+        if (
+          !message.data ||
+          !(typeof message.data === "object") ||
+          Array.isArray(message.data)
+        )
+          return [];
+
+        const data = message.data as MaybeSupportedDataMessage;
+
+        if (data.type === "tool-call") {
+          return {
+            role: "assistant",
+            id: message.id,
+            createdAt: message.createdAt,
+            content: [data],
+          };
+        } else if (data.type === "tool-result") {
+          return {
+            role: "tool",
+            id: message.id,
+            toolCallId: data.toolCallId,
+            result: data.result,
+          };
+        }
+        return [];
+      }
+
+      default:
+        // TODO handle tool and function messages
+        const _unsupported: "function" | "tool" = message.role;
+        throw new Error(
+          `You have a message with an unsupported role. The role ${_unsupported} is not supported.`,
+        );
+    }
+  },
+);

package/src/ui/utils/sliceMessagesUntil.tsx

@@ -0,0 +1,20 @@
+import type { Message } from "@ai-sdk/ui-utils";
+
+export const sliceMessagesUntil = (
+  messages: Message[],
+  messageId: string | null,
+) => {
+  if (messageId == null) return [];
+
+  let messageIdx = messages.findIndex((m) => m.id === messageId);
+  if (messageIdx === -1)
+    throw new Error(
+      "useVercelAIThreadState: Message not found. This is liekly an internal bug in assistant-ui.",
+    );
+
+  while (messages[messageIdx + 1]?.role === "assistant") {
+    messageIdx++;
+  }
+
+  return messages.slice(0, messageIdx + 1);
+};

package/src/ui/utils/toCreateMessage.ts

@@ -0,0 +1,44 @@
+import { AppendMessage } from "@assistant-ui/react";
+import { CreateMessage } from "@ai-sdk/ui-utils";
+
+export const toCreateMessage = async (
+  message: AppendMessage,
+): Promise<CreateMessage> => {
+  const content = message.content
+    .filter((part) => part.type === "text")
+    .map((t) => t.text)
+    .join("\n\n");
+
+  const images = message.content
+    .filter((part) => part.type === "image")
+    .map((part) => ({ url: part.image }));
+
+  return {
+    role: message.role,
+    content,
+    experimental_attachments: [
+      ...images,
+      ...(await Promise.all(
+        (message.attachments ?? []).map(async (m) => {
+          if (m.file == null)
+            throw new Error("Attachment did not contain a file");
+          return {
+            contentType: m.file.type,
+            name: m.file.name,
+            url: await getFileDataURL(m.file),
+          };
+        }),
+      )),
+    ],
+  };
+};
+
+const getFileDataURL = (file: File) =>
+  new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = (error) => reject(error);
+
+    reader.readAsDataURL(file);
+  });

package/src/ui/utils/useInputSync.tsx

@@ -0,0 +1,24 @@
+import { useEffect } from "react";
+import { useAssistant, useChat } from "@ai-sdk/react";
+import { AssistantRuntime } from "@assistant-ui/react";
+
+type VercelHelpers =
+  | ReturnType<typeof useChat>
+  | ReturnType<typeof useAssistant>;
+
+export const useInputSync = (
+  { setInput, input }: VercelHelpers,
+  runtime: AssistantRuntime,
+) => {
+  // sync input from vercel to assistant-ui
+  useEffect(() => {
+    runtime.thread.composer.setText(input);
+  }, [runtime, input]);
+
+  // sync input from assistant-ui to vercel
+  useEffect(() => {
+    return runtime.thread.composer.subscribe(() => {
+      setInput(runtime.thread.composer.getState().text);
+    });
+  }, [runtime, setInput]);
+};

package/src/ui/utils/vercelAttachmentAdapter.ts

@@ -0,0 +1,29 @@
+import { AttachmentAdapter } from "@assistant-ui/react";
+import { generateId } from "@ai-sdk/ui-utils";
+
+export const vercelAttachmentAdapter: AttachmentAdapter = {
+  accept:
+    "image/*, text/plain, text/html, text/markdown, text/csv, text/xml, text/json, text/css",
+  async add({ file }) {
+    return {
+      id: generateId(),
+      type: "file",
+      name: file.name,
+      file,
+      contentType: file.type,
+      content: [],
+      status: { type: "requires-action", reason: "composer-send" },
+    };
+  },
+  async send(attachment) {
+    // noop
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content: [],
+    };
+  },
+  async remove() {
+    // noop
+  },
+};

package/src/useChatRuntime.ts

@@ -0,0 +1,10 @@
+import { EdgeRuntimeOptions, useEdgeRuntime } from "@assistant-ui/react-edge";
+
+type UseChatRuntimeOptions = Omit<EdgeRuntimeOptions, "unstable_AISDKInterop">;
+
+export const useChatRuntime = (options: UseChatRuntimeOptions) => {
+  return useEdgeRuntime({
+    ...options,
+    unstable_AISDKInterop: "v2",
+  });
+};

package/dist/index.d.mts

@@ -1,56 +0,0 @@
-import * as _assistant_ui_react_internal from '@assistant-ui/react/internal';
-import { AppendMessage, ExternalStoreAdapter, ThreadMessage } from '@assistant-ui/react';
-import { ReactNode, FC } from 'react';
-import { useChat, useAssistant } from '@ai-sdk/react';
-import { Message } from '@ai-sdk/ui-utils';
-import { EdgeRuntimeOptions } from '@assistant-ui/react-edge';
-export { fromLanguageModelMessages, fromLanguageModelTools, toLanguageModelMessages, toLanguageModelTools, useDangerousInBrowserRuntime } from '@assistant-ui/react-edge';
-
-type VercelRSCMessage = {
-    id?: string | undefined;
-    role: "user" | "assistant";
-    display: ReactNode;
-    createdAt?: Date | undefined;
-};
-
-type RSCMessageConverter<T> = {
-    convertMessage: (message: T) => VercelRSCMessage;
-};
-type VercelRSCAdapterBase<T> = {
-    isRunning?: boolean | undefined;
-    messages: T[];
-    onNew?: (message: AppendMessage) => Promise<void>;
-    onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
-    onReload?: ((parentId: string | null) => Promise<void>) | undefined;
-    convertMessage?: ((message: T) => VercelRSCMessage) | undefined;
-    adapters?: ExternalStoreAdapter["adapters"] | undefined;
-};
-type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
-
-declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => _assistant_ui_react_internal.AssistantRuntimeImpl;
-
-/**
- * @deprecated Use `getExternalStoreMessage` instead. This method was specific to Vercel RSC
- * implementation and has been replaced by a more generic external store message handler.
- */
-declare const getVercelRSCMessage: (message: ThreadMessage) => unknown;
-
-declare const RSCDisplay: FC;
-
-type VercelUseChatAdapter$1 = {
-    adapters?: Omit<NonNullable<ExternalStoreAdapter["adapters"]>, "attachments"> | undefined;
-    unstable_joinStrategy?: "concat-content" | "none";
-};
-declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>, adapter?: VercelUseChatAdapter$1) => _assistant_ui_react_internal.AssistantRuntimeImpl;
-
-type VercelUseChatAdapter = {
-    adapters?: Omit<NonNullable<ExternalStoreAdapter["adapters"]>, "attachments"> | undefined;
-};
-declare const useVercelUseAssistantRuntime: (assistantHelpers: ReturnType<typeof useAssistant>, adapter?: VercelUseChatAdapter) => _assistant_ui_react_internal.AssistantRuntimeImpl;
-
-declare const getVercelAIMessages: (message: ThreadMessage) => Message[];
-
-type UseChatRuntimeOptions = Omit<EdgeRuntimeOptions, "unstable_AISDKInterop">;
-declare const useChatRuntime: (options: UseChatRuntimeOptions) => _assistant_ui_react_internal.AssistantRuntimeImpl;
-
-export { RSCDisplay, type VercelRSCAdapter, type VercelRSCMessage, getVercelAIMessages, getVercelRSCMessage, useChatRuntime, useVercelRSCRuntime, useVercelUseAssistantRuntime, useVercelUseChatRuntime };