@copilotkit/react-core 1.5.0-tyler-reset-chat.0 → 1.5.0

package/src/hooks/use-coagent-state-render.ts

@@ -12,13 +12,13 @@
  * ### Simple Usage
  *
  * ```tsx
- * import { useCoagentStateRender } from "@copilotkit/react-core";
+ * import { useCoAgentStateRender } from "@copilotkit/react-core";
  *
  * type YourAgentState = {
  *   agent_state_property: string;
  * }
  *
- * useCoagentStateRender<YourAgentState>({
+ * useCoAgentStateRender<YourAgentState>({
  *   name: "basic_agent",
  *   nodeName: "optionally_specify_a_specific_node",
  *   render: ({ status, state, nodeName }) => {

package/src/hooks/use-coagent.ts

@@ -97,7 +97,9 @@ import {
 } from "../context";
 import { CoagentState } from "../types/coagent-state";
 import { useCopilotChat } from "./use-copilot-chat";
-import { AgentStateMessage, Message, Role, TextMessage } from "@copilotkit/runtime-client-gql";
+import { Message } from "@copilotkit/runtime-client-gql";
+import { flushSync } from "react-dom";
+import { useAsyncCallback } from "../components/error-boundary/error-utils";
 
 interface WithInternalStateManagementAndInitial<T> {
   /**
@@ -218,8 +220,8 @@ export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentRe
   const generalContext = useCopilotContext();
   const messagesContext = useCopilotMessagesContext();
   const context = { ...generalContext, ...messagesContext };
-  const { coagentStates, setCoagentStates } = context;
-  const { appendMessage } = useCopilotChat();
+  const { coagentStates, coagentStatesRef, setCoagentStatesWithRef } = context;
+  const { appendMessage, runChatCompletion } = useCopilotChat();
 
   const getCoagentState = (coagentStates: Record<string, CoagentState>, name: string) => {
     if (coagentStates[name]) {
@@ -239,19 +241,16 @@ export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentRe
 
   // if we manage state internally, we need to provide a function to set the state
   const setState = (newState: T | ((prevState: T | undefined) => T)) => {
-    setCoagentStates((prevAgentStates) => {
-      let coagentState: CoagentState = getCoagentState(prevAgentStates, name);
+    let coagentState: CoagentState = getCoagentState(coagentStatesRef.current || {}, name);
+    const updatedState =
+      typeof newState === "function" ? (newState as Function)(coagentState.state) : newState;
 
-      const updatedState =
-        typeof newState === "function" ? (newState as Function)(coagentState.state) : newState;
-
-      return {
-        ...prevAgentStates,
-        [name]: {
-          ...coagentState,
-          state: updatedState,
-        },
-      };
+    setCoagentStatesWithRef({
+      ...coagentStatesRef.current,
+      [name]: {
+        ...coagentState,
+        state: updatedState,
+      },
     });
   };
 
@@ -269,25 +268,27 @@ export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentRe
   }, [
     isExternalStateManagement(options) ? JSON.stringify(options.state) : undefined,
     // reset initialstate on reset
-    coagentStates === undefined,
+    coagentStates[name] === undefined,
   ]);
 
+  const runAgentCallback = useAsyncCallback(
+    async (hint?: HintFunction) => {
+      await runAgent(name, context, appendMessage, runChatCompletion, hint);
+    },
+    [name, context, appendMessage, runChatCompletion],
+  );
+
   // Return the state and setState function
   return {
     name,
     nodeName: coagentState.nodeName,
-    state,
-    setState,
+    threadId: coagentState.threadId,
     running: coagentState.running,
-    start: () => {
-      startAgent(name, context);
-    },
-    stop: () => {
-      stopAgent(name, context);
-    },
-    run: (hint?: HintFunction) => {
-      return runAgent(name, context, appendMessage, hint);
-    },
+    state: coagentState.state,
+    setState: isExternalStateManagement(options) ? options.setState : setState,
+    start: () => startAgent(name, context),
+    stop: () => stopAgent(name, context),
+    run: runAgentCallback,
   };
 }
 
@@ -324,6 +325,7 @@ export async function runAgent(
   name: string,
   context: CopilotContextParams & CopilotMessagesContextParams,
   appendMessage: (message: Message) => Promise<void>,
+  runChatCompletion: () => Promise<Message[]>,
   hint?: HintFunction,
 ) {
   const { agentSession, setAgentSession } = context;
@@ -341,12 +343,16 @@ export async function runAgent(
     }
   }
 
-  let state = context.coagentStates?.[name]?.state || {};
+  let state = context.coagentStatesRef.current?.[name]?.state || {};
 
   if (hint) {
     const hintMessage = hint({ previousState, currentState: state });
     if (hintMessage) {
       await appendMessage(hintMessage);
+    } else {
+      await runChatCompletion();
     }
+  } else {
+    await runChatCompletion();
   }
 }

package/src/hooks/use-copilot-action.ts

@@ -71,6 +71,15 @@
  *     );
  *   },
  * });
+ *
+ * @example
+ * // Catch all action allows you to render actions that are not defined in the frontend
+ * useCopilotAction({
+ *   name: "*",
+ *   render: ({ name, args, status, result, handler, respond }) => {
+ *     return <div>Rendering action: {name}</div>;
+ *   },
+ * });
  */
 
 /**
@@ -124,10 +133,12 @@
 import { Parameter, randomId } from "@copilotkit/shared";
 import { createElement, Fragment, useEffect, useRef } from "react";
 import { useCopilotContext } from "../context/copilot-context";
+import { useAsyncCallback } from "../components/error-boundary/error-utils";
 import {
   ActionRenderProps,
   ActionRenderPropsNoArgsWait,
   ActionRenderPropsWait,
+  CatchAllFrontendAction,
   FrontendAction,
 } from "../types/frontend-action";
 
@@ -141,7 +152,7 @@ import {
 // useCallback, useMemo or other memoization techniques are not suitable here,
 // because they will cause a infinite rerender loop.
 export function useCopilotAction<const T extends Parameter[] | [] = []>(
-  action: FrontendAction<T>,
+  action: FrontendAction<T> | CatchAllFrontendAction,
   dependencies?: any[],
 ): void {
   const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();
@@ -151,15 +162,20 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
   // clone the action to avoid mutating the original object
   action = { ...action };
 
-  // If the developer provides a renderAndWait function, we transform the action
+  // If the developer provides a renderAndWaitForResponse function, we transform the action
   // to use a promise internally, so that we can treat it like a normal action.
-  if (action.renderAndWait || action.renderAndWaitForResponse) {
+  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;
     // remove the renderAndWait function from the action
     action.renderAndWait = undefined;
     action.renderAndWaitForResponse = undefined;
     // add a handler that will be called when the action is executed
-    action.handler = (async () => {
+    action.handler = useAsyncCallback(async () => {
       // we create a new promise when the handler is called
       let resolve: (result: any) => void;
       let reject: (error: any) => void;
@@ -170,17 +186,23 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
       renderAndWaitRef.current = { promise, resolve: resolve!, reject: reject! };
       // then we await the promise (it will be resolved in the original renderAndWait function)
       return await promise;
-    }) as any;
+    }, []) as any;
 
     // add a render function that will be called when the action is rendered
     action.render = ((props: ActionRenderProps<T>): React.ReactElement => {
+      // Specifically for renderAndWaitForResponse the executing state is set too early, causing a race condition
+      // To fit it: we will wait for the handler to be ready
+      let status = props.status;
+      if (props.status === "executing" && !renderAndWaitRef.current) {
+        status = "inProgress";
+      }
       // Create type safe waitProps based on whether T extends empty array or not
       const waitProps = {
-        status: props.status,
+        status,
         args: props.args,
         result: props.result,
-        handler: props.status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
-        respond: props.status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
+        handler: status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
+        respond: status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
       } as T extends [] ? ActionRenderPropsNoArgsWait<T> : ActionRenderPropsWait<T>;
 
       // Type guard to check if renderAndWait is for no args case
@@ -211,10 +233,15 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
   // This ensures that any captured variables in the handler are up to date.
   if (dependencies === undefined) {
     if (actions[idRef.current]) {
-      actions[idRef.current].handler = action.handler as any;
+      // catch all actions don't have a handler
+      if (isFrontendAction(action)) {
+        actions[idRef.current].handler = action.handler as any;
+      }
       if (typeof action.render === "function") {
         if (chatComponentsCache.current !== null) {
-          chatComponentsCache.current.actions[action.name] = action.render;
+          // TODO: using as any here because the type definitions are getting to tricky
+          // not wasting time on this now - we know the types are compatible
+          chatComponentsCache.current.actions[action.name] = action.render as any;
         }
       }
     }
@@ -223,23 +250,25 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
   useEffect(() => {
     setAction(idRef.current, action as any);
     if (chatComponentsCache.current !== null && action.render !== undefined) {
-      chatComponentsCache.current.actions[action.name] = action.render;
+      // see comment about type safety above
+      chatComponentsCache.current.actions[action.name] = action.render as any;
     }
     return () => {
       // NOTE: For now, we don't remove the chatComponentsCache entry when the action is removed.
       // This is because we currently don't have access to the messages array in CopilotContext.
+      // UPDATE: We now have access, we should remove the entry if not referenced by any message.
       removeAction(idRef.current);
     };
   }, [
     setAction,
     removeAction,
-    action.description,
+    isFrontendAction(action) ? action.description : undefined,
     action.name,
-    action.disabled,
-    action.available,
+    isFrontendAction(action) ? action.disabled : undefined,
+    isFrontendAction(action) ? action.available : undefined,
     // This should be faster than deep equality checking
     // In addition, all major JS engines guarantee the order of object keys
-    JSON.stringify(action.parameters),
+    JSON.stringify(isFrontendAction(action) ? action.parameters : []),
     // include render only if it's a string
     typeof action.render === "string" ? action.render : undefined,
     // dependencies set by the developer
@@ -247,6 +276,12 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
   ]);
 }
 
+function isFrontendAction<T extends Parameter[]>(
+  action: FrontendAction<T> | CatchAllFrontendAction,
+): action is FrontendAction<T> {
+  return action.name !== "*";
+}
+
 interface RenderAndWaitForResponse {
   promise: Promise<any>;
   resolve: (result: any) => void;

package/src/hooks/use-copilot-chat.ts

@@ -47,6 +47,7 @@ import { defaultCopilotContextCategories } from "../components";
 import { MessageStatusCode } from "@copilotkit/runtime-client-gql";
 import { CoAgentStateRenderHandlerArguments } from "@copilotkit/shared";
 import { useCopilotMessagesContext } from "../context";
+import { useAsyncCallback } from "../components/error-boundary/error-utils";
 
 export interface UseCopilotChatOptions {
   /**
@@ -80,6 +81,7 @@ export interface UseCopilotChatReturn {
   stopGeneration: () => void;
   reset: () => void;
   isLoading: boolean;
+  runChatCompletion: () => Promise<Message[]>;
 }
 
 export function useCopilotChat({
@@ -94,9 +96,8 @@ export function useCopilotChat({
     setIsLoading,
     chatInstructions,
     actions,
-
-    coagentStates,
-    setCoagentStates,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
     coAgentStateRenders,
     agentSession,
     setAgentSession,
@@ -130,7 +131,7 @@ export function useCopilotChat({
     });
   }, [getContextString, makeSystemMessage, chatInstructions]);
 
-  const onCoAgentStateRender = useCallback(
+  const onCoAgentStateRender = useAsyncCallback(
     async (args: CoAgentStateRenderHandlerArguments) => {
       const { name, nodeName, state } = args;
       let action = Object.values(coAgentStateRenders).find(
@@ -148,7 +149,7 @@ export function useCopilotChat({
     [coAgentStateRenders],
   );
 
-  const { append, reload, stop } = useChat({
+  const { append, reload, stop, runChatCompletion } = useChat({
     ...options,
     actions: Object.values(actions),
     copilotConfig: copilotApiConfig,
@@ -160,8 +161,8 @@ export function useCopilotChat({
     makeSystemMessageCallback,
     isLoading,
     setIsLoading,
-    coagentStates,
-    setCoagentStates,
+    coagentStatesRef,
+    setCoagentStatesWithRef,
     agentSession,
     setAgentSession,
     threadId,
@@ -180,16 +181,16 @@ export function useCopilotChat({
   // How does this work?
   // we store the relevant function in a ref that is always up-to-date, and then we use that ref in the callback.
   const latestAppend = useUpdatedRef(append);
-  const latestAppendFunc = useCallback(
-    (message: Message) => {
-      return latestAppend.current(message);
+  const latestAppendFunc = useAsyncCallback(
+    async (message: Message) => {
+      return await latestAppend.current(message);
     },
     [latestAppend],
   );
 
   const latestReload = useUpdatedRef(reload);
-  const latestReloadFunc = useCallback(() => {
-    return latestReload.current();
+  const latestReloadFunc = useAsyncCallback(async () => {
+    return await latestReload.current();
   }, [latestReload]);
 
   const latestStop = useUpdatedRef(stop);
@@ -213,12 +214,17 @@ export function useCopilotChat({
     [latestSetMessages],
   );
 
+  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
+  const latestRunChatCompletionFunc = useAsyncCallback(async () => {
+    return await latestRunChatCompletion.current!();
+  }, [latestRunChatCompletion]);
+
   const reset = useCallback(() => {
     latestStopFunc();
     setMessages([]);
     setThreadId(null);
     setRunId(null);
-    setCoagentStates({});
+    setCoagentStatesWithRef({});
     let initialAgentSession: AgentSession | null = null;
     if (agentLock) {
       initialAgentSession = {
@@ -226,7 +232,14 @@ export function useCopilotChat({
       };
     }
     setAgentSession(initialAgentSession);
-  }, [latestStopFunc, setMessages, setThreadId, setCoagentStates, setAgentSession, agentLock]);
+  }, [
+    latestStopFunc,
+    setMessages,
+    setThreadId,
+    setCoagentStatesWithRef,
+    setAgentSession,
+    agentLock,
+  ]);
 
   const latestReset = useUpdatedRef(reset);
   const latestResetFunc = useCallback(() => {
@@ -241,6 +254,7 @@ export function useCopilotChat({
     stopGeneration: latestStopFunc,
     reset: latestResetFunc,
     deleteMessage: latestDeleteFunc,
+    runChatCompletion: latestRunChatCompletionFunc,
     isLoading,
   };
 }

package/src/hooks/use-copilot-runtime-client.ts

@@ -5,9 +5,11 @@ import {
 } from "@copilotkit/runtime-client-gql";
 import { useToast } from "../components/toast/toast-provider";
 import { useMemo } from "react";
+import { useErrorToast } from "../components/error-boundary/error-utils";
 
 export const useCopilotRuntimeClient = (options: CopilotRuntimeClientOptions) => {
   const { addGraphQLErrorsToast } = useToast();
+  const addErrorToast = useErrorToast();
 
   const runtimeClient = useMemo(() => {
     return new CopilotRuntimeClient({
@@ -15,6 +17,8 @@ export const useCopilotRuntimeClient = (options: CopilotRuntimeClientOptions) =>
       handleGQLErrors: (error) => {
         if ((error as any).graphQLErrors.length) {
           addGraphQLErrorsToast((error as any).graphQLErrors as GraphQLError[]);
+        } else {
+          addErrorToast([error]);
         }
       },
     });

package/src/lib/copilot-task.ts

@@ -57,11 +57,9 @@ import {
   filterAgentStateMessages,
   CopilotRequestType,
 } from "@copilotkit/runtime-client-gql";
-import { FrontendAction } from "../types/frontend-action";
+import { FrontendAction, processActionsForRuntimeRequest } from "../types/frontend-action";
 import { CopilotContextParams } from "../context";
 import { defaultCopilotContextCategories } from "../components";
-import { MessageStatusCode } from "@copilotkit/runtime-client-gql";
-import { actionParametersToJsonSchema } from "@copilotkit/shared";
 
 export interface CopilotTaskConfig {
   /**
@@ -137,11 +135,7 @@ export class CopilotTask<T = any> {
       .generateCopilotResponse({
         data: {
           frontend: {
-            actions: Object.values(actions).map((action) => ({
-              name: action.name,
-              description: action.description || "",
-              jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters || [])),
-            })),
+            actions: processActionsForRuntimeRequest(Object.values(actions)),
             url: window.location.href,
           },
           messages: convertMessagesToGqlInput(filterAgentStateMessages(messages)),

package/src/types/frontend-action.ts

@@ -1,4 +1,10 @@
-import { Action, Parameter, MappedParameterTypes } from "@copilotkit/shared";
+import { ActionInputAvailability } from "@copilotkit/runtime-client-gql";
+import {
+  Action,
+  Parameter,
+  MappedParameterTypes,
+  actionParametersToJsonSchema,
+} from "@copilotkit/shared";
 import React from "react";
 
 interface InProgressState<T extends Parameter[] | [] = []> {
@@ -110,9 +116,24 @@ export type ActionRenderPropsNoArgsWait<T extends Parameter[] | [] = []> =
   | ExecutingStateNoArgsWait<T>
   | InProgressStateNoArgsWait<T>;
 
+export type CatchAllActionRenderProps<T extends Parameter[] | [] = []> =
+  | (CompleteState<T> & {
+      name: string;
+    })
+  | (ExecutingState<T> & {
+      name: string;
+    })
+  | (InProgressState<T> & {
+      name: string;
+    });
+
 export type FrontendActionAvailability = "disabled" | "enabled" | "remote";
 
-export type FrontendAction<T extends Parameter[] | [] = []> = Action<T> & {
+export type FrontendAction<
+  T extends Parameter[] | [] = [],
+  N extends string = string,
+> = Action<T> & {
+  name: Exclude<N, "*">;
   /**
    * @deprecated Use `available` instead.
    */
@@ -143,4 +164,36 @@ export type FrontendAction<T extends Parameter[] | [] = []> = Action<T> & {
       }
   );
 
+export type CatchAllFrontendAction = {
+  name: "*";
+  render: (props: CatchAllActionRenderProps<any>) => React.ReactElement;
+};
+
 export type RenderFunctionStatus = ActionRenderProps<any>["status"];
+
+export function processActionsForRuntimeRequest(actions: FrontendAction<any>[]) {
+  const filteredActions = actions
+    .filter(
+      (action) =>
+        action.available !== ActionInputAvailability.Disabled &&
+        action.disabled !== true &&
+        action.name !== "*",
+    )
+    .map((action) => {
+      let available: ActionInputAvailability | undefined = ActionInputAvailability.Enabled;
+      if (action.disabled) {
+        available = ActionInputAvailability.Disabled;
+      } else if (action.available === "disabled") {
+        available = ActionInputAvailability.Disabled;
+      } else if (action.available === "remote") {
+        available = ActionInputAvailability.Remote;
+      }
+      return {
+        name: action.name,
+        description: action.description || "",
+        jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters || [])),
+        available,
+      };
+    });
+  return filteredActions;
+}

package/src/types/index.ts

@@ -1,4 +1,8 @@
 export type { DocumentPointer } from "./document-pointer";
 export type { SystemMessageFunction } from "./system-message";
-export type { ActionRenderProps, RenderFunctionStatus } from "./frontend-action";
+export type {
+  ActionRenderProps,
+  RenderFunctionStatus,
+  CatchAllActionRenderProps,
+} from "./frontend-action";
 export type { CopilotChatSuggestionConfiguration } from "./chat-suggestion-configuration";

package/dist/chunk-2JP64U3A.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/context/copilot-context.tsx"],"sourcesContent":["import { CopilotCloudConfig, FunctionCallHandler } from \"@copilotkit/shared\";\nimport { ActionRenderProps, FrontendAction } from \"../types/frontend-action\";\nimport React from \"react\";\nimport { TreeNodeId } from \"../hooks/use-tree\";\nimport { DocumentPointer } from \"../types\";\nimport { CopilotChatSuggestionConfiguration } from \"../types/chat-suggestion-configuration\";\nimport { CoAgentStateRender, CoAgentStateRenderProps } from \"../types/coagent-action\";\nimport { CoagentState } from \"../types/coagent-state\";\nimport { CopilotRuntimeClient } from \"@copilotkit/runtime-client-gql\";\n\n/**\n * Interface for the configuration of the Copilot API.\n */\nexport interface CopilotApiConfig {\n  /**\n   * The public API key for Copilot Cloud.\n   */\n  publicApiKey?: string;\n\n  /**\n   * The configuration for Copilot Cloud.\n   */\n  cloud?: CopilotCloudConfig;\n\n  /**\n   * The endpoint for the chat API.\n   */\n  chatApiEndpoint: string;\n\n  /**\n   * The endpoint for the Copilot transcribe audio service.\n   */\n  transcribeAudioUrl?: string;\n\n  /**\n   * The endpoint for the Copilot text to speech service.\n   */\n  textToSpeechUrl?: string;\n\n  /**\n   * additional headers to be sent with the request\n   * @default {}\n   * @example\n   * ```\n   * {\n   *   'Authorization': 'Bearer your_token_here'\n   * }\n   * ```\n   */\n  headers: Record<string, string>;\n\n  /**\n   * Custom properties to be sent with the request\n   * @default {}\n   * @example\n   * ```\n   * {\n   *   'user_id': 'user_id'\n   * }\n   * ```\n   */\n  properties?: Record<string, any>;\n\n  /**\n   * Indicates whether the user agent should send or receive cookies from the other domain\n   * in the case of cross-origin requests.\n   */\n  credentials?: RequestCredentials;\n}\n\nexport type InChatRenderFunction = (props: ActionRenderProps<any>) => string | JSX.Element;\nexport type CoagentInChatRenderFunction = (\n  props: CoAgentStateRenderProps<any>,\n) => string | JSX.Element | undefined | null;\n\nexport interface ChatComponentsCache {\n  actions: Record<string, InChatRenderFunction | string>;\n  coAgentStateRenders: Record<string, CoagentInChatRenderFunction | string>;\n}\n\nexport interface AgentSession {\n  agentName: string;\n  threadId?: string;\n  nodeName?: string;\n}\n\nexport interface CopilotContextParams {\n  // function-calling\n  actions: Record<string, FrontendAction<any>>;\n  setAction: (id: string, action: FrontendAction<any>) => void;\n  removeAction: (id: string) => void;\n\n  // coagent actions\n  coAgentStateRenders: Record<string, CoAgentStateRender<any>>;\n  setCoAgentStateRender: (id: string, stateRender: CoAgentStateRender<any>) => void;\n  removeCoAgentStateRender: (id: string) => void;\n\n  chatComponentsCache: React.RefObject<ChatComponentsCache>;\n\n  getFunctionCallHandler: (\n    customEntryPoints?: Record<string, FrontendAction<any>>,\n  ) => FunctionCallHandler;\n\n  // text context\n  addContext: (context: string, parentId?: string, categories?: string[]) => TreeNodeId;\n  removeContext: (id: TreeNodeId) => void;\n  getContextString: (documents: DocumentPointer[], categories: string[]) => string;\n\n  // document context\n  addDocumentContext: (documentPointer: DocumentPointer, categories?: string[]) => TreeNodeId;\n  removeDocumentContext: (documentId: string) => void;\n  getDocumentsContext: (categories: string[]) => DocumentPointer[];\n\n  isLoading: boolean;\n  setIsLoading: React.Dispatch<React.SetStateAction<boolean>>;\n\n  chatSuggestionConfiguration: { [key: string]: CopilotChatSuggestionConfiguration };\n  addChatSuggestionConfiguration: (\n    id: string,\n    suggestion: CopilotChatSuggestionConfiguration,\n  ) => void;\n  removeChatSuggestionConfiguration: (id: string) => void;\n\n  chatInstructions: string;\n  setChatInstructions: React.Dispatch<React.SetStateAction<string>>;\n\n  // api endpoints\n  copilotApiConfig: CopilotApiConfig;\n\n  showDevConsole: boolean | \"auto\";\n\n  // agents\n  coagentStates: Record<string, CoagentState>;\n  setCoagentStates: React.Dispatch<React.SetStateAction<Record<string, CoagentState>>>;\n  agentSession: AgentSession | null;\n  setAgentSession: React.Dispatch<React.SetStateAction<AgentSession | null>>;\n\n  agentLock: string | null;\n\n  threadId: string | null;\n  setThreadId: React.Dispatch<React.SetStateAction<string | null>>;\n\n  runId: string | null;\n  setRunId: React.Dispatch<React.SetStateAction<string | null>>;\n\n  // The chat abort controller can be used to stop generation globally,\n  // i.e. when using `stop()` from `useChat`\n  chatAbortControllerRef: React.MutableRefObject<AbortController | null>;\n\n  // runtime\n  runtimeClient: CopilotRuntimeClient;\n}\n\nconst emptyCopilotContext: CopilotContextParams = {\n  actions: {},\n  setAction: () => {},\n  removeAction: () => {},\n\n  coAgentStateRenders: {},\n  setCoAgentStateRender: () => {},\n  removeCoAgentStateRender: () => {},\n\n  chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },\n  getContextString: (documents: DocumentPointer[], categories: string[]) =>\n    returnAndThrowInDebug(\"\"),\n  addContext: () => \"\",\n  removeContext: () => {},\n\n  getFunctionCallHandler: () => returnAndThrowInDebug(async () => {}),\n\n  isLoading: false,\n  setIsLoading: () => returnAndThrowInDebug(false),\n\n  chatInstructions: \"\",\n  setChatInstructions: () => returnAndThrowInDebug(\"\"),\n\n  getDocumentsContext: (categories: string[]) => returnAndThrowInDebug([]),\n  addDocumentContext: () => returnAndThrowInDebug(\"\"),\n  removeDocumentContext: () => {},\n  runtimeClient: {} as any,\n\n  copilotApiConfig: new (class implements CopilotApiConfig {\n    get chatApiEndpoint(): string {\n      throw new Error(\"Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!\");\n    }\n\n    get headers(): Record<string, string> {\n      return {};\n    }\n    get body(): Record<string, any> {\n      return {};\n    }\n  })(),\n\n  chatSuggestionConfiguration: {},\n  addChatSuggestionConfiguration: () => {},\n  removeChatSuggestionConfiguration: () => {},\n  showDevConsole: \"auto\",\n  coagentStates: {},\n  setCoagentStates: () => {},\n\n  agentSession: null,\n  setAgentSession: () => {},\n\n  agentLock: null,\n\n  threadId: null,\n  setThreadId: () => {},\n\n  runId: null,\n  setRunId: () => {},\n\n  chatAbortControllerRef: { current: null },\n};\n\nexport const CopilotContext = React.createContext<CopilotContextParams>(emptyCopilotContext);\n\nexport function useCopilotContext(): CopilotContextParams {\n  const context = React.useContext(CopilotContext);\n  if (context === emptyCopilotContext) {\n    throw new Error(\"Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!\");\n  }\n  return context;\n}\n\nfunction returnAndThrowInDebug<T>(value: T): T {\n  throw new Error(\"Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!\");\n  return value;\n}\n"],"mappings":";;;;;AAEA,OAAO,WAAW;AAuJlB,IAAM,sBAA4C;AAAA,EAChD,SAAS,CAAC;AAAA,EACV,WAAW,MAAM;AAAA,EAAC;AAAA,EAClB,cAAc,MAAM;AAAA,EAAC;AAAA,EAErB,qBAAqB,CAAC;AAAA,EACtB,uBAAuB,MAAM;AAAA,EAAC;AAAA,EAC9B,0BAA0B,MAAM;AAAA,EAAC;AAAA,EAEjC,qBAAqB,EAAE,SAAS,EAAE,SAAS,CAAC,GAAG,qBAAqB,CAAC,EAAE,EAAE;AAAA,EACzE,kBAAkB,CAAC,WAA8B,eAC/C,sBAAsB,EAAE;AAAA,EAC1B,YAAY,MAAM;AAAA,EAClB,eAAe,MAAM;AAAA,EAAC;AAAA,EAEtB,wBAAwB,MAAM,sBAAsB,MAAY;AAAA,EAAC,EAAC;AAAA,EAElE,WAAW;AAAA,EACX,cAAc,MAAM,sBAAsB,KAAK;AAAA,EAE/C,kBAAkB;AAAA,EAClB,qBAAqB,MAAM,sBAAsB,EAAE;AAAA,EAEnD,qBAAqB,CAAC,eAAyB,sBAAsB,CAAC,CAAC;AAAA,EACvE,oBAAoB,MAAM,sBAAsB,EAAE;AAAA,EAClD,uBAAuB,MAAM;AAAA,EAAC;AAAA,EAC9B,eAAe,CAAC;AAAA,EAEhB,kBAAkB,IAAK,MAAkC;AAAA,IACvD,IAAI,kBAA0B;AAC5B,YAAM,IAAI,MAAM,uEAAuE;AAAA,IACzF;AAAA,IAEA,IAAI,UAAkC;AACpC,aAAO,CAAC;AAAA,IACV;AAAA,IACA,IAAI,OAA4B;AAC9B,aAAO,CAAC;AAAA,IACV;AAAA,EACF,EAAG;AAAA,EAEH,6BAA6B,CAAC;AAAA,EAC9B,gCAAgC,MAAM;AAAA,EAAC;AAAA,EACvC,mCAAmC,MAAM;AAAA,EAAC;AAAA,EAC1C,gBAAgB;AAAA,EAChB,eAAe,CAAC;AAAA,EAChB,kBAAkB,MAAM;AAAA,EAAC;AAAA,EAEzB,cAAc;AAAA,EACd,iBAAiB,MAAM;AAAA,EAAC;AAAA,EAExB,WAAW;AAAA,EAEX,UAAU;AAAA,EACV,aAAa,MAAM;AAAA,EAAC;AAAA,EAEpB,OAAO;AAAA,EACP,UAAU,MAAM;AAAA,EAAC;AAAA,EAEjB,wBAAwB,EAAE,SAAS,KAAK;AAC1C;AAEO,IAAM,iBAAiB,MAAM,cAAoC,mBAAmB;AAEpF,SAAS,oBAA0C;AACxD,QAAM,UAAU,MAAM,WAAW,cAAc;AAC/C,MAAI,YAAY,qBAAqB;AACnC,UAAM,IAAI,MAAM,uEAAuE;AAAA,EACzF;AACA,SAAO;AACT;AAEA,SAAS,sBAAyB,OAAa;AAC7C,QAAM,IAAI,MAAM,uEAAuE;AACvF,SAAO;AACT;","names":[]}

package/dist/chunk-2KCEHGSI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/toast/toast-provider.tsx"],"sourcesContent":["import { useCopilotContext } from \"../../context\";\nimport { GraphQLError } from \"@copilotkit/runtime-client-gql\";\nimport React, { createContext, useContext, useState, useCallback } from \"react\";\nimport { ExclamationMarkIcon } from \"./exclamation-mark-icon\";\n\ninterface Toast {\n  id: string;\n  message: string | React.ReactNode;\n  type: \"info\" | \"success\" | \"warning\" | \"error\";\n  duration?: number;\n}\n\ninterface ToastContextValue {\n  toasts: Toast[];\n  addToast: (toast: Omit<Toast, \"id\">) => void;\n  addGraphQLErrorsToast: (errors: GraphQLError[]) => void;\n  removeToast: (id: string) => void;\n  enabled: boolean;\n}\n\nconst ToastContext = createContext<ToastContextValue | undefined>(undefined);\n\nexport function useToast() {\n  const context = useContext(ToastContext);\n  if (!context) {\n    throw new Error(\"useToast must be used within a ToastProvider\");\n  }\n  return context;\n}\n\nexport function ToastProvider({\n  enabled,\n  children,\n}: {\n  enabled: boolean;\n  children: React.ReactNode;\n}) {\n  const [toasts, setToasts] = useState<Toast[]>([]);\n  const addToast = useCallback((toast: Omit<Toast, \"id\">) => {\n    const id = Math.random().toString(36).substring(2, 9);\n\n    setToasts((currentToasts) => [...currentToasts, { ...toast, id }]);\n\n    if (toast.duration) {\n      setTimeout(() => {\n        removeToast(id);\n      }, toast.duration);\n    }\n  }, []);\n\n  const addGraphQLErrorsToast = useCallback((errors: GraphQLError[]) => {\n    // We do not display these errors unless we are in dev mode.\n    // if (!showDevConsole) {\n    //   return;\n    // }\n\n    const errorsToRender = errors.map((error, idx) => {\n      const message = error.message;\n      const code = error.extensions?.code as string;\n\n      return (\n        <div\n          key={idx}\n          style={{\n            marginTop: idx === 0 ? 0 : 10,\n            marginBottom: 14,\n          }}\n        >\n          <ExclamationMarkIcon style={{ marginBottom: 4 }} />\n\n          {code && (\n            <div\n              style={{\n                fontWeight: \"600\",\n                marginBottom: 4,\n              }}\n            >\n              Copilot Cloud Error:{\" \"}\n              <span style={{ fontFamily: \"monospace\", fontWeight: \"normal\" }}>{code}</span>\n            </div>\n          )}\n          <div>{message}</div>\n        </div>\n      );\n    });\n\n    addToast({\n      type: \"error\",\n      message: (\n        <div\n          style={{\n            fontSize: \"13px\",\n            maxWidth: \"600px\",\n          }}\n        >\n          {errorsToRender}\n          <div style={{ fontSize: \"11px\", opacity: 0.75 }}>\n            NOTE: This is a Copilot Cloud error, and it only displays during local development.\n          </div>\n        </div>\n      ),\n    });\n  }, []);\n\n  const removeToast = useCallback((id: string) => {\n    setToasts((currentToasts) => currentToasts.filter((toast) => toast.id !== id));\n  }, []);\n\n  const value = {\n    toasts,\n    addToast,\n    addGraphQLErrorsToast,\n    removeToast,\n    enabled,\n  };\n\n  return (\n    <ToastContext.Provider value={value}>\n      <div\n        style={{\n          position: \"fixed\",\n          bottom: \"1rem\",\n          left: \"50%\",\n          transform: \"translateX(-50%)\",\n          zIndex: 50,\n          display: \"flex\",\n          flexDirection: \"column\",\n          gap: \"0.5rem\",\n        }}\n      >\n        {toasts.length > 1 && (\n          <div style={{ textAlign: \"right\" }}>\n            <button\n              onClick={() => setToasts([])}\n              style={{\n                padding: \"4px 8px\",\n                fontSize: \"12px\",\n                cursor: \"pointer\",\n                background: \"white\",\n                border: \"1px solid rgba(0,0,0,0.2)\",\n                borderRadius: \"4px\",\n              }}\n            >\n              Close All\n            </button>\n          </div>\n        )}\n        {toasts.map((toast) => (\n          <Toast\n            key={toast.id}\n            message={toast.message}\n            type={toast.type}\n            onClose={() => removeToast(toast.id)}\n          />\n        ))}\n      </div>\n      {children}\n    </ToastContext.Provider>\n  );\n}\n\nfunction Toast({\n  message,\n  type = \"info\",\n  onClose,\n}: {\n  message: string | React.ReactNode;\n  type: \"info\" | \"success\" | \"warning\" | \"error\";\n  onClose: () => void;\n}) {\n  const bgColors = {\n    info: \"#3b82f6\",\n    success: \"#22c55e\",\n    warning: \"#eab308\",\n    error: \"#ef4444\",\n  };\n\n  return (\n    <div\n      style={{\n        backgroundColor: bgColors[type],\n        color: \"white\",\n        padding: \"0.5rem 1rem\",\n        borderRadius: \"0.25rem\",\n        boxShadow: \"0 2px 4px rgba(0,0,0,0.1)\",\n        position: \"relative\",\n        minWidth: \"200px\",\n      }}\n    >\n      <div>{message}</div>\n      <button\n        onClick={onClose}\n        style={{\n          position: \"absolute\",\n          top: \"0\",\n          right: \"0\",\n          background: \"none\",\n          border: \"none\",\n          color: \"white\",\n          cursor: \"pointer\",\n          padding: \"0.5rem\",\n          fontSize: \"1rem\",\n        }}\n      >\n        ✕\n      </button>\n    </div>\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-3R4J2TPH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/use-copilot-action.ts"],"sourcesContent":["/**\n * Example usage of useCopilotAction with complex parameters:\n *\n * @example\n * useCopilotAction({\n *   name: \"myAction\",\n *   parameters: [\n *     { name: \"arg1\", type: \"string\", enum: [\"option1\", \"option2\", \"option3\"], required: false },\n *     { name: \"arg2\", type: \"number\" },\n *     {\n *       name: \"arg3\",\n *       type: \"object\",\n *       attributes: [\n *         { name: \"nestedArg1\", type: \"boolean\" },\n *         { name: \"xyz\", required: false },\n *       ],\n *     },\n *     { name: \"arg4\", type: \"number[]\" },\n *   ],\n *   handler: ({ arg1, arg2, arg3, arg4 }) => {\n *     const x = arg3.nestedArg1;\n *     const z = arg3.xyz;\n *     console.log(arg1, arg2, arg3);\n *   },\n * });\n *\n * @example\n * // Simple action without parameters\n * useCopilotAction({\n *   name: \"myAction\",\n *   handler: () => {\n *     console.log(\"No parameters provided.\");\n *   },\n * });\n *\n * @example\n * // Interactive action with UI rendering and response handling\n * useCopilotAction({\n *   name: \"handleMeeting\",\n *   description: \"Handle a meeting by booking or canceling\",\n *   parameters: [\n *     {\n *       name: \"meeting\",\n *       type: \"string\",\n *       description: \"The meeting to handle\",\n *       required: true,\n *     },\n *     {\n *       name: \"date\",\n *       type: \"string\",\n *       description: \"The date of the meeting\",\n *       required: true,\n *     },\n *     {\n *       name: \"title\",\n *       type: \"string\",\n *       description: \"The title of the meeting\",\n *       required: true,\n *     },\n *   ],\n *   renderAndWaitForResponse: ({ args, respond, status }) => {\n *     const { meeting, date, title } = args;\n *     return (\n *       <MeetingConfirmationDialog\n *         meeting={meeting}\n *         date={date}\n *         title={title}\n *         onConfirm={() => respond('meeting confirmed')}\n *         onCancel={() => respond('meeting canceled')}\n *       />\n *     );\n *   },\n * });\n */\n\n/**\n * <img src=\"/images/use-copilot-action/useCopilotAction.gif\" width=\"500\" />\n * `useCopilotAction` is a React hook that you can use in your application to provide\n * custom actions that can be called by the AI. Essentially, it allows the Copilot to\n * execute these actions contextually during a chat, based on the user's interactions\n * and needs.\n *\n * Here's how it works:\n *\n * Use `useCopilotAction` to set up actions that the Copilot can call. To provide\n * more context to the Copilot, you can provide it with a `description` (for example to explain\n * what the action does, under which conditions it can be called, etc.).\n *\n * Then you define the parameters of the action, which can be simple, e.g. primitives like strings or numbers,\n * or complex, e.g. objects or arrays.\n *\n * Finally, you provide a `handler` function that receives the parameters and returns a result.\n * CopilotKit takes care of automatically inferring the parameter types, so you get type safety\n * and autocompletion for free.\n *\n * To render a custom UI for the action, you can provide a `render()` function. This function\n * lets you render a custom component or return a string to display.\n *\n * ## Usage\n *\n * ### Simple Usage\n *\n * ```tsx\n * useCopilotAction({\n *   name: \"sayHello\",\n *   description: \"Say hello to someone.\",\n *   parameters: [\n *     {\n *       name: \"name\",\n *       type: \"string\",\n *       description: \"name of the person to say greet\",\n *     },\n *   ],\n *   handler: async ({ name }) => {\n *     alert(`Hello, ${name}!`);\n *   },\n * });\n * ```\n *\n * ## Generative UI\n *\n * This hooks enables you to dynamically generate UI elements and render them in the copilot chat. For more information, check out the [Generative UI](/guides/generative-ui) page.\n */\nimport { Parameter, randomId } from \"@copilotkit/shared\";\nimport { createElement, Fragment, useEffect, useRef } from \"react\";\nimport { useCopilotContext } from \"../context/copilot-context\";\nimport {\n  ActionRenderProps,\n  ActionRenderPropsNoArgsWait,\n  ActionRenderPropsWait,\n  FrontendAction,\n} from \"../types/frontend-action\";\n\n// We implement useCopilotAction dependency handling so that\n// the developer has the option to not provide any dependencies.\n// In this case, we assume they want to update the handler on each rerender.\n// To avoid getting stuck in an infinite loop, we update the handler directly,\n// skipping React state updates.\n// This is ok in this case, because the handler is not part of any UI that\n// needs to be updated.\n// useCallback, useMemo or other memoization techniques are not suitable here,\n// because they will cause a infinite rerender loop.\nexport function useCopilotAction<const T extends Parameter[] | [] = []>(\n  action: FrontendAction<T>,\n  dependencies?: any[],\n): void {\n  const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();\n  const idRef = useRef<string>(randomId());\n  const renderAndWaitRef = useRef<RenderAndWaitForResponse | null>(null);\n\n  // clone the action to avoid mutating the original object\n  action = { ...action };\n\n  // If the developer provides a renderAndWait function, we transform the action\n  // to use a promise internally, so that we can treat it like a normal action.\n  if (action.renderAndWait || action.renderAndWaitForResponse) {\n    const renderAndWait = action.renderAndWait || action.renderAndWaitForResponse;\n    // remove the renderAndWait function from the action\n    action.renderAndWait = undefined;\n    action.renderAndWaitForResponse = undefined;\n    // add a handler that will be called when the action is executed\n    action.handler = (async () => {\n      // we create a new promise when the handler is called\n      let resolve: (result: any) => void;\n      let reject: (error: any) => void;\n      const promise = new Promise<any>((resolvePromise, rejectPromise) => {\n        resolve = resolvePromise;\n        reject = rejectPromise;\n      });\n      renderAndWaitRef.current = { promise, resolve: resolve!, reject: reject! };\n      // then we await the promise (it will be resolved in the original renderAndWait function)\n      return await promise;\n    }) as any;\n\n    // add a render function that will be called when the action is rendered\n    action.render = ((props: ActionRenderProps<T>): React.ReactElement => {\n      // Create type safe waitProps based on whether T extends empty array or not\n      const waitProps = {\n        status: props.status,\n        args: props.args,\n        result: props.result,\n        handler: props.status === \"executing\" ? renderAndWaitRef.current!.resolve : undefined,\n        respond: props.status === \"executing\" ? renderAndWaitRef.current!.resolve : undefined,\n      } as T extends [] ? ActionRenderPropsNoArgsWait<T> : ActionRenderPropsWait<T>;\n\n      // Type guard to check if renderAndWait is for no args case\n      const isNoArgsRenderWait = (\n        _fn:\n          | ((props: ActionRenderPropsNoArgsWait<T>) => React.ReactElement)\n          | ((props: ActionRenderPropsWait<T>) => React.ReactElement),\n      ): _fn is (props: ActionRenderPropsNoArgsWait<T>) => React.ReactElement => {\n        return action.parameters?.length === 0;\n      };\n\n      // Safely call renderAndWait with correct props type\n      if (renderAndWait) {\n        if (isNoArgsRenderWait(renderAndWait)) {\n          return renderAndWait(waitProps as ActionRenderPropsNoArgsWait<T>);\n        } else {\n          return renderAndWait(waitProps as ActionRenderPropsWait<T>);\n        }\n      }\n\n      // Return empty Fragment instead of null\n      return createElement(Fragment);\n    }) as any;\n  }\n\n  // If the developer doesn't provide dependencies, we assume they want to\n  // update handler and render function when the action object changes.\n  // This ensures that any captured variables in the handler are up to date.\n  if (dependencies === undefined) {\n    if (actions[idRef.current]) {\n      actions[idRef.current].handler = action.handler as any;\n      if (typeof action.render === \"function\") {\n        if (chatComponentsCache.current !== null) {\n          chatComponentsCache.current.actions[action.name] = action.render;\n        }\n      }\n    }\n  }\n\n  useEffect(() => {\n    setAction(idRef.current, action as any);\n    if (chatComponentsCache.current !== null && action.render !== undefined) {\n      chatComponentsCache.current.actions[action.name] = action.render;\n    }\n    return () => {\n      // NOTE: For now, we don't remove the chatComponentsCache entry when the action is removed.\n      // This is because we currently don't have access to the messages array in CopilotContext.\n      removeAction(idRef.current);\n    };\n  }, [\n    setAction,\n    removeAction,\n    action.description,\n    action.name,\n    action.disabled,\n    action.available,\n    // This should be faster than deep equality checking\n    // In addition, all major JS engines guarantee the order of object keys\n    JSON.stringify(action.parameters),\n    // include render only if it's a string\n    typeof action.render === \"string\" ? action.render : undefined,\n    // dependencies set by the developer\n    ...(dependencies || []),\n  ]);\n}\n\ninterface RenderAndWaitForResponse {\n  promise: Promise<any>;\n  resolve: (result: any) => void;\n  reject: (error: any) => void;\n}\n"],"mappings":";;;;;;;;;AA2HA,SAAoB,gBAAgB;AACpC,SAAS,eAAe,UAAU,WAAW,cAAc;AAkBpD,SAAS,iBACd,QACA,cACM;AACN,QAAM,EAAE,WAAW,cAAc,SAAS,oBAAoB,IAAI,kBAAkB;AACpF,QAAM,QAAQ,OAAe,SAAS,CAAC;AACvC,QAAM,mBAAmB,OAAwC,IAAI;AAGrE,WAAS,mBAAK;AAId,MAAI,OAAO,iBAAiB,OAAO,0BAA0B;AAC3D,UAAM,gBAAgB,OAAO,iBAAiB,OAAO;AAErD,WAAO,gBAAgB;AACvB,WAAO,2BAA2B;AAElC,WAAO,UAAW,MAAY;AAE5B,UAAI;AACJ,UAAI;AACJ,YAAM,UAAU,IAAI,QAAa,CAAC,gBAAgB,kBAAkB;AAClE,kBAAU;AACV,iBAAS;AAAA,MACX,CAAC;AACD,uBAAiB,UAAU,EAAE,SAAS,SAAmB,OAAgB;AAEzE,aAAO,MAAM;AAAA,IACf;AAGA,WAAO,SAAU,CAAC,UAAoD;AAEpE,YAAM,YAAY;AAAA,QAChB,QAAQ,MAAM;AAAA,QACd,MAAM,MAAM;AAAA,QACZ,QAAQ,MAAM;AAAA,QACd,SAAS,MAAM,WAAW,cAAc,iBAAiB,QAAS,UAAU;AAAA,QAC5E,SAAS,MAAM,WAAW,cAAc,iBAAiB,QAAS,UAAU;AAAA,MAC9E;AAGA,YAAM,qBAAqB,CACzB,QAGyE;AA9LjF;AA+LQ,iBAAO,YAAO,eAAP,mBAAmB,YAAW;AAAA,MACvC;AAGA,UAAI,eAAe;AACjB,YAAI,mBAAmB,aAAa,GAAG;AACrC,iBAAO,cAAc,SAA2C;AAAA,QAClE,OAAO;AACL,iBAAO,cAAc,SAAqC;AAAA,QAC5D;AAAA,MACF;AAGA,aAAO,cAAc,QAAQ;AAAA,IAC/B;AAAA,EACF;AAKA,MAAI,iBAAiB,QAAW;AAC9B,QAAI,QAAQ,MAAM,OAAO,GAAG;AAC1B,cAAQ,MAAM,OAAO,EAAE,UAAU,OAAO;AACxC,UAAI,OAAO,OAAO,WAAW,YAAY;AACvC,YAAI,oBAAoB,YAAY,MAAM;AACxC,8BAAoB,QAAQ,QAAQ,OAAO,IAAI,IAAI,OAAO;AAAA,QAC5D;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,YAAU,MAAM;AACd,cAAU,MAAM,SAAS,MAAa;AACtC,QAAI,oBAAoB,YAAY,QAAQ,OAAO,WAAW,QAAW;AACvE,0BAAoB,QAAQ,QAAQ,OAAO,IAAI,IAAI,OAAO;AAAA,IAC5D;AACA,WAAO,MAAM;AAGX,mBAAa,MAAM,OAAO;AAAA,IAC5B;AAAA,EACF,GAAG;AAAA,IACD;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,OAAO;AAAA,IACP,OAAO;AAAA,IACP,OAAO;AAAA;AAAA;AAAA,IAGP,KAAK,UAAU,OAAO,UAAU;AAAA;AAAA,IAEhC,OAAO,OAAO,WAAW,WAAW,OAAO,SAAS;AAAA;AAAA,IAEpD,GAAI,gBAAgB,CAAC;AAAA,EACvB,CAAC;AACH;","names":[]}