@copilotkit/react-core
Version:
<div align="center"> <a href="https://copilotkit.ai" target="_blank"> <img src="https://github.com/copilotkit/copilotkit/raw/main/assets/banner.png" alt="CopilotKit Logo"> </a>
765 lines (755 loc) • 30.7 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// src/hooks/use-chat.ts
var use_chat_exports = {};
__export(use_chat_exports, {
useChat: () => useChat
});
module.exports = __toCommonJS(use_chat_exports);
var import_react4 = require("react");
var import_shared2 = require("@copilotkit/shared");
var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
// src/types/frontend-action.ts
var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
var import_shared = require("@copilotkit/shared");
function processActionsForRuntimeRequest(actions) {
const filteredActions = actions.filter(
(action) => action.available !== import_runtime_client_gql.ActionInputAvailability.Disabled && action.disabled !== true && action.name !== "*" && action.available != "frontend" && !action.pairedAction
).map((action) => {
let available = import_runtime_client_gql.ActionInputAvailability.Enabled;
if (action.disabled) {
available = import_runtime_client_gql.ActionInputAvailability.Disabled;
} else if (action.available === "disabled") {
available = import_runtime_client_gql.ActionInputAvailability.Disabled;
} else if (action.available === "remote") {
available = import_runtime_client_gql.ActionInputAvailability.Remote;
}
return {
name: action.name,
description: action.description || "",
jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters || [])),
available
};
});
return filteredActions;
}
// src/hooks/use-copilot-runtime-client.ts
var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
// src/components/toast/toast-provider.tsx
var import_react2 = require("react");
// src/components/error-boundary/error-utils.tsx
var import_react = require("react");
// src/components/toast/exclamation-mark-icon.tsx
var import_jsx_runtime = require("react/jsx-runtime");
var ExclamationMarkIcon = ({
className,
style
}) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
"svg",
{
xmlns: "http://www.w3.org/2000/svg",
width: "24",
height: "24",
viewBox: "0 0 24 24",
fill: "none",
stroke: "currentColor",
strokeWidth: "2",
strokeLinecap: "round",
strokeLinejoin: "round",
className: `lucide lucide-circle-alert ${className ? className : ""}`,
style,
children: [
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("circle", { cx: "12", cy: "12", r: "10" }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("line", { x1: "12", x2: "12", y1: "8", y2: "12" }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("line", { x1: "12", x2: "12.01", y1: "16", y2: "16" })
]
}
);
// src/components/error-boundary/error-utils.tsx
var import_react_markdown = __toESM(require("react-markdown"));
var import_jsx_runtime2 = require("react/jsx-runtime");
function ErrorToast({ errors }) {
const errorsToRender = errors.map((error, idx) => {
var _a, _b, _c;
const originalError = "extensions" in error ? (_a = error.extensions) == null ? void 0 : _a.originalError : {};
const message = (_b = originalError == null ? void 0 : originalError.message) != null ? _b : error.message;
const code = "extensions" in error ? (_c = error.extensions) == null ? void 0 : _c.code : null;
return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
"div",
{
style: {
marginTop: idx === 0 ? 0 : 10,
marginBottom: 14
},
children: [
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ExclamationMarkIcon, { style: { marginBottom: 4 } }),
code && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
"div",
{
style: {
fontWeight: "600",
marginBottom: 4
},
children: [
"Copilot Cloud Error:",
" ",
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: { fontFamily: "monospace", fontWeight: "normal" }, children: code })
]
}
),
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_markdown.default, { children: message })
]
},
idx
);
});
return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
"div",
{
style: {
fontSize: "13px",
maxWidth: "600px"
},
children: [
errorsToRender,
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontSize: "11px", opacity: 0.75 }, children: "NOTE: This error only displays during local development." })
]
}
);
}
function useErrorToast() {
const { addToast } = useToast();
return (0, import_react.useCallback)(
(error) => {
const errorId = error.map((err) => {
var _a, _b;
const message = "extensions" in err ? ((_b = (_a = err.extensions) == null ? void 0 : _a.originalError) == null ? void 0 : _b.message) || err.message : err.message;
const stack = err.stack || "";
return btoa(message + stack).slice(0, 32);
}).join("|");
addToast({
type: "error",
id: errorId,
// Toast libraries typically dedupe by id
message: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ErrorToast, { errors: error })
});
},
[addToast]
);
}
function useAsyncCallback(callback, deps) {
const addErrorToast = useErrorToast();
return (0, import_react.useCallback)((...args) => __async(this, null, function* () {
try {
return yield callback(...args);
} catch (error) {
console.error("Error in async callback:", error);
addErrorToast([error]);
throw error;
}
}), deps);
}
// src/components/toast/toast-provider.tsx
var import_jsx_runtime3 = require("react/jsx-runtime");
var ToastContext = (0, import_react2.createContext)(void 0);
function useToast() {
const context = (0, import_react2.useContext)(ToastContext);
if (!context) {
throw new Error("useToast must be used within a ToastProvider");
}
return context;
}
// src/hooks/use-copilot-runtime-client.ts
var import_react3 = require("react");
var useCopilotRuntimeClient = (options) => {
const { addGraphQLErrorsToast } = useToast();
const addErrorToast = useErrorToast();
const { addToast } = useToast();
const runtimeClient = (0, import_react3.useMemo)(() => {
return new import_runtime_client_gql2.CopilotRuntimeClient(__spreadProps(__spreadValues({}, options), {
handleGQLErrors: (error) => {
if (error.graphQLErrors.length) {
addGraphQLErrorsToast(error.graphQLErrors);
} else {
addErrorToast([error]);
}
},
handleGQLWarning: (message) => {
console.warn(message);
addToast({ type: "warning", message });
}
}));
}, [options, addGraphQLErrorsToast, addToast]);
return runtimeClient;
};
// src/hooks/use-chat.ts
function useChat(options) {
const {
messages,
setMessages,
makeSystemMessageCallback,
copilotConfig,
setIsLoading,
initialMessages,
isLoading,
actions,
onFunctionCall,
onCoAgentStateRender,
setCoagentStatesWithRef,
coagentStatesRef,
agentSession,
setAgentSession,
threadId,
setThreadId,
runId,
setRunId,
chatAbortControllerRef,
agentLock,
extensions,
setExtensions,
langGraphInterruptAction,
setLangGraphInterruptAction
} = options;
const runChatCompletionRef = (0, import_react4.useRef)();
const addErrorToast = useErrorToast();
const agentSessionRef = (0, import_react4.useRef)(agentSession);
agentSessionRef.current = agentSession;
const runIdRef = (0, import_react4.useRef)(runId);
runIdRef.current = runId;
const extensionsRef = (0, import_react4.useRef)(extensions);
extensionsRef.current = extensions;
const publicApiKey = copilotConfig.publicApiKey;
const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared2.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
const runtimeClient = useCopilotRuntimeClient({
url: copilotConfig.chatApiEndpoint,
publicApiKey: copilotConfig.publicApiKey,
headers,
credentials: copilotConfig.credentials
});
const runChatCompletion = useAsyncCallback(
(previousMessages) => __async(this, null, function* () {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
setIsLoading(true);
const interruptEvent = langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event;
if ((interruptEvent == null ? void 0 : interruptEvent.name) === import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent && (interruptEvent == null ? void 0 : interruptEvent.value) && !(interruptEvent == null ? void 0 : interruptEvent.response) && agentSessionRef.current) {
addErrorToast([
new Error(
"A message was sent while interrupt is active. This will cause failure on the agent side"
)
]);
}
let newMessages = [
new import_runtime_client_gql3.TextMessage({
content: "",
role: import_runtime_client_gql3.Role.Assistant
})
];
chatAbortControllerRef.current = new AbortController();
setMessages([...previousMessages, ...newMessages]);
const systemMessage = makeSystemMessageCallback();
const messagesWithContext = [systemMessage, ...initialMessages || [], ...previousMessages];
const isAgentRun = agentSessionRef.current !== null;
const stream = runtimeClient.asStream(
runtimeClient.generateCopilotResponse({
data: __spreadProps(__spreadValues(__spreadProps(__spreadValues({
frontend: {
actions: processActionsForRuntimeRequest(actions),
url: window.location.href
},
threadId,
runId: runIdRef.current,
extensions: extensionsRef.current,
metaEvents: composeAndFlushMetaEventsInput([langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event]),
messages: (0, import_runtime_client_gql3.convertMessagesToGqlInput)((0, import_runtime_client_gql3.filterAgentStateMessages)(messagesWithContext))
}, copilotConfig.cloud ? {
cloud: __spreadValues({}, ((_c = (_b = (_a = copilotConfig.cloud.guardrails) == null ? void 0 : _a.input) == null ? void 0 : _b.restrictToTopic) == null ? void 0 : _c.enabled) ? {
guardrails: {
inputValidationRules: {
allowList: copilotConfig.cloud.guardrails.input.restrictToTopic.validTopics,
denyList: copilotConfig.cloud.guardrails.input.restrictToTopic.invalidTopics
}
}
} : {})
} : {}), {
metadata: {
requestType: import_runtime_client_gql3.CopilotRequestType.Chat
}
}), agentSessionRef.current ? {
agentSession: agentSessionRef.current
} : {}), {
agentStates: Object.values(coagentStatesRef.current).map((state) => {
var _a2;
return {
agentName: state.name,
state: JSON.stringify(state.state),
configurable: JSON.stringify((_a2 = state.configurable) != null ? _a2 : {})
};
}),
forwardedParameters: options.forwardedParameters || {}
}),
properties: copilotConfig.properties,
signal: (_d = chatAbortControllerRef.current) == null ? void 0 : _d.signal
})
);
const guardrailsEnabled = ((_g = (_f = (_e = copilotConfig.cloud) == null ? void 0 : _e.guardrails) == null ? void 0 : _f.input) == null ? void 0 : _g.restrictToTopic.enabled) || false;
const reader = stream.getReader();
let executedCoAgentStateRenders = [];
let followUp = void 0;
let messages2 = [];
let syncedMessages = [];
let interruptMessages = [];
try {
while (true) {
let done, value;
try {
const readResult = yield reader.read();
done = readResult.done;
value = readResult.value;
} catch (readError) {
break;
}
if (done) {
if (chatAbortControllerRef.current.signal.aborted) {
return [];
}
break;
}
if (!(value == null ? void 0 : value.generateCopilotResponse)) {
continue;
}
runIdRef.current = value.generateCopilotResponse.runId || null;
extensionsRef.current = import_runtime_client_gql3.CopilotRuntimeClient.removeGraphQLTypename(
value.generateCopilotResponse.extensions || {}
);
setRunId(runIdRef.current);
setExtensions(extensionsRef.current);
let rawMessagesResponse = value.generateCopilotResponse.messages;
((_i = (_h = value.generateCopilotResponse) == null ? void 0 : _h.metaEvents) != null ? _i : []).forEach((ev) => {
if (ev.name === import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent) {
let eventValue = (0, import_runtime_client_gql3.langGraphInterruptEvent)(ev).value;
eventValue = (0, import_shared2.parseJson)(eventValue, eventValue);
setLangGraphInterruptAction({
event: __spreadProps(__spreadValues({}, (0, import_runtime_client_gql3.langGraphInterruptEvent)(ev)), {
value: eventValue
})
});
}
if (ev.name === import_runtime_client_gql3.MetaEventName.CopilotKitLangGraphInterruptEvent) {
const data = ev.data;
rawMessagesResponse = [...rawMessagesResponse, ...data.messages];
interruptMessages = (0, import_runtime_client_gql3.convertGqlOutputToMessages)(
// @ts-ignore
(0, import_runtime_client_gql3.filterAdjacentAgentStateMessages)(data.messages)
);
}
});
messages2 = (0, import_runtime_client_gql3.convertGqlOutputToMessages)(
(0, import_runtime_client_gql3.filterAdjacentAgentStateMessages)(rawMessagesResponse)
);
if (messages2.length === 0) {
continue;
}
newMessages = [];
if (((_j = value.generateCopilotResponse.status) == null ? void 0 : _j.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
newMessages = [
new import_runtime_client_gql3.TextMessage({
role: import_runtime_client_gql3.MessageRole.Assistant,
content: ((_k = value.generateCopilotResponse.status.details) == null ? void 0 : _k.guardrailsReason) || ""
})
];
setMessages([...previousMessages, ...newMessages]);
break;
} else {
newMessages = [...messages2];
for (const message of messages2) {
if (message.isAgentStateMessage() && !message.active && !executedCoAgentStateRenders.includes(message.id) && onCoAgentStateRender) {
if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
break;
}
yield onCoAgentStateRender({
name: message.agentName,
nodeName: message.nodeName,
state: message.state
});
executedCoAgentStateRenders.push(message.id);
}
}
const lastAgentStateMessage = [...messages2].reverse().find((message) => message.isAgentStateMessage());
if (lastAgentStateMessage) {
if (lastAgentStateMessage.state.messages && lastAgentStateMessage.state.messages.length > 0) {
syncedMessages = (0, import_runtime_client_gql3.loadMessagesFromJsonRepresentation)(
lastAgentStateMessage.state.messages
);
}
setCoagentStatesWithRef((prevAgentStates) => __spreadProps(__spreadValues({}, prevAgentStates), {
[lastAgentStateMessage.agentName]: {
name: lastAgentStateMessage.agentName,
state: lastAgentStateMessage.state,
running: lastAgentStateMessage.running,
active: lastAgentStateMessage.active,
threadId: lastAgentStateMessage.threadId,
nodeName: lastAgentStateMessage.nodeName,
runId: lastAgentStateMessage.runId
}
}));
if (lastAgentStateMessage.running) {
setAgentSession({
threadId: lastAgentStateMessage.threadId,
agentName: lastAgentStateMessage.agentName,
nodeName: lastAgentStateMessage.nodeName
});
} else {
if (agentLock) {
setAgentSession({
threadId: (0, import_shared2.randomId)(),
agentName: agentLock,
nodeName: void 0
});
} else {
setAgentSession(null);
}
}
}
}
if (newMessages.length > 0) {
setMessages([...previousMessages, ...newMessages]);
}
}
let finalMessages = constructFinalMessages(
[...syncedMessages, ...interruptMessages],
previousMessages,
newMessages
);
let didExecuteAction = false;
if (onFunctionCall) {
const lastMessages = [];
for (let i = finalMessages.length - 1; i >= 0; i--) {
const message = finalMessages[i];
if ((message.isActionExecutionMessage() || message.isResultMessage()) && message.status.code !== import_runtime_client_gql3.MessageStatusCode.Pending) {
lastMessages.unshift(message);
} else {
break;
}
}
for (const message of lastMessages) {
setMessages(finalMessages);
const action = actions.find(
(action2) => action2.name === message.name
);
const currentResultMessagePairedFeAction = message.isResultMessage() ? getPairedFeAction(actions, message) : null;
const executeActionFromMessage = (action2, message2) => __async(this, null, function* () {
followUp = action2 == null ? void 0 : action2.followUp;
const resultMessage = yield executeAction({
onFunctionCall,
previousMessages,
message: message2,
chatAbortControllerRef,
onError: (error) => {
addErrorToast([error]);
console.error(`Failed to execute action ${message2.name}: ${error}`);
}
});
didExecuteAction = true;
const messageIndex = finalMessages.findIndex((msg) => msg.id === message2.id);
finalMessages.splice(messageIndex + 1, 0, resultMessage);
return resultMessage;
});
if (action && message.isActionExecutionMessage()) {
const resultMessage = yield executeActionFromMessage(action, message);
const pairedFeAction = getPairedFeAction(actions, resultMessage);
if (pairedFeAction) {
const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
name: pairedFeAction.name,
arguments: (0, import_shared2.parseJson)(resultMessage.result, resultMessage.result),
status: message.status,
createdAt: message.createdAt,
parentMessageId: message.parentMessageId
});
yield executeActionFromMessage(pairedFeAction, newExecutionMessage);
}
} else if (message.isResultMessage() && currentResultMessagePairedFeAction) {
const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
name: currentResultMessagePairedFeAction.name,
arguments: (0, import_shared2.parseJson)(message.result, message.result),
status: message.status,
createdAt: message.createdAt
});
finalMessages.push(newExecutionMessage);
yield executeActionFromMessage(
currentResultMessagePairedFeAction,
newExecutionMessage
);
}
}
setMessages(finalMessages);
}
if (
// if followUp is not explicitly false
followUp !== false && // and we executed an action
(didExecuteAction || // the last message is a server side result
!isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
!((_l = chatAbortControllerRef.current) == null ? void 0 : _l.signal.aborted)
) {
yield new Promise((resolve) => setTimeout(resolve, 10));
return yield runChatCompletionRef.current(finalMessages);
} else if ((_m = chatAbortControllerRef.current) == null ? void 0 : _m.signal.aborted) {
const repairedMessages = finalMessages.filter((message, actionExecutionIndex) => {
if (message.isActionExecutionMessage()) {
return finalMessages.find(
(msg, resultIndex) => msg.isResultMessage() && msg.actionExecutionId === message.id && resultIndex === actionExecutionIndex + 1
);
}
return true;
});
const repairedMessageIds = repairedMessages.map((message) => message.id);
setMessages(repairedMessages);
if ((_n = agentSessionRef.current) == null ? void 0 : _n.nodeName) {
setAgentSession({
threadId: agentSessionRef.current.threadId,
agentName: agentSessionRef.current.agentName,
nodeName: "__end__"
});
}
return newMessages.filter((message) => repairedMessageIds.includes(message.id));
} else {
return newMessages.slice();
}
} finally {
setIsLoading(false);
}
}),
[
messages,
setMessages,
makeSystemMessageCallback,
copilotConfig,
setIsLoading,
initialMessages,
isLoading,
actions,
onFunctionCall,
onCoAgentStateRender,
setCoagentStatesWithRef,
coagentStatesRef,
agentSession,
setAgentSession
]
);
runChatCompletionRef.current = runChatCompletion;
const runChatCompletionAndHandleFunctionCall = useAsyncCallback(
(messages2) => __async(this, null, function* () {
yield runChatCompletionRef.current(messages2);
}),
[messages]
);
const composeAndFlushMetaEventsInput = (0, import_react4.useCallback)(
(metaEvents) => {
return metaEvents.reduce((acc, event) => {
if (!event)
return acc;
switch (event.name) {
case import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent:
if (event.response) {
setLangGraphInterruptAction(null);
const value = event.value;
return [
...acc,
{
name: event.name,
value: typeof value === "string" ? value : JSON.stringify(value),
response: typeof event.response === "string" ? event.response : JSON.stringify(event.response)
}
];
}
return acc;
default:
return acc;
}
}, []);
},
[setLangGraphInterruptAction]
);
const append = useAsyncCallback(
(message, options2) => __async(this, null, function* () {
var _a;
if (isLoading) {
return;
}
const newMessages = [...messages, message];
setMessages(newMessages);
const followUp = (_a = options2 == null ? void 0 : options2.followUp) != null ? _a : true;
if (followUp) {
return runChatCompletionAndHandleFunctionCall(newMessages);
}
}),
[isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
);
const reload = useAsyncCallback(() => __async(this, null, function* () {
if (isLoading || messages.length === 0) {
return;
}
let newMessages = [...messages];
const lastMessage = messages[messages.length - 1];
if (lastMessage.isTextMessage() && lastMessage.role === "assistant") {
newMessages = newMessages.slice(0, -1);
}
setMessages(newMessages);
return runChatCompletionAndHandleFunctionCall(newMessages);
}), [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]);
const stop = () => {
var _a;
(_a = chatAbortControllerRef.current) == null ? void 0 : _a.abort("Stop was called");
};
return {
append,
reload,
stop,
runChatCompletion: () => runChatCompletionRef.current(messages)
};
}
function constructFinalMessages(syncedMessages, previousMessages, newMessages) {
const finalMessages = syncedMessages.length > 0 ? [...syncedMessages] : [...previousMessages, ...newMessages];
if (syncedMessages.length > 0) {
const messagesWithAgentState = [...previousMessages, ...newMessages];
let previousMessageId = void 0;
for (const message of messagesWithAgentState) {
if (message.isAgentStateMessage()) {
const index = finalMessages.findIndex((msg) => msg.id === previousMessageId);
if (index !== -1) {
finalMessages.splice(index + 1, 0, message);
}
}
previousMessageId = message.id;
}
}
return finalMessages;
}
function executeAction(_0) {
return __async(this, arguments, function* ({
onFunctionCall,
previousMessages,
message,
chatAbortControllerRef,
onError
}) {
let result;
let error = null;
try {
result = yield Promise.race([
onFunctionCall({
messages: previousMessages,
name: message.name,
args: message.arguments
}),
new Promise(
(resolve) => {
var _a;
return (_a = chatAbortControllerRef.current) == null ? void 0 : _a.signal.addEventListener(
"abort",
() => resolve("Operation was aborted by the user")
);
}
),
// if the user stopped generation, we also abort consecutive actions
new Promise((resolve) => {
var _a;
if ((_a = chatAbortControllerRef.current) == null ? void 0 : _a.signal.aborted) {
resolve("Operation was aborted by the user");
}
})
]);
} catch (e) {
onError(e);
}
return new import_runtime_client_gql3.ResultMessage({
id: "result-" + message.id,
result: import_runtime_client_gql3.ResultMessage.encodeResult(
error ? {
content: result,
error: JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
} : result
),
actionExecutionId: message.id,
actionName: message.name
});
});
}
function getPairedFeAction(actions, message) {
let actionName = null;
if (message.isActionExecutionMessage()) {
actionName = message.name;
} else if (message.isResultMessage()) {
actionName = message.actionName;
}
return actions.find(
(action) => action.name === actionName && action.available === "frontend" || action.pairedAction === actionName
);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
useChat
});
//# sourceMappingURL=use-chat.js.map