@assistant-ui/react-ai-sdk 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { unstable_ChatModelAdapter, unstable_ChatModelRunOptions, AssistantContentPart, AppendMessage, AssistantRuntime, ReactThreadRuntime, ThreadMessage } from '@assistant-ui/react';
+import { LanguageModel, Message } from 'ai';
+import { ReactNode } from 'react';
+import { UseChatHelpers, UseAssistantHelpers } from '@ai-sdk/react';
+
+declare class VercelModelAdapter implements unstable_ChatModelAdapter {
+    private readonly model;
+    constructor(model: LanguageModel);
+    run({ messages, abortSignal, onUpdate }: unstable_ChatModelRunOptions): Promise<{
+        content: AssistantContentPart[];
+    }>;
+}
+
+type VercelRSCMessage = {
+    id: string;
+    role: "user" | "assistant";
+    display: ReactNode;
+    createdAt?: Date;
+};
+
+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;
+};
+type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
+
+declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> implements AssistantRuntime, ReactThreadRuntime {
+    adapter: VercelRSCAdapter<T>;
+    private useAdapter;
+    private _subscriptions;
+    isRunning: boolean;
+    messages: ThreadMessage[];
+    constructor(adapter: VercelRSCAdapter<T>);
+    private withRunning;
+    getBranches(): readonly string[];
+    switchToBranch(): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): () => void;
+    onAdapterUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => VercelRSCRuntime<T>;
+
+declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
+
+type VercelHelpers = UseChatHelpers | UseAssistantHelpers;
+
+declare class VercelAIRuntime implements AssistantRuntime, ReactThreadRuntime {
+    vercel: VercelHelpers;
+    private _subscriptions;
+    private repository;
+    private assistantOptimisticId;
+    private useVercel;
+    messages: ThreadMessage[];
+    isRunning: boolean;
+    constructor(vercel: VercelHelpers);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): () => void;
+    private updateVercelMessages;
+    onVercelUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelUseChatRuntime: (chatHelpers: UseChatHelpers) => VercelAIRuntime;
+
+declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelAIRuntime;
+
+declare const getVercelAIMessage: (message: ThreadMessage) => Message[] | undefined;
+
+export { type VercelRSCAdapter, type VercelRSCMessage, getVercelAIMessage, getVercelRSCMessage, VercelModelAdapter as unstable_VercelModelAdapter, useVercelRSCRuntime, useVercelUseAssistantRuntime, useVercelUseChatRuntime };

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import { unstable_ChatModelAdapter, unstable_ChatModelRunOptions, AssistantContentPart, AppendMessage, AssistantRuntime, ReactThreadRuntime, ThreadMessage } from '@assistant-ui/react';
+import { LanguageModel, Message } from 'ai';
+import { ReactNode } from 'react';
+import { UseChatHelpers, UseAssistantHelpers } from '@ai-sdk/react';
+
+declare class VercelModelAdapter implements unstable_ChatModelAdapter {
+    private readonly model;
+    constructor(model: LanguageModel);
+    run({ messages, abortSignal, onUpdate }: unstable_ChatModelRunOptions): Promise<{
+        content: AssistantContentPart[];
+    }>;
+}
+
+type VercelRSCMessage = {
+    id: string;
+    role: "user" | "assistant";
+    display: ReactNode;
+    createdAt?: Date;
+};
+
+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;
+};
+type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
+
+declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> implements AssistantRuntime, ReactThreadRuntime {
+    adapter: VercelRSCAdapter<T>;
+    private useAdapter;
+    private _subscriptions;
+    isRunning: boolean;
+    messages: ThreadMessage[];
+    constructor(adapter: VercelRSCAdapter<T>);
+    private withRunning;
+    getBranches(): readonly string[];
+    switchToBranch(): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): () => void;
+    onAdapterUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => VercelRSCRuntime<T>;
+
+declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
+
+type VercelHelpers = UseChatHelpers | UseAssistantHelpers;
+
+declare class VercelAIRuntime implements AssistantRuntime, ReactThreadRuntime {
+    vercel: VercelHelpers;
+    private _subscriptions;
+    private repository;
+    private assistantOptimisticId;
+    private useVercel;
+    messages: ThreadMessage[];
+    isRunning: boolean;
+    constructor(vercel: VercelHelpers);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): () => void;
+    private updateVercelMessages;
+    onVercelUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelUseChatRuntime: (chatHelpers: UseChatHelpers) => VercelAIRuntime;
+
+declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelAIRuntime;
+
+declare const getVercelAIMessage: (message: ThreadMessage) => Message[] | undefined;
+
+export { type VercelRSCAdapter, type VercelRSCMessage, getVercelAIMessage, getVercelRSCMessage, VercelModelAdapter as unstable_VercelModelAdapter, useVercelRSCRuntime, useVercelUseAssistantRuntime, useVercelUseChatRuntime };

