@assistant-ui/react-ai-sdk 0.5.15 → 0.6.0

package/dist/index.mjs

@@ -40,80 +40,56 @@ var getVercelRSCMessage = (message) => {
   return getExternalStoreMessage(message);
 };
 
-// src/ui/use-chat/useVercelUseChatRuntime.tsx
-import { useEffect as useEffect3, useInsertionEffect, useState } from "react";
-
-// src/ui/use-chat/VercelUseChatRuntime.tsx
-import { INTERNAL as INTERNAL2 } from "@assistant-ui/react";
-
-// src/ui/use-chat/VercelUseChatThreadRuntime.tsx
-import {
-  INTERNAL
-} from "@assistant-ui/react";
-import { create } 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++;
+// src/ui/utils/useCachedChunkedMessages.ts
+import { useMemo } from "react";
+var hasItems = (messages) => messages.length > 0;
+var chunkedMessages = (messages) => {
+  const chunks = [];
+  let currentChunk = [];
+  for (const message of messages) {
+    if (message.role === "assistant" || message.role === "data") {
+      currentChunk.push(message);
+    } else {
+      if (hasItems(currentChunk)) {
+        chunks.push(currentChunk);
+        currentChunk = [];
+      }
+      chunks.push([message]);
+    }
   }
-  return messages.slice(0, messageIdx + 1);
+  if (hasItems(currentChunk)) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
 };
-
-// src/ui/utils/useVercelAIComposerSync.tsx
-import { useThreadContext } from "@assistant-ui/react";
-import { useEffect } from "react";
-var useVercelAIComposerSync = (vercel) => {
-  const { useComposer } = useThreadContext();
-  useEffect(() => {
-    useComposer.setState({
-      value: vercel.input,
-      setValue: vercel.setInput
-    });
-  }, [useComposer, vercel.input, vercel.setInput]);
+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;
 };
-
-// src/ui/utils/useVercelAIThreadSync.tsx
-import { useEffect as useEffect2, 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;
+var useCachedChunkedMessages = (messages) => {
+  const cache = useMemo(() => /* @__PURE__ */ new WeakMap(), []);
+  return useMemo(() => {
+    return chunkedMessages(messages).map((m) => {
+      const key = m[0];
+      if (!key) return m;
+      const cached = cache.get(key);
+      if (cached && shallowArrayEqual(cached, m)) return cached;
+      cache.set(key, m);
+      return m;
     });
-  }
+  }, [messages, cache]);
 };
 
-// src/ui/utils/useVercelAIThreadSync.tsx
-var getIsRunning = (vercel) => {
-  if ("isLoading" in vercel) return vercel.isLoading;
-  return vercel.status === "in_progress";
-};
-var vercelToThreadMessage2 = (messages, status) => {
+// src/ui/utils/convertMessage.ts
+var convertMessage = (messages) => {
   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
+    createdAt: firstMessage.createdAt ?? /* @__PURE__ */ new Date()
   };
   switch (firstMessage.role) {
     case "user":
@@ -153,8 +129,7 @@ var vercelToThreadMessage2 = (messages, status) => {
             ) ?? [],
             ...typeof message.data === "object" && !Array.isArray(message.data) && message.data?.["type"] === "tool-call" ? [message.data] : []
           ];
-        }),
-        status
+        })
       };
       for (const message of messages) {
         if (typeof message.data === "object" && !Array.isArray(message.data) && message.data?.["type"] === "tool-result") {
@@ -175,369 +150,137 @@ var vercelToThreadMessage2 = (messages, status) => {
       );
   }
 };
