@assistant-ui/react-ai-sdk 0.1.1 → 0.1.2

package/src/rsc/VercelRSCAdapter.tsx

@@ -1,18 +0,0 @@
-"use client";
-import type { AppendMessage } from "@assistant-ui/react";
-import type { VercelRSCMessage } from "./VercelRSCMessage";
-
-type RSCMessageConverter<T> = {
-  convertMessage: (message: T) => VercelRSCMessage;
-};
-
-type VercelRSCAdapterBase<T> = {
-  messages: T[];
-  append: (message: AppendMessage) => Promise<void>;
-  edit?: (message: AppendMessage) => Promise<void>;
-  reload?: (parentId: string | null) => Promise<void>;
-  convertMessage?: (message: T) => VercelRSCMessage;
-};
-
-export type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> &
-  (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);

package/src/rsc/VercelRSCMessage.tsx

@@ -1,9 +0,0 @@
-"use client";
-import type { ReactNode } from "react";
-
-export type VercelRSCMessage = {
-  id: string;
-  role: "user" | "assistant";
-  display: ReactNode;
-  createdAt?: Date;
-};

package/src/rsc/VercelRSCRuntime.tsx

@@ -1,106 +0,0 @@
-"use client";
-
-import type {
-  AssistantRuntime,
-  ReactThreadRuntime,
-  Unsubscribe,
-} from "@assistant-ui/react";
-
-import type { AppendMessage, ThreadMessage } from "@assistant-ui/react";
-import { ProxyConfigProvider } from "@assistant-ui/react/internal";
-import { type StoreApi, type UseBoundStore, create } from "zustand";
-import type { VercelRSCAdapter } from "./VercelRSCAdapter";
-import type { VercelRSCMessage } from "./VercelRSCMessage";
-import { useVercelRSCSync } from "./useVercelRSCSync";
-
-const EMPTY_BRANCHES: readonly never[] = Object.freeze([]);
-
-export class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage>
-  extends ProxyConfigProvider
-  implements AssistantRuntime, ReactThreadRuntime
-{
-  private useAdapter: UseBoundStore<StoreApi<{ adapter: VercelRSCAdapter<T> }>>;
-
-  private _subscriptions = new Set<() => void>();
-
-  public isRunning = false;
-  public messages: ThreadMessage[] = [];
-
-  constructor(public adapter: VercelRSCAdapter<T>) {
-    super();
-
-    this.useAdapter = create(() => ({
-      adapter,
-    }));
-  }
-
-  private withRunning = (callback: Promise<unknown>) => {
-    this.isRunning = true;
-    return callback.finally(() => {
-      this.isRunning = false;
-    });
-  };
-
-  public getBranches(): readonly string[] {
-    return EMPTY_BRANCHES;
-  }
-
-  public switchToBranch(): void {
-    throw new Error(
-      "Branch switching is not supported by VercelRSCAssistantProvider.",
-    );
-  }
-
-  public async append(message: AppendMessage): Promise<void> {
-    if (message.parentId !== (this.messages.at(-1)?.id ?? null)) {
-      if (!this.adapter.edit)
-        throw new Error(
-          "Message editing is not enabled, please provide an edit callback to VercelRSCAssistantProvider.",
-        );
-      await this.withRunning(this.adapter.edit(message));
-    } else {
-      await this.withRunning(this.adapter.append(message));
-    }
-  }
-
-  public async startRun(parentId: string | null): Promise<void> {
-    if (!this.adapter.reload)
-      throw new Error(
-        "Message reloading is not enabled, please provide a reload callback to VercelRSCAssistantProvider.",
-      );
-    await this.withRunning(this.adapter.reload(parentId));
-  }
-
-  cancelRun(): void {
-    // in dev mode, log a warning
-    if (process.env["NODE_ENV"] === "development") {
-      console.warn(
-        "Run cancellation is not supported by VercelRSCAssistantProvider.",
-      );
-    }
-  }
-
-  public subscribe(callback: () => void): Unsubscribe {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
-  }
-
-  public onAdapterUpdated() {
-    if (this.useAdapter.getState().adapter !== this.adapter) {
-      this.useAdapter.setState({ adapter: this.adapter });
-    }
-  }
-
-  private updateData = (messages: ThreadMessage[]) => {
-    this.messages = messages;
-    for (const callback of this._subscriptions) callback();
-  };
-
-  unstable_synchronizer = () => {
-    const { adapter } = this.useAdapter();
-
-    useVercelRSCSync(adapter, this.updateData);
-
-    return null;
-  };
-}

