@assistant-ui/react 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -0,0 +1,1574 @@
+import {
+  AssistantContext,
+  ContentPartContext,
+  MessageContext,
+  ThreadContext,
+  __export,
+  useAssistantContext,
+  useComposerContext,
+  useContentPartContext,
+  useMessageContext,
+  useThreadContext
+} from "./chunk-KIP3YFVM.mjs";
+
+// src/actions/useCopyMessage.tsx
+import { useCallback } from "react";
+
+// src/utils/combined/useCombinedStore.ts
+import { useMemo } from "react";
+
+// src/utils/combined/createCombinedStore.ts
+import { useSyncExternalStore } from "react";
+var createCombinedStore = (stores) => {
+  const subscribe = (callback) => {
+    const unsubscribes = stores.map((store) => store.subscribe(callback));
+    return () => {
+      for (const unsub of unsubscribes) {
+        unsub();
+      }
+    };
+  };
+  return (selector) => {
+    const getSnapshot = () => selector(...stores.map((store) => store.getState()));
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  };
+};
+
+// src/utils/combined/useCombinedStore.ts
+var useCombinedStore = (stores, selector) => {
+  const useCombined = useMemo(() => createCombinedStore(stores), stores);
+  return useCombined(selector);
+};
+
+// src/utils/getMessageText.tsx
+var getMessageText = (message) => {
+  const textParts = message.content.filter(
+    (part) => part.type === "text"
+  );
+  return textParts.map((part) => part.text).join("\n\n");
+};
+
+// src/actions/useCopyMessage.tsx
+var useCopyMessage = ({ copiedDuration = 3e3 }) => {
+  const { useMessage, useComposer } = useMessageContext();
+  const hasCopyableContent = useCombinedStore(
+    [useMessage, useComposer],
+    (m, c) => {
+      return c.isEditing || m.message.content.some((c2) => c2.type === "text");
+    }
+  );
+  const callback = useCallback(() => {
+    const { isEditing, value: composerValue } = useComposer.getState();
+    const { message, setIsCopied } = useMessage.getState();
+    const valueToCopy = isEditing ? composerValue : getMessageText(message);
+    navigator.clipboard.writeText(valueToCopy);
+    setIsCopied(true);
+    setTimeout(() => setIsCopied(false), copiedDuration);
+  }, [useComposer, useMessage, copiedDuration]);
+  if (!hasCopyableContent) return null;
+  return callback;
+};
+
+// src/actions/useReloadMessage.tsx
+import { useCallback as useCallback2 } from "react";
+var useReloadMessage = () => {
+  const { useThread, useViewport } = useThreadContext();
+  const { useMessage } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useThread, useMessage],
+    (t, m) => t.isRunning || m.message.role !== "assistant"
+  );
+  const callback = useCallback2(() => {
+    const { parentId } = useMessage.getState();
+    useThread.getState().startRun(parentId);
+    useViewport.getState().scrollToBottom();
+  }, [useMessage, useThread, useViewport]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/actions/useBeginMessageEdit.tsx
+import { useCallback as useCallback3 } from "react";
+var useBeginMessageEdit = () => {
+  const { useMessage, useComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useComposer],
+    (m, c) => m.message.role !== "user" || c.isEditing
+  );
+  const callback = useCallback3(() => {
+    const { edit } = useComposer.getState();
+    edit();
+  }, [useComposer]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/actions/useGoToNextBranch.tsx
+import { useCallback as useCallback4 } from "react";
+var useGoToNextBranch = () => {
+  const { useThread } = useThreadContext();
+  const { useMessage, useComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useComposer],
+    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
+  );
+  const callback = useCallback4(() => {
+    const { message, branches } = useMessage.getState();
+    useThread.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
+  }, [useMessage, useThread]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/actions/useGoToPreviousBranch.tsx
+import { useCallback as useCallback5 } from "react";
+var useGoToPreviousBranch = () => {
+  const { useThread } = useThreadContext();
+  const { useMessage, useComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useComposer],
+    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
+  );
+  const callback = useCallback5(() => {
+    const { message, branches } = useMessage.getState();
+    useThread.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
+  }, [useMessage, useThread]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/primitives/thread/index.ts
+var thread_exports = {};
+__export(thread_exports, {
+  Empty: () => ThreadEmpty,
+  If: () => ThreadIf,
+  Messages: () => ThreadMessages,
+  Root: () => ThreadRoot,
+  ScrollToBottom: () => ThreadScrollToBottom,
+  Suggestion: () => ThreadSuggestion,
+  Viewport: () => ThreadViewport
+});
+
+// src/primitives/thread/ThreadRoot.tsx
+import {
+  Primitive
+} from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var ThreadRoot = forwardRef(
+  (props, ref) => {
+    return /* @__PURE__ */ jsx(Primitive.div, { ...props, ref });
+  }
+);
+
+// src/primitives/thread/ThreadIf.tsx
+var useThreadIf = (props) => {
+  const { useThread } = useThreadContext();
+  return useThread((thread) => {
+    if (props.empty === true && thread.messages.length !== 0) return false;
+    if (props.empty === false && thread.messages.length === 0) return false;
+    if (props.running === true && !thread.isRunning) return false;
+    if (props.running === false && thread.isRunning) return false;
+    return true;
+  });
+};
+var ThreadIf = ({ children, ...query }) => {
+  const result = useThreadIf(query);
+  return result ? children : null;
+};
+
+// src/primitives/thread/ThreadEmpty.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ThreadEmpty = ({ children }) => {
+  return /* @__PURE__ */ jsx2(ThreadIf, { empty: true, children });
+};
+
+// src/primitives/thread/ThreadViewport.tsx
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import {
+  Primitive as Primitive2
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef2, useRef } from "react";
+
+// src/utils/hooks/useOnResizeContent.tsx
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useEffect } from "react";
+var useOnResizeContent = (ref, callback) => {
+  const callbackRef = useCallbackRef(callback);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const resizeObserver = new ResizeObserver(() => {
+      callbackRef();
+    });
+    const mutationObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        for (const node of mutation.addedNodes) {
+          if (node instanceof Element) {
+            resizeObserver.observe(node);
+          }
+        }
+        for (const node of mutation.removedNodes) {
+          if (node instanceof Element) {
+            resizeObserver.unobserve(node);
+          }
+        }
+      }
+      callbackRef();
+    });
+    resizeObserver.observe(el);
+    mutationObserver.observe(el, { childList: true });
+    for (const child of el.children) {
+      resizeObserver.observe(child);
+    }
+    return () => {
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+    };
+  }, [ref.current, callbackRef]);
+};
+
+// src/utils/hooks/useOnScrollToBottom.tsx
+import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-ref";
+import { useEffect as useEffect2 } from "react";
+var useOnScrollToBottom = (callback) => {
+  const callbackRef = useCallbackRef2(callback);
+  const { useViewport } = useThreadContext();
+  useEffect2(() => {
+    return useViewport.getState().onScrollToBottom(() => {
+      callbackRef();
+    });
+  }, [useViewport, callbackRef]);
+};
+
+// src/primitives/thread/ThreadViewport.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...rest }, forwardedRef) => {
+  const messagesEndRef = useRef(null);
+  const divRef = useRef(null);
+  const ref = useComposedRefs(forwardedRef, divRef);
+  const { useViewport } = useThreadContext();
+  const firstRenderRef = useRef(true);
+  const isScrollingToBottomRef = useRef(false);
+  const lastScrollTop = useRef(0);
+  const scrollToBottom = () => {
+    const div = messagesEndRef.current;
+    if (!div || !autoScroll) return;
+    const behavior = firstRenderRef.current ? "instant" : "auto";
+    firstRenderRef.current = false;
+    isScrollingToBottomRef.current = true;
+    div.scrollIntoView({ behavior });
+  };
+  useOnResizeContent(divRef, () => {
+    if (!isScrollingToBottomRef.current && !useViewport.getState().isAtBottom) {
+      handleScroll();
+    } else {
+      scrollToBottom();
+    }
+  });
+  useOnScrollToBottom(() => {
+    scrollToBottom();
+  });
+  const handleScroll = () => {
+    const div = divRef.current;
+    if (!div) return;
+    const isAtBottom = useViewport.getState().isAtBottom;
+    const newIsAtBottom = div.scrollHeight - div.scrollTop <= div.clientHeight;
+    if (!newIsAtBottom && lastScrollTop.current < div.scrollTop) {
+    } else if (newIsAtBottom !== isAtBottom) {
+      isScrollingToBottomRef.current = false;
+      useViewport.setState({ isAtBottom: newIsAtBottom });
+    }
+    lastScrollTop.current = div.scrollTop;
+  };
+  return /* @__PURE__ */ jsxs(
+    Primitive2.div,
+    {
+      ...rest,
+      onScroll: composeEventHandlers(onScroll, handleScroll),
+      ref,
+      children: [
+        children,
+        /* @__PURE__ */ jsx3("div", { ref: messagesEndRef })
+      ]
+    }
+  );
+});
+
+// src/primitives/thread/ThreadMessages.tsx
+import { memo } from "react";
+
+// src/context/providers/MessageProvider.tsx
+import { useEffect as useEffect3, useState } from "react";
+import { create as create2 } from "zustand";
+
+// src/context/stores/MessageComposer.ts
+import { create } from "zustand";
+
+// src/context/stores/BaseComposer.ts
+var makeBaseComposer = (set) => ({
+  value: "",
+  setValue: (value) => {
+    set({ value });
+  }
+});
+
+// src/context/stores/MessageComposer.ts
+var makeEditComposerStore = ({
+  onEdit,
+  onSend
+}) => create()((set, get, store) => ({
+  ...makeBaseComposer(set, get, store),
+  isEditing: false,
+  edit: () => {
+    const value = onEdit();
+    set({ isEditing: true, value });
+  },
+  send: () => {
+    const value = get().value;
+    set({ isEditing: false });
+    onSend(value);
+  },
+  cancel: () => {
+    if (!get().isEditing) return false;
+    set({ isEditing: false });
+    return true;
+  }
+}));
+
+// src/context/providers/MessageProvider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var getIsLast = (thread, message) => {
+  return thread.messages[thread.messages.length - 1]?.id === message.id;
+};
+var syncMessage = (thread, useMessage, messageIndex) => {
+  const parentId = thread.messages[messageIndex - 1]?.id ?? null;
+  const message = thread.messages[messageIndex];
+  if (!message) return;
+  const isLast = getIsLast(thread, message);
+  const branches = thread.getBranches(message.id);
+  const currentState = useMessage.getState();
+  if (currentState.message === message && currentState.parentId === parentId && currentState.branches === branches && currentState.isLast === isLast)
+    return;
+  useMessage.setState({
+    message,
+    parentId,
+    branches,
+    isLast
+  });
+};
+var useMessageContext2 = (messageIndex) => {
+  const { useThread } = useThreadContext();
+  const [context] = useState(() => {
+    const useMessage = create2((set) => ({
+      message: null,
+      parentId: null,
+      branches: [],
+      isLast: false,
+      inProgressIndicator: null,
+      isCopied: false,
+      isHovering: false,
+      setInProgressIndicator: (value) => {
+        set({ inProgressIndicator: value });
+      },
+      setIsCopied: (value) => {
+        set({ isCopied: value });
+      },
+      setIsHovering: (value) => {
+        set({ isHovering: value });
+      }
+    }));
+    const useComposer = makeEditComposerStore({
+      onEdit: () => {
+        const message = useMessage.getState().message;
+        if (message.role !== "user")
+          throw new Error(
+            "Tried to edit a non-user message. Editing is only supported for user messages. This is likely an internal bug in assistant-ui."
+          );
+        const text = getMessageText(message);
+        return text;
+      },
+      onSend: (text) => {
+        const { message, parentId } = useMessage.getState();
+        if (message.role !== "user")
+          throw new Error(
+            "Tried to edit a non-user message. Editing is only supported for user messages. This is likely an internal bug in assistant-ui."
+          );
+        const nonTextParts = message.content.filter(
+          (part) => part.type !== "text" && part.type !== "ui"
+        );
+        useThread.getState().append({
+          parentId,
+          content: [{ type: "text", text }, ...nonTextParts]
+        });
+      }
+    });
+    syncMessage(useThread.getState(), useMessage, messageIndex);
+    return { useMessage, useComposer };
+  });
+  useEffect3(() => {
+    return useThread.subscribe((thread) => {
+      syncMessage(thread, context.useMessage, messageIndex);
+    });
+  }, [context, useThread, messageIndex]);
+  return context;
+};
+var MessageProvider = ({
+  messageIndex,
+  children
+}) => {
+  const context = useMessageContext2(messageIndex);
+  return /* @__PURE__ */ jsx4(MessageContext.Provider, { value: context, children });
+};
+
+// src/primitives/composer/ComposerIf.tsx
+var useComposerIf = (props) => {
+  const { useComposer } = useComposerContext();
+  return useComposer((composer) => {
+    if (props.editing === true && !composer.isEditing) return false;
+    if (props.editing === false && composer.isEditing) return false;
+    return true;
+  });
+};
+var ComposerIf = ({ children, ...query }) => {
+  const result = useComposerIf(query);
+  return result ? children : null;
+};
+
+// src/primitives/message/MessageIf.tsx
+var useMessageIf = (props) => {
+  const { useMessage } = useMessageContext();
+  return useMessage(({ message, branches, isLast, isCopied, isHovering }) => {
+    if (props.hasBranches === true && branches.length < 2) return false;
+    if (props.user && message.role !== "user") return false;
+    if (props.assistant && message.role !== "assistant") return false;
+    if (props.lastOrHover === true && !isHovering && !isLast) return false;
+    if (props.copied === true && !isCopied) return false;
+    if (props.copied === false && isCopied) return false;
+    return true;
+  });
+};
+var MessageIf = ({ children, ...query }) => {
+  const result = useMessageIf(query);
+  return result ? children : null;
+};
+
+// src/primitives/thread/ThreadMessages.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var getComponents = (components) => {
+  return {
+    EditComposer: components.EditComposer ?? components.UserMessage ?? components.Message,
+    UserMessage: components.UserMessage ?? components.Message,
+    AssistantMessage: components.AssistantMessage ?? components.Message
+  };
+};
+var ThreadMessageImpl = ({
+  messageIndex,
+  components
+}) => {
+  const { UserMessage, EditComposer, AssistantMessage } = getComponents(components);
+  return /* @__PURE__ */ jsxs2(MessageProvider, { messageIndex, children: [
+    /* @__PURE__ */ jsxs2(MessageIf, { user: true, children: [
+      /* @__PURE__ */ jsx5(ComposerIf, { editing: false, children: /* @__PURE__ */ jsx5(UserMessage, {}) }),
+      /* @__PURE__ */ jsx5(ComposerIf, { editing: true, children: /* @__PURE__ */ jsx5(EditComposer, {}) })
+    ] }),
+    /* @__PURE__ */ jsx5(MessageIf, { assistant: true, children: /* @__PURE__ */ jsx5(AssistantMessage, {}) })
+  ] });
+};
+var ThreadMessage = memo(
+  ThreadMessageImpl,
+  (prev, next) => prev.messageIndex === next.messageIndex && prev.components.UserMessage === next.components.UserMessage && prev.components.EditComposer === next.components.EditComposer && prev.components.AssistantMessage === next.components.AssistantMessage
+);
+var ThreadMessages = ({ components }) => {
+  const { useThread } = useThreadContext();
+  const messagesLength = useThread((t) => t.messages.length);
+  if (messagesLength === 0) return null;
+  return new Array(messagesLength).fill(null).map((_, idx) => {
+    const messageIndex = idx;
+    return /* @__PURE__ */ jsx5(
+      ThreadMessage,
+      {
+        messageIndex,
+        components
+      },
+      messageIndex
+    );
+  });
+};
+
+// src/primitives/thread/ThreadScrollToBottom.tsx
+import { composeEventHandlers as composeEventHandlers2 } from "@radix-ui/primitive";
+import {
+  Primitive as Primitive3
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef3 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ThreadScrollToBottom = forwardRef3(({ onClick, ...rest }, ref) => {
+  const { useViewport } = useThreadContext();
+  const isAtBottom = useViewport((s) => s.isAtBottom);
+  const handleScrollToBottom = () => {
+    useViewport.getState().scrollToBottom();
+  };
+  return /* @__PURE__ */ jsx6(
+    Primitive3.button,
+    {
+      ...rest,
+      disabled: isAtBottom,
+      ref,
+      onClick: composeEventHandlers2(onClick, handleScrollToBottom)
+    }
+  );
+});
+
+// src/primitives/thread/ThreadSuggestion.tsx
+import { composeEventHandlers as composeEventHandlers3 } from "@radix-ui/primitive";
+import {
+  Primitive as Primitive4
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef4 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ThreadSuggestion = forwardRef4(({ onClick, prompt, method, autoSend: send, ...rest }, ref) => {
+  const { useThread, useComposer } = useThreadContext();
+  const isDisabled = useThread((t) => t.isRunning);
+  const handleApplySuggestion = () => {
+    const thread = useThread.getState();
+    const composer = useComposer.getState();
+    composer.setValue(prompt);
+    if (send && !thread.isRunning) {
+      composer.send();
+    }
+  };
+  return /* @__PURE__ */ jsx7(
+    Primitive4.button,
+    {
+      ...rest,
+      disabled: isDisabled,
+      ref,
+      onClick: composeEventHandlers3(onClick, handleApplySuggestion)
+    }
+  );
+});
+
+// src/primitives/composer/index.ts
+var composer_exports = {};
+__export(composer_exports, {
+  Cancel: () => ComposerCancel,
+  If: () => ComposerIf,
+  Input: () => ComposerInput,
+  Root: () => ComposerRoot,
+  Send: () => ComposerSend
+});
+
+// src/primitives/composer/ComposerRoot.tsx
+import { composeEventHandlers as composeEventHandlers4 } from "@radix-ui/primitive";
+import { useComposedRefs as useComposedRefs2 } from "@radix-ui/react-compose-refs";
+import {
+  Primitive as Primitive5
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef5, useRef as useRef2 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var ComposerRoot = forwardRef5(
+  ({ onSubmit, ...rest }, forwardedRef) => {
+    const { useViewport } = useThreadContext();
+    const { useComposer } = useComposerContext();
+    const formRef = useRef2(null);
+    const ref = useComposedRefs2(forwardedRef, formRef);
+    const handleSubmit = (e) => {
+      const composerState = useComposer.getState();
+      if (!composerState.isEditing) return;
+      e.preventDefault();
+      composerState.send();
+      useViewport.getState().scrollToBottom();
+    };
+    return /* @__PURE__ */ jsx8(
+      Primitive5.form,
+      {
+        ...rest,
+        ref,
+        onSubmit: composeEventHandlers4(onSubmit, handleSubmit)
+      }
+    );
+  }
+);
+
+// src/primitives/composer/ComposerInput.tsx
+import { composeEventHandlers as composeEventHandlers5 } from "@radix-ui/primitive";
+import { useComposedRefs as useComposedRefs3 } from "@radix-ui/react-compose-refs";
+import { Slot } from "@radix-ui/react-slot";
+import {
+  forwardRef as forwardRef6,
+  useCallback as useCallback6,
+  useEffect as useEffect4,
+  useRef as useRef3
+} from "react";
+import TextareaAutosize from "react-textarea-autosize";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var ComposerInput = forwardRef6(
+  ({ autoFocus = false, asChild, disabled, onChange, onKeyDown, ...rest }, forwardedRef) => {
+    const { useThread } = useThreadContext();
+    const { useComposer, type } = useComposerContext();
+    const value = useComposer((c) => {
+      if (!c.isEditing) return "";
+      return c.value;
+    });
+    const Component = asChild ? Slot : TextareaAutosize;
+    const textareaRef = useRef3(null);
+    const ref = useComposedRefs3(forwardedRef, textareaRef);
+    const handleKeyPress = (e) => {
+      if (disabled) return;
+      if (e.key === "Escape") {
+        const composer = useComposer.getState();
+        if (composer.cancel()) {
+          e.preventDefault();
+        }
+      } else if (e.key === "Enter" && e.shiftKey === false) {
+        const isRunning = useThread.getState().isRunning;
+        if (!isRunning) {
+          e.preventDefault();
+          textareaRef.current?.closest("form")?.requestSubmit();
+        }
+      }
+    };
+    const autoFocusEnabled = autoFocus && !disabled;
+    const focus = useCallback6(() => {
+      const textarea = textareaRef.current;
+      if (!textarea || !autoFocusEnabled) return;
+      console.log("focus");
+      textarea.focus();
+      textarea.setSelectionRange(
+        textareaRef.current.value.length,
+        textareaRef.current.value.length
+      );
+    }, [autoFocusEnabled]);
+    useEffect4(() => focus(), [focus]);
+    useOnScrollToBottom(() => {
+      if (type === "new") {
+        focus();
+      }
+    });
+    return /* @__PURE__ */ jsx9(
+      Component,
+      {
+        value,
+        ...rest,
+        ref,
+        autoFocus,
+        disabled,
+        onChange: composeEventHandlers5(onChange, (e) => {
+          const composerState = useComposer.getState();
+          if (!composerState.isEditing) return;
+          return composerState.setValue(e.target.value);
+        }),
+        onKeyDown: composeEventHandlers5(onKeyDown, handleKeyPress)
+      }
+    );
+  }
+);
+
+// src/primitives/composer/ComposerSend.tsx
+import {
+  Primitive as Primitive6
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef7 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var ComposerSend = forwardRef7(
+  ({ disabled, ...rest }, ref) => {
+    const { useComposer } = useComposerContext();
+    const hasValue = useComposer((c) => c.isEditing && c.value.length > 0);
+    return /* @__PURE__ */ jsx10(
+      Primitive6.button,
+      {
+        type: "submit",
+        ...rest,
+        ref,
+        disabled: disabled || !hasValue
+      }
+    );
+  }
+);
+
+// src/primitives/composer/ComposerCancel.tsx
+import { composeEventHandlers as composeEventHandlers6 } from "@radix-ui/primitive";
+import {
+  Primitive as Primitive7
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef8 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var ComposerCancel = forwardRef8(({ onClick, ...rest }, ref) => {
+  const { useComposer } = useComposerContext();
+  const handleCancel = () => {
+    useComposer.getState().cancel();
+  };
+  return /* @__PURE__ */ jsx11(
+    Primitive7.button,
+    {
+      type: "button",
+      ...rest,
+      ref,
+      onClick: composeEventHandlers6(onClick, handleCancel)
+    }
+  );
+});
+
+// src/primitives/message/index.ts
+var message_exports = {};
+__export(message_exports, {
+  Content: () => MessageContent,
+  If: () => MessageIf,
+  InProgress: () => MessageInProgress,
+  Root: () => MessageRoot
+});
+
+// src/primitives/message/MessageRoot.tsx
+import { composeEventHandlers as composeEventHandlers7 } from "@radix-ui/primitive";
+import {
+  Primitive as Primitive8
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef9 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var MessageRoot = forwardRef9(
+  ({ onMouseEnter, onMouseLeave, ...rest }, ref) => {
+    const { useMessage } = useMessageContext();
+    const setIsHovering = useMessage((s) => s.setIsHovering);
+    const handleMouseEnter = () => {
+      setIsHovering(true);
+    };
+    const handleMouseLeave = () => {
+      setIsHovering(false);
+    };
+    return /* @__PURE__ */ jsx12(
+      Primitive8.div,
+      {
+        ...rest,
+        ref,
+        onMouseEnter: composeEventHandlers7(onMouseEnter, handleMouseEnter),
+        onMouseLeave: composeEventHandlers7(onMouseLeave, handleMouseLeave)
+      }
+    );
+  }
+);
+
+// src/primitives/message/MessageContent.tsx
+import { memo as memo2 } from "react";
+
+// src/context/providers/ContentPartProvider.tsx
+import { useEffect as useEffect5, useState as useState2 } from "react";
+import { create as create3 } from "zustand";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var syncContentPart = ({ message }, useContentPart, partIndex) => {
+  const part = message.content[partIndex];
+  if (!part) return;
+  const messageStatus = message.role === "assistant" ? message.status : "done";
+  const status = partIndex === message.content.length - 1 ? messageStatus : "done";
+  const currentState = useContentPart.getState();
+  if (currentState.part === part && currentState.status === status) return;
+  useContentPart.setState({ part, status });
+};
+var useContentPartContext2 = (partIndex) => {
+  const { useMessage } = useMessageContext();
+  const [context] = useState2(() => {
+    const useContentPart = create3(() => ({
+      part: { type: "text", text: "" },
+      status: "done"
+    }));
+    syncContentPart(useMessage.getState(), useContentPart, partIndex);
+    return { useContentPart };
+  });
+  useEffect5(() => {
+    return useMessage.subscribe((message) => {
+      syncContentPart(message, context.useContentPart, partIndex);
+    });
+  }, [context, useMessage, partIndex]);
+  return context;
+};
+var ContentPartProvider = ({
+  partIndex,
+  children
+}) => {
+  const context = useContentPartContext2(partIndex);
+  return /* @__PURE__ */ jsx13(ContentPartContext.Provider, { value: context, children });
+};
+
+// src/primitives/contentPart/ContentPartDisplay.tsx
+var ContentPartDisplay = () => {
+  const { useContentPart } = useContentPartContext();
+  const display = useContentPart((c) => {
+    if (c.part.type !== "ui")
+      throw new Error(
+        "ContentPartDisplay can only be used inside ui content parts."
+      );
+    return c.part.display;
+  });
+  return display ?? null;
+};
+
+// src/primitives/contentPart/ContentPartInProgressIndicator.tsx
+var ContentPartInProgressIndicator = () => {
+  const { useMessage } = useMessageContext();
+  const { useContentPart } = useContentPartContext();
+  const indicator = useCombinedStore(
+    [useMessage, useContentPart],
+    (m, c) => c.status === "in_progress" ? m.inProgressIndicator : null
+  );
+  return indicator;
+};
+
+// src/primitives/contentPart/ContentPartText.tsx
+import {
+  Primitive as Primitive9
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef10 } from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var ContentPartText = forwardRef10((props, forwardedRef) => {
+  const { useContentPart } = useContentPartContext();
+  const text = useContentPart((c) => {
+    if (c.part.type !== "text")
+      throw new Error(
+        "ContentPartText can only be used inside text content parts."
+      );
+    return c.part.text;
+  });
+  return /* @__PURE__ */ jsx14(Primitive9.span, { ...props, ref: forwardedRef, children: text });
+});
+
+// src/primitives/message/MessageContent.tsx
+import { Fragment, jsx as jsx15, jsxs as jsxs3 } from "react/jsx-runtime";
+var defaultComponents = {
+  Text: () => /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx15(ContentPartText, {}),
+    /* @__PURE__ */ jsx15(ContentPartInProgressIndicator, {})
+  ] }),
+  Image: () => null,
+  UI: () => /* @__PURE__ */ jsx15(ContentPartDisplay, {}),
+  tools: {
+    Fallback: (props) => {
+      const { useToolRenderers } = useAssistantContext();
+      const Render = useToolRenderers(
+        (s) => s.getToolRenderer(props.part.toolName)
+      );
+      if (!Render) return null;
+      return /* @__PURE__ */ jsx15(Render, { ...props });
+    }
+  }
+};
+var MessageContentPartComponent = ({
+  components: {
+    Text = defaultComponents.Text,
+    Image = defaultComponents.Image,
+    UI = defaultComponents.UI,
+    tools: { by_name = {}, Fallback = defaultComponents.tools.Fallback } = {}
+  } = {}
+}) => {
+  const { useContentPart } = useContentPartContext();
+  const { part, status } = useContentPart();
+  const type = part.type;
+  switch (type) {
+    case "text":
+      return /* @__PURE__ */ jsx15(Text, { part, status });
+    case "image":
+      return /* @__PURE__ */ jsx15(Image, { part, status });
+    case "ui":
+      return /* @__PURE__ */ jsx15(UI, { part, status });
+    case "tool-call": {
+      const Tool = by_name[part.toolName] || Fallback;
+      return /* @__PURE__ */ jsx15(Tool, { part, status });
+    }
+    default:
+      throw new Error(`Unknown content part type: ${type}`);
+  }
+};
+var MessageContentPartImpl = ({
+  partIndex,
+  components
+}) => {
+  return /* @__PURE__ */ jsx15(ContentPartProvider, { partIndex, children: /* @__PURE__ */ jsx15(MessageContentPartComponent, { components }) });
+};
+var MessageContentPart = memo2(
+  MessageContentPartImpl,
+  (prev, next) => prev.partIndex === next.partIndex && prev.components?.Text === next.components?.Text && prev.components?.Image === next.components?.Image && prev.components?.UI === next.components?.UI && prev.components?.tools === next.components?.tools
+);
+var MessageContent = ({ components }) => {
+  const { useMessage } = useMessageContext();
+  const contentLength = useMessage((s) => s.message.content.length);
+  return new Array(contentLength).fill(null).map((_, idx) => {
+    const partIndex = idx;
+    return /* @__PURE__ */ jsx15(
+      MessageContentPart,
+      {
+        partIndex,
+        components
+      },
+      partIndex
+    );
+  });
+};
+
+// src/primitives/message/MessageInProgress.tsx
+import {
+  Primitive as Primitive10
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef11, useMemo as useMemo2 } from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var MessageInProgress = forwardRef11((props, ref) => {
+  const { useMessage } = useMessageContext();
+  useMemo2(() => {
+    useMessage.getState().setInProgressIndicator(/* @__PURE__ */ jsx16(Primitive10.span, { ...props, ref }));
+  }, [useMessage, props, ref]);
+  return null;
+});
+
+// src/primitives/branchPicker/index.ts
+var branchPicker_exports = {};
+__export(branchPicker_exports, {
+  Count: () => BranchPickerCount,
+  Next: () => BranchPickerNext,
+  Number: () => BranchPickerNumber,
+  Previous: () => BranchPickerPrevious,
+  Root: () => BranchPickerRoot
+});
+
+// src/utils/createActionButton.tsx
+import { composeEventHandlers as composeEventHandlers8 } from "@radix-ui/primitive";
+import {
+  Primitive as Primitive11
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef12 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var createActionButton = (useActionButton) => {
+  return forwardRef12(
+    (props, forwardedRef) => {
+      const onClick = useActionButton(props);
+      return /* @__PURE__ */ jsx17(
+        Primitive11.button,
+        {
+          type: "button",
+          disabled: !onClick,
+          ...props,
+          ref: forwardedRef,
+          onClick: composeEventHandlers8(props.onClick, onClick ?? void 0)
+        }
+      );
+    }
+  );
+};
+
+// src/primitives/branchPicker/BranchPickerNext.tsx
+var BranchPickerNext = createActionButton(useGoToNextBranch);
+
+// src/primitives/branchPicker/BranchPickerPrevious.tsx
+var BranchPickerPrevious = createActionButton(useGoToPreviousBranch);
+
+// src/primitives/branchPicker/BranchPickerCount.tsx
+import { Fragment as Fragment2, jsx as jsx18 } from "react/jsx-runtime";
+var BranchPickerCount = () => {
+  const { useMessage } = useMessageContext();
+  const branchCount = useMessage((s) => s.branches.length);
+  return /* @__PURE__ */ jsx18(Fragment2, { children: branchCount });
+};
+
+// src/primitives/branchPicker/BranchPickerNumber.tsx
+import { Fragment as Fragment3, jsx as jsx19 } from "react/jsx-runtime";
+var BranchPickerNumber = () => {
+  const { useMessage } = useMessageContext();
+  const branchIdx = useMessage((s) => s.branches.indexOf(s.message.id));
+  return /* @__PURE__ */ jsx19(Fragment3, { children: branchIdx + 1 });
+};
+
+// src/primitives/branchPicker/BranchPickerRoot.tsx
+import {
+  Primitive as Primitive12
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef13 } from "react";
+import { jsx as jsx20 } from "react/jsx-runtime";
+var BranchPickerRoot = forwardRef13(({ hideWhenSingleBranch, ...rest }, ref) => {
+  return /* @__PURE__ */ jsx20(MessageIf, { hasBranches: hideWhenSingleBranch ? true : void 0, children: /* @__PURE__ */ jsx20(Primitive12.div, { ...rest, ref }) });
+});
+
+// src/primitives/actionBar/index.ts
+var actionBar_exports = {};
+__export(actionBar_exports, {
+  Copy: () => ActionBarCopy,
+  Edit: () => ActionBarEdit,
+  Reload: () => ActionBarReload,
+  Root: () => ActionBarRoot
+});
+
+// src/primitives/actionBar/ActionBarRoot.tsx
+import {
+  Primitive as Primitive13
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef14 } from "react";
+import { jsx as jsx21 } from "react/jsx-runtime";
+var ActionBarRoot = forwardRef14(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
+  const { useThread } = useThreadContext();
+  const { useMessage } = useMessageContext();
+  const hideAndfloatStatus = useCombinedStore(
+    [useThread, useMessage],
+    (t, m) => {
+      if (hideWhenRunning && t.isRunning) return "hidden" /* Hidden */;
+      const autohideEnabled = autohide === "always" || autohide === "not-last" && !m.isLast;
+      if (!autohideEnabled) return "normal" /* Normal */;
+      if (!m.isHovering) return "hidden" /* Hidden */;
+      if (autohideFloat === "always" || autohideFloat === "single-branch" && m.branches.length <= 1)
+        return "floating" /* Floating */;
+      return "normal" /* Normal */;
+    }
+  );
+  if (hideAndfloatStatus === "hidden" /* Hidden */) return null;
+  return /* @__PURE__ */ jsx21(
+    Primitive13.div,
+    {
+      ...hideAndfloatStatus === "floating" /* Floating */ ? { "data-floating": "true" } : null,
+      ...rest,
+      ref
+    }
+  );
+});
+
+// src/primitives/actionBar/ActionBarCopy.tsx
+var ActionBarCopy = createActionButton(useCopyMessage);
+
+// src/primitives/actionBar/ActionBarReload.tsx
+var ActionBarReload = createActionButton(useReloadMessage);
+
+// src/primitives/actionBar/ActionBarEdit.tsx
+var ActionBarEdit = createActionButton(useBeginMessageEdit);
+
+// src/primitives/contentPart/index.ts
+var contentPart_exports = {};
+__export(contentPart_exports, {
+  Display: () => ContentPartDisplay,
+  Image: () => ContentPartImage,
+  InProgressIndicator: () => ContentPartInProgressIndicator,
+  Text: () => ContentPartText
+});
+
+// src/primitives/contentPart/ContentPartImage.tsx
+import {
+  Primitive as Primitive14
+} from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef15 } from "react";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var ContentPartImage = forwardRef15((props, forwardedRef) => {
+  const { useContentPart } = useContentPartContext();
+  const image = useContentPart((c) => {
+    if (c.part.type !== "image")
+      throw new Error(
+        "ContentPartImage can only be used inside image content parts."
+      );
+    return c.part.image;
+  });
+  return /* @__PURE__ */ jsx22(Primitive14.img, { src: image, ...props, ref: forwardedRef });
+});
+
+// src/runtime/local/useLocalRuntime.tsx
+import { useInsertionEffect, useState as useState3 } from "react";
+
+// src/utils/ModelConfigTypes.ts
+var mergeModelConfigs = (configSet) => {
+  const configs = Array.from(configSet).map((c) => c()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  return configs.reduce((acc, config) => {
+    if (config.system) {
+      if (acc.system) {
+        acc.system += `
+
+${config.system}`;
+      } else {
+        acc.system = config.system;
+      }
+    }
+    if (config.tools) {
+      for (const [name, tool] of Object.entries(config.tools)) {
+        if (acc.tools?.[name]) {
+          throw new Error(
+            `You tried to define a tool with the name ${name}, but it already exists.`
+          );
+        }
+        if (!acc.tools) acc.tools = {};
+        acc.tools[name] = tool;
+      }
+    }
+    return acc;
+  }, {});
+};
+
+// src/runtime/utils/idUtils.tsx
+import { customAlphabet } from "nanoid/non-secure";
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var optimisticPrefix = "__optimistic__";
+var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
+
+// src/runtime/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;
+    }
+  }
+  appendOptimisticMessage(parentId, message) {
+    let optimisticId;
+    do {
+      optimisticId = generateOptimisticId();
+    } while (this.messages.has(optimisticId));
+    this.addOrUpdateMessage(parentId, {
+      ...message,
+      id: optimisticId,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...message.role === "assistant" ? { status: "in_progress" } : void 0
+    });
+    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/runtime/local/LocalRuntime.tsx
+var LocalRuntime = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  _configProviders = /* @__PURE__ */ new Set();
+  abortController = null;
+  repository = new MessageRepository();
+  get messages() {
+    return this.repository.getMessages();
+  }
+  get isRunning() {
+    return this.abortController != null;
+  }
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.notifySubscribers();
+  }
+  async append(message) {
+    const userMessageId = generateId();
+    const userMessage = {
+      id: userMessageId,
+      role: "user",
+      content: message.content,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.repository.addOrUpdateMessage(message.parentId, userMessage);
+    await this.startRun(userMessageId);
+  }
+  async startRun(parentId) {
+    const id = generateId();
+    this.repository.resetHead(parentId);
+    const messages = this.repository.getMessages();
+    const message = {
+      id,
+      role: "assistant",
+      status: "in_progress",
+      content: [{ type: "text", text: "" }],
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.repository.addOrUpdateMessage(parentId, { ...message });
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    this.notifySubscribers();
+    try {
+      const updateHandler = ({ content }) => {
+        message.content = content;
+        this.repository.addOrUpdateMessage(parentId, { ...message });
+        this.notifySubscribers();
+      };
+      const result = await this.adapter.run({
+        messages,
+        abortSignal: this.abortController.signal,
+        config: mergeModelConfigs(this._configProviders),
+        onUpdate: updateHandler
+      });
+      updateHandler(result);
+      message.status = "done";
+      this.repository.addOrUpdateMessage(parentId, { ...message });
+    } catch (e) {
+      message.status = "error";
+      this.repository.addOrUpdateMessage(parentId, { ...message });
+      console.error(e);
+    } finally {
+      this.abortController = null;
+      this.notifySubscribers();
+    }
+  }
+  cancelRun() {
+    if (!this.abortController) return;
+    this.abortController.abort();
+    this.abortController = null;
+    this.notifySubscribers();
+  }
+  notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  registerModelConfigProvider(provider) {
+    this._configProviders.add(provider);
+    return () => this._configProviders.delete(provider);
+  }
+};
+
+// src/runtime/local/useLocalRuntime.tsx
+var useLocalRuntime = (adapter) => {
+  const [runtime] = useState3(() => new LocalRuntime(adapter));
+  useInsertionEffect(() => {
+    runtime.adapter = adapter;
+  });
+  return runtime;
+};
+
+// src/context/providers/AssistantRuntimeProvider.tsx
+import { memo as memo3 } from "react";
+
+// src/context/providers/AssistantProvider.tsx
+import { useEffect as useEffect7, useInsertionEffect as useInsertionEffect3, useRef as useRef5, useState as useState5 } from "react";
+
+// src/context/stores/AssistantModelConfig.ts
+import { create as create4 } from "zustand";
+
+// 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/context/stores/AssistantModelConfig.ts
+var makeAssistantModelConfigStore = () => create4(() => {
+  const proxy = new ProxyConfigProvider();
+  return {
+    getModelConfig: () => {
+      return proxy.getModelConfig();
+    },
+    registerModelConfigProvider: (provider) => {
+      return proxy.registerModelConfigProvider(provider);
+    }
+  };
+});
+
+// src/context/stores/AssistantToolRenderers.ts
+import { create as create5 } from "zustand";
+var makeAssistantToolRenderersStore = () => create5((set) => {
+  const renderers = /* @__PURE__ */ new Map();
+  return {
+    getToolRenderer: (name) => {
+      const arr = renderers.get(name);
+      const last = arr?.at(-1);
+      if (last) return last;
+      return null;
+    },
+    setToolRenderer: (name, render) => {
+      let arr = renderers.get(name);
+      if (!arr) {
+        arr = [];
+        renderers.set(name, arr);
+      }
+      arr.push(render);
+      set({});
+      return () => {
+        const index = arr.indexOf(render);
+        if (index !== -1) {
+          arr.splice(index, 1);
+        }
+        set({});
+      };
+    }
+  };
+});
+
+// src/context/providers/ThreadProvider.tsx
+import { useEffect as useEffect6, useInsertionEffect as useInsertionEffect2, useRef as useRef4, useState as useState4 } from "react";
+
+// src/context/stores/Composer.ts
+import { create as create6 } from "zustand";
+var makeComposerStore = (useThread) => create6()((set, get, store) => {
+  return {
+    ...makeBaseComposer(set, get, store),
+    isEditing: true,
+    send: () => {
+      const { setValue, value } = get();
+      setValue("");
+      useThread.getState().append({
+        parentId: useThread.getState().messages.at(-1)?.id ?? null,
+        content: [{ type: "text", text: value }]
+      });
+    },
+    cancel: () => {
+      const thread = useThread.getState();
+      if (!thread.isRunning) return false;
+      useThread.getState().cancelRun();
+      return true;
+    }
+  };
+});
+
+// src/context/stores/Thread.ts
+import { create as create7 } from "zustand";
+var makeThreadStore = (runtimeRef) => {
+  const useThread = create7(() => ({
+    messages: runtimeRef.current.messages,
+    isRunning: runtimeRef.current.isRunning,
+    getBranches: (messageId) => runtimeRef.current.getBranches(messageId),
+    switchToBranch: (branchId) => runtimeRef.current.switchToBranch(branchId),
+    startRun: (parentId) => runtimeRef.current.startRun(parentId),
+    append: (message) => runtimeRef.current.append(message),
+    cancelRun: () => runtimeRef.current.cancelRun()
+  }));
+  const onRuntimeUpdate = () => {
+    useThread.setState({
+      messages: runtimeRef.current.messages,
+      isRunning: runtimeRef.current.isRunning
+    });
+  };
+  return {
+    useThread,
+    onRuntimeUpdate
+  };
+};
+
+// src/context/stores/ThreadViewport.tsx
+import { create as create8 } from "zustand";
+var makeThreadViewportStore = () => {
+  const scrollToBottomListeners = /* @__PURE__ */ new Set();
+  return create8(() => ({
+    isAtBottom: true,
+    scrollToBottom: () => {
+      for (const listener of scrollToBottomListeners) {
+        listener();
+      }
+    },
+    onScrollToBottom: (callback) => {
+      scrollToBottomListeners.add(callback);
+      return () => {
+        scrollToBottomListeners.delete(callback);
+      };
+    }
+  }));
+};
+
+// src/context/providers/ThreadProvider.tsx
+import { jsx as jsx23, jsxs as jsxs4 } from "react/jsx-runtime";
+var ThreadProvider = ({
+  children,
+  runtime
+}) => {
+  const runtimeRef = useRef4(runtime);
+  useInsertionEffect2(() => {
+    runtimeRef.current = runtime;
+  });
+  const [{ context, onRuntimeUpdate }] = useState4(() => {
+    const { useThread, onRuntimeUpdate: onRuntimeUpdate2 } = makeThreadStore(runtimeRef);
+    const useViewport = makeThreadViewportStore();
+    const useComposer = makeComposerStore(useThread);
+    return {
+      context: {
+        useViewport,
+        useThread,
+        useComposer
+      },
+      onRuntimeUpdate: onRuntimeUpdate2
+    };
+  });
+  useEffect6(() => {
+    onRuntimeUpdate();
+    return runtime.subscribe(onRuntimeUpdate);
+  }, [onRuntimeUpdate, runtime]);
+  const RuntimeSynchronizer = runtime.unstable_synchronizer;
+  return /* @__PURE__ */ jsxs4(ThreadContext.Provider, { value: context, children: [
+    RuntimeSynchronizer && /* @__PURE__ */ jsx23(RuntimeSynchronizer, {}),
+    children
+  ] });
+};
+
+// src/context/providers/AssistantProvider.tsx
+import { jsx as jsx24 } from "react/jsx-runtime";
+var AssistantProvider = ({ children, runtime }) => {
+  const runtimeRef = useRef5(runtime);
+  useInsertionEffect3(() => {
+    runtimeRef.current = runtime;
+  });
+  const [context] = useState5(() => {
+    const useModelConfig = makeAssistantModelConfigStore();
+    const useToolRenderers = makeAssistantToolRenderersStore();
+    return { useModelConfig, useToolRenderers };
+  });
+  const getModelCOnfig = context.useModelConfig((c) => c.getModelConfig);
+  useEffect7(() => {
+    return runtime.registerModelConfigProvider(getModelCOnfig);
+  }, [runtime, getModelCOnfig]);
+  return /* @__PURE__ */ jsx24(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ jsx24(ThreadProvider, { runtime, children }) });
+};
+
+// src/context/providers/AssistantRuntimeProvider.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
+  return /* @__PURE__ */ jsx25(AssistantProvider, { runtime, children });
+};
+var AssistantRuntimeProvider = memo3(AssistantRuntimeProviderImpl);
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  MessageRepository: () => MessageRepository,
+  ProxyConfigProvider: () => ProxyConfigProvider
+});
+export {
+  actionBar_exports as ActionBarPrimitive,
+  AssistantRuntimeProvider,
+  branchPicker_exports as BranchPickerPrimitive,
+  composer_exports as ComposerPrimitive,
+  contentPart_exports as ContentPartPrimitive,
+  internal_exports as INTERNAL,
+  message_exports as MessagePrimitive,
+  thread_exports as ThreadPrimitive,
+  useBeginMessageEdit,
+  useCopyMessage,
+  useGoToNextBranch,
+  useGoToPreviousBranch,
+  useLocalRuntime,
+  useReloadMessage
+};
+//# sourceMappingURL=index.mjs.map