@assistant-ui/react 0.3.5 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.mjs CHANGED
@@ -1,3 +1,4 @@
1
+ "use client";
1
2
  var __defProp = Object.defineProperty;
2
3
  var __export = (target, all) => {
3
4
  for (var name in all)
@@ -15,14 +16,14 @@ import { createContext, useContext } from "react";
15
16
  var AssistantContext = createContext(
16
17
  null
17
18
  );
18
- var useAssistantContext = () => {
19
+ function useAssistantContext(options) {
19
20
  const context = useContext(AssistantContext);
20
- if (!context)
21
+ if (!options?.optional && !context)
21
22
  throw new Error(
22
23
  "This component must be used within an AssistantRuntimeProvider."
23
24
  );
24
25
  return context;
25
- };
26
+ }
26
27
 
27
28
  // src/context/stores/AssistantModelConfig.ts
28
29
  import { create } from "zustand";
@@ -127,14 +128,14 @@ import {
127
128
  // src/context/react/ThreadContext.ts
128
129
  import { createContext as createContext2, useContext as useContext2 } from "react";
129
130
  var ThreadContext = createContext2(null);
130
- var useThreadContext = () => {
131
+ function useThreadContext(options) {
131
132
  const context = useContext2(ThreadContext);
132
- if (!context)
133
+ if (!options?.optional && !context)
133
134
  throw new Error(
134
135
  "This component must be used within an AssistantRuntimeProvider."
135
136
  );
136
137
  return context;
137
- };
138
+ }
138
139
 
139
140
  // src/context/stores/Composer.ts
140
141
  import { create as create3 } from "zustand";
@@ -225,7 +226,7 @@ var makeThreadActionStore = (runtimeRef) => {
225
226
  startRun: (parentId) => runtimeRef.current.startRun(parentId),
226
227
  append: (message) => runtimeRef.current.append(message),
227
228
  cancelRun: () => runtimeRef.current.cancelRun(),
228
- addToolResult: (toolCallId, result) => runtimeRef.current.addToolResult(toolCallId, result)
229
+ addToolResult: (options) => runtimeRef.current.addToolResult(options)
229
230
  })
230
231
  );
231
232
  };
@@ -324,24 +325,24 @@ var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
324
325
  var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
325
326
 
326
327
  // src/context/react/ComposerContext.ts
327
- import { useContext as useContext4, useMemo } from "react";
328
+ import { useMemo } from "react";
328
329
 
329
330
  // src/context/react/MessageContext.ts
330
331
  import { createContext as createContext3, useContext as useContext3 } from "react";
331
332
  var MessageContext = createContext3(null);
332
- var useMessageContext = () => {
333
+ function useMessageContext(options) {
333
334
  const context = useContext3(MessageContext);
334
- if (!context)
335
+ if (!options?.optional && !context)
335
336
  throw new Error(
336
337
  "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
337
338
  );
338
339
  return context;
339
- };
340
+ }
340
341
 
341
342
  // src/context/react/ComposerContext.ts