package/src/rsc/getVercelRSCMessage.tsx

@@ -1,11 +0,0 @@
-import type { ThreadMessage } from "@assistant-ui/react";
-
-export const symbolInnerRSCMessage = Symbol("innerVercelRSCMessage");
-
-export type VercelRSCThreadMessage<T> = ThreadMessage & {
-  [symbolInnerRSCMessage]?: T;
-};
-
-export const getVercelRSCMessage = <T,>(message: ThreadMessage) => {
-  return (message as VercelRSCThreadMessage<T>)[symbolInnerRSCMessage];
-};

package/src/rsc/index.ts

@@ -1,4 +0,0 @@
-export { useVercelRSCRuntime } from "./useVercelRSCRuntime";
-export { getVercelRSCMessage } from "./getVercelRSCMessage";
-export type { VercelRSCAdapter } from "./VercelRSCAdapter";
-export type { VercelRSCMessage } from "./VercelRSCMessage";

package/src/rsc/useVercelRSCRuntime.tsx

@@ -1,20 +0,0 @@
-"use client";
-
-import { useEffect, useInsertionEffect, useState } from "react";
-import type { VercelRSCAdapter } from "./VercelRSCAdapter";
-import { VercelRSCRuntime } from "./VercelRSCRuntime";
-
-export const useVercelRSCRuntime = <T extends WeakKey>(
-  adapter: VercelRSCAdapter<T>,
-) => {
-  const [runtime] = useState(() => new VercelRSCRuntime(adapter));
-
-  useInsertionEffect(() => {
-    runtime.adapter = adapter;
-  });
-  useEffect(() => {
-    runtime.onAdapterUpdated();
-  });
-
-  return runtime;
-};

package/src/rsc/useVercelRSCSync.tsx

@@ -1,50 +0,0 @@
-import type { ThreadMessage } from "@assistant-ui/react";
-import { useEffect, useMemo } from "react";
-import {
-  type ConverterCallback,
-  ThreadMessageConverter,
-} from "../utils/ThreadMessageConverter";
-import type { VercelRSCAdapter } from "./VercelRSCAdapter";
-import type { VercelRSCMessage } from "./VercelRSCMessage";
-import {
-  type VercelRSCThreadMessage,
-  symbolInnerRSCMessage,
-} from "./getVercelRSCMessage";
-
-const vercelToThreadMessage = <T,>(
-  converter: (message: T) => VercelRSCMessage,
-  rawMessage: T,
-): VercelRSCThreadMessage<T> => {
-  const message = converter(rawMessage);
-
-  return {
-    id: message.id,
-    role: message.role,
-    content: [{ type: "ui", display: message.display }],
-    createdAt: message.createdAt ?? new Date(),
-    ...{ status: "done" },
-    [symbolInnerRSCMessage]: rawMessage,
-  };
-};
-
-type UpdateDataCallback = (messages: ThreadMessage[]) => void;
-
-export const useVercelRSCSync = <T extends WeakKey>(
-  adapter: VercelRSCAdapter<T>,
-  updateData: UpdateDataCallback,
-) => {
-  // flush the converter cache when the convertMessage prop changes
-  const [converter, convertCallback] = useMemo(() => {
-    const rscConverter =
-      adapter.convertMessage ?? ((m: T) => m as VercelRSCMessage);
-    const convertCallback: ConverterCallback<T> = (m, cache) => {
-      if (cache) return cache;
-      return vercelToThreadMessage(rscConverter, m);
-    };
-    return [new ThreadMessageConverter(), convertCallback];
-  }, [adapter.convertMessage]);
-
-  useEffect(() => {
-    updateData(converter.convertMessages(adapter.messages, convertCallback));
-  }, [updateData, converter, convertCallback, adapter.messages]);
-};

package/src/ui/VercelAIRuntime.tsx

