@copilotkit/react-core 1.51.4 → 1.51.5-next.1

package/dist/index.d.mts

@@ -0,0 +1,1327 @@
+import React$1, { ReactNode, RefObject, SetStateAction } from "react";
+import { CopilotKitProviderProps, useAgent, useRenderToolCall as useRenderToolCall$1 } from "@copilotkitnext/react";
+import { AIMessage, Action, CopilotCloudConfig, CopilotErrorHandler, CopilotKitError, FunctionCallHandler, MappedParameterTypes, Message, Parameter } from "@copilotkit/shared";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ActionInputAvailability, Agent, CopilotRuntimeClient, CopilotRuntimeClientOptions, ExtensionsInput, ForwardedParametersInput, LangGraphInterruptEvent, Message as Message$1 } from "@copilotkit/runtime-client-gql";
+import { AbstractAgent } from "@ag-ui/client";
+import { StaticSuggestionsConfig, Suggestion } from "@copilotkitnext/core";
+
+//#region src/types/frontend-action.d.ts
+interface InProgressState<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+interface ExecutingState<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+interface CompleteState<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+interface InProgressStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+interface ExecutingStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+interface CompleteStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+interface InProgressStateWait<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: undefined;
+}
+interface ExecutingStateWait<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: (result: any) => void;
+  respond: (result: any) => void;
+  result: undefined;
+}
+interface CompleteStateWait<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: any;
+}
+interface InProgressStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: undefined;
+}
+interface ExecutingStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: (result: any) => void;
+  respond: (result: any) => void;
+  result: undefined;
+}
+interface CompleteStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+}
+type ActionRenderProps<T extends Parameter[] | [] = []> = CompleteState<T> | ExecutingState<T> | InProgressState<T>;
+type ActionRenderPropsNoArgs<T extends Parameter[] | [] = []> = CompleteStateNoArgs<T> | ExecutingStateNoArgs<T> | InProgressStateNoArgs<T>;
+type ActionRenderPropsWait<T extends Parameter[] | [] = []> = CompleteStateWait<T> | ExecutingStateWait<T> | InProgressStateWait<T>;
+type ActionRenderPropsNoArgsWait<T extends Parameter[] | [] = []> = CompleteStateNoArgsWait<T> | ExecutingStateNoArgsWait<T> | InProgressStateNoArgsWait<T>;
+type CatchAllActionRenderProps<T extends Parameter[] | [] = []> = (CompleteState<T> & {
+  name: string;
+}) | (ExecutingState<T> & {
+  name: string;
+}) | (InProgressState<T> & {
+  name: string;
+});
+type FrontendActionAvailability = "disabled" | "enabled" | "remote" | "frontend";
+type FrontendAction<T extends Parameter[] | [] = [], N extends string = string> = Action<T> & {
+  name: Exclude<N, "*">;
+  /**
+   * @deprecated Use `available` instead.
+   */
+  disabled?: boolean;
+  available?: FrontendActionAvailability;
+  pairedAction?: string;
+  followUp?: boolean;
+} & ({
+  render?: string | (T extends [] ? (props: ActionRenderPropsNoArgs<T>) => string | React$1.ReactElement : (props: ActionRenderProps<T>) => string | React$1.ReactElement); /** @deprecated use renderAndWaitForResponse instead */
+  renderAndWait?: never;
+  renderAndWaitForResponse?: never;
+} | {
+  render?: never; /** @deprecated use renderAndWaitForResponse instead */
+  renderAndWait?: T extends [] ? (props: ActionRenderPropsNoArgsWait<T>) => React$1.ReactElement : (props: ActionRenderPropsWait<T>) => React$1.ReactElement;
+  renderAndWaitForResponse?: T extends [] ? (props: ActionRenderPropsNoArgsWait<T>) => React$1.ReactElement : (props: ActionRenderPropsWait<T>) => React$1.ReactElement;
+  handler?: never;
+});
+type CatchAllFrontendAction = {
+  name: "*";
+  render: (props: CatchAllActionRenderProps<any>) => React$1.ReactElement;
+};
+type RenderFunctionStatus = ActionRenderProps<any>["status"];
+//#endregion
+//#region src/hooks/use-tree.d.ts
+type TreeNodeId = string;
+interface TreeNode {
+  id: TreeNodeId;
+  value: string;
+  children: TreeNode[];
+  parentId?: TreeNodeId;
+  categories: Set<string>;
+}
+type Tree = TreeNode[];
+//#endregion
+//#region src/types/document-pointer.d.ts
+interface DocumentPointer {
+  id: string;
+  name: string;
+  sourceApplication: string;
+  iconImageUri: string;
+  getContents: () => string;
+}
+//#endregion
+//#region src/types/system-message.d.ts
+type SystemMessageFunction = (contextString: string, additionalInstructions?: string) => string;
+//#endregion
+//#region src/types/chat-suggestion-configuration.d.ts
+interface CopilotChatSuggestionConfiguration {
+  /**
+   * A prompt or instructions for the GPT to generate suggestions.
+   */
+  instructions: string;
+  /**
+   * The minimum number of suggestions to generate. Defaults to `1`.
+   * @default 1
+   */
+  minSuggestions?: number;
+  /**
+   * The maximum number of suggestions to generate. Defaults to `3`.
+   * @default 1
+   */
+  maxSuggestions?: number;
+  /**
+   * An optional class name to apply to the suggestions.
+   */
+  className?: string;
+}
+//#endregion
+//#region src/types/crew.d.ts
+/**
+ * Status of a response or action that requires user input
+ */
+type CrewsResponseStatus = "inProgress" | "complete" | "executing";
+/**
+ * Response data structure for the ResponseRenderer
+ */
+interface CrewsResponse {
+  /**
+   * Unique identifier for the response
+   */
+  id: string;
+  /**
+   * The content of the response to display
+   */
+  content: string;
+  /**
+   * Optional metadata for the response
+   */
+  metadata?: Record<string, any>;
+}
+/**
+ * Base state item interface for agent state items
+ */
+interface CrewsStateItem {
+  /**
+   * Unique identifier for the item
+   */
+  id: string;
+  /**
+   * Timestamp when the item was created
+   */
+  timestamp: string;
+}
+/**
+ * Tool execution state item
+ */
+interface CrewsToolStateItem extends CrewsStateItem {
+  /**
+   * Name of the tool that was executed
+   */
+  tool: string;
+  /**
+   * Optional thought process for the tool execution
+   */
+  thought?: string;
+  /**
+   * Result of the tool execution
+   */
+  result?: any;
+}
+/**
+ * Task state item
+ */
+interface CrewsTaskStateItem extends CrewsStateItem {
+  /**
+   * Name of the task
+   */
+  name: string;
+  /**
+   * Description of the task
+   */
+  description?: string;
+}
+/**
+ * AgentState containing information about steps and tasks
+ */
+interface CrewsAgentState {
+  /**
+   * Array of tool execution steps
+   */
+  steps?: CrewsToolStateItem[];
+  /**
+   * Array of tasks
+   */
+  tasks?: CrewsTaskStateItem[];
+}
+//#endregion
+//#region src/types/interrupt-action.d.ts
+interface LangGraphInterruptRenderHandlerProps<TEventValue = any> {
+  event: LangGraphInterruptEvent<TEventValue>;
+  resolve: (resolution: string) => void;
+}
+interface LangGraphInterruptRenderProps<TEventValue = any> {
+  result: unknown;
+  event: LangGraphInterruptEvent<TEventValue>;
+  resolve: (resolution: string) => void;
+}
+interface LangGraphInterruptRender<TEventValue = any> {
+  id: string;
+  /**
+   * The handler function to handle the event.
+   */
+  handler?: (props: LangGraphInterruptRenderHandlerProps<TEventValue>) => any | Promise<any>;
+  /**
+   * The render function to handle the event.
+   */
+  render?: (props: LangGraphInterruptRenderProps<TEventValue>) => string | React.ReactElement;
+  /**
+   * Method that returns a boolean, indicating if the interrupt action should run
+   * Useful when using multiple interrupts
+   */
+  enabled?: (args: {
+    eventValue: TEventValue;
+    agentMetadata: AgentSession;
+  }) => boolean;
+}
+type LangGraphInterruptAction = LangGraphInterruptRender & {
+  event?: LangGraphInterruptEvent;
+};
+type LangGraphInterruptActionSetterArgs = Partial<LangGraphInterruptRender> | null;
+type LangGraphInterruptActionSetter = (action: LangGraphInterruptActionSetterArgs) => void;
+interface QueuedInterruptEvent {
+  eventId: string;
+  threadId: string;
+  event: LangGraphInterruptEvent;
+}
+//#endregion
+//#region src/types/coagent-action.d.ts
+type CoAgentStateRenderProps<T> = {
+  state: T;
+  nodeName: string;
+  status: "inProgress" | "complete";
+};
+type CoAgentStateRenderHandlerArguments<T> = {
+  nodeName: string;
+  state: T;
+};
+interface CoAgentStateRender<T = any> {
+  /**
+   * The name of the coagent.
+   */
+  name: string;
+  /**
+   * The node name of the coagent.
+   */
+  nodeName?: string;
+  /**
+   * The handler function to handle the state of the agent.
+   */
+  handler?: (props: CoAgentStateRenderHandlerArguments<T>) => void | Promise<void>;
+  /**
+   * The render function to handle the state of the agent.
+   */
+  render?: ((props: CoAgentStateRenderProps<T>) => string | React.ReactElement | undefined | null) | string;
+}
+//#endregion
+//#region src/types/coagent-state.d.ts
+interface CoagentState {
+  name: string;
+  state: any;
+  running: boolean;
+  active: boolean;
+  threadId?: string;
+  config?: {
+    configurable?: Record<string, any>;
+    [key: string]: any;
+  };
+  nodeName?: string;
+  runId?: string;
+}
+//#endregion
+//#region src/context/copilot-context.d.ts
+/**
+ * Interface for the configuration of the Copilot API.
+ */
+interface CopilotApiConfig {
+  /**
+   * The public API key for Copilot Cloud.
+   */
+  publicApiKey?: string;
+  /**
+   * The configuration for Copilot Cloud.
+   */
+  cloud?: CopilotCloudConfig;
+  /**
+   * The endpoint for the chat API.
+   */
+  chatApiEndpoint: string;
+  /**
+   * The endpoint for the Copilot transcribe audio service.
+   */
+  transcribeAudioUrl?: string;
+  /**
+   * The endpoint for the Copilot text to speech service.
+   */
+  textToSpeechUrl?: string;
+  /**
+   * additional headers to be sent with the request
+   * @default {}
+   * @example
+   * ```
+   * {
+   *   'Authorization': 'Bearer your_token_here'
+   * }
+   * ```
+   */
+  headers: Record<string, string>;
+  /**
+   * Custom properties to be sent with the request
+   * @default {}
+   * @example
+   * ```
+   * {
+   *   'user_id': 'user_id'
+   * }
+   * ```
+   */
+  properties?: Record<string, any>;
+  /**
+   * Indicates whether the user agent should send or receive cookies from the other domain
+   * in the case of cross-origin requests.
+   */
+  credentials?: RequestCredentials;
+  /**
+   * Optional configuration for connecting to Model Context Protocol (MCP) servers.
+   * This is typically derived from the CopilotKitProps and used internally.
+   * @experimental
+   */
+  mcpServers?: Array<{
+    endpoint: string;
+    apiKey?: string;
+  }>;
+}
+type InChatRenderFunction<TProps = ActionRenderProps<any> | CatchAllActionRenderProps<any>> = (props: TProps) => string | React$1.JSX.Element;
+type CoagentInChatRenderFunction = (props: CoAgentStateRenderProps<any>) => string | React$1.JSX.Element | undefined | null;
+interface ChatComponentsCache {
+  actions: Record<string, InChatRenderFunction | string>;
+  coAgentStateRenders: Record<string, CoagentInChatRenderFunction | string>;
+}
+interface AgentSession {
+  agentName: string;
+  threadId?: string;
+  nodeName?: string;
+}
+interface AuthState {
+  status: "authenticated" | "unauthenticated";
+  authHeaders: Record<string, string>;
+  userId?: string;
+  metadata?: Record<string, any>;
+}
+type ActionName = string;
+interface CopilotContextParams {
+  actions: Record<string, FrontendAction<any>>;
+  setAction: (id: string, action: FrontendAction<any>) => void;
+  removeAction: (id: string) => void;
+  setRegisteredActions: (actionConfig: any) => string;
+  removeRegisteredAction: (actionKey: string) => void;
+  chatComponentsCache: React$1.RefObject<ChatComponentsCache>;
+  getFunctionCallHandler: (customEntryPoints?: Record<string, FrontendAction<any>>) => FunctionCallHandler;
+  addContext: (context: string, parentId?: string, categories?: string[]) => TreeNodeId;
+  removeContext: (id: TreeNodeId) => void;
+  getAllContext: () => Tree;
+  getContextString: (documents: DocumentPointer[], categories: string[]) => string;
+  addDocumentContext: (documentPointer: DocumentPointer, categories?: string[]) => TreeNodeId;
+  removeDocumentContext: (documentId: string) => void;
+  getDocumentsContext: (categories: string[]) => DocumentPointer[];
+  isLoading: boolean;
+  setIsLoading: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+  chatSuggestionConfiguration: {
+    [key: string]: CopilotChatSuggestionConfiguration;
+  };
+  addChatSuggestionConfiguration: (id: string, suggestion: CopilotChatSuggestionConfiguration) => void;
+  removeChatSuggestionConfiguration: (id: string) => void;
+  chatInstructions: string;
+  setChatInstructions: React$1.Dispatch<React$1.SetStateAction<string>>;
+  additionalInstructions?: string[];
+  setAdditionalInstructions: React$1.Dispatch<React$1.SetStateAction<string[]>>;
+  copilotApiConfig: CopilotApiConfig;
+  showDevConsole: boolean;
+  coagentStates: Record<string, CoagentState>;
+  setCoagentStates: React$1.Dispatch<React$1.SetStateAction<Record<string, CoagentState>>>;
+  coagentStatesRef: React$1.RefObject<Record<string, CoagentState>>;
+  setCoagentStatesWithRef: (value: Record<string, CoagentState> | ((prev: Record<string, CoagentState>) => Record<string, CoagentState>)) => void;
+  agentSession: AgentSession | null;
+  setAgentSession: React$1.Dispatch<React$1.SetStateAction<AgentSession | null>>;
+  agentLock: string | null;
+  threadId: string;
+  setThreadId: React$1.Dispatch<React$1.SetStateAction<string>>;
+  runId: string | null;
+  setRunId: React$1.Dispatch<React$1.SetStateAction<string | null>>;
+  chatAbortControllerRef: React$1.MutableRefObject<AbortController | null>;
+  /**
+   * The forwarded parameters to use for the task.
+   */
+  forwardedParameters?: Partial<Pick<ForwardedParametersInput, "temperature">>;
+  availableAgents: Agent[];
+  /**
+   * The auth states for the CopilotKit.
+   */
+  authStates_c?: Record<ActionName, AuthState>;
+  setAuthStates_c?: React$1.Dispatch<React$1.SetStateAction<Record<ActionName, AuthState>>>;
+  /**
+   * The auth config for the CopilotKit.
+   */
+  authConfig_c?: {
+    SignInComponent: React$1.ComponentType<{
+      onSignInComplete: (authState: AuthState) => void;
+    }>;
+  };
+  extensions: ExtensionsInput;
+  setExtensions: React$1.Dispatch<React$1.SetStateAction<ExtensionsInput>>;
+  interruptActions: Record<string, LangGraphInterruptRender>;
+  setInterruptAction: LangGraphInterruptActionSetter;
+  removeInterruptAction: (actionId: string) => void;
+  interruptEventQueue: Record<string, QueuedInterruptEvent[]>;
+  addInterruptEvent: (queuedEvent: QueuedInterruptEvent) => void;
+  resolveInterruptEvent: (threadId: string, eventId: string, response: string) => void;
+  /**
+   * Optional trace handler for comprehensive debugging and observability.
+   */
+  onError: CopilotErrorHandler;
+  bannerError: CopilotKitError | null;
+  setBannerError: React$1.Dispatch<React$1.SetStateAction<CopilotKitError | null>>;
+  internalErrorHandlers: Record<string, CopilotErrorHandler>;
+  setInternalErrorHandler: (handler: Record<string, CopilotErrorHandler>) => void;
+  removeInternalErrorHandler: (id: string) => void;
+}
+declare const CopilotContext: React$1.Context<CopilotContextParams>;
+declare function useCopilotContext(): CopilotContextParams;
+//#endregion
+//#region src/components/copilot-provider/copilotkit-props.d.ts
+/**
+ * Props for CopilotKit.
+ */
+/**
+ * We shouldn't need this `Omit` here, but using it because `CopilotKitProps`
+ * and `CopilotKitProviderProps` have non-identical `children` types
+ *
+ * TODO: Remove this `Omit` once this is resolved.
+ */
+interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children"> {
+  /**
+   * Your Copilot Cloud API key.
+   *
+   * Don't have it yet? Go to https://cloud.copilotkit.ai and get one for free.
+   */
+  publicApiKey?: string;
+  /**
+   * Your public license key for accessing premium CopilotKit features.
+   *
+   * Don't have it yet? Go to https://cloud.copilotkit.ai and get one for free.
+   */
+  publicLicenseKey?: string;
+  /**
+   * Restrict input to a specific topic.
+   * @deprecated Use `guardrails_c` instead to control input restrictions
+   */
+  cloudRestrictToTopic?: {
+    validTopics?: string[];
+    invalidTopics?: string[];
+  };
+  /**
+   * Restrict input to specific topics using guardrails.
+   * @remarks
+   *
+   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
+   */
+  guardrails_c?: {
+    validTopics?: string[];
+    invalidTopics?: string[];
+  };
+  /**
+   * The endpoint for the Copilot Runtime instance. [Click here for more information](/concepts/copilot-runtime).
+   */
+  runtimeUrl?: string;
+  /**
+   * The endpoint for the Copilot transcribe audio service.
+   */
+  transcribeAudioUrl?: string;
+  /**
+   * The endpoint for the Copilot text to speech service.
+   */
+  textToSpeechUrl?: string;
+  /**
+   * Additional headers to be sent with the request.
+   *
+   * For example:
+   * ```json
+   * {
+   *   "Authorization": "Bearer X"
+   * }
+   * ```
+   */
+  headers?: Record<string, string>;
+  /**
+   * The children to be rendered within the CopilotKit.
+   */
+  children: ReactNode;
+  /**
+   * Custom properties to be sent with the request.
+   * Can include threadMetadata for thread creation and authorization for LangGraph Platform authentication.
+   * For example:
+   * ```js
+   * {
+   *   'user_id': 'users_id',
+   *   'authorization': 'your-auth-token', // For LangGraph Platform authentication
+   *   threadMetadata: {
+   *     'account_id': '123',
+   *     'user_type': 'premium'
+   *   }
+   * }
+   * ```
+   *
+   * **Note**: The `authorization` property is automatically forwarded to LangGraph agents. See the [LangGraph Agent Authentication Guide](/coagents/shared/guides/langgraph-platform-authentication) for details.
+   */
+  properties?: Record<string, any>;
+  /**
+   * Indicates whether the user agent should send or receive cookies from the other domain
+   * in the case of cross-origin requests.
+   *
+   * To enable HTTP-only cookie authentication, set `credentials="include"` and configure
+   * CORS on your runtime endpoint:
+   *
+   * ```tsx
+   * // Frontend (https://myapp.com)
+   * <CopilotKit runtimeUrl="https://api.myapp.com/copilotkit" credentials="include">
+   *   {children}
+   * </CopilotKit>
+   *
+   * // Backend (https://api.myapp.com)
+   * copilotRuntimeNextJSAppRouterEndpoint({
+   *   runtime,
+   *   endpoint: "/copilotkit",
+   *   cors: {
+   *     origin: "https://myapp.com",
+   *     credentials: true,
+   *   },
+   * });
+   * ```
+   */
+  credentials?: RequestCredentials;
+  /**
+   * Whether to show the dev console.
+   *
+   * Set to `true` to show error banners and toasts, `false` to hide all error UI.
+   * Defaults to `false` for production safety.
+   */
+  showDevConsole?: boolean;
+  /**
+   * The name of the agent to use.
+   */
+  agent?: string;
+  /**
+   * The forwarded parameters to use for the task.
+   */
+  forwardedParameters?: Pick<ForwardedParametersInput, "temperature">;
+  /**
+   * The auth config to use for the CopilotKit.
+   * @remarks
+   *
+   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
+   */
+  authConfig_c?: {
+    SignInComponent: React.ComponentType<{
+      onSignInComplete: (authState: AuthState) => void;
+    }>;
+  };
+  /**
+   * The thread id to use for the CopilotKit.
+   */
+  threadId?: string;
+  /**
+   * Optional error handler for comprehensive debugging and observability.
+   *
+   * **Requires publicApiKey**: Error handling only works when publicApiKey is provided.
+   * This is a premium Copilot Cloud feature.
+   *
+   * @param errorEvent - Structured error event with rich debugging context
+   *
+   * @example
+   * ```typescript
+   * <CopilotKit
+   *   publicApiKey="ck_pub_your_key"
+   *   onError={(errorEvent) => {
+   *     debugDashboard.capture(errorEvent);
+   *   }}
+   * >
+   * ```
+   */
+  onError?: CopilotErrorHandler;
+  /**
+   * Enable or disable the CopilotKit Inspector, letting you inspect AG-UI events,
+   * view agent messages, check agent state, and visualize agent context. Defaults
+   * to enabled.
+   */
+  enableInspector?: boolean;
+}
+//#endregion
+//#region src/components/copilot-provider/copilotkit.d.ts
+declare function CopilotKit({
+  children,
+  ...props
+}: CopilotKitProps): react_jsx_runtime0.JSX.Element;
+declare const defaultCopilotContextCategories: string[];
+//#endregion
+//#region src/context/copilot-messages-context.d.ts
+interface CopilotMessagesContextParams {
+  messages: Message$1[];
+  setMessages: React$1.Dispatch<React$1.SetStateAction<Message$1[]>>;
+  suggestions: Suggestion[];
+  setSuggestions: React$1.Dispatch<React$1.SetStateAction<Suggestion[]>>;
+}
+declare const CopilotMessagesContext: React$1.Context<CopilotMessagesContextParams>;
+declare function useCopilotMessagesContext(): CopilotMessagesContextParams;
+//#endregion
+//#region src/context/coagent-state-renders-context.d.ts
+interface StateRenderClaim {
+  stateRenderId: string;
+  stateSnapshot?: any;
+  runId?: string;
+  messageIndex?: number;
+  locked?: boolean;
+}
+type ClaimsRef = Record<string, StateRenderClaim>;
+interface CoAgentStateRendersContextValue {
+  coAgentStateRenders: Record<string, CoAgentStateRender<any>>;
+  setCoAgentStateRender: (id: string, stateRender: CoAgentStateRender<any>) => void;
+  removeCoAgentStateRender: (id: string) => void;
+  claimsRef: RefObject<ClaimsRef>;
+}
+declare const CoAgentStateRendersContext: React$1.Context<CoAgentStateRendersContextValue | undefined>;
+declare function CoAgentStateRendersProvider({
+  children
+}: {
+  children: ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+declare function useCoAgentStateRenders(): CoAgentStateRendersContextValue;
+//#endregion
+//#region src/context/threads-context.d.ts
+interface ThreadsContextValue {
+  threadId: string;
+  setThreadId: (value: SetStateAction<string>) => void;
+}
+declare const ThreadsContext: React$1.Context<ThreadsContextValue | undefined>;
+interface ThreadsProviderProps {
+  children: ReactNode;
+  threadId?: string;
+}
+declare function ThreadsProvider({
+  children,
+  threadId: explicitThreadId
+}: ThreadsProviderProps): react_jsx_runtime0.JSX.Element;
+declare function useThreads(): ThreadsContextValue;
+//#endregion
+//#region src/hooks/use-copilot-chat_internal.d.ts
+/**
+ * The type of suggestions to use in the chat.
+ *
+ * `auto` - Suggestions are generated automatically.
+ * `manual` - Suggestions are controlled programmatically.
+ * `SuggestionItem[]` - Static suggestions array.
+ */
+type ChatSuggestions = "auto" | "manual" | Omit<Suggestion, "isLoading">[];
+interface AppendMessageOptions {
+  /**
+   * Whether to run the chat completion after appending the message. Defaults to `true`.
+   */
+  followUp?: boolean;
+  /**
+   * Whether to clear the suggestions after appending the message. Defaults to `true`.
+   */
+  clearSuggestions?: boolean;
+}
+interface OnStopGenerationArguments {
+  /**
+   * The name of the currently executing agent.
+   */
+  currentAgentName: string | undefined;
+  /**
+   * The messages in the chat.
+   */
+  messages: Message[];
+}
+type OnReloadMessagesArguments = OnStopGenerationArguments & {
+  /**
+   * The message on which "regenerate" was pressed
+   */
+  messageId: string;
+};
+type OnStopGeneration = (args: OnStopGenerationArguments) => void;
+type OnReloadMessages = (args: OnReloadMessagesArguments) => void;
+interface UseCopilotChatOptions {
+  /**
+   * A unique identifier for the chat. If not provided, a random one will be
+   * generated. When provided, the `useChat` hook with the same `id` will
+   * have shared states across components.
+   */
+  id?: string;
+  /**
+   * HTTP headers to be sent with the API request.
+   */
+  headers?: Record<string, string> | Headers;
+  /**
+   * Initial messages to populate the chat with.
+   */
+  initialMessages?: Message[];
+  /**
+   * A function to generate the system message. Defaults to `defaultSystemMessage`.
+   */
+  makeSystemMessage?: SystemMessageFunction;
+  /**
+   * Disables inclusion of CopilotKit’s default system message. When true, no system message is sent (this also suppresses any custom message from <code>makeSystemMessage</code>).
+   */
+  disableSystemMessage?: boolean;
+  /**
+   * Controls the behavior of suggestions in the chat interface.
+   *
+   * `auto` (default) - Suggestions are generated automatically:
+   *   - When the chat is first opened (empty state)
+   *   - After each message exchange completes
+   *   - Uses configuration from `useCopilotChatSuggestions` hooks
+   *
+   * `manual` - Suggestions are controlled programmatically:
+   *   - Use `setSuggestions()` to set custom suggestions
+   *   - Use `generateSuggestions()` to trigger AI generation
+   *   - Access via `useCopilotChat` hook
+   *
+   * `SuggestionItem[]` - Static suggestions array:
+   *   - Always shows the same suggestions
+   *   - No AI generation involved
+   */
+  suggestions?: ChatSuggestions;
+  onInProgress?: (isLoading: boolean) => void;
+  onSubmitMessage?: (messageContent: string) => Promise<void> | void;
+  onStopGeneration?: OnStopGeneration;
+  onReloadMessages?: OnReloadMessages;
+}
+interface MCPServerConfig {
+  endpoint: string;
+  apiKey?: string;
+}
+interface UseCopilotChatReturn$1 {
+  /**
+   * @deprecated use `messages` instead, this is an old non ag-ui version of the messages
+   * Array of messages currently visible in the chat interface
+   *
+   * This is the visible messages, not the raw messages from the runtime client.
+   */
+  visibleMessages: Message$1[];
+  /**
+   * The messages that are currently in the chat in AG-UI format.
+   */
+  messages: Message[];
+  /** @deprecated use `sendMessage` in `useCopilotChatHeadless_c` instead. This will be removed in a future major version. */
+  appendMessage: (message: Message$1, options?: AppendMessageOptions) => Promise<void>;
+  /**
+   * Send a new message to the chat
+   *
+   * ```tsx
+   * await sendMessage({
+   *   id: "123",
+   *   role: "user",
+   *   content: "Hello, process this request",
+   * });
+   * ```
+   */
+  sendMessage: (message: Message, options?: AppendMessageOptions) => Promise<void>;
+  /**
+   * Replace all messages in the chat
+   *
+   * ```tsx
+   * setMessages([
+   *   { id: "123", role: "user", content: "Hello, process this request" },
+   *   { id: "456", role: "assistant", content: "Hello, I'm the assistant" },
+   * ]);
+   * ```
+   *
+   * **Deprecated** non-ag-ui version:
+   *
+   * ```tsx
+   * setMessages([
+   *   new TextMessage({
+   *     content: "Hello, process this request",
+   *     role: gqlRole.User,
+   *   }),
+   *   new TextMessage({
+   *     content: "Hello, I'm the assistant",
+   *     role: gqlRole.Assistant,
+   * ]);
+   * ```
+   *
+   */
+  setMessages: (messages: Message[] | Message$1[]) => void;
+  /**
+   * Remove a specific message by ID
+   *
+   * ```tsx
+   * deleteMessage("123");
+   * ```
+   */
+  deleteMessage: (messageId: string) => void;
+  /**
+   * Regenerate the response for a specific message
+   *
+   * ```tsx
+   * reloadMessages("123");
+   * ```
+   */
+  reloadMessages: (messageId: string) => Promise<void>;
+  /**
+   * Stop the current message generation
+   *
+   * ```tsx
+   * if (isLoading) {
+   *   stopGeneration();
+   * }
+   * ```
+   */
+  stopGeneration: () => void;
+  /**
+   * Clear all messages and reset chat state
+   *
+   * ```tsx
+   * reset();
+   * console.log(messages); // []
+   * ```
+   */
+  reset: () => void;
+  /**
+   * Whether the chat is currently generating a response
+   *
+   * ```tsx
+   * if (isLoading) {
+   *   console.log("Loading...");
+   * } else {
+   *   console.log("Not loading");
+   * }
+   */
+  isLoading: boolean;
+  /**
+   * Whether the chat agent is available to generate responses
+   *
+   * ```tsx
+   * if (isAvailable) {
+   *   console.log("Loading...");
+   * } else {
+   *   console.log("Not loading");
+   * }
+   */
+  isAvailable: 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: Suggestion[];
+  /**
+   * Manually set suggestions
+   * Useful for manual mode or custom suggestion workflows
+   */
+  setSuggestions: (suggestions: Omit<Suggestion, "isLoading">[]) => void;
+  /**
+   * Trigger AI-powered suggestion generation
+   * Uses configurations from useCopilotChatSuggestions hooks
+   * Respects global debouncing - only one generation can run at a time
+   *
+   * ```tsx
+   * generateSuggestions();
+   * console.log(suggestions); // [suggestion1, suggestion2, suggestion3]
+   * ```
+   */
+  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;
+  agent?: ReturnType<typeof useAgent>["agent"];
+  threadId?: string;
+}
+declare function useCopilotChatInternal({
+  suggestions,
+  onInProgress,
+  onSubmitMessage,
+  onStopGeneration,
+  onReloadMessages
+}?: UseCopilotChatOptions): UseCopilotChatReturn$1;
+//#endregion
+//#region src/hooks/use-copilot-chat.d.ts
+type UseCopilotChatReturn = Omit<UseCopilotChatReturn$1, "messages" | "sendMessage" | "suggestions" | "setSuggestions" | "generateSuggestions" | "isLoadingSuggestions" | "resetSuggestions" | "interrupt" | "setMessages" | "deleteMessage">;
+/**
+ * A lightweight React hook for headless chat interactions.
+ * Perfect for programmatic messaging, background operations, and custom UI implementations.
+ *
+ * **Open Source Friendly** - Works without requiring a `publicApiKey`.
+ */
+declare function useCopilotChat(options?: UseCopilotChatOptions): UseCopilotChatReturn;
+//#endregion
+//#region src/hooks/use-copilot-chat-headless_c.d.ts
+/**
+ * Enterprise React hook that provides complete chat functionality for fully custom UI implementations.
+ * Includes all advanced features like direct message access, suggestions array, interrupt handling, and MCP support.
+ *
+ * **Requires a publicApiKey** - Sign up for free at https://cloud.copilotkit.ai/
+ *
+ * @param options - Configuration options for the chat
+ * @returns Complete chat interface with all enterprise features
+ *
+ * @example
+ * ```tsx
+ * const { messages, sendMessage, suggestions, interrupt } = useCopilotChatHeadless_c();
+ * ```
+ */
+declare function useCopilotChatHeadless_c(options?: UseCopilotChatOptions): UseCopilotChatReturn$1;
+//#endregion
+//#region src/hooks/use-copilot-action.d.ts
+/**
+ * useCopilotAction is a legacy hook maintained for backwards compatibility.
+ *
+ * To avoid violating React's Rules of Hooks (which prohibit conditional hook calls),
+ * we use a registration pattern:
+ * 1. This hook registers the action configuration with the CopilotContext
+ * 2. A renderer component in CopilotKit actually renders the appropriate hook wrapper
+ * 3. React properly manages hook state since components are rendered, not conditionally called
+ *
+ * This allows action types to change between renders without corrupting React's hook state.
+ */
+declare function useCopilotAction<const T extends Parameter[] | [] = []>(action: FrontendAction<T> | CatchAllFrontendAction, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-coagent-state-render.d.ts
+/**
+ * This hook is used to render agent state with custom UI components or text. This is particularly
+ * useful for showing intermediate state or progress during Agentic Copilot operations.
+ * To get started using rendering intermediate state through this hook, checkout the documentation.
+ *
+ * https://docs.copilotkit.ai/coagents/shared-state/predictive-state-updates
+ */
+declare function useCoAgentStateRender<T = any>(action: CoAgentStateRender<T>, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-make-copilot-document-readable.d.ts
+/**
+ * Makes a document readable by Copilot.
+ * @param document The document to make readable.
+ * @param categories The categories to associate with the document.
+ * @param dependencies The dependencies to use for the effect.
+ * @returns The id of the document.
+ */
+declare function useMakeCopilotDocumentReadable(document: DocumentPointer, categories?: string[], dependencies?: any[]): string | undefined;
+//#endregion
+//#region src/hooks/use-copilot-readable.d.ts
+/**
+ * Options for the useCopilotReadable hook.
+ */
+interface UseCopilotReadableOptions {
+  /**
+   * The description of the information to be added to the Copilot context.
+   */
+  description: string;
+  /**
+   * The value to be added to the Copilot context. Object values are automatically stringified.
+   */
+  value: any;
+  /**
+   * The ID of the parent context, if any.
+   */
+  parentId?: string;
+  /**
+   * An array of categories to control which context are visible where. Particularly useful
+   * with CopilotTextarea (see `useMakeAutosuggestionFunction`)
+   */
+  categories?: string[];
+  /**
+   * Whether the context is available to the Copilot.
+   */
+  available?: "enabled" | "disabled";
+  /**
+   * A custom conversion function to use to serialize the value to a string. If not provided, the value
+   * will be serialized using `JSON.stringify`.
+   */
+  convert?: (description: string, value: any) => string;
+}
+/**
+ * Adds the given information to the Copilot context to make it readable by Copilot.
+ */
+declare function useCopilotReadable({
+  description,
+  value,
+  convert,
+  available
+}: UseCopilotReadableOptions, dependencies?: any[]): string | undefined;
+//#endregion
+//#region src/hooks/use-coagent.d.ts
+interface UseCoagentOptionsBase {
+  /**
+   * The name of the agent being used.
+   */
+  name: string;
+  /**
+   * @deprecated - use "config.configurable"
+   * Config to pass to a LangGraph Agent
+   */
+  configurable?: Record<string, any>;
+  /**
+   * Config to pass to a LangGraph Agent
+   */
+  config?: {
+    configurable?: Record<string, any>;
+    [key: string]: any;
+  };
+}
+interface WithInternalStateManagementAndInitial<T> extends UseCoagentOptionsBase {
+  /**
+   * The initial state of the agent.
+   */
+  initialState: T;
+}
+interface WithInternalStateManagement extends UseCoagentOptionsBase {
+  /**
+   * Optional initialState with default type any
+   */
+  initialState?: any;
+}
+interface WithExternalStateManagement<T> extends UseCoagentOptionsBase {
+  /**
+   * The current state of the agent.
+   */
+  state: T;
+  /**
+   * A function to update the state of the agent.
+   */
+  setState: (newState: T | ((prevState: T | undefined) => T)) => void;
+}
+type UseCoagentOptions<T> = WithInternalStateManagementAndInitial<T> | WithInternalStateManagement | WithExternalStateManagement<T>;
+interface UseCoagentReturnType<T> {
+  /**
+   * The name of the agent being used.
+   */
+  name: string;
+  /**
+   * The name of the current LangGraph node.
+   */
+  nodeName?: string;
+  /**
+   * The ID of the thread the agent is running in.
+   */
+  threadId?: string;
+  /**
+   * A boolean indicating if the agent is currently running.
+   */
+  running: boolean;
+  /**
+   * The current state of the agent.
+   */
+  state: T;
+  /**
+   * A function to update the state of the agent.
+   */
+  setState: (newState: T | ((prevState: T | undefined) => T)) => void;
+  /**
+   * A function to start the agent.
+   */
+  start: () => void;
+  /**
+   * A function to stop the agent.
+   */
+  stop: () => void;
+  /**
+   * A function to re-run the agent. The hint function can be used to provide a hint to the agent
+   * about why it is being re-run again.
+   */
+  run: (...args: any[]) => Promise<any>;
+}
+interface HintFunctionParams {
+  /**
+   * The previous state of the agent.
+   */
+  previousState: any;
+  /**
+   * The current state of the agent.
+   */
+  currentState: any;
+}
+type HintFunction = (params: HintFunctionParams) => Message | undefined;
+/**
+ * This hook is used to integrate an agent into your application. With its use, you can
+ * render and update the state of the agent, allowing for a dynamic and interactive experience.
+ * We call these shared state experiences "agentic copilots". To get started using agentic copilots, which
+ * we refer to as CoAgents, checkout the documentation at https://docs.copilotkit.ai/coagents/quickstart/langgraph.
+ */
+declare function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentReturnType<T>;
+//#endregion
+//#region src/hooks/use-copilot-runtime-client.d.ts
+interface CopilotRuntimeClientHookOptions extends CopilotRuntimeClientOptions {
+  showDevConsole?: boolean;
+  onError: CopilotErrorHandler;
+}
+declare const useCopilotRuntimeClient: (options: CopilotRuntimeClientHookOptions) => CopilotRuntimeClient;
+//#endregion
+//#region src/hooks/use-copilot-authenticated-action.d.ts
+/**
+ * Hook to create an authenticated action that requires user sign-in before execution.
+ *
+ * @remarks
+ * This feature is only available when using CopilotKit's hosted cloud service.
+ * To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey.
+ *
+ * @param action - The frontend action to be wrapped with authentication
+ * @param dependencies - Optional array of dependencies that will trigger recreation of the action when changed
+ */
+declare function useCopilotAuthenticatedAction_c<T extends Parameter[]>(action: FrontendAction<T>, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-langgraph-interrupt.d.ts
+declare function useLangGraphInterrupt<TEventValue = any>(action: Omit<LangGraphInterruptRender<TEventValue>, "id">, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-langgraph-interrupt-render.d.ts
+declare function useLangGraphInterruptRender(agent: AbstractAgent): string | React$1.ReactElement | null;
+//#endregion
+//#region src/hooks/use-copilot-additional-instructions.d.ts
+/**
+ * Options for the useCopilotAdditionalInstructions hook.
+ */
+interface UseCopilotAdditionalInstructionsOptions {
+  /**
+   * The instructions to be added to the Copilot. Will be added to the instructions like so:
+   *
+   * ```txt
+   * You are a helpful assistant.
+   * Additionally, follow these instructions:
+   * - Do not answer questions about the weather.
+   * - Do not answer questions about the stock market.
+   * ```
+   */
+  instructions: string;
+  /**
+   * Whether the instructions are available to the Copilot.
+   */
+  available?: "enabled" | "disabled";
+}
+/**
+ * Adds the given instructions to the Copilot context.
+ */
+declare function useCopilotAdditionalInstructions({
+  instructions,
+  available
+}: UseCopilotAdditionalInstructionsOptions, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-frontend-tool.d.ts
+type UseFrontendToolArgs<T extends Parameter[] | [] = []> = {
+  available?: "disabled" | "enabled";
+} & Pick<FrontendAction<T>, "name" | "description" | "parameters" | "handler" | "followUp" | "render">;
+declare function useFrontendTool<const T extends Parameter[] = []>(tool: UseFrontendToolArgs<T>, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-human-in-the-loop.d.ts
+type UseHumanInTheLoopArgs<T extends Parameter[] | [] = []> = {
+  available?: "disabled" | "enabled";
+  render: FrontendAction<T>["renderAndWaitForResponse"];
+  followUp?: FrontendAction<T>["followUp"];
+} & Pick<FrontendAction<T>, "name" | "description" | "parameters">;
+declare function useHumanInTheLoop<const T extends Parameter[] | [] = []>(tool: UseHumanInTheLoopArgs<T>, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-render-tool-call.d.ts
+type UseRenderToolCallArgs<T extends Parameter[] | [] = []> = Pick<FrontendAction<T>, "name" | "description" | "parameters"> & {
+  available?: "disabled" | "enabled";
+  render: T extends [] ? (props: ActionRenderPropsNoArgs<T>) => React$1.ReactElement : (props: ActionRenderProps<T>) => React$1.ReactElement;
+};
+declare function useRenderToolCall<const T extends Parameter[] | [] = []>(tool: UseRenderToolCallArgs<T>, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-default-tool.d.ts
+declare function useDefaultTool(tool: Omit<CatchAllFrontendAction, "name">, dependencies?: any[]): void;
+//#endregion
+//#region src/hooks/use-lazy-tool-renderer.d.ts
+declare function useLazyToolRenderer(): (message?: AIMessage, messages?: Message[]) => null | (() => ReturnType<ReturnType<typeof useRenderToolCall$1>> | null);
+//#endregion
+//#region src/hooks/use-copilot-chat-suggestions.d.ts
+type StaticSuggestionInput = Omit<Suggestion, "isLoading"> & Partial<Pick<Suggestion, "isLoading">>;
+type StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig, "suggestions"> & {
+  suggestions: StaticSuggestionInput[];
+};
+type DynamicSuggestionsConfigInput = {
+  /**
+   * A prompt or instructions for the GPT to generate suggestions.
+   */
+  instructions: string;
+  /**
+   * The minimum number of suggestions to generate. Defaults to `1`.
+   * @default 1
+   */
+  minSuggestions?: number;
+  /**
+   * The maximum number of suggestions to generate. Defaults to `3`.
+   * @default 1
+   */
+  maxSuggestions?: number;
+  /**
+   * Whether the suggestions are available. Defaults to `enabled`.
+   * @default enabled
+   */
+  available?: "enabled" | "disabled" | "always" | "before-first-message" | "after-first-message";
+  /**
+   * An optional class name to apply to the suggestions.
+   */
+  className?: string;
+};
+type UseCopilotChatSuggestionsConfiguration = DynamicSuggestionsConfigInput | StaticSuggestionsConfigInput;
+declare function useCopilotChatSuggestions(config: UseCopilotChatSuggestionsConfiguration, dependencies?: any[]): void;
+//#endregion
+//#region src/lib/copilot-task.d.ts
+interface CopilotTaskConfig {
+  /**
+   * The instructions to be given to the assistant.
+   */
+  instructions: string;
+  /**
+   * An array of action definitions that can be called.
+   */
+  actions?: FrontendAction<any>[];
+  /**
+   * Whether to include the copilot readable context in the task.
+   */
+  includeCopilotReadable?: boolean;
+  /**
+   * Whether to include actions defined via useCopilotAction in the task.
+   */
+  includeCopilotActions?: boolean;
+  /**
+   * The forwarded parameters to use for the task.
+   */
+  forwardedParameters?: ForwardedParametersInput;
+}
+declare class CopilotTask<T = any> {
+  private instructions;
+  private actions;
+  private includeCopilotReadable;
+  private includeCopilotActions;
+  private forwardedParameters?;
+  constructor(config: CopilotTaskConfig);
+  /**
+   * Run the task.
+   * @param context The CopilotContext to use for the task. Use `useCopilotContext` to obtain the current context.
+   * @param data The data to use for the task.
+   */
+  run(context: CopilotContextParams, data?: T): Promise<void>;
+}
+//#endregion
+//#region src/utils/suggestions-constants.d.ts
+/**
+ * Constants for suggestions retry logic
+ */
+declare const SUGGESTION_RETRY_CONFIG: {
+  readonly MAX_RETRIES: 3;
+  readonly COOLDOWN_MS: 5000;
+};
+//#endregion
+//#region src/utils/dev-console.d.ts
+declare function shouldShowDevConsole(showDevConsole?: boolean): boolean;
+//#endregion
+export { type ActionRenderProps, type ActionRenderPropsNoArgs, type ActionRenderPropsNoArgsWait, type ActionRenderPropsWait, type CatchAllActionRenderProps, type CatchAllFrontendAction, type ChatSuggestions, CoAgentStateRendersContext, type CoAgentStateRendersContextValue, CoAgentStateRendersProvider, type CoagentInChatRenderFunction, type CopilotApiConfig, type CopilotChatSuggestionConfiguration, CopilotContext, type CopilotContextParams, CopilotKit, type CopilotKitProps, CopilotMessagesContext, type CopilotMessagesContextParams, CopilotTask, CopilotTaskConfig, CrewsAgentState, CrewsResponse, CrewsResponseStatus, CrewsStateItem, CrewsTaskStateItem, CrewsToolStateItem, type DocumentPointer, type FrontendAction, type FrontendActionAvailability, type HintFunction, LangGraphInterruptAction, LangGraphInterruptActionSetter, LangGraphInterruptActionSetterArgs, LangGraphInterruptRender, LangGraphInterruptRenderHandlerProps, LangGraphInterruptRenderProps, type OnReloadMessages, type OnStopGeneration, QueuedInterruptEvent, type RenderFunctionStatus, SUGGESTION_RETRY_CONFIG, type SystemMessageFunction, ThreadsContext, type ThreadsContextValue, ThreadsProvider, type ThreadsProviderProps, type Tree, type TreeNode, type UseCopilotChatOptions, type UseCopilotChatOptions as UseCopilotChatOptions_c, type UseCopilotChatReturn, type UseCopilotChatReturn$1 as UseCopilotChatReturn_c, type UseCopilotChatSuggestionsConfiguration, defaultCopilotContextCategories, shouldShowDevConsole, useCoAgent, useCoAgentStateRender, useCoAgentStateRenders, useCopilotAction, useCopilotAdditionalInstructions, useCopilotAuthenticatedAction_c, useCopilotChat, useCopilotChatHeadless_c, useCopilotChatInternal, useCopilotChatSuggestions, useCopilotContext, useCopilotMessagesContext, useCopilotReadable, useCopilotRuntimeClient, useDefaultTool, useFrontendTool, useHumanInTheLoop, useLangGraphInterrupt, useLangGraphInterruptRender, useLazyToolRenderer, useMakeCopilotDocumentReadable, useRenderToolCall, useThreads };
+//# sourceMappingURL=index.d.mts.map