@copilotkit/react-core 1.53.0 → 1.53.1-next.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # ui
 
+## 1.53.1-next.0
+
+### Patch Changes
+
+- Updated dependencies [6e0cddf]
+  - @copilotkitnext/react@1.53.1-next.0
+  - @copilotkit/runtime-client-gql@1.53.1-next.0
+  - @copilotkit/shared@1.53.1-next.0
+  - @copilotkitnext/core@1.53.1-next.0
+
 ## 1.53.0
 
 ### Patch Changes

package/dist/copilotkit-BRPQ2sqS.d.cts

@@ -0,0 +1,670 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Agent, ExtensionsInput, ForwardedParametersInput, LangGraphInterruptEvent } from "@copilotkit/runtime-client-gql";
+import React$1, { ReactNode } from "react";
+import { Action, CopilotCloudConfig, CopilotErrorHandler, CopilotKitError, FunctionCallHandler, MappedParameterTypes, Parameter } from "@copilotkit/shared";
+import { CopilotKitProviderProps } from "@copilotkitnext/react";
+
+//#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;
+  /**
+   * Optional agent ID to scope this interrupt to a specific agent.
+   * Defaults to the agent configured in the CopilotKit chat configuration.
+   */
+  agentId?: string;
+}
+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
+export { ActionRenderPropsNoArgsWait as A, CopilotChatSuggestionConfiguration as C, TreeNode as D, Tree as E, FrontendActionAvailability as F, RenderFunctionStatus as I, CatchAllActionRenderProps as M, CatchAllFrontendAction as N, ActionRenderProps as O, FrontendAction as P, CrewsToolStateItem as S, DocumentPointer as T, CrewsAgentState as _, CopilotApiConfig as a, CrewsStateItem as b, useCopilotContext as c, LangGraphInterruptActionSetter as d, LangGraphInterruptActionSetterArgs as f, QueuedInterruptEvent as g, LangGraphInterruptRenderProps as h, CoagentInChatRenderFunction as i, ActionRenderPropsWait as j, ActionRenderPropsNoArgs as k, CoAgentStateRender as l, LangGraphInterruptRenderHandlerProps as m, defaultCopilotContextCategories as n, CopilotContext as o, LangGraphInterruptRender as p, CopilotKitProps as r, CopilotContextParams as s, CopilotKit as t, LangGraphInterruptAction as u, CrewsResponse as v, SystemMessageFunction as w, CrewsTaskStateItem as x, CrewsResponseStatus as y };
+//# sourceMappingURL=copilotkit-BRPQ2sqS.d.cts.map