@assistant-ui/react 0.3.5 → 0.4.1

package/dist/index.mjs

@@ -1,3 +1,4 @@
+"use client";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,14 +16,14 @@ import { createContext, useContext } from "react";
 var AssistantContext = createContext(
   null
 );
-var useAssistantContext = () => {
+function useAssistantContext(options) {
   const context = 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
 import { create } from "zustand";
@@ -127,14 +128,14 @@ import {
 // src/context/react/ThreadContext.ts
 import { createContext as createContext2, useContext as useContext2 } from "react";
 var ThreadContext = createContext2(null);
-var useThreadContext = () => {
+function useThreadContext(options) {
   const context = useContext2(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
 import { create as create3 } from "zustand";
@@ -225,7 +226,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)
     })
   );
 };
@@ -324,24 +325,24 @@ var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
 var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
 
 // src/context/react/ComposerContext.ts
-import { useContext as useContext4, useMemo } from "react";
+import { useMemo } from "react";
 
 // src/context/react/MessageContext.ts
 import { createContext as createContext3, useContext as useContext3 } from "react";
 var MessageContext = createContext3(null);
-var useMessageContext = () => {
+function useMessageContext(options) {
   const context = useContext3(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 } = useContext4(MessageContext) ?? {};
+  const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
   return useMemo(
     () => ({
       useComposer: useEditComposer ?? useComposer,
@@ -352,18 +353,18 @@ var useComposerContext = () => {
 };
 
 // src/context/react/ContentPartContext.ts
-import { createContext as createContext4, useContext as useContext5 } from "react";
+import { createContext as createContext4, useContext as useContext4 } from "react";
 var ContentPartContext = createContext4(
   null
 );
-var useContentPartContext = () => {
-  const context = useContext5(ContentPartContext);
-  if (!context)
+function useContentPartContext(options) {
+  const context = useContext4(ContentPartContext);
+  if (!options?.optional && !context)
     throw new Error(
       "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
     );
   return context;
-};
+}
 
 // src/hooks/useAppendMessage.tsx
 import { useCallback as useCallback2 } from "react";
@@ -709,6 +710,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;
@@ -1098,9 +1100,9 @@ var useIsHoveringRef = () => {
   );
   return useManagedRef(callbackRef);
 };
-var MessagePrimitiveRoot = forwardRef6(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef15) => {
+var MessagePrimitiveRoot = forwardRef6(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef28) => {
   const isHoveringRef = useIsHoveringRef();
-  const ref = useComposedRefs(forwardRef15, isHoveringRef);
+  const ref = useComposedRefs(forwardRef28, isHoveringRef);
   return /* @__PURE__ */ jsx12(Primitive3.div, { ...rest, ref });
 });
 MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
@@ -1122,11 +1124,12 @@ import { memo as memo2 } from "react";
 import { useEffect as useEffect7, useState as useState4 } from "react";
 import { create as create9 } from "zustand";
 import { jsx as jsx13 } from "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(
@@ -1168,7 +1171,8 @@ import { forwardRef as forwardRef7 } from "react";
 // src/utils/hooks/useSmooth.tsx
 import { useEffect as useEffect8, useState as useState5 } from "react";
 var TextStreamAnimator = class {
-  constructor(setText) {
+  constructor(currentText, setText) {
+    this.currentText = currentText;
     this.setText = setText;
   }
   animationFrameId = null;
@@ -1189,33 +1193,31 @@ var TextStreamAnimator = class {
     const currentTime = Date.now();
     const deltaTime = currentTime - this.lastUpdateTime;
     let timeToConsume = deltaTime;
-    this.setText((currentText) => {
-      const targetText = this.targetText;
-      if (currentText === targetText) {
-        this.animationFrameId = null;
-        return currentText;
-      }
-      const remainingChars = targetText.length - currentText.length;
-      const baseTimePerChar = Math.min(5, 250 / remainingChars);
-      let charsToAdd = 0;
-      while (timeToConsume >= baseTimePerChar && charsToAdd < remainingChars) {
-        charsToAdd++;
-        timeToConsume -= baseTimePerChar;
-      }
+    const remainingChars = this.targetText.length - this.currentText.length;
+    const baseTimePerChar = Math.min(5, 250 / remainingChars);
+    let charsToAdd = 0;
+    while (timeToConsume >= baseTimePerChar && charsToAdd < remainingChars) {
+      charsToAdd++;
+      timeToConsume -= baseTimePerChar;
+    }
+    if (charsToAdd !== remainingChars) {
       this.animationFrameId = requestAnimationFrame(this.animate);
-      if (charsToAdd === 0) {
-        return currentText;
-      }
-      const newText = targetText.slice(0, currentText.length + charsToAdd);
-      this.lastUpdateTime = currentTime - timeToConsume;
-      return newText;
-    });
+    } else {
+      this.animationFrameId = null;
+    }
+    if (charsToAdd === 0) return;
+    this.currentText = this.targetText.slice(
+      0,
+      this.currentText.length + charsToAdd
+    );
+    this.lastUpdateTime = currentTime - timeToConsume;
+    this.setText(this.currentText);
   };
 };
 var useSmooth = (text, smooth = false) => {
   const [displayedText, setDisplayedText] = useState5(text);
   const [animatorRef] = useState5(
-    new TextStreamAnimator(setDisplayedText)
+    new TextStreamAnimator(text, setDisplayedText)
   );
   useEffect8(() => {
     if (!smooth) {
@@ -1224,6 +1226,7 @@ var useSmooth = (text, smooth = false) => {
     }
     if (!text.startsWith(animatorRef.targetText)) {
       setDisplayedText(text);
+      animatorRef.currentText = text;
       animatorRef.targetText = text;
       animatorRef.stop();
       return;
@@ -1273,11 +1276,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";
@@ -1302,31 +1303,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__ */ jsx16(Text, { part, status });
+      return /* @__PURE__ */ jsx16(Text2, { part, status });
     case "image":
-      return /* @__PURE__ */ jsx16(Image, { part, status });
+      return /* @__PURE__ */ jsx16(Image2, { part, status });
     case "ui":
       return /* @__PURE__ */ jsx16(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__ */ jsx16(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 = ({
@@ -1818,29 +1825,32 @@ var MessageProvider = ({
 
 // src/primitives/thread/ThreadMessages.tsx
 import { jsx as jsx24, jsxs as jsxs3 } from "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__ */ jsxs3(MessageProvider, { messageIndex, children: [
     /* @__PURE__ */ jsxs3(MessagePrimitiveIf, { user: true, children: [
-      /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ jsx24(UserMessage, {}) }),
-      /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx24(EditComposer, {}) })
+      /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ jsx24(UserMessage2, {}) }),
+      /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx24(EditComposer2, {}) })
     ] }),
-    /* @__PURE__ */ jsx24(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ jsx24(AssistantMessage, {}) })
+    /* @__PURE__ */ jsx24(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ jsx24(AssistantMessage2, {}) }),
+    /* @__PURE__ */ jsx24(MessagePrimitiveIf, { system: true, children: /* @__PURE__ */ jsx24(SystemMessage2, {}) })
   ] });
 };
 var ThreadMessage = memo3(
   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
@@ -1863,7 +1873,7 @@ var ThreadPrimitiveMessagesImpl = ({
 ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
 var ThreadPrimitiveMessages = memo3(
   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
@@ -1878,10 +1888,10 @@ var ThreadPrimitiveSuggestion = createActionButton(
   useThreadSuggestion
 );
 
-// src/runtime/local/useLocalRuntime.tsx
+// src/runtimes/local/useLocalRuntime.tsx
 import { useInsertionEffect as useInsertionEffect3, useState as useState7 } from "react";
 
-// src/runtime/utils/idUtils.tsx
+// src/utils/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
@@ -1890,7 +1900,7 @@ var generateId = 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;
@@ -1964,6 +1974,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 {
@@ -2041,7 +2062,7 @@ var MessageRepository = class {
   }
 };
 
-// src/runtime/core/BaseAssistantRuntime.tsx
+// src/runtimes/core/BaseAssistantRuntime.tsx
 var BaseAssistantRuntime = class {
   constructor(_thread) {
     this._thread = _thread;
@@ -2082,8 +2103,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) {
@@ -2098,7 +2119,7 @@ var BaseAssistantRuntime = class {
   }
 };
 
-// src/runtime/local/LocalRuntime.tsx
+// src/runtimes/local/LocalRuntime.tsx
 var LocalRuntime = class extends BaseAssistantRuntime {
   _configProviders;
   constructor(adapter) {
@@ -2169,7 +2190,7 @@ var LocalThreadRuntime = class {
     const message = {
       id,
       role: "assistant",
-      status: "in_progress",
+      status: { type: "in_progress" },
       content: [{ type: "text", text: "" }],
       createdAt: /* @__PURE__ */ new Date()
     };
@@ -2189,11 +2210,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 {
@@ -2214,12 +2241,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] = useState7(() => new LocalRuntime(adapter));
   useInsertionEffect3(() => {
@@ -2228,24 +2273,1495 @@ 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
+import sjson from "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 sjson.parse(json);
+  } catch {
+    try {
+      return sjson.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
+import { useMemo as useMemo3 } from "react";
+
+// src/runtimes/edge/streams/toolResultStream.ts
+import { z } from "zod";
+import sjson2 from "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 = sjson2.parse(argsText);
+          if (tool.parameters instanceof 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
+import { z as z2 } from "zod";
+import { zodToJsonSchema } from "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 z2.ZodType ? 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 = useMemo3(() => createEdgeChatAdapter(options), [options]);
+  return useLocalRuntime(adapter);
+};
+
+// src/ui/thread-config.tsx
+import { createContext as createContext5, useContext as useContext5 } from "react";
+import { Fragment as Fragment3, jsx as jsx25 } from "react/jsx-runtime";
+var ThreadConfigContext = createContext5({});
+var useThreadConfig = () => {
+  return useContext5(ThreadConfigContext);
+};
+var ThreadConfigProvider = ({
+  children,
+  config
+}) => {
+  const assistant = useAssistantContext({ optional: true });
+  const configProvider = config && Object.keys(config ?? {}).length > 0 ? /* @__PURE__ */ jsx25(ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ jsx25(Fragment3, { 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__ */ jsx25(AssistantRuntimeProvider, { runtime: config.runtime, children: configProvider });
+};
+ThreadConfigProvider.displayName = "ThreadConfigProvider";
+
+// src/ui/assistant-action-bar.tsx
+import { forwardRef as forwardRef18 } from "react";
+import { CheckIcon, CopyIcon, RefreshCwIcon } from "lucide-react";
+
+// src/ui/base/tooltip-icon-button.tsx
+import { forwardRef as forwardRef17 } from "react";
+
+// src/ui/base/tooltip.tsx
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+
+// src/ui/utils/withDefaults.tsx
+import {
+  forwardRef as forwardRef15
+} from "react";
+import classNames from "classnames";
+import { jsx as jsx26 } from "react/jsx-runtime";
+var withDefaultProps = ({
+  className,
+  ...defaultProps
+}) => ({ className: classNameProp, ...props }) => {
+  return {
+    className: classNames(className, classNameProp),
+    ...defaultProps,
+    ...props
+  };
+};
+var withDefaults = (Component, defaultProps) => {
+  const getProps = withDefaultProps(defaultProps);
+  const WithDefaults = forwardRef15(
+    (props, ref) => {
+      const ComponentAsAny = Component;
+      return /* @__PURE__ */ jsx26(ComponentAsAny, { ...getProps(props), ref });
+    }
+  );
+  WithDefaults.displayName = "withDefaults(" + (typeof Component === "string" ? Component : Component.displayName) + ")";
+  return WithDefaults;
+};
+
+// src/ui/base/tooltip.tsx
+import { jsx as jsx27 } from "react/jsx-runtime";
+var Tooltip = (props) => {
+  return /* @__PURE__ */ jsx27(TooltipPrimitive.Provider, { children: /* @__PURE__ */ jsx27(TooltipPrimitive.Root, { ...props }) });
+};
+Tooltip.displayName = "Tooltip";
+var TooltipTrigger = TooltipPrimitive.Trigger;
+var TooltipContent = withDefaults(TooltipPrimitive.Content, {
+  sideOffset: 4,
+  className: "aui-tooltip-content"
+});
+TooltipContent.displayName = "TooltipContent";
+
+// src/ui/base/button.tsx
+import { cva } from "class-variance-authority";
+import { Primitive as Primitive11 } from "@radix-ui/react-primitive";
+import { forwardRef as forwardRef16 } from "react";
+import { jsx as jsx28 } from "react/jsx-runtime";
+var buttonVariants = cva("aui-button", {
+  variants: {
+    variant: {
+      default: "aui-button-primary",
+      outline: "aui-button-outline",
+      ghost: "aui-button-ghost"
+    },
+    size: {
+      default: "aui-button-medium",
+      icon: "aui-button-icon"
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "default"
+  }
+});
+var Button = forwardRef16(
+  ({ className, variant, size, ...props }, ref) => {
+    return /* @__PURE__ */ jsx28(
+      Primitive11.button,
+      {
+        className: buttonVariants({ variant, size, className }),
+        ...props,
+        ref
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/ui/base/tooltip-icon-button.tsx
+import { jsx as jsx29, jsxs as jsxs4 } from "react/jsx-runtime";
+var TooltipIconButton = forwardRef17(({ children, tooltip, side = "bottom", ...rest }, ref) => {
+  return /* @__PURE__ */ jsxs4(Tooltip, { children: [
+    /* @__PURE__ */ jsx29(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs4(Button, { variant: "ghost", size: "icon", ...rest, ref, children: [
+      children,
+      /* @__PURE__ */ jsx29("span", { className: "aui-sr-only", children: tooltip })
+    ] }) }),
+    /* @__PURE__ */ jsx29(TooltipContent, { side, children: tooltip })
+  ] });
+});
+TooltipIconButton.displayName = "TooltipIconButton";
+
+// src/ui/assistant-action-bar.tsx
+import { jsx as jsx30, jsxs as jsxs5 } from "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__ */ jsxs5(
+    AssistantActionBarRoot,
+    {
+      hideWhenRunning: true,
+      autohide: "not-last",
+      autohideFloat: "single-branch",
+      children: [
+        /* @__PURE__ */ jsx30(AssistantActionBarCopy, {}),
+        /* @__PURE__ */ jsx30(AssistantActionBarReload, {})
+      ]
+    }
+  );
+};
+AssistantActionBar.displayName = "AssistantActionBar";
+var AssistantActionBarRoot = withDefaults(actionBar_exports.Root, {
+  className: "aui-assistant-action-bar-root"
+});
+AssistantActionBarRoot.displayName = "AssistantActionBarRoot";
+var AssistantActionBarCopy = forwardRef18((props, ref) => {
+  const {
+    strings: {
+      assistantMessage: { reload: { tooltip = "Copy" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  const allowCopy = useAllowCopy();
+  if (!allowCopy) return null;
+  return /* @__PURE__ */ jsx30(actionBar_exports.Copy, { asChild: true, children: /* @__PURE__ */ jsxs5(TooltipIconButton, { tooltip, ...props, ref, children: [
+    /* @__PURE__ */ jsx30(message_exports.If, { copied: true, children: /* @__PURE__ */ jsx30(CheckIcon, {}) }),
+    /* @__PURE__ */ jsx30(message_exports.If, { copied: false, children: /* @__PURE__ */ jsx30(CopyIcon, {}) })
+  ] }) });
+});
+AssistantActionBarCopy.displayName = "AssistantActionBarCopy";
+var AssistantActionBarReload = forwardRef18((props, ref) => {
+  const {
+    strings: {
+      assistantMessage: { reload: { tooltip = "Refresh" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  const allowReload = useAllowReload();
+  if (!allowReload) return null;
+  return /* @__PURE__ */ jsx30(actionBar_exports.Reload, { asChild: true, children: /* @__PURE__ */ jsx30(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx30(RefreshCwIcon, {}) }) });
+});
+AssistantActionBarReload.displayName = "AssistantActionBarReload";
+var exports = {
+  Root: AssistantActionBarRoot,
+  Reload: AssistantActionBarReload,
+  Copy: AssistantActionBarCopy
+};
+var assistant_action_bar_default = Object.assign(
+  AssistantActionBar,
+  exports
+);
+
+// src/ui/assistant-message.tsx
+import { forwardRef as forwardRef20 } from "react";
+
+// src/ui/branch-picker.tsx
+import { forwardRef as forwardRef19 } from "react";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import { jsx as jsx31, jsxs as jsxs6 } from "react/jsx-runtime";
+var BranchPicker = () => {
+  return /* @__PURE__ */ jsxs6(BranchPickerRoot, { hideWhenSingleBranch: true, children: [
+    /* @__PURE__ */ jsx31(BranchPickerPrevious2, {}),
+    /* @__PURE__ */ jsx31(BranchPickerState, {}),
+    /* @__PURE__ */ jsx31(BranchPickerNext, {})
+  ] });
+};
+BranchPicker.displayName = "BranchPicker";
+var BranchPickerRoot = withDefaults(branchPicker_exports.Root, {
+  className: "aui-branch-picker-root"
+});
+BranchPickerRoot.displayName = "BranchPickerRoot";
+var BranchPickerPrevious2 = forwardRef19((props, ref) => {
+  const {
+    strings: {
+      branchPicker: { previous: { tooltip = "Previous" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx31(branchPicker_exports.Previous, { asChild: true, children: /* @__PURE__ */ jsx31(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx31(ChevronLeftIcon, {}) }) });
+});
+BranchPickerPrevious2.displayName = "BranchPickerPrevious";
+var BranchPickerStateWrapper = withDefaults("span", {
+  className: "aui-branch-picker-state"
+});
+var BranchPickerState = forwardRef19((props, ref) => {
+  return /* @__PURE__ */ jsxs6(BranchPickerStateWrapper, { ...props, ref, children: [
+    /* @__PURE__ */ jsx31(branchPicker_exports.Number, {}),
+    " / ",
+    /* @__PURE__ */ jsx31(branchPicker_exports.Count, {})
+  ] });
+});
+BranchPickerState.displayName = "BranchPickerState";
+var BranchPickerNext = forwardRef19((props, ref) => {
+  const {
+    strings: { branchPicker: { next: { tooltip = "Next" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx31(branchPicker_exports.Next, { asChild: true, children: /* @__PURE__ */ jsx31(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx31(ChevronRightIcon, {}) }) });
+});
+BranchPickerNext.displayName = "BranchPickerNext";
+var exports2 = {
+  Root: BranchPickerRoot,
+  Previous: BranchPickerPrevious2,
+  Next: BranchPickerNext
+};
+var branch_picker_default = Object.assign(BranchPicker, exports2);
+
+// src/ui/base/avatar.tsx
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import { jsx as jsx32, jsxs as jsxs7 } from "react/jsx-runtime";
+var Avatar = ({ src, alt, fallback }) => {
+  if (src == null && fallback == null) return null;
+  return /* @__PURE__ */ jsxs7(AvatarRoot, { children: [
+    src != null && /* @__PURE__ */ jsx32(AvatarImage, { src, alt }),
+    fallback != null && /* @__PURE__ */ jsx32(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
+import classNames2 from "classnames";
+import { jsx as jsx33 } from "react/jsx-runtime";
+var Text = ({ status }) => {
+  return /* @__PURE__ */ jsx33(
+    "p",
+    {
+      className: classNames2(
+        "aui-text",
+        status.type === "in_progress" && "aui-text-in-progress"
+      ),
+      children: /* @__PURE__ */ jsx33(contentPart_exports.Text, {})
+    }
+  );
+};
+var exports3 = { Text };
+var content_part_default = exports3;
+
+// src/ui/assistant-message.tsx
+import { jsx as jsx34, jsxs as jsxs8 } from "react/jsx-runtime";
+var AssistantMessage = () => {
+  return /* @__PURE__ */ jsxs8(AssistantMessageRoot, { children: [
+    /* @__PURE__ */ jsx34(AssistantMessageAvatar, {}),
+    /* @__PURE__ */ jsx34(AssistantMessageContent, {}),
+    /* @__PURE__ */ jsx34(branch_picker_default, {}),
+    /* @__PURE__ */ jsx34(assistant_action_bar_default, {})
+  ] });
+};
+AssistantMessage.displayName = "AssistantMessage";
+var AssistantMessageAvatar = () => {
+  const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
+  return /* @__PURE__ */ jsx34(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 = forwardRef20(({ components: componentsProp, ...rest }, ref) => {
+  const { assistantMessage: { components = {} } = {} } = useThreadConfig();
+  return /* @__PURE__ */ jsx34(AssistantMessageContentWrapper, { ...rest, ref, children: /* @__PURE__ */ jsx34(
+    message_exports.Content,
+    {
+      components: {
+        ...componentsProp,
+        Text: componentsProp?.Text ?? components.Text ?? content_part_default.Text
+      }
+    }
+  ) });
+});
+AssistantMessageContent.displayName = "AssistantMessageContent";
+var exports4 = {
+  Root: AssistantMessageRoot,
+  Avatar: AssistantMessageAvatar,
+  Content: AssistantMessageContent
+};
+var assistant_message_default = Object.assign(
+  AssistantMessage,
+  exports4
+);
+
+// src/ui/assistant-modal.tsx
+import { forwardRef as forwardRef27 } from "react";
+import { BotIcon, ChevronDownIcon } from "lucide-react";
+
+// src/ui/thread.tsx
+import { forwardRef as forwardRef26 } from "react";
+import { ArrowDownIcon } from "lucide-react";
+
+// src/ui/composer.tsx
+import { forwardRef as forwardRef21 } from "react";
+import { SendHorizonalIcon } from "lucide-react";
+
+// src/ui/base/CircleStopIcon.tsx
+import { jsx as jsx35 } from "react/jsx-runtime";
+var CircleStopIcon = () => {
+  return /* @__PURE__ */ jsx35(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 16 16",
+      fill: "currentColor",
+      children: /* @__PURE__ */ jsx35("rect", { width: "10", height: "10", x: "3", y: "3", rx: "2" })
+    }
+  );
+};
+CircleStopIcon.displayName = "CircleStopIcon";
+
+// src/ui/composer.tsx
+import { Fragment as Fragment4, jsx as jsx36, jsxs as jsxs9 } from "react/jsx-runtime";
+var Composer = () => {
+  return /* @__PURE__ */ jsxs9(ComposerRoot, { children: [
+    /* @__PURE__ */ jsx36(ComposerInput, { autoFocus: true }),
+    /* @__PURE__ */ jsx36(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 = forwardRef21(
+  (props, ref) => {
+    const {
+      strings: {
+        composer: { input: { placeholder = "Write a message..." } = {} } = {}
+      } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ jsx36(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__ */ jsx36(ComposerSend, {});
+  return /* @__PURE__ */ jsxs9(Fragment4, { children: [
+    /* @__PURE__ */ jsx36(thread_exports.If, { running: false, children: /* @__PURE__ */ jsx36(ComposerSend, {}) }),
+    /* @__PURE__ */ jsx36(thread_exports.If, { running: true, children: /* @__PURE__ */ jsx36(ComposerCancel, {}) })
+  ] });
+};
+ComposerAction.displayName = "ComposerAction";
+var ComposerSendButton = withDefaults(TooltipIconButton, {
+  variant: "default",
+  className: "aui-composer-send"
+});
+var ComposerSend = forwardRef21((props, ref) => {
+  const {
+    strings: { composer: { send: { tooltip = "Send" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx36(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ jsx36(ComposerSendButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx36(SendHorizonalIcon, {}) }) });
+});
+ComposerSend.displayName = "ComposerSend";
+var ComposerCancelButton = withDefaults(TooltipIconButton, {
+  variant: "default",
+  className: "aui-composer-cancel"
+});
+var ComposerCancel = forwardRef21((props, ref) => {
+  const {
+    strings: { composer: { cancel: { tooltip = "Cancel" } = {} } = {} } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx36(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ jsx36(ComposerCancelButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx36(CircleStopIcon, {}) }) });
+});
+ComposerCancel.displayName = "ComposerCancel";
+var exports5 = {
+  Root: ComposerRoot,
+  Input: ComposerInput,
+  Action: ComposerAction,
+  Send: ComposerSend,
+  Cancel: ComposerCancel
+};
+var composer_default = Object.assign(Composer, exports5);
+
+// src/ui/thread-welcome.tsx
+import { forwardRef as forwardRef22 } from "react";
+import { jsx as jsx37, jsxs as jsxs10 } from "react/jsx-runtime";
+var ThreadWelcome = () => {
+  return /* @__PURE__ */ jsxs10(ThreadWelcomeRoot, { children: [
+    /* @__PURE__ */ jsxs10(ThreadWelcomeCenter, { children: [
+      /* @__PURE__ */ jsx37(ThreadWelcomeAvatar, {}),
+      /* @__PURE__ */ jsx37(ThreadWelcomeMessage, {})
+    ] }),
+    /* @__PURE__ */ jsx37(ThreadWelcomeSuggestions, {})
+  ] });
+};
+ThreadWelcome.displayName = "ThreadWelcome";
+var ThreadWelcomeRootStyled = withDefaults("div", {
+  className: "aui-thread-welcome-root"
+});
+var ThreadWelcomeCenter = withDefaults("div", {
+  className: "aui-thread-welcome-center"
+});
+var ThreadWelcomeRoot = forwardRef22(
+  (props, ref) => {
+    return /* @__PURE__ */ jsx37(thread_exports.Empty, { children: /* @__PURE__ */ jsx37(ThreadWelcomeRootStyled, { ...props, ref }) });
+  }
+);
+ThreadWelcomeRoot.displayName = "ThreadWelcomeRoot";
+var ThreadWelcomeAvatar = () => {
+  const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
+  return /* @__PURE__ */ jsx37(Avatar, { ...avatar });
+};
+var ThreadWelcomeMessageStyled = withDefaults("p", {
+  className: "aui-thread-welcome-message"
+});
+var ThreadWelcomeMessage = forwardRef22(({ message: messageProp, ...rest }, ref) => {
+  const { welcome: { message = "How can I help you today?" } = {} } = useThreadConfig();
+  return /* @__PURE__ */ jsx37(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__ */ jsx37(
+    ThreadWelcomeSuggestionStyled,
+    {
+      prompt: prompt ?? text,
+      method: "replace",
+      autoSend: true,
+      children: /* @__PURE__ */ jsx37("span", { className: "aui-thread-welcome-suggestion-text", children: text })
+    }
+  );
+};
+var ThreadWelcomeSuggestions = () => {
+  const { welcome: { suggestions } = {} } = useThreadConfig();
+  return /* @__PURE__ */ jsx37(ThreadWelcomeSuggestionContainer, { children: suggestions?.map((suggestion, idx) => {
+    const key = `${suggestion.prompt}-${idx}`;
+    return /* @__PURE__ */ jsx37(ThreadWelcomeSuggestion, { suggestion }, key);
+  }) });
+};
+ThreadWelcomeSuggestions.displayName = "ThreadWelcomeSuggestions";
+var exports6 = {
+  Root: ThreadWelcomeRoot,
+  Center: ThreadWelcomeCenter,
+  Avatar: ThreadWelcomeAvatar,
+  Message: ThreadWelcomeMessage,
+  Suggestions: ThreadWelcomeSuggestions,
+  Suggestion: ThreadWelcomeSuggestion
+};
+var thread_welcome_default = Object.assign(ThreadWelcome, exports6);
+
+// src/ui/user-message.tsx
+import { forwardRef as forwardRef24 } from "react";
+
+// src/ui/user-action-bar.tsx
+import { forwardRef as forwardRef23 } from "react";
+import { PencilIcon } from "lucide-react";
+import { jsx as jsx38 } from "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__ */ jsx38(UserActionBarRoot, { hideWhenRunning: true, autohide: "not-last", children: /* @__PURE__ */ jsx38(UserActionBarEdit, {}) });
+};
+UserActionBar.displayName = "UserActionBar";
+var UserActionBarRoot = withDefaults(actionBar_exports.Root, {
+  className: "aui-user-action-bar-root"
+});
+UserActionBarRoot.displayName = "UserActionBarRoot";
+var UserActionBarEdit = forwardRef23((props, ref) => {
+  const {
+    strings: { userMessage: { edit: { tooltip = "Edit" } = {} } = {} } = {}
+  } = useThreadConfig();
+  const allowEdit = useAllowEdit();
+  if (!allowEdit) return null;
+  return /* @__PURE__ */ jsx38(actionBar_exports.Edit, { asChild: true, children: /* @__PURE__ */ jsx38(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx38(PencilIcon, {}) }) });
+});
+UserActionBarEdit.displayName = "UserActionBarEdit";
+var exports7 = {
+  Root: UserActionBarRoot,
+  Edit: UserActionBarEdit
+};
+var user_action_bar_default = Object.assign(UserActionBar, exports7);
+
+// src/ui/user-message.tsx
+import { jsx as jsx39, jsxs as jsxs11 } from "react/jsx-runtime";
+var UserMessage = () => {
+  return /* @__PURE__ */ jsxs11(UserMessageRoot, { children: [
+    /* @__PURE__ */ jsx39(user_action_bar_default, {}),
+    /* @__PURE__ */ jsx39(UserMessageContent, {}),
+    /* @__PURE__ */ jsx39(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 = forwardRef24(
+  ({ components, ...props }, ref) => {
+    return /* @__PURE__ */ jsx39(UserMessageContentWrapper, { ...props, ref, children: /* @__PURE__ */ jsx39(
+      message_exports.Content,
+      {
+        components: {
+          ...components,
+          Text: components?.Text ?? content_part_default.Text
+        }
+      }
+    ) });
+  }
+);
+UserMessageContent.displayName = "UserMessageContent";
+var exports8 = {
+  Root: UserMessageRoot,
+  Content: UserMessageContent
+};
+var user_message_default = Object.assign(UserMessage, exports8);
+
+// src/ui/edit-composer.tsx
+import { forwardRef as forwardRef25 } from "react";
+import { jsx as jsx40, jsxs as jsxs12 } from "react/jsx-runtime";
+var EditComposer = () => {
+  return /* @__PURE__ */ jsxs12(EditComposerRoot, { children: [
+    /* @__PURE__ */ jsx40(EditComposerInput, {}),
+    /* @__PURE__ */ jsxs12(EditComposerFooter, { children: [
+      /* @__PURE__ */ jsx40(EditComposerCancel, {}),
+      /* @__PURE__ */ jsx40(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 = forwardRef25(
+  (props, ref) => {
+    const {
+      strings: {
+        editComposer: { cancel: { label = "Cancel" } = {} } = {}
+      } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ jsx40(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ jsx40(Button, { variant: "ghost", ...props, ref, children: label }) });
+  }
+);
+EditComposerCancel.displayName = "EditComposerCancel";
+var EditComposerSend = forwardRef25(
+  (props, ref) => {
+    const {
+      strings: { editComposer: { send: { label = "Send" } = {} } = {} } = {}
+    } = useThreadConfig();
+    return /* @__PURE__ */ jsx40(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ jsx40(Button, { ...props, ref, children: label }) });
+  }
+);
+EditComposerSend.displayName = "EditComposerSend";
+var exports9 = {
+  Root: EditComposerRoot,
+  Input: EditComposerInput,
+  Footer: EditComposerFooter,
+  Cancel: EditComposerCancel,
+  Send: EditComposerSend
+};
+var edit_composer_default = Object.assign(EditComposer, exports9);
+
+// src/ui/thread.tsx
+import { jsx as jsx41, jsxs as jsxs13 } from "react/jsx-runtime";
+var Thread = (config) => {
+  return /* @__PURE__ */ jsx41(ThreadRoot, { config, children: /* @__PURE__ */ jsxs13(ThreadViewport, { children: [
+    /* @__PURE__ */ jsx41(thread_welcome_default, {}),
+    /* @__PURE__ */ jsx41(ThreadMessages, {}),
+    /* @__PURE__ */ jsxs13(ThreadViewportFooter, { children: [
+      /* @__PURE__ */ jsx41(ThreadScrollToBottom, {}),
+      /* @__PURE__ */ jsx41(composer_default, {})
+    ] })
+  ] }) });
+};
+var ThreadRootStyled = withDefaults(thread_exports.Root, {
+  className: "aui-root aui-thread-root"
+});
+var ThreadRoot = forwardRef26(
+  ({ config, ...props }, ref) => {
+    return /* @__PURE__ */ jsx41(ThreadConfigProvider, { config, children: /* @__PURE__ */ jsx41(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__ */ jsx41(
+    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 = forwardRef26((props, ref) => {
+  const {
+    strings: {
+      thread: { scrollToBottom: { tooltip = "Scroll to bottom" } = {} } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx41(thread_exports.ScrollToBottom, { asChild: true, children: /* @__PURE__ */ jsx41(ThreadScrollToBottomIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx41(ArrowDownIcon, {}) }) });
+});
+ThreadScrollToBottom.displayName = "ThreadScrollToBottom";
+var exports10 = {
+  Root: ThreadRoot,
+  Viewport: ThreadViewport,
+  Messages: ThreadMessages,
+  ScrollToBottom: ThreadScrollToBottom,
+  ViewportFooter: ThreadViewportFooter
+};
+var thread_default = Object.assign(Thread, exports10);
+
+// src/ui/assistant-modal.tsx
+import { jsx as jsx42, jsxs as jsxs14 } from "react/jsx-runtime";
+var AssistantModal = (config) => {
+  return /* @__PURE__ */ jsxs14(AssistantModalRoot, { config, children: [
+    /* @__PURE__ */ jsx42(AssistantModalTrigger, {}),
+    /* @__PURE__ */ jsx42(AssistantModalContent, { children: /* @__PURE__ */ jsx42(thread_default, {}) })
+  ] });
+};
+AssistantModal.displayName = "AssistantModal";
+var AssistantModalRoot = ({ config, ...props }) => {
+  return /* @__PURE__ */ jsx42(ThreadConfigProvider, { config, children: /* @__PURE__ */ jsx42(assistantModal_exports.Root, { ...props }) });
+};
+AssistantModalRoot.displayName = "AssistantModalRoot";
+var AssistantModalTrigger = forwardRef27((props, ref) => {
+  return /* @__PURE__ */ jsx42(AssistantModalAnchor, { children: /* @__PURE__ */ jsx42(assistantModal_exports.Trigger, { asChild: true, children: /* @__PURE__ */ jsx42(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 = forwardRef27(({ "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__ */ jsxs14(
+    ModalButtonStyled,
+    {
+      side: "left",
+      tooltip,
+      "data-state": state,
+      ...rest,
+      ref,
+      children: [
+        /* @__PURE__ */ jsx42(BotIcon, { "data-state": state, className: "aui-modal-button-closed-icon" }),
+        /* @__PURE__ */ jsx42(
+          ChevronDownIcon,
+          {
+            "data-state": state,
+            className: "aui-modal-button-open-icon"
+          }
+        ),
+        /* @__PURE__ */ jsx42("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 exports11 = {
+  Root: AssistantModalRoot,
+  Trigger: AssistantModalTrigger,
+  Content: AssistantModalContent
+};
+var assistant_modal_default = Object.assign(AssistantModal, exports11);
+
 // src/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
   BaseAssistantRuntime: () => BaseAssistantRuntime,
   MessageRepository: () => MessageRepository,
   ProxyConfigProvider: () => ProxyConfigProvider,
+  TooltipIconButton: () => TooltipIconButton,
   useSmooth: () => useSmooth
 });
 export {
   actionBar_exports as ActionBarPrimitive,
+  assistant_action_bar_default as AssistantActionBar,
+  assistant_message_default as AssistantMessage,
+  assistant_modal_default as AssistantModal,
   assistantModal_exports as AssistantModalPrimitive,
   AssistantRuntimeProvider,
+  branch_picker_default as BranchPicker,
   branchPicker_exports as BranchPickerPrimitive,
+  composer_default as Composer,
   composer_exports as ComposerPrimitive,
+  content_part_default as ContentPart,
   contentPart_exports as ContentPartPrimitive,
+  edit_composer_default as EditComposer,
   internal_exports as INTERNAL,
   message_exports as MessagePrimitive,
+  thread_default as Thread,
+  ThreadConfigProvider,
   thread_exports as ThreadPrimitive,
+  thread_welcome_default as ThreadWelcome,
+  user_action_bar_default as UserActionBar,
+  user_message_default as UserMessage,
   makeAssistantTool,
   makeAssistantToolUI,
   useActionBarCopy,
@@ -2268,10 +3784,12 @@ export {
   useContentPartDisplay,
   useContentPartImage,
   useContentPartText,
+  useEdgeRuntime,
   useLocalRuntime,
   useMessageContext,
   useMessageIf,
   useSwitchToNewThread,
+  useThreadConfig,
   useThreadContext,
   useThreadEmpty,
   useThreadIf,