@copilotkit/react-core 1.10.6 → 1.50.0-beta.0

package/dist/chunk-CB7CRBDG.mjs

@@ -0,0 +1,48 @@
+import {
+  useCopilotContext
+} from "./chunk-WVLHXIFP.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-SKC7AJIV.mjs";
+
+// src/hooks/use-configure-chat-suggestions.tsx
+import {
+  useConfigureSuggestions,
+  useCopilotKit,
+  useSuggestions
+} from "@copilotkitnext/react";
+import { useEffect } from "react";
+function useConfigureChatSuggestions(config, dependencies = []) {
+  const { agentSession } = useCopilotContext();
+  const { copilotkit } = useCopilotKit();
+  const available = config.available === "enabled" ? "always" : config.available;
+  const finalSuggestionConfig = __spreadProps(__spreadValues({}, config), {
+    available,
+    consumerAgentId: agentSession == null ? void 0 : agentSession.agentName
+    // Use chatConfig.agentId here
+  });
+  useConfigureSuggestions(finalSuggestionConfig, { deps: dependencies });
+  const result = useSuggestions({ agentId: agentSession == null ? void 0 : agentSession.agentName });
+  useEffect(() => {
+    if (finalSuggestionConfig.available === "disabled")
+      return;
+    const subscription = copilotkit.subscribe({
+      onAgentsChanged: () => {
+        const agent = copilotkit.getAgent(agentSession == null ? void 0 : agentSession.agentName);
+        if (agent && !agent.isRunning && !result.suggestions.length) {
+          copilotkit.reloadSuggestions(agentSession == null ? void 0 : agentSession.agentName);
+        }
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, []);
+  return result;
+}
+
+export {
+  useConfigureChatSuggestions
+};
+//# sourceMappingURL=chunk-CB7CRBDG.mjs.map

package/dist/chunk-CB7CRBDG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/use-configure-chat-suggestions.tsx"],"sourcesContent":["import {\n  useConfigureSuggestions,\n  useCopilotChatConfiguration,\n  useCopilotKit,\n  useSuggestions,\n} from \"@copilotkitnext/react\";\nimport { StaticSuggestionsConfig, Suggestion } from \"@copilotkitnext/core\";\nimport { useCopilotContext } from \"../context\";\nimport { useEffect, useMemo } from \"react\";\n\ntype StaticSuggestionInput = Omit<Suggestion, \"isLoading\"> & Partial<Pick<Suggestion, \"isLoading\">>;\n\ntype StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig, \"suggestions\"> & {\n  suggestions: StaticSuggestionInput[];\n};\n\ntype DynamicSuggestionsConfigInput = {\n  /**\n   * A prompt or instructions for the GPT to generate suggestions.\n   */\n  instructions: string;\n  /**\n   * The minimum number of suggestions to generate. Defaults to `1`.\n   * @default 1\n   */\n  minSuggestions?: number;\n  /**\n   * The maximum number of suggestions to generate. Defaults to `3`.\n   * @default 1\n   */\n  maxSuggestions?: number;\n\n  /**\n   * Whether the suggestions are available. Defaults to `enabled`.\n   * @default enabled\n   */\n  available?: \"enabled\" | \"disabled\" | \"always\" | \"before-first-message\" | \"after-first-message\";\n\n  /**\n   * An optional class name to apply to the suggestions.\n   */\n  className?: string;\n};\n\nexport type UseCopilotChatSuggestionsConfiguration =\n  | DynamicSuggestionsConfigInput\n  | StaticSuggestionsConfigInput;\n\nexport function useConfigureChatSuggestions(\n  config: UseCopilotChatSuggestionsConfiguration,\n  dependencies: any[] = [],\n): ReturnType<typeof useSuggestions> {\n  const { agentSession } = useCopilotContext();\n  const { copilotkit } = useCopilotKit();\n\n  const available = config.available === \"enabled\" ? \"always\" : config.available;\n\n  const finalSuggestionConfig = {\n    ...config,\n    available,\n    consumerAgentId: agentSession?.agentName, // Use chatConfig.agentId here\n  };\n  useConfigureSuggestions(finalSuggestionConfig, { deps: dependencies });\n\n  const result = useSuggestions({ agentId: agentSession?.agentName });\n\n  useEffect(() => {\n    if (finalSuggestionConfig.available === \"disabled\") return;\n    const subscription = copilotkit.subscribe({\n      onAgentsChanged: () => {\n        // When agents change, check if our target agent now exists and reload\n        const agent = copilotkit.getAgent(agentSession?.agentName!);\n        if (agent && !agent.isRunning && !result.suggestions.length) {\n          copilotkit.reloadSuggestions(agentSession?.agentName!);\n        }\n      },\n    });\n\n    return () => {\n      subscription.unsubscribe();\n    };\n  }, []);\n\n  return result;\n}\n"],"mappings":";;;;;;;;;AAAA;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAGP,SAAS,iBAA0B;AAwC5B,SAAS,4BACd,QACA,eAAsB,CAAC,GACY;AACnC,QAAM,EAAE,aAAa,IAAI,kBAAkB;AAC3C,QAAM,EAAE,WAAW,IAAI,cAAc;AAErC,QAAM,YAAY,OAAO,cAAc,YAAY,WAAW,OAAO;AAErE,QAAM,wBAAwB,iCACzB,SADyB;AAAA,IAE5B;AAAA,IACA,iBAAiB,6CAAc;AAAA;AAAA,EACjC;AACA,0BAAwB,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAErE,QAAM,SAAS,eAAe,EAAE,SAAS,6CAAc,UAAU,CAAC;AAElE,YAAU,MAAM;AACd,QAAI,sBAAsB,cAAc;AAAY;AACpD,UAAM,eAAe,WAAW,UAAU;AAAA,MACxC,iBAAiB,MAAM;AAErB,cAAM,QAAQ,WAAW,SAAS,6CAAc,SAAU;AAC1D,YAAI,SAAS,CAAC,MAAM,aAAa,CAAC,OAAO,YAAY,QAAQ;AAC3D,qBAAW,kBAAkB,6CAAc,SAAU;AAAA,QACvD;AAAA,MACF;AAAA,IACF,CAAC;AAED,WAAO,MAAM;AACX,mBAAa,YAAY;AAAA,IAC3B;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;","names":[]}

package/dist/chunk-CYDWEPFL.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-CYDWEPFL.mjs.map

package/dist/{chunk-BBUQMG45.mjs → chunk-D3QSYDJR.mjs}

@@ -1,12 +1,12 @@
 import {
   useCopilotContext
-} from "./chunk-EUX2P2E7.mjs";
+} from "./chunk-WVLHXIFP.mjs";
 
 // src/hooks/use-make-copilot-document-readable.ts
 import { useEffect, useRef } from "react";
 function useMakeCopilotDocumentReadable(document, categories, dependencies = []) {
   const { addDocumentContext, removeDocumentContext } = useCopilotContext();
-  const idRef = useRef();
+  const idRef = useRef(void 0);
   useEffect(() => {
     const id = addDocumentContext(document, categories);
     idRef.current = id;
@@ -20,4 +20,4 @@ function useMakeCopilotDocumentReadable(document, categories, dependencies = [])
 export {
   useMakeCopilotDocumentReadable
 };
-//# sourceMappingURL=chunk-BBUQMG45.mjs.map
+//# sourceMappingURL=chunk-D3QSYDJR.mjs.map

package/dist/{chunk-BBUQMG45.mjs.map → chunk-D3QSYDJR.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/hooks/use-make-copilot-document-readable.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useCopilotContext } from \"../context/copilot-context\";\nimport { DocumentPointer } from \"../types\";\n\n/**\n * Makes a document readable by Copilot.\n * @param document The document to make readable.\n * @param categories The categories to associate with the document.\n * @param dependencies The dependencies to use for the effect.\n * @returns The id of the document.\n */\nexport function useMakeCopilotDocumentReadable(\n  document: DocumentPointer,\n  categories?: string[],\n  dependencies: any[] = [],\n): string | undefined {\n  const { addDocumentContext, removeDocumentContext } = useCopilotContext();\n  const idRef = useRef<string>();\n\n  useEffect(() => {\n    const id = addDocumentContext(document, categories);\n    idRef.current = id;\n\n    return () => {\n      removeDocumentContext(id);\n    };\n  }, [addDocumentContext, removeDocumentContext, ...dependencies]);\n\n  return idRef.current;\n}\n"],"mappings":";;;;;AAAA,SAAS,WAAW,cAAc;AAW3B,SAAS,+BACd,UACA,YACA,eAAsB,CAAC,GACH;AACpB,QAAM,EAAE,oBAAoB,sBAAsB,IAAI,kBAAkB;AACxE,QAAM,QAAQ,OAAe;AAE7B,YAAU,MAAM;AACd,UAAM,KAAK,mBAAmB,UAAU,UAAU;AAClD,UAAM,UAAU;AAEhB,WAAO,MAAM;AACX,4BAAsB,EAAE;AAAA,IAC1B;AAAA,EACF,GAAG,CAAC,oBAAoB,uBAAuB,GAAG,YAAY,CAAC;AAE/D,SAAO,MAAM;AACf;","names":[]}
+{"version":3,"sources":["../src/hooks/use-make-copilot-document-readable.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useCopilotContext } from \"../context/copilot-context\";\nimport { DocumentPointer } from \"../types\";\n\n/**\n * Makes a document readable by Copilot.\n * @param document The document to make readable.\n * @param categories The categories to associate with the document.\n * @param dependencies The dependencies to use for the effect.\n * @returns The id of the document.\n */\nexport function useMakeCopilotDocumentReadable(\n  document: DocumentPointer,\n  categories?: string[],\n  dependencies: any[] = [],\n): string | undefined {\n  const { addDocumentContext, removeDocumentContext } = useCopilotContext();\n  const idRef = useRef<string>(undefined!);\n\n  useEffect(() => {\n    const id = addDocumentContext(document, categories);\n    idRef.current = id;\n\n    return () => {\n      removeDocumentContext(id);\n    };\n  }, [addDocumentContext, removeDocumentContext, ...dependencies]);\n\n  return idRef.current;\n}\n"],"mappings":";;;;;AAAA,SAAS,WAAW,cAAc;AAW3B,SAAS,+BACd,UACA,YACA,eAAsB,CAAC,GACH;AACpB,QAAM,EAAE,oBAAoB,sBAAsB,IAAI,kBAAkB;AACxE,QAAM,QAAQ,OAAe,MAAU;AAEvC,YAAU,MAAM;AACd,UAAM,KAAK,mBAAmB,UAAU,UAAU;AAClD,UAAM,UAAU;AAEhB,WAAO,MAAM;AACX,4BAAsB,EAAE;AAAA,IAC1B;AAAA,EACF,GAAG,CAAC,oBAAoB,uBAAuB,GAAG,YAAY,CAAC;AAE/D,SAAO,MAAM;AACf;","names":[]}

package/dist/chunk-DCHSCK62.mjs

@@ -0,0 +1,549 @@
+import {
+  CopilotErrorBoundary
+} from "./chunk-LHERIF3L.mjs";
+import {
+  CopilotMessages,
+  MessagesTapProvider
+} from "./chunk-FBD24VEH.mjs";
+import {
+  ConsoleTrigger
+} from "./chunk-LHKZJ2ND.mjs";
+import {
+  shouldShowDevConsole
+} from "./chunk-ICIK2BSB.mjs";
+import {
+  use_tree_default
+} from "./chunk-RKTVJRK7.mjs";
+import {
+  use_flat_category_store_default
+} from "./chunk-YYN33GSG.mjs";
+import {
+  CoAgentStateRenderBridge
+} from "./chunk-NROJOTQP.mjs";
+import {
+  CopilotListeners
+} from "./chunk-5X5DJRQQ.mjs";
+import {
+  ThreadsProvider,
+  useThreads
+} from "./chunk-F555TVE4.mjs";
+import {
+  ToastProvider
+} from "./chunk-EFL5OBKN.mjs";
+import {
+  UsageBanner,
+  getErrorActions
+} from "./chunk-6ZLPNY7X.mjs";
+import {
+  CoAgentStateRendersProvider
+} from "./chunk-FDOMAPJY.mjs";
+import {
+  CopilotContext
+} from "./chunk-WVLHXIFP.mjs";
+import {
+  __async,
+  __objRest,
+  __restKey,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-SKC7AJIV.mjs";
+
+// src/components/copilot-provider/copilotkit.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { CopilotChatConfigurationProvider, CopilotKitProvider } from "@copilotkitnext/react";
+import { flushSync } from "react-dom";
+import {
+  COPILOT_CLOUD_CHAT_URL,
+  COPILOT_CLOUD_PUBLIC_API_KEY_HEADER,
+  randomUUID,
+  ConfigurationError,
+  MissingPublicApiKeyError
+} from "@copilotkit/shared";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function CopilotKit(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const enabled = shouldShowDevConsole(props.showDevConsole);
+  const publicApiKey = props.publicApiKey || props.publicLicenseKey;
+  const renderArr = useMemo(() => [{ render: CoAgentStateRenderBridge }], []);
+  return /* @__PURE__ */ jsx(ToastProvider, { enabled, children: /* @__PURE__ */ jsx(CopilotErrorBoundary, { publicApiKey, showUsageBanner: enabled, children: /* @__PURE__ */ jsx(ThreadsProvider, { threadId: props.threadId, children: /* @__PURE__ */ jsx(
+    CopilotKitProvider,
+    {
+      runtimeUrl: props.runtimeUrl,
+      renderCustomMessages: renderArr,
+      useSingleEndpoint: true,
+      children: /* @__PURE__ */ jsx(CopilotKitInternal, __spreadProps(__spreadValues({}, props), { children }))
+    }
+  ) }) }) });
+}
+function CopilotKitInternal(cpkProps) {
+  var _b;
+  const _a = cpkProps, { children } = _a, props = __objRest(_a, ["children"]);
+  validateProps(cpkProps);
+  const publicApiKey = props.publicLicenseKey || props.publicApiKey;
+  const chatApiEndpoint = props.runtimeUrl || COPILOT_CLOUD_CHAT_URL;
+  const [actions, setActions] = useState({});
+  const [registeredActionConfigs, setRegisteredActionConfigs] = useState(/* @__PURE__ */ new Map());
+  const chatComponentsCache = useRef({
+    actions: {},
+    coAgentStateRenders: {}
+  });
+  const { addElement, removeElement, printTree, getAllElements } = use_tree_default();
+  const [isLoading, setIsLoading] = useState(false);
+  const [chatInstructions, setChatInstructions] = useState("");
+  const [authStates, setAuthStates] = useState({});
+  const [extensions, setExtensions] = useState({});
+  const [additionalInstructions, setAdditionalInstructions] = useState([]);
+  const {
+    addElement: addDocument,
+    removeElement: removeDocument,
+    allElements: allDocuments
+  } = use_flat_category_store_default();
+  const setAction = useCallback((id, action) => {
+    setActions((prevPoints) => {
+      return __spreadProps(__spreadValues({}, prevPoints), {
+        [id]: action
+      });
+    });
+  }, []);
+  const removeAction = useCallback((id) => {
+    setActions((prevPoints) => {
+      const newPoints = __spreadValues({}, prevPoints);
+      delete newPoints[id];
+      return newPoints;
+    });
+  }, []);
+  const getContextString = 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 = useCallback(
+    (context, parentId, categories = defaultCopilotContextCategories) => {
+      return addElement(context, categories, parentId);
+    },
+    [addElement]
+  );
+  const removeContext = useCallback(
+    (id) => {
+      removeElement(id);
+    },
+    [removeElement]
+  );
+  const getAllContext = useCallback(() => {
+    return getAllElements();
+  }, [getAllElements]);
+  const getFunctionCallHandler = useCallback(
+    (customEntryPoints) => {
+      return entryPointsToFunctionCallHandler(Object.values(customEntryPoints || actions));
+    },
+    [actions]
+  );
+  const getDocumentsContext = useCallback(
+    (categories) => {
+      return allDocuments(categories);
+    },
+    [allDocuments]
+  );
+  const addDocumentContext = useCallback(
+    (documentPointer, categories = defaultCopilotContextCategories) => {
+      return addDocument(documentPointer, categories);
+    },
+    [addDocument]
+  );
+  const removeDocumentContext = useCallback(
+    (documentId) => {
+      removeDocument(documentId);
+    },
+    [removeDocument]
+  );
+  const copilotApiConfig = useMemo(() => {
+    var _a2, _b2;
+    let cloud = void 0;
+    if (publicApiKey) {
+      cloud = {
+        guardrails: {
+          input: {
+            restrictToTopic: {
+              enabled: Boolean(props.guardrails_c),
+              validTopics: ((_a2 = props.guardrails_c) == null ? void 0 : _a2.validTopics) || [],
+              invalidTopics: ((_b2 = props.guardrails_c) == null ? void 0 : _b2.invalidTopics) || []
+            }
+          }
+        }
+      };
+    }
+    return __spreadProps(__spreadValues({
+      publicApiKey
+    }, cloud ? { cloud } : {}), {
+      chatApiEndpoint,
+      headers: props.headers || {},
+      properties: props.properties || {},
+      transcribeAudioUrl: props.transcribeAudioUrl,
+      textToSpeechUrl: props.textToSpeechUrl,
+      credentials: props.credentials
+    });
+  }, [
+    publicApiKey,
+    props.headers,
+    props.properties,
+    props.transcribeAudioUrl,
+    props.textToSpeechUrl,
+    props.credentials,
+    props.cloudRestrictToTopic,
+    props.guardrails_c
+  ]);
+  const headers = 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 ? { [COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: copilotApiConfig.publicApiKey } : {}), authHeaders);
+  }, [copilotApiConfig.headers, copilotApiConfig.publicApiKey, authStates]);
+  const [internalErrorHandlers, _setInternalErrorHandler] = useState({});
+  const setInternalErrorHandler = useCallback((handler) => {
+    _setInternalErrorHandler((prev) => __spreadValues(__spreadValues({}, prev), handler));
+  }, []);
+  const removeInternalErrorHandler = useCallback((key) => {
+    _setInternalErrorHandler((prev) => {
+      const _a2 = prev, { [key]: _removed } = _a2, rest = __objRest(_a2, [__restKey(key)]);
+      return rest;
+    });
+  }, []);
+  const onErrorRef = useRef(props.onError);
+  useEffect(() => {
+    onErrorRef.current = props.onError;
+  }, [props.onError]);
+  const internalHandlersRef = useRef({});
+  useEffect(() => {
+    internalHandlersRef.current = internalErrorHandlers;
+  }, [internalErrorHandlers]);
+  const handleErrors = useCallback(
+    (error) => __async(this, null, function* () {
+      if (copilotApiConfig.publicApiKey && onErrorRef.current) {
+        try {
+          yield onErrorRef.current(error);
+        } catch (e) {
+          console.error("Error in public onError handler:", e);
+        }
+      }
+      const handlers = Object.values(internalHandlersRef.current);
+      yield Promise.all(
+        handlers.map(
+          (h) => Promise.resolve(h(error)).catch(
+            (e) => console.error("Error in internal error handler:", e)
+          )
+        )
+      );
+    }),
+    [copilotApiConfig.publicApiKey]
+  );
+  const [chatSuggestionConfiguration, setChatSuggestionConfiguration] = useState({});
+  const addChatSuggestionConfiguration = useCallback(
+    (id, suggestion) => {
+      setChatSuggestionConfiguration((prev) => __spreadProps(__spreadValues({}, prev), { [id]: suggestion }));
+    },
+    [setChatSuggestionConfiguration]
+  );
+  const removeChatSuggestionConfiguration = useCallback(
+    (id) => {
+      setChatSuggestionConfiguration((prev) => {
+        const _a2 = prev, { [id]: _ } = _a2, rest = __objRest(_a2, [__restKey(id)]);
+        return rest;
+      });
+    },
+    [setChatSuggestionConfiguration]
+  );
+  const [availableAgents, setAvailableAgents] = useState([]);
+  const [coagentStates, setCoagentStates] = useState({});
+  const coagentStatesRef = useRef({});
+  const setCoagentStatesWithRef = useCallback(
+    (value) => {
+      const newValue = typeof value === "function" ? value(coagentStatesRef.current) : value;
+      coagentStatesRef.current = newValue;
+      setCoagentStates((prev) => {
+        return newValue;
+      });
+    },
+    []
+  );
+  let initialAgentSession = null;
+  if (props.agent) {
+    initialAgentSession = {
+      agentName: props.agent
+    };
+  }
+  const [agentSession, setAgentSession] = useState(initialAgentSession);
+  useEffect(() => {
+    if (props.agent) {
+      setAgentSession({
+        agentName: props.agent
+      });
+    } else {
+      setAgentSession(null);
+    }
+  }, [props.agent]);
+  const { threadId, setThreadId: setInternalThreadId } = useThreads();
+  const setThreadId = useCallback(
+    (value) => {
+      if (props.threadId) {
+        throw new Error("Cannot call setThreadId() when threadId is provided via props.");
+      }
+      setInternalThreadId(value);
+    },
+    [props.threadId]
+  );
+  const [runId, setRunId] = useState(null);
+  const chatAbortControllerRef = useRef(null);
+  const showDevConsole = shouldShowDevConsole(props.showDevConsole);
+  const [interruptActions, _setInterruptActions] = useState({});
+  const setInterruptAction = useCallback(
+    (threadId2, action) => {
+      _setInterruptActions((prev) => {
+        var _a2;
+        if (action == null || !action.id) {
+          return prev;
+        }
+        return __spreadProps(__spreadValues({}, prev), {
+          [action.id]: __spreadValues(__spreadValues({}, (_a2 = prev[action.id]) != null ? _a2 : {}), action)
+        });
+      });
+    },
+    []
+  );
+  const removeInterruptAction = useCallback((actionId) => {
+    _setInterruptActions((prev) => {
+      const _a2 = prev, { [actionId]: _ } = _a2, rest = __objRest(_a2, [__restKey(actionId)]);
+      return rest;
+    });
+  }, []);
+  const [interruptEventQueue, setInterruptEventQueue] = useState({});
+  const addInterruptEvent = useCallback((queuedEvent) => {
+    setInterruptEventQueue((prev) => {
+      const threadQueue = prev[queuedEvent.threadId] || [];
+      return __spreadProps(__spreadValues({}, prev), {
+        [queuedEvent.threadId]: [...threadQueue, queuedEvent]
+      });
+    });
+  }, []);
+  const removeInterruptEvent = useCallback((threadId2, eventId) => {
+    setInterruptEventQueue((prev) => {
+      const threadQueue = prev[threadId2] || [];
+      return __spreadProps(__spreadValues({}, prev), {
+        [threadId2]: threadQueue.filter((event) => event.eventId !== eventId)
+      });
+    });
+  }, []);
+  const memoizedChildren = useMemo(() => children, [children]);
+  const [bannerError, setBannerError] = useState(null);
+  const agentLock = useMemo(() => {
+    var _a2;
+    return (_a2 = props.agent) != null ? _a2 : null;
+  }, [props.agent]);
+  const forwardedParameters = useMemo(
+    () => {
+      var _a2;
+      return (_a2 = props.forwardedParameters) != null ? _a2 : {};
+    },
+    [props.forwardedParameters]
+  );
+  const updateExtensions = useCallback(
+    (newExtensions) => {
+      setExtensions((prev) => {
+        const resolved = typeof newExtensions === "function" ? newExtensions(prev) : newExtensions;
+        const isSameLength = Object.keys(resolved).length === Object.keys(prev).length;
+        const isEqual = isSameLength && // @ts-ignore
+        Object.entries(resolved).every(([key, value]) => prev[key] === value);
+        return isEqual ? prev : resolved;
+      });
+    },
+    [setExtensions]
+  );
+  const updateAuthStates = useCallback(
+    (newAuthStates) => {
+      setAuthStates((prev) => {
+        const resolved = typeof newAuthStates === "function" ? newAuthStates(prev) : newAuthStates;
+        const isSameLength = Object.keys(resolved).length === Object.keys(prev).length;
+        const isEqual = isSameLength && // @ts-ignore
+        Object.entries(resolved).every(([key, value]) => prev[key] === value);
+        return isEqual ? prev : resolved;
+      });
+    },
+    [setAuthStates]
+  );
+  const handleSetRegisteredActions = useCallback((actionConfig) => {
+    const key = actionConfig.action.name || randomUUID();
+    setRegisteredActionConfigs((prev) => {
+      const newMap = new Map(prev);
+      newMap.set(key, actionConfig);
+      return newMap;
+    });
+    return key;
+  }, []);
+  const handleRemoveRegisteredAction = useCallback((actionKey) => {
+    setRegisteredActionConfigs((prev) => {
+      const newMap = new Map(prev);
+      newMap.delete(actionKey);
+      return newMap;
+    });
+  }, []);
+  const RegisteredActionsRenderer = useMemo(() => {
+    return () => /* @__PURE__ */ jsx(Fragment, { children: Array.from(registeredActionConfigs.entries()).map(([key, config]) => {
+      const Component = config.component;
+      return /* @__PURE__ */ jsx(Component, { action: config.action }, key);
+    }) });
+  }, [registeredActionConfigs]);
+  return /* @__PURE__ */ jsx(
+    CopilotChatConfigurationProvider,
+    {
+      agentId: (_b = agentSession == null ? void 0 : agentSession.agentName) != null ? _b : "default",
+      threadId,
+      children: /* @__PURE__ */ jsxs(
+        CopilotContext.Provider,
+        {
+          value: {
+            actions,
+            chatComponentsCache,
+            getFunctionCallHandler,
+            setAction,
+            removeAction,
+            setRegisteredActions: handleSetRegisteredActions,
+            removeRegisteredAction: handleRemoveRegisteredAction,
+            getContextString,
+            addContext,
+            removeContext,
+            getAllContext,
+            getDocumentsContext,
+            addDocumentContext,
+            removeDocumentContext,
+            copilotApiConfig,
+            isLoading,
+            setIsLoading,
+            chatSuggestionConfiguration,
+            addChatSuggestionConfiguration,
+            removeChatSuggestionConfiguration,
+            chatInstructions,
+            setChatInstructions,
+            additionalInstructions,
+            setAdditionalInstructions,
+            showDevConsole,
+            coagentStates,
+            setCoagentStates,
+            coagentStatesRef,
+            setCoagentStatesWithRef,
+            agentSession,
+            setAgentSession,
+            forwardedParameters,
+            agentLock,
+            threadId,
+            setThreadId,
+            runId,
+            setRunId,
+            chatAbortControllerRef,
+            availableAgents,
+            authConfig_c: props.authConfig_c,
+            authStates_c: authStates,
+            setAuthStates_c: updateAuthStates,
+            extensions,
+            setExtensions: updateExtensions,
+            interruptActions,
+            setInterruptAction,
+            removeInterruptAction,
+            interruptEventQueue,
+            addInterruptEvent,
+            removeInterruptEvent,
+            bannerError,
+            setBannerError,
+            onError: handleErrors,
+            internalErrorHandlers,
+            setInternalErrorHandler,
+            removeInternalErrorHandler
+          },
+          children: [
+            /* @__PURE__ */ jsx(CopilotListeners, {}),
+            /* @__PURE__ */ jsxs(CoAgentStateRendersProvider, { children: [
+              /* @__PURE__ */ jsx(MessagesTapProvider, { children: /* @__PURE__ */ jsxs(CopilotMessages, { children: [
+                memoizedChildren,
+                showDevConsole && /* @__PURE__ */ jsx(ConsoleTrigger, {}),
+                /* @__PURE__ */ jsx(RegisteredActionsRenderer, {})
+              ] }) }),
+              bannerError && showDevConsole && /* @__PURE__ */ jsx(
+                UsageBanner,
+                {
+                  severity: bannerError.severity,
+                  message: bannerError.message,
+                  onClose: () => setBannerError(null),
+                  actions: getErrorActions(bannerError)
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+var defaultCopilotContextCategories = ["global"];
+function entryPointsToFunctionCallHandler(actions) {
+  return (_0) => __async(this, [_0], function* ({ 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) => {
+        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;
+  });
+}
+function formatFeatureName(featureName) {
+  return featureName.replace(/_c$/, "").split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function validateProps(props) {
+  const cloudFeatures = Object.keys(props).filter((key) => key.endsWith("_c"));
+  const hasApiKey = props.publicApiKey || props.publicLicenseKey;
+  if (!props.runtimeUrl && !hasApiKey) {
+    throw new ConfigurationError(
+      "Missing required prop: 'runtimeUrl' or 'publicApiKey' or 'publicLicenseKey'"
+    );
+  }
+  if (cloudFeatures.length > 0 && !hasApiKey) {
+    throw new MissingPublicApiKeyError(
+      `Missing required prop: 'publicApiKey' or 'publicLicenseKey' to use cloud features: ${cloudFeatures.map(formatFeatureName).join(", ")}`
+    );
+  }
+}
+
+export {
+  CopilotKit,
+  CopilotKitInternal,
+  defaultCopilotContextCategories
+};
+//# sourceMappingURL=chunk-DCHSCK62.mjs.map