-var hasItems = (messages) => messages.length > 0;
-var chunkedMessages = (messages) => {
-  const chunks = [];
-  let currentChunk = [];
-  for (const message of messages) {
-    if (message.role === "assistant" || message.role === "data") {
-      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 = useMemo(() => new ThreadMessageConverter(), []);
-  useEffect2(() => {
-    const lastMessageId = vercel.messages.at(-1)?.id;
-    const convertCallback = (messages2, cache) => {
-      const status = lastMessageId === messages2[0].id && isRunning ? {
-        type: "running"
-      } : {
-        type: "complete",
-        reason: "unknown"
-      };
-      if (cache && shallowArrayEqual(cache.content, messages2) && (cache.role !== "assistant" || cache.status.type === status.type))
-        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/use-chat/VercelUseChatThreadRuntime.tsx
-var { MessageRepository } = INTERNAL;
-var hasUpcomingMessage = (isRunning, messages) => {
-  return isRunning && messages[messages.length - 1]?.role !== "assistant";
-};
-var CAPABILITIES = Object.freeze({
-  switchToBranch: true,
-  edit: true,
-  reload: true,
-  cancel: true,
-  copy: true
-});
-var VercelUseChatThreadRuntime = class {
-  constructor(vercel) {
-    this.vercel = vercel;
-    this.useVercel = create(() => ({
-      vercel
-    }));
-  }
-  _subscriptions = /* @__PURE__ */ new Set();
-  repository = new MessageRepository();
-  assistantOptimisticId = null;
-  useVercel;
-  capabilities = CAPABILITIES;
-  messages = [];
-  isDisabled = 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 VercelUseChatRuntime. Use the Edge runtime for image support."
-      );
-    const newMessages = sliceMessagesUntil(
-      this.vercel.messages,
-      message.parentId
-    );
-    this.vercel.setMessages(newMessages);
-    await this.vercel.append({
-      role: message.role,
-      content: message.content[0].text
-    });
-  }
-  async startRun(parentId) {
-    const newMessages = sliceMessagesUntil(this.vercel.messages, parentId);
-    this.vercel.setMessages(newMessages);
-    await this.vercel.reload();
-  }
-  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: []
-        }
-      );
-    }
-    this.repository.resetHead(
-      this.assistantOptimisticId ?? vm.at(-1)?.id ?? null
-    );
-    this.messages = this.repository.getMessages();
-    for (const callback of this._subscriptions) callback();
-  };
-  unstable_synchronizer = () => {
-    const { vercel } = this.useVercel();
-    useVercelAIThreadSync(vercel, this.updateData);
-    useVercelAIComposerSync(vercel);
-    return null;
-  };
-  addToolResult({ toolCallId, result }) {
-    this.vercel.addToolResult({ toolCallId, result });
-  }
-};
-
-// src/ui/use-chat/VercelUseChatRuntime.tsx
-var { ProxyConfigProvider, BaseAssistantRuntime } = INTERNAL2;
-var VercelUseChatRuntime = class extends BaseAssistantRuntime {
-  _proxyConfigProvider = new ProxyConfigProvider();
-  constructor(vercel) {
-    super(new VercelUseChatThreadRuntime(vercel));
-  }
-  set vercel(vercel) {
-    this.thread.vercel = vercel;
-  }
-  onVercelUpdated() {
-    return this.thread.onVercelUpdated();
-  }
-  getModelConfig() {
-    return this._proxyConfigProvider.getModelConfig();
-  }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
-  }
-  switchToThread(threadId) {
-    if (threadId) {
-      throw new Error(
-        "VercelAIRuntime does not yet support switching threads."
-      );
-    }
-    this.thread.vercel.messages = [];
-    this.thread.vercel.input = "";
-    this.thread.vercel.setMessages([]);
-    this.thread.vercel.setInput("");
-    this.thread = new VercelUseChatThreadRuntime(this.thread.vercel);
-  }
-};
 
 // src/ui/use-chat/useVercelUseChatRuntime.tsx
-var useVercelUseChatRuntime = (chatHelpers) => {
-  const [runtime] = useState(() => new VercelUseChatRuntime(chatHelpers));
-  useInsertionEffect(() => {
-    runtime.vercel = chatHelpers;
-  });
-  useEffect3(() => {
-    runtime.onVercelUpdated();
-  });
-  return runtime;
-};
-
-// src/ui/use-assistant/useVercelUseAssistantRuntime.tsx
-import { useEffect as useEffect4, useInsertionEffect as useInsertionEffect2, useState as useState2 } from "react";
+import { useExternalStoreRuntime as useExternalStoreRuntime2 } from "@assistant-ui/react";
 
-// src/ui/use-assistant/VercelUseAssistantRuntime.tsx
+// src/ui/utils/useInputSync.tsx
+import { useRef, useEffect } from "react";
 import {
-  INTERNAL as INTERNAL3
+  subscribeToMainThread
 } from "@assistant-ui/react";