342
343
  var useComposerContext = () => {
343
344
  const { useComposer } = useThreadContext();
344
- const { useEditComposer } = useContext4(MessageContext) ?? {};
345
+ const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
345
346
  return useMemo(
346
347
  () => ({
347
348
  useComposer: useEditComposer ?? useComposer,
@@ -352,18 +353,18 @@ var useComposerContext = () => {
352
353
  };
353
354
 
354
355
  // src/context/react/ContentPartContext.ts
355
- import { createContext as createContext4, useContext as useContext5 } from "react";
356
+ import { createContext as createContext4, useContext as useContext4 } from "react";
356
357
  var ContentPartContext = createContext4(
357
358
  null
358
359
  );
359
- var useContentPartContext = () => {
360
- const context = useContext5(ContentPartContext);
361
- if (!context)
360
+ function useContentPartContext(options) {
361
+ const context = useContext4(ContentPartContext);
362
+ if (!options?.optional && !context)
362
363
  throw new Error(
363
364
  "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
364
365
  );
365
366
  return context;
366
- };
367
+ }
367
368
 
368
369
  // src/hooks/useAppendMessage.tsx
369
370
  import { useCallback as useCallback2 } from "react";
@@ -709,6 +710,7 @@ var useMessageIf = (props) => {
709
710
  if (props.hasBranches === true && branches.length < 2) return false;
710
711
  if (props.user && message.role !== "user") return false;
711
712
  if (props.assistant && message.role !== "assistant") return false;
713
+ if (props.system && message.role !== "system") return false;
712
714
  if (props.lastOrHover === true && !isHovering && !isLast) return false;
713
715
  if (props.copied === true && !isCopied) return false;
714
716
  if (props.copied === false && isCopied) return false;
@@ -1098,9 +1100,9 @@ var useIsHoveringRef = () => {
1098
1100
  );
1099
1101
  return useManagedRef(callbackRef);
1100
1102
  };
1101
- var MessagePrimitiveRoot = forwardRef6(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef15) => {
1103
+ var MessagePrimitiveRoot = forwardRef6(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef28) => {
1102
1104
  const isHoveringRef = useIsHoveringRef();
1103
- const ref = useComposedRefs(forwardRef15, isHoveringRef);
1105
+ const ref = useComposedRefs(forwardRef28, isHoveringRef);
1104
1106
  return /* @__PURE__ */ jsx12(Primitive3.div, { ...rest, ref });
1105
1107
  });
1106
1108
  MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
@@ -1122,11 +1124,12 @@ import { memo as memo2 } from "react";
1122
1124
  import { useEffect as useEffect7, useState as useState4 } from "react";
1123
1125
  import { create as create9 } from "zustand";
1124
1126
  import { jsx as jsx13 } from "react/jsx-runtime";
1127
+ var DONE_STATUS = { type: "done" };
1125
1128
  var syncContentPart = ({ message }, useContentPart, partIndex) => {
1126
1129
  const part = message.content[partIndex];
1127
1130
  if (!part) return;
1128
- const messageStatus = message.role === "assistant" ? message.status : "done";
1129
- const status = partIndex === message.content.length - 1 ? messageStatus : "done";
1131
+ const messageStatus = message.role === "assistant" ? message.status : DONE_STATUS;
1132
+ const status = partIndex === message.content.length - 1 ? messageStatus : DONE_STATUS;
1130
1133
  const currentState = useContentPart.getState();
1131
1134
  if (currentState.part === part && currentState.status === status) return;
1132
1135
  useContentPart.setState(
@@ -1273,11 +1276,9 @@ var ContentPartPrimitiveDisplay = () => {
1273
1276
  ContentPartPrimitiveDisplay.displayName = "ContentPartPrimitive.Display";
1274
1277
 
1275
1278
  // src/primitives/contentPart/ContentPartInProgress.tsx
1276
- var ContentPartPrimitiveInProgress = ({
1277
- children
1278
- }) => {
1279
+ var ContentPartPrimitiveInProgress = ({ children }) => {
1279
1280
  const { useContentPart } = useContentPartContext();
1280
- const isInProgress = useContentPart((c) => c.status === "in_progress");
1281
+ const isInProgress = useContentPart((c) => c.status.type === "in_progress");
1281
1282
  return isInProgress ? children : null;
1282
1283
  };
1283
1284
  ContentPartPrimitiveInProgress.displayName = "ContentPartPrimitive.InProgress";
@@ -1302,31 +1303,37 @@ var defaultComponents = {
1302
1303
  };
1303
1304
  var MessageContentPartComponent = ({
1304
1305
  components: {
1305
- Text = defaultComponents.Text,
1306
- Image = defaultComponents.Image,
1306
+ Text: Text2 = defaultComponents.Text,
1307
+ Image: Image2 = defaultComponents.Image,
1307
1308
  UI = defaultComponents.UI,
1308
- tools: { by_name = {}, Fallback = defaultComponents.tools.Fallback } = {}
1309
+ tools: { by_name = {}, Fallback: Fallback2 = defaultComponents.tools.Fallback } = {}
1309
1310
  } = {}
1310
1311
  }) => {
1311
1312
  const { useThreadActions } = useThreadContext();
1313
+ const { useMessage } = useMessageContext();
1312
1314
  const addToolResult = useThreadActions((t) => t.addToolResult);
1313
1315
  const { useContentPart } = useContentPartContext();
1314
1316
  const { part, status } = useContentPart();
1315
1317
  const type = part.type;
1316
1318
  switch (type) {
1317
1319
  case "text":
1318
- return /* @__PURE__ */ jsx16(Text, { part, status });
1320
+ return /* @__PURE__ */ jsx16(Text2, { part, status });
1319
1321
  case "image":
1320
- return /* @__PURE__ */ jsx16(Image, { part, status });
1322
+ return /* @__PURE__ */ jsx16(Image2, { part, status });
1321
1323
  case "ui":
1322
1324
  return /* @__PURE__ */ jsx16(UI, { part, status });
1323
1325
  case "tool-call": {
1324
- const Tool = by_name[part.toolName] || Fallback;
1325
- const addResult = (result) => addToolResult(part.toolCallId, result);
1326
+ const Tool = by_name[part.toolName] || Fallback2;
1327
+ const addResult = (result) => addToolResult({
1328
+ messageId: useMessage.getState().message.id,
1329
+ toolCallId: part.toolCallId,
1330
+ result
1331
+ });
1326
1332
  return /* @__PURE__ */ jsx16(Tool, { part, status, addResult });
1327
1333
  }
1328
1334
  default:
1329
- throw new Error(`Unknown content part type: ${type}`);
1335
+ const unhandledType = type;
1336
+ throw new Error(`Unknown content part type: ${unhandledType}`);
1330
1337
  }
1331
1338
  };
1332
1339
  var MessageContentPartImpl = ({
@@ -1818,29 +1825,32 @@ var MessageProvider = ({
1818
1825
 
1819
1826
  // src/primitives/thread/ThreadMessages.tsx
1820
1827
  import { jsx as jsx24, jsxs as jsxs3 } from "react/jsx-runtime";
1828
+ var DEFAULT_SYSTEM_MESSAGE = () => null;
1821
1829
  var getComponents = (components) => {
1822
1830
  return {
1823
1831
  EditComposer: components.EditComposer ?? components.UserMessage ?? components.Message,
1824
1832
  UserMessage: components.UserMessage ?? components.Message,
1825
- AssistantMessage: components.AssistantMessage ?? components.Message
1833
+ AssistantMessage: components.AssistantMessage ?? components.Message,
1834
+ SystemMessage: components.SystemMessage ?? DEFAULT_SYSTEM_MESSAGE
1826
1835
  };
1827
1836
  };
1828
1837
  var ThreadMessageImpl = ({
1829
1838
  messageIndex,
1830
1839
  components
1831
1840
  }) => {
1832
- const { UserMessage, EditComposer, AssistantMessage } = getComponents(components);
1841
+ const { UserMessage: UserMessage2, EditComposer: EditComposer2, AssistantMessage: AssistantMessage2, SystemMessage: SystemMessage2 } = getComponents(components);
1833
1842
  return /* @__PURE__ */ jsxs3(MessageProvider, { messageIndex, children: [
1834
1843
  /* @__PURE__ */ jsxs3(MessagePrimitiveIf, { user: true, children: [
1835
- /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ jsx24(UserMessage, {}) }),
1836
- /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx24(EditComposer, {}) })
1844
+ /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ jsx24(UserMessage2, {}) }),
1845
+ /* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx24(EditComposer2, {}) })
1837
1846
  ] }),
1838
- /* @__PURE__ */ jsx24(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ jsx24(AssistantMessage, {}) })
1847
+ /* @__PURE__ */ jsx24(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ jsx24(AssistantMessage2, {}) }),
1848
+ /* @__PURE__ */ jsx24(MessagePrimitiveIf, { system: true, children: /* @__PURE__ */ jsx24(SystemMessage2, {}) })
1839
1849
  ] });
1840
1850
  };
1841
1851
  var ThreadMessage = memo3(
1842
1852
  ThreadMessageImpl,
1843
- (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
1853
+ (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
1844
1854
  );
1845
1855
  var ThreadPrimitiveMessagesImpl = ({
1846
1856
  components
@@ -1863,7 +1873,7 @@ var ThreadPrimitiveMessagesImpl = ({
1863
1873
  ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
1864
1874
  var ThreadPrimitiveMessages = memo3(
1865
1875
  ThreadPrimitiveMessagesImpl,
1866
- (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
1876
+ (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
1867
1877
  );
1868
1878
 
1869
1879
  // src/primitives/thread/ThreadScrollToBottom.tsx
@@ -1878,10 +1888,10 @@ var ThreadPrimitiveSuggestion = createActionButton(
1878
1888
  useThreadSuggestion
1879
1889
  );
1880
1890
 
1881
- // src/runtime/local/useLocalRuntime.tsx
1891
+ // src/runtimes/local/useLocalRuntime.tsx
1882
1892
  import { useInsertionEffect as useInsertionEffect3, useState as useState7 } from "react";
1883
1893
 
1884
- // src/runtime/utils/idUtils.tsx
1894
+ // src/utils/idUtils.tsx
1885
1895
  import { customAlphabet } from "nanoid/non-secure";
1886
1896
  var generateId = customAlphabet(
1887
1897
  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
@@ -1890,7 +1900,7 @@ var generateId = customAlphabet(
1890
1900
  var optimisticPrefix = "__optimistic__";
1891
1901
  var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
1892
1902
 
1893
- // src/runtime/utils/MessageRepository.tsx
1903
+ // src/runtimes/utils/MessageRepository.tsx
1894
1904
  var findHead = (message) => {
1895
1905
  if (message.next) return findHead(message.next);
1896
1906
  return message;
@@ -1964,6 +1974,17 @@ var MessageRepository = class {
1964
1974
  this.head = newItem;
1965
1975
  }
1966
1976
  }
1977
+ getMessage(messageId) {
1978
+ const message = this.messages.get(messageId);
1979
+ if (!message)
1980
+ throw new Error(
1981
+ "MessageRepository(updateMessage): Message not found. This is likely an internal bug in assistant-ui."
1982
+ );
1983
+ return {
1984
+ parentId: message.prev?.current.id ?? null,
1985
+ message: message.current
1986
+ };
1987
+ }
1967
1988
  appendOptimisticMessage(parentId, message) {
1968
1989
  let optimisticId;
1969
1990
  do {
@@ -2041,7 +2062,7 @@ var MessageRepository = class {
2041
2062
  }
2042
2063
  };
2043
2064
 
2044
- // src/runtime/core/BaseAssistantRuntime.tsx
2065
+ // src/runtimes/core/BaseAssistantRuntime.tsx
2045
2066
  var BaseAssistantRuntime = class {
2046
2067
  constructor(_thread) {
2047
2068
  this._thread = _thread;
@@ -2082,8 +2103,8 @@ var BaseAssistantRuntime = class {
2082
2103
  cancelRun() {
2083
2104
  return this.thread.cancelRun();
2084
2105
  }
2085
- addToolResult(toolCallId, result) {
2086
- return this.thread.addToolResult(toolCallId, result);
2106
+ addToolResult(options) {
2107
+ return this.thread.addToolResult(options);
2087
2108
  }
2088
2109
  _subscriptions = /* @__PURE__ */ new Set();
2089
2110
  subscribe(callback) {
@@ -2098,7 +2119,7 @@ var BaseAssistantRuntime = class {
2098
2119
  }
2099
2120
  };
2100
2121
 
2101
- // src/runtime/local/LocalRuntime.tsx
2122
+ // src/runtimes/local/LocalRuntime.tsx
2102
2123
  var LocalRuntime = class extends BaseAssistantRuntime {
2103
2124
  _configProviders;
2104
2125
  constructor(adapter) {
@@ -2169,7 +2190,7 @@ var LocalThreadRuntime = class {
2169
2190
  const message = {
2170
2191
  id,
2171
2192
  role: "assistant",
2172
- status: "in_progress",
2193
+ status: { type: "in_progress" },
2173
2194
  content: [{ type: "text", text: "" }],
2174
2195
  createdAt: /* @__PURE__ */ new Date()
2175
2196
  };
@@ -2189,11 +2210,17 @@ var LocalThreadRuntime = class {
2189
2210
  config: mergeModelConfigs(this._configProviders),
2190
2211
  onUpdate: updateHandler
2191
2212
  });
2192
- updateHandler(result);
2193
- message.status = "done";
2213
+ if (result !== void 0) {
2214
+ updateHandler(result);
2215
+ }
2216
+ if (result.status?.type === "in_progress")
2217
+ throw new Error(
2218
+ "Unexpected in_progress status returned from ChatModelAdapter"
2219
+ );
2220
+ message.status = result.status ?? { type: "done" };
2194
2221
  this.repository.addOrUpdateMessage(parentId, { ...message });
2195
2222
  } catch (e) {
2196
- message.status = "error";
2223
+ message.status = { type: "error", error: e };
2197
2224
  this.repository.addOrUpdateMessage(parentId, { ...message });
2198
2225
  console.error(e);
2199
2226
  } finally {
@@ -2214,12 +2241,30 @@ var LocalThreadRuntime = class {
2214
2241
  this._subscriptions.add(callback);
2215
2242
  return () => this._subscriptions.delete(callback);
2216
2243
  }
2217
- addToolResult() {
2218
- throw new Error("LocalRuntime does not yet support adding tool results");
2244
+ addToolResult({ messageId, toolCallId, result }) {
2245
+ const { parentId, message } = this.repository.getMessage(messageId);
2246
+ if (message.role !== "assistant")
2247
+ throw new Error("Tried to add tool re^sult to non-assistant message");
2248
+ let found = false;
2249
+ const newContent = message.content.map((c) => {
2250
+ if (c.type !== "tool-call") return c;
2251
+ if (c.toolCallId !== toolCallId) return c;
2252
+ found = true;
2253
+ return {
2254
+ ...c,
2255
+ result
2256
+ };
2257
+ });
2258
+ if (!found)
2259
+ throw new Error("Tried to add tool result to non-existing tool call");
2260
+ this.repository.addOrUpdateMessage(parentId, {
2261
+ ...message,
2262
+ content: newContent
2263
+ });
2219
2264
  }
2220
2265
  };
2221
2266
 
2222
- // src/runtime/local/useLocalRuntime.tsx
2267
+ // src/runtimes/local/useLocalRuntime.tsx
2223
2268
  var useLocalRuntime = (adapter) => {
2224
2269
  const [runtime] = useState7(() => new LocalRuntime(adapter));
2225
2270
  useInsertionEffect3(() => {
@@ -2228,24 +2273,1495 @@ var useLocalRuntime = (adapter) => {
2228
2273
  return runtime;
2229
2274
  };
2230
2275
 
2276
+ // src/runtimes/edge/streams/assistantDecoderStream.ts
2277
+ function assistantDecoderStream() {
2278
+ let currentToolCall;
2279
+ return new TransformStream({
2280
+ transform(chunk, controller) {
2281
+ const [code, valueJson] = chunk.split(":");
2282
+ const value = JSON.parse(valueJson);
2283
+ if (currentToolCall && code !== "2" /* ToolCallArgsTextDelta */ && code !== "E" /* Error */) {
2284
+ controller.enqueue({
2285
+ type: "tool-call",
2286
+ toolCallType: "function",
2287
+ toolCallId: currentToolCall.id,
2288
+ toolName: currentToolCall.name,
2289
+ args: JSON.parse(currentToolCall.argsText)
2290
+ });
2291
+ currentToolCall = void 0;
2292
+ }
2293
+ switch (code) {
2294
+ case "0" /* TextDelta */: {
2295
+ controller.enqueue({
2296
+ type: "text-delta",
2297
+ textDelta: value
2298
+ });
2299
+ break;
2300
+ }
2301
+ case "1" /* ToolCallBegin */: {
2302
+ const { id, name } = JSON.parse(value);
2303
+ currentToolCall = { id, name, argsText: "" };
2304
+ break;
2305
+ }
2306
+ case "2" /* ToolCallArgsTextDelta */: {
2307
+ const delta = JSON.parse(value);
2308
+ currentToolCall.argsText += delta;
2309
+ controller.enqueue({
2310
+ type: "tool-call-delta",
2311
+ toolCallType: "function",
2312
+ toolCallId: currentToolCall.id,
2313
+ toolName: currentToolCall.name,
2314
+ argsTextDelta: delta
2315
+ });
2316
+ break;
2317
+ }
2318
+ case "F" /* Finish */: {
2319
+ controller.enqueue({
2320
+ type: "finish",
2321
+ ...JSON.parse(value)
2322
+ });
2323
+ break;
2324
+ }
2325
+ case "E" /* Error */: {
2326
+ controller.enqueue({
2327
+ type: "error",
2328
+ error: JSON.parse(value)
2329
+ });
2330
+ break;
2331
+ }
2332
+ default: {
2333
+ const unhandledType = code;
2334
+ throw new Error(`Unhandled chunk type: ${unhandledType}`);
2335
+ }
2336
+ }
2337
+ }
2338
+ });
2339
+ }
2340
+
2341
+ // src/runtimes/edge/streams/chunkByLineStream.ts
2342
+ function chunkByLineStream() {
2343
+ let buffer = "";
2344
+ return new TransformStream({
2345
+ transform(chunk, controller) {
2346
+ buffer += chunk;
2347
+ const lines = buffer.split("\n");
2348
+ for (let i = 0; i < lines.length - 1; i++) {
2349
+ controller.enqueue(lines[i]);
2350
+ }
2351
+ buffer = lines[lines.length - 1];
2352
+ },
2353
+ flush(controller) {
2354
+ if (buffer) {
2355
+ controller.enqueue(buffer);
2356
+ }
2357
+ }
2358
+ });
2359
+ }
2360
+
2361
+ // src/runtimes/edge/partial-json/parse-partial-json.ts
2362
+ import sjson from "secure-json-parse";
2363
+
2364
+ // src/runtimes/edge/partial-json/fix-json.ts
2365
+ function fixJson(input) {
2366
+ const stack = ["ROOT"];
2367
+ let lastValidIndex = -1;
2368
+ let literalStart = null;
2369
+ function processValueStart(char, i, swapState) {
2370
+ {
2371
+ switch (char) {
2372
+ case '"': {
2373
+ lastValidIndex = i;
2374
+ stack.pop();
2375
+ stack.push(swapState);
2376
+ stack.push("INSIDE_STRING");
2377
+ break;
2378
+ }
2379
+ case "f":
2380
+ case "t":
2381
+ case "n": {
2382
+ lastValidIndex = i;
2383
+ literalStart = i;
2384
+ stack.pop();
2385
+ stack.push(swapState);
2386
+ stack.push("INSIDE_LITERAL");
2387
+ break;
2388
+ }
2389
+ case "-": {
2390
+ stack.pop();
2391
+ stack.push(swapState);
2392
+ stack.push("INSIDE_NUMBER");
2393
+ break;
2394
+ }
2395
+ case "0":
2396
+ case "1":
2397
+ case "2":
2398
+ case "3":
2399
+ case "4":
2400
+ case "5":
2401
+ case "6":
2402
+ case "7":
2403
+ case "8":
2404
+ case "9": {
2405
+ lastValidIndex = i;
2406
+ stack.pop();
2407
+ stack.push(swapState);
2408
+ stack.push("INSIDE_NUMBER");
2409
+ break;
2410
+ }
2411
+ case "{": {
2412
+ lastValidIndex = i;
2413
+ stack.pop();
2414
+ stack.push(swapState);
2415
+ stack.push("INSIDE_OBJECT_START");
2416
+ break;
2417
+ }
2418
+ case "[": {
2419
+ lastValidIndex = i;
2420
+ stack.pop();
2421
+ stack.push(swapState);
2422
+ stack.push("INSIDE_ARRAY_START");
2423
+ break;
2424
+ }
2425
+ }
2426
+ }
2427
+ }
2428
+ function processAfterObjectValue(char, i) {
2429
+ switch (char) {
2430
+ case ",": {
2431
+ stack.pop();
2432
+ stack.push("INSIDE_OBJECT_AFTER_COMMA");
2433
+ break;
2434
+ }
2435
+ case "}": {
2436
+ lastValidIndex = i;
2437
+ stack.pop();
2438
+ break;
2439
+ }
2440
+ }
2441
+ }
2442
+ function processAfterArrayValue(char, i) {
2443
+ switch (char) {
2444
+ case ",": {
2445
+ stack.pop();
2446
+ stack.push("INSIDE_ARRAY_AFTER_COMMA");
2447
+ break;
2448
+ }
2449
+ case "]": {
2450
+ lastValidIndex = i;
2451
+ stack.pop();
2452
+ break;
2453
+ }
2454
+ }
2455
+ }
2456
+ for (let i = 0; i < input.length; i++) {
2457
+ const char = input[i];
2458
+ const currentState = stack[stack.length - 1];
2459
+ switch (currentState) {
2460
+ case "ROOT":
2461
+ processValueStart(char, i, "FINISH");
2462
+ break;
2463
+ case "INSIDE_OBJECT_START": {
2464
+ switch (char) {
2465
+ case '"': {
2466
+ stack.pop();
2467
+ stack.push("INSIDE_OBJECT_KEY");
2468
+ break;
2469
+ }
2470
+ case "}": {
2471
+ lastValidIndex = i;
2472
+ stack.pop();
2473
+ break;
2474
+ }
2475
+ }
2476
+ break;
2477
+ }
2478
+ case "INSIDE_OBJECT_AFTER_COMMA": {
2479
+ switch (char) {
2480
+ case '"': {
2481
+ stack.pop();
2482
+ stack.push("INSIDE_OBJECT_KEY");
2483
+ break;
2484
+ }
2485
+ }
2486
+ break;
2487
+ }
2488
+ case "INSIDE_OBJECT_KEY": {
2489
+ switch (char) {
2490
+ case '"': {
2491
+ stack.pop();
2492
+ stack.push("INSIDE_OBJECT_AFTER_KEY");
2493
+ break;
2494
+ }
2495
+ }
2496
+ break;
2497
+ }
2498
+ case "INSIDE_OBJECT_AFTER_KEY": {
2499
+ switch (char) {
2500
+ case ":": {
2501
+ stack.pop();
2502
+ stack.push("INSIDE_OBJECT_BEFORE_VALUE");
2503
+ break;
2504
+ }
2505
+ }
2506
+ break;
2507
+ }
2508
+ case "INSIDE_OBJECT_BEFORE_VALUE": {
2509
+ processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
2510
+ break;
2511
+ }
2512
+ case "INSIDE_OBJECT_AFTER_VALUE": {
2513
+ processAfterObjectValue(char, i);
2514
+ break;
2515
+ }
2516
+ case "INSIDE_STRING": {
2517
+ switch (char) {
2518
+ case '"': {
2519
+ stack.pop();
2520
+ lastValidIndex = i;
2521
+ break;
2522
+ }
2523
+ case "\\": {
2524
+ stack.push("INSIDE_STRING_ESCAPE");
2525
+ break;
2526
+ }
2527
+ default: {
2528
+ lastValidIndex = i;
2529
+ }
2530
+ }
2531
+ break;
2532
+ }
2533
+ case "INSIDE_ARRAY_START": {
2534
+ switch (char) {
2535
+ case "]": {
2536
+ lastValidIndex = i;
2537
+ stack.pop();
2538
+ break;
2539
+ }
2540
+ default: {
2541
+ lastValidIndex = i;
2542
+ processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
2543
+ break;
2544
+ }
2545
+ }
2546
+ break;
2547
+ }
2548
+ case "INSIDE_ARRAY_AFTER_VALUE": {
2549
+ switch (char) {
2550
+ case ",": {
2551
+ stack.pop();
2552
+ stack.push("INSIDE_ARRAY_AFTER_COMMA");
2553
+ break;
2554
+ }
2555
+ case "]": {
2556
+ lastValidIndex = i;
2557
+ stack.pop();
2558
+ break;
2559
+ }
2560
+ default: {
2561
+ lastValidIndex = i;
2562
+ break;
2563
+ }
2564
+ }
2565
+ break;
2566
+ }
2567
+ case "INSIDE_ARRAY_AFTER_COMMA": {
2568
+ processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
2569
+ break;
2570
+ }
2571
+ case "INSIDE_STRING_ESCAPE": {
2572
+ stack.pop();
2573
+ lastValidIndex = i;
2574
+ break;
2575
+ }
2576
+ case "INSIDE_NUMBER": {
2577
+ switch (char) {
2578
+ case "0":
2579
+ case "1":
2580
+ case "2":
2581
+ case "3":
2582
+ case "4":
2583
+ case "5":
2584
+ case "6":
2585
+ case "7":
2586
+ case "8":
2587
+ case "9": {
2588
+ lastValidIndex = i;
2589
+ break;
2590
+ }
2591
+ case "e":
2592
+ case "E":
2593
+ case "-":
2594
+ case ".": {
2595
+ break;
2596
+ }
2597
+ case ",": {
2598
+ stack.pop();
2599
+ if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
2600
+ processAfterArrayValue(char, i);
2601
+ }
2602
+ if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
2603
+ processAfterObjectValue(char, i);
2604
+ }
2605
+ break;
2606
+ }
2607
+ case "}": {
2608
+ stack.pop();
2609
+ if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
2610
+ processAfterObjectValue(char, i);
2611
+ }
2612
+ break;
2613
+ }
2614
+ case "]": {
2615
+ stack.pop();
2616
+ if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
2617
+ processAfterArrayValue(char, i);
2618
+ }
2619
+ break;
2620
+ }
2621
+ default: {
2622
+ stack.pop();
2623
+ break;
2624
+ }
2625
+ }
2626
+ break;
2627
+ }
2628
+ case "INSIDE_LITERAL": {
2629
+ const partialLiteral = input.substring(literalStart, i + 1);
2630
+ if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
2631
+ stack.pop();
2632
+ if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
2633
+ processAfterObjectValue(char, i);
2634
+ } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
2635
+ processAfterArrayValue(char, i);
2636
+ }
2637
+ } else {
2638
+ lastValidIndex = i;
2639
+ }
2640
+ break;
2641
+ }
2642
+ }
2643
+ }
2644
+ let result = input.slice(0, lastValidIndex + 1);
2645
+ for (let i = stack.length - 1; i >= 0; i--) {
2646
+ const state = stack[i];
2647
+ switch (state) {
2648
+ case "INSIDE_STRING": {
2649
+ result += '"';
2650
+ break;
2651
+ }
2652
+ case "INSIDE_OBJECT_KEY":
2653
+ case "INSIDE_OBJECT_AFTER_KEY":
2654
+ case "INSIDE_OBJECT_AFTER_COMMA":
2655
+ case "INSIDE_OBJECT_START":
2656
+ case "INSIDE_OBJECT_BEFORE_VALUE":
2657
+ case "INSIDE_OBJECT_AFTER_VALUE": {
2658
+ result += "}";
2659
+ break;
2660
+ }
2661
+ case "INSIDE_ARRAY_START":
2662
+ case "INSIDE_ARRAY_AFTER_COMMA":
2663
+ case "INSIDE_ARRAY_AFTER_VALUE": {
2664
+ result += "]";
2665
+ break;
2666
+ }
2667
+ case "INSIDE_LITERAL": {
2668
+ const partialLiteral = input.substring(literalStart, input.length);
2669
+ if ("true".startsWith(partialLiteral)) {
2670
+ result += "true".slice(partialLiteral.length);
2671
+ } else if ("false".startsWith(partialLiteral)) {
2672
+ result += "false".slice(partialLiteral.length);
2673
+ } else if ("null".startsWith(partialLiteral)) {
2674
+ result += "null".slice(partialLiteral.length);
2675
+ }
2676
+ }
2677
+ }
2678
+ }
2679
+ return result;
2680
+ }
2681
+
2682
+ // src/runtimes/edge/partial-json/parse-partial-json.ts
2683
+ var parsePartialJson = (json) => {
2684
+ try {
2685
+ return sjson.parse(json);
2686
+ } catch {
2687
+ try {
2688
+ return sjson.parse(fixJson(json));
2689
+ } catch {
2690
+ return void 0;
2691
+ }
2692
+ }
2693
+ };
2694
+
2695
+ // src/runtimes/edge/streams/runResultStream.ts
2696
+ function runResultStream() {
2697
+ let message = {
2698
+ content: []
2699
+ };
2700
+ const currentToolCall = { toolCallId: "", argsText: "" };
2701
+ return new TransformStream({
2702
+ transform(chunk, controller) {
2703
+ const chunkType = chunk.type;
2704
+ switch (chunkType) {
2705
+ case "text-delta": {
2706
+ message = appendOrUpdateText(message, chunk.textDelta);
2707
+ controller.enqueue(message);
2708
+ break;
2709
+ }
2710
+ case "tool-call-delta": {
2711
+ const { toolCallId, toolName, argsTextDelta } = chunk;
2712
+ if (currentToolCall.toolCallId !== toolCallId) {
2713
+ currentToolCall.toolCallId = toolCallId;
2714
+ currentToolCall.argsText = argsTextDelta;
2715
+ } else {
2716
+ currentToolCall.argsText += argsTextDelta;
2717
+ }
2718
+ message = appendOrUpdateToolCall(
2719
+ message,
2720
+ toolCallId,
2721
+ toolName,
2722
+ parsePartialJson(currentToolCall.argsText)
2723
+ );
2724
+ controller.enqueue(message);
2725
+ break;
2726
+ }
2727
+ case "tool-call": {
2728
+ break;
2729
+ }
2730
+ case "tool-result": {
2731
+ message = appendOrUpdateToolResult(
2732
+ message,
2733
+ chunk.toolCallId,
2734
+ chunk.toolName,
2735
+ chunk.result
2736
+ );
2737
+ controller.enqueue(message);
2738
+ break;
2739
+ }
2740
+ case "finish": {
2741
+ message = appendOrUpdateFinish(message, chunk);
2742
+ controller.enqueue(message);
2743
+ break;
2744
+ }
2745
+ case "error": {
2746
+ throw chunk.error;
2747
+ }
2748
+ default: {
2749
+ const unhandledType = chunkType;
2750
+ throw new Error(`Unhandled chunk type: ${unhandledType}`);
2751
+ }
2752
+ }
2753
+ }
2754
+ });
2755
+ }
2756
+ var appendOrUpdateText = (message, textDelta) => {
2757
+ let contentParts = message.content;
2758
+ let contentPart = message.content.at(-1);
2759
+ if (contentPart?.type !== "text") {
2760
+ contentPart = { type: "text", text: textDelta };
2761
+ } else {
2762
+ contentParts = contentParts.slice(0, -1);
2763
+ contentPart = { type: "text", text: contentPart.text + textDelta };
2764
+ }
2765
+ return {
2766
+ ...message,
2767
+ content: contentParts.concat([contentPart])
2768
+ };
2769
+ };
2770
+ var appendOrUpdateToolCall = (message, toolCallId, toolName, args) => {
2771
+ let contentParts = message.content;
2772
+ let contentPart = message.content.at(-1);
2773
+ if (contentPart?.type !== "tool-call" || contentPart.toolCallId !== toolCallId) {
2774
+ contentPart = {
2775
+ type: "tool-call",
2776
+ toolCallId,
2777
+ toolName,
2778
+ args
2779
+ };
2780
+ } else {
2781
+ contentParts = contentParts.slice(0, -1);
2782
+ contentPart = {
2783
+ ...contentPart,
2784
+ args
2785
+ };
2786
+ }
2787
+ return {
2788
+ ...message,
2789
+ content: contentParts.concat([contentPart])
2790
+ };
2791
+ };
2792
+ var appendOrUpdateToolResult = (message, toolCallId, toolName, result) => {
2793
+ let found = false;
2794
+ const newContentParts = message.content.map((part) => {
2795
+ if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
2796
+ return part;
2797
+ found = true;
2798
+ if (part.toolName !== toolName)
2799
+ throw new Error(
2800
+ `Tool call ${toolCallId} found with tool name ${part.toolName}, but expected ${toolName}`
2801
+ );
2802
+ return {
2803
+ ...part,
2804
+ result
2805
+ };
2806
+ });
2807
+ if (!found)
2808
+ throw new Error(
2809
+ `Received tool result for unknown tool call "${toolName}" / "${toolCallId}". This is likely an internal bug in assistant-ui.`
2810
+ );
2811
+ return {
2812
+ ...message,
2813
+ content: newContentParts
2814
+ };
2815
+ };
2816
+ var appendOrUpdateFinish = (message, chunk) => {
2817
+ const { type, ...rest } = chunk;
2818
+ return {
2819
+ ...message,
2820
+ status: {
2821
+ type: "done",
2822
+ ...rest
2823
+ }
2824
+ };
2825
+ };
2826
+
2827
+ // src/runtimes/edge/useEdgeRuntime.ts
2828
+ import { useMemo as useMemo3 } from "react";
2829
+
2830
+ // src/runtimes/edge/streams/toolResultStream.ts
2831
+ import { z } from "zod";
2832
+ import sjson2 from "secure-json-parse";
2833
+ function toolResultStream(tools) {
2834
+ const toolCallExecutions = /* @__PURE__ */ new Map();
2835
+ return new TransformStream({
2836
+ transform(chunk, controller) {
2837
+ controller.enqueue(chunk);
2838
+ const chunkType = chunk.type;
2839
+ switch (chunkType) {
2840
+ case "tool-call": {
2841
+ const { toolCallId, toolCallType, toolName, args: argsText } = chunk;
2842
+ const tool = tools?.[toolName];
2843
+ if (!tool) return;
2844
+ const args = sjson2.parse(argsText);
2845
+ if (tool.parameters instanceof z.ZodType) {
2846
+ const result = tool.parameters.safeParse(args);
2847
+ if (!result.success) {
2848
+ controller.enqueue({
2849
+ type: "error",
2850
+ error: new Error("Invalid tool call arguments")
2851
+ });
2852
+ return;
2853
+ } else {
2854
+ toolCallExecutions.set(
2855
+ toolCallId,
2856
+ (async () => {
2857
+ try {
2858
+ const result2 = await tool.execute(args);
2859
+ controller.enqueue({
2860
+ type: "tool-result",
2861
+ toolCallType,
2862
+ toolCallId,
2863
+ toolName,
2864
+ result: result2
2865
+ });
2866
+ } catch (error) {
2867
+ controller.enqueue({
2868
+ type: "error",
2869
+ error
2870
+ });
2871
+ } finally {
2872
+ toolCallExecutions.delete(toolCallId);
2873
+ }
2874
+ })()
2875
+ );
2876
+ }
2877
+ }
2878
+ break;
2879
+ }
2880
+ case "text-delta":
2881
+ case "tool-call-delta":
2882
+ case "finish":
2883
+ case "error":
2884
+ break;
2885
+ default: {
2886
+ const unhandledType = chunkType;
2887
+ throw new Error(`Unhandled chunk type: ${unhandledType}`);
2888
+ }
2889
+ }
2890
+ },
2891
+ async flush() {
2892
+ await Promise.all(toolCallExecutions.values());
2893
+ }
2894
+ });
2895
+ }
2896
+
2897
+ // src/runtimes/edge/useEdgeRuntime.ts
2898
+ import { z as z2 } from "zod";
2899
+ import { zodToJsonSchema } from "zod-to-json-schema";
2900
+ function asAsyncIterable(source) {
2901
+ return {
2902
+ [Symbol.asyncIterator]: () => {
2903
+ const reader = source.getReader();
2904
+ return {
2905
+ async next() {
2906
+ const { done, value } = await reader.read();
2907
+ return done ? { done: true, value: void 0 } : { done: false, value };
2908
+ }
2909
+ };
2910
+ }
2911
+ };
2912
+ }
2913
+ var toSerializableTools = (tools) => {
2914
+ if (!tools) return [];
2915
+ return Object.entries(tools).map(([name, tool]) => ({
2916
+ type: "function",
2917
+ name,
2918
+ ...tool.description ? { description: tool.description } : void 0,
2919
+ parameters: tool.parameters instanceof z2.ZodType ? zodToJsonSchema(tool.parameters) : tool.parameters
2920
+ }));
2921
+ };
2922
+ var createEdgeChatAdapter = ({
2923
+ api
2924
+ }) => ({
2925
+ run: async ({ messages, abortSignal, config, onUpdate }) => {
2926
+ const result = await fetch(api, {
2927
+ method: "POST",
2928
+ headers: {
2929
+ "Content-Type": "application/json"
2930
+ },
2931
+ body: JSON.stringify({
2932
+ system: config.system,
2933
+ messages,
2934
+ tools: toSerializableTools(
2935
+ config.tools
2936
+ )
2937
+ }),
2938
+ signal: abortSignal
2939
+ });
2940
+ const stream = result.body.pipeThrough(new TextDecoderStream()).pipeThrough(chunkByLineStream()).pipeThrough(assistantDecoderStream()).pipeThrough(toolResultStream(config.tools)).pipeThrough(runResultStream());
2941
+ let update;
2942
+ for await (update of asAsyncIterable(stream)) {
2943
+ onUpdate(update);
2944
+ }
2945
+ if (update === void 0)
2946
+ throw new Error("No data received from Edge Runtime");
2947
+ return update;
2948
+ }
2949
+ });
2950
+ var useEdgeRuntime = (options) => {
2951
+ const adapter = useMemo3(() => createEdgeChatAdapter(options), [options]);
2952
+ return useLocalRuntime(adapter);
2953
+ };
2954
+
2955
+ // src/ui/thread-config.tsx
2956
+ import { createContext as createContext5, useContext as useContext5 } from "react";
2957
+ import { Fragment as Fragment3, jsx as jsx25 } from "react/jsx-runtime";
2958
+ var ThreadConfigContext = createContext5({});
2959
+ var useThreadConfig = () => {
2960
+ return useContext5(ThreadConfigContext);
2961
+ };
2962
+ var ThreadConfigProvider = ({
2963
+ children,
2964
+ config
2965
+ }) => {
2966
+ const assistant = useAssistantContext({ optional: true });
2967
+ const configProvider = config && Object.keys(config ?? {}).length > 0 ? /* @__PURE__ */ jsx25(ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ jsx25(Fragment3, { children });
2968
+ if (!config?.runtime) return configProvider;
2969
+ if (assistant) {
2970
+ throw new Error(
2971
+ "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
2972
+ );
2973
+ }
2974
+ return /* @__PURE__ */ jsx25(AssistantRuntimeProvider, { runtime: config.runtime, children: configProvider });
2975
+ };
2976
+ ThreadConfigProvider.displayName = "ThreadConfigProvider";
2977
+
2978
+ // src/ui/assistant-action-bar.tsx
2979
+ import { forwardRef as forwardRef18 } from "react";
2980
+ import { CheckIcon, CopyIcon, RefreshCwIcon } from "lucide-react";
2981
+
2982
+ // src/ui/base/tooltip-icon-button.tsx
2983
+ import { forwardRef as forwardRef17 } from "react";
2984
+
2985
+ // src/ui/base/tooltip.tsx
2986
+ import * as TooltipPrimitive from "@radix-ui/react-tooltip";
2987
+
2988
+ // src/ui/utils/withDefaults.tsx
2989
+ import {
2990
+ forwardRef as forwardRef15
2991
+ } from "react";
2992
+ import classNames from "classnames";
2993
+ import { jsx as jsx26 } from "react/jsx-runtime";
2994
+ var withDefaultProps = ({
2995
+ className,
2996
+ ...defaultProps
2997
+ }) => ({ className: classNameProp, ...props }) => {
2998
+ return {
2999
+ className: classNames(className, classNameProp),
3000
+ ...defaultProps,
3001
+ ...props
3002
+ };
3003
+ };
3004
+ var withDefaults = (Component, defaultProps) => {
3005
+ const getProps = withDefaultProps(defaultProps);
3006
+ const WithDefaults = forwardRef15(
3007
+ (props, ref) => {
3008
+ const ComponentAsAny = Component;
3009
+ return /* @__PURE__ */ jsx26(ComponentAsAny, { ...getProps(props), ref });
3010
+ }
3011
+ );
3012
+ WithDefaults.displayName = "withDefaults(" + (typeof Component === "string" ? Component : Component.displayName) + ")";
3013
+ return WithDefaults;
3014
+ };
3015
+
3016
+ // src/ui/base/tooltip.tsx
3017
+ import { jsx as jsx27 } from "react/jsx-runtime";
3018
+ var Tooltip = (props) => {
3019
+ return /* @__PURE__ */ jsx27(TooltipPrimitive.Provider, { children: /* @__PURE__ */ jsx27(TooltipPrimitive.Root, { ...props }) });
3020
+ };
3021
+ Tooltip.displayName = "Tooltip";
3022
+ var TooltipTrigger = TooltipPrimitive.Trigger;
3023
+ var TooltipContent = withDefaults(TooltipPrimitive.Content, {
3024
+ sideOffset: 4,
3025
+ className: "aui-tooltip-content"
3026
+ });
3027
+ TooltipContent.displayName = "TooltipContent";
3028
+
3029
+ // src/ui/base/button.tsx
3030
+ import { cva } from "class-variance-authority";
3031
+ import { Primitive as Primitive11 } from "@radix-ui/react-primitive";
3032
+ import { forwardRef as forwardRef16 } from "react";
3033
+ import { jsx as jsx28 } from "react/jsx-runtime";
3034
+ var buttonVariants = cva("aui-button", {
3035
+ variants: {
3036
+ variant: {
3037
+ default: "aui-button-primary",
3038
+ outline: "aui-button-outline",
3039
+ ghost: "aui-button-ghost"
3040
+ },
3041
+ size: {
3042
+ default: "aui-button-medium",
3043
+ icon: "aui-button-icon"
3044
+ }
3045
+ },
3046
+ defaultVariants: {
3047
+ variant: "default",
3048
+ size: "default"
3049
+ }
3050
+ });
3051
+ var Button = forwardRef16(
3052
+ ({ className, variant, size, ...props }, ref) => {
3053
+ return /* @__PURE__ */ jsx28(
3054
+ Primitive11.button,
3055
+ {
3056
+ className: buttonVariants({ variant, size, className }),
3057
+ ...props,
3058
+ ref
3059
+ }
3060
+ );
3061
+ }
3062
+ );
3063
+ Button.displayName = "Button";
3064
+
3065
+ // src/ui/base/tooltip-icon-button.tsx
3066
+ import { jsx as jsx29, jsxs as jsxs4 } from "react/jsx-runtime";
3067
+ var TooltipIconButton = forwardRef17(({ children, tooltip, side = "bottom", ...rest }, ref) => {
3068
+ return /* @__PURE__ */ jsxs4(Tooltip, { children: [
3069
+ /* @__PURE__ */ jsx29(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs4(Button, { variant: "ghost", size: "icon", ...rest, ref, children: [
3070
+ children,
3071
+ /* @__PURE__ */ jsx29("span", { className: "aui-sr-only", children: tooltip })
3072
+ ] }) }),
3073
+ /* @__PURE__ */ jsx29(TooltipContent, { side, children: tooltip })
3074
+ ] });
3075
+ });
3076
+ TooltipIconButton.displayName = "TooltipIconButton";
3077
+
3078
+ // src/ui/assistant-action-bar.tsx
3079
+ import { jsx as jsx30, jsxs as jsxs5 } from "react/jsx-runtime";
3080
+ var useAllowCopy = () => {
3081
+ const { assistantMessage: { allowCopy = true } = {} } = useThreadConfig();
3082
+ const { useThreadActions } = useThreadContext();
3083
+ const copySupported = useThreadActions((t) => t.capabilities.copy);
3084
+ return copySupported && allowCopy;
3085
+ };
3086
+ var useAllowReload = () => {
3087
+ const { assistantMessage: { allowReload = true } = {} } = useThreadConfig();
3088
+ const { useThreadActions } = useThreadContext();
3089
+ const reloadSupported = useThreadActions((t) => t.capabilities.reload);
3090
+ return reloadSupported && allowReload;
3091
+ };
3092
+ var AssistantActionBar = () => {
3093
+ const allowCopy = useAllowCopy();
3094
+ const allowReload = useAllowReload();
3095
+ if (!allowCopy && !allowReload) return null;
3096
+ return /* @__PURE__ */ jsxs5(
3097
+ AssistantActionBarRoot,
3098
+ {
3099
+ hideWhenRunning: true,
3100
+ autohide: "not-last",
3101
+ autohideFloat: "single-branch",
3102
+ children: [
3103
+ /* @__PURE__ */ jsx30(AssistantActionBarCopy, {}),
3104
+ /* @__PURE__ */ jsx30(AssistantActionBarReload, {})
3105
+ ]
3106
+ }
3107
+ );
3108
+ };
3109
+ AssistantActionBar.displayName = "AssistantActionBar";
3110
+ var AssistantActionBarRoot = withDefaults(actionBar_exports.Root, {
3111
+ className: "aui-assistant-action-bar-root"
3112
+ });
3113
+ AssistantActionBarRoot.displayName = "AssistantActionBarRoot";
3114
+ var AssistantActionBarCopy = forwardRef18((props, ref) => {
3115
+ const {
3116
+ strings: {
3117
+ assistantMessage: { reload: { tooltip = "Copy" } = {} } = {}
3118
+ } = {}
3119
+ } = useThreadConfig();
3120
+ const allowCopy = useAllowCopy();
3121
+ if (!allowCopy) return null;
3122
+ return /* @__PURE__ */ jsx30(actionBar_exports.Copy, { asChild: true, children: /* @__PURE__ */ jsxs5(TooltipIconButton, { tooltip, ...props, ref, children: [
3123
+ /* @__PURE__ */ jsx30(message_exports.If, { copied: true, children: /* @__PURE__ */ jsx30(CheckIcon, {}) }),
3124
+ /* @__PURE__ */ jsx30(message_exports.If, { copied: false, children: /* @__PURE__ */ jsx30(CopyIcon, {}) })
3125
+ ] }) });
3126
+ });
3127
+ AssistantActionBarCopy.displayName = "AssistantActionBarCopy";
3128
+ var AssistantActionBarReload = forwardRef18((props, ref) => {
3129
+ const {
3130
+ strings: {
3131
+ assistantMessage: { reload: { tooltip = "Refresh" } = {} } = {}
3132
+ } = {}
3133
+ } = useThreadConfig();
3134
+ const allowReload = useAllowReload();
3135
+ if (!allowReload) return null;
3136
+ return /* @__PURE__ */ jsx30(actionBar_exports.Reload, { asChild: true, children: /* @__PURE__ */ jsx30(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx30(RefreshCwIcon, {}) }) });
3137
+ });
3138
+ AssistantActionBarReload.displayName = "AssistantActionBarReload";
3139
+ var exports = {
3140
+ Root: AssistantActionBarRoot,
3141
+ Reload: AssistantActionBarReload,
3142
+ Copy: AssistantActionBarCopy
3143
+ };
3144
+ var assistant_action_bar_default = Object.assign(
3145
+ AssistantActionBar,
3146
+ exports
3147
+ );
3148
+
3149
+ // src/ui/assistant-message.tsx
3150
+ import { forwardRef as forwardRef20 } from "react";
3151
+
3152
+ // src/ui/branch-picker.tsx
3153
+ import { forwardRef as forwardRef19 } from "react";
3154
+ import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
3155
+ import { jsx as jsx31, jsxs as jsxs6 } from "react/jsx-runtime";
3156
+ var BranchPicker = () => {
3157
+ return /* @__PURE__ */ jsxs6(BranchPickerRoot, { hideWhenSingleBranch: true, children: [
3158
+ /* @__PURE__ */ jsx31(BranchPickerPrevious2, {}),
3159
+ /* @__PURE__ */ jsx31(BranchPickerState, {}),
3160
+ /* @__PURE__ */ jsx31(BranchPickerNext, {})
3161
+ ] });
3162
+ };
3163
+ BranchPicker.displayName = "BranchPicker";
3164
+ var BranchPickerRoot = withDefaults(branchPicker_exports.Root, {
3165
+ className: "aui-branch-picker-root"
3166
+ });
3167
+ BranchPickerRoot.displayName = "BranchPickerRoot";
3168
+ var BranchPickerPrevious2 = forwardRef19((props, ref) => {
3169
+ const {
3170
+ strings: {
3171
+ branchPicker: { previous: { tooltip = "Previous" } = {} } = {}
3172
+ } = {}
3173
+ } = useThreadConfig();
3174
+ return /* @__PURE__ */ jsx31(branchPicker_exports.Previous, { asChild: true, children: /* @__PURE__ */ jsx31(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx31(ChevronLeftIcon, {}) }) });
3175
+ });
3176
+ BranchPickerPrevious2.displayName = "BranchPickerPrevious";
3177
+ var BranchPickerStateWrapper = withDefaults("span", {
3178
+ className: "aui-branch-picker-state"
3179
+ });
3180
+ var BranchPickerState = forwardRef19((props, ref) => {
3181
+ return /* @__PURE__ */ jsxs6(BranchPickerStateWrapper, { ...props, ref, children: [
3182
+ /* @__PURE__ */ jsx31(branchPicker_exports.Number, {}),
3183
+ " / ",
3184
+ /* @__PURE__ */ jsx31(branchPicker_exports.Count, {})
3185
+ ] });
3186
+ });
3187
+ BranchPickerState.displayName = "BranchPickerState";
3188
+ var BranchPickerNext = forwardRef19((props, ref) => {
3189
+ const {
3190
+ strings: { branchPicker: { next: { tooltip = "Next" } = {} } = {} } = {}
3191
+ } = useThreadConfig();
3192
+ return /* @__PURE__ */ jsx31(branchPicker_exports.Next, { asChild: true, children: /* @__PURE__ */ jsx31(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx31(ChevronRightIcon, {}) }) });
3193
+ });
3194
+ BranchPickerNext.displayName = "BranchPickerNext";
3195
+ var exports2 = {
3196
+ Root: BranchPickerRoot,
3197
+ Previous: BranchPickerPrevious2,
3198
+ Next: BranchPickerNext
3199
+ };
3200
+ var branch_picker_default = Object.assign(BranchPicker, exports2);
3201
+
3202
+ // src/ui/base/avatar.tsx
3203
+ import * as AvatarPrimitive from "@radix-ui/react-avatar";
3204
+ import { jsx as jsx32, jsxs as jsxs7 } from "react/jsx-runtime";
3205
+ var Avatar = ({ src, alt, fallback }) => {
3206
+ if (src == null && fallback == null) return null;
3207
+ return /* @__PURE__ */ jsxs7(AvatarRoot, { children: [
3208
+ src != null && /* @__PURE__ */ jsx32(AvatarImage, { src, alt }),
3209
+ fallback != null && /* @__PURE__ */ jsx32(AvatarFallback, { children: fallback })
3210
+ ] });
3211
+ };
3212
+ Avatar.displayName = "Avatar";
3213
+ var AvatarRoot = withDefaults(AvatarPrimitive.Root, {
3214
+ className: "aui-avatar-root"
3215
+ });
3216
+ AvatarRoot.displayName = "AvatarRoot";
3217
+ var AvatarImage = withDefaults(AvatarPrimitive.Image, {
3218
+ className: "aui-avatar-image"
3219
+ });
3220
+ AvatarImage.displayName = "AvatarImage";
3221
+ var AvatarFallback = withDefaults(AvatarPrimitive.Fallback, {
3222
+ className: "aui-avatar-fallback"
3223
+ });
3224
+ AvatarFallback.displayName = "AvatarFallback";
3225
+
3226
+ // src/ui/content-part.tsx
3227
+ import classNames2 from "classnames";
3228
+ import { jsx as jsx33 } from "react/jsx-runtime";
3229
+ var Text = ({ status }) => {
3230
+ return /* @__PURE__ */ jsx33(
3231
+ "p",
3232
+ {
3233
+ className: classNames2(
3234
+ "aui-text",
3235
+ status.type === "in_progress" && "aui-text-in-progress"
3236
+ ),
3237
+ children: /* @__PURE__ */ jsx33(contentPart_exports.Text, {})
3238
+ }
3239
+ );
3240
+ };
3241
+ var exports3 = { Text };
3242
+ var content_part_default = exports3;
3243
+
3244
+ // src/ui/assistant-message.tsx
3245
+ import { jsx as jsx34, jsxs as jsxs8 } from "react/jsx-runtime";
3246
+ var AssistantMessage = () => {
3247
+ return /* @__PURE__ */ jsxs8(AssistantMessageRoot, { children: [
3248
+ /* @__PURE__ */ jsx34(AssistantMessageAvatar, {}),
3249
+ /* @__PURE__ */ jsx34(AssistantMessageContent, {}),
3250
+ /* @__PURE__ */ jsx34(branch_picker_default, {}),
3251
+ /* @__PURE__ */ jsx34(assistant_action_bar_default, {})
3252
+ ] });
3253
+ };
3254
+ AssistantMessage.displayName = "AssistantMessage";
3255
+ var AssistantMessageAvatar = () => {
3256
+ const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
3257
+ return /* @__PURE__ */ jsx34(Avatar, { ...avatar });
3258
+ };
3259
+ var AssistantMessageRoot = withDefaults(message_exports.Root, {
3260
+ className: "aui-assistant-message-root"
3261
+ });
3262
+ AssistantMessageRoot.displayName = "AssistantMessageRoot";
3263
+ var AssistantMessageContentWrapper = withDefaults("div", {
3264
+ className: "aui-assistant-message-content"
3265
+ });
3266
+ var AssistantMessageContent = forwardRef20(({ components: componentsProp, ...rest }, ref) => {
3267
+ const { assistantMessage: { components = {} } = {} } = useThreadConfig();
3268
+ return /* @__PURE__ */ jsx34(AssistantMessageContentWrapper, { ...rest, ref, children: /* @__PURE__ */ jsx34(
3269
+ message_exports.Content,
3270
+ {
3271
+ components: {
3272
+ ...componentsProp,
3273
+ Text: componentsProp?.Text ?? components.Text ?? content_part_default.Text
3274
+ }
3275
+ }
3276
+ ) });
3277
+ });
3278
+ AssistantMessageContent.displayName = "AssistantMessageContent";
3279
+ var exports4 = {
3280
+ Root: AssistantMessageRoot,
3281
+ Avatar: AssistantMessageAvatar,
3282
+ Content: AssistantMessageContent
3283
+ };
3284
+ var assistant_message_default = Object.assign(
3285
+ AssistantMessage,
3286
+ exports4
3287
+ );
3288
+
3289
+ // src/ui/assistant-modal.tsx
3290
+ import { forwardRef as forwardRef27 } from "react";
3291
+ import { BotIcon, ChevronDownIcon } from "lucide-react";
3292
+
3293
+ // src/ui/thread.tsx
3294
+ import { forwardRef as forwardRef26 } from "react";
3295
+ import { ArrowDownIcon } from "lucide-react";
3296
+
3297
+ // src/ui/composer.tsx
3298
+ import { forwardRef as forwardRef21 } from "react";
3299
+ import { SendHorizonalIcon } from "lucide-react";
3300
+
3301
+ // src/ui/base/CircleStopIcon.tsx
3302
+ import { jsx as jsx35 } from "react/jsx-runtime";
3303
+ var CircleStopIcon = () => {
3304
+ return /* @__PURE__ */ jsx35(
3305
+ "svg",
3306
+ {
3307
+ xmlns: "http://www.w3.org/2000/svg",
3308
+ viewBox: "0 0 16 16",
3309
+ fill: "currentColor",
3310
+ children: /* @__PURE__ */ jsx35("rect", { width: "10", height: "10", x: "3", y: "3", rx: "2" })
3311
+ }
3312
+ );
3313
+ };
3314
+ CircleStopIcon.displayName = "CircleStopIcon";
3315
+
3316
+ // src/ui/composer.tsx
3317
+ import { Fragment as Fragment4, jsx as jsx36, jsxs as jsxs9 } from "react/jsx-runtime";
3318
+ var Composer = () => {
3319
+ return /* @__PURE__ */ jsxs9(ComposerRoot, { children: [
3320
+ /* @__PURE__ */ jsx36(ComposerInput, { autoFocus: true }),
3321
+ /* @__PURE__ */ jsx36(ComposerAction, {})
3322
+ ] });
3323
+ };
3324
+ Composer.displayName = "Composer";
3325
+ var ComposerRoot = withDefaults(composer_exports.Root, {
3326
+ className: "aui-composer-root"
3327
+ });
3328
+ ComposerRoot.displayName = "ComposerRoot";
3329
+ var ComposerInputStyled = withDefaults(composer_exports.Input, {
3330
+ rows: 1,
3331
+ autoFocus: true,
3332
+ className: "aui-composer-input"
3333
+ });
3334
+ var ComposerInput = forwardRef21(
3335
+ (props, ref) => {
3336
+ const {
3337
+ strings: {
3338
+ composer: { input: { placeholder = "Write a message..." } = {} } = {}
3339
+ } = {}
3340
+ } = useThreadConfig();
3341
+ return /* @__PURE__ */ jsx36(ComposerInputStyled, { placeholder, ...props, ref });
3342
+ }
3343
+ );
3344
+ ComposerInput.displayName = "ComposerInput";
3345
+ var useAllowCancel = () => {
3346
+ const { useThreadActions } = useThreadContext();
3347
+ const cancelSupported = useThreadActions((t) => t.capabilities.cancel);
3348
+ return cancelSupported;
3349
+ };
3350
+ var ComposerAction = () => {
3351
+ const allowCancel = useAllowCancel();
3352
+ if (!allowCancel) return /* @__PURE__ */ jsx36(ComposerSend, {});
3353
+ return /* @__PURE__ */ jsxs9(Fragment4, { children: [
3354
+ /* @__PURE__ */ jsx36(thread_exports.If, { running: false, children: /* @__PURE__ */ jsx36(ComposerSend, {}) }),
3355
+ /* @__PURE__ */ jsx36(thread_exports.If, { running: true, children: /* @__PURE__ */ jsx36(ComposerCancel, {}) })
3356
+ ] });
3357
+ };
3358
+ ComposerAction.displayName = "ComposerAction";
3359
+ var ComposerSendButton = withDefaults(TooltipIconButton, {
3360
+ variant: "default",
3361
+ className: "aui-composer-send"
3362
+ });
3363
+ var ComposerSend = forwardRef21((props, ref) => {
3364
+ const {
3365
+ strings: { composer: { send: { tooltip = "Send" } = {} } = {} } = {}
3366
+ } = useThreadConfig();
3367
+ return /* @__PURE__ */ jsx36(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ jsx36(ComposerSendButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx36(SendHorizonalIcon, {}) }) });
3368
+ });
3369
+ ComposerSend.displayName = "ComposerSend";
3370
+ var ComposerCancelButton = withDefaults(TooltipIconButton, {
3371
+ variant: "default",
3372
+ className: "aui-composer-cancel"
3373
+ });
3374
+ var ComposerCancel = forwardRef21((props, ref) => {
3375
+ const {
3376
+ strings: { composer: { cancel: { tooltip = "Cancel" } = {} } = {} } = {}
3377
+ } = useThreadConfig();
3378
+ return /* @__PURE__ */ jsx36(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ jsx36(ComposerCancelButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx36(CircleStopIcon, {}) }) });
3379
+ });
3380
+ ComposerCancel.displayName = "ComposerCancel";
3381
+ var exports5 = {
3382
+ Root: ComposerRoot,
3383
+ Input: ComposerInput,
3384
+ Action: ComposerAction,
3385
+ Send: ComposerSend,
3386
+ Cancel: ComposerCancel
3387
+ };
3388
+ var composer_default = Object.assign(Composer, exports5);
3389
+
3390
+ // src/ui/thread-welcome.tsx
3391
+ import { forwardRef as forwardRef22 } from "react";
3392
+ import { jsx as jsx37, jsxs as jsxs10 } from "react/jsx-runtime";
3393
+ var ThreadWelcome = () => {
3394
+ return /* @__PURE__ */ jsxs10(ThreadWelcomeRoot, { children: [
3395
+ /* @__PURE__ */ jsxs10(ThreadWelcomeCenter, { children: [
3396
+ /* @__PURE__ */ jsx37(ThreadWelcomeAvatar, {}),
3397
+ /* @__PURE__ */ jsx37(ThreadWelcomeMessage, {})
3398
+ ] }),
3399
+ /* @__PURE__ */ jsx37(ThreadWelcomeSuggestions, {})
3400
+ ] });
3401
+ };
3402
+ ThreadWelcome.displayName = "ThreadWelcome";
3403
+ var ThreadWelcomeRootStyled = withDefaults("div", {
3404
+ className: "aui-thread-welcome-root"
3405
+ });
3406
+ var ThreadWelcomeCenter = withDefaults("div", {
3407
+ className: "aui-thread-welcome-center"
3408
+ });
3409
+ var ThreadWelcomeRoot = forwardRef22(
3410
+ (props, ref) => {
3411
+ return /* @__PURE__ */ jsx37(thread_exports.Empty, { children: /* @__PURE__ */ jsx37(ThreadWelcomeRootStyled, { ...props, ref }) });
3412
+ }
3413
+ );
3414
+ ThreadWelcomeRoot.displayName = "ThreadWelcomeRoot";
3415
+ var ThreadWelcomeAvatar = () => {
3416
+ const { assistantAvatar: avatar = { fallback: "A" } } = useThreadConfig();
3417
+ return /* @__PURE__ */ jsx37(Avatar, { ...avatar });
3418
+ };
3419
+ var ThreadWelcomeMessageStyled = withDefaults("p", {
3420
+ className: "aui-thread-welcome-message"
3421
+ });
3422
+ var ThreadWelcomeMessage = forwardRef22(({ message: messageProp, ...rest }, ref) => {
3423
+ const { welcome: { message = "How can I help you today?" } = {} } = useThreadConfig();
3424
+ return /* @__PURE__ */ jsx37(ThreadWelcomeMessageStyled, { ...rest, ref, children: messageProp ?? message });
3425
+ });
3426
+ ThreadWelcomeMessage.displayName = "ThreadWelcomeMessage";
3427
+ var ThreadWelcomeSuggestionContainer = withDefaults("div", {
3428
+ className: "aui-thread-welcome-suggestion-container"
3429
+ });
3430
+ var ThreadWelcomeSuggestionStyled = withDefaults(thread_exports.Suggestion, {
3431
+ className: "aui-thread-welcome-suggestion"
3432
+ });
3433
+ var ThreadWelcomeSuggestion = ({
3434
+ suggestion: { text, prompt }
3435
+ }) => {
3436
+ return /* @__PURE__ */ jsx37(
3437
+ ThreadWelcomeSuggestionStyled,
3438
+ {
3439
+ prompt: prompt ?? text,
3440
+ method: "replace",
3441
+ autoSend: true,
3442
+ children: /* @__PURE__ */ jsx37("span", { className: "aui-thread-welcome-suggestion-text", children: text })
3443
+ }
3444
+ );
3445
+ };
3446
+ var ThreadWelcomeSuggestions = () => {
3447
+ const { welcome: { suggestions } = {} } = useThreadConfig();
3448
+ return /* @__PURE__ */ jsx37(ThreadWelcomeSuggestionContainer, { children: suggestions?.map((suggestion, idx) => {
3449
+ const key = `${suggestion.prompt}-${idx}`;
3450
+ return /* @__PURE__ */ jsx37(ThreadWelcomeSuggestion, { suggestion }, key);
3451
+ }) });
3452
+ };
3453
+ ThreadWelcomeSuggestions.displayName = "ThreadWelcomeSuggestions";
3454
+ var exports6 = {
3455
+ Root: ThreadWelcomeRoot,
3456
+ Center: ThreadWelcomeCenter,
3457
+ Avatar: ThreadWelcomeAvatar,
3458
+ Message: ThreadWelcomeMessage,
3459
+ Suggestions: ThreadWelcomeSuggestions,
3460
+ Suggestion: ThreadWelcomeSuggestion
3461
+ };
3462
+ var thread_welcome_default = Object.assign(ThreadWelcome, exports6);
3463
+
3464
+ // src/ui/user-message.tsx
3465
+ import { forwardRef as forwardRef24 } from "react";
3466
+
3467
+ // src/ui/user-action-bar.tsx
3468
+ import { forwardRef as forwardRef23 } from "react";
3469
+ import { PencilIcon } from "lucide-react";
3470
+ import { jsx as jsx38 } from "react/jsx-runtime";
3471
+ var useAllowEdit = () => {
3472
+ const { userMessage: { allowEdit = true } = {} } = useThreadConfig();
3473
+ const { useThreadActions } = useThreadContext();
3474
+ const editSupported = useThreadActions((t) => t.capabilities.edit);
3475
+ return editSupported && allowEdit;
3476
+ };
3477
+ var UserActionBar = () => {
3478
+ const allowEdit = useAllowEdit();
3479
+ if (!allowEdit) return null;
3480
+ return /* @__PURE__ */ jsx38(UserActionBarRoot, { hideWhenRunning: true, autohide: "not-last", children: /* @__PURE__ */ jsx38(UserActionBarEdit, {}) });
3481
+ };
3482
+ UserActionBar.displayName = "UserActionBar";
3483
+ var UserActionBarRoot = withDefaults(actionBar_exports.Root, {
3484
+ className: "aui-user-action-bar-root"
3485
+ });
3486
+ UserActionBarRoot.displayName = "UserActionBarRoot";
3487
+ var UserActionBarEdit = forwardRef23((props, ref) => {
3488
+ const {
3489
+ strings: { userMessage: { edit: { tooltip = "Edit" } = {} } = {} } = {}
3490
+ } = useThreadConfig();
3491
+ const allowEdit = useAllowEdit();
3492
+ if (!allowEdit) return null;
3493
+ return /* @__PURE__ */ jsx38(actionBar_exports.Edit, { asChild: true, children: /* @__PURE__ */ jsx38(TooltipIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx38(PencilIcon, {}) }) });
3494
+ });
3495
+ UserActionBarEdit.displayName = "UserActionBarEdit";
3496
+ var exports7 = {
3497
+ Root: UserActionBarRoot,
3498
+ Edit: UserActionBarEdit
3499
+ };
3500
+ var user_action_bar_default = Object.assign(UserActionBar, exports7);
3501
+
3502
+ // src/ui/user-message.tsx
3503
+ import { jsx as jsx39, jsxs as jsxs11 } from "react/jsx-runtime";
3504
+ var UserMessage = () => {
3505
+ return /* @__PURE__ */ jsxs11(UserMessageRoot, { children: [
3506
+ /* @__PURE__ */ jsx39(user_action_bar_default, {}),
3507
+ /* @__PURE__ */ jsx39(UserMessageContent, {}),
3508
+ /* @__PURE__ */ jsx39(branch_picker_default, {})
3509
+ ] });
3510
+ };
3511
+ UserMessage.displayName = "UserMessage";
3512
+ var UserMessageRoot = withDefaults(message_exports.Root, {
3513
+ className: "aui-user-message-root"
3514
+ });
3515
+ UserMessageRoot.displayName = "UserMessageRoot";
3516
+ var UserMessageContentWrapper = withDefaults("div", {
3517
+ className: "aui-user-message-content"
3518
+ });
3519
+ var UserMessageContent = forwardRef24(
3520
+ ({ components, ...props }, ref) => {
3521
+ return /* @__PURE__ */ jsx39(UserMessageContentWrapper, { ...props, ref, children: /* @__PURE__ */ jsx39(
3522
+ message_exports.Content,
3523
+ {
3524
+ components: {
3525
+ ...components,
3526
+ Text: components?.Text ?? content_part_default.Text
3527
+ }
3528
+ }
3529
+ ) });
3530
+ }
3531
+ );
3532
+ UserMessageContent.displayName = "UserMessageContent";
3533
+ var exports8 = {
3534
+ Root: UserMessageRoot,
3535
+ Content: UserMessageContent
3536
+ };
3537
+ var user_message_default = Object.assign(UserMessage, exports8);
3538
+
3539
+ // src/ui/edit-composer.tsx
3540
+ import { forwardRef as forwardRef25 } from "react";
3541
+ import { jsx as jsx40, jsxs as jsxs12 } from "react/jsx-runtime";
3542
+ var EditComposer = () => {
3543
+ return /* @__PURE__ */ jsxs12(EditComposerRoot, { children: [
3544
+ /* @__PURE__ */ jsx40(EditComposerInput, {}),
3545
+ /* @__PURE__ */ jsxs12(EditComposerFooter, { children: [
3546
+ /* @__PURE__ */ jsx40(EditComposerCancel, {}),
3547
+ /* @__PURE__ */ jsx40(EditComposerSend, {})
3548
+ ] })
3549
+ ] });
3550
+ };
3551
+ EditComposer.displayName = "EditComposer";
3552
+ var EditComposerRoot = withDefaults(composer_exports.Root, {
3553
+ className: "aui-edit-composer-root"
3554
+ });
3555
+ EditComposerRoot.displayName = "EditComposerRoot";
3556
+ var EditComposerInput = withDefaults(composer_exports.Input, {
3557
+ className: "aui-edit-composer-input"
3558
+ });
3559
+ EditComposerInput.displayName = "EditComposerInput";
3560
+ var EditComposerFooter = withDefaults("div", {
3561
+ className: "aui-edit-composer-footer"
3562
+ });
3563
+ EditComposerFooter.displayName = "EditComposerFooter";
3564
+ var EditComposerCancel = forwardRef25(
3565
+ (props, ref) => {
3566
+ const {
3567
+ strings: {
3568
+ editComposer: { cancel: { label = "Cancel" } = {} } = {}
3569
+ } = {}
3570
+ } = useThreadConfig();
3571
+ return /* @__PURE__ */ jsx40(composer_exports.Cancel, { asChild: true, children: /* @__PURE__ */ jsx40(Button, { variant: "ghost", ...props, ref, children: label }) });
3572
+ }
3573
+ );
3574
+ EditComposerCancel.displayName = "EditComposerCancel";
3575
+ var EditComposerSend = forwardRef25(
3576
+ (props, ref) => {
3577
+ const {
3578
+ strings: { editComposer: { send: { label = "Send" } = {} } = {} } = {}
3579
+ } = useThreadConfig();
3580
+ return /* @__PURE__ */ jsx40(composer_exports.Send, { asChild: true, children: /* @__PURE__ */ jsx40(Button, { ...props, ref, children: label }) });
3581
+ }
3582
+ );
3583
+ EditComposerSend.displayName = "EditComposerSend";
3584
+ var exports9 = {
3585
+ Root: EditComposerRoot,
3586
+ Input: EditComposerInput,
3587
+ Footer: EditComposerFooter,
3588
+ Cancel: EditComposerCancel,
3589
+ Send: EditComposerSend
3590
+ };
3591
+ var edit_composer_default = Object.assign(EditComposer, exports9);
3592
+
3593
+ // src/ui/thread.tsx
3594
+ import { jsx as jsx41, jsxs as jsxs13 } from "react/jsx-runtime";
3595
+ var Thread = (config) => {
3596
+ return /* @__PURE__ */ jsx41(ThreadRoot, { config, children: /* @__PURE__ */ jsxs13(ThreadViewport, { children: [
3597
+ /* @__PURE__ */ jsx41(thread_welcome_default, {}),
3598
+ /* @__PURE__ */ jsx41(ThreadMessages, {}),
3599
+ /* @__PURE__ */ jsxs13(ThreadViewportFooter, { children: [
3600
+ /* @__PURE__ */ jsx41(ThreadScrollToBottom, {}),
3601
+ /* @__PURE__ */ jsx41(composer_default, {})
3602
+ ] })
3603
+ ] }) });
3604
+ };
3605
+ var ThreadRootStyled = withDefaults(thread_exports.Root, {
3606
+ className: "aui-root aui-thread-root"
3607
+ });
3608
+ var ThreadRoot = forwardRef26(
3609
+ ({ config, ...props }, ref) => {
3610
+ return /* @__PURE__ */ jsx41(ThreadConfigProvider, { config, children: /* @__PURE__ */ jsx41(ThreadRootStyled, { ...props, ref }) });
3611
+ }
3612
+ );
3613
+ ThreadRoot.displayName = "ThreadRoot";
3614
+ var ThreadViewport = withDefaults(thread_exports.Viewport, {
3615
+ className: "aui-thread-viewport"
3616
+ });
3617
+ ThreadViewport.displayName = "ThreadViewport";
3618
+ var ThreadViewportFooter = withDefaults("div", {
3619
+ className: "aui-thread-viewport-footer"
3620
+ });
3621
+ ThreadViewportFooter.displayName = "ThreadViewportFooter";
3622
+ var SystemMessage = () => null;
3623
+ var ThreadMessages = ({ components, ...rest }) => {
3624
+ return /* @__PURE__ */ jsx41(
3625
+ thread_exports.Messages,
3626
+ {
3627
+ components: {
3628
+ UserMessage: components?.UserMessage ?? user_message_default,
3629
+ EditComposer: components?.EditComposer ?? edit_composer_default,
3630
+ AssistantMessage: components?.AssistantMessage ?? assistant_message_default,
3631
+ SystemMessage: components?.SystemMessage ?? SystemMessage
3632
+ },
3633
+ ...rest
3634
+ }
3635
+ );
3636
+ };
3637
+ ThreadMessages.displayName = "ThreadMessages";
3638
+ var ThreadScrollToBottomIconButton = withDefaults(TooltipIconButton, {
3639
+ variant: "outline",
3640
+ className: "aui-thread-scroll-to-bottom"
3641
+ });
3642
+ var ThreadScrollToBottom = forwardRef26((props, ref) => {
3643
+ const {
3644
+ strings: {
3645
+ thread: { scrollToBottom: { tooltip = "Scroll to bottom" } = {} } = {}
3646
+ } = {}
3647
+ } = useThreadConfig();
3648
+ return /* @__PURE__ */ jsx41(thread_exports.ScrollToBottom, { asChild: true, children: /* @__PURE__ */ jsx41(ThreadScrollToBottomIconButton, { tooltip, ...props, ref, children: /* @__PURE__ */ jsx41(ArrowDownIcon, {}) }) });
3649
+ });
3650
+ ThreadScrollToBottom.displayName = "ThreadScrollToBottom";
3651
+ var exports10 = {
3652
+ Root: ThreadRoot,
3653
+ Viewport: ThreadViewport,
3654
+ Messages: ThreadMessages,
3655
+ ScrollToBottom: ThreadScrollToBottom,
3656
+ ViewportFooter: ThreadViewportFooter
3657
+ };
3658
+ var thread_default = Object.assign(Thread, exports10);
3659
+
3660
+ // src/ui/assistant-modal.tsx
3661
+ import { jsx as jsx42, jsxs as jsxs14 } from "react/jsx-runtime";
3662
+ var AssistantModal = (config) => {
3663
+ return /* @__PURE__ */ jsxs14(AssistantModalRoot, { config, children: [
3664
+ /* @__PURE__ */ jsx42(AssistantModalTrigger, {}),
3665
+ /* @__PURE__ */ jsx42(AssistantModalContent, { children: /* @__PURE__ */ jsx42(thread_default, {}) })
3666
+ ] });
3667
+ };
3668
+ AssistantModal.displayName = "AssistantModal";
3669
+ var AssistantModalRoot = ({ config, ...props }) => {
3670
+ return /* @__PURE__ */ jsx42(ThreadConfigProvider, { config, children: /* @__PURE__ */ jsx42(assistantModal_exports.Root, { ...props }) });
3671
+ };
3672
+ AssistantModalRoot.displayName = "AssistantModalRoot";
3673
+ var AssistantModalTrigger = forwardRef27((props, ref) => {
3674
+ return /* @__PURE__ */ jsx42(AssistantModalAnchor, { children: /* @__PURE__ */ jsx42(assistantModal_exports.Trigger, { asChild: true, children: /* @__PURE__ */ jsx42(AssistantModalButton, { ...props, ref }) }) });
3675
+ });
3676
+ AssistantModalTrigger.displayName = "AssistantModalTrigger";
3677
+ var AssistantModalAnchor = withDefaults(assistantModal_exports.Anchor, {
3678
+ className: "aui-root aui-modal-anchor"
3679
+ });
3680
+ AssistantModalAnchor.displayName = "AssistantModalAnchor";
3681
+ var ModalButtonStyled = withDefaults(TooltipIconButton, {
3682
+ variant: "default",
3683
+ className: "aui-modal-button"
3684
+ });
3685
+ var AssistantModalButton = forwardRef27(({ "data-state": state, ...rest }, ref) => {
3686
+ const {
3687
+ strings: {
3688
+ assistantModal: {
3689
+ open: {
3690
+ button: { tooltip: openTooltip = "Close Assistant" } = {}
3691
+ } = {},
3692
+ closed: {
3693
+ button: { tooltip: closedTooltip = "Open Assistant" } = {}
3694
+ } = {}
3695
+ } = {}
3696
+ } = {}
3697
+ } = useThreadConfig();
3698
+ const tooltip = state === "open" ? openTooltip : closedTooltip;
3699
+ return /* @__PURE__ */ jsxs14(
3700
+ ModalButtonStyled,
3701
+ {
3702
+ side: "left",
3703
+ tooltip,
3704
+ "data-state": state,
3705
+ ...rest,
3706
+ ref,
3707
+ children: [
3708
+ /* @__PURE__ */ jsx42(BotIcon, { "data-state": state, className: "aui-modal-button-closed-icon" }),
3709
+ /* @__PURE__ */ jsx42(
3710
+ ChevronDownIcon,
3711
+ {
3712
+ "data-state": state,
3713
+ className: "aui-modal-button-open-icon"
3714
+ }
3715
+ ),
3716
+ /* @__PURE__ */ jsx42("span", { className: "aui-sr-only", children: tooltip })
3717
+ ]
3718
+ }
3719
+ );
3720
+ });
3721
+ AssistantModalButton.displayName = "AssistantModalButton";
3722
+ var AssistantModalContent = withDefaults(assistantModal_exports.Content, {
3723
+ className: "aui-root aui-modal-content",
3724
+ sideOffset: 16
3725
+ });
3726
+ AssistantModalContent.displayName = "AssistantModalContent";
3727
+ var exports11 = {
3728
+ Root: AssistantModalRoot,
3729
+ Trigger: AssistantModalTrigger,
3730
+ Content: AssistantModalContent
3731
+ };
3732
+ var assistant_modal_default = Object.assign(AssistantModal, exports11);
3733
+
2231
3734
  // src/internal.ts
2232
3735
  var internal_exports = {};
2233
3736
  __export(internal_exports, {
2234
3737
  BaseAssistantRuntime: () => BaseAssistantRuntime,
2235
3738
  MessageRepository: () => MessageRepository,
2236
3739
  ProxyConfigProvider: () => ProxyConfigProvider,
3740
+ TooltipIconButton: () => TooltipIconButton,
2237
3741
  useSmooth: () => useSmooth
2238
3742
  });
2239
3743
  export {
2240
3744
  actionBar_exports as ActionBarPrimitive,
3745
+ assistant_action_bar_default as AssistantActionBar,
3746
+ assistant_message_default as AssistantMessage,
3747
+ assistant_modal_default as AssistantModal,
2241
3748
  assistantModal_exports as AssistantModalPrimitive,
2242
3749
  AssistantRuntimeProvider,
3750
+ branch_picker_default as BranchPicker,
2243
3751
  branchPicker_exports as BranchPickerPrimitive,
3752
+ composer_default as Composer,
2244
3753
  composer_exports as ComposerPrimitive,
3754
+ content_part_default as ContentPart,
2245
3755
  contentPart_exports as ContentPartPrimitive,
3756
+ edit_composer_default as EditComposer,
2246
3757
  internal_exports as INTERNAL,
2247
3758
  message_exports as MessagePrimitive,
3759
+ thread_default as Thread,
3760
+ ThreadConfigProvider,
2248
3761
  thread_exports as ThreadPrimitive,
3762
+ thread_welcome_default as ThreadWelcome,
3763
+ user_action_bar_default as UserActionBar,
3764
+ user_message_default as UserMessage,
2249
3765
  makeAssistantTool,
2250
3766
  makeAssistantToolUI,
2251
3767
  useActionBarCopy,
@@ -2268,10 +3784,12 @@ export {
2268
3784
  useContentPartDisplay,
2269
3785
  useContentPartImage,
2270
3786
  useContentPartText,
3787
+ useEdgeRuntime,
2271
3788
  useLocalRuntime,
2272
3789
  useMessageContext,
2273
3790
  useMessageIf,
2274
3791
  useSwitchToNewThread,
3792
+ useThreadConfig,
2275
3793
  useThreadContext,
2276
3794
  useThreadEmpty,
2277
3795
  useThreadIf,