@copilotkit/react-core 0.18.0-alpha.1 → 0.18.0-alpha.3

package/dist/index.js

@@ -0,0 +1,838 @@
+'use strict';
+
+var React = require('react');
+var nanoid = require('nanoid');
+var shared = require('@copilotkit/shared');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __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());
+  });
+};
+var emptyCopilotContext = {
+  entryPoints: {},
+  setEntryPoint: () => {
+  },
+  removeEntryPoint: () => {
+  },
+  getChatCompletionFunctionDescriptions: () => returnAndThrowInDebug(),
+  getFunctionCallHandler: () => returnAndThrowInDebug(),
+  getContextString: (documents, categories) => returnAndThrowInDebug(),
+  addContext: () => "",
+  removeContext: () => {
+  },
+  getDocumentsContext: (categories) => returnAndThrowInDebug(),
+  addDocumentContext: () => returnAndThrowInDebug(),
+  removeDocumentContext: () => {
+  },
+  copilotApiConfig: new class {
+    get chatApiEndpoint() {
+      throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+    }
+    get chatApiEndpointV2() {
+      throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+    }
+    get headers() {
+      return {};
+    }
+    get body() {
+      return {};
+    }
+  }()
+};
+var CopilotContext = React__default.default.createContext(emptyCopilotContext);
+function returnAndThrowInDebug(value) {
+  throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+}
+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] = React.useReducer(treeReducer, []);
+  const addElement = React.useCallback(
+    (value, categories, parentId) => {
+      const newNodeId = nanoid.nanoid();
+      dispatch({
+        type: "ADD_NODE",
+        value,
+        parentId,
+        id: newNodeId,
+        categories
+      });
+      return newNodeId;
+    },
+    []
+  );
+  const removeElement = React.useCallback((id) => {
+    dispatch({ type: "REMOVE_NODE", id });
+  }, []);
+  const printTree = React.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;
+}
+var useFlatCategoryStore = () => {
+  const [elements, dispatch] = React.useReducer(flatCategoryStoreReducer, /* @__PURE__ */ new Map());
+  const addElement = React.useCallback((value, categories) => {
+    const newId = nanoid.nanoid();
+    dispatch({
+      type: "ADD_ELEMENT",
+      value,
+      id: newId,
+      categories
+    });
+    return newId;
+  }, []);
+  const removeElement = React.useCallback((id) => {
+    dispatch({ type: "REMOVE_ELEMENT", id });
+  }, []);
+  const allElements = React.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/standard-copilot-api-config.tsx
+var StandardCopilotApiConfig = class {
+  constructor(chatApiEndpoint, chatApiEndpointV2, headers, body) {
+    this.chatApiEndpoint = chatApiEndpoint;
+    this.chatApiEndpointV2 = chatApiEndpointV2;
+    this.headers = headers;
+    this.body = body;
+  }
+};
+function CopilotKit(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const [entryPoints, setEntryPoints] = React.useState({});
+  const { addElement, removeElement, printTree } = use_tree_default();
+  const {
+    addElement: addDocument,
+    removeElement: removeDocument,
+    allElements: allDocuments
+  } = use_flat_category_store_default();
+  const setEntryPoint = React.useCallback((id, entryPoint) => {
+    setEntryPoints((prevPoints) => {
+      return __spreadProps(__spreadValues({}, prevPoints), {
+        [id]: entryPoint
+      });
+    });
+  }, []);
+  const removeEntryPoint = React.useCallback((id) => {
+    setEntryPoints((prevPoints) => {
+      const newPoints = __spreadValues({}, prevPoints);
+      delete newPoints[id];
+      return newPoints;
+    });
+  }, []);
+  const getContextString = React.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 = React.useCallback(
+    (context, parentId, categories = defaultCopilotContextCategories) => {
+      return addElement(context, categories, parentId);
+    },
+    [addElement]
+  );
+  const removeContext = React.useCallback(
+    (id) => {
+      removeElement(id);
+    },
+    [removeElement]
+  );
+  const getChatCompletionFunctionDescriptions = React.useCallback(() => {
+    return entryPointsToChatCompletionFunctions(Object.values(entryPoints));
+  }, [entryPoints]);
+  const getFunctionCallHandler = React.useCallback(() => {
+    return entryPointsToFunctionCallHandler(Object.values(entryPoints));
+  }, [entryPoints]);
+  const getDocumentsContext = React.useCallback(
+    (categories) => {
+      return allDocuments(categories);
+    },
+    [allDocuments]
+  );
+  const addDocumentContext = React.useCallback(
+    (documentPointer, categories = defaultCopilotContextCategories) => {
+      return addDocument(documentPointer, categories);
+    },
+    [addDocument]
+  );
+  const removeDocumentContext = React.useCallback(
+    (documentId) => {
+      removeDocument(documentId);
+    },
+    [removeDocument]
+  );
+  const copilotApiConfig = new StandardCopilotApiConfig(
+    props.url,
+    `${props.url}/v2`,
+    props.headers || {},
+    props.body || {}
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    CopilotContext.Provider,
+    {
+      value: {
+        entryPoints,
+        getChatCompletionFunctionDescriptions,
+        getFunctionCallHandler,
+        setEntryPoint,
+        removeEntryPoint,
+        getContextString,
+        addContext,
+        removeContext,
+        getDocumentsContext,
+        addDocumentContext,
+        removeDocumentContext,
+        copilotApiConfig
+      },
+      children
+    }
+  );
+}
+var defaultCopilotContextCategories = ["global"];
+function entryPointsToFunctionCallHandler(entryPoints) {
+  return (chatMessages, functionCall) => __async(this, null, function* () {
+    let entrypointsByFunctionName = {};
+    for (let entryPoint of entryPoints) {
+      entrypointsByFunctionName[entryPoint.name] = entryPoint;
+    }
+    const entryPointFunction = entrypointsByFunctionName[functionCall.name || ""];
+    if (entryPointFunction) {
+      let functionCallArguments = [];
+      if (functionCall.arguments) {
+        functionCallArguments = JSON.parse(functionCall.arguments);
+      }
+      const paramsInCorrectOrder = [];
+      for (let arg of entryPointFunction.argumentAnnotations) {
+        paramsInCorrectOrder.push(
+          functionCallArguments[arg.name]
+        );
+      }
+      yield entryPointFunction.implementation(...paramsInCorrectOrder);
+    }
+  });
+}
+function entryPointsToChatCompletionFunctions(entryPoints) {
+  return entryPoints.map(shared.annotatedFunctionToChatCompletionFunction);
+}
+function fetchChatCompletion(_0) {
+  return __async(this, arguments, function* ({
+    copilotConfig,
+    model,
+    messages,
+    functions,
+    temperature,
+    headers,
+    body,
+    signal
+  }) {
+    temperature || (temperature = 0.5);
+    functions || (functions = []);
+    const cleanedMessages = messages.map((message) => {
+      const { content, role, name, function_call } = message;
+      return { content, role, name, function_call };
+    });
+    const response = yield fetch(copilotConfig.chatApiEndpoint, {
+      method: "POST",
+      headers: __spreadValues(__spreadValues({
+        "Content-Type": "application/json"
+      }, copilotConfig.headers), headers ? __spreadValues({}, headers) : {}),
+      body: JSON.stringify(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+        model,
+        messages: cleanedMessages,
+        stream: true
+      }, functions.length ? { functions } : {}), temperature ? { temperature } : {}), functions.length != 0 ? { function_call: "auto" } : {}), copilotConfig.body), body ? __spreadValues({}, body) : {})),
+      signal
+    });
+    return response;
+  });
+}
+function fetchAndDecodeChatCompletion(params) {
+  return __async(this, null, function* () {
+    const response = yield fetchChatCompletion(params);
+    if (!response.ok || !response.body) {
+      return __spreadProps(__spreadValues({}, response), { events: null });
+    }
+    const events = yield shared.decodeChatCompletion(shared.parseChatCompletion(response.body));
+    return __spreadProps(__spreadValues({}, response), { events });
+  });
+}
+function fetchAndDecodeChatCompletionAsText(params) {
+  return __async(this, null, function* () {
+    const response = yield fetchChatCompletion(params);
+    if (!response.ok || !response.body) {
+      return __spreadProps(__spreadValues({}, response), { events: null });
+    }
+    const events = yield shared.decodeChatCompletionAsText(
+      shared.decodeChatCompletion(shared.parseChatCompletion(response.body))
+    );
+    return __spreadProps(__spreadValues({}, response), { events });
+  });
+}
+
+// src/hooks/use-chat.ts
+function useChat(options) {
+  const [messages, setMessages] = React.useState([]);
+  const [input, setInput] = React.useState("");
+  const [isLoading, setIsLoading] = React.useState(false);
+  const abortControllerRef = React.useRef();
+  const runChatCompletion = (messages2) => __async(this, null, function* () {
+    setIsLoading(true);
+    const assistantMessage = {
+      id: nanoid.nanoid(),
+      createdAt: /* @__PURE__ */ new Date(),
+      content: "",
+      role: "assistant"
+    };
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    setMessages([...messages2, __spreadValues({}, assistantMessage)]);
+    const messagesWithContext = [...options.initialMessages || [], ...messages2];
+    const response = yield fetchAndDecodeChatCompletion({
+      copilotConfig: options.copilotConfig,
+      messages: messagesWithContext,
+      functions: options.functions,
+      headers: options.headers,
+      signal: abortController.signal
+    });
+    if (!response.events) {
+      throw new Error("Failed to fetch chat completion");
+    }
+    const reader = response.events.getReader();
+    while (true) {
+      try {
+        const { done, value } = yield reader.read();
+        if (done) {
+          setIsLoading(false);
+          return __spreadValues({}, assistantMessage);
+        }
+        if (value.type === "content") {
+          assistantMessage.content += value.content;
+          setMessages([...messages2, __spreadValues({}, assistantMessage)]);
+        } else if (value.type === "function") {
+          assistantMessage.function_call = {
+            name: value.name,
+            arguments: JSON.stringify(value.arguments)
+          };
+          setMessages([...messages2, __spreadValues({}, assistantMessage)]);
+          setIsLoading(false);
+          return __spreadValues({}, assistantMessage);
+        }
+      } catch (error) {
+        setIsLoading(false);
+        throw error;
+      }
+    }
+  });
+  const runChatCompletionAndHandleFunctionCall = (messages2) => __async(this, null, function* () {
+    const message = yield runChatCompletion(messages2);
+    if (message.function_call && options.onFunctionCall) {
+      yield options.onFunctionCall(messages2, message.function_call);
+    }
+  });
+  const append = (message) => __async(this, null, function* () {
+    if (isLoading) {
+      return;
+    }
+    const newMessages = [...messages, message];
+    setMessages(newMessages);
+    return runChatCompletionAndHandleFunctionCall(newMessages);
+  });
+  const reload = () => __async(this, null, function* () {
+    if (isLoading || messages.length === 0) {
+      return;
+    }
+    let newMessages = [...messages];
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage.role === "assistant") {
+      newMessages = newMessages.slice(0, -1);
+    }
+    setMessages(newMessages);
+    return runChatCompletionAndHandleFunctionCall(newMessages);
+  });
+  const stop = () => {
+    var _a;
+    (_a = abortControllerRef.current) == null ? void 0 : _a.abort();
+  };
+  return {
+    messages,
+    append,
+    reload,
+    stop,
+    isLoading,
+    input,
+    setInput
+  };
+}
+
+// src/hooks/use-copilot-chat.ts
+function useCopilotChat(_a) {
+  var _b = _a, {
+    makeSystemMessage,
+    additionalInstructions
+  } = _b, options = __objRest(_b, [
+    "makeSystemMessage",
+    "additionalInstructions"
+  ]);
+  const {
+    getContextString,
+    getChatCompletionFunctionDescriptions,
+    getFunctionCallHandler,
+    copilotApiConfig
+  } = React.useContext(CopilotContext);
+  const systemMessage = React.useMemo(() => {
+    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
+    const contextString = getContextString([], defaultCopilotContextCategories);
+    return {
+      id: "system",
+      content: systemMessageMaker(contextString, additionalInstructions),
+      role: "system"
+    };
+  }, [getContextString, makeSystemMessage]);
+  const functionDescriptions = React.useMemo(() => {
+    return getChatCompletionFunctionDescriptions();
+  }, [getChatCompletionFunctionDescriptions]);
+  const { messages, append, reload, stop, isLoading, input, setInput } = useChat(__spreadProps(__spreadValues({}, options), {
+    copilotConfig: copilotApiConfig,
+    id: options.id,
+    initialMessages: [systemMessage].concat(options.initialMessages || []),
+    functions: functionDescriptions,
+    onFunctionCall: getFunctionCallHandler(),
+    headers: __spreadValues({}, options.headers),
+    body: __spreadValues({}, options.body)
+  }));
+  const visibleMessages = messages.filter(
+    (message) => message.role === "user" || message.role === "assistant"
+  );
+  return {
+    visibleMessages,
+    append,
+    reload,
+    stop,
+    isLoading,
+    input,
+    setInput
+  };
+}
+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}` : "");
+}
+function useMakeCopilotActionable(annotatedFunction, dependencies) {
+  const idRef = React.useRef(nanoid.nanoid());
+  const { setEntryPoint, removeEntryPoint } = React.useContext(CopilotContext);
+  const memoizedAnnotatedFunction = React.useMemo(
+    () => ({
+      name: annotatedFunction.name,
+      description: annotatedFunction.description,
+      argumentAnnotations: annotatedFunction.argumentAnnotations,
+      implementation: annotatedFunction.implementation
+    }),
+    dependencies
+  );
+  React.useEffect(() => {
+    setEntryPoint(idRef.current, memoizedAnnotatedFunction);
+    return () => {
+      removeEntryPoint(idRef.current);
+    };
+  }, [memoizedAnnotatedFunction, setEntryPoint, removeEntryPoint]);
+}
+function useMakeCopilotReadable(information, parentId, categories) {
+  const { addContext, removeContext } = React.useContext(CopilotContext);
+  const idRef = React.useRef();
+  React.useEffect(() => {
+    const id = addContext(information, parentId, categories);
+    idRef.current = id;
+    return () => {
+      removeContext(id);
+    };
+  }, [information, parentId, addContext, removeContext]);
+  return idRef.current;
+}
+function useMakeCopilotDocumentReadable(document, categories, dependencies = []) {
+  const { addDocumentContext, removeDocumentContext } = React.useContext(CopilotContext);
+  const idRef = React.useRef();
+  React.useEffect(() => {
+    const id = addDocumentContext(document, categories);
+    idRef.current = id;
+    return () => {
+      removeDocumentContext(id);
+    };
+  }, [addDocumentContext, removeDocumentContext, ...dependencies]);
+  return idRef.current;
+}
+
+// src/openai-assistants/utils/process-message-stream.ts
+function processMessageStream(reader, processMessage) {
+  return __async(this, null, function* () {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = yield reader.read();
+      if (done) {
+        if (buffer.length > 0) {
+          processMessage(buffer);
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let endIndex;
+      while ((endIndex = buffer.indexOf("\n")) !== -1) {
+        processMessage(buffer.substring(0, endIndex).trim());
+        buffer = buffer.substring(endIndex + 1);
+      }
+    }
+  });
+}
+function useCopilotChatV2(options) {
+  const {
+    getContextString,
+    getChatCompletionFunctionDescriptions,
+    getFunctionCallHandler,
+    copilotApiConfig
+  } = React.useContext(CopilotContext);
+  const [messages, setMessages] = React.useState([]);
+  const [input, setInput] = React.useState("");
+  const [threadId, setThreadId] = React.useState(void 0);
+  const [status, setStatus] = React.useState("awaiting_message");
+  const [error, setError] = React.useState(void 0);
+  React.useMemo(() => {
+    const systemMessageMaker = options.makeSystemMessage || defaultSystemMessage2;
+    const contextString = getContextString([], defaultCopilotContextCategories);
+    return {
+      id: "system",
+      content: systemMessageMaker(contextString),
+      role: "system"
+    };
+  }, [getContextString, options.makeSystemMessage]);
+  const handleInputChange = (e) => {
+    setInput(e.target.value);
+  };
+  const submitMessage = (e) => __async(this, null, function* () {
+    var _a, _b;
+    e.preventDefault();
+    if (input === "") {
+      return;
+    }
+    setStatus("in_progress");
+    setMessages((messages2) => [...messages2, { id: "", role: "user", content: input }]);
+    setInput("");
+    const apiUrl = copilotApiConfig.chatApiEndpointV2;
+    const functions = getChatCompletionFunctionDescriptions();
+    const result = yield fetch(apiUrl, {
+      method: "POST",
+      headers: __spreadValues(__spreadValues({
+        "Content-Type": "application/json"
+      }, copilotApiConfig.headers), options.headers),
+      body: JSON.stringify(__spreadValues(__spreadValues(__spreadValues({
+        // always use user-provided threadId when available:
+        threadId: (_b = (_a = options.threadId) != null ? _a : threadId) != null ? _b : null,
+        message: input
+      }, functions.length > 0 && { functions }), copilotApiConfig.body), options.body))
+    });
+    if (result.body == null) {
+      throw new Error("The response body is empty.");
+    }
+    yield processMessageStream(result.body.getReader(), (message) => {
+      try {
+        const { type, value } = shared.parseStreamPart(message);
+        switch (type) {
+          case "assistant_message": {
+            setMessages((messages2) => [
+              ...messages2,
+              {
+                id: value.id,
+                role: value.role,
+                content: value.content[0].text.value
+              }
+            ]);
+            break;
+          }
+          case "assistant_control_data": {
+            setThreadId(value.threadId);
+            setMessages((messages2) => {
+              const lastMessage = messages2[messages2.length - 1];
+              lastMessage.id = value.messageId;
+              return [...messages2.slice(0, messages2.length - 1), lastMessage];
+            });
+            break;
+          }
+          case "error": {
+            setError(value);
+            break;
+          }
+        }
+      } catch (error2) {
+        setError(error2);
+      }
+    });
+    setStatus("awaiting_message");
+  });
+  return {
+    messages,
+    input,
+    handleInputChange,
+    submitMessage,
+    status,
+    error
+  };
+}
+function defaultSystemMessage2(contextString) {
+  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.
+`;
+}
+
+exports.CopilotContext = CopilotContext;
+exports.CopilotKit = CopilotKit;
+exports.defaultCopilotContextCategories = defaultCopilotContextCategories;
+exports.fetchAndDecodeChatCompletion = fetchAndDecodeChatCompletion;
+exports.fetchAndDecodeChatCompletionAsText = fetchAndDecodeChatCompletionAsText;
+exports.fetchChatCompletion = fetchChatCompletion;
+exports.processMessageStream = processMessageStream;
+exports.useCopilotChat = useCopilotChat;
+exports.useCopilotChatV2 = useCopilotChatV2;
+exports.useMakeCopilotActionable = useMakeCopilotActionable;
+exports.useMakeCopilotDocumentReadable = useMakeCopilotDocumentReadable;
+exports.useMakeCopilotReadable = useMakeCopilotReadable;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map