@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/README.md +10 -8
- package/dist/edge.d.mts +9 -0
- package/dist/edge.d.ts +9 -0
- package/dist/edge.js +264 -0
- package/dist/edge.js.map +1 -0
- package/dist/edge.mjs +237 -0
- package/dist/edge.mjs.map +1 -0
- package/dist/index.d.mts +422 -60
- package/dist/index.d.ts +422 -60
- package/dist/index.js +1581 -51
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +1572 -54
- package/dist/index.mjs.map +1 -1
- package/dist/styles/index.css +859 -0
- package/dist/styles/index.css.map +1 -0
- package/dist/styles/index.d.ts +2 -0
- package/dist/styles/modal.css +143 -0
- package/dist/styles/modal.css.map +1 -0
- package/dist/styles/modal.d.ts +2 -0
- package/dist/styles/tailwindcss/base-components.css +53 -0
- package/dist/styles/tailwindcss/modal.css +29 -0
- package/dist/styles/tailwindcss/thread.css +159 -0
- package/dist/styles/themes/default.css +61 -0
- package/dist/tailwindcss/index.d.mts +15 -0
- package/dist/tailwindcss/index.d.ts +15 -0
- package/dist/tailwindcss/index.js +108 -0
- package/dist/tailwindcss/index.js.map +1 -0
- package/dist/tailwindcss/index.mjs +77 -0
- package/dist/tailwindcss/index.mjs.map +1 -0
- package/package.json +49 -6
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
|
-
|
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
|
-
|
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: (
|
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 {
|
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
|
-
|
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 } =
|
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
|
356
|
+
import { createContext as createContext4, useContext as useContext4 } from "react";
|
356
357
|
var ContentPartContext = createContext4(
|
357
358
|
null
|
358
359
|
);
|
359
|
-
|
360
|
-
const context =
|
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 },
|
1103
|
+
var MessagePrimitiveRoot = forwardRef6(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef28) => {
|
1102
1104
|
const isHoveringRef = useIsHoveringRef();
|
1103
|
-
const ref = useComposedRefs(
|
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 :
|
1129
|
-
const status = partIndex === message.content.length - 1 ? messageStatus :
|
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(
|
1320
|
+
return /* @__PURE__ */ jsx16(Text2, { part, status });
|
1319
1321
|
case "image":
|
1320
|
-
return /* @__PURE__ */ jsx16(
|
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] ||
|
1325
|
-
const addResult = (result) => addToolResult(
|
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
|
-
|
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(
|
1836
|
-
/* @__PURE__ */ jsx24(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx24(
|
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(
|
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/
|
1891
|
+
// src/runtimes/local/useLocalRuntime.tsx
|
1882
1892
|
import { useInsertionEffect as useInsertionEffect3, useState as useState7 } from "react";
|
1883
1893
|
|
1884
|
-
// src/
|
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/
|
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/
|
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(
|
2086
|
-
return this.thread.addToolResult(
|
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/
|
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
|
-
|
2193
|
-
|
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
|
-
|
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/
|
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,
|