@@ -1,169 +0,0 @@
-import type {
-  AssistantRuntime,
-  ReactThreadRuntime,
-  Unsubscribe,
-} from "@assistant-ui/react";
-import type { AppendMessage, ThreadMessage } from "@assistant-ui/react";
-import {
-  MessageRepository,
-  ProxyConfigProvider,
-} from "@assistant-ui/react/internal";
-import type { Message } from "ai";
-import { type StoreApi, type UseBoundStore, create } from "zustand";
-import { getVercelAIMessage } from "./getVercelAIMessage";
-import type { VercelHelpers } from "./utils/VercelHelpers";
-import { sliceMessagesUntil } from "./utils/sliceMessagesUntil";
-import { useVercelAIComposerSync } from "./utils/useVercelAIComposerSync";
-import { useVercelAIThreadSync } from "./utils/useVercelAIThreadSync";
-
-const hasUpcomingMessage = (isRunning: boolean, messages: ThreadMessage[]) => {
-  return isRunning && messages[messages.length - 1]?.role !== "assistant";
-};
-
-export class VercelAIRuntime
-  extends ProxyConfigProvider
-  implements AssistantRuntime, ReactThreadRuntime
-{
-  private _subscriptions = new Set<() => void>();
-  private repository = new MessageRepository();
-  private assistantOptimisticId: string | null = null;
-
-  private useVercel: UseBoundStore<StoreApi<{ vercel: VercelHelpers }>>;
-
-  public messages: ThreadMessage[] = [];
-  public isRunning = false;
-
-  constructor(public vercel: VercelHelpers) {
-    super();
-    this.useVercel = create(() => ({
-      vercel,
-    }));
-  }
-
-  public getBranches(messageId: string): string[] {
-    return this.repository.getBranches(messageId);
-  }
-
-  public switchToBranch(branchId: string): void {
-    this.repository.switchToBranch(branchId);
-    this.updateVercelMessages(this.repository.getMessages());
-  }
-
-  public async append(message: AppendMessage): Promise<void> {
-    // add user message
-    if (message.content.length !== 1 || message.content[0]?.type !== "text")
-      throw new Error("Only text content is supported by Vercel AI SDK.");
-
-    const newMessages = sliceMessagesUntil(
-      this.vercel.messages,
-      message.parentId,
-    );
-    this.vercel.setMessages(newMessages);
-
-    await this.vercel.append({
-      role: "user",
-      content: message.content[0].text,
-    });
-  }
-
-  public async startRun(parentId: string | null): Promise<void> {
-    const reloadMaybe =
-      "reload" in this.vercel ? this.vercel.reload : undefined;
-    if (!reloadMaybe)
-      throw new Error(
-        "Reload is not supported by Vercel AI SDK's useAssistant.",
-      );
-
-    const newMessages = sliceMessagesUntil(this.vercel.messages, parentId);
-    this.vercel.setMessages(newMessages);
-
-    await reloadMaybe();
-  }
-
-  public cancelRun(): void {
-    const previousMessage = this.vercel.messages.at(-1);
-
-    this.vercel.stop();
-
-    if (this.assistantOptimisticId) {
-      this.repository.deleteMessage(this.assistantOptimisticId);
-      this.assistantOptimisticId = null;
-    }
-
-    let messages = this.repository.getMessages();
-    if (
-      previousMessage?.role === "user" &&
-      previousMessage.id === messages.at(-1)?.id // ensure the previous message is a leaf node
-    ) {
-      this.vercel.setInput(previousMessage.content);
-      this.repository.deleteMessage(previousMessage.id);
-
-      messages = this.repository.getMessages();
-    }
-
-    // resync messages
-    setTimeout(() => {
-      this.updateVercelMessages(messages);
-    }, 0);
-  }
-
-  public subscribe(callback: () => void): Unsubscribe {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
-  }
-
-  private updateVercelMessages = (messages: ThreadMessage[]) => {
-    this.vercel.setMessages(
-      messages
-        .flatMap(getVercelAIMessage)
-        .filter((m): m is Message => m != null),
-    );
-  };
-
-  public onVercelUpdated() {
-    if (this.useVercel.getState().vercel !== this.vercel) {
-      this.useVercel.setState({ vercel: this.vercel });
-    }
-  }
-
-  private updateData = (isRunning: boolean, vm: ThreadMessage[]) => {
-    for (let i = 0; i < vm.length; i++) {
-      const message = vm[i]!;
-      const parent = vm[i - 1];
-      this.repository.addOrUpdateMessage(parent?.id ?? null, message);
-    }
-
-    if (this.assistantOptimisticId) {
-      this.repository.deleteMessage(this.assistantOptimisticId);
-      this.assistantOptimisticId = null;
-    }
-
-    if (hasUpcomingMessage(isRunning, vm)) {
-      this.assistantOptimisticId = this.repository.appendOptimisticMessage(
-        vm.at(-1)?.id ?? null,
-        {
-          role: "assistant",
-          content: [{ type: "text", text: "" }],
-        },
-      );
-    }
-
-    this.repository.resetHead(
-      this.assistantOptimisticId ?? vm.at(-1)?.id ?? null,
-    );
-
-    this.messages = this.repository.getMessages();
-    this.isRunning = isRunning;
-
-    for (const callback of this._subscriptions) callback();
-  };
-
-  unstable_synchronizer = () => {
-    const { vercel } = this.useVercel();
-
-    useVercelAIThreadSync(vercel, this.updateData);
-    useVercelAIComposerSync(vercel);
-
-    return null;
-  };
-}

