@copilotkit/react-core
Version:
<img src="https://github.com/user-attachments/assets/0a6b64d9-e193-4940-a3f6-60334ac34084" alt="banner" style="border-radius: 12px; border: 2px solid #d6d4fa;" />
1,227 lines (1,209 loc) • 95 kB
JavaScript
"use strict";
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 __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
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/index.ts
var hooks_exports = {};
__export(hooks_exports, {
runAgent: () => runAgent,
startAgent: () => startAgent,
stopAgent: () => stopAgent,
useCoAgent: () => useCoAgent,
useCoAgentStateRender: () => useCoAgentStateRender,
useCopilotAction: () => useCopilotAction,
useCopilotAdditionalInstructions: () => useCopilotAdditionalInstructions,
useCopilotAuthenticatedAction_c: () => useCopilotAuthenticatedAction_c,
useCopilotChat: () => useCopilotChat2,
useCopilotChatHeadless_c: () => useCopilotChatHeadless_c,
useCopilotChatInternal: () => useCopilotChat,
useCopilotReadable: () => useCopilotReadable,
useCopilotRuntimeClient: () => useCopilotRuntimeClient,
useLangGraphInterrupt: () => useLangGraphInterrupt,
useLangGraphInterruptRender: () => useLangGraphInterruptRender,
useMakeCopilotDocumentReadable: () => useMakeCopilotDocumentReadable
});
module.exports = __toCommonJS(hooks_exports);
// src/hooks/use-copilot-chat_internal.ts
var import_react10 = require("react");
// src/context/copilot-context.tsx
var import_react = __toESM(require("react"));
var emptyCopilotContext = {
actions: {},
setAction: () => {
},
removeAction: () => {
},
coAgentStateRenders: {},
setCoAgentStateRender: () => {
},
removeCoAgentStateRender: () => {
},
chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },
getContextString: (documents, categories) => returnAndThrowInDebug(""),
addContext: () => "",
removeContext: () => {
},
getAllContext: () => [],
getFunctionCallHandler: () => returnAndThrowInDebug(() => __async(void 0, null, function* () {
})),
isLoading: false,
setIsLoading: () => returnAndThrowInDebug(false),
chatInstructions: "",
setChatInstructions: () => returnAndThrowInDebug(""),
additionalInstructions: [],
setAdditionalInstructions: () => returnAndThrowInDebug([]),
getDocumentsContext: (categories) => returnAndThrowInDebug([]),
addDocumentContext: () => returnAndThrowInDebug(""),
removeDocumentContext: () => {
},
runtimeClient: {},
copilotApiConfig: new class {
get chatApiEndpoint() {
throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
}
get headers() {
return {};
}
get body() {
return {};
}
}(),
chatSuggestionConfiguration: {},
addChatSuggestionConfiguration: () => {
},
removeChatSuggestionConfiguration: () => {
},
showDevConsole: false,
coagentStates: {},
setCoagentStates: () => {
},
coagentStatesRef: { current: {} },
setCoagentStatesWithRef: () => {
},
agentSession: null,
setAgentSession: () => {
},
forwardedParameters: {},
agentLock: null,
threadId: "",
setThreadId: () => {
},
runId: null,
setRunId: () => {
},
chatAbortControllerRef: { current: null },
availableAgents: [],
extensions: {},
setExtensions: () => {
},
langGraphInterruptAction: null,
setLangGraphInterruptAction: () => null,
removeLangGraphInterruptAction: () => null,
onError: void 0,
bannerError: null,
setBannerError: () => {
}
};
var CopilotContext = import_react.default.createContext(emptyCopilotContext);
function useCopilotContext() {
const context = import_react.default.useContext(CopilotContext);
if (context === emptyCopilotContext) {
throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
}
return context;
}
function returnAndThrowInDebug(_value) {
throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
}
// src/context/copilot-messages-context.tsx
var import_react2 = __toESM(require("react"));
var emptyCopilotContext2 = {
messages: [],
setMessages: () => [],
// suggestions state
suggestions: [],
setSuggestions: () => []
};
var CopilotMessagesContext = import_react2.default.createContext(emptyCopilotContext2);
function useCopilotMessagesContext() {
const context = import_react2.default.useContext(CopilotMessagesContext);
if (context === emptyCopilotContext2) {
throw new Error(
"A messages consuming component was not wrapped with `<CopilotMessages> {...} </CopilotMessages>`"
);
}
return context;
}
// src/hooks/use-chat.ts
var import_react6 = require("react");
var import_react_dom = require("react-dom");
var import_shared4 = 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_react3 = require("react");
var import_shared2 = require("@copilotkit/shared");
var import_jsx_runtime = require("react/jsx-runtime");
var ToastContext = (0, import_react3.createContext)(void 0);
function useToast() {
const context = (0, import_react3.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_react4 = require("react");
var import_shared3 = require("@copilotkit/shared");
// src/utils/dev-console.ts
function isLocalhost() {
if (typeof window === "undefined")
return false;
return window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname === "0.0.0.0";
}
function shouldShowDevConsole(showDevConsole) {
if (showDevConsole !== void 0) {
return showDevConsole;
}
return isLocalhost();
}
// src/hooks/use-copilot-runtime-client.ts
var useCopilotRuntimeClient = (options) => {
const { setBannerError } = useToast();
const _a = options, { showDevConsole, onError } = _a, runtimeOptions = __objRest(_a, ["showDevConsole", "onError"]);
const lastStructuredErrorRef = (0, import_react4.useRef)(null);
const traceUIError = (error, originalError) => __async(void 0, null, function* () {
if (!onError || !runtimeOptions.publicApiKey)
return;
try {
const errorEvent = {
type: "error",
timestamp: Date.now(),
context: {
source: "ui",
request: {
operation: "runtimeClient",
url: runtimeOptions.url,
startTime: Date.now()
},
technical: {
environment: "browser",
userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
stackTrace: originalError instanceof Error ? originalError.stack : void 0
}
},
error
};
yield onError(errorEvent);
} catch (error2) {
console.error("Error in onError handler:", error2);
}
});
const runtimeClient = (0, import_react4.useMemo)(() => {
return new import_runtime_client_gql2.CopilotRuntimeClient(__spreadProps(__spreadValues({}, runtimeOptions), {
handleGQLErrors: (error) => {
var _a2;
if ((_a2 = error.graphQLErrors) == null ? void 0 : _a2.length) {
const graphQLErrors = error.graphQLErrors;
const routeError = (gqlError) => {
const extensions = gqlError.extensions;
const visibility = extensions == null ? void 0 : extensions.visibility;
const isDev = shouldShowDevConsole(showDevConsole != null ? showDevConsole : false);
if (visibility === import_shared3.ErrorVisibility.SILENT) {
console.error("CopilotKit Silent Error:", gqlError.message);
return;
}
if (!isDev) {
console.error("CopilotKit Error (hidden in production):", gqlError.message);
return;
}
const now = Date.now();
const errorMessage = gqlError.message;
if (lastStructuredErrorRef.current && lastStructuredErrorRef.current.message === errorMessage && now - lastStructuredErrorRef.current.timestamp < 150) {
return;
}
lastStructuredErrorRef.current = { message: errorMessage, timestamp: now };
const ckError = createStructuredError(gqlError);
if (ckError) {
setBannerError(ckError);
traceUIError(ckError, gqlError);
} else {
const fallbackError = new import_shared3.CopilotKitError({
message: gqlError.message,
code: import_shared3.CopilotKitErrorCode.UNKNOWN
});
setBannerError(fallbackError);
traceUIError(fallbackError, gqlError);
}
};
graphQLErrors.forEach(routeError);
} else {
const isDev = shouldShowDevConsole(showDevConsole != null ? showDevConsole : false);
if (!isDev) {
console.error("CopilotKit Error (hidden in production):", error);
} else {
const fallbackError = new import_shared3.CopilotKitError({
message: (error == null ? void 0 : error.message) || String(error),
code: import_shared3.CopilotKitErrorCode.UNKNOWN
});
setBannerError(fallbackError);
traceUIError(fallbackError, error);
}
}
},
handleGQLWarning: (message) => {
console.warn(message);
const warningError = new import_shared3.CopilotKitError({
message,
code: import_shared3.CopilotKitErrorCode.UNKNOWN
});
setBannerError(warningError);
}
}));
}, [runtimeOptions, setBannerError, showDevConsole, onError]);
return runtimeClient;
};
function createStructuredError(gqlError) {
var _a, _b, _c;
const extensions = gqlError.extensions;
const originalError = extensions == null ? void 0 : extensions.originalError;
const message = (originalError == null ? void 0 : originalError.message) || gqlError.message;
const code = extensions == null ? void 0 : extensions.code;
if (code) {
return new import_shared3.CopilotKitError({ message, code });
}
if ((_a = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _a.includes("CopilotApiDiscoveryError")) {
return new import_shared3.CopilotKitApiDiscoveryError({ message });
}
if ((_b = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _b.includes("CopilotKitRemoteEndpointDiscoveryError")) {
return new import_shared3.CopilotKitRemoteEndpointDiscoveryError({ message });
}
if ((_c = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _c.includes("CopilotKitAgentDiscoveryError")) {
return new import_shared3.CopilotKitAgentDiscoveryError({
agentName: "",
availableAgents: []
});
}
return null;
}
// src/components/error-boundary/error-utils.tsx
var import_react5 = require("react");
// src/components/toast/exclamation-mark-icon.tsx
var import_jsx_runtime2 = require("react/jsx-runtime");
var ExclamationMarkIcon = ({
className,
style
}) => /* @__PURE__ */ (0, import_jsx_runtime2.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_runtime2.jsx)("circle", { cx: "12", cy: "12", r: "10" }),
/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", x2: "12", y1: "8", y2: "12" }),
/* @__PURE__ */ (0, import_jsx_runtime2.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_runtime3 = 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_runtime3.jsxs)(
"div",
{
style: {
marginTop: idx === 0 ? 0 : 10,
marginBottom: 14
},
children: [
/* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ExclamationMarkIcon, { style: { marginBottom: 4 } }),
code && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
"div",
{
style: {
fontWeight: "600",
marginBottom: 4
},
children: [
"Copilot Runtime Error:",
" ",
/* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { fontFamily: "monospace", fontWeight: "normal" }, children: code })
]
}
),
/* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_markdown.default, { children: message })
]
},
idx
);
});
return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
"div",
{
style: {
fontSize: "13px",
maxWidth: "600px"
},
children: [
errorsToRender,
/* @__PURE__ */ (0, import_jsx_runtime3.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_react5.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_runtime3.jsx)(ErrorToast, { errors: error })
});
},
[addToast]
);
}
function useAsyncCallback(callback, deps) {
const addErrorToast = useErrorToast();
return (0, import_react5.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/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_react6.useRef)();
const addErrorToast = useErrorToast();
const { setBannerError } = useToast();
const { onError } = useCopilotContext();
const traceUIError = (error, originalError) => __async(this, null, function* () {
if (!onError || !(copilotConfig == null ? void 0 : copilotConfig.publicApiKey))
return;
try {
const traceEvent = {
type: "error",
timestamp: Date.now(),
context: {
source: "ui",
request: {
operation: "useChatCompletion",
url: copilotConfig.chatApiEndpoint,
startTime: Date.now()
},
technical: {
environment: "browser",
userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
stackTrace: originalError instanceof Error ? originalError.stack : void 0
}
},
error
};
yield onError(traceEvent);
} catch (traceError) {
console.error("Error in use-chat onError handler:", traceError);
}
});
const agentSessionRef = (0, import_react6.useRef)(agentSession);
agentSessionRef.current = agentSession;
const runIdRef = (0, import_react6.useRef)(runId);
runIdRef.current = runId;
const extensionsRef = (0, import_react6.useRef)(extensions);
extensionsRef.current = extensions;
const publicApiKey = copilotConfig.publicApiKey;
const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared4.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
const { showDevConsole } = useCopilotContext();
const runtimeClient = useCopilotRuntimeClient({
url: copilotConfig.chatApiEndpoint,
publicApiKey: copilotConfig.publicApiKey,
headers,
credentials: copilotConfig.credentials,
showDevConsole
});
const pendingAppendsRef = (0, import_react6.useRef)([]);
const runChatCompletion = useAsyncCallback(
(previousMessages) => __async(this, null, function* () {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
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 finalProperties = __spreadValues({}, copilotConfig.properties || {});
let mcpServersToUse = null;
if (copilotConfig.mcpServers && Array.isArray(copilotConfig.mcpServers) && copilotConfig.mcpServers.length > 0) {
mcpServersToUse = copilotConfig.mcpServers;
} else if (((_a = copilotConfig.properties) == null ? void 0 : _a.mcpServers) && Array.isArray(copilotConfig.properties.mcpServers) && copilotConfig.properties.mcpServers.length > 0) {
mcpServersToUse = copilotConfig.properties.mcpServers;
}
if (mcpServersToUse) {
finalProperties.mcpServers = mcpServersToUse;
copilotConfig.mcpServers = mcpServersToUse;
}
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({}, ((_d = (_c = (_b = copilotConfig.cloud.guardrails) == null ? void 0 : _b.input) == null ? void 0 : _c.restrictToTopic) == null ? void 0 : _d.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) => {
const stateObject = {
agentName: state.name,
state: JSON.stringify(state.state)
};
if (state.config !== void 0) {
stateObject.config = JSON.stringify(state.config);
}
return stateObject;
}),
forwardedParameters: options.forwardedParameters || {}
}),
properties: finalProperties,
signal: (_e = chatAbortControllerRef.current) == null ? void 0 : _e.signal
})
);
const guardrailsEnabled = ((_h = (_g = (_f = copilotConfig.cloud) == null ? void 0 : _f.guardrails) == null ? void 0 : _g.input) == null ? void 0 : _h.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;
const metaEvents = (_j = (_i = value.generateCopilotResponse) == null ? void 0 : _i.metaEvents) != null ? _j : [];
(metaEvents != null ? metaEvents : []).forEach((ev) => {
if (ev.name === import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent) {
let eventValue = (0, import_runtime_client_gql3.langGraphInterruptEvent)(ev).value;
eventValue = (0, import_shared4.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)
);
newMessages = [];
if (((_k = value.generateCopilotResponse.status) == null ? void 0 : _k.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
const guardrailsReason = ((_l = value.generateCopilotResponse.status.details) == null ? void 0 : _l.guardrailsReason) || "";
newMessages = [
new import_runtime_client_gql3.TextMessage({
role: import_runtime_client_gql3.MessageRole.Assistant,
content: guardrailsReason
})
];
const guardrailsError = new import_shared4.CopilotKitError({
message: `Guardrails validation failed: ${guardrailsReason}`,
code: import_shared4.CopilotKitErrorCode.MISUSE
});
yield traceUIError(guardrailsError, {
statusReason: value.generateCopilotResponse.status.reason,
statusDetails: value.generateCopilotResponse.status.details
});
setMessages([...previousMessages, ...newMessages]);
break;
}
if (((_m = value.generateCopilotResponse.status) == null ? void 0 : _m.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "UNKNOWN_ERROR") {
const errorMessage = ((_n = value.generateCopilotResponse.status.details) == null ? void 0 : _n.description) || "An unknown error occurred";
const statusDetails = value.generateCopilotResponse.status.details;
const originalError = (statusDetails == null ? void 0 : statusDetails.originalError) || (statusDetails == null ? void 0 : statusDetails.error);
const originalCode = (originalError == null ? void 0 : originalError.code) || ((_o = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _o.code);
const originalSeverity = (originalError == null ? void 0 : originalError.severity) || ((_p = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _p.severity);
const originalVisibility = (originalError == null ? void 0 : originalError.visibility) || ((_q = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _q.visibility);
let errorCode = import_shared4.CopilotKitErrorCode.NETWORK_ERROR;
if (originalCode && Object.values(import_shared4.CopilotKitErrorCode).includes(originalCode)) {
errorCode = originalCode;
}
const structuredError = new import_shared4.CopilotKitError({
message: errorMessage,
code: errorCode,
severity: originalSeverity,
visibility: originalVisibility
});
setBannerError(structuredError);
yield traceUIError(structuredError, {
statusReason: value.generateCopilotResponse.status.reason,
statusDetails: value.generateCopilotResponse.status.details,
originalErrorCode: originalCode,
preservedStructure: !!originalCode
});
setIsLoading(false);
break;
} else if (messages2.length > 0) {
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) => {
var _a2;
return __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,
// Preserve existing config from previous state
config: (_a2 = prevAgentStates[lastAgentStateMessage.agentName]) == null ? void 0 : _a2.config
}
});
});
if (lastAgentStateMessage.running) {
setAgentSession({
threadId: lastAgentStateMessage.threadId,
agentName: lastAgentStateMessage.agentName,
nodeName: lastAgentStateMessage.nodeName
});
} else {
if (agentLock) {
setAgentSession({
threadId: (0, import_shared4.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;
const executeActionFromMessage = (currentAction, actionMessage) => __async(this, null, function* () {
var _a2;
const isInterruptAction = interruptMessages.find((m) => m.id === actionMessage.id);
followUp = (_a2 = currentAction == null ? void 0 : currentAction.followUp) != null ? _a2 : !isInterruptAction;
if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
currentAction._setActivatingMessageId(actionMessage.id);
}
const resultMessage = yield executeAction({
onFunctionCall,
message: actionMessage,
chatAbortControllerRef,
onError: (error) => {
addErrorToast([error]);
console.error(`Failed to execute action ${actionMessage.name}: ${error}`);
},
setMessages,
getFinalMessages: () => finalMessages,
isRenderAndWait: (currentAction == null ? void 0 : currentAction._isRenderAndWait) || false
});
didExecuteAction = true;
const messageIndex = finalMessages.findIndex((msg) => msg.id === actionMessage.id);
finalMessages.splice(messageIndex + 1, 0, resultMessage);
if (currentAction == null ? void 0 : currentAction._isRenderAndWait) {
const messagesForImmediateUpdate = [...finalMessages];
(0, import_react_dom.flushSync)(() => {
setMessages(messagesForImmediateUpdate);
});
}
if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
currentAction._setActivatingMessageId(null);
}
return resultMessage;
});
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 if (!message.isAgentStateMessage()) {
break;
}
}
for (const message of lastMessages) {
setMessages(finalMessages);
const action = actions.find(
(action2) => action2.name === message.name
);
if (action && action.available === "frontend") {
continue;
}
const currentResultMessagePairedFeAction = message.isResultMessage() ? getPairedFeAction(actions, message) : null;
if (action && message.isActionExecutionMessage()) {
const isRenderAndWaitAction = (action == null ? void 0 : action._isRenderAndWait) || false;
const alreadyProcessed = isRenderAndWaitAction && finalMessages.some(
(fm) => fm.isResultMessage() && fm.actionExecutionId === message.id
);
if (alreadyProcessed) {
} else {
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_shared4.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_shared4.parseJson)(message.result, message.result),
status: message.status,
createdAt: message.createdAt
});
finalMessages.push(newExecutionMessage);
yield executeActionFromMessage(
currentResultMessagePairedFeAction,
newExecutionMessage
);
}
}
setMessages(finalMessages);
}
if (followUp !== false && (didExecuteAction || // the last message is a server side result
!isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
!((_r = chatAbortControllerRef.current) == null ? void 0 : _r.signal.aborted)) {
yield new Promise((resolve) => setTimeout(resolve, 10));
return yield runChatCompletionRef.current(finalMessages);
} else if ((_s = chatAbortControllerRef.current) == null ? void 0 : _s.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 ((_t = agentSessionRef.current) == null ? void 0 : _t.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]
);
(0, import_react6.useEffect)(() => {
if (!isLoading && pendingAppendsRef.current.length > 0) {
const pending = pendingAppendsRef.current.splice(0);
const followUp = pending.some((p) => p.followUp);
const newMessages = [...messages, ...pending.map((p) => p.message)];
setMessages(newMessages);
if (followUp) {
runChatCompletionAndHandleFunctionCall(newMessages);
}
}
}, [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]);
const composeAndFlushMetaEventsInput = (0, import_react6.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;
const followUp = (_a = options2 == null ? void 0 : options2.followUp) != null ? _a : true;
if (isLoading) {
pendingAppendsRef.current.push({ message, followUp });
return;
}
const newMessages = [...messages, message];
setMessages(newMessages);
if (followUp) {
return runChatCompletionAndHandleFunctionCall(newMessages);
}
}),
[isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
);
const reload = useAsyncCallback(
(reloadMessageId) => __async(this, null, function* () {
if (isLoading || messages.length === 0) {
return;
}
const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
if (reloadMessageIndex === -1) {
console.warn(`Message with id ${reloadMessageId} not found`);
return;
}
const reloadMessageRole = messages[reloadMessageIndex].role;
if (reloadMessageRole !== import_runtime_client_gql3.MessageRole.Assistant) {
console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
return;
}
let historyCutoff = [];
if (messages.length > 2) {
const lastUserMessageBeforeRegenerate = messages.slice(0, reloadMessageIndex).reverse().find(
(msg) => (
// @ts-expect-error -- message has role
msg.role === import_runtime_client_gql3.MessageRole.User
)
);
const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
(msg) => msg.id === lastUserMessageBeforeRegenerate.id
);
historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
}
setMessages(historyCutoff);
return runChatCompletionAndHandleFunctionCall(historyCutoff);
}),
[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,
message,
chatAbortControllerRef,
onError,
setMessages,
getFinalMessages,
isRenderAndWait
}) {
let result;
let error = null;
const currentMessagesForHandler = getFinalMessages();
const handlerReturnedPromise = onFunctionCall({
messages: currentMessagesForHandler,
name: message.name,
args: message.arguments
});
if (isRenderAndWait) {
const currentMessagesForRender = getFinalMessages();
(0, import_react_dom.flushSync)(() => {
setMessages([...currentMessagesForRender]);
});
}
try {
result = yield Promise.race([
handlerReturnedPromise,
// Await the promise returned by the handler
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
);
}
// src/components/copilot-provider/copilotkit.tsx
var import_react8 = require("react");
var import_react_dom2 = require("react-dom");
var import_shared8 = require("@copilotkit/shared");
// src/components/copilot-provider/copilot-messages.tsx
var import_react7 = require("react");
var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
var import_shared5 = require("@copilotkit/shared");
var import_jsx_runtime4 = require("react/jsx-runtime");
var MessagesTapContext = (0, import_react7.createContext)(null);
function useMessagesTap() {
const tap = (0, import_react7.useContext)(MessagesTapContext);
if (!tap)
throw new Error("useMessagesTap must be used inside <MessagesTapProvider>");
return tap;
}
// src/utils/extract.ts
var import_shared6 = require("@copilotkit/shared");
var import_runtime_client_gql5 = require("@copilotkit/runtime-client-gql");
var import_runtime_client_gql6 = require("@copilotkit/runtime-client-gql");
function extract(_0) {
return __async(this, arguments, function* ({
context,
instructions,
parameters,
include,
data,
abortSignal,
stream,
requestType = import_runtime_client_gql5.CopilotRequestType.Task,
forwardedParameters
}) {
var _a, _b;
const { messages } = context;
const action = {
name: "extract",
description: instructions,
parameters,
handler: (args) => {
}
};
const includeReadable = (_a = include == null ? void 0 : include.readable) != null ? _a : false;
const includeMessages = (_b = include == null ? void 0 : include.messages) != null ? _b : false;
let contextString = "";
if (data) {
contextString = (typeof data === "string" ? data : JSON.stringify(data)) + "\n\n";
}
if (includeReadable) {
contextString += context.getContextString([], defaultCopilotContextCategories);
}
const systemMessage = new import_runtime_client_gql5.TextMessage({
content: makeSystemMessage(contextString, instructions),
role: import_runtime_client_gql5.Role.System
});
const instructionsMessage = n