@assistant-ui/react 0.3.4 → 0.4.0

package/dist/index.js

@@ -1,3 +1,4 @@
+"use client";
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -31,14 +32,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ActionBarPrimitive: () => actionBar_exports,
+  AssistantActionBar: () => assistant_action_bar_default,
+  AssistantMessage: () => assistant_message_default,
+  AssistantModal: () => assistant_modal_default,
   AssistantModalPrimitive: () => assistantModal_exports,
   AssistantRuntimeProvider: () => AssistantRuntimeProvider,
+  BranchPicker: () => branch_picker_default,
   BranchPickerPrimitive: () => branchPicker_exports,
+  Composer: () => composer_default,
   ComposerPrimitive: () => composer_exports,
+  ContentPart: () => content_part_default,
   ContentPartPrimitive: () => contentPart_exports,
+  EditComposer: () => edit_composer_default,
   INTERNAL: () => internal_exports,
   MessagePrimitive: () => message_exports,
+  Thread: () => thread_default,
+  ThreadConfigProvider: () => ThreadConfigProvider,
   ThreadPrimitive: () => thread_exports,
+  ThreadWelcome: () => thread_welcome_default,
+  UserActionBar: () => user_action_bar_default,
+  UserMessage: () => user_message_default,
   makeAssistantTool: () => makeAssistantTool,
   makeAssistantToolUI: () => makeAssistantToolUI,
   useActionBarCopy: () => useActionBarCopy,
@@ -61,10 +74,12 @@ __export(src_exports, {
   useContentPartDisplay: () => useContentPartDisplay,
   useContentPartImage: () => useContentPartImage,
   useContentPartText: () => useContentPartText,
+  useEdgeRuntime: () => useEdgeRuntime,
   useLocalRuntime: () => useLocalRuntime,
   useMessageContext: () => useMessageContext,
   useMessageIf: () => useMessageIf,
   useSwitchToNewThread: () => useSwitchToNewThread,
+  useThreadConfig: () => useThreadConfig,
   useThreadContext: () => useThreadContext,
   useThreadEmpty: () => useThreadEmpty,
   useThreadIf: () => useThreadIf,
@@ -84,14 +99,14 @@ var import_react = require("react");
 var AssistantContext = (0, import_react.createContext)(
   null
 );
-var useAssistantContext = () => {
+function useAssistantContext(options) {
   const context = (0, import_react.useContext)(AssistantContext);
-  if (!context)
+  if (!options?.optional && !context)
     throw new Error(
       "This component must be used within an AssistantRuntimeProvider."
     );
   return context;
-};
+}
 
 // src/context/stores/AssistantModelConfig.ts
 var import_zustand = require("zustand");
@@ -189,14 +204,14 @@ var import_react3 = require("react");
 // src/context/react/ThreadContext.ts
 var import_react2 = require("react");
 var ThreadContext = (0, import_react2.createContext)(null);
-var useThreadContext = () => {
+function useThreadContext(options) {
   const context = (0, import_react2.useContext)(ThreadContext);
-  if (!context)
+  if (!options?.optional && !context)
     throw new Error(
       "This component must be used within an AssistantRuntimeProvider."
     );
   return context;
-};
+}
 
 // src/context/stores/Composer.ts
 var import_zustand3 = require("zustand");
@@ -287,7 +302,7 @@ var makeThreadActionStore = (runtimeRef) => {
       startRun: (parentId) => runtimeRef.current.startRun(parentId),
       append: (message) => runtimeRef.current.append(message),
       cancelRun: () => runtimeRef.current.cancelRun(),
-      addToolResult: (toolCallId, result) => runtimeRef.current.addToolResult(toolCallId, result)
+      addToolResult: (options) => runtimeRef.current.addToolResult(options)
     })
   );
 };
@@ -391,19 +406,19 @@ var import_react7 = require("react");
 // src/context/react/MessageContext.ts
 var import_react6 = require("react");
 var MessageContext = (0, import_react6.createContext)(null);