package/dist/index.js

@@ -0,0 +1,464 @@
+// src/core/VercelModelAdapter.tsx
+import { streamText } from "ai";
+var VercelModelAdapter = class {
+  constructor(model) {
+    this.model = model;
+  }
+  async run({ messages, abortSignal, onUpdate }) {
+    const { fullStream } = await streamText({
+      model: this.model,
+      abortSignal,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content.filter((c) => c.type !== "ui")
+      }))
+    });
+    const content = [];
+    for await (const aiPart of fullStream) {
+      switch (aiPart.type) {
+        case "text-delta": {
+          let part = content.at(-1);
+          if (!part || part.type !== "text") {
+            part = { type: "text", text: "" };
+            content.push(part);
+          }
+          part.text += aiPart.textDelta;
+          break;
+        }
+        case "tool-call": {
+          content.push({
+            type: "tool-call",
+            name: aiPart.toolName,
+            args: aiPart.args
+          });
+          break;
+        }
+      }
+      onUpdate({ content });
+    }
+    return { content };
+  }
+};
+
+// src/rsc/useVercelRSCRuntime.tsx
+import { useEffect as useEffect2, useInsertionEffect, useState } from "react";
+
+// src/rsc/VercelRSCRuntime.tsx
+import { create } from "zustand";
+
+// src/rsc/useVercelRSCSync.tsx
+import { useEffect, useMemo } from "react";
+
+// src/utils/ThreadMessageConverter.ts
+var ThreadMessageConverter = class {
+  cache = /* @__PURE__ */ new WeakMap();
+  convertMessages(messages, converter, keyMapper = (key) => key) {
+    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;
+    });
+  }
+};
+
+// src/rsc/getVercelRSCMessage.tsx
+var symbolInnerRSCMessage = Symbol("innerVercelRSCMessage");
+var getVercelRSCMessage = (message) => {
+  return message[symbolInnerRSCMessage];
+};
+
+// src/rsc/useVercelRSCSync.tsx
+var vercelToThreadMessage = (converter, rawMessage) => {
+  const message = converter(rawMessage);
+  return {
+    id: message.id,
+    role: message.role,
+    content: [{ type: "ui", display: message.display }],
+    createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
+    ...{ status: "done" },
+    [symbolInnerRSCMessage]: rawMessage
+  };
+};
+var useVercelRSCSync = (adapter, updateData) => {
+  const [converter, convertCallback] = useMemo(() => {
+    const rscConverter = adapter.convertMessage ?? ((m) => m);
+    const convertCallback2 = (m, cache) => {
+      if (cache) return cache;
+      return vercelToThreadMessage(rscConverter, m);
+    };
+    return [new ThreadMessageConverter(), convertCallback2];
+  }, [adapter.convertMessage]);
+  useEffect(() => {
+    updateData(converter.convertMessages(adapter.messages, convertCallback));
+  }, [updateData, converter, convertCallback, adapter.messages]);
+};
+
+// src/rsc/VercelRSCRuntime.tsx
+var EMPTY_BRANCHES = Object.freeze([]);
+var VercelRSCRuntime = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+    this.useAdapter = create(() => ({
+      adapter
+    }));
+  }
+  useAdapter;
+  _subscriptions = /* @__PURE__ */ new Set();
+  isRunning = false;
+  messages = [];
+  withRunning = (callback) => {
+    this.isRunning = true;
+    return callback.finally(() => {
+      this.isRunning = false;
+    });
+  };
+  getBranches() {
+    return EMPTY_BRANCHES;
+  }
+  switchToBranch() {
+    throw new Error(
+      "Branch switching is not supported by VercelRSCAssistantProvider."
+    );
+  }
+  async append(message) {
+    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));
+    }
+  }
+  async startRun(parentId) {
+    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() {
+    if (process.env["NODE_ENV"] === "development") {
+      console.warn(
+        "Run cancellation is not supported by VercelRSCAssistantProvider."
+      );
+    }
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  onAdapterUpdated() {
+    if (this.useAdapter.getState().adapter !== this.adapter) {
+      this.useAdapter.setState({ adapter: this.adapter });
+    }
+  }
+  updateData = (messages) => {
+    this.messages = messages;
+    for (const callback of this._subscriptions) callback();
+  };
+  unstable_synchronizer = () => {
+    const { adapter } = this.useAdapter();
+    useVercelRSCSync(adapter, this.updateData);
+    return null;
+  };
+};
+
+// src/rsc/useVercelRSCRuntime.tsx
+var useVercelRSCRuntime = (adapter) => {
+  const [runtime] = useState(() => new VercelRSCRuntime(adapter));
+  useInsertionEffect(() => {
+    runtime.adapter = adapter;
+  });
+  useEffect2(() => {
+    runtime.onAdapterUpdated();
+  });
+  return runtime;
+};
+
+// src/ui/use-chat/useVercelUseChatRuntime.tsx
+import { useEffect as useEffect5, useInsertionEffect as useInsertionEffect2, useState as useState2 } from "react";
+
+// src/ui/VercelAIRuntime.tsx
+import {
+  unstable_MessageRepository as MessageRepository
+} from "@assistant-ui/react";
+import { create as create2 } from "zustand";
+
+// src/ui/getVercelAIMessage.tsx
+var symbolInnerAIMessage = Symbol("innerVercelAIUIMessage");
+var getVercelAIMessage = (message) => {
+  return message[symbolInnerAIMessage];
+};
+
+// src/ui/utils/sliceMessagesUntil.tsx
+var sliceMessagesUntil = (messages, messageId) => {
+  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);
+};
+
+// src/ui/utils/useVercelAIComposerSync.tsx
+import { unstable_useThreadContext as useThreadContext } from "@assistant-ui/react";
+import { useEffect as useEffect3 } from "react";
+var useVercelAIComposerSync = (vercel) => {
+  const { useComposer } = useThreadContext();
+  useEffect3(() => {
+    useComposer.setState({
+      value: vercel.input,
+      setValue: vercel.setInput
+    });
+  }, [useComposer, vercel.input, vercel.setInput]);
+};
+
+// src/ui/utils/useVercelAIThreadSync.tsx
+import { useEffect as useEffect4, useMemo as useMemo2 } from "react";
+var getIsRunning = (vercel) => {
+  if ("isLoading" in vercel) return vercel.isLoading;
+  return vercel.status === "in_progress";
+};
+var vercelToThreadMessage2 = (messages, status) => {
+  const firstMessage = messages[0];
+  if (!firstMessage) throw new Error("No messages found");
+  const common = {
+    id: firstMessage.id,
+    createdAt: firstMessage.createdAt ?? /* @__PURE__ */ 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 }] : [],
+          ...message.toolInvocations?.map(
+            (t) => ({
+              type: "tool-call",
+              name: t.toolName,
+              args: t.args,
+              result: "result" in t ? t.result : void 0
+            })
+          ) ?? []
+        ]),
+        status
+      };
+    default:
+      throw new Error(
+        `You have a message with an unsupported role. The role ${firstMessage.role} is not supported.`
+      );
+  }
+};
+var hasItems = (messages) => messages.length > 0;
+var chunkedMessages = (messages) => {
+  const chunks = [];
+  let currentChunk = [];
+  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;
+};
+var shallowArrayEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+};
+var useVercelAIThreadSync = (vercel, updateData) => {
+  const isRunning = getIsRunning(vercel);
+  const converter = useMemo2(() => new ThreadMessageConverter(), []);
+  useEffect4(() => {
+    const lastMessageId = vercel.messages.at(-1)?.id;
+    const convertCallback = (messages2, cache) => {
+      const status = lastMessageId === messages2[0].id && isRunning ? "in_progress" : "done";
+      if (cache && shallowArrayEqual(cache.content, messages2) && (cache.role === "user" || cache.status === status))
+        return cache;
+      return vercelToThreadMessage2(messages2, status);
+    };
+    const messages = converter.convertMessages(
+      chunkedMessages(vercel.messages),
+      convertCallback,
+      (m) => m[0]
+    );
+    updateData(isRunning, messages);
+  }, [updateData, isRunning, vercel.messages, converter]);
+};
+
+// src/ui/VercelAIRuntime.tsx
+var hasUpcomingMessage = (isRunning, messages) => {
+  return isRunning && messages[messages.length - 1]?.role !== "assistant";
+};
+var VercelAIRuntime = class {
+  constructor(vercel) {
+    this.vercel = vercel;
+    this.useVercel = create2(() => ({
+      vercel
+    }));
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  repository = new MessageRepository();
+  assistantOptimisticId = null;
+  useVercel;
+  messages = [];
+  isRunning = false;
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.updateVercelMessages(this.repository.getMessages());
+  }
+  async append(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
+    });
+  }
+  async startRun(parentId) {
+    const reloadMaybe = "reload" in this.vercel ? this.vercel.reload : void 0;
+    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();
+  }
+  cancelRun() {
+    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) {
+      this.vercel.setInput(previousMessage.content);
+      this.repository.deleteMessage(previousMessage.id);
+      messages = this.repository.getMessages();
+    }
+    setTimeout(() => {
+      this.updateVercelMessages(messages);
+    }, 0);
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  updateVercelMessages = (messages) => {
+    this.vercel.setMessages(
+      messages.flatMap(getVercelAIMessage).filter((m) => m != null)
+    );
+  };
+  onVercelUpdated() {
+    if (this.useVercel.getState().vercel !== this.vercel) {
+      this.useVercel.setState({ vercel: this.vercel });
+    }
+  }
+  updateData = (isRunning, vm) => {
+    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;
+  };
+};
+
+// src/ui/use-chat/useVercelUseChatRuntime.tsx
+var useVercelUseChatRuntime = (chatHelpers) => {
+  const [runtime] = useState2(() => new VercelAIRuntime(chatHelpers));
+  useInsertionEffect2(() => {
+    runtime.vercel = chatHelpers;
+  });
+  useEffect5(() => {
+    runtime.onVercelUpdated();
+  });
+  return runtime;
+};
+
+// src/ui/use-assistant/useVercelUseAssistantRuntime.tsx
+import { useEffect as useEffect6, useInsertionEffect as useInsertionEffect3, useState as useState3 } from "react";
+var useVercelUseAssistantRuntime = (assistantHelpers) => {
+  const [runtime] = useState3(() => new VercelAIRuntime(assistantHelpers));
+  useInsertionEffect3(() => {
+    runtime.vercel = assistantHelpers;
+  });
+  useEffect6(() => {
+    runtime.onVercelUpdated();
+  });
+  return runtime;
+};
+export {
+  getVercelAIMessage,
+  getVercelRSCMessage,
+  VercelModelAdapter as unstable_VercelModelAdapter,
+  useVercelRSCRuntime,
+  useVercelUseAssistantRuntime,
+  useVercelUseChatRuntime
+};
+//# sourceMappingURL=index.js.map