@copilotkit/react-core 1.9.3 → 1.10.0-next.0

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

@@ -27,6 +27,37 @@
  * }
  * ```
  *
+ * ### Working with Suggestions
+ *
+ * ```tsx
+ * import { useCopilotChat, useCopilotChatSuggestions } from "@copilotkit/react-core";
+ *
+ * export function YourComponent() {
+ *   const {
+ *     suggestions,
+ *     setSuggestions,
+ *     generateSuggestions,
+ *     isLoadingSuggestions
+ *   } = useCopilotChat();
+ *
+ *   // Configure AI suggestion generation
+ *   useCopilotChatSuggestions({
+ *     instructions: "Suggest helpful actions based on the current context",
+ *     maxSuggestions: 3
+ *   });
+ *
+ *   // Manual suggestion control
+ *   const handleCustomSuggestion = () => {
+ *     setSuggestions([{ title: "Custom Action", message: "Perform custom action" }]);
+ *   };
+ *
+ *   // Trigger AI generation
+ *   const handleGenerateSuggestions = async () => {
+ *     await generateSuggestions();
+ *   };
+ * }
+ * ```
+ *
  * `useCopilotChat` returns an object with the following properties:
  *
  * ```tsx
@@ -39,18 +70,30 @@
  *   stopGeneration, // A function to stop the generation of the next message.
  *   reset, // A function to reset the chat.
  *   isLoading, // A boolean indicating if the chat is loading.