package/src/ui/getVercelAIMessage.tsx

@@ -1,12 +0,0 @@
-import type { ThreadMessage } from "@assistant-ui/react";
-import type { Message } from "ai";
-
-export const symbolInnerAIMessage = Symbol("innerVercelAIUIMessage");
-
-export type VercelAIThreadMessage = ThreadMessage & {
-  [symbolInnerAIMessage]?: Message[];
-};
-
-export const getVercelAIMessage = (message: ThreadMessage) => {
-  return (message as VercelAIThreadMessage)[symbolInnerAIMessage];
-};

package/src/ui/index.ts

@@ -1,3 +0,0 @@
-export { useVercelUseChatRuntime } from "./use-chat/useVercelUseChatRuntime";
-export { useVercelUseAssistantRuntime } from "./use-assistant/useVercelUseAssistantRuntime";
-export { getVercelAIMessage } from "./getVercelAIMessage";

package/src/ui/use-assistant/useVercelUseAssistantRuntime.tsx

@@ -1,18 +0,0 @@
-import type { UseAssistantHelpers } from "@ai-sdk/react";
-import { useEffect, useInsertionEffect, useState } from "react";
-import { VercelAIRuntime } from "../VercelAIRuntime";
-
-export const useVercelUseAssistantRuntime = (
-  assistantHelpers: UseAssistantHelpers,
-) => {
-  const [runtime] = useState(() => new VercelAIRuntime(assistantHelpers));
-
-  useInsertionEffect(() => {
-    runtime.vercel = assistantHelpers;
-  });
-  useEffect(() => {
-    runtime.onVercelUpdated();
-  });
-
-  return runtime;
-};

package/src/ui/use-chat/useVercelUseChatRuntime.tsx

@@ -1,16 +0,0 @@
-import type { UseChatHelpers } from "@ai-sdk/react";
-import { useEffect, useInsertionEffect, useState } from "react";
-import { VercelAIRuntime } from "../VercelAIRuntime";
-
-export const useVercelUseChatRuntime = (chatHelpers: UseChatHelpers) => {
-  const [runtime] = useState(() => new VercelAIRuntime(chatHelpers));
-
-  useInsertionEffect(() => {
-    runtime.vercel = chatHelpers;
-  });
-  useEffect(() => {
-    runtime.onVercelUpdated();
-  });
-
-  return runtime;
-};

package/src/ui/utils/VercelHelpers.tsx

@@ -1,3 +0,0 @@
-import type { UseAssistantHelpers, UseChatHelpers } from "@ai-sdk/react";
-
-export type VercelHelpers = UseChatHelpers | UseAssistantHelpers;

package/src/ui/utils/sliceMessagesUntil.tsx

@@ -1,20 +0,0 @@
-import type { Message } from "ai";
-
-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/useVercelAIComposerSync.tsx

@@ -1,15 +0,0 @@
-import { useThreadContext } from "@assistant-ui/react/experimental";
-import { useEffect } from "react";
-import type { VercelHelpers } from "./VercelHelpers";
-
-// two way sync between vercel helpers input state and composer text state
-export const useVercelAIComposerSync = (vercel: VercelHelpers) => {
-  const { useComposer } = useThreadContext();
-
-  useEffect(() => {
-    useComposer.setState({
-      value: vercel.input,
-      setValue: vercel.setInput,
-    });
-  }, [useComposer, vercel.input, vercel.setInput]);
-};

package/src/ui/utils/useVercelAIThreadSync.tsx

