@assistant-ui/react 0.5.19 → 0.5.21

package/dist/chunk-V66MVXBH.mjs

@@ -0,0 +1,608 @@
+"use client";
+import {
+  mergeModelConfigs
+} from "./chunk-QBS6JLLN.mjs";
+import {
+  __export
+} from "./chunk-BJPOCE4O.mjs";
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  BaseAssistantRuntime: () => BaseAssistantRuntime,
+  MessageRepository: () => MessageRepository,
+  ProxyConfigProvider: () => ProxyConfigProvider,
+  TooltipIconButton: () => TooltipIconButton,
+  generateId: () => generateId,
+  useSmooth: () => useSmooth,
+  useSmoothStatus: () => useSmoothStatus,
+  withSmoothContextProvider: () => withSmoothContextProvider
+});
+
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = class {
+  _providers = /* @__PURE__ */ new Set();
+  getModelConfig() {
+    return mergeModelConfigs(this._providers);
+  }
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    return () => {
+      this._providers.delete(provider);
+    };
+  }
+};
+
+// src/utils/idUtils.tsx
+import { customAlphabet } from "nanoid/non-secure";
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var optimisticPrefix = "__optimistic__";
+var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
+
+// src/runtimes/edge/converters/fromCoreMessage.ts
+var fromCoreMessages = (message) => {
+  return message.map((message2) => fromCoreMessage(message2));
+};
+var fromCoreMessage = (message, {
+  id = generateId(),
+  status = { type: "complete", reason: "unknown" }
+} = {}) => {
+  const commonProps = {
+    id,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  const role = message.role;
+  switch (role) {
+    case "assistant":
+      return {
+        ...commonProps,
+        role,
+        content: message.content.map((part) => {
+          if (part.type === "tool-call") {
+            return {
+              ...part,
+              argsText: JSON.stringify(part.args)
+            };
+          }
+          return part;
+        }),
+        status
+      };
+    case "user":
+      return {
+        ...commonProps,
+        role,
+        content: message.content
+      };
+    case "system":
+      return {
+        ...commonProps,
+        role,
+        content: message.content
+      };
+    default: {
+      const unsupportedRole = role;
+      throw new Error(`Unknown message role: ${unsupportedRole}`);
+    }
+  }
+};
+
+// src/runtimes/utils/MessageRepository.tsx
+var findHead = (message) => {
+  if (message.next) return findHead(message.next);
+  return message;
+};
+var MessageRepository = class {
+  messages = /* @__PURE__ */ new Map();
+  // message_id -> item
+  head = null;
+  root = {
+    children: []
+  };
+  performOp(newParent, child, operation) {
+    const parentOrRoot = child.prev ?? this.root;
+    const newParentOrRoot = newParent ?? this.root;
+    if (operation === "relink" && parentOrRoot === newParentOrRoot) return;
+    if (operation !== "link") {
+      parentOrRoot.children = parentOrRoot.children.filter(
+        (m) => m !== child.current.id
+      );
+      if (child.prev?.next === child) {
+        const fallbackId = child.prev.children.at(-1);
+        const fallback = fallbackId ? this.messages.get(fallbackId) : null;
+        if (fallback === void 0) {
+          throw new Error(
+            "MessageRepository(performOp/cut): Fallback sibling message not found. This is likely an internal bug in assistant-ui."
+          );
+        }
+        child.prev.next = fallback;
+      }
+    }
+    if (operation !== "cut") {
+      newParentOrRoot.children = [
+        ...newParentOrRoot.children,
+        child.current.id
+      ];
+      if (newParent && (findHead(child) === this.head || newParent.next === null)) {
+        newParent.next = child;
+      }
+      child.prev = newParent;
+    }
+  }
+  getMessages() {
+    const messages = new Array(this.head?.level ?? 0);
+    for (let current = this.head; current; current = current.prev) {
+      messages[current.level] = current.current;
+    }
+    return messages;
+  }
+  addOrUpdateMessage(parentId, message) {
+    const existingItem = this.messages.get(message.id);
+    const prev = parentId ? this.messages.get(parentId) : null;
+    if (prev === void 0)
+      throw new Error(
+        "MessageRepository(addOrUpdateMessage): Parent message not found. This is likely an internal bug in assistant-ui."
+      );
+    if (existingItem) {
+      existingItem.current = message;
+      this.performOp(prev, existingItem, "relink");
+      return;
+    }
+    const newItem = {
+      prev,
+      current: message,
+      next: null,
+      children: [],
+      level: prev ? prev.level + 1 : 0
+    };
+    this.messages.set(message.id, newItem);
+    this.performOp(prev, newItem, "link");
+    if (this.head === prev) {
+      this.head = newItem;
+    }
+  }
+  getMessage(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(updateMessage): Message not found. This is likely an internal bug in assistant-ui."
+      );
+    return {
+      parentId: message.prev?.current.id ?? null,
+      message: message.current
+    };
+  }
+  appendOptimisticMessage(parentId, message) {
+    let optimisticId;
+    do {
+      optimisticId = generateOptimisticId();
+    } while (this.messages.has(optimisticId));
+    this.addOrUpdateMessage(
+      parentId,
+      fromCoreMessage(message, {
+        id: optimisticId,
+        status: { type: "running" }
+      })
+    );
+    return optimisticId;
+  }
+  deleteMessage(messageId, replacementId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(deleteMessage): Optimistic message not found. This is likely an internal bug in assistant-ui."
+      );
+    const replacement = replacementId === void 0 ? message.prev : replacementId === null ? null : this.messages.get(replacementId);
+    if (replacement === void 0)
+      throw new Error(
+        "MessageRepository(deleteMessage): Replacement not found. This is likely an internal bug in assistant-ui."
+      );
+    for (const child of message.children) {
+      const childMessage = this.messages.get(child);
+      if (!childMessage)
+        throw new Error(
+          "MessageRepository(deleteMessage): Child message not found. This is likely an internal bug in assistant-ui."
+        );
+      this.performOp(replacement, childMessage, "relink");
+    }
+    this.performOp(null, message, "cut");
+    this.messages.delete(messageId);
+    if (this.head === message) {
+      this.head = replacement ? findHead(replacement) : null;
+    }
+  }
+  getBranches(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(getBranches): Message not found. This is likely an internal bug in assistant-ui."
+      );
+    const { children } = message.prev ?? this.root;
+    return children;
+  }
+  switchToBranch(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(switchToBranch): Branch not found. This is likely an internal bug in assistant-ui."
+      );
+    if (message.prev) {
+      message.prev.next = message;
+    }
+    this.head = findHead(message);
+  }
+  resetHead(messageId) {
+    if (messageId === null) {
+      this.head = null;
+      return;
+    }
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(resetHead): Branch not found. This is likely an internal bug in assistant-ui."
+      );
+    this.head = message;
+    for (let current = message; current; current = current.prev) {
+      if (current.prev) {
+        current.prev.next = current;
+      }
+    }
+  }
+};
+
+// src/runtimes/core/BaseAssistantRuntime.tsx
+var BaseAssistantRuntime = class {
+  constructor(_thread) {
+    this._thread = _thread;
+    this._thread = _thread;
+  }
+  get thread() {
+    return this._thread;
+  }
+  set thread(thread) {
+    this._thread = thread;
+    this.subscriptionHandler();
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  subscriptionHandler = () => {
+    for (const callback of this._subscriptions) callback();
+  };
+};
+
+// src/utils/smooth/useSmooth.tsx
+import { useEffect, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+
+// src/context/react/AssistantContext.ts
+import { createContext, useContext } from "react";
+var AssistantContext = createContext(
+  null
+);
+function useAssistantContext(options) {
+  const context = useContext(AssistantContext);
+  if (!options?.optional && !context)
+    throw new Error(
+      "This component must be used within an AssistantRuntimeProvider."
+    );
+  return context;
+}
+
+// src/context/react/ThreadContext.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var ThreadContext = createContext2(null);
+function useThreadContext(options) {
+  const context = useContext2(ThreadContext);
+  if (!options?.optional && !context)
+    throw new Error(
+      "This component must be used within an AssistantRuntimeProvider."
+    );
+  return context;
+}
+
+// src/context/react/ComposerContext.ts
+import { useMemo } from "react";
+
+// src/context/react/MessageContext.ts
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var MessageContext = createContext3(null);
+function useMessageContext(options) {
+  const context = useContext3(MessageContext);
+  if (!options?.optional && !context)
+    throw new Error(
+      "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
+    );
+  return context;
+}
+
+// src/context/react/ComposerContext.ts
+var useComposerContext = () => {
+  const { useComposer } = useThreadContext();
+  const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
+  return useMemo(
+    () => ({
+      useComposer: useEditComposer ?? useComposer,
+      type: useEditComposer ? "edit" : "new"
+    }),
+    [useEditComposer, useComposer]
+  );
+};
+
+// src/context/react/ContentPartContext.ts
+import { createContext as createContext4, useContext as useContext4 } from "react";
+var ContentPartContext = createContext4(
+  null
+);
+function useContentPartContext(options) {
+  const context = useContext4(ContentPartContext);
+  if (!options?.optional && !context)
+    throw new Error(
+      "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
+    );
+  return context;
+}
+
+// src/utils/smooth/SmoothContext.tsx
+import {
+  createContext as createContext5,
+  forwardRef,
+  useContext as useContext5,
+  useState
+} from "react";
+import { create } from "zustand";
+import { jsx } from "react/jsx-runtime";
+var SmoothContext = createContext5(null);
+var makeSmoothContext = (initialState) => {
+  const useSmoothStatus2 = create(() => initialState);
+  return { useSmoothStatus: useSmoothStatus2 };
+};
+var SmoothContextProvider = ({ children }) => {
+  const outer = useSmoothContext({ optional: true });
+  const { useContentPart } = useContentPartContext();
+  const [context] = useState(
+    () => makeSmoothContext(useContentPart.getState().status)
+  );
+  if (outer) return children;
+  return /* @__PURE__ */ jsx(SmoothContext.Provider, { value: context, children });
+};
+var withSmoothContextProvider = (Component) => {
+  const Wrapped = forwardRef((props, ref) => {
+    return /* @__PURE__ */ jsx(SmoothContextProvider, { children: /* @__PURE__ */ jsx(Component, { ...props, ref }) });
+  });
+  Wrapped.displayName = Component.displayName;
+  return Wrapped;
+};
+function useSmoothContext(options) {
+  const context = useContext5(SmoothContext);
+  if (!options?.optional && !context)
+    throw new Error(
+      "This component must be used within a SmoothContextProvider."
+    );
+  return context;
+}
+var useSmoothStatus = () => {
+  const { useSmoothStatus: useSmoothStatus2 } = useSmoothContext();
+  return useSmoothStatus2();
+};
+
+// src/utils/smooth/useSmooth.tsx
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+var TextStreamAnimator = class {
+  constructor(currentText, setText) {
+    this.currentText = currentText;
+    this.setText = setText;
+  }
+  animationFrameId = null;
+  lastUpdateTime = Date.now();
+  targetText = "";
+  start() {
+    if (this.animationFrameId !== null) return;
+    this.lastUpdateTime = Date.now();
+    this.animate();
+  }
+  stop() {
+    if (this.animationFrameId !== null) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+  }
+  animate = () => {
+    const currentTime = Date.now();
+    const deltaTime = currentTime - this.lastUpdateTime;
+    let timeToConsume = deltaTime;
+    const remainingChars = this.targetText.length - this.currentText.length;
+    const baseTimePerChar = Math.min(5, 250 / remainingChars);
+    let charsToAdd = 0;
+    while (timeToConsume >= baseTimePerChar && charsToAdd < remainingChars) {
+      charsToAdd++;
+      timeToConsume -= baseTimePerChar;
+    }
+    if (charsToAdd !== remainingChars) {
+      this.animationFrameId = requestAnimationFrame(this.animate);
+    } else {
+      this.animationFrameId = null;
+    }
+    if (charsToAdd === 0) return;
+    this.currentText = this.targetText.slice(
+      0,
+      this.currentText.length + charsToAdd
+    );
+    this.lastUpdateTime = currentTime - timeToConsume;
+    this.setText(this.currentText);
+  };
+};
+var SMOOTH_STATUS = Object.freeze({
+  type: "running"
+});
+var useSmooth = (state, smooth = false) => {
+  const { useSmoothStatus: useSmoothStatus2 } = useSmoothContext({ optional: true }) ?? {};
+  const {
+    part: { text }
+  } = state;
+  const { useMessage } = useMessageContext();
+  const id = useMessage((m) => m.message.id);
+  const idRef = useRef(id);
+  const [displayedText, setDisplayedText] = useState2(text);
+  const setText = useCallbackRef((text2) => {
+    setDisplayedText(text2);
+    useSmoothStatus2?.setState(text2 !== state.part.text ? SMOOTH_STATUS : state.status);
+  });
+  const [animatorRef] = useState2(
+    new TextStreamAnimator(text, setText)
+  );
+  useEffect(() => {
+    if (!smooth) {
+      animatorRef.stop();
+      return;
+    }
+    if (idRef.current !== id || !text.startsWith(animatorRef.targetText)) {
+      idRef.current = id;
+      setText(text);
+      animatorRef.currentText = text;
+      animatorRef.targetText = text;
+      animatorRef.stop();
+      return;
+    }
+    animatorRef.targetText = text;
+    animatorRef.start();
+  }, [setText, animatorRef, id, smooth, text]);
+  useEffect(() => {
+    return () => {
+      animatorRef.stop();
+    };
+  }, [animatorRef]);
+  return useMemo2(
+    () => smooth ? {
+      part: { type: "text", text: displayedText },
+      status: text === displayedText ? state.status : SMOOTH_STATUS
+    } : state,
+    [smooth, displayedText, state, text]
+  );
+};
+
+// src/ui/base/tooltip-icon-button.tsx
+import { forwardRef as forwardRef4 } from "react";
+
+// src/ui/base/tooltip.tsx
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+
+// src/ui/utils/withDefaults.tsx
+import {
+  forwardRef as forwardRef2
+} from "react";
+import classNames from "classnames";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var withDefaultProps = ({
+  className,
+  ...defaultProps
+}) => ({ className: classNameProp, ...props }) => {
+  return {
+    className: classNames(className, classNameProp),
+    ...defaultProps,
+    ...props
+  };
+};
+var withDefaults = (Component, defaultProps) => {
+  const getProps = withDefaultProps(defaultProps);
+  const WithDefaults = forwardRef2(
+    (props, ref) => {
+      const ComponentAsAny = Component;
+      return /* @__PURE__ */ jsx2(ComponentAsAny, { ...getProps(props), ref });
+    }
+  );
+  WithDefaults.displayName = "withDefaults(" + (typeof Component === "string" ? Component : Component.displayName) + ")";
+  return WithDefaults;
+};
+
+// src/ui/base/tooltip.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var Tooltip = (props) => {
+  return /* @__PURE__ */ jsx3(TooltipPrimitive.Provider, { children: /* @__PURE__ */ jsx3(TooltipPrimitive.Root, { ...props }) });
+};
+Tooltip.displayName = "Tooltip";
+var TooltipTrigger = TooltipPrimitive.Trigger;
+var TooltipContent = withDefaults(TooltipPrimitive.Content, {
+  sideOffset: 4,
+  className: "aui-tooltip-content"
+});
+TooltipContent.displayName = "TooltipContent";
+
+// src/ui/base/button.tsx
+import { cva } from "class-variance-authority";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var buttonVariants = cva("aui-button", {
+  variants: {
+    variant: {
+      default: "aui-button-primary",
+      outline: "aui-button-outline",
+      ghost: "aui-button-ghost"
+    },
+    size: {
+      default: "aui-button-medium",
+      icon: "aui-button-icon"
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "default"
+  }
+});
+var Button = forwardRef3(
+  ({ className, variant, size, ...props }, ref) => {
+    return /* @__PURE__ */ jsx4(
+      Primitive.button,
+      {
+        className: buttonVariants({ variant, size, className }),
+        ...props,
+        ref
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/ui/base/tooltip-icon-button.tsx
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+var TooltipIconButton = forwardRef4(({ children, tooltip, side = "bottom", ...rest }, ref) => {
+  return /* @__PURE__ */ jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsx5(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", size: "icon", ...rest, ref, children: [
+      children,
+      /* @__PURE__ */ jsx5("span", { className: "aui-sr-only", children: tooltip })
+    ] }) }),
+    /* @__PURE__ */ jsx5(TooltipContent, { side, children: tooltip })
+  ] });
+});
+TooltipIconButton.displayName = "TooltipIconButton";
+
+export {
+  AssistantContext,
+  useAssistantContext,
+  ProxyConfigProvider,
+  ThreadContext,
+  useThreadContext,
+  MessageContext,
+  useMessageContext,
+  useComposerContext,
+  ContentPartContext,
+  useContentPartContext,
+  withSmoothContextProvider,
+  useSmoothStatus,
+  useSmooth,
+  BaseAssistantRuntime,
+  generateId,
+  fromCoreMessages,
+  fromCoreMessage,
+  MessageRepository,
+  withDefaults,
+  Button,
+  TooltipIconButton,
+  internal_exports
+};
+//# sourceMappingURL=chunk-V66MVXBH.mjs.map