+ *
+ *   // Suggestion control (headless UI)
+ *   suggestions, // Current suggestions array
+ *   setSuggestions, // Manually set suggestions
+ *   generateSuggestions, // Trigger AI suggestion generation
+ *   resetSuggestions, // Clear all suggestions
+ *   isLoadingSuggestions, // Whether suggestions are being generated
  * } = useCopilotChat();
  * ```
  */
-import { useRef, useEffect, useCallback, useState } from "react";
-import { AgentSession, useCopilotContext } from "../context/copilot-context";
-import { Message, Role, TextMessage } from "@copilotkit/runtime-client-gql";
+import { useRef, useEffect, useCallback, useState, useMemo } from "react";
+import { AgentSession, useCopilotContext, CopilotContextParams } from "../context/copilot-context";
+import { useCopilotMessagesContext, CopilotMessagesContextParams } from "../context";
 import { SystemMessageFunction } from "../types";
 import { useChat, AppendMessageOptions } from "./use-chat";
 import { defaultCopilotContextCategories } from "../components";
 import { CoAgentStateRenderHandlerArguments } from "@copilotkit/shared";
-import { useCopilotMessagesContext } from "../context";
 import { useAsyncCallback } from "../components/error-boundary/error-utils";
+import { reloadSuggestions as generateSuggestions } from "../utils";
+import type { SuggestionItem } from "../utils";
+
+import { Message } from "@copilotkit/shared";
+import { Role as gqlRole, TextMessage, aguiToGQL, gqlToAGUI } from "@copilotkit/runtime-client-gql";
+import { useLangGraphInterruptRender } from "./use-langgraph-interrupt-render";
 
 export interface UseCopilotChatOptions {
   /**
@@ -64,8 +107,9 @@ export interface UseCopilotChatOptions {
    * HTTP headers to be sent with the API request.
    */
   headers?: Record<string, string> | Headers;
+
   /**
-   * System messages of the chat. Defaults to an empty array.
+   * Initial messages to populate the chat with.
    */
   initialMessages?: Message[];
 
@@ -81,23 +125,75 @@ export interface MCPServerConfig {
 }
 
 export interface UseCopilotChatReturn {
+  /** Array of messages currently visible in the chat interface */
   visibleMessages: Message[];
+
+  /** Send a new message to the chat */
   appendMessage: (message: Message, options?: AppendMessageOptions) => Promise<void>;
+
+  /** Replace all messages in the chat */
   setMessages: (messages: Message[]) => void;
+
+  /** Remove a specific message by ID */
   deleteMessage: (messageId: string) => void;
+
+  /** Regenerate the response for a specific message */
   reloadMessages: (messageId: string) => Promise<void>;
+
+  /** Stop the current message generation */
   stopGeneration: () => void;
+
+  /** Clear all messages and reset chat state */
   reset: () => void;
+
+  /** Whether the chat is currently generating a response */
   isLoading: boolean;
+
+  /** Manually trigger chat completion (advanced usage) */
   runChatCompletion: () => Promise<Message[]>;
+
+  /** MCP (Model Context Protocol) server configurations */
   mcpServers: MCPServerConfig[];
+
+  /** Update MCP server configurations */
   setMcpServers: (mcpServers: MCPServerConfig[]) => void;
+
+  /**
+   * Current suggestions array
+   * Use this to read the current suggestions or in conjunction with setSuggestions for manual control
+   */
+  suggestions: SuggestionItem[];
+
+  /**
+   * Manually set suggestions
+   * Useful for manual mode or custom suggestion workflows
+   */
+  setSuggestions: (suggestions: SuggestionItem[]) => void;
+
+  /**
+   * Trigger AI-powered suggestion generation
+   * Uses configurations from useCopilotChatSuggestions hooks
+   * Respects global debouncing - only one generation can run at a time
+   */
+  generateSuggestions: () => Promise<void>;
+
+  /**
+   * Clear all current suggestions
+   * Also resets suggestion generation state
+   */
+  resetSuggestions: () => void;
+
+  /** Whether suggestions are currently being generated */
+  isLoadingSuggestions: boolean;
+
+  /** Interrupt content for human-in-the-loop workflows */
+  interrupt: string | React.ReactElement | null;
 }
 
-export function useCopilotChat({
-  makeSystemMessage,
-  ...options
-}: UseCopilotChatOptions = {}): UseCopilotChatReturn {
+let globalSuggestionPromise: Promise<void> | null = null;
+
+export function useCopilotChat(options: UseCopilotChatOptions = {}): UseCopilotChatReturn {
+  const makeSystemMessage = options.makeSystemMessage ?? defaultSystemMessage;
   const {
     getContextString,
     getFunctionCallHandler,
@@ -122,22 +218,91 @@ export function useCopilotChat({
     setExtensions,
     langGraphInterruptAction,
     setLangGraphInterruptAction,
+    chatSuggestionConfiguration,
+    suggestions,
+    setSuggestions,
+    runtimeClient,
   } = useCopilotContext();
   const { messages, setMessages } = useCopilotMessagesContext();
 
   // Simple state for MCP servers (keep for interface compatibility)
   const [mcpServers, setLocalMcpServers] = useState<MCPServerConfig[]>([]);
 
-  // This effect directly updates the context when mcpServers state changes
+  // Basic suggestion state for programmatic control
+  const suggestionsAbortControllerRef = useRef<AbortController | null>(null);
+  const isLoadingSuggestionsRef = useRef<boolean>(false);
+
+  const abortSuggestions = useCallback(
+    (clear: boolean = true) => {
+      suggestionsAbortControllerRef.current?.abort("suggestions aborted by user");
+      suggestionsAbortControllerRef.current = null;
+      if (clear) {
+        setSuggestions([]);
+      }
+    },
+    [setSuggestions],
+  );
+
+  // Memoize context with stable dependencies only
+  const stableContext = useMemo(() => {
+    return {
+      actions,
+      copilotApiConfig,
+      chatSuggestionConfiguration,
+      messages,
+      setMessages,
+      getContextString,
+      runtimeClient,
+    };
+  }, [
+    JSON.stringify(Object.keys(actions)),
+    copilotApiConfig.chatApiEndpoint,
+    messages.length,
+    Object.keys(chatSuggestionConfiguration).length,
+  ]);
+
+  // Programmatic suggestion generation function
+  const generateSuggestionsFunc = useCallback(async () => {
+    // If a global suggestion is running, ignore this call
+    if (globalSuggestionPromise) {
+      return globalSuggestionPromise;
+    }
+
+    globalSuggestionPromise = (async () => {
+      try {
+        abortSuggestions();
+        isLoadingSuggestionsRef.current = true;
+        suggestionsAbortControllerRef.current = new AbortController();
+
+        setSuggestions([]);
+
+        await generateSuggestions(
+          stableContext as CopilotContextParams & CopilotMessagesContextParams,
+          chatSuggestionConfiguration,
+          setSuggestions,
+          suggestionsAbortControllerRef,
+        );
+      } catch (error) {
+        // Re-throw to allow caller to handle the error
+        throw error;
+      } finally {
+        isLoadingSuggestionsRef.current = false;
+        globalSuggestionPromise = null;
+      }
+    })();
+
+    return globalSuggestionPromise;
+  }, [stableContext, chatSuggestionConfiguration, setSuggestions, abortSuggestions]);
+
+  const resetSuggestions = useCallback(() => {
+    setSuggestions([]);
+  }, [setSuggestions]);
+
+  // MCP servers logic
   useEffect(() => {
     if (mcpServers.length > 0) {
-      // Copy to avoid issues
       const serversCopy = [...mcpServers];
-
-      // Update in all locations
       copilotApiConfig.mcpServers = serversCopy;
-
-      // Also ensure it's in properties
       if (!copilotApiConfig.properties) {
         copilotApiConfig.properties = {};
       }
@@ -145,7 +310,6 @@ export function useCopilotChat({
     }
   }, [mcpServers, copilotApiConfig]);
 
-  // Provide the same interface
   const setMcpServers = useCallback((servers: MCPServerConfig[]) => {
     setLocalMcpServers(servers);
   }, []);
@@ -176,7 +340,7 @@ export function useCopilotChat({
 
     return new TextMessage({
       content: systemMessageMaker(contextString, chatInstructions),
-      role: Role.System,
+      role: gqlRole.System,
     });
   }, [getContextString, makeSystemMessage, chatInstructions]);
 
@@ -192,7 +356,7 @@ export function useCopilotChat({
     ...options,
     actions: Object.values(actions),
     copilotConfig: copilotApiConfig,
-    initialMessages: options.initialMessages || [],
+    initialMessages: aguiToGQL(options.initialMessages || []),
     onFunctionCall: getFunctionCallHandler(),
     onCoAgentStateRender,
     messages,
@@ -220,7 +384,8 @@ export function useCopilotChat({
   const latestAppend = useUpdatedRef(append);
   const latestAppendFunc = useAsyncCallback(
     async (message: Message, options?: AppendMessageOptions) => {
-      return await latestAppend.current(message, options);
+      abortSuggestions(options?.clearSuggestions);
+      return await latestAppend.current(aguiToGQL([message])[0], options);
     },
     [latestAppend],
   );
@@ -249,7 +414,7 @@ export function useCopilotChat({
   const latestSetMessages = useUpdatedRef(setMessages);
   const latestSetMessagesFunc = useCallback(
     (messages: Message[]) => {
-      return latestSetMessages.current(messages);
+      return latestSetMessages.current(aguiToGQL(messages));
     },
     [latestSetMessages],
   );
@@ -271,6 +436,8 @@ export function useCopilotChat({
       };
     }
     setAgentSession(initialAgentSession);
+    // Reset suggestions when chat is reset
+    resetSuggestions();
   }, [
     latestStopFunc,
     setMessages,
@@ -278,6 +445,7 @@ export function useCopilotChat({
     setCoagentStatesWithRef,
     setAgentSession,
     agentLock,
+    resetSuggestions,
   ]);
 
   const latestReset = useUpdatedRef(reset);
@@ -285,8 +453,10 @@ export function useCopilotChat({
     return latestReset.current();
   }, [latestReset]);
 
+  const interrupt = useLangGraphInterruptRender();
+
   return {
-    visibleMessages: messages,
+    visibleMessages: gqlToAGUI(messages, actions, coAgentStateRenders),
     appendMessage: latestAppendFunc,
     setMessages: latestSetMessagesFunc,
     reloadMessages: latestReloadFunc,
@@ -297,6 +467,12 @@ export function useCopilotChat({
     isLoading,
     mcpServers,
     setMcpServers,
+    suggestions,
+    setSuggestions,
+    generateSuggestions: generateSuggestionsFunc,
+    resetSuggestions,
+    isLoadingSuggestions: isLoadingSuggestionsRef.current,
+    interrupt,
   };
 }
 

package/src/utils/index.ts

@@ -1,2 +1,5 @@
 export { extract } from "./extract";
+export { reloadSuggestions } from "./suggestions";
+export type { SuggestionItem } from "./suggestions";
+export { SUGGESTION_RETRY_CONFIG } from "./suggestions-constants";
 export * from "./dev-console";

package/src/utils/suggestions-constants.ts

@@ -0,0 +1,8 @@
+/**
+ * Constants for suggestions retry logic
+ */
+
+export const SUGGESTION_RETRY_CONFIG = {
+  MAX_RETRIES: 3,
+  COOLDOWN_MS: 5000, // 5 seconds
+} as const;

package/src/utils/suggestions.ts

@@ -0,0 +1,208 @@
+/**
+ * Suggestions utility functions for CopilotKit
+ *
+ * This module handles the generation of chat suggestions with optimized error handling
+ * and streaming validation to prevent infinite retry loops and console spam.
+ */
+
+import { extract } from "./extract";
+import { actionParametersToJsonSchema } from "@copilotkit/shared";
+import { CopilotRequestType } from "@copilotkit/runtime-client-gql";
+import { CopilotContextParams, CopilotMessagesContextParams } from "../context";
+import { CopilotChatSuggestionConfiguration } from "../types";
+
+export interface SuggestionItem {
+  title: string;
+  message: string;
+  partial?: boolean;
+  className?: string;
+}
+
+export const reloadSuggestions = async (
+  context: CopilotContextParams & CopilotMessagesContextParams,
+  chatSuggestionConfiguration: { [key: string]: CopilotChatSuggestionConfiguration },
+  setCurrentSuggestions: (suggestions: SuggestionItem[]) => void,
+  abortControllerRef: React.MutableRefObject<AbortController | null>,
+): Promise<void> => {
+  const abortController = abortControllerRef.current;
+
+  // Early abort check
+  if (abortController?.signal.aborted) {
+    return;
+  }
+
+  // Abort-aware suggestion setter with safety checks to prevent race conditions
+  const setSuggestionsIfNotAborted = (suggestions: SuggestionItem[]) => {
+    if (!abortController?.signal.aborted && abortControllerRef.current === abortController) {
+      setCurrentSuggestions(suggestions);
+    }
+  };
+
+  try {
+    const tools = JSON.stringify(
+      Object.values(context.actions).map((action) => ({
+        name: action.name,
+        description: action.description,
+        jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters)),
+      })),
+    );
+
+    const allSuggestions: SuggestionItem[] = [];
+    let hasSuccessfulSuggestions = false;
+    let hasErrors = false; // Track if any errors occurred
+    let lastError: Error | null = null; // Track the last error for better error reporting
+
+    // Get enabled configurations
+    const enabledConfigs = Object.values(chatSuggestionConfiguration).filter(
+      (config) => config.instructions && config.instructions.trim().length > 0,
+    );
+
+    if (enabledConfigs.length === 0) {
+      return;
+    }
+
+    // Clear existing suggestions
+    setSuggestionsIfNotAborted([]);
+
+    // Generate suggestions for each configuration
+    for (const config of enabledConfigs) {
+      // Check if aborted before each configuration
+      if (abortController?.signal.aborted) {
+        setSuggestionsIfNotAborted([]);
+        return;
+      }
+
+      try {
+        const result = await extract({
+          context,
+          instructions:
+            "Suggest what the user could say next. Provide clear, highly relevant suggestions. Do not literally suggest function calls. ",
+          data: `${config.instructions}\n\nAvailable tools: ${tools}\n\n`,
+          requestType: CopilotRequestType.Task,
+          parameters: [
+            {
+              name: "suggestions",
+              type: "object[]",
+              attributes: [
+                {
+                  name: "title",
+                  description:
+                    "The title of the suggestion. This is shown as a button and should be short.",
+                  type: "string",
+                },
+                {
+                  name: "message",
+                  description:
+                    "The message to send when the suggestion is clicked. This should be a clear, complete sentence and will be sent as an instruction to the AI.",
+                  type: "string",
+                },
+              ],
+            },
+          ],
+          include: {
+            messages: true,
+            readable: true,
+          },
+          abortSignal: abortController?.signal,
+          stream: ({ status, args }: { status: string; args: any }) => {
+            // Check abort status in stream callback
+            if (abortController?.signal.aborted) {
+              return;
+            }
+
+            const suggestions = args.suggestions || [];
+            const newSuggestions: SuggestionItem[] = [];
+
+            for (let i = 0; i < suggestions.length; i++) {
+              // Respect max suggestions limit
+              if (config.maxSuggestions !== undefined && i >= config.maxSuggestions) {
+                break;
+              }
+
+              const suggestion = suggestions[i];
+
+              // Skip completely empty or invalid objects during streaming
+              if (!suggestion || typeof suggestion !== "object") {
+                continue;
+              }
+
+              const { title, message } = suggestion;
+
+              // During streaming, be permissive but require at least a meaningful title
+              const hasValidTitle = title && typeof title === "string" && title.trim().length > 0;
+              const hasValidMessage =
+                message && typeof message === "string" && message.trim().length > 0;
+
+              // During streaming, we need at least a title to show something useful
+              if (!hasValidTitle) {
+                continue;
+              }
+
+              // Mark as partial if this is the last suggestion and streaming isn't complete
+              const partial = i === suggestions.length - 1 && status !== "complete";
+
+              newSuggestions.push({
+                title: title.trim(),
+                message: hasValidMessage ? message.trim() : "", // Use title as fallback
+                partial,
+                className: config.className,
+              });
+            }
+
+            // Update suggestions with current batch
+            setSuggestionsIfNotAborted([...allSuggestions, ...newSuggestions]);
+          },
+        });
+
+        // Process final results with strict validation
+        if (result?.suggestions && Array.isArray(result.suggestions)) {
+          const validSuggestions = result.suggestions
+            .filter(
+              (suggestion: any) =>
+                suggestion &&
+                typeof suggestion.title === "string" &&
+                suggestion.title.trim().length > 0,
+            )
+            .map((suggestion: any) => ({
+              title: suggestion.title.trim(),
+              message:
+                suggestion.message &&
+                typeof suggestion.message === "string" &&
+                suggestion.message.trim()
+                  ? suggestion.message.trim()
+                  : suggestion.title.trim(),
+            }));
+
+          if (validSuggestions.length > 0) {
+            allSuggestions.push(...validSuggestions);
+            hasSuccessfulSuggestions = true;
+          }
+        }
+      } catch (error) {
+        // Simple error handling - just continue with next config, don't log here
+        hasErrors = true;
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+
+    // Display any successful suggestions we got
+    if (hasSuccessfulSuggestions && allSuggestions.length > 0) {
+      // Remove duplicates based on message content
+      const uniqueSuggestions = allSuggestions.filter(
+        (suggestion, index, self) =>
+          index === self.findIndex((s) => s.message === suggestion.message),
+      );
+
+      setSuggestionsIfNotAborted(uniqueSuggestions);
+    } else if (hasErrors) {
+      // If we had errors but no successful suggestions, throw an error with details
+      const errorMessage = lastError
+        ? lastError.message
+        : "Failed to generate suggestions due to API errors";
+      throw new Error(errorMessage);
+    }
+  } catch (error) {
+    // Top-level error handler - re-throw to allow caller to handle
+    throw error;
+  }
+};

package/dist/chunk-DKZTPL66.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/context/copilot-context.tsx"],"sourcesContent":["import { CopilotCloudConfig, FunctionCallHandler, CopilotErrorHandler } from \"@copilotkit/shared\";\nimport {\n  ActionRenderProps,\n  CatchAllActionRenderProps,\n  FrontendAction,\n} from \"../types/frontend-action\";\nimport React from \"react\";\nimport { TreeNodeId, Tree } 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 {\n  CopilotRuntimeClient,\n  ExtensionsInput,\n  ForwardedParametersInput,\n} from \"@copilotkit/runtime-client-gql\";\nimport { Agent } from \"@copilotkit/runtime-client-gql\";\nimport {\n  LangGraphInterruptAction,\n  LangGraphInterruptActionSetter,\n} from \"../types/interrupt-action\";\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  /**\n   * Optional configuration for connecting to Model Context Protocol (MCP) servers.\n   * This is typically derived from the CopilotKitProps and used internally.\n   * @experimental\n   */\n  mcpServers?: Array<{ endpoint: string; apiKey?: string }>;\n}\n\nexport type InChatRenderFunction<TProps = ActionRenderProps<any> | CatchAllActionRenderProps<any>> =\n  (props: TProps) => 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 AuthState {\n  status: \"authenticated\" | \"unauthenticated\";\n  authHeaders: Record<string, string>;\n  userId?: string;\n  metadata?: Record<string, any>;\n}\n\nexport type ActionName = string;\nexport type ContextTree = Tree;\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  getAllContext: () => Tree;\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  additionalInstructions?: string[];\n  setAdditionalInstructions: React.Dispatch<React.SetStateAction<string[]>>;\n\n  // api endpoints\n  copilotApiConfig: CopilotApiConfig;\n\n  showDevConsole: boolean;\n\n  // agents\n  coagentStates: Record<string, CoagentState>;\n  setCoagentStates: React.Dispatch<React.SetStateAction<Record<string, CoagentState>>>;\n  coagentStatesRef: React.RefObject<Record<string, CoagentState>>;\n  setCoagentStatesWithRef: (\n    value:\n      | Record<string, CoagentState>\n      | ((prev: Record<string, CoagentState>) => Record<string, CoagentState>),\n  ) => void;\n\n  agentSession: AgentSession | null;\n  setAgentSession: React.Dispatch<React.SetStateAction<AgentSession | null>>;\n\n  agentLock: string | null;\n\n  threadId: string;\n  setThreadId: React.Dispatch<React.SetStateAction<string>>;\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  /**\n   * The forwarded parameters to use for the task.\n   */\n  forwardedParameters?: Partial<Pick<ForwardedParametersInput, \"temperature\">>;\n  availableAgents: Agent[];\n\n  /**\n   * The auth states for the CopilotKit.\n   */\n  authStates_c?: Record<ActionName, AuthState>;\n  setAuthStates_c?: React.Dispatch<React.SetStateAction<Record<ActionName, AuthState>>>;\n\n  /**\n   * The auth config for the CopilotKit.\n   */\n  authConfig_c?: {\n    SignInComponent: React.ComponentType<{\n      onSignInComplete: (authState: AuthState) => void;\n    }>;\n  };\n\n  extensions: ExtensionsInput;\n  setExtensions: React.Dispatch<React.SetStateAction<ExtensionsInput>>;\n  langGraphInterruptAction: LangGraphInterruptAction | null;\n  setLangGraphInterruptAction: LangGraphInterruptActionSetter;\n  removeLangGraphInterruptAction: () => void;\n\n  /**\n   * Optional trace handler for comprehensive debugging and observability.\n   */\n  onError?: CopilotErrorHandler;\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  getAllContext: () => [],\n\n  getFunctionCallHandler: () => returnAndThrowInDebug(async () => {}),\n\n  isLoading: false,\n  setIsLoading: () => returnAndThrowInDebug(false),\n\n  chatInstructions: \"\",\n  setChatInstructions: () => returnAndThrowInDebug(\"\"),\n\n  additionalInstructions: [],\n  setAdditionalInstructions: () => 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: false,\n  coagentStates: {},\n  setCoagentStates: () => {},\n  coagentStatesRef: { current: {} },\n  setCoagentStatesWithRef: () => {},\n  agentSession: null,\n  setAgentSession: () => {},\n  forwardedParameters: {},\n  agentLock: null,\n  threadId: \"\",\n  setThreadId: () => {},\n  runId: null,\n  setRunId: () => {},\n  chatAbortControllerRef: { current: null },\n  availableAgents: [],\n  extensions: {},\n  setExtensions: () => {},\n  langGraphInterruptAction: null,\n  setLangGraphInterruptAction: () => null,\n  removeLangGraphInterruptAction: () => null,\n  onError: undefined,\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}\n"],"mappings":";;;;;AAMA,OAAO,WAAW;AA6NlB,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,EACtB,eAAe,MAAM,CAAC;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,wBAAwB,CAAC;AAAA,EACzB,2BAA2B,MAAM,sBAAsB,CAAC,CAAC;AAAA,EAEzD,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,EACzB,kBAAkB,EAAE,SAAS,CAAC,EAAE;AAAA,EAChC,yBAAyB,MAAM;AAAA,EAAC;AAAA,EAChC,cAAc;AAAA,EACd,iBAAiB,MAAM;AAAA,EAAC;AAAA,EACxB,qBAAqB,CAAC;AAAA,EACtB,WAAW;AAAA,EACX,UAAU;AAAA,EACV,aAAa,MAAM;AAAA,EAAC;AAAA,EACpB,OAAO;AAAA,EACP,UAAU,MAAM;AAAA,EAAC;AAAA,EACjB,wBAAwB,EAAE,SAAS,KAAK;AAAA,EACxC,iBAAiB,CAAC;AAAA,EAClB,YAAY,CAAC;AAAA,EACb,eAAe,MAAM;AAAA,EAAC;AAAA,EACtB,0BAA0B;AAAA,EAC1B,6BAA6B,MAAM;AAAA,EACnC,gCAAgC,MAAM;AAAA,EACtC,SAAS;AACX;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,QAAc;AAC9C,QAAM,IAAI,MAAM,uEAAuE;AACzF;","names":[]}