@copilotkit/react-core 1.5.8 → 1.5.10-next.0

package/dist/index.js

@@ -0,0 +1,2224 @@
+"use strict";
+"use client";
+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 __restKey = (key) => typeof key === "symbol" ? key : key + "";
+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/index.tsx
+var src_exports = {};
+__export(src_exports, {
+  CopilotContext: () => CopilotContext,
+  CopilotKit: () => CopilotKit,
+  CopilotMessagesContext: () => CopilotMessagesContext,
+  CopilotTask: () => CopilotTask,
+  defaultCopilotContextCategories: () => defaultCopilotContextCategories,
+  extract: () => extract,
+  runAgent: () => runAgent,
+  shouldShowDevConsole: () => shouldShowDevConsole,
+  startAgent: () => startAgent,
+  stopAgent: () => stopAgent,
+  useCoAgent: () => useCoAgent,
+  useCoAgentStateRender: () => useCoAgentStateRender,
+  useCopilotAction: () => useCopilotAction,
+  useCopilotAuthenticatedAction: () => useCopilotAuthenticatedAction,
+  useCopilotChat: () => useCopilotChat,
+  useCopilotContext: () => useCopilotContext,
+  useCopilotMessagesContext: () => useCopilotMessagesContext,
+  useCopilotReadable: () => useCopilotReadable,
+  useCopilotRuntimeClient: () => useCopilotRuntimeClient,
+  useMakeCopilotDocumentReadable: () => useMakeCopilotDocumentReadable
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/components/copilot-provider/copilotkit.tsx
+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: () => {
+  },
+  getFunctionCallHandler: () => returnAndThrowInDebug(() => __async(void 0, null, function* () {
+  })),
+  isLoading: false,
+  setIsLoading: () => returnAndThrowInDebug(false),
+  chatInstructions: "",
+  setChatInstructions: () => 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: "auto",
+  coagentStates: {},
+  setCoagentStates: () => {
+  },
+  coagentStatesRef: { current: {} },
+  setCoagentStatesWithRef: () => {
+  },
+  agentSession: null,
+  setAgentSession: () => {
+  },
+  forwardedParameters: {},
+  agentLock: null,
+  threadId: null,
+  setThreadId: () => {
+  },
+  runId: null,
+  setRunId: () => {
+  },
+  chatAbortControllerRef: { current: null },
+  availableAgents: []
+};
+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-tree.ts
+var import_shared = require("@copilotkit/shared");
+var import_react2 = require("react");
+var removeNode = (nodes, id) => {
+  return nodes.reduce((result, node) => {
+    if (node.id !== id) {
+      const newNode = __spreadProps(__spreadValues({}, node), { children: removeNode(node.children, id) });
+      result.push(newNode);
+    }
+    return result;
+  }, []);
+};
+var addNode = (nodes, newNode, parentId) => {
+  if (!parentId) {
+    return [...nodes, newNode];
+  }
+  return nodes.map((node) => {
+    if (node.id === parentId) {
+      return __spreadProps(__spreadValues({}, node), { children: [...node.children, newNode] });
+    } else if (node.children.length) {
+      return __spreadProps(__spreadValues({}, node), { children: addNode(node.children, newNode, parentId) });
+    }
+    return node;
+  });
+};
+var treeIndentationRepresentation = (index, indentLevel) => {
+  if (indentLevel === 0) {
+    return (index + 1).toString();
+  } else if (indentLevel === 1) {
+    return String.fromCharCode(65 + index);
+  } else if (indentLevel === 2) {
+    return String.fromCharCode(97 + index);
+  } else {
+    return "-";
+  }
+};
+var printNode = (node, prefix = "", indentLevel = 0) => {
+  const indent = " ".repeat(3).repeat(indentLevel);
+  const prefixPlusIndentLength = prefix.length + indent.length;
+  const subsequentLinesPrefix = " ".repeat(prefixPlusIndentLength);
+  const valueLines = node.value.split("\n");
+  const outputFirstLine = `${indent}${prefix}${valueLines[0]}`;
+  const outputSubsequentLines = valueLines.slice(1).map((line) => `${subsequentLinesPrefix}${line}`).join("\n");
+  let output = `${outputFirstLine}
+`;
+  if (outputSubsequentLines) {
+    output += `${outputSubsequentLines}
+`;
+  }
+  const childPrePrefix = " ".repeat(prefix.length);
+  node.children.forEach(
+    (child, index) => output += printNode(
+      child,
+      `${childPrePrefix}${treeIndentationRepresentation(index, indentLevel + 1)}. `,
+      indentLevel + 1
+    )
+  );
+  return output;
+};
+function treeReducer(state, action) {
+  switch (action.type) {
+    case "ADD_NODE": {
+      const { value, parentId, id: newNodeId } = action;
+      const newNode = {
+        id: newNodeId,
+        value,
+        children: [],
+        categories: new Set(action.categories)
+      };
+      try {
+        return addNode(state, newNode, parentId);
+      } catch (error) {
+        console.error(`Error while adding node with id ${newNodeId}: ${error}`);
+        return state;
+      }
+    }
+    case "REMOVE_NODE":
+      return removeNode(state, action.id);
+    default:
+      return state;
+  }
+}
+var useTree = () => {
+  const [tree, dispatch] = (0, import_react2.useReducer)(treeReducer, []);
+  const addElement = (0, import_react2.useCallback)(
+    (value, categories, parentId) => {
+      const newNodeId = (0, import_shared.randomId)();
+      dispatch({
+        type: "ADD_NODE",
+        value,
+        parentId,
+        id: newNodeId,
+        categories
+      });
+      return newNodeId;
+    },
+    []
+  );
+  const removeElement = (0, import_react2.useCallback)((id) => {
+    dispatch({ type: "REMOVE_NODE", id });
+  }, []);
+  const printTree = (0, import_react2.useCallback)(
+    (categories) => {
+      const categoriesSet = new Set(categories);
+      let output = "";
+      tree.forEach((node, index) => {
+        if (!setsHaveIntersection(categoriesSet, node.categories)) {
+          return;
+        }
+        if (index !== 0) {
+          output += "\n";
+        }
+        output += printNode(node, `${treeIndentationRepresentation(index, 0)}. `);
+      });
+      return output;
+    },
+    [tree]
+  );
+  return { tree, addElement, printTree, removeElement };
+};
+var use_tree_default = useTree;
+function setsHaveIntersection(setA, setB) {
+  const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
+  for (let item of smallerSet) {
+    if (largerSet.has(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/components/copilot-provider/copilotkit.tsx
+var import_react_dom = require("react-dom");
+var import_shared4 = require("@copilotkit/shared");
+
+// src/hooks/use-flat-category-store.ts
+var import_react3 = require("react");
+var import_shared2 = require("@copilotkit/shared");
+var useFlatCategoryStore = () => {
+  const [elements, dispatch] = (0, import_react3.useReducer)(flatCategoryStoreReducer, /* @__PURE__ */ new Map());
+  const addElement = (0, import_react3.useCallback)((value, categories) => {
+    const newId = (0, import_shared2.randomId)();
+    dispatch({
+      type: "ADD_ELEMENT",
+      value,
+      id: newId,
+      categories
+    });
+    return newId;
+  }, []);
+  const removeElement = (0, import_react3.useCallback)((id) => {
+    dispatch({ type: "REMOVE_ELEMENT", id });
+  }, []);
+  const allElements = (0, import_react3.useCallback)(
+    (categories) => {
+      const categoriesSet = new Set(categories);
+      const result = [];
+      elements.forEach((element) => {
+        if (setsHaveIntersection2(categoriesSet, element.categories)) {
+          result.push(element.value);
+        }
+      });
+      return result;
+    },
+    [elements]
+  );
+  return { addElement, removeElement, allElements };
+};
+var use_flat_category_store_default = useFlatCategoryStore;
+function flatCategoryStoreReducer(state, action) {
+  switch (action.type) {
+    case "ADD_ELEMENT": {
+      const { value, id, categories } = action;
+      const newElement = {
+        id,
+        value,
+        categories: new Set(categories)
+      };
+      const newState = new Map(state);
+      newState.set(id, newElement);
+      return newState;
+    }
+    case "REMOVE_ELEMENT": {
+      const newState = new Map(state);
+      newState.delete(action.id);
+      return newState;
+    }
+    default:
+      return state;
+  }
+}
+function setsHaveIntersection2(setA, setB) {
+  const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
+  for (let item of smallerSet) {
+    if (largerSet.has(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/components/copilot-provider/copilot-messages.tsx
+var import_react5 = require("react");
+
+// src/context/copilot-messages-context.tsx
+var import_react4 = __toESM(require("react"));
+var emptyCopilotContext2 = {
+  messages: [],
+  setMessages: () => []
+};
+var CopilotMessagesContext = import_react4.default.createContext(emptyCopilotContext2);
+function useCopilotMessagesContext() {
+  const context = import_react4.default.useContext(CopilotMessagesContext);
+  if (context === emptyCopilotContext2) {
+    throw new Error(
+      "A messages consuming component was not wrapped with `<CopilotMessages> {...} </CopilotMessages>`"
+    );
+  }
+  return context;
+}
+
+// src/components/copilot-provider/copilot-messages.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function CopilotMessages(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const [messages, setMessages] = (0, import_react5.useState)([]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    CopilotMessagesContext.Provider,
+    {
+      value: {
+        messages,
+        setMessages
+      },
+      children
+    }
+  );
+}
+
+// src/components/toast/toast-provider.tsx
+var import_react7 = require("react");
+
+// src/components/error-boundary/error-utils.tsx
+var import_react6 = 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_jsx_runtime3 = require("react/jsx-runtime");
+function ErrorToast({ errors }) {
+  const errorsToRender = errors.map((error, idx) => {
+    var _a, _b, _c;
+    const message = "extensions" in error ? (_b = (_a = error.extensions) == null ? void 0 : _a.originalError) == null ? void 0 : _b.message : 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 Cloud Error:",
+                " ",
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { fontFamily: "monospace", fontWeight: "normal" }, children: code })
+              ]
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { 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_react6.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_react6.useCallback)((...args) => __async(this, null, function* () {
+    try {
+      return yield callback(...args);
+    } catch (error) {
+      console.error("Error in async callback:", error);
+      addErrorToast([error]);
+      throw error;
+    }
+  }), deps);
+}
+
+// src/components/toast/toast-provider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var ToastContext = (0, import_react7.createContext)(void 0);
+function useToast() {
+  const context = (0, import_react7.useContext)(ToastContext);
+  if (!context) {
+    throw new Error("useToast must be used within a ToastProvider");
+  }
+  return context;
+}
+function ToastProvider({
+  enabled,
+  children
+}) {
+  const [toasts, setToasts] = (0, import_react7.useState)([]);
+  const addToast = (0, import_react7.useCallback)((toast) => {
+    var _a;
+    const id = (_a = toast.id) != null ? _a : Math.random().toString(36).substring(2, 9);
+    setToasts((currentToasts) => {
+      if (currentToasts.find((toast2) => toast2.id === id))
+        return currentToasts;
+      return [...currentToasts, __spreadProps(__spreadValues({}, toast), { id })];
+    });
+    if (toast.duration) {
+      setTimeout(() => {
+        removeToast(id);
+      }, toast.duration);
+    }
+  }, []);
+  const addGraphQLErrorsToast = (0, import_react7.useCallback)((errors) => {
+    addToast({
+      type: "error",
+      message: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ErrorToast, { errors })
+    });
+  }, []);
+  const removeToast = (0, import_react7.useCallback)((id) => {
+    setToasts((currentToasts) => currentToasts.filter((toast) => toast.id !== id));
+  }, []);
+  const value = {
+    toasts,
+    addToast,
+    addGraphQLErrorsToast,
+    removeToast,
+    enabled
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(ToastContext.Provider, { value, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          bottom: "1rem",
+          left: "50%",
+          transform: "translateX(-50%)",
+          zIndex: 50,
+          display: "flex",
+          flexDirection: "column",
+          gap: "0.5rem"
+        },
+        children: [
+          toasts.length > 1 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { textAlign: "right" }, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "button",
+            {
+              onClick: () => setToasts([]),
+              style: {
+                padding: "4px 8px",
+                fontSize: "12px",
+                cursor: "pointer",
+                background: "white",
+                border: "1px solid rgba(0,0,0,0.2)",
+                borderRadius: "4px"
+              },
+              children: "Close All"
+            }
+          ) }),
+          toasts.map((toast) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            Toast,
+            {
+              message: toast.message,
+              type: toast.type,
+              onClose: () => removeToast(toast.id)
+            },
+            toast.id
+          ))
+        ]
+      }
+    ),
+    children
+  ] });
+}
+function Toast({
+  message,
+  type = "info",
+  onClose
+}) {
+  const bgColors = {
+    info: "#3b82f6",
+    success: "#22c55e",
+    warning: "#eab308",
+    error: "#ef4444"
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    "div",
+    {
+      style: {
+        backgroundColor: bgColors[type],
+        color: "white",
+        padding: "0.5rem 1.5rem",
+        borderRadius: "0.25rem",
+        boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+        position: "relative",
+        minWidth: "200px"
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: message }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "button",
+          {
+            onClick: onClose,
+            style: {
+              position: "absolute",
+              top: "0",
+              right: "0",
+              background: "none",
+              border: "none",
+              color: "white",
+              cursor: "pointer",
+              padding: "0.5rem",
+              fontSize: "1rem"
+            },
+            children: "\u2715"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/hooks/use-copilot-runtime-client.ts
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
+var import_react8 = require("react");
+var useCopilotRuntimeClient = (options) => {
+  const { addGraphQLErrorsToast } = useToast();
+  const addErrorToast = useErrorToast();
+  const runtimeClient = (0, import_react8.useMemo)(() => {
+    return new import_runtime_client_gql.CopilotRuntimeClient(__spreadProps(__spreadValues({}, options), {
+      handleGQLErrors: (error) => {
+        if (error.graphQLErrors.length) {
+          addGraphQLErrorsToast(error.graphQLErrors);
+        } else {
+          addErrorToast([error]);
+        }
+      }
+    }));
+  }, [options, addGraphQLErrorsToast]);
+  return runtimeClient;
+};
+
+// src/utils/extract.ts
+var import_shared3 = require("@copilotkit/shared");
+var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
+function extract(_0) {
+  return __async(this, arguments, function* ({
+    context,
+    instructions,
+    parameters,
+    include,
+    data,
+    abortSignal,
+    stream,
+    requestType = import_runtime_client_gql2.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_gql2.TextMessage({
+      content: makeSystemMessage(contextString, instructions),
+      role: import_runtime_client_gql2.Role.System
+    });
+    const instructionsMessage = new import_runtime_client_gql2.TextMessage({
+      content: makeInstructionsMessage(instructions),
+      role: import_runtime_client_gql2.Role.User
+    });
+    const response = context.runtimeClient.asStream(
+      context.runtimeClient.generateCopilotResponse({
+        data: {
+          frontend: {
+            actions: [
+              {
+                name: action.name,
+                description: action.description || "",
+                jsonSchema: JSON.stringify((0, import_shared3.actionParametersToJsonSchema)(action.parameters || []))
+              }
+            ],
+            url: window.location.href
+          },
+          messages: (0, import_runtime_client_gql3.convertMessagesToGqlInput)(
+            includeMessages ? [systemMessage, instructionsMessage, ...(0, import_runtime_client_gql3.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_gql2.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/dev-console.ts
+function shouldShowDevConsole(showDevConsole) {
+  if (typeof showDevConsole === "boolean") {
+    return showDevConsole;
+  }
+  return getHostname() === "localhost" || getHostname() === "127.0.0.1" || getHostname() === "0.0.0.0" || getHostname() === "::1";
+}
+function getHostname() {
+  if (typeof window !== "undefined" && window.location) {
+    return window.location.hostname;
+  }
+  return "";
+}
+
+// src/components/error-boundary/error-boundary.tsx
+var import_react9 = __toESM(require("react"));
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var CopilotErrorBoundary = class extends import_react9.default.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("CopilotKit Error:", error, errorInfo);
+  }
+  render() {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ErrorToast2, { error: this.state.error, children: this.props.children });
+  }
+};
+function ErrorToast2({ error, children }) {
+  const addErrorToast = useErrorToast();
+  (0, import_react9.useEffect)(() => {
+    if (error) {
+      addErrorToast([error]);
+    }
+  }, [error, addErrorToast]);
+  return children;
+}
+
+// src/components/copilot-provider/copilotkit.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function CopilotKit(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const showDevConsole = props.showDevConsole === void 0 ? "auto" : props.showDevConsole;
+  const enabled = shouldShowDevConsole(showDevConsole);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ToastProvider, { enabled, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CopilotErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CopilotKitInternal, __spreadProps(__spreadValues({}, props), { children })) }) });
+}
+function CopilotKitInternal(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  if (!props.runtimeUrl && !props.publicApiKey) {
+    throw new Error(
+      "Please provide either a runtimeUrl or a publicApiKey to the CopilotKit component."
+    );
+  }
+  const chatApiEndpoint = props.runtimeUrl || import_shared4.COPILOT_CLOUD_CHAT_URL;
+  const [actions, setActions] = (0, import_react10.useState)({});
+  const [coAgentStateRenders, setCoAgentStateRenders] = (0, import_react10.useState)({});
+  const chatComponentsCache = (0, import_react10.useRef)({
+    actions: {},
+    coAgentStateRenders: {}
+  });
+  const { addElement, removeElement, printTree } = use_tree_default();
+  const [isLoading, setIsLoading] = (0, import_react10.useState)(false);
+  const [chatInstructions, setChatInstructions] = (0, import_react10.useState)("");
+  const [authStates, setAuthStates] = (0, import_react10.useState)({});
+  const {
+    addElement: addDocument,
+    removeElement: removeDocument,
+    allElements: allDocuments
+  } = use_flat_category_store_default();
+  const setAction = (0, import_react10.useCallback)((id, action) => {
+    setActions((prevPoints) => {
+      return __spreadProps(__spreadValues({}, prevPoints), {
+        [id]: action
+      });
+    });
+  }, []);
+  const removeAction = (0, import_react10.useCallback)((id) => {
+    setActions((prevPoints) => {
+      const newPoints = __spreadValues({}, prevPoints);
+      delete newPoints[id];
+      return newPoints;
+    });
+  }, []);
+  const setCoAgentStateRender = (0, import_react10.useCallback)((id, stateRender) => {
+    setCoAgentStateRenders((prevPoints) => {
+      return __spreadProps(__spreadValues({}, prevPoints), {
+        [id]: stateRender
+      });
+    });
+  }, []);
+  const removeCoAgentStateRender = (0, import_react10.useCallback)((id) => {
+    setCoAgentStateRenders((prevPoints) => {
+      const newPoints = __spreadValues({}, prevPoints);
+      delete newPoints[id];
+      return newPoints;
+    });
+  }, []);
+  const getContextString = (0, import_react10.useCallback)(
+    (documents, categories) => {
+      const documentsString = documents.map((document) => {
+        return `${document.name} (${document.sourceApplication}):
+${document.getContents()}`;
+      }).join("\n\n");
+      const nonDocumentStrings = printTree(categories);
+      return `${documentsString}
+
+${nonDocumentStrings}`;
+    },
+    [printTree]
+  );
+  const addContext = (0, import_react10.useCallback)(
+    (context, parentId, categories = defaultCopilotContextCategories) => {
+      return addElement(context, categories, parentId);
+    },
+    [addElement]
+  );
+  const removeContext = (0, import_react10.useCallback)(
+    (id) => {
+      removeElement(id);
+    },
+    [removeElement]
+  );
+  const getFunctionCallHandler = (0, import_react10.useCallback)(
+    (customEntryPoints) => {
+      return entryPointsToFunctionCallHandler(Object.values(customEntryPoints || actions));
+    },
+    [actions]
+  );
+  const getDocumentsContext = (0, import_react10.useCallback)(
+    (categories) => {
+      return allDocuments(categories);
+    },
+    [allDocuments]
+  );
+  const addDocumentContext = (0, import_react10.useCallback)(
+    (documentPointer, categories = defaultCopilotContextCategories) => {
+      return addDocument(documentPointer, categories);
+    },
+    [addDocument]
+  );
+  const removeDocumentContext = (0, import_react10.useCallback)(
+    (documentId) => {
+      removeDocument(documentId);
+    },
+    [removeDocument]
+  );
+  if (!props.publicApiKey) {
+    if (props.cloudRestrictToTopic) {
+      throw new Error(
+        "To use the cloudRestrictToTopic feature, please sign up at https://copilotkit.ai and provide a publicApiKey."
+      );
+    }
+  }
+  const copilotApiConfig = (0, import_react10.useMemo)(() => {
+    var _a2, _b2;
+    let cloud = void 0;
+    if (props.publicApiKey) {
+      cloud = {
+        guardrails: {
+          input: {
+            restrictToTopic: {
+              enabled: props.cloudRestrictToTopic ? true : false,
+              validTopics: ((_a2 = props.cloudRestrictToTopic) == null ? void 0 : _a2.validTopics) || [],
+              invalidTopics: ((_b2 = props.cloudRestrictToTopic) == null ? void 0 : _b2.invalidTopics) || []
+            }
+          }
+        }
+      };
+    }
+    return __spreadProps(__spreadValues({
+      publicApiKey: props.publicApiKey
+    }, cloud ? { cloud } : {}), {
+      chatApiEndpoint,
+      headers: props.headers || {},
+      properties: props.properties || {},
+      transcribeAudioUrl: props.transcribeAudioUrl,
+      textToSpeechUrl: props.textToSpeechUrl,
+      credentials: props.credentials
+    });
+  }, [
+    props.publicApiKey,
+    props.headers,
+    props.properties,
+    props.transcribeAudioUrl,
+    props.textToSpeechUrl,
+    props.credentials,
+    props.cloudRestrictToTopic
+  ]);
+  const headers = (0, import_react10.useMemo)(() => {
+    const authHeaders = Object.values(authStates || {}).reduce((acc, state) => {
+      if (state.status === "authenticated" && state.authHeaders) {
+        return __spreadValues(__spreadValues({}, acc), Object.entries(state.authHeaders).reduce(
+          (headers2, [key, value]) => __spreadProps(__spreadValues({}, headers2), {
+            [key.startsWith("X-Custom-") ? key : `X-Custom-${key}`]: value
+          }),
+          {}
+        ));
+      }
+      return acc;
+    }, {});
+    return __spreadValues(__spreadValues(__spreadValues({}, copilotApiConfig.headers || {}), copilotApiConfig.publicApiKey ? { [import_shared4.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: copilotApiConfig.publicApiKey } : {}), authHeaders);
+  }, [copilotApiConfig.headers, copilotApiConfig.publicApiKey, authStates]);
+  const runtimeClient = useCopilotRuntimeClient({
+    url: copilotApiConfig.chatApiEndpoint,
+    publicApiKey: copilotApiConfig.publicApiKey,
+    headers,
+    credentials: copilotApiConfig.credentials
+  });
+  const [chatSuggestionConfiguration, setChatSuggestionConfiguration] = (0, import_react10.useState)({});
+  const addChatSuggestionConfiguration = (id, suggestion) => {
+    setChatSuggestionConfiguration((prev) => __spreadProps(__spreadValues({}, prev), { [id]: suggestion }));
+  };
+  const removeChatSuggestionConfiguration = (id) => {
+    setChatSuggestionConfiguration((prev) => {
+      const _a2 = prev, { [id]: _ } = _a2, rest = __objRest(_a2, [__restKey(id)]);
+      return rest;
+    });
+  };
+  const [availableAgents, setAvailableAgents] = (0, import_react10.useState)([]);
+  const [coagentStates, setCoagentStates] = (0, import_react10.useState)({});
+  const coagentStatesRef = (0, import_react10.useRef)({});
+  const setCoagentStatesWithRef = (0, import_react10.useCallback)(
+    (value) => {
+      const newValue = typeof value === "function" ? value(coagentStatesRef.current) : value;
+      coagentStatesRef.current = newValue;
+      setCoagentStates((prev) => {
+        return newValue;
+      });
+    },
+    []
+  );
+  (0, import_react10.useEffect)(() => {
+    const fetchData = () => __async(this, null, function* () {
+      var _a2;
+      const result = yield runtimeClient.availableAgents();
+      if ((_a2 = result.data) == null ? void 0 : _a2.availableAgents) {
+        setAvailableAgents(result.data.availableAgents.agents);
+      }
+    });
+    void fetchData();
+  }, []);
+  let initialAgentSession = null;
+  if (props.agent) {
+    initialAgentSession = {
+      agentName: props.agent
+    };
+  }
+  const [agentSession, setAgentSession] = (0, import_react10.useState)(initialAgentSession);
+  const [threadId, setThreadId] = (0, import_react10.useState)(null);
+  const [runId, setRunId] = (0, import_react10.useState)(null);
+  const chatAbortControllerRef = (0, import_react10.useRef)(null);
+  const showDevConsole = props.showDevConsole === void 0 ? "auto" : props.showDevConsole;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    CopilotContext.Provider,
+    {
+      value: {
+        actions,
+        chatComponentsCache,
+        getFunctionCallHandler,
+        setAction,
+        removeAction,
+        coAgentStateRenders,
+        setCoAgentStateRender,
+        removeCoAgentStateRender,
+        getContextString,
+        addContext,
+        removeContext,
+        getDocumentsContext,
+        addDocumentContext,
+        removeDocumentContext,
+        copilotApiConfig,
+        isLoading,
+        setIsLoading,
+        chatSuggestionConfiguration,
+        addChatSuggestionConfiguration,
+        removeChatSuggestionConfiguration,
+        chatInstructions,
+        setChatInstructions,
+        showDevConsole,
+        coagentStates,
+        setCoagentStates,
+        coagentStatesRef,
+        setCoagentStatesWithRef,
+        agentSession,
+        setAgentSession,
+        runtimeClient,
+        forwardedParameters: props.forwardedParameters || {},
+        agentLock: props.agent || null,
+        threadId,
+        setThreadId,
+        runId,
+        setRunId,
+        chatAbortControllerRef,
+        availableAgents,
+        authConfig: props.authConfig,
+        authStates,
+        setAuthStates
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CopilotMessages, { children })
+    }
+  );
+}
+var defaultCopilotContextCategories = ["global"];
+function entryPointsToFunctionCallHandler(actions) {
+  return (_0) => __async(this, [_0], function* ({ messages, name, args }) {
+    let actionsByFunctionName = {};
+    for (let action2 of actions) {
+      actionsByFunctionName[action2.name] = action2;
+    }
+    const action = actionsByFunctionName[name];
+    let result = void 0;
+    if (action) {
+      yield new Promise((resolve, reject) => {
+        (0, import_react_dom.flushSync)(() => __async(this, null, function* () {
+          var _a;
+          try {
+            result = yield (_a = action.handler) == null ? void 0 : _a.call(action, args);
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        }));
+      });
+      yield new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    return result;
+  });
+}
+
+// src/hooks/use-copilot-chat.ts
+var import_react12 = require("react");
+var import_runtime_client_gql6 = require("@copilotkit/runtime-client-gql");
+
+// src/hooks/use-chat.ts
+var import_react11 = require("react");
+var import_shared6 = require("@copilotkit/shared");
+var import_runtime_client_gql5 = require("@copilotkit/runtime-client-gql");
+
+// src/types/frontend-action.ts
+var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
+var import_shared5 = require("@copilotkit/shared");
+function processActionsForRuntimeRequest(actions) {
+  const filteredActions = actions.filter(
+    (action) => action.available !== import_runtime_client_gql4.ActionInputAvailability.Disabled && action.disabled !== true && action.name !== "*"
+  ).map((action) => {
+    let available = import_runtime_client_gql4.ActionInputAvailability.Enabled;
+    if (action.disabled) {
+      available = import_runtime_client_gql4.ActionInputAvailability.Disabled;
+    } else if (action.available === "disabled") {
+      available = import_runtime_client_gql4.ActionInputAvailability.Disabled;
+    } else if (action.available === "remote") {
+      available = import_runtime_client_gql4.ActionInputAvailability.Remote;
+    }
+    return {
+      name: action.name,
+      description: action.description || "",
+      jsonSchema: JSON.stringify((0, import_shared5.actionParametersToJsonSchema)(action.parameters || [])),
+      available
+    };
+  });
+  return filteredActions;
+}
+
+// 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
+  } = options;
+  const runChatCompletionRef = (0, import_react11.useRef)();
+  const agentSessionRef = (0, import_react11.useRef)(agentSession);
+  agentSessionRef.current = agentSession;
+  const threadIdRef = (0, import_react11.useRef)(threadId);
+  threadIdRef.current = threadId;
+  const runIdRef = (0, import_react11.useRef)(runId);
+  runIdRef.current = runId;
+  const publicApiKey = copilotConfig.publicApiKey;
+  const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared6.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
+  const runtimeClient = useCopilotRuntimeClient({
+    url: copilotConfig.chatApiEndpoint,
+    publicApiKey: copilotConfig.publicApiKey,
+    headers,
+    credentials: copilotConfig.credentials
+  });
+  const runChatCompletion = useAsyncCallback(
+    (previousMessages) => __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      setIsLoading(true);
+      let newMessages = [
+        new import_runtime_client_gql5.TextMessage({
+          content: "",
+          role: import_runtime_client_gql5.Role.Assistant
+        })
+      ];
+      chatAbortControllerRef.current = new AbortController();
+      setMessages([...previousMessages, ...newMessages]);
+      const systemMessage = makeSystemMessageCallback();
+      const messagesWithContext = [systemMessage, ...initialMessages || [], ...previousMessages];
+      const isAgentRun = agentSessionRef.current !== null;
+      const stream = runtimeClient.asStream(
+        runtimeClient.generateCopilotResponse({
+          data: __spreadProps(__spreadValues(__spreadProps(__spreadValues({
+            frontend: {
+              actions: processActionsForRuntimeRequest(actions),
+              url: window.location.href
+            },
+            threadId: threadIdRef.current,
+            runId: runIdRef.current,
+            messages: (0, import_runtime_client_gql5.convertMessagesToGqlInput)((0, import_runtime_client_gql5.filterAgentStateMessages)(messagesWithContext))
+          }, copilotConfig.cloud ? {
+            cloud: __spreadValues({}, ((_c = (_b = (_a = copilotConfig.cloud.guardrails) == null ? void 0 : _a.input) == null ? void 0 : _b.restrictToTopic) == null ? void 0 : _c.enabled) ? {
+              guardrails: {
+                inputValidationRules: {
+                  allowList: copilotConfig.cloud.guardrails.input.restrictToTopic.validTopics,
+                  denyList: copilotConfig.cloud.guardrails.input.restrictToTopic.invalidTopics
+                }
+              }
+            } : {})
+          } : {}), {
+            metadata: {
+              requestType: import_runtime_client_gql5.CopilotRequestType.Chat
+            }
+          }), agentSessionRef.current ? {
+            agentSession: agentSessionRef.current
+          } : {}), {
+            agentStates: Object.values(coagentStatesRef.current).map((state) => ({
+              agentName: state.name,
+              state: JSON.stringify(state.state)
+            })),
+            forwardedParameters: options.forwardedParameters || {}
+          }),
+          properties: copilotConfig.properties,
+          signal: (_d = chatAbortControllerRef.current) == null ? void 0 : _d.signal
+        })
+      );
+      const guardrailsEnabled = ((_g = (_f = (_e = copilotConfig.cloud) == null ? void 0 : _e.guardrails) == null ? void 0 : _f.input) == null ? void 0 : _g.restrictToTopic.enabled) || false;
+      const reader = stream.getReader();
+      let executedCoAgentStateRenders = [];
+      let followUp = void 0;
+      let messages2 = [];
+      let syncedMessages = [];
+      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;
+          }
+          threadIdRef.current = value.generateCopilotResponse.threadId || null;
+          runIdRef.current = value.generateCopilotResponse.runId || null;
+          setThreadId(threadIdRef.current);
+          setRunId(runIdRef.current);
+          messages2 = (0, import_runtime_client_gql5.convertGqlOutputToMessages)(
+            (0, import_runtime_client_gql5.filterAdjacentAgentStateMessages)(value.generateCopilotResponse.messages)
+          );
+          if (messages2.length === 0) {
+            continue;
+          }
+          newMessages = [];
+          if (((_h = value.generateCopilotResponse.status) == null ? void 0 : _h.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
+            newMessages = [
+              new import_runtime_client_gql5.TextMessage({
+                role: import_runtime_client_gql5.MessageRole.Assistant,
+                content: ((_i = value.generateCopilotResponse.status.details) == null ? void 0 : _i.guardrailsReason) || ""
+              })
+            ];
+            setMessages([...previousMessages, ...newMessages]);
+            break;
+          } else {
+            newMessages = [...messages2];
+            for (const message of messages2) {
+              if (message.isAgentStateMessage() && !message.active && !executedCoAgentStateRenders.includes(message.id) && onCoAgentStateRender) {
+                if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
+                  break;
+                }
+                yield onCoAgentStateRender({
+                  name: message.agentName,
+                  nodeName: message.nodeName,
+                  state: message.state
+                });
+                executedCoAgentStateRenders.push(message.id);
+              }
+            }
+            const lastAgentStateMessage = [...messages2].reverse().find((message) => message.isAgentStateMessage());
+            if (lastAgentStateMessage) {
+              if (lastAgentStateMessage.state.messages && lastAgentStateMessage.state.messages.length > 0) {
+                syncedMessages = (0, import_runtime_client_gql5.loadMessagesFromJsonRepresentation)(
+                  lastAgentStateMessage.state.messages
+                );
+              }
+              setCoagentStatesWithRef((prevAgentStates) => __spreadProps(__spreadValues({}, prevAgentStates), {
+                [lastAgentStateMessage.agentName]: {
+                  name: lastAgentStateMessage.agentName,
+                  state: lastAgentStateMessage.state,
+                  running: lastAgentStateMessage.running,
+                  active: lastAgentStateMessage.active,
+                  threadId: lastAgentStateMessage.threadId,
+                  nodeName: lastAgentStateMessage.nodeName,
+                  runId: lastAgentStateMessage.runId
+                }
+              }));
+              if (lastAgentStateMessage.running) {
+                setAgentSession({
+                  threadId: lastAgentStateMessage.threadId,
+                  agentName: lastAgentStateMessage.agentName,
+                  nodeName: lastAgentStateMessage.nodeName
+                });
+              } else {
+                if (agentLock) {
+                  setAgentSession({
+                    threadId: (0, import_shared6.randomId)(),
+                    agentName: agentLock,
+                    nodeName: void 0
+                  });
+                } else {
+                  setAgentSession(null);
+                }
+              }
+            }
+          }
+          if (newMessages.length > 0) {
+            setMessages([...previousMessages, ...newMessages]);
+          }
+        }
+        const finalMessages = constructFinalMessages(syncedMessages, previousMessages, newMessages);
+        let didExecuteAction = false;
+        if (onFunctionCall) {
+          const lastMessages = [];
+          for (let i = finalMessages.length - 1; i >= 0; i--) {
+            const message = finalMessages[i];
+            if (message.isActionExecutionMessage() && message.status.code !== import_runtime_client_gql5.MessageStatusCode.Pending) {
+              lastMessages.unshift(message);
+            } else {
+              break;
+            }
+          }
+          for (const message of lastMessages) {
+            setMessages(finalMessages);
+            const action = actions.find((action2) => action2.name === message.name);
+            if (action) {
+              followUp = action.followUp;
+              let result;
+              try {
+                result = yield Promise.race([
+                  onFunctionCall({
+                    messages: previousMessages,
+                    name: message.name,
+                    args: message.arguments
+                  }),
+                  new Promise(
+                    (resolve) => {
+                      var _a2;
+                      return (_a2 = chatAbortControllerRef.current) == null ? void 0 : _a2.signal.addEventListener(
+                        "abort",
+                        () => resolve("Operation was aborted by the user")
+                      );
+                    }
+                  ),
+                  // if the user stopped generation, we also abort consecutive actions
+                  new Promise((resolve) => {
+                    var _a2;
+                    if ((_a2 = chatAbortControllerRef.current) == null ? void 0 : _a2.signal.aborted) {
+                      resolve("Operation was aborted by the user");
+                    }
+                  })
+                ]);
+              } catch (e) {
+                result = `Failed to execute action ${message.name}`;
+                console.error(`Failed to execute action ${message.name}: ${e}`);
+              }
+              didExecuteAction = true;
+              const messageIndex = finalMessages.findIndex((msg) => msg.id === message.id);
+              finalMessages.splice(
+                messageIndex + 1,
+                0,
+                new import_runtime_client_gql5.ResultMessage({
+                  id: "result-" + message.id,
+                  result: import_runtime_client_gql5.ResultMessage.encodeResult(result),
+                  actionExecutionId: message.id,
+                  actionName: message.name
+                })
+              );
+            }
+          }
+          setMessages(finalMessages);
+        }
+        if (
+          // if followUp is not explicitly false
+          followUp !== false && // and we executed an action
+          (didExecuteAction || // the last message is a server side result
+          !isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
+          !((_j = chatAbortControllerRef.current) == null ? void 0 : _j.signal.aborted)
+        ) {
+          yield new Promise((resolve) => setTimeout(resolve, 10));
+          return yield runChatCompletionRef.current(finalMessages);
+        } else if ((_k = chatAbortControllerRef.current) == null ? void 0 : _k.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 ((_l = agentSessionRef.current) == null ? void 0 : _l.nodeName) {
+            setAgentSession({
+              threadId: agentSessionRef.current.threadId,
+              agentName: agentSessionRef.current.agentName,
+              nodeName: "__end__"
+            });
+          }
+          return newMessages.filter((message) => repairedMessageIds.includes(message.id));
+        } else {
+          return newMessages.slice();
+        }
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [
+      messages,
+      setMessages,
+      makeSystemMessageCallback,
+      copilotConfig,
+      setIsLoading,
+      initialMessages,
+      isLoading,
+      actions,
+      onFunctionCall,
+      onCoAgentStateRender,
+      setCoagentStatesWithRef,
+      coagentStatesRef,
+      agentSession,
+      setAgentSession
+    ]
+  );
+  runChatCompletionRef.current = runChatCompletion;
+  const runChatCompletionAndHandleFunctionCall = useAsyncCallback(
+    (messages2) => __async(this, null, function* () {
+      yield runChatCompletionRef.current(messages2);
+    }),
+    [messages]
+  );
+  const append = useAsyncCallback(
+    (message) => __async(this, null, function* () {
+      if (isLoading) {
+        return;
+      }
+      const newMessages = [...messages, message];
+      setMessages(newMessages);
+      return runChatCompletionAndHandleFunctionCall(newMessages);
+    }),
+    [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
+  );
+  const reload = useAsyncCallback(() => __async(this, null, function* () {
+    if (isLoading || messages.length === 0) {
+      return;
+    }
+    let newMessages = [...messages];
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage.isTextMessage() && lastMessage.role === "assistant") {
+      newMessages = newMessages.slice(0, -1);
+    }
+    setMessages(newMessages);
+    return runChatCompletionAndHandleFunctionCall(newMessages);
+  }), [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]);
+  const stop = () => {
+    var _a;
+    (_a = chatAbortControllerRef.current) == null ? void 0 : _a.abort("Stop was called");
+  };
+  return {
+    append,
+    reload,
+    stop,
+    runChatCompletion: () => runChatCompletionRef.current(messages)
+  };
+}
+function constructFinalMessages(syncedMessages, previousMessages, newMessages) {
+  const finalMessages = syncedMessages.length > 0 ? [...syncedMessages] : [...previousMessages, ...newMessages];
+  if (syncedMessages.length > 0) {
+    const messagesWithAgentState = [...previousMessages, ...newMessages];
+    let previousMessageId = void 0;
+    for (const message of messagesWithAgentState) {
+      if (message.isAgentStateMessage()) {
+        const index = finalMessages.findIndex((msg) => msg.id === previousMessageId);
+        if (index !== -1) {
+          finalMessages.splice(index + 1, 0, message);
+        }
+      }
+      previousMessageId = message.id;
+    }
+  }
+  return finalMessages;
+}
+
+// src/hooks/use-copilot-chat.ts
+function useCopilotChat(_a = {}) {
+  var _b = _a, {
+    makeSystemMessage: makeSystemMessage2
+  } = _b, options = __objRest(_b, [
+    "makeSystemMessage"
+  ]);
+  const {
+    getContextString,
+    getFunctionCallHandler,
+    copilotApiConfig,
+    isLoading,
+    setIsLoading,
+    chatInstructions,
+    actions,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
+    coAgentStateRenders,
+    agentSession,
+    setAgentSession,
+    forwardedParameters,
+    agentLock,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef
+  } = useCopilotContext();
+  const { messages, setMessages } = useCopilotMessagesContext();
+  const latestGetContextString = useUpdatedRef(getContextString);
+  const deleteMessage = (0, import_react12.useCallback)(
+    (messageId) => {
+      setMessages((prev) => prev.filter((message) => message.id !== messageId));
+    },
+    [setMessages]
+  );
+  const makeSystemMessageCallback = (0, import_react12.useCallback)(() => {
+    const systemMessageMaker = makeSystemMessage2 || defaultSystemMessage;
+    const contextString = latestGetContextString.current([], defaultCopilotContextCategories);
+    return new import_runtime_client_gql6.TextMessage({
+      content: systemMessageMaker(contextString, chatInstructions),
+      role: import_runtime_client_gql6.Role.System
+    });
+  }, [getContextString, makeSystemMessage2, chatInstructions]);
+  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 { append, reload, stop, runChatCompletion } = useChat(__spreadProps(__spreadValues({}, options), {
+    actions: Object.values(actions),
+    copilotConfig: copilotApiConfig,
+    initialMessages: options.initialMessages || [],
+    onFunctionCall: getFunctionCallHandler(),
+    onCoAgentStateRender,
+    messages,
+    setMessages,
+    makeSystemMessageCallback,
+    isLoading,
+    setIsLoading,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
+    agentSession,
+    setAgentSession,
+    forwardedParameters,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef,
+    agentLock
+  }));
+  const latestAppend = useUpdatedRef(append);
+  const latestAppendFunc = useAsyncCallback(
+    (message) => __async(this, null, function* () {
+      return yield latestAppend.current(message);
+    }),
+    [latestAppend]
+  );
+  const latestReload = useUpdatedRef(reload);
+  const latestReloadFunc = useAsyncCallback(() => __async(this, null, function* () {
+    return yield latestReload.current();
+  }), [latestReload]);
+  const latestStop = useUpdatedRef(stop);
+  const latestStopFunc = (0, import_react12.useCallback)(() => {
+    return latestStop.current();
+  }, [latestStop]);
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = (0, import_react12.useCallback)(
+    (messageId) => {
+      return latestDelete.current(messageId);
+    },
+    [latestDelete]
+  );
+  const latestSetMessages = useUpdatedRef(setMessages);
+  const latestSetMessagesFunc = (0, import_react12.useCallback)(
+    (messages2) => {
+      return latestSetMessages.current(messages2);
+    },
+    [latestSetMessages]
+  );
+  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
+  const latestRunChatCompletionFunc = useAsyncCallback(() => __async(this, null, function* () {
+    return yield latestRunChatCompletion.current();
+  }), [latestRunChatCompletion]);
+  const reset = (0, import_react12.useCallback)(() => {
+    latestStopFunc();
+    setMessages([]);
+    setThreadId(null);
+    setRunId(null);
+    setCoagentStatesWithRef({});
+    let initialAgentSession = null;
+    if (agentLock) {
+      initialAgentSession = {
+        agentName: agentLock
+      };
+    }
+    setAgentSession(initialAgentSession);
+  }, [
+    latestStopFunc,
+    setMessages,
+    setThreadId,
+    setCoagentStatesWithRef,
+    setAgentSession,
+    agentLock
+  ]);
+  const latestReset = useUpdatedRef(reset);
+  const latestResetFunc = (0, import_react12.useCallback)(() => {
+    return latestReset.current();
+  }, [latestReset]);
+  return {
+    visibleMessages: messages,
+    appendMessage: latestAppendFunc,
+    setMessages: latestSetMessagesFunc,
+    reloadMessages: latestReloadFunc,
+    stopGeneration: latestStopFunc,
+    reset: latestResetFunc,
+    deleteMessage: latestDeleteFunc,
+    runChatCompletion: latestRunChatCompletionFunc,
+    isLoading
+  };
+}
+function useUpdatedRef(value) {
+  const ref = (0, import_react12.useRef)(value);
+  (0, import_react12.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.
+` + (additionalInstructions ? `
+
+${additionalInstructions}` : "");
+}
+
+// src/hooks/use-copilot-action.ts
+var import_shared7 = require("@copilotkit/shared");
+var import_react13 = require("react");
+function useCopilotAction(action, dependencies) {
+  const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();
+  const idRef = (0, import_react13.useRef)((0, import_shared7.randomId)());
+  const renderAndWaitRef = (0, import_react13.useRef)(null);
+  action = __spreadValues({}, action);
+  if (
+    // renderAndWaitForResponse is not available for catch all actions
+    isFrontendAction(action) && // check if renderAndWaitForResponse is set
+    (action.renderAndWait || action.renderAndWaitForResponse)
+  ) {
+    const renderAndWait = action.renderAndWait || action.renderAndWaitForResponse;
+    action.renderAndWait = void 0;
+    action.renderAndWaitForResponse = void 0;
+    action.handler = useAsyncCallback(() => __async(this, null, function* () {
+      let resolve;
+      let reject;
+      const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+      });
+      renderAndWaitRef.current = { promise, resolve, reject };
+      return yield promise;
+    }), []);
+    action.render = (props) => {
+      let status = props.status;
+      if (props.status === "executing" && !renderAndWaitRef.current) {
+        status = "inProgress";
+      }
+      const waitProps = {
+        status,
+        args: props.args,
+        result: props.result,
+        handler: status === "executing" ? renderAndWaitRef.current.resolve : void 0,
+        respond: status === "executing" ? renderAndWaitRef.current.resolve : void 0
+      };
+      const isNoArgsRenderWait = (_fn) => {
+        var _a;
+        return ((_a = action.parameters) == null ? void 0 : _a.length) === 0;
+      };
+      if (renderAndWait) {
+        if (isNoArgsRenderWait(renderAndWait)) {
+          return renderAndWait(waitProps);
+        } else {
+          return renderAndWait(waitProps);
+        }
+      }
+      return (0, import_react13.createElement)(import_react13.Fragment);
+    };
+  }
+  if (dependencies === void 0) {
+    if (actions[idRef.current]) {
+      if (isFrontendAction(action)) {
+        actions[idRef.current].handler = action.handler;
+      }
+      if (typeof action.render === "function") {
+        if (chatComponentsCache.current !== null) {
+          chatComponentsCache.current.actions[action.name] = action.render;
+        }
+      }
+    }
+  }
+  (0, import_react13.useEffect)(() => {
+    setAction(idRef.current, action);
+    if (chatComponentsCache.current !== null && action.render !== void 0) {
+      chatComponentsCache.current.actions[action.name] = action.render;
+    }
+    return () => {
+      removeAction(idRef.current);
+    };
+  }, [
+    setAction,
+    removeAction,
+    isFrontendAction(action) ? action.description : void 0,
+    action.name,
+    isFrontendAction(action) ? action.disabled : void 0,
+    isFrontendAction(action) ? action.available : void 0,
+    // This should be faster than deep equality checking
+    // In addition, all major JS engines guarantee the order of object keys
+    JSON.stringify(isFrontendAction(action) ? action.parameters : []),
+    // include render only if it's a string
+    typeof action.render === "string" ? action.render : void 0,
+    // dependencies set by the developer
+    ...dependencies || []
+  ]);
+}
+function isFrontendAction(action) {
+  return action.name !== "*";
+}
+
+// src/hooks/use-coagent-state-render.ts
+var import_react14 = require("react");
+var import_shared8 = require("@copilotkit/shared");
+function useCoAgentStateRender(action, dependencies) {
+  const {
+    setCoAgentStateRender,
+    removeCoAgentStateRender,
+    coAgentStateRenders,
+    chatComponentsCache,
+    availableAgents
+  } = (0, import_react14.useContext)(CopilotContext);
+  const idRef = (0, import_react14.useRef)((0, import_shared8.randomId)());
+  const { addToast } = useToast();
+  (0, import_react14.useEffect)(() => {
+    if ((availableAgents == null ? void 0 : availableAgents.length) && !availableAgents.some((a) => a.name === action.name)) {
+      const message = `(useCoAgentStateRender): Agent "${action.name}" not found. Make sure the agent exists and is properly configured.`;
+      console.warn(message);
+      addToast({ type: "warning", message });
+    }
+  }, [availableAgents]);
+  const key = `${action.name}-${action.nodeName || "global"}`;
+  if (dependencies === void 0) {
+    if (coAgentStateRenders[idRef.current]) {
+      coAgentStateRenders[idRef.current].handler = action.handler;
+      if (typeof action.render === "function") {
+        if (chatComponentsCache.current !== null) {
+          chatComponentsCache.current.coAgentStateRenders[key] = action.render;
+        }
+      }
+    }
+  }
+  (0, import_react14.useEffect)(() => {
+    setCoAgentStateRender(idRef.current, action);
+    if (chatComponentsCache.current !== null && action.render !== void 0) {
+      chatComponentsCache.current.coAgentStateRenders[key] = action.render;
+    }
+    return () => {
+      removeCoAgentStateRender(idRef.current);
+    };
+  }, [
+    setCoAgentStateRender,
+    removeCoAgentStateRender,
+    action.name,
+    // include render only if it's a string
+    typeof action.render === "string" ? action.render : void 0,
+    // dependencies set by the developer
+    ...dependencies || []
+  ]);
+}
+
+// src/hooks/use-make-copilot-document-readable.ts
+var import_react15 = require("react");
+function useMakeCopilotDocumentReadable(document, categories, dependencies = []) {
+  const { addDocumentContext, removeDocumentContext } = useCopilotContext();
+  const idRef = (0, import_react15.useRef)();
+  (0, import_react15.useEffect)(() => {
+    const id = addDocumentContext(document, categories);
+    idRef.current = id;
+    return () => {
+      removeDocumentContext(id);
+    };
+  }, [addDocumentContext, removeDocumentContext, ...dependencies]);
+  return idRef.current;
+}
+
+// src/hooks/use-copilot-readable.ts
+var import_react16 = require("react");
+function convertToJSON(description, value) {
+  return `${description}: ${typeof value === "string" ? value : JSON.stringify(value)}`;
+}
+function useCopilotReadable({ description, value, parentId, categories, convert }, dependencies) {
+  const { addContext, removeContext } = useCopilotContext();
+  const idRef = (0, import_react16.useRef)();
+  convert = convert || convertToJSON;
+  const information = convert(description, value);
+  (0, import_react16.useEffect)(() => {
+    const id = addContext(information, parentId, categories);
+    idRef.current = id;
+    return () => {
+      removeContext(id);
+    };
+  }, [information, parentId, addContext, removeContext, ...dependencies || []]);
+  return idRef.current;
+}
+
+// src/hooks/use-coagent.ts
+var import_react17 = require("react");
+function useCoAgent(options) {
+  const generalContext = useCopilotContext();
+  const { availableAgents } = generalContext;
+  const { addToast } = useToast();
+  const isExternalStateManagement = (options2) => {
+    return "state" in options2 && "setState" in options2;
+  };
+  const { name } = options;
+  (0, import_react17.useEffect)(() => {
+    if ((availableAgents == null ? void 0 : availableAgents.length) && !availableAgents.some((a) => a.name === name)) {
+      const message = `(useCoAgent): Agent "${name}" not found. Make sure the agent exists and is properly configured.`;
+      console.warn(message);
+      addToast({ type: "warning", message });
+    }
+  }, [availableAgents]);
+  const isInternalStateManagementWithInitial = (options2) => {
+    return "initialState" in options2;
+  };
+  const messagesContext = useCopilotMessagesContext();
+  const context = __spreadValues(__spreadValues({}, generalContext), messagesContext);
+  const { coagentStates, coagentStatesRef, setCoagentStatesWithRef } = context;
+  const { appendMessage, runChatCompletion } = useCopilotChat();
+  const getCoagentState = (coagentStates2, name2) => {
+    if (coagentStates2[name2]) {
+      return coagentStates2[name2];
+    } else {
+      return {
+        name: name2,
+        state: isInternalStateManagementWithInitial(options) ? options.initialState : {},
+        running: false,
+        active: false,
+        threadId: void 0,
+        nodeName: void 0,
+        runId: void 0
+      };
+    }
+  };
+  const setState = (newState) => {
+    let coagentState2 = getCoagentState(coagentStatesRef.current || {}, name);
+    const updatedState = typeof newState === "function" ? newState(coagentState2.state) : newState;
+    setCoagentStatesWithRef(__spreadProps(__spreadValues({}, coagentStatesRef.current), {
+      [name]: __spreadProps(__spreadValues({}, coagentState2), {
+        state: updatedState
+      })
+    }));
+  };
+  const coagentState = getCoagentState(coagentStates, name);
+  const state = isExternalStateManagement(options) ? options.state : coagentState.state;
+  (0, import_react17.useEffect)(() => {
+    if (isExternalStateManagement(options)) {
+      setState(options.state);
+    } else if (coagentStates[name] === void 0) {
+      setState(options.initialState === void 0 ? {} : options.initialState);
+    }
+  }, [
+    isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0,
+    // reset initialstate on reset
+    coagentStates[name] === void 0
+  ]);
+  const runAgentCallback = useAsyncCallback(
+    (hint) => __async(this, null, function* () {
+      yield runAgent(name, context, appendMessage, runChatCompletion, hint);
+    }),
+    [name, context, appendMessage, runChatCompletion]
+  );
+  return {
+    name,
+    nodeName: coagentState.nodeName,
+    threadId: coagentState.threadId,
+    running: coagentState.running,
+    state: coagentState.state,
+    setState: isExternalStateManagement(options) ? options.setState : setState,
+    start: () => startAgent(name, context),
+    stop: () => stopAgent(name, context),
+    run: runAgentCallback
+  };
+}
+function startAgent(name, context) {
+  const { setAgentSession } = context;
+  setAgentSession({
+    agentName: name
+  });
+}
+function stopAgent(name, context) {
+  const { agentSession, setAgentSession } = context;
+  if (agentSession && agentSession.agentName === name) {
+    setAgentSession(null);
+    context.setCoagentStates((prevAgentStates) => {
+      return __spreadProps(__spreadValues({}, prevAgentStates), {
+        [name]: __spreadProps(__spreadValues({}, prevAgentStates[name]), {
+          running: false,
+          active: false,
+          threadId: void 0,
+          nodeName: void 0,
+          runId: void 0
+        })
+      });
+    });
+  } else {
+    console.warn(`No agent session found for ${name}`);
+  }
+}
+function runAgent(name, context, appendMessage, runChatCompletion, hint) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const { agentSession, setAgentSession } = context;
+    if (!agentSession || agentSession.agentName !== name) {
+      setAgentSession({
+        agentName: name
+      });
+    }
+    let previousState = null;
+    for (let i = context.messages.length - 1; i >= 0; i--) {
+      const message = context.messages[i];
+      if (message.isAgentStateMessage() && message.agentName === name) {
+        previousState = message.state;
+      }
+    }
+    let state = ((_b = (_a = context.coagentStatesRef.current) == null ? void 0 : _a[name]) == null ? void 0 : _b.state) || {};
+    if (hint) {
+      const hintMessage = hint({ previousState, currentState: state });
+      if (hintMessage) {
+        yield appendMessage(hintMessage);
+      } else {
+        yield runChatCompletion();
+      }
+    } else {
+      yield runChatCompletion();
+    }
+  });
+}
+
+// src/hooks/use-copilot-authenticated-action.ts
+var import_react18 = require("react");
+var import_react19 = __toESM(require("react"));
+function useCopilotAuthenticatedAction(action, dependencies) {
+  const { authConfig, authStates, setAuthStates } = useCopilotContext();
+  const pendingActionRef = (0, import_react18.useRef)(null);
+  const executeAction = (0, import_react18.useCallback)(
+    (props) => {
+      if (typeof action.render === "function") {
+        return action.render(props);
+      }
+      return action.render || import_react19.default.createElement(import_react18.Fragment);
+    },
+    [action]
+  );
+  const wrappedRender = (0, import_react18.useCallback)(
+    (props) => {
+      const isAuthenticated = Object.values(authStates || {}).some(
+        (state) => state.status === "authenticated"
+      );
+      if (!isAuthenticated) {
+        pendingActionRef.current = props;
+        return (authConfig == null ? void 0 : authConfig.SignInComponent) ? import_react19.default.createElement(authConfig.SignInComponent, {
+          onSignInComplete: (authState) => {
+            setAuthStates == null ? void 0 : setAuthStates((prev) => __spreadProps(__spreadValues({}, prev), { [action.name]: authState }));
+            if (pendingActionRef.current) {
+              executeAction(pendingActionRef.current);
+              pendingActionRef.current = null;
+            }
+          }
+        }) : import_react19.default.createElement(import_react18.Fragment);
+      }
+      return executeAction(props);
+    },
+    [action, authStates, setAuthStates]
+  );
+  useCopilotAction(
+    __spreadProps(__spreadValues({}, action), {
+      render: wrappedRender
+    }),
+    dependencies
+  );
+}
+
+// src/lib/copilot-task.ts
+var import_runtime_client_gql7 = require("@copilotkit/runtime-client-gql");
+var CopilotTask = class {
+  constructor(config) {
+    this.instructions = config.instructions;
+    this.actions = config.actions || [];
+    this.includeCopilotReadable = config.includeCopilotReadable !== false;
+    this.includeCopilotActions = config.includeCopilotActions !== false;
+    this.forwardedParameters = config.forwardedParameters;
+  }
+  /**
+   * Run the task.
+   * @param context The CopilotContext to use for the task. Use `useCopilotContext` to obtain the current context.
+   * @param data The data to use for the task.
+   */
+  run(context, data) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const actions = this.includeCopilotActions ? Object.assign({}, context.actions) : {};
+      for (const fn of this.actions) {
+        actions[fn.name] = fn;
+      }
+      let contextString = "";
+      if (data) {
+        contextString = (typeof data === "string" ? data : JSON.stringify(data)) + "\n\n";
+      }
+      if (this.includeCopilotReadable) {
+        contextString += context.getContextString([], defaultCopilotContextCategories);
+      }
+      const systemMessage = new import_runtime_client_gql7.TextMessage({
+        content: taskSystemMessage(contextString, this.instructions),
+        role: import_runtime_client_gql7.Role.System
+      });
+      const messages = [systemMessage];
+      const runtimeClient = new import_runtime_client_gql7.CopilotRuntimeClient({
+        url: context.copilotApiConfig.chatApiEndpoint,
+        publicApiKey: context.copilotApiConfig.publicApiKey,
+        headers: context.copilotApiConfig.headers,
+        credentials: context.copilotApiConfig.credentials
+      });
+      const response = yield runtimeClient.generateCopilotResponse({
+        data: {
+          frontend: {
+            actions: processActionsForRuntimeRequest(Object.values(actions)),
+            url: window.location.href
+          },
+          messages: (0, import_runtime_client_gql7.convertMessagesToGqlInput)((0, import_runtime_client_gql7.filterAgentStateMessages)(messages)),
+          metadata: {
+            requestType: import_runtime_client_gql7.CopilotRequestType.Task
+          },
+          forwardedParameters: __spreadProps(__spreadValues({}, (_a = this.forwardedParameters) != null ? _a : {}), {
+            toolChoice: "required"
+          })
+        },
+        properties: context.copilotApiConfig.properties
+      }).toPromise();
+      const functionCallHandler = context.getFunctionCallHandler(actions);
+      const functionCalls = (0, import_runtime_client_gql7.convertGqlOutputToMessages)(
+        ((_c = (_b = response.data) == null ? void 0 : _b.generateCopilotResponse) == null ? void 0 : _c.messages) || []
+      ).filter((m) => m.isActionExecutionMessage());
+      for (const functionCall of functionCalls) {
+        yield functionCallHandler({
+          messages,
+          name: functionCall.name,
+          args: functionCall.arguments
+        });
+      }
+    });
+  }
+};
+function taskSystemMessage(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 functions you can 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 a function without saying anything else.
+
+The user has given you the following task to complete:
+
+\`\`\`
+${instructions}
+\`\`\`
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CopilotContext,
+  CopilotKit,
+  CopilotMessagesContext,
+  CopilotTask,
+  defaultCopilotContextCategories,
+  extract,
+  runAgent,
+  shouldShowDevConsole,
+  startAgent,
+  stopAgent,
+  useCoAgent,
+  useCoAgentStateRender,
+  useCopilotAction,
+  useCopilotAuthenticatedAction,
+  useCopilotChat,
+  useCopilotContext,
+  useCopilotMessagesContext,
+  useCopilotReadable,
+  useCopilotRuntimeClient,
+  useMakeCopilotDocumentReadable
+});
+//# sourceMappingURL=index.js.map