-
-// src/ui/use-assistant/VercelUseAssistantThreadRuntime.tsx
-import { create as create2 } from "zustand";
-var EMPTY_BRANCHES = Object.freeze([]);
-var CAPABILITIES2 = Object.freeze({
-  switchToBranch: false,
-  edit: false,
-  reload: false,
-  cancel: false,
-  copy: true
-});
-var VercelUseAssistantThreadRuntime = class {
-  constructor(vercel) {
-    this.vercel = vercel;
-    this.useVercel = create2(() => ({
-      vercel
-    }));
-  }
-  _subscriptions = /* @__PURE__ */ new Set();
-  capabilities = CAPABILITIES2;
-  useVercel;
-  messages = [];
-  isDisabled = false;
-  getBranches() {
-    return EMPTY_BRANCHES;
-  }
-  switchToBranch() {
-    throw new Error(
-      "VercelUseAssistantRuntime does not support switching branches."
-    );
-  }
-  async append(message) {
-    if (message.role !== "user")
-      throw new Error(
-        "Only appending user messages are supported in VercelUseAssistantRuntime. This is likely an internal bug in assistant-ui."
-      );
-    if (message.content.length !== 1 || message.content[0]?.type !== "text")
-      throw new Error("VercelUseAssistantRuntime only supports text content.");
-    if (message.parentId !== (this.messages.at(-1)?.id ?? null))
-      throw new Error(
-        "VercelUseAssistantRuntime does not support editing messages."
-      );
-    await this.vercel.append({
-      role: "user",
-      content: message.content[0].text
-    });
-  }
-  async startRun() {
-    throw new Error("VercelUseAssistantRuntime does not support reloading.");
-  }
-  cancelRun() {
-    const previousMessage = this.vercel.messages.at(-1);
-    this.vercel.stop();
-    if (previousMessage?.role === "user") {
-      this.vercel.setInput(previousMessage.content);
-    }
-  }
-  subscribe(callback) {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
-  }
-  onVercelUpdated() {
-    if (this.useVercel.getState().vercel !== this.vercel) {
-      this.useVercel.setState({ vercel: this.vercel });
-    }
-  }
-  updateData = (isRunning, vm) => {
-    if (hasUpcomingMessage2(isRunning, vm)) {
-      vm.push({
-        id: "__optimistic__result",
-        createdAt: /* @__PURE__ */ new Date(),
-        status: { type: "running" },
-        role: "assistant",
-        content: []
-      });
+var useInputSync = (helpers, runtime) => {
+  const helpersRef = useRef(helpers);
+  useEffect(() => {
+    helpersRef.current = helpers;
+    if (runtime.thread.composer.text !== helpers.input) {
+      runtime.thread.composer.setText(helpers.input);
     }
-    this.messages = vm;
-    for (const callback of this._subscriptions) callback();
-  };
-  unstable_synchronizer = () => {
-    const { vercel } = this.useVercel();
-    useVercelAIThreadSync(vercel, this.updateData);
-    useVercelAIComposerSync(vercel);
-    return null;
-  };
-  addToolResult() {
+  }, [helpers, runtime]);
+  useEffect(() => {
+    return subscribeToMainThread(runtime, () => {
+      if (runtime.thread.composer.text !== helpersRef.current.input) {
+        helpersRef.current.setInput(runtime.thread.composer.text);
+      }
+    });
+  }, [runtime]);
+};
+
+// 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(
-      "VercelUseAssistantRuntime does not support adding tool results."
+      "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/use-assistant/VercelUseAssistantRuntime.tsx
-var { ProxyConfigProvider: ProxyConfigProvider2, BaseAssistantRuntime: BaseAssistantRuntime2 } = INTERNAL3;
-var hasUpcomingMessage2 = (isRunning, messages) => {
-  return isRunning && messages[messages.length - 1]?.role !== "assistant";
-};
-var VercelUseAssistantRuntime = class extends BaseAssistantRuntime2 {
-  _proxyConfigProvider = new ProxyConfigProvider2();
-  constructor(vercel) {
-    super(new VercelUseAssistantThreadRuntime(vercel));
-  }
-  set vercel(vercel) {
-    this.thread.vercel = vercel;
-  }
-  onVercelUpdated() {
-    return this.thread.onVercelUpdated();
-  }
-  getModelConfig() {
-    return this._proxyConfigProvider.getModelConfig();
-  }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
-  }
-  switchToThread(threadId) {
-    if (threadId) {
-      throw new Error("VercelAIRuntime does not yet support switching threads");
-    }
-    this.thread.vercel.messages = [];
-    this.thread.vercel.input = "";
-    this.thread.vercel.setMessages([]);
-    this.thread.vercel.setInput("");
-    this.thread = new VercelUseAssistantThreadRuntime(this.thread.vercel);
-  }
+// src/ui/use-chat/useVercelUseChatRuntime.tsx
+var useVercelUseChatRuntime = (chatHelpers) => {
+  const messages = useCachedChunkedMessages(chatHelpers.messages);
+  const runtime = useExternalStoreRuntime2({
+    isRunning: chatHelpers.isLoading,
+    messages,
+    setMessages: (messages2) => chatHelpers.setMessages(messages2.flat()),
+    onCancel: async () => chatHelpers.stop(),
+    onNew: async (message) => {
+      if (message.content.length !== 1 || message.content[0]?.type !== "text")
+        throw new Error(
+          "Only text content is supported by VercelUseChatRuntime. Use the Edge runtime for image support."
+        );
+      await chatHelpers.append({
+        role: message.role,
+        content: message.content[0].text
+      });
+    },
+    onEdit: async (message) => {
+      if (message.content.length !== 1 || message.content[0]?.type !== "text")
+        throw new Error(
+          "Only text content is supported by VercelUseChatRuntime. Use the Edge runtime for image support."
+        );
+      const newMessages = sliceMessagesUntil(
+        chatHelpers.messages,
+        message.parentId
+      );
+      chatHelpers.setMessages(newMessages);
+      await chatHelpers.append({
+        role: message.role,
+        content: message.content[0].text
+      });
+    },
+    onReload: async (parentId) => {
+      const newMessages = sliceMessagesUntil(chatHelpers.messages, parentId);
+      chatHelpers.setMessages(newMessages);
+      await chatHelpers.reload();
+    },
+    onAddToolResult: ({ toolCallId, result }) => {
+      chatHelpers.addToolResult({ toolCallId, result });
+    },
+    // onCopy // TODO
+    onNewThread: () => {
+      chatHelpers.messages = [];
+      chatHelpers.input = "";
+      chatHelpers.setMessages([]);
+      chatHelpers.setInput("");
+    },
+    convertMessage
+  });
+  useInputSync(chatHelpers, runtime);
+  return runtime;
 };
 
 // src/ui/use-assistant/useVercelUseAssistantRuntime.tsx
+import { useExternalStoreRuntime as useExternalStoreRuntime3 } from "@assistant-ui/react";
 var useVercelUseAssistantRuntime = (assistantHelpers) => {
-  const [runtime] = useState2(
-    () => new VercelUseAssistantRuntime(assistantHelpers)
-  );
-  useInsertionEffect2(() => {
-    runtime.vercel = assistantHelpers;
-  });
-  useEffect4(() => {
-    runtime.onVercelUpdated();
+  const messages = useCachedChunkedMessages(assistantHelpers.messages);
+  const runtime = useExternalStoreRuntime3({
+    isRunning: assistantHelpers.status === "in_progress",
+    messages,
+    onCancel: async () => assistantHelpers.stop(),
+    onNew: async (message) => {
+      if (message.content.length !== 1 || message.content[0]?.type !== "text")
+        throw new Error(
+          "VercelUseAssistantRuntime only supports text content."
+        );
+      await assistantHelpers.append({
+        role: message.role,
+        content: message.content[0].text
+      });
+    },
+    onNewThread: () => {
+      assistantHelpers.messages = [];
+      assistantHelpers.input = "";
+      assistantHelpers.setMessages([]);
+      assistantHelpers.setInput("");
+    },
+    convertMessage
   });
+  useInputSync(assistantHelpers, runtime);
   return runtime;
 };
+
+// src/ui/getVercelAIMessage.tsx
+import {
+  getExternalStoreMessage as getExternalStoreMessage2
+} from "@assistant-ui/react";
+var getVercelAIMessage = (message) => {
+  return getExternalStoreMessage2(message);
+};
 export {
   getVercelAIMessage,
   getVercelRSCMessage,