@assistant-ui/react-ai-sdk 0.2.1 → 0.2.3

package/dist/index.d.mts

@@ -31,8 +31,8 @@ type VercelRSCAdapterBase<T> = {
 };
 type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
 
-declare const BaseAssistantRuntime$1: typeof INTERNAL.BaseAssistantRuntime;
-declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> extends BaseAssistantRuntime$1<VercelRSCThreadRuntime<T>> {
+declare const BaseAssistantRuntime$2: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> extends BaseAssistantRuntime$2<VercelRSCThreadRuntime<T>> {
     private readonly _proxyConfigProvider;
     constructor(adapter: VercelRSCAdapter<T>);
     set adapter(adapter: VercelRSCAdapter<T>);
@@ -65,27 +65,15 @@ declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter
 
 declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
 
-type VercelHelpers = ReturnType<typeof useChat> | UseAssistantHelpers;
-
-declare const BaseAssistantRuntime: typeof INTERNAL.BaseAssistantRuntime;
-declare class VercelAIRuntime extends BaseAssistantRuntime<VercelAIThreadRuntime> {
-    private readonly _proxyConfigProvider;
-    constructor(vercel: VercelHelpers);
-    set vercel(vercel: VercelHelpers);
-    onVercelUpdated(): void;
-    getModelConfig(): _assistant_ui_react.ModelConfig;
-    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
-    switchToThread(threadId: string | null): void;
-}
-declare class VercelAIThreadRuntime implements ReactThreadRuntime {
-    vercel: VercelHelpers;
+declare class VercelUseChatThreadRuntime implements ReactThreadRuntime {
+    vercel: ReturnType<typeof useChat>;
     private _subscriptions;
     private repository;
     private assistantOptimisticId;
     private useVercel;
     messages: ThreadMessage[];
     isRunning: boolean;
-    constructor(vercel: VercelHelpers);
+    constructor(vercel: ReturnType<typeof useChat>);
     getBranches(messageId: string): string[];
     switchToBranch(branchId: string): void;
     append(message: AppendMessage): Promise<void>;
@@ -99,9 +87,50 @@ declare class VercelAIThreadRuntime implements ReactThreadRuntime {
     addToolResult(toolCallId: string, result: any): void;
 }
 
-declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => VercelAIRuntime;
+declare const BaseAssistantRuntime$1: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelUseChatRuntime extends BaseAssistantRuntime$1<VercelUseChatThreadRuntime> {
+    private readonly _proxyConfigProvider;
+    constructor(vercel: ReturnType<typeof useChat>);
+    set vercel(vercel: ReturnType<typeof useChat>);
+    onVercelUpdated(): void;
+    getModelConfig(): _assistant_ui_react.ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+    switchToThread(threadId: string | null): void;
+}
+
+declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => VercelUseChatRuntime;
+
+declare class VercelUseAssistantThreadRuntime implements ReactThreadRuntime {
+    vercel: UseAssistantHelpers;
+    private _subscriptions;
+    private useVercel;
+    messages: readonly ThreadMessage[];
+    isRunning: boolean;
+    constructor(vercel: UseAssistantHelpers);
+    getBranches(): readonly string[];
+    switchToBranch(): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    onVercelUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+    addToolResult(): void;
+}
+
+declare const BaseAssistantRuntime: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelUseAssistantRuntime extends BaseAssistantRuntime<VercelUseAssistantThreadRuntime> {
+    private readonly _proxyConfigProvider;
+    constructor(vercel: UseAssistantHelpers);
+    set vercel(vercel: UseAssistantHelpers);
+    onVercelUpdated(): void;
+    getModelConfig(): _assistant_ui_react.ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+    switchToThread(threadId: string | null): void;
+}
 
-declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelAIRuntime;
+declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelUseAssistantRuntime;
 
 declare const getVercelAIMessage: (message: ThreadMessage) => Message[] | undefined;
 

package/dist/index.d.ts

@@ -31,8 +31,8 @@ type VercelRSCAdapterBase<T> = {
 };
 type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
 
-declare const BaseAssistantRuntime$1: typeof INTERNAL.BaseAssistantRuntime;
-declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> extends BaseAssistantRuntime$1<VercelRSCThreadRuntime<T>> {
+declare const BaseAssistantRuntime$2: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> extends BaseAssistantRuntime$2<VercelRSCThreadRuntime<T>> {
     private readonly _proxyConfigProvider;
     constructor(adapter: VercelRSCAdapter<T>);
     set adapter(adapter: VercelRSCAdapter<T>);
@@ -65,27 +65,15 @@ declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter
 
 declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
 
-type VercelHelpers = ReturnType<typeof useChat> | UseAssistantHelpers;
-
-declare const BaseAssistantRuntime: typeof INTERNAL.BaseAssistantRuntime;
-declare class VercelAIRuntime extends BaseAssistantRuntime<VercelAIThreadRuntime> {
-    private readonly _proxyConfigProvider;
-    constructor(vercel: VercelHelpers);
-    set vercel(vercel: VercelHelpers);
-    onVercelUpdated(): void;
-    getModelConfig(): _assistant_ui_react.ModelConfig;
-    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
-    switchToThread(threadId: string | null): void;
-}
-declare class VercelAIThreadRuntime implements ReactThreadRuntime {
-    vercel: VercelHelpers;
+declare class VercelUseChatThreadRuntime implements ReactThreadRuntime {
+    vercel: ReturnType<typeof useChat>;
     private _subscriptions;
     private repository;
     private assistantOptimisticId;
     private useVercel;
     messages: ThreadMessage[];
     isRunning: boolean;
-    constructor(vercel: VercelHelpers);
+    constructor(vercel: ReturnType<typeof useChat>);
     getBranches(messageId: string): string[];
     switchToBranch(branchId: string): void;
     append(message: AppendMessage): Promise<void>;
@@ -99,9 +87,50 @@ declare class VercelAIThreadRuntime implements ReactThreadRuntime {
     addToolResult(toolCallId: string, result: any): void;
 }
 
-declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => VercelAIRuntime;
+declare const BaseAssistantRuntime$1: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelUseChatRuntime extends BaseAssistantRuntime$1<VercelUseChatThreadRuntime> {
+    private readonly _proxyConfigProvider;
+    constructor(vercel: ReturnType<typeof useChat>);
+    set vercel(vercel: ReturnType<typeof useChat>);
+    onVercelUpdated(): void;
+    getModelConfig(): _assistant_ui_react.ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+    switchToThread(threadId: string | null): void;
+}
+
+declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => VercelUseChatRuntime;
+
+declare class VercelUseAssistantThreadRuntime implements ReactThreadRuntime {
+    vercel: UseAssistantHelpers;
+    private _subscriptions;
+    private useVercel;
+    messages: readonly ThreadMessage[];
+    isRunning: boolean;
+    constructor(vercel: UseAssistantHelpers);
+    getBranches(): readonly string[];
+    switchToBranch(): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    onVercelUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+    addToolResult(): void;
+}
+
+declare const BaseAssistantRuntime: typeof INTERNAL.BaseAssistantRuntime;
+declare class VercelUseAssistantRuntime extends BaseAssistantRuntime<VercelUseAssistantThreadRuntime> {
+    private readonly _proxyConfigProvider;
+    constructor(vercel: UseAssistantHelpers);
+    set vercel(vercel: UseAssistantHelpers);
+    onVercelUpdated(): void;
+    getModelConfig(): _assistant_ui_react.ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+    switchToThread(threadId: string | null): void;
+}
 
-declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelAIRuntime;
+declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelUseAssistantRuntime;
 
 declare const getVercelAIMessage: (message: ThreadMessage) => Message[] | undefined;
 

package/dist/index.js

@@ -303,9 +303,12 @@ var useVercelRSCRuntime = (adapter) => {
 };
 
 // src/ui/use-chat/useVercelUseChatRuntime.tsx
-var import_react8 = require("react");
+var import_react9 = require("react");
+
+// src/ui/use-chat/VercelUseChatRuntime.tsx
+var import_react8 = require("@assistant-ui/react");
 
-// src/ui/VercelAIRuntime.tsx
+// src/ui/use-chat/VercelUseChatThreadRuntime.tsx
 var import_react7 = require("@assistant-ui/react");
 var import_zustand2 = require("zustand");
 
@@ -368,27 +371,43 @@ var vercelToThreadMessage2 = (messages, status) => {
         role: "user",
         content: [{ type: "text", text: firstMessage.content }]
       };
-    case "assistant":
-      return {
+    case "data":
+    case "assistant": {
+      const res = {
         ...common,
         role: "assistant",
-        content: messages.flatMap((message) => [
-          ...message.content ? [{ type: "text", text: message.content }] : [],
-          ...message.toolInvocations?.map(
-            (t) => ({
-              type: "tool-call",
-              toolName: t.toolName,
-              toolCallId: t.toolCallId,
-              args: t.args,
-              result: "result" in t ? t.result : void 0
-            })
-          ) ?? []
-        ]),
+        content: messages.flatMap((message) => {
+          return [
+            ...message.content ? [{ type: "text", text: message.content }] : [],
+            ...message.toolInvocations?.map(
+              (t) => ({
+                type: "tool-call",
+                toolName: t.toolName,
+                toolCallId: t.toolCallId,
+                args: t.args,
+                result: "result" in t ? t.result : void 0
+              })
+            ) ?? [],
+            ...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") {
+          const toolCallId = message.data["toolCallId"];
+          const toolContent = res.content.find(
+            (c) => c.type === "tool-call" && c.toolCallId === toolCallId
+          );
+          if (!toolContent) throw new Error("Tool call not found");
+          toolContent.result = message.data["result"];
+        }
+      }
+      return res;
+    }
     default:
       throw new Error(
-        `You have a message with an unsupported role. The role ${firstMessage.role} is not supported.`
+        `123 You have a message with an unsupported role. The role ${firstMessage.role} is not supported.`
       );
   }
 };
@@ -397,7 +416,7 @@ var chunkedMessages = (messages) => {
   const chunks = [];
   let currentChunk = [];
   for (const message of messages) {
-    if (message.role === "assistant") {
+    if (message.role === "assistant" || message.role === "data") {
       currentChunk.push(message);
     } else {
       if (hasItems(currentChunk)) {
@@ -439,40 +458,12 @@ var useVercelAIThreadSync = (vercel, updateData) => {
   }, [updateData, isRunning, vercel.messages, converter]);
 };
 
-// src/ui/VercelAIRuntime.tsx
-var { ProxyConfigProvider: ProxyConfigProvider2, MessageRepository, BaseAssistantRuntime: BaseAssistantRuntime2 } = import_react7.INTERNAL;
+// src/ui/use-chat/VercelUseChatThreadRuntime.tsx
+var { MessageRepository } = import_react7.INTERNAL;
 var hasUpcomingMessage = (isRunning, messages) => {
   return isRunning && messages[messages.length - 1]?.role !== "assistant";
 };
-var VercelAIRuntime = class extends BaseAssistantRuntime2 {
-  _proxyConfigProvider = new ProxyConfigProvider2();
-  constructor(vercel) {
-    super(new VercelAIThreadRuntime(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 VercelAIThreadRuntime(this.thread.vercel);
-  }
-};
-var VercelAIThreadRuntime = class {
+var VercelUseChatThreadRuntime = class {
   constructor(vercel) {
     this.vercel = vercel;
     this.useVercel = (0, import_zustand2.create)(() => ({
@@ -494,7 +485,9 @@ var VercelAIThreadRuntime = class {
   }
   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.");
+      throw new Error(
+        "Only text content is supported by VercelUseChatRuntime."
+      );
     const newMessages = sliceMessagesUntil(
       this.vercel.messages,
       message.parentId
@@ -506,14 +499,9 @@ var VercelAIThreadRuntime = class {
     });
   }
   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();
+    await this.vercel.reload();
   }
   cancelRun() {
     const previousMessage = this.vercel.messages.at(-1);
@@ -579,33 +567,184 @@ var VercelAIThreadRuntime = class {
     return null;
   };
   addToolResult(toolCallId, result) {
-    if (!("addToolResult" in this.vercel)) {
-      throw new Error("VercelAIRuntime does not support adding tool results");
-    }
     this.vercel.addToolResult({ toolCallId, result });
   }
 };
 
+// src/ui/use-chat/VercelUseChatRuntime.tsx
+var { ProxyConfigProvider: ProxyConfigProvider2, BaseAssistantRuntime: BaseAssistantRuntime2 } = import_react8.INTERNAL;
+var VercelUseChatRuntime = class extends BaseAssistantRuntime2 {
+  _proxyConfigProvider = new ProxyConfigProvider2();
+  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] = (0, import_react8.useState)(() => new VercelAIRuntime(chatHelpers));
-  (0, import_react8.useInsertionEffect)(() => {
+  const [runtime] = (0, import_react9.useState)(() => new VercelUseChatRuntime(chatHelpers));
+  (0, import_react9.useInsertionEffect)(() => {
     runtime.vercel = chatHelpers;
   });
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     runtime.onVercelUpdated();
   });
   return runtime;
 };
 
 // src/ui/use-assistant/useVercelUseAssistantRuntime.tsx
-var import_react9 = require("react");
+var import_react11 = require("react");
+
+// src/ui/use-assistant/VercelUseAssistantRuntime.tsx
+var import_react10 = require("@assistant-ui/react");
+
+// src/ui/use-assistant/VercelUseAssistantThreadRuntime.tsx
+var import_zustand3 = require("zustand");
+var EMPTY_BRANCHES2 = Object.freeze([]);
+var VercelUseAssistantThreadRuntime = class {
+  constructor(vercel) {
+    this.vercel = vercel;
+    this.useVercel = (0, import_zustand3.create)(() => ({
+      vercel
+    }));
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  useVercel;
+  messages = [];
+  isRunning = false;
+  getBranches() {
+    return EMPTY_BRANCHES2;
+  }
+  switchToBranch() {
+    throw new Error(
+      "VercelUseAssistantRuntime does not support switching branches."
+    );
+  }
+  async append(message) {
+    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: "in_progress",
+        role: "assistant",
+        content: [{ type: "text", text: "" }]
+      });
+    }
+    this.messages = vm;
+    this.isRunning = isRunning;
+    for (const callback of this._subscriptions) callback();
+  };
+  unstable_synchronizer = () => {
+    const { vercel } = this.useVercel();
+    useVercelAIThreadSync(vercel, this.updateData);
+    useVercelAIComposerSync(vercel);
+    return null;
+  };
+  addToolResult() {
+    throw new Error(
+      "VercelUseAssistantRuntime does not support adding tool results."
+    );
+  }
+};
+
+// src/ui/use-assistant/VercelUseAssistantRuntime.tsx
+var { ProxyConfigProvider: ProxyConfigProvider3, BaseAssistantRuntime: BaseAssistantRuntime3 } = import_react10.INTERNAL;
+var hasUpcomingMessage2 = (isRunning, messages) => {
+  return isRunning && messages[messages.length - 1]?.role !== "assistant";
+};
+var VercelUseAssistantRuntime = class extends BaseAssistantRuntime3 {
+  _proxyConfigProvider = new ProxyConfigProvider3();
+  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-assistant/useVercelUseAssistantRuntime.tsx
 var useVercelUseAssistantRuntime = (assistantHelpers) => {
-  const [runtime] = (0, import_react9.useState)(() => new VercelAIRuntime(assistantHelpers));
-  (0, import_react9.useInsertionEffect)(() => {
+  const [runtime] = (0, import_react11.useState)(
+    () => new VercelUseAssistantRuntime(assistantHelpers)
+  );
+  (0, import_react11.useInsertionEffect)(() => {
     runtime.vercel = assistantHelpers;
   });
-  (0, import_react9.useEffect)(() => {
+  (0, import_react11.useEffect)(() => {
     runtime.onVercelUpdated();
   });
   return runtime;