@@ -1,142 +0,0 @@
-import type { TextContentPart, ThreadMessage } from "@assistant-ui/react";
-import type { ToolCallContentPart } from "@assistant-ui/react/experimental";
-import type { Message } from "ai";
-import { useEffect, useMemo } from "react";
-import {
-  type ConverterCallback,
-  ThreadMessageConverter,
-} from "../../utils/ThreadMessageConverter";
-import {
-  type VercelAIThreadMessage,
-  symbolInnerAIMessage,
-} from "../getVercelAIMessage";
-import type { VercelHelpers } from "./VercelHelpers";
-
-const getIsRunning = (vercel: VercelHelpers) => {
-  if ("isLoading" in vercel) return vercel.isLoading;
-  return vercel.status === "in_progress";
-};
-
-const vercelToThreadMessage = (
-  messages: Message[],
-  status: "in_progress" | "done" | "error",
-): VercelAIThreadMessage => {
-  const firstMessage = messages[0];
-  if (!firstMessage) throw new Error("No messages found");
-
-  const common = {
-    id: firstMessage.id,
-    createdAt: firstMessage.createdAt ?? new Date(),
-    [symbolInnerAIMessage]: messages,
-  };
-
-  switch (firstMessage.role) {
-    case "user":
-      if (messages.length > 1) {
-        throw new Error(
-          "Multiple user messages found. This is likely an internal bug in assistant-ui.",
-        );
-      }
-
-      return {
-        ...common,
-        role: "user",
-        content: [{ type: "text", text: firstMessage.content }],
-      };
-    case "assistant":
-      return {
-        ...common,
-        role: "assistant",
-        content: messages.flatMap((message) => [
-          ...(message.content
-            ? [{ type: "text", text: message.content } as TextContentPart]
-            : []),
-          ...(message.toolInvocations?.map(
-            (t) =>
-              ({
-                type: "tool-call",
-                name: t.toolName,
-                args: t.args,
-                result: "result" in t ? t.result : undefined,
-              }) as ToolCallContentPart,
-          ) ?? []),
-        ]),
-        status,
-      };
-    default:
-      throw new Error(
-        `You have a message with an unsupported role. The role ${firstMessage.role} is not supported.`,
-      );
-  }
-};
-
-type Chunk = [Message, ...Message[]];
-const hasItems = (messages: Message[]): messages is Chunk =>
-  messages.length > 0;
-
-const chunkedMessages = (messages: Message[]): Chunk[] => {
-  const chunks: Chunk[] = [];
-  let currentChunk: Message[] = [];
-
-  for (const message of messages) {
-    if (message.role === "assistant") {
-      currentChunk.push(message);
-    } else {
-      if (hasItems(currentChunk)) {
-        chunks.push(currentChunk);
-        currentChunk = [];
-      }
-      chunks.push([message]);
-    }
-  }
-
-  if (hasItems(currentChunk)) {
-    chunks.push(currentChunk);
-  }
-
-  return chunks;
-};
-
-const shallowArrayEqual = (a: unknown[], b: unknown[]) => {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-};
-
-type UpdateDataCallback = (isRunning: boolean, vm: ThreadMessage[]) => void;
-
-export const useVercelAIThreadSync = (
-  vercel: VercelHelpers,
-  updateData: UpdateDataCallback,
-) => {
-  const isRunning = getIsRunning(vercel);
-
-  const converter = useMemo(() => new ThreadMessageConverter(), []);
-
-  useEffect(() => {
-    const lastMessageId = vercel.messages.at(-1)?.id;
-    const convertCallback: ConverterCallback<Chunk> = (messages, cache) => {
-      const status =
-        lastMessageId === messages[0].id && isRunning ? "in_progress" : "done";
-
-      if (
-        cache &&
-        shallowArrayEqual(cache.content, messages) &&
-        (cache.role === "user" || cache.status === status)
-      )
-        return cache;
-
-      return vercelToThreadMessage(messages, status);
-    };
-
-    const messages = converter.convertMessages(
-      chunkedMessages(vercel.messages),
-      convertCallback,
-      (m) => m[0],
-    );
-
-    updateData(isRunning, messages);
-  }, [updateData, isRunning, vercel.messages, converter]);
-};

package/src/utils/ThreadMessageConverter.ts

@@ -1,24 +0,0 @@
-import type { ThreadMessage } from "@assistant-ui/react";
-
-export type ConverterCallback<TIn> = (
-  message: TIn,
-  cache: ThreadMessage | undefined,
-) => ThreadMessage;
-
-export class ThreadMessageConverter {
-  private readonly cache = new WeakMap<WeakKey, ThreadMessage>();
-
-  convertMessages<TIn extends WeakKey>(
-    messages: TIn[],
-    converter: ConverterCallback<TIn>,
-    keyMapper: (m: TIn) => WeakKey = (key) => key,
-  ): ThreadMessage[] {
-    return messages.map((m) => {
-      const key = keyMapper(m);
-      const cached = this.cache.get(key);
-      const newMessage = converter(m, cached);
-      this.cache.set(key, newMessage);
-      return newMessage;
-    });
-  }
-}

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "@assistant-ui/tsconfig/base.json",
-  "compilerOptions": {
-    "paths": {
-      "@assistant-ui/*": ["../../packages/*/src"],
-      "@assistant-ui/react/*": ["../../packages/react/src/*"]
-    }
-  },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules"]
-}