@copilotkit/react-core 1.10.0-next.1 → 1.10.0-next.10

package/dist/hooks/use-copilot-chat-headless_c.js

@@ -0,0 +1,1837 @@
+"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/use-copilot-chat-headless_c.ts
+var use_copilot_chat_headless_c_exports = {};
+__export(use_copilot_chat_headless_c_exports, {
+  defaultSystemMessage: () => defaultSystemMessage,
+  useCopilotChatHeadless_c: () => useCopilotChatHeadless_c
+});
+module.exports = __toCommonJS(use_copilot_chat_headless_c_exports);
+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/hooks/use-copilot-chat_internal.ts
+var import_react9 = require("react");
+
+// 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_react7 = require("react");
+var import_react_dom2 = require("react-dom");
+var import_shared7 = require("@copilotkit/shared");
+
+// src/utils/extract.ts
+var import_shared5 = require("@copilotkit/shared");
+var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
+var import_runtime_client_gql5 = require("@copilotkit/runtime-client-gql");
+function extract(_0) {
+  return __async(this, arguments, function* ({
+    context,
+    instructions,
+    parameters,
+    include,
+    data,
+    abortSignal,
+    stream,
+    requestType = import_runtime_client_gql4.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_gql4.TextMessage({
+      content: makeSystemMessage(contextString, instructions),
+      role: import_runtime_client_gql4.Role.System
+    });
+    const instructionsMessage = new import_runtime_client_gql4.TextMessage({
+      content: makeInstructionsMessage(instructions),
+      role: import_runtime_client_gql4.Role.User
+    });
+    const response = context.runtimeClient.asStream(
+      context.runtimeClient.generateCopilotResponse({
+        data: {
+          frontend: {
+            actions: [
+              {
+                name: action.name,
+                description: action.description || "",
+                jsonSchema: JSON.stringify((0, import_shared5.actionParametersToJsonSchema)(action.parameters || []))
+              }
+            ],
+            url: window.location.href
+          },
+          messages: (0, import_runtime_client_gql5.convertMessagesToGqlInput)(
+            includeMessages ? [systemMessage, instructionsMessage, ...(0, import_runtime_client_gql5.filterAgentStateMessages)(messages)] : [systemMessage, instructionsMessage]
+          ),
+          metadata: {
+            requestType
+          },
+          forwardedParameters: __spreadProps(__spreadValues({}, forwardedParameters != null ? forwardedParameters : {}), {
+            toolChoice: "function",
+            toolChoiceFunctionName: action.name
+          })
+        },
+        properties: context.copilotApiConfig.properties,
+        signal: abortSignal
+      })
+    );
+    const reader = response.getReader();
+    let isInitial = true;
+    let actionExecutionMessage = void 0;
+    while (true) {
+      const { done, value } = yield reader.read();
+      if (done) {
+        break;
+      }
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        throw new Error("Aborted");
+      }
+      actionExecutionMessage = (0, import_runtime_client_gql4.convertGqlOutputToMessages)(
+        value.generateCopilotResponse.messages
+      ).find((msg) => msg.isActionExecutionMessage());
+      if (!actionExecutionMessage) {
+        continue;
+      }
+      stream == null ? void 0 : stream({
+        status: isInitial ? "initial" : "inProgress",
+        args: actionExecutionMessage.arguments
+      });
+      isInitial = false;
+    }
+    if (!actionExecutionMessage) {
+      throw new Error("extract() failed: No function call occurred");
+    }
+    stream == null ? void 0 : stream({
+      status: "complete",
+      args: actionExecutionMessage.arguments
+    });
+    return actionExecutionMessage.arguments;
+  });
+}
+function makeInstructionsMessage(instructions) {
+  return `
+The user has given you the following task to complete:
+
+\`\`\`
+${instructions}
+\`\`\`
+
+Any additional messages provided are for providing context only and should not be used to ask questions or engage in conversation.
+`;
+}
+function makeSystemMessage(contextString, instructions) {
+  return `
+Please act as an efficient, competent, conscientious, and industrious professional assistant.
+
+Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
+Always be polite and respectful, and prefer brevity over verbosity.
+
+The user has provided you with the following context:
+\`\`\`
+${contextString}
+\`\`\`
+
+They have also provided you with a function called extract you MUST call to initiate actions on their behalf.
+
+Please assist them as best you can.
+
+This is not a conversation, so please do not ask questions. Just call the function without saying anything else.
+`;
+}
+
+// src/utils/suggestions.ts
+var import_shared6 = require("@copilotkit/shared");
+var import_runtime_client_gql6 = require("@copilotkit/runtime-client-gql");
+var reloadSuggestions = (context, chatSuggestionConfiguration, setCurrentSuggestions, abortControllerRef) => __async(void 0, null, function* () {
+  const abortController = abortControllerRef.current;
+  if (abortController == null ? void 0 : abortController.signal.aborted) {
+    return;
+  }
+  const setSuggestionsIfNotAborted = (suggestions) => {
+    if (!(abortController == null ? void 0 : abortController.signal.aborted) && abortControllerRef.current === abortController) {
+      setCurrentSuggestions(suggestions);
+    }
+  };
+  try {
+    const tools = JSON.stringify(
+      Object.values(context.actions).map((action) => ({
+        name: action.name,
+        description: action.description,
+        jsonSchema: JSON.stringify((0, import_shared6.actionParametersToJsonSchema)(action.parameters))
+      }))
+    );
+    const allSuggestions = [];
+    let hasSuccessfulSuggestions = false;
+    let hasErrors = false;
+    let lastError = null;
+    const enabledConfigs = Object.values(chatSuggestionConfiguration).filter(
+      (config) => config.instructions && config.instructions.trim().length > 0
+    );
+    if (enabledConfigs.length === 0) {
+      return;
+    }
+    setSuggestionsIfNotAborted([]);
+    for (const config of enabledConfigs) {
+      if (abortController == null ? void 0 : abortController.signal.aborted) {
+        setSuggestionsIfNotAborted([]);
+        return;
+      }
+      try {
+        const result = yield extract({
+          context,
+          instructions: "Suggest what the user could say next. Provide clear, highly relevant suggestions. Do not literally suggest function calls. ",
+          data: `${config.instructions}
+
+Available tools: ${tools}
+
+`,
+          requestType: import_runtime_client_gql6.CopilotRequestType.Task,
+          parameters: [
+            {
+              name: "suggestions",
+              type: "object[]",
+              attributes: [
+                {
+                  name: "title",
+                  description: "The title of the suggestion. This is shown as a button and should be short.",
+                  type: "string"
+                },
+                {
+                  name: "message",
+                  description: "The message to send when the suggestion is clicked. This should be a clear, complete sentence and will be sent as an instruction to the AI.",
+                  type: "string"
+                }
+              ]
+            }
+          ],
+          include: {
+            messages: true,
+            readable: true
+          },
+          abortSignal: abortController == null ? void 0 : abortController.signal,
+          stream: ({ status, args }) => {
+            if (abortController == null ? void 0 : abortController.signal.aborted) {
+              return;
+            }
+            const suggestions = args.suggestions || [];
+            const newSuggestions = [];
+            for (let i = 0; i < suggestions.length; i++) {
+              if (config.maxSuggestions !== void 0 && i >= config.maxSuggestions) {
+                break;
+              }
+              const suggestion = suggestions[i];
+              if (!suggestion || typeof suggestion !== "object") {
+                continue;
+              }
+              const { title, message } = suggestion;
+              const hasValidTitle = title && typeof title === "string" && title.trim().length > 0;
+              const hasValidMessage = message && typeof message === "string" && message.trim().length > 0;
+              if (!hasValidTitle) {
+                continue;
+              }
+              const partial = i === suggestions.length - 1 && status !== "complete";
+              newSuggestions.push({
+                title: title.trim(),
+                message: hasValidMessage ? message.trim() : "",
+                // Use title as fallback
+                partial,
+                className: config.className
+              });
+            }
+            setSuggestionsIfNotAborted([...allSuggestions, ...newSuggestions]);
+          }
+        });
+        if ((result == null ? void 0 : result.suggestions) && Array.isArray(result.suggestions)) {
+          const validSuggestions = result.suggestions.filter(
+            (suggestion) => suggestion && typeof suggestion.title === "string" && suggestion.title.trim().length > 0
+          ).map((suggestion) => ({
+            title: suggestion.title.trim(),
+            message: suggestion.message && typeof suggestion.message === "string" && suggestion.message.trim() ? suggestion.message.trim() : suggestion.title.trim()
+          }));
+          if (validSuggestions.length > 0) {
+            allSuggestions.push(...validSuggestions);
+            hasSuccessfulSuggestions = true;
+          }
+        }
+      } catch (error) {
+        hasErrors = true;
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    if (hasSuccessfulSuggestions && allSuggestions.length > 0) {
+      const uniqueSuggestions = allSuggestions.filter(
+        (suggestion, index, self) => index === self.findIndex((s) => s.message === suggestion.message)
+      );
+      setSuggestionsIfNotAborted(uniqueSuggestions);
+    } else if (hasErrors) {
+      const errorMessage = lastError ? lastError.message : "Failed to generate suggestions due to API errors";
+      throw new Error(errorMessage);
+    }
+  } catch (error) {
+    throw error;
+  }
+});
+
+// src/components/copilot-provider/copilotkit.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var defaultCopilotContextCategories = ["global"];
+
+// src/hooks/use-copilot-chat_internal.ts
+var import_runtime_client_gql7 = require("@copilotkit/runtime-client-gql");
+
+// src/hooks/use-langgraph-interrupt-render.ts
+var import_react8 = __toESM(require("react"));
+var InterruptRenderer = ({ event, result, render, resolve }) => {
+  return render({ event, result, resolve });
+};
+function useLangGraphInterruptRender() {
+  const { langGraphInterruptAction, setLangGraphInterruptAction, agentSession } = useCopilotContext();
+  const responseRef = import_react8.default.useRef();
+  const resolveInterrupt = (0, import_react8.useCallback)(
+    (response) => {
+      responseRef.current = response;
+      setTimeout(() => {
+        setLangGraphInterruptAction({ event: { response } });
+      }, 0);
+    },
+    [setLangGraphInterruptAction]
+  );
+  if (!langGraphInterruptAction || !langGraphInterruptAction.event || !langGraphInterruptAction.render)
+    return null;
+  const { render, handler, event, enabled } = langGraphInterruptAction;
+  const conditionsMet = !agentSession || !enabled ? true : enabled({ eventValue: event.value, agentMetadata: agentSession });
+  if (!conditionsMet) {
+    return null;
+  }
+  let result = null;
+  if (handler) {
+    result = handler({
+      event,
+      resolve: resolveInterrupt
+    });
+  }
+  return import_react8.default.createElement(InterruptRenderer, {
+    event,
+    result,
+    render,
+    resolve: resolveInterrupt
+  });
+}
+
+// src/hooks/use-copilot-chat_internal.ts
+var globalSuggestionPromise = null;
+function useCopilotChat(options = {}) {
+  var _a;
+  const makeSystemMessage2 = (_a = options.makeSystemMessage) != null ? _a : defaultSystemMessage;
+  const {
+    getContextString,
+    getFunctionCallHandler,
+    copilotApiConfig,
+    isLoading,
+    setIsLoading,
+    chatInstructions,
+    actions,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
+    coAgentStateRenders,
+    agentSession,
+    setAgentSession,
+    forwardedParameters,
+    agentLock,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef,
+    extensions,
+    setExtensions,
+    langGraphInterruptAction,
+    setLangGraphInterruptAction,
+    chatSuggestionConfiguration,
+    runtimeClient
+  } = useCopilotContext();
+  const { messages, setMessages, suggestions, setSuggestions } = useCopilotMessagesContext();
+  const [mcpServers, setLocalMcpServers] = (0, import_react9.useState)([]);
+  const suggestionsAbortControllerRef = (0, import_react9.useRef)(null);
+  const isLoadingSuggestionsRef = (0, import_react9.useRef)(false);
+  const abortSuggestions = (0, import_react9.useCallback)(
+    (clear = true) => {
+      var _a2;
+      (_a2 = suggestionsAbortControllerRef.current) == null ? void 0 : _a2.abort("suggestions aborted by user");
+      suggestionsAbortControllerRef.current = null;
+      if (clear) {
+        setSuggestions([]);
+      }
+    },
+    [setSuggestions]
+  );
+  const stableContext = (0, import_react9.useMemo)(() => {
+    return {
+      actions,
+      copilotApiConfig,
+      chatSuggestionConfiguration,
+      messages,
+      setMessages,
+      getContextString,
+      runtimeClient
+    };
+  }, [
+    JSON.stringify(Object.keys(actions)),
+    copilotApiConfig.chatApiEndpoint,
+    messages.length,
+    Object.keys(chatSuggestionConfiguration).length
+  ]);
+  const generateSuggestionsFunc = (0, import_react9.useCallback)(() => __async(this, null, function* () {
+    if (globalSuggestionPromise) {
+      return globalSuggestionPromise;
+    }
+    globalSuggestionPromise = (() => __async(this, null, function* () {
+      try {
+        abortSuggestions();
+        isLoadingSuggestionsRef.current = true;
+        suggestionsAbortControllerRef.current = new AbortController();
+        setSuggestions([]);
+        yield reloadSuggestions(
+          stableContext,
+          chatSuggestionConfiguration,
+          setSuggestions,
+          suggestionsAbortControllerRef
+        );
+      } catch (error) {
+        throw error;
+      } finally {
+        isLoadingSuggestionsRef.current = false;
+        globalSuggestionPromise = null;
+      }
+    }))();
+    return globalSuggestionPromise;
+  }), [stableContext, chatSuggestionConfiguration, setSuggestions, abortSuggestions]);
+  const resetSuggestions = (0, import_react9.useCallback)(() => {
+    setSuggestions([]);
+  }, [setSuggestions]);
+  (0, import_react9.useEffect)(() => {
+    if (mcpServers.length > 0) {
+      const serversCopy = [...mcpServers];
+      copilotApiConfig.mcpServers = serversCopy;
+      if (!copilotApiConfig.properties) {
+        copilotApiConfig.properties = {};
+      }
+      copilotApiConfig.properties.mcpServers = serversCopy;
+    }
+  }, [mcpServers, copilotApiConfig]);
+  const setMcpServers = (0, import_react9.useCallback)((servers) => {
+    setLocalMcpServers(servers);
+  }, []);
+  const onCoAgentStateRender = useAsyncCallback(
+    (args) => __async(this, null, function* () {
+      var _a2;
+      const { name, nodeName, state } = args;
+      let action = Object.values(coAgentStateRenders).find(
+        (action2) => action2.name === name && action2.nodeName === nodeName
+      );
+      if (!action) {
+        action = Object.values(coAgentStateRenders).find(
+          (action2) => action2.name === name && !action2.nodeName
+        );
+      }
+      if (action) {
+        yield (_a2 = action.handler) == null ? void 0 : _a2.call(action, { state, nodeName });
+      }
+    }),
+    [coAgentStateRenders]
+  );
+  const makeSystemMessageCallback = (0, import_react9.useCallback)(() => {
+    const systemMessageMaker = makeSystemMessage2 || defaultSystemMessage;
+    const contextString = getContextString([], defaultCopilotContextCategories);
+    return new import_runtime_client_gql7.TextMessage({
+      content: systemMessageMaker(contextString, chatInstructions),
+      role: import_runtime_client_gql7.Role.System
+    });
+  }, [getContextString, makeSystemMessage2, chatInstructions]);
+  const deleteMessage = (0, import_react9.useCallback)(
+    (messageId) => {
+      setMessages((prev) => prev.filter((message) => message.id !== messageId));
+    },
+    [setMessages]
+  );
+  const { append, reload, stop, runChatCompletion } = useChat(__spreadProps(__spreadValues({}, options), {
+    actions: Object.values(actions),
+    copilotConfig: copilotApiConfig,
+    initialMessages: (0, import_runtime_client_gql7.aguiToGQL)(options.initialMessages || []),
+    onFunctionCall: getFunctionCallHandler(),
+    onCoAgentStateRender,
+    messages,
+    setMessages,
+    makeSystemMessageCallback,
+    isLoading,
+    setIsLoading,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
+    agentSession,
+    setAgentSession,
+    forwardedParameters,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef,
+    agentLock,
+    extensions,
+    setExtensions,
+    langGraphInterruptAction,
+    setLangGraphInterruptAction
+  }));
+  const latestAppend = useUpdatedRef(append);
+  const latestAppendFunc = useAsyncCallback(
+    (message, options2) => __async(this, null, function* () {
+      abortSuggestions(options2 == null ? void 0 : options2.clearSuggestions);
+      return yield latestAppend.current(message, options2);
+    }),
+    [latestAppend]
+  );
+  const latestSendMessageFunc = useAsyncCallback(
+    (message, options2) => __async(this, null, function* () {
+      abortSuggestions(options2 == null ? void 0 : options2.clearSuggestions);
+      return yield latestAppend.current((0, import_runtime_client_gql7.aguiToGQL)([message])[0], options2);
+    }),
+    [latestAppend]
+  );
+  const latestReload = useUpdatedRef(reload);
+  const latestReloadFunc = useAsyncCallback(
+    (messageId) => __async(this, null, function* () {
+      return yield latestReload.current(messageId);
+    }),
+    [latestReload]
+  );
+  const latestStop = useUpdatedRef(stop);
+  const latestStopFunc = (0, import_react9.useCallback)(() => {
+    return latestStop.current();
+  }, [latestStop]);
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = (0, import_react9.useCallback)(
+    (messageId) => {
+      return latestDelete.current(messageId);
+    },
+    [latestDelete]
+  );
+  const latestSetMessages = useUpdatedRef(setMessages);
+  const latestSetMessagesFunc = (0, import_react9.useCallback)(
+    (messages2) => {
+      if (messages2.every((message) => message instanceof import_runtime_client_gql7.Message)) {
+        return latestSetMessages.current(messages2);
+      }
+      return latestSetMessages.current((0, import_runtime_client_gql7.aguiToGQL)(messages2));
+    },
+    [latestSetMessages]
+  );
+  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
+  const latestRunChatCompletionFunc = useAsyncCallback(() => __async(this, null, function* () {
+    return yield latestRunChatCompletion.current();
+  }), [latestRunChatCompletion]);
+  const reset = (0, import_react9.useCallback)(() => {
+    latestStopFunc();
+    setMessages([]);
+    setRunId(null);
+    setCoagentStatesWithRef({});
+    let initialAgentSession = null;
+    if (agentLock) {
+      initialAgentSession = {
+        agentName: agentLock
+      };
+    }
+    setAgentSession(initialAgentSession);
+    resetSuggestions();
+  }, [
+    latestStopFunc,
+    setMessages,
+    setThreadId,
+    setCoagentStatesWithRef,
+    setAgentSession,
+    agentLock,
+    resetSuggestions
+  ]);
+  const latestReset = useUpdatedRef(reset);
+  const latestResetFunc = (0, import_react9.useCallback)(() => {
+    return latestReset.current();
+  }, [latestReset]);
+  const interrupt = useLangGraphInterruptRender();
+  return {
+    visibleMessages: messages,
+    messages: (0, import_runtime_client_gql7.gqlToAGUI)(messages, actions, coAgentStateRenders),
+    sendMessage: latestSendMessageFunc,
+    appendMessage: latestAppendFunc,
+    setMessages: latestSetMessagesFunc,
+    reloadMessages: latestReloadFunc,
+    stopGeneration: latestStopFunc,
+    reset: latestResetFunc,
+    deleteMessage: latestDeleteFunc,
+    runChatCompletion: latestRunChatCompletionFunc,
+    isLoading,
+    mcpServers,
+    setMcpServers,
+    suggestions,
+    setSuggestions,
+    generateSuggestions: generateSuggestionsFunc,
+    resetSuggestions,
+    isLoadingSuggestions: isLoadingSuggestionsRef.current,
+    interrupt
+  };
+}
+function useUpdatedRef(value) {
+  const ref = (0, import_react9.useRef)(value);
+  (0, import_react9.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+function defaultSystemMessage(contextString, additionalInstructions) {
+  return `
+Please act as an efficient, competent, conscientious, and industrious professional assistant.
+
+Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
+Always be polite and respectful, and prefer brevity over verbosity.
+
+The user has provided you with the following context:
+\`\`\`
+${contextString}
+\`\`\`
+
+They have also provided you with functions you can call to initiate actions on their behalf, or functions you can call to receive more information.
+
+Please assist them as best you can.
+
+You can ask them for clarifying questions if needed, but don't be annoying about it. If you can reasonably 'fill in the blanks' yourself, do so.
+
+If you would like to call a function, call it without saying anything else.
+In case of a function error:
+- If this error stems from incorrect function parameters or syntax, you may retry with corrected arguments.
+- If the error's source is unclear or seems unrelated to your input, do not attempt further retries.
+` + (additionalInstructions ? `
+
+${additionalInstructions}` : "");
+}
+
+// src/hooks/use-copilot-chat-headless_c.ts
+var import_shared8 = require("@copilotkit/shared");
+var createNonFunctionalReturn = () => ({
+  visibleMessages: [],
+  messages: [],
+  sendMessage: () => __async(void 0, null, function* () {
+  }),
+  appendMessage: () => __async(void 0, null, function* () {
+  }),
+  setMessages: () => {
+  },
+  deleteMessage: () => {
+  },
+  reloadMessages: () => __async(void 0, null, function* () {
+  }),
+  stopGeneration: () => {
+  },
+  reset: () => {
+  },
+  isLoading: false,
+  runChatCompletion: () => __async(void 0, null, function* () {
+    return [];
+  }),
+  mcpServers: [],
+  setMcpServers: () => {
+  },
+  suggestions: [],
+  setSuggestions: () => {
+  },
+  generateSuggestions: () => __async(void 0, null, function* () {
+  }),
+  resetSuggestions: () => {
+  },
+  isLoadingSuggestions: false,
+  interrupt: null
+});
+function useCopilotChatHeadless_c(options = {}) {
+  const { copilotApiConfig, setBannerError } = useCopilotContext();
+  const hasPublicApiKey = Boolean(copilotApiConfig.publicApiKey);
+  const internalResult = useCopilotChat(options);
+  (0, import_react10.useEffect)(() => {
+    if (!hasPublicApiKey) {
+      setBannerError(
+        new import_shared8.CopilotKitError({
+          message: (
+            // add link to documentation here
+            "You're using useCopilotChatHeadless_c, a subscription-only feature, which offers extensive headless chat capabilities. To continue, you'll need to provide a free subscription key."
+          ),
+          code: import_shared8.CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
+          severity: import_shared8.Severity.WARNING,
+          visibility: import_shared8.ErrorVisibility.BANNER
+        })
+      );
+      import_shared8.styledConsole.logCopilotKitPlatformMessage();
+    } else {
+      setBannerError(null);
+    }
+  }, [hasPublicApiKey]);
+  if (hasPublicApiKey) {
+    return internalResult;
+  }
+  return createNonFunctionalReturn();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultSystemMessage,
+  useCopilotChatHeadless_c
+});
+//# sourceMappingURL=use-copilot-chat-headless_c.js.map