-var useMessageContext = () => {
+function useMessageContext(options) {
   const context = (0, import_react6.useContext)(MessageContext);
-  if (!context)
+  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 } = (0, import_react7.useContext)(MessageContext) ?? {};
+  const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
   return (0, import_react7.useMemo)(
     () => ({
       useComposer: useEditComposer ?? useComposer,
@@ -418,14 +433,14 @@ var import_react8 = require("react");
 var ContentPartContext = (0, import_react8.createContext)(
   null
 );
-var useContentPartContext = () => {
+function useContentPartContext(options) {
   const context = (0, import_react8.useContext)(ContentPartContext);
-  if (!context)
+  if (!options?.optional && !context)
     throw new Error(
       "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
     );
   return context;
-};
+}
 
 // src/hooks/useAppendMessage.tsx
 var import_react9 = require("react");
@@ -591,9 +606,10 @@ var useActionBarCopy = ({
     const { setIsCopied } = useMessageUtils.getState();
     const { isEditing, value: composerValue } = useEditComposer.getState();
     const valueToCopy = isEditing ? composerValue : getMessageText(message);
-    navigator.clipboard.writeText(valueToCopy);
-    setIsCopied(true);
-    setTimeout(() => setIsCopied(false), copiedDuration);
+    navigator.clipboard.writeText(valueToCopy).then(() => {
+      setIsCopied(true);
+      setTimeout(() => setIsCopied(false), copiedDuration);
+    });
   }, [useMessage, useMessageUtils, useEditComposer, copiedDuration]);
   if (!hasCopyableContent) return null;
   return callback;
@@ -770,6 +786,7 @@ var useMessageIf = (props) => {
       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.system && message.role !== "system") return false;
       if (props.lastOrHover === true && !isHovering && !isLast) return false;
       if (props.copied === true && !isCopied) return false;
       if (props.copied === false && isCopied) return false;
@@ -1156,9 +1173,9 @@ var useIsHoveringRef = () => {
   );
   return useManagedRef(callbackRef);
 };
-var MessagePrimitiveRoot = (0, import_react33.forwardRef)(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef15) => {
+var MessagePrimitiveRoot = (0, import_react33.forwardRef)(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef28) => {
   const isHoveringRef = useIsHoveringRef();
-  const ref = (0, import_react_compose_refs.useComposedRefs)(forwardRef15, isHoveringRef);
+  const ref = (0, import_react_compose_refs.useComposedRefs)(forwardRef28, isHoveringRef);
   return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_react_primitive3.Primitive.div, { ...rest, ref });
 });
 MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
@@ -1180,11 +1197,12 @@ var import_react38 = require("react");
 var import_react34 = require("react");
 var import_zustand9 = require("zustand");
 var import_jsx_runtime13 = require("react/jsx-runtime");
+var DONE_STATUS = { type: "done" };
 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 messageStatus = message.role === "assistant" ? message.status : DONE_STATUS;
+  const status = partIndex === message.content.length - 1 ? messageStatus : DONE_STATUS;
   const currentState = useContentPart.getState();
   if (currentState.part === part && currentState.status === status) return;
   useContentPart.setState(
@@ -1331,11 +1349,9 @@ var ContentPartPrimitiveDisplay = () => {
 ContentPartPrimitiveDisplay.displayName = "ContentPartPrimitive.Display";
 
 // src/primitives/contentPart/ContentPartInProgress.tsx
-var ContentPartPrimitiveInProgress = ({
-  children
-}) => {
+var ContentPartPrimitiveInProgress = ({ children }) => {
   const { useContentPart } = useContentPartContext();
-  const isInProgress = useContentPart((c) => c.status === "in_progress");
+  const isInProgress = useContentPart((c) => c.status.type === "in_progress");
   return isInProgress ? children : null;
 };
 ContentPartPrimitiveInProgress.displayName = "ContentPartPrimitive.InProgress";
@@ -1360,31 +1376,37 @@ var defaultComponents = {
 };
 var MessageContentPartComponent = ({
   components: {
-    Text = defaultComponents.Text,
-    Image = defaultComponents.Image,
+    Text: Text2 = defaultComponents.Text,
+    Image: Image2 = defaultComponents.Image,
     UI = defaultComponents.UI,
-    tools: { by_name = {}, Fallback = defaultComponents.tools.Fallback } = {}
+    tools: { by_name = {}, Fallback: Fallback2 = defaultComponents.tools.Fallback } = {}
   } = {}
 }) => {
   const { useThreadActions } = useThreadContext();
+  const { useMessage } = useMessageContext();
   const addToolResult = useThreadActions((t) => t.addToolResult);
   const { useContentPart } = useContentPartContext();
   const { part, status } = useContentPart();
   const type = part.type;
   switch (type) {
     case "text":
-      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Text, { part, status });
+      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Text2, { part, status });
     case "image":
-      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Image, { part, status });
+      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Image2, { part, status });
     case "ui":
       return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(UI, { part, status });
     case "tool-call": {
-      const Tool = by_name[part.toolName] || Fallback;
-      const addResult = (result) => addToolResult(part.toolCallId, result);
+      const Tool = by_name[part.toolName] || Fallback2;
+      const addResult = (result) => addToolResult({
+        messageId: useMessage.getState().message.id,
+        toolCallId: part.toolCallId,
+        result
+      });
       return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Tool, { part, status, addResult });
     }
     default:
-      throw new Error(`Unknown content part type: ${type}`);
+      const unhandledType = type;
+      throw new Error(`Unknown content part type: ${unhandledType}`);
   }
 };
 var MessageContentPartImpl = ({
@@ -1869,29 +1891,32 @@ var MessageProvider = ({
 
 // src/primitives/thread/ThreadMessages.tsx
 var import_jsx_runtime24 = require("react/jsx-runtime");
+var DEFAULT_SYSTEM_MESSAGE = () => null;
 var getComponents = (components) => {
   return {
     EditComposer: components.EditComposer ?? components.UserMessage ?? components.Message,
     UserMessage: components.UserMessage ?? components.Message,
-    AssistantMessage: components.AssistantMessage ?? components.Message
+    AssistantMessage: components.AssistantMessage ?? components.Message,
+    SystemMessage: components.SystemMessage ?? DEFAULT_SYSTEM_MESSAGE
   };
 };
 var ThreadMessageImpl = ({
   messageIndex,
   components
 }) => {
-  const { UserMessage, EditComposer, AssistantMessage } = getComponents(components);
+  const { UserMessage: UserMessage2, EditComposer: EditComposer2, AssistantMessage: AssistantMessage2, SystemMessage: SystemMessage2 } = getComponents(components);
   return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(MessageProvider, { messageIndex, children: [
     /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(MessagePrimitiveIf, { user: true, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(UserMessage, {}) }),
-      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(EditComposer, {}) })
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(UserMessage2, {}) }),
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(EditComposer2, {}) })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(AssistantMessage, {}) })
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(AssistantMessage2, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MessagePrimitiveIf, { system: true, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(SystemMessage2, {}) })
   ] });
 };
 var ThreadMessage = (0, import_react49.memo)(
   ThreadMessageImpl,
-  (prev, next) => prev.messageIndex === next.messageIndex && prev.components.Message === next.components.Message && prev.components.UserMessage === next.components.UserMessage && prev.components.EditComposer === next.components.EditComposer && prev.components.AssistantMessage === next.components.AssistantMessage
+  (prev, next) => prev.messageIndex === next.messageIndex && prev.components.Message === next.components.Message && prev.components.UserMessage === next.components.UserMessage && prev.components.EditComposer === next.components.EditComposer && prev.components.AssistantMessage === next.components.AssistantMessage && prev.components.SystemMessage === next.components.SystemMessage
 );
 var ThreadPrimitiveMessagesImpl = ({
   components
@@ -1914,7 +1939,7 @@ var ThreadPrimitiveMessagesImpl = ({
 ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
 var ThreadPrimitiveMessages = (0, import_react49.memo)(
   ThreadPrimitiveMessagesImpl,
-  (prev, next) => prev.components?.Message === next.components?.Message && prev.components?.UserMessage === next.components?.UserMessage && prev.components?.EditComposer === next.components?.EditComposer && prev.components?.AssistantMessage === next.components?.AssistantMessage
+  (prev, next) => prev.components?.Message === next.components?.Message && prev.components?.UserMessage === next.components?.UserMessage && prev.components?.EditComposer === next.components?.EditComposer && prev.components?.AssistantMessage === next.components?.AssistantMessage && prev.components?.SystemMessage === next.components?.SystemMessage
 );
 
 // src/primitives/thread/ThreadScrollToBottom.tsx
@@ -1929,10 +1954,10 @@ var ThreadPrimitiveSuggestion = createActionButton(
   useThreadSuggestion
 );
 
-// src/runtime/local/useLocalRuntime.tsx
+// src/runtimes/local/useLocalRuntime.tsx
 var import_react50 = require("react");
 
-// src/runtime/utils/idUtils.tsx
+// src/utils/idUtils.tsx
 var import_non_secure = require("nanoid/non-secure");
 var generateId = (0, import_non_secure.customAlphabet)(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
@@ -1941,7 +1966,7 @@ var generateId = (0, import_non_secure.customAlphabet)(
 var optimisticPrefix = "__optimistic__";
 var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
 
-// src/runtime/utils/MessageRepository.tsx
+// src/runtimes/utils/MessageRepository.tsx
 var findHead = (message) => {
   if (message.next) return findHead(message.next);
   return message;
@@ -2015,6 +2040,17 @@ var MessageRepository = class {
       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 {
@@ -2092,7 +2128,7 @@ var MessageRepository = class {
   }
 };
 
-// src/runtime/core/BaseAssistantRuntime.tsx
+// src/runtimes/core/BaseAssistantRuntime.tsx
 var BaseAssistantRuntime = class {
   constructor(_thread) {
     this._thread = _thread;
@@ -2133,8 +2169,8 @@ var BaseAssistantRuntime = class {
   cancelRun() {
     return this.thread.cancelRun();
   }
-  addToolResult(toolCallId, result) {
-    return this.thread.addToolResult(toolCallId, result);
+  addToolResult(options) {
+    return this.thread.addToolResult(options);
   }
   _subscriptions = /* @__PURE__ */ new Set();
   subscribe(callback) {
@@ -2149,7 +2185,7 @@ var BaseAssistantRuntime = class {
   }
 };
 
-// src/runtime/local/LocalRuntime.tsx
+// src/runtimes/local/LocalRuntime.tsx
 var LocalRuntime = class extends BaseAssistantRuntime {
   _configProviders;
   constructor(adapter) {
@@ -2220,7 +2256,7 @@ var LocalThreadRuntime = class {
     const message = {
       id,
       role: "assistant",
-      status: "in_progress",
+      status: { type: "in_progress" },
       content: [{ type: "text", text: "" }],
       createdAt: /* @__PURE__ */ new Date()
     };
@@ -2240,11 +2276,17 @@ var LocalThreadRuntime = class {
         config: mergeModelConfigs(this._configProviders),
         onUpdate: updateHandler
       });
-      updateHandler(result);
-      message.status = "done";
+      if (result !== void 0) {
+        updateHandler(result);
+      }
+      if (result.status?.type === "in_progress")
+        throw new Error(
+          "Unexpected in_progress status returned from ChatModelAdapter"
+        );
+      message.status = result.status ?? { type: "done" };
       this.repository.addOrUpdateMessage(parentId, { ...message });
     } catch (e) {
-      message.status = "error";
+      message.status = { type: "error", error: e };
       this.repository.addOrUpdateMessage(parentId, { ...message });
       console.error(e);
     } finally {
@@ -2265,12 +2307,30 @@ var LocalThreadRuntime = class {
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-  addToolResult() {
-    throw new Error("LocalRuntime does not yet support adding tool results");
+  addToolResult({ messageId, toolCallId, result }) {
+    const { parentId, message } = this.repository.getMessage(messageId);
+    if (message.role !== "assistant")
+      throw new Error("Tried to add tool re^sult to non-assistant message");
+    let found = false;
+    const newContent = message.content.map((c) => {
+      if (c.type !== "tool-call") return c;
+      if (c.toolCallId !== toolCallId) return c;
+      found = true;
+      return {
+        ...c,
+        result
+      };
+    });
+    if (!found)
+      throw new Error("Tried to add tool result to non-existing tool call");
+    this.repository.addOrUpdateMessage(parentId, {
+      ...message,
+      content: newContent
+    });
   }
 };
 
-// src/runtime/local/useLocalRuntime.tsx
+// src/runtimes/local/useLocalRuntime.tsx
 var useLocalRuntime = (adapter) => {
   const [runtime] = (0, import_react50.useState)(() => new LocalRuntime(adapter));
   (0, import_react50.useInsertionEffect)(() => {
@@ -2279,25 +2339,1494 @@ var useLocalRuntime = (adapter) => {
   return runtime;
 };
 
+// src/runtimes/edge/streams/assistantDecoderStream.ts
+function assistantDecoderStream() {
+  let currentToolCall;
+  return new TransformStream({
+    transform(chunk, controller) {
+      const [code, valueJson] = chunk.split(":");
+      const value = JSON.parse(valueJson);
+      if (currentToolCall && code !== "2" /* ToolCallArgsTextDelta */ && code !== "E" /* Error */) {
+        controller.enqueue({
+          type: "tool-call",
+          toolCallType: "function",
+          toolCallId: currentToolCall.id,
+          toolName: currentToolCall.name,
+          args: JSON.parse(currentToolCall.argsText)
+        });
+        currentToolCall = void 0;
+      }
+      switch (code) {
+        case "0" /* TextDelta */: {
+          controller.enqueue({
+            type: "text-delta",
+            textDelta: value
+          });
+          break;
+        }
+        case "1" /* ToolCallBegin */: {
+          const { id, name } = JSON.parse(value);
+          currentToolCall = { id, name, argsText: "" };
+          break;
+        }
+        case "2" /* ToolCallArgsTextDelta */: {
+          const delta = JSON.parse(value);
+          currentToolCall.argsText += delta;
+          controller.enqueue({
+            type: "tool-call-delta",
+            toolCallType: "function",
+            toolCallId: currentToolCall.id,
+            toolName: currentToolCall.name,
+            argsTextDelta: delta
+          });
+          break;
+        }
+        case "F" /* Finish */: {
+          controller.enqueue({
+            type: "finish",
+            ...JSON.parse(value)
+          });
+          break;
+        }
+        case "E" /* Error */: {
+          controller.enqueue({
+            type: "error",
+            error: JSON.parse(value)
+          });
+          break;
+        }
+        default: {
+          const unhandledType = code;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    }
+  });
+}
+
+// src/runtimes/edge/streams/chunkByLineStream.ts
+function chunkByLineStream() {
+  let buffer = "";
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      for (let i = 0; i < lines.length - 1; i++) {
+        controller.enqueue(lines[i]);
+      }
+      buffer = lines[lines.length - 1];
+    },
+    flush(controller) {
+      if (buffer) {
+        controller.enqueue(buffer);
+      }
+    }
+  });
+}
+
+// src/runtimes/edge/partial-json/parse-partial-json.ts
+var import_secure_json_parse = __toESM(require("secure-json-parse"));
+
+// src/runtimes/edge/partial-json/fix-json.ts
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/runtimes/edge/partial-json/parse-partial-json.ts
+var parsePartialJson = (json) => {
+  try {
+    return import_secure_json_parse.default.parse(json);
+  } catch {
+    try {
+      return import_secure_json_parse.default.parse(fixJson(json));
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/runtimes/edge/streams/runResultStream.ts
+function runResultStream() {
+  let message = {
+    content: []
+  };
+  const currentToolCall = { toolCallId: "", argsText: "" };
+  return new TransformStream({
+    transform(chunk, controller) {
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "text-delta": {
+          message = appendOrUpdateText(message, chunk.textDelta);
+          controller.enqueue(message);
+          break;
+        }
+        case "tool-call-delta": {
+          const { toolCallId, toolName, argsTextDelta } = chunk;
+          if (currentToolCall.toolCallId !== toolCallId) {
+            currentToolCall.toolCallId = toolCallId;
+            currentToolCall.argsText = argsTextDelta;
+          } else {
+            currentToolCall.argsText += argsTextDelta;
+          }
+          message = appendOrUpdateToolCall(
+            message,
+            toolCallId,
+            toolName,
+            parsePartialJson(currentToolCall.argsText)
+          );
+          controller.enqueue(message);
+          break;
+        }
+        case "tool-call": {
+          break;
+        }
+        case "tool-result": {
+          message = appendOrUpdateToolResult(
+            message,
+            chunk.toolCallId,
+            chunk.toolName,
+            chunk.result
+          );
+          controller.enqueue(message);
+          break;
+        }
+        case "finish": {
+          message = appendOrUpdateFinish(message, chunk);
+          controller.enqueue(message);
+          break;
+        }
+        case "error": {
+          throw chunk.error;
+        }
+        default: {
+          const unhandledType = chunkType;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    }
+  });
+}
+var appendOrUpdateText = (message, textDelta) => {
+  let contentParts = message.content;
+  let contentPart = message.content.at(-1);
+  if (contentPart?.type !== "text") {
+    contentPart = { type: "text", text: textDelta };
+  } else {
+    contentParts = contentParts.slice(0, -1);
+    contentPart = { type: "text", text: contentPart.text + textDelta };
+  }
+  return {
+    ...message,
+    content: contentParts.concat([contentPart])
+  };
+};
+var appendOrUpdateToolCall = (message, toolCallId, toolName, args) => {
+  let contentParts = message.content;
+  let contentPart = message.content.at(-1);
+  if (contentPart?.type !== "tool-call" || contentPart.toolCallId !== toolCallId) {
+    contentPart = {
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      args
+    };
+  } else {
+    contentParts = contentParts.slice(0, -1);
+    contentPart = {
+      ...contentPart,
+      args
+    };
+  }
+  return {
+    ...message,
+    content: contentParts.concat([contentPart])
+  };
+};
+var appendOrUpdateToolResult = (message, toolCallId, toolName, result) => {
+  let found = false;
+  const newContentParts = message.content.map((part) => {
+    if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
+      return part;
+    found = true;
+    if (part.toolName !== toolName)
+      throw new Error(
+        `Tool call ${toolCallId} found with tool name ${part.toolName}, but expected ${toolName}`
+      );
+    return {
+      ...part,
+      result
+    };
+  });
+  if (!found)
+    throw new Error(
+      `Received tool result for unknown tool call "${toolName}" / "${toolCallId}". This is likely an internal bug in assistant-ui.`
+    );
+  return {
+    ...message,
+    content: newContentParts
+  };
+};
+var appendOrUpdateFinish = (message, chunk) => {
+  const { type, ...rest } = chunk;
+  return {
+    ...message,
+    status: {
+      type: "done",
+      ...rest
+    }
+  };
+};
+
+// src/runtimes/edge/useEdgeRuntime.ts
+var import_react51 = require("react");
+
+// src/runtimes/edge/streams/toolResultStream.ts
+var import_zod = require("zod");
+var import_secure_json_parse2 = __toESM(require("secure-json-parse"));
+function toolResultStream(tools) {
+  const toolCallExecutions = /* @__PURE__ */ new Map();
+  return new TransformStream({
+    transform(chunk, controller) {
+      controller.enqueue(chunk);
+      const chunkType = chunk.type;
+      switch (chunkType) {
+        case "tool-call": {
+          const { toolCallId, toolCallType, toolName, args: argsText } = chunk;
+          const tool = tools?.[toolName];
+          if (!tool) return;
+          const args = import_secure_json_parse2.default.parse(argsText);
+          if (tool.parameters instanceof import_zod.z.ZodType) {
+            const result = tool.parameters.safeParse(args);
+            if (!result.success) {
+              controller.enqueue({
+                type: "error",
+                error: new Error("Invalid tool call arguments")
+              });
+              return;
+            } else {
+              toolCallExecutions.set(
+                toolCallId,
+                (async () => {
+                  try {
+                    const result2 = await tool.execute(args);
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallType,
+                      toolCallId,
+                      toolName,
+                      result: result2
+                    });
+                  } catch (error) {
+                    controller.enqueue({
+                      type: "error",
+                      error
+                    });
+                  } finally {
+                    toolCallExecutions.delete(toolCallId);
+                  }
+                })()
+              );
+            }
+          }
+          break;
+        }
+        case "text-delta":
+        case "tool-call-delta":
+        case "finish":
+        case "error":
+          break;
+        default: {
+          const unhandledType = chunkType;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    },
+    async flush() {
+      await Promise.all(toolCallExecutions.values());
+    }
+  });
+}
+
+// src/runtimes/edge/useEdgeRuntime.ts
+var import_zod2 = require("zod");
+var import_zod_to_json_schema = require("zod-to-json-schema");
+function asAsyncIterable(source) {
+  return {
+    [Symbol.asyncIterator]: () => {
+      const reader = source.getReader();
+      return {
+        async next() {
+          const { done, value } = await reader.read();
+          return done ? { done: true, value: void 0 } : { done: false, value };
+        }
+      };
+    }
+  };
+}
+var toSerializableTools = (tools) => {
+  if (!tools) return [];
+  return Object.entries(tools).map(([name, tool]) => ({
+    type: "function",
+    name,
+    ...tool.description ? { description: tool.description } : void 0,
+    parameters: tool.parameters instanceof import_zod2.z.ZodType ? (0, import_zod_to_json_schema.zodToJsonSchema)(tool.parameters) : tool.parameters
+  }));
+};
+var createEdgeChatAdapter = ({
+  api
+}) => ({
+  run: async ({ messages, abortSignal, config, onUpdate }) => {
+    const result = await fetch(api, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        system: config.system,
+        messages,
+        tools: toSerializableTools(
+          config.tools
+        )
+      }),
+      signal: abortSignal
+    });
+    const stream = result.body.pipeThrough(new TextDecoderStream()).pipeThrough(chunkByLineStream()).pipeThrough(assistantDecoderStream()).pipeThrough(toolResultStream(config.tools)).pipeThrough(runResultStream());
+    let update;
+    for await (update of asAsyncIterable(stream)) {
+      onUpdate(update);
+    }
+    if (update === void 0)
+      throw new Error("No data received from Edge Runtime");
+    return update;
+  }
+});
+var useEdgeRuntime = (options) => {
+  const adapter = (0, import_react51.useMemo)(() => createEdgeChatAdapter(options), [options]);
+  return useLocalRuntime(adapter);
+};
+
+// src/ui/thread-config.tsx
+var import_react52 = require("react");
+var import_jsx_runtime25 = require("react/jsx-runtime");
+var ThreadConfigContext = (0, import_react52.createContext)({});
+var useThreadConfig = () => {
+  return (0, import_react52.useContext)(ThreadConfigContext);
+};
+var ThreadConfigProvider = ({
+  children,
+  config
+}) => {
+  const assistant = useAssistantContext({ optional: true });
+  const configProvider = config && Object.keys(config ?? {}).length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_jsx_runtime25.Fragment, { children });
+  if (!config?.runtime) return configProvider;
+  if (assistant) {
+    throw new Error(
+      "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(AssistantRuntimeProvider, { runtime: config.runtime, children: configProvider });
+};
+ThreadConfigProvider.displayName = "ThreadConfigProvider";
+
+// src/ui/assistant-action-bar.tsx
+var import_react56 = require("react");
+var import_lucide_react = require("lucide-react");
+
+// src/ui/base/tooltip-icon-button.tsx
+var import_react55 = require("react");
+
+// src/ui/base/tooltip.tsx
+var TooltipPrimitive = __toESM(require("@radix-ui/react-tooltip"));
+
+// src/ui/utils/withDefaults.tsx
+var import_react53 = require("react");
+var import_classnames = __toESM(require("classnames"));
+var import_jsx_runtime26 = require("react/jsx-runtime");
+var withDefaultProps = ({
+  className,
+  ...defaultProps
+}) => ({ className: classNameProp, ...props }) => {
+  return {
+    className: (0, import_classnames.default)(className, classNameProp),
+    ...defaultProps,
+    ...props
+  };
+};
+var withDefaults = (Component, defaultProps) => {
+  const getProps = withDefaultProps(defaultProps);
+  const WithDefaults = (0, import_react53.forwardRef)(
+    (props, ref) => {
+      const ComponentAsAny = Component;
+      return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(ComponentAsAny, { ...getProps(props), ref });
+    }
+  );
+  WithDefaults.displayName = "withDefaults(" + (typeof Component === "string" ? Component : Component.displayName) + ")";
+  return WithDefaults;
+};
+
+// src/ui/base/tooltip.tsx
+var import_jsx_runtime27 = require("react/jsx-runtime");
+var Tooltip = (props) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(TooltipPrimitive.Provider, { children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(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
+var import_class_variance_authority = require("class-variance-authority");
+var import_react_primitive11 = require("@radix-ui/react-primitive");
+var import_react54 = require("react");
+var import_jsx_runtime28 = require("react/jsx-runtime");
+var buttonVariants = (0, import_class_variance_authority.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 = (0, import_react54.forwardRef)(
+  ({ className, variant, size, ...props }, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
+      import_react_primitive11.Primitive.button,
+      {
+        className: buttonVariants({ variant, size, className }),
+        ...props,
+        ref
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/ui/base/tooltip-icon-button.tsx
+var import_jsx_runtime29 = require("react/jsx-runtime");
+var TooltipIconButton = (0, import_react55.forwardRef)(({ children, tooltip, side = "bottom", ...rest }, ref) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)(Tooltip, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)(Button, { variant: "ghost", size: "icon", ...rest, ref, children: [
+      children,
+      /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("span", { className: "aui-sr-only", children: tooltip })
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(TooltipContent, { side, children: tooltip })
+  ] });
+});
+TooltipIconButton.displayName = "TooltipIconButton";
+
+// src/ui/assistant-action-bar.tsx
+var import_jsx_runtime30 = require("react/jsx-runtime");
+var useAllowCopy = () => {
+  const { assistantMessage: { allowCopy = true } = {} } = useThreadConfig();
+  const { useThreadActions } = useThreadContext();
+  const copySupported = useThreadActions((t) => t.capabilities.copy);
+  return copySupported && allowCopy;
+};
+var useAllowReload = () => {
+  const { assistantMessage: { allowReload = true } = {} } = useThreadConfig();
+  const { useThreadActions } = useThreadContext();
+  const reloadSupported = useThreadActions((t) => t.capabilities.reload);
+  return reloadSupported && allowReload;
+};
+var AssistantActionBar = () => {
+  const allowCopy = useAllowCopy();
+  const allowReload = useAllowReload();
+  if (!allowCopy && !allowReload) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)(
+    AssistantActionBarRoot,
+    {
+      hideWhenRunning: true,
+      autohide: "not-last",
+      autohideFloat: "single-branch",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(AssistantActionBarCopy, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(AssistantActionBarReload, {})
+      ]
+    }
+  );
+};
+AssistantActionBar.displayName = "AssistantActionBar";
+var AssistantActionBarRoot = withDefaults(actionBar_exports.Root, {
+  className: "aui-assistant-action-bar-root"
+});
+AssistantActionBarRoot.displayName = "AssistantActionBarRoot";
+var AssistantActionBarCopy = (0, import_react56.forwardRef)((props, ref) => {
+  const {
+    strings: {
+      assistantMessage: { reload: { tooltip = "Copy" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  const allowCopy = useAllowCopy();
+  if (!allowCopy) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(actionBar_exports.Copy, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)(TooltipIconButton, { tooltip, ...props, ref, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(message_exports.If, { copied: true, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_lucide_react.CheckIcon, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(message_exports.If, { copied: false, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_lucide_react.CopyIcon, {}) })
+  ] }) });
+});
+AssistantActionBarCopy.displayName = "AssistantActionBarCopy";
+var AssistantActionBarReload = (0, import_react56.forwardRef)((props, ref) => {
+  const {
+    strings: {
+      assistantMessage: { reload: { tooltip = "Refresh" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  const allowReload = useAllowReload();
+  if (!allowReload) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(actionBar_exports.Reload, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_lucide_react.RefreshCwIcon, {}) }) });
+});
+AssistantActionBarReload.displayName = "AssistantActionBarReload";
+var exports2 = {
+  Root: AssistantActionBarRoot,
+  Reload: AssistantActionBarReload,
+  Copy: AssistantActionBarCopy
+};
+var assistant_action_bar_default = Object.assign(
+  AssistantActionBar,
+  exports2
+);
+
+// src/ui/assistant-message.tsx
+var import_react58 = require("react");
+
+// src/ui/branch-picker.tsx
+var import_react57 = require("react");
+var import_lucide_react2 = require("lucide-react");
+var import_jsx_runtime31 = require("react/jsx-runtime");
+var BranchPicker = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)(BranchPickerRoot, { hideWhenSingleBranch: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(BranchPickerPrevious2, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(BranchPickerState, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(BranchPickerNext, {})
+  ] });
+};
+BranchPicker.displayName = "BranchPicker";
+var BranchPickerRoot = withDefaults(branchPicker_exports.Root, {
+  className: "aui-branch-picker-root"
+});
+BranchPickerRoot.displayName = "BranchPickerRoot";
+var BranchPickerPrevious2 = (0, import_react57.forwardRef)((props, ref) => {
+  const {
+    strings: {
+      branchPicker: { previous: { tooltip = "Previous" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(branchPicker_exports.Previous, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(import_lucide_react2.ChevronLeftIcon, {}) }) });
+});
+BranchPickerPrevious2.displayName = "BranchPickerPrevious";
+var BranchPickerStateWrapper = withDefaults("span", {
+  className: "aui-branch-picker-state"
+});
+var BranchPickerState = (0, import_react57.forwardRef)((props, ref) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)(BranchPickerStateWrapper, { ...props, ref, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(branchPicker_exports.Number, {}),
+    " / ",
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(branchPicker_exports.Count, {})
+  ] });
+});
+BranchPickerState.displayName = "BranchPickerState";
+var BranchPickerNext = (0, import_react57.forwardRef)((props, ref) => {
+  const {
+    strings: { branchPicker: { next: { tooltip = "Next" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(branchPicker_exports.Next, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(import_lucide_react2.ChevronRightIcon, {}) }) });
+});
+BranchPickerNext.displayName = "BranchPickerNext";
+var exports3 = {
+  Root: BranchPickerRoot,
+  Previous: BranchPickerPrevious2,
+  Next: BranchPickerNext
+};
+var branch_picker_default = Object.assign(BranchPicker, exports3);
+
+// src/ui/base/avatar.tsx
+var AvatarPrimitive = __toESM(require("@radix-ui/react-avatar"));
+var import_jsx_runtime32 = require("react/jsx-runtime");
+var Avatar = ({ src, alt, fallback }) => {
+  if (src == null && fallback == null) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(AvatarRoot, { children: [
+    src != null && /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(AvatarImage, { src, alt }),
+    fallback != null && /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(AvatarFallback, { children: fallback })
+  ] });
+};
+Avatar.displayName = "Avatar";
+var AvatarRoot = withDefaults(AvatarPrimitive.Root, {
+  className: "aui-avatar-root"
+});
+AvatarRoot.displayName = "AvatarRoot";
+var AvatarImage = withDefaults(AvatarPrimitive.Image, {
+  className: "aui-avatar-image"
+});
+AvatarImage.displayName = "AvatarImage";
+var AvatarFallback = withDefaults(AvatarPrimitive.Fallback, {
+  className: "aui-avatar-fallback"
+});
+AvatarFallback.displayName = "AvatarFallback";
+
+// src/ui/content-part.tsx
+var import_classnames2 = __toESM(require("classnames"));
+var import_jsx_runtime33 = require("react/jsx-runtime");
+var Text = ({ status }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+    "p",
+    {
+      className: (0, import_classnames2.default)(
+        "aui-text",
+        status.type === "in_progress" && "aui-text-in-progress"
+      ),
+      children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(contentPart_exports.Text, {})
+    }
+  );
+};
+var exports4 = { Text };
+var content_part_default = exports4;
+
+// src/ui/assistant-message.tsx
+var import_jsx_runtime34 = require("react/jsx-runtime");
+var AssistantMessage = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(AssistantMessageRoot, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AssistantMessageAvatar, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AssistantMessageContent, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(branch_picker_default, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(assistant_action_bar_default, {})
+  ] });
+};
+AssistantMessage.displayName = "AssistantMessage";
+var AssistantMessageAvatar = () => {
+  const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Avatar, { ...avatar });
+};
+var AssistantMessageRoot = withDefaults(message_exports.Root, {
+  className: "aui-assistant-message-root"
+});
+AssistantMessageRoot.displayName = "AssistantMessageRoot";
+var AssistantMessageContentWrapper = withDefaults("div", {
+  className: "aui-assistant-message-content"
+});
+var AssistantMessageContent = (0, import_react58.forwardRef)(({ components: componentsProp, ...rest }, ref) => {
+  const { assistantMessage: { components = {} } = {} } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AssistantMessageContentWrapper, { ...rest, ref, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+    message_exports.Content,
+    {
+      components: {
+        ...componentsProp,
+        Text: componentsProp?.Text ?? components.Text ?? content_part_default.Text
+      }
+    }
+  ) });
+});
+AssistantMessageContent.displayName = "AssistantMessageContent";
+var exports5 = {
+  Root: AssistantMessageRoot,
+  Avatar: AssistantMessageAvatar,
+  Content: AssistantMessageContent
+};
+var assistant_message_default = Object.assign(
+  AssistantMessage,
+  exports5
+);
+
+// src/ui/assistant-modal.tsx
+var import_react65 = require("react");
+var import_lucide_react6 = require("lucide-react");
+
+// src/ui/thread.tsx
+var import_react64 = require("react");
+var import_lucide_react5 = require("lucide-react");
+
+// src/ui/composer.tsx
+var import_react59 = require("react");
+var import_lucide_react3 = require("lucide-react");
+
+// src/ui/base/CircleStopIcon.tsx
+var import_jsx_runtime35 = require("react/jsx-runtime");
+var CircleStopIcon = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 16 16",
+      fill: "currentColor",
+      children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("rect", { width: "10", height: "10", x: "3", y: "3", rx: "2" })
+    }
+  );
+};
+CircleStopIcon.displayName = "CircleStopIcon";
+
+// src/ui/composer.tsx
+var import_jsx_runtime36 = require("react/jsx-runtime");
+var Composer = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(ComposerRoot, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerInput, { autoFocus: true }),
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerAction, {})
+  ] });
+};
+Composer.displayName = "Composer";
+var ComposerRoot = withDefaults(composer_exports.Root, {
+  className: "aui-composer-root"
+});
+ComposerRoot.displayName = "ComposerRoot";
+var ComposerInputStyled = withDefaults(composer_exports.Input, {
+  rows: 1,
+  autoFocus: true,
+  className: "aui-composer-input"
+});
+var ComposerInput = (0, import_react59.forwardRef)(
+  (props, ref) => {
+    const {
+      strings: {
+        composer: { input: { placeholder = "Write a message..." } = {} } = {}
+      } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerInputStyled, { placeholder, ...props, ref });
+  }
+);
+ComposerInput.displayName = "ComposerInput";
+var useAllowCancel = () => {
+  const { useThreadActions } = useThreadContext();
+  const cancelSupported = useThreadActions((t) => t.capabilities.cancel);
+  return cancelSupported;
+};
+var ComposerAction = () => {
+  const allowCancel = useAllowCancel();
+  if (!allowCancel) return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerSend, {});
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(import_jsx_runtime36.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(thread_exports.If, { running: false, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerSend, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(thread_exports.If, { running: true, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerCancel, {}) })
+  ] });
+};
+ComposerAction.displayName = "ComposerAction";
+var ComposerSendButton = withDefaults(TooltipIconButton, {
+  variant: "default",
+  className: "aui-composer-send"
+});
+var ComposerSend = (0, import_react59.forwardRef)((props, ref) => {
+  const {
+    strings: { composer: { send: { tooltip = "Send" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerSendButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(import_lucide_react3.SendHorizonalIcon, {}) }) });
+});
+ComposerSend.displayName = "ComposerSend";
+var ComposerCancelButton = withDefaults(TooltipIconButton, {
+  variant: "default",
+  className: "aui-composer-cancel"
+});
+var ComposerCancel = (0, import_react59.forwardRef)((props, ref) => {
+  const {
+    strings: { composer: { cancel: { tooltip = "Cancel" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ComposerCancelButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(CircleStopIcon, {}) }) });
+});
+ComposerCancel.displayName = "ComposerCancel";
+var exports6 = {
+  Root: ComposerRoot,
+  Input: ComposerInput,
+  Action: ComposerAction,
+  Send: ComposerSend,
+  Cancel: ComposerCancel
+};
+var composer_default = Object.assign(Composer, exports6);
+
+// src/ui/thread-welcome.tsx
+var import_react60 = require("react");
+var import_jsx_runtime37 = require("react/jsx-runtime");
+var ThreadWelcome = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)(ThreadWelcomeRoot, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)(ThreadWelcomeCenter, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeAvatar, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeMessage, {})
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeSuggestions, {})
+  ] });
+};
+ThreadWelcome.displayName = "ThreadWelcome";
+var ThreadWelcomeRootStyled = withDefaults("div", {
+  className: "aui-thread-welcome-root"
+});
+var ThreadWelcomeCenter = withDefaults("div", {
+  className: "aui-thread-welcome-center"
+});
+var ThreadWelcomeRoot = (0, import_react60.forwardRef)(
+  (props, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(thread_exports.Empty, { children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeRootStyled, { ...props, ref }) });
+  }
+);
+ThreadWelcomeRoot.displayName = "ThreadWelcomeRoot";
+var ThreadWelcomeAvatar = () => {
+  const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(Avatar, { ...avatar });
+};
+var ThreadWelcomeMessageStyled = withDefaults("p", {
+  className: "aui-thread-welcome-message"
+});
+var ThreadWelcomeMessage = (0, import_react60.forwardRef)(({ message: messageProp, ...rest }, ref) => {
+  const { welcome: { message = "How can I help you today?" } = {} } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeMessageStyled, { ...rest, ref, children: messageProp ?? message });
+});
+ThreadWelcomeMessage.displayName = "ThreadWelcomeMessage";
+var ThreadWelcomeSuggestionContainer = withDefaults("div", {
+  className: "aui-thread-welcome-suggestion-container"
+});
+var ThreadWelcomeSuggestionStyled = withDefaults(thread_exports.Suggestion, {
+  className: "aui-thread-welcome-suggestion"
+});
+var ThreadWelcomeSuggestion = ({
+  suggestion: { text, prompt }
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
+    ThreadWelcomeSuggestionStyled,
+    {
+      prompt: prompt ?? text,
+      method: "replace",
+      autoSend: true,
+      children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("span", { className: "aui-thread-welcome-suggestion-text", children: text })
+    }
+  );
+};
+var ThreadWelcomeSuggestions = () => {
+  const { welcome: { suggestions } = {} } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeSuggestionContainer, { children: suggestions?.map((suggestion, idx) => {
+    const key = `${suggestion.prompt}-${idx}`;
+    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(ThreadWelcomeSuggestion, { suggestion }, key);
+  }) });
+};
+ThreadWelcomeSuggestions.displayName = "ThreadWelcomeSuggestions";
+var exports7 = {
+  Root: ThreadWelcomeRoot,
+  Center: ThreadWelcomeCenter,
+  Avatar: ThreadWelcomeAvatar,
+  Message: ThreadWelcomeMessage,
+  Suggestions: ThreadWelcomeSuggestions,
+  Suggestion: ThreadWelcomeSuggestion
+};
+var thread_welcome_default = Object.assign(ThreadWelcome, exports7);
+
+// src/ui/user-message.tsx
+var import_react62 = require("react");
+
+// src/ui/user-action-bar.tsx
+var import_react61 = require("react");
+var import_lucide_react4 = require("lucide-react");
+var import_jsx_runtime38 = require("react/jsx-runtime");
+var useAllowEdit = () => {
+  const { userMessage: { allowEdit = true } = {} } = useThreadConfig();
+  const { useThreadActions } = useThreadContext();
+  const editSupported = useThreadActions((t) => t.capabilities.edit);
+  return editSupported && allowEdit;
+};
+var UserActionBar = () => {
+  const allowEdit = useAllowEdit();
+  if (!allowEdit) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(UserActionBarRoot, { hideWhenRunning: true, autohide: "not-last", children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(UserActionBarEdit, {}) });
+};
+UserActionBar.displayName = "UserActionBar";
+var UserActionBarRoot = withDefaults(actionBar_exports.Root, {
+  className: "aui-user-action-bar-root"
+});
+UserActionBarRoot.displayName = "UserActionBarRoot";
+var UserActionBarEdit = (0, import_react61.forwardRef)((props, ref) => {
+  const {
+    strings: { userMessage: { edit: { tooltip = "Edit" } = {} } = {} } = {}
+  } = useThreadConfig();
+  const allowEdit = useAllowEdit();
+  if (!allowEdit) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(actionBar_exports.Edit, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(import_lucide_react4.PencilIcon, {}) }) });
+});
+UserActionBarEdit.displayName = "UserActionBarEdit";
+var exports8 = {
+  Root: UserActionBarRoot,
+  Edit: UserActionBarEdit
+};
+var user_action_bar_default = Object.assign(UserActionBar, exports8);
+
+// src/ui/user-message.tsx
+var import_jsx_runtime39 = require("react/jsx-runtime");
+var UserMessage = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)(UserMessageRoot, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(user_action_bar_default, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(UserMessageContent, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(branch_picker_default, {})
+  ] });
+};
+UserMessage.displayName = "UserMessage";
+var UserMessageRoot = withDefaults(message_exports.Root, {
+  className: "aui-user-message-root"
+});
+UserMessageRoot.displayName = "UserMessageRoot";
+var UserMessageContentWrapper = withDefaults("div", {
+  className: "aui-user-message-content"
+});
+var UserMessageContent = (0, import_react62.forwardRef)(
+  ({ components, ...props }, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(UserMessageContentWrapper, { ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
+      message_exports.Content,
+      {
+        components: {
+          ...components,
+          Text: components?.Text ?? content_part_default.Text
+        }
+      }
+    ) });
+  }
+);
+UserMessageContent.displayName = "UserMessageContent";
+var exports9 = {
+  Root: UserMessageRoot,
+  Content: UserMessageContent
+};
+var user_message_default = Object.assign(UserMessage, exports9);
+
+// src/ui/edit-composer.tsx
+var import_react63 = require("react");
+var import_jsx_runtime40 = require("react/jsx-runtime");
+var EditComposer = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)(EditComposerRoot, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(EditComposerInput, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)(EditComposerFooter, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(EditComposerCancel, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(EditComposerSend, {})
+    ] })
+  ] });
+};
+EditComposer.displayName = "EditComposer";
+var EditComposerRoot = withDefaults(composer_exports.Root, {
+  className: "aui-edit-composer-root"
+});
+EditComposerRoot.displayName = "EditComposerRoot";
+var EditComposerInput = withDefaults(composer_exports.Input, {
+  className: "aui-edit-composer-input"
+});
+EditComposerInput.displayName = "EditComposerInput";
+var EditComposerFooter = withDefaults("div", {
+  className: "aui-edit-composer-footer"
+});
+EditComposerFooter.displayName = "EditComposerFooter";
+var EditComposerCancel = (0, import_react63.forwardRef)(
+  (props, ref) => {
+    const {
+      strings: {
+        editComposer: { cancel: { label = "Cancel" } = {} } = {}
+      } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Button, { variant: "ghost", ...props, ref, children: label }) });
+  }
+);
+EditComposerCancel.displayName = "EditComposerCancel";
+var EditComposerSend = (0, import_react63.forwardRef)(
+  (props, ref) => {
+    const {
+      strings: { editComposer: { send: { label = "Send" } = {} } = {} } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Button, { ...props, ref, children: label }) });
+  }
+);
+EditComposerSend.displayName = "EditComposerSend";
+var exports10 = {
+  Root: EditComposerRoot,
+  Input: EditComposerInput,
+  Footer: EditComposerFooter,
+  Cancel: EditComposerCancel,
+  Send: EditComposerSend
+};
+var edit_composer_default = Object.assign(EditComposer, exports10);
+
+// src/ui/thread.tsx
+var import_jsx_runtime41 = require("react/jsx-runtime");
+var Thread = (config) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadRoot, { config, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(ThreadViewport, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(thread_welcome_default, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadMessages, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(ThreadViewportFooter, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadScrollToBottom, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(composer_default, {})
+    ] })
+  ] }) });
+};
+var ThreadRootStyled = withDefaults(thread_exports.Root, {
+  className: "aui-root aui-thread-root"
+});
+var ThreadRoot = (0, import_react64.forwardRef)(
+  ({ config, ...props }, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadConfigProvider, { config, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadRootStyled, { ...props, ref }) });
+  }
+);
+ThreadRoot.displayName = "ThreadRoot";
+var ThreadViewport = withDefaults(thread_exports.Viewport, {
+  className: "aui-thread-viewport"
+});
+ThreadViewport.displayName = "ThreadViewport";
+var ThreadViewportFooter = withDefaults("div", {
+  className: "aui-thread-viewport-footer"
+});
+ThreadViewportFooter.displayName = "ThreadViewportFooter";
+var SystemMessage = () => null;
+var ThreadMessages = ({ components, ...rest }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+    thread_exports.Messages,
+    {
+      components: {
+        UserMessage: components?.UserMessage ?? user_message_default,
+        EditComposer: components?.EditComposer ?? edit_composer_default,
+        AssistantMessage: components?.AssistantMessage ?? assistant_message_default,
+        SystemMessage: components?.SystemMessage ?? SystemMessage
+      },
+      ...rest
+    }
+  );
+};
+ThreadMessages.displayName = "ThreadMessages";
+var ThreadScrollToBottomIconButton = withDefaults(TooltipIconButton, {
+  variant: "outline",
+  className: "aui-thread-scroll-to-bottom"
+});
+var ThreadScrollToBottom = (0, import_react64.forwardRef)((props, ref) => {
+  const {
+    strings: {
+      thread: { scrollToBottom: { tooltip = "Scroll to bottom" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(thread_exports.ScrollToBottom, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(ThreadScrollToBottomIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_lucide_react5.ArrowDownIcon, {}) }) });
+});
+ThreadScrollToBottom.displayName = "ThreadScrollToBottom";
+var exports11 = {
+  Root: ThreadRoot,
+  Viewport: ThreadViewport,
+  Messages: ThreadMessages,
+  ScrollToBottom: ThreadScrollToBottom,
+  ViewportFooter: ThreadViewportFooter
+};
+var thread_default = Object.assign(Thread, exports11);
+
+// src/ui/assistant-modal.tsx
+var import_jsx_runtime42 = require("react/jsx-runtime");
+var AssistantModal = (config) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)(AssistantModalRoot, { config, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(AssistantModalTrigger, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(AssistantModalContent, { children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(thread_default, {}) })
+  ] });
+};
+AssistantModal.displayName = "AssistantModal";
+var AssistantModalRoot = ({ config, ...props }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(ThreadConfigProvider, { config, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(assistantModal_exports.Root, { ...props }) });
+};
+AssistantModalRoot.displayName = "AssistantModalRoot";
+var AssistantModalTrigger = (0, import_react65.forwardRef)((props, ref) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(AssistantModalAnchor, { children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(assistantModal_exports.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(AssistantModalButton, { ...props, ref }) }) });
+});
+AssistantModalTrigger.displayName = "AssistantModalTrigger";
+var AssistantModalAnchor = withDefaults(assistantModal_exports.Anchor, {
+  className: "aui-root aui-modal-anchor"
+});
+AssistantModalAnchor.displayName = "AssistantModalAnchor";
+var ModalButtonStyled = withDefaults(TooltipIconButton, {
+  variant: "default",
+  className: "aui-modal-button"
+});
+var AssistantModalButton = (0, import_react65.forwardRef)(({ "data-state": state, ...rest }, ref) => {
+  const {
+    strings: {
+      assistantModal: {
+        open: {
+          button: { tooltip: openTooltip = "Close Assistant" } = {}
+        } = {},
+        closed: {
+          button: { tooltip: closedTooltip = "Open Assistant" } = {}
+        } = {}
+      } = {}
+    } = {}
+  } = useThreadConfig();
+  const tooltip = state === "open" ? openTooltip : closedTooltip;
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)(
+    ModalButtonStyled,
+    {
+      side: "left",
+      tooltip,
+      "data-state": state,
+      ...rest,
+      ref,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_lucide_react6.BotIcon, { "data-state": state, className: "aui-modal-button-closed-icon" }),
+        /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+          import_lucide_react6.ChevronDownIcon,
+          {
+            "data-state": state,
+            className: "aui-modal-button-open-icon"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("span", { className: "aui-sr-only", children: tooltip })
+      ]
+    }
+  );
+});
+AssistantModalButton.displayName = "AssistantModalButton";
+var AssistantModalContent = withDefaults(assistantModal_exports.Content, {
+  className: "aui-root aui-modal-content",
+  sideOffset: 16
+});
+AssistantModalContent.displayName = "AssistantModalContent";
+var exports12 = {
+  Root: AssistantModalRoot,
+  Trigger: AssistantModalTrigger,
+  Content: AssistantModalContent
+};
+var assistant_modal_default = Object.assign(AssistantModal, exports12);
+
 // src/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
   BaseAssistantRuntime: () => BaseAssistantRuntime,
   MessageRepository: () => MessageRepository,
   ProxyConfigProvider: () => ProxyConfigProvider,
+  TooltipIconButton: () => TooltipIconButton,
   useSmooth: () => useSmooth
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActionBarPrimitive,
+  AssistantActionBar,
+  AssistantMessage,
+  AssistantModal,
   AssistantModalPrimitive,
   AssistantRuntimeProvider,
+  BranchPicker,
   BranchPickerPrimitive,
+  Composer,
   ComposerPrimitive,
+  ContentPart,
   ContentPartPrimitive,
+  EditComposer,
   INTERNAL,
   MessagePrimitive,
+  Thread,
+  ThreadConfigProvider,
   ThreadPrimitive,
+  ThreadWelcome,
+  UserActionBar,
+  UserMessage,
   makeAssistantTool,
   makeAssistantToolUI,
   useActionBarCopy,
@@ -2320,10 +3849,12 @@ __export(internal_exports, {
   useContentPartDisplay,
   useContentPartImage,
   useContentPartText,
+  useEdgeRuntime,
   useLocalRuntime,
   useMessageContext,
   useMessageIf,
   useSwitchToNewThread,
+  useThreadConfig,
   useThreadContext,
   useThreadEmpty,
   useThreadIf,