@copilotkit/react-core 1.54.1 → 1.55.0-next.8

package/dist/copilotkit-DBzgOMby.d.cts

@@ -0,0 +1,2182 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Agent, ExtensionsInput, ForwardedParametersInput, LangGraphInterruptEvent } from "@copilotkit/runtime-client-gql";
+import * as react from "react";
+import React$1, { ComponentType, ReactNode } from "react";
+import { Action, CopilotCloudConfig, CopilotErrorHandler, CopilotKitError, FunctionCallHandler, InferSchemaOutput, MappedParameterTypes, Parameter, StandardSchemaV1 } from "@copilotkit/shared";
+import { CopilotKitCore, CopilotKitCoreConfig, CopilotKitCoreErrorCode, CopilotKitCoreSubscriber, CopilotKitCoreSubscription, DynamicSuggestionsConfig, FrontendTool, StaticSuggestionsConfig, Suggestion, ToolCallStatus, ɵThread } from "@copilotkit/core";
+import { AbstractAgent } from "@ag-ui/client";
+import { ActivityMessage, AssistantMessage, Message as Message$2, ReasoningMessage, ToolCall, ToolMessage, UserMessage } from "@ag-ui/core";
+import { Streamdown } from "streamdown";
+import { z } from "zod";
+import { Theme } from "@copilotkit/a2ui-renderer";
+
+//#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/v2/components/chat/CopilotChatAudioRecorder.d.ts
+/** Finite-state machine for every recorder implementation */
+type AudioRecorderState = "idle" | "recording" | "processing";
+/** Error subclass so callers can `instanceof`-guard recorder failures */
+declare class AudioRecorderError extends Error {
+  constructor(message: string);
+}
+interface AudioRecorderRef {
+  state: AudioRecorderState;
+  start: () => Promise<void>;
+  stop: () => Promise<Blob>;
+  dispose: () => void;
+}
+declare const CopilotChatAudioRecorder: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<AudioRecorderRef>>;
+//#endregion
+//#region src/v2/providers/CopilotChatConfigurationProvider.d.ts
+declare const CopilotChatDefaultLabels: {
+  chatInputPlaceholder: string;
+  chatInputToolbarStartTranscribeButtonLabel: string;
+  chatInputToolbarCancelTranscribeButtonLabel: string;
+  chatInputToolbarFinishTranscribeButtonLabel: string;
+  chatInputToolbarAddButtonLabel: string;
+  chatInputToolbarToolsButtonLabel: string;
+  assistantMessageToolbarCopyCodeLabel: string;
+  assistantMessageToolbarCopyCodeCopiedLabel: string;
+  assistantMessageToolbarCopyMessageLabel: string;
+  assistantMessageToolbarThumbsUpLabel: string;
+  assistantMessageToolbarThumbsDownLabel: string;
+  assistantMessageToolbarReadAloudLabel: string;
+  assistantMessageToolbarRegenerateLabel: string;
+  userMessageToolbarCopyMessageLabel: string;
+  userMessageToolbarEditMessageLabel: string;
+  chatDisclaimerText: string;
+  chatToggleOpenLabel: string;
+  chatToggleCloseLabel: string;
+  modalHeaderTitle: string;
+  welcomeMessageText: string;
+};
+type CopilotChatLabels = typeof CopilotChatDefaultLabels;
+interface CopilotChatConfigurationValue {
+  labels: CopilotChatLabels;
+  agentId: string;
+  threadId: string;
+  isModalOpen: boolean;
+  setModalOpen: (open: boolean) => void;
+}
+interface CopilotChatConfigurationProviderProps {
+  children: ReactNode;
+  labels?: Partial<CopilotChatLabels>;
+  agentId?: string;
+  threadId?: string;
+  isModalDefaultOpen?: boolean;
+}
+declare const CopilotChatConfigurationProvider: React$1.FC<CopilotChatConfigurationProviderProps>;
+declare const useCopilotChatConfiguration: () => CopilotChatConfigurationValue | null;
+//#endregion
+//#region src/v2/lib/slots.d.ts
+/** Existing union (unchanged) */
+type SlotValue<C extends React$1.ComponentType<any>> = C | string | Partial<React$1.ComponentProps<C>>;
+/** Utility: concrete React elements for every slot */
+type SlotElements<S> = { [K in keyof S]: React$1.ReactElement };
+type WithSlots<S extends Record<string, React$1.ComponentType<any>>, Rest = {}> = { [K in keyof S]?: SlotValue<S[K]> } & {
+  children?: (props: SlotElements<S> & Rest) => React$1.ReactNode;
+} & Omit<Rest, "children">;
+//#endregion
+//#region src/v2/components/chat/CopilotChatInput.d.ts
+type CopilotChatInputMode = "input" | "transcribe" | "processing";
+type ToolsMenuItem = {
+  label: string;
+} & ({
+  action: () => void;
+  items?: never;
+} | {
+  action?: never;
+  items: (ToolsMenuItem | "-")[];
+});
+type CopilotChatInputSlots = {
+  textArea: typeof CopilotChatInput.TextArea;
+  sendButton: typeof CopilotChatInput.SendButton;
+  startTranscribeButton: typeof CopilotChatInput.StartTranscribeButton;
+  cancelTranscribeButton: typeof CopilotChatInput.CancelTranscribeButton;
+  finishTranscribeButton: typeof CopilotChatInput.FinishTranscribeButton;
+  addMenuButton: typeof CopilotChatInput.AddMenuButton;
+  audioRecorder: typeof CopilotChatAudioRecorder;
+  disclaimer: typeof CopilotChatInput.Disclaimer;
+};
+type CopilotChatInputRestProps = {
+  mode?: CopilotChatInputMode;
+  toolsMenu?: (ToolsMenuItem | "-")[];
+  autoFocus?: boolean;
+  onSubmitMessage?: (value: string) => void;
+  onStop?: () => void;
+  isRunning?: boolean;
+  onStartTranscribe?: () => void;
+  onCancelTranscribe?: () => void;
+  onFinishTranscribe?: () => void;
+  onFinishTranscribeWithAudio?: (audioBlob: Blob) => Promise<void>;
+  onAddFile?: () => void;
+  value?: string;
+  onChange?: (value: string) => void; /** Positioning mode for the input container. Default: 'static' */
+  positioning?: "static" | "absolute"; /** Keyboard height in pixels for mobile keyboard handling */
+  keyboardHeight?: number; /** Ref for the outer positioning container */
+  containerRef?: React$1.Ref<HTMLDivElement>; /** Whether to show the disclaimer. Default: true for absolute positioning, false for static */
+  showDisclaimer?: boolean;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">;
+type CopilotChatInputBaseProps = WithSlots<CopilotChatInputSlots, CopilotChatInputRestProps>;
+type CopilotChatInputChildrenArgs = CopilotChatInputBaseProps extends {
+  children?: infer C;
+} ? C extends ((props: infer P) => React$1.ReactNode) ? P : never : never;
+type CopilotChatInputProps = Omit<CopilotChatInputBaseProps, "children"> & {
+  children?: (props: CopilotChatInputChildrenArgs) => React$1.ReactNode;
+};
+declare function CopilotChatInput({
+  mode,
+  onSubmitMessage,
+  onStop,
+  isRunning,
+  onStartTranscribe,
+  onCancelTranscribe,
+  onFinishTranscribe,
+  onFinishTranscribeWithAudio,
+  onAddFile,
+  onChange,
+  value,
+  toolsMenu,
+  autoFocus,
+  positioning,
+  keyboardHeight,
+  containerRef,
+  showDisclaimer,
+  textArea,
+  sendButton,
+  startTranscribeButton,
+  cancelTranscribeButton,
+  finishTranscribeButton,
+  addMenuButton,
+  audioRecorder,
+  disclaimer,
+  children,
+  className,
+  ...props
+}: CopilotChatInputProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatInput {
+  const SendButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ToolbarButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    icon: React$1.ReactNode;
+    labelKey: keyof CopilotChatLabels;
+    defaultClassName?: string;
+  }>;
+  const StartTranscribeButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const CancelTranscribeButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const FinishTranscribeButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const AddMenuButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    toolsMenu?: (ToolsMenuItem | "-")[];
+    onAddFile?: () => void;
+  }>;
+  type TextAreaProps = React$1.TextareaHTMLAttributes<HTMLTextAreaElement>;
+  const TextArea: React$1.ForwardRefExoticComponent<TextAreaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+  const AudioRecorder: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<AudioRecorderRef>>;
+  const Disclaimer: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatToolCallsView.d.ts
+type CopilotChatToolCallsViewProps = {
+  message: AssistantMessage;
+  messages?: Message$2[];
+};
+declare function CopilotChatToolCallsView({
+  message,
+  messages
+}: CopilotChatToolCallsViewProps): react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/v2/components/chat/CopilotChatAssistantMessage.d.ts
+type CopilotChatAssistantMessageProps = WithSlots<{
+  markdownRenderer: typeof CopilotChatAssistantMessage.MarkdownRenderer;
+  toolbar: typeof CopilotChatAssistantMessage.Toolbar;
+  copyButton: typeof CopilotChatAssistantMessage.CopyButton;
+  thumbsUpButton: typeof CopilotChatAssistantMessage.ThumbsUpButton;
+  thumbsDownButton: typeof CopilotChatAssistantMessage.ThumbsDownButton;
+  readAloudButton: typeof CopilotChatAssistantMessage.ReadAloudButton;
+  regenerateButton: typeof CopilotChatAssistantMessage.RegenerateButton;
+  toolCallsView: typeof CopilotChatToolCallsView;
+}, {
+  onThumbsUp?: (message: AssistantMessage) => void;
+  onThumbsDown?: (message: AssistantMessage) => void;
+  onReadAloud?: (message: AssistantMessage) => void;
+  onRegenerate?: (message: AssistantMessage) => void;
+  message: AssistantMessage;
+  messages?: Message$2[];
+  isRunning?: boolean;
+  additionalToolbarItems?: React.ReactNode;
+  toolbarVisible?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatAssistantMessage({
+  message,
+  messages,
+  isRunning,
+  onThumbsUp,
+  onThumbsDown,
+  onReadAloud,
+  onRegenerate,
+  additionalToolbarItems,
+  toolbarVisible,
+  markdownRenderer,
+  toolbar,
+  copyButton,
+  thumbsUpButton,
+  thumbsDownButton,
+  readAloudButton,
+  regenerateButton,
+  toolCallsView,
+  children,
+  className,
+  ...props
+}: CopilotChatAssistantMessageProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatAssistantMessage {
+  const MarkdownRenderer: React.FC<Omit<React.ComponentProps<typeof Streamdown>, "children"> & {
+    content: string;
+  }>;
+  const Toolbar: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+  const ToolbarButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    title: string;
+    children: React.ReactNode;
+  }>;
+  const CopyButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ThumbsUpButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ThumbsDownButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ReadAloudButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const RegenerateButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatUserMessage.d.ts
+interface CopilotChatUserMessageOnEditMessageProps {
+  message: UserMessage;
+}
+interface CopilotChatUserMessageOnSwitchToBranchProps {
+  message: UserMessage;
+  branchIndex: number;
+  numberOfBranches: number;
+}
+type CopilotChatUserMessageProps = WithSlots<{
+  messageRenderer: typeof CopilotChatUserMessage.MessageRenderer;
+  toolbar: typeof CopilotChatUserMessage.Toolbar;
+  copyButton: typeof CopilotChatUserMessage.CopyButton;
+  editButton: typeof CopilotChatUserMessage.EditButton;
+  branchNavigation: typeof CopilotChatUserMessage.BranchNavigation;
+}, {
+  onEditMessage?: (props: CopilotChatUserMessageOnEditMessageProps) => void;
+  onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
+  message: UserMessage;
+  branchIndex?: number;
+  numberOfBranches?: number;
+  additionalToolbarItems?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatUserMessage({
+  message,
+  onEditMessage,
+  branchIndex,
+  numberOfBranches,
+  onSwitchToBranch,
+  additionalToolbarItems,
+  messageRenderer,
+  toolbar,
+  copyButton,
+  editButton,
+  branchNavigation,
+  children,
+  className,
+  ...props
+}: CopilotChatUserMessageProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatUserMessage {
+  const Container: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLDivElement>>>;
+  const MessageRenderer: React.FC<{
+    content: string;
+    className?: string;
+  }>;
+  const Toolbar: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+  const ToolbarButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    title: string;
+    children: React.ReactNode;
+  }>;
+  const CopyButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    copied?: boolean;
+  }>;
+  const EditButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const BranchNavigation: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    currentBranch?: number;
+    numberOfBranches?: number;
+    onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
+    message: UserMessage;
+  }>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatReasoningMessage.d.ts
+type CopilotChatReasoningMessageProps = WithSlots<{
+  header: typeof CopilotChatReasoningMessage.Header;
+  contentView: typeof CopilotChatReasoningMessage.Content;
+  toggle: typeof CopilotChatReasoningMessage.Toggle;
+}, {
+  message: ReasoningMessage;
+  messages?: Message$2[];
+  isRunning?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatReasoningMessage({
+  message,
+  messages,
+  isRunning,
+  header,
+  contentView,
+  toggle,
+  children,
+  className,
+  ...props
+}: CopilotChatReasoningMessageProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatReasoningMessage {
+  const Header: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    isOpen?: boolean;
+    label?: string;
+    hasContent?: boolean;
+    isStreaming?: boolean;
+  }>;
+  const Content: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    isStreaming?: boolean;
+    hasContent?: boolean;
+  }>;
+  const Toggle: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    isOpen?: boolean;
+  }>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatSuggestionPill.d.ts
+interface CopilotChatSuggestionPillProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+  /** Optional icon to render on the left side when not loading. */
+  icon?: React$1.ReactNode;
+  /** Whether the pill should display a loading spinner. */
+  isLoading?: boolean;
+}
+declare const CopilotChatSuggestionPill: React$1.ForwardRefExoticComponent<CopilotChatSuggestionPillProps & React$1.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/v2/components/chat/CopilotChatSuggestionView.d.ts
+declare const DefaultContainer: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+type CopilotChatSuggestionViewProps = WithSlots<{
+  container: typeof DefaultContainer;
+  suggestion: typeof CopilotChatSuggestionPill;
+}, {
+  suggestions: Suggestion[];
+  onSelectSuggestion?: (suggestion: Suggestion, index: number) => void;
+  loadingIndexes?: ReadonlyArray<number>;
+} & React$1.HTMLAttributes<HTMLDivElement>>;
+declare const CopilotChatSuggestionView: React$1.ForwardRefExoticComponent<{
+  container?: SlotValue<React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>> | undefined;
+  suggestion?: SlotValue<React$1.ForwardRefExoticComponent<CopilotChatSuggestionPillProps & React$1.RefAttributes<HTMLButtonElement>>> | undefined;
+} & {
+  children?: ((props: {
+    container: React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+    suggestion: React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+  } & {
+    suggestions: Suggestion[];
+    onSelectSuggestion?: (suggestion: Suggestion, index: number) => void;
+    loadingIndexes?: ReadonlyArray<number>;
+  } & React$1.HTMLAttributes<HTMLDivElement>) => React$1.ReactNode) | undefined;
+} & Omit<{
+  suggestions: Suggestion[];
+  onSelectSuggestion?: (suggestion: Suggestion, index: number) => void;
+  loadingIndexes?: ReadonlyArray<number>;
+} & React$1.HTMLAttributes<HTMLDivElement>, "children"> & React$1.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/v2/components/chat/CopilotChatMessageView.d.ts
+type CopilotChatMessageViewProps = Omit<WithSlots<{
+  assistantMessage: typeof CopilotChatAssistantMessage;
+  userMessage: typeof CopilotChatUserMessage;
+  reasoningMessage: typeof CopilotChatReasoningMessage;
+  cursor: typeof CopilotChatMessageView.Cursor;
+}, {
+  isRunning?: boolean;
+  messages?: Message$2[];
+} & React$1.HTMLAttributes<HTMLDivElement>>, "children"> & {
+  children?: (props: {
+    isRunning: boolean;
+    messages: Message$2[];
+    messageElements: React$1.ReactElement[];
+    interruptElement: React$1.ReactElement | null;
+  }) => React$1.ReactElement;
+};
+declare function CopilotChatMessageView({
+  messages,
+  assistantMessage,
+  userMessage,
+  reasoningMessage,
+  cursor,
+  isRunning,
+  children,
+  className,
+  ...props
+}: CopilotChatMessageViewProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatMessageView {
+  var Cursor: ({
+    className,
+    ...props
+  }: React$1.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime0.JSX.Element;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatView.d.ts
+type WelcomeScreenProps = WithSlots<{
+  welcomeMessage: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+}, {
+  input: React$1.ReactElement;
+  suggestionView: React$1.ReactElement;
+} & React$1.HTMLAttributes<HTMLDivElement>>;
+type CopilotChatViewProps = WithSlots<{
+  messageView: typeof CopilotChatMessageView;
+  scrollView: typeof CopilotChatView.ScrollView;
+  input: typeof CopilotChatInput;
+  suggestionView: typeof CopilotChatSuggestionView;
+}, {
+  messages?: Message$2[];
+  autoScroll?: boolean;
+  isRunning?: boolean;
+  suggestions?: Suggestion[];
+  suggestionLoadingIndexes?: ReadonlyArray<number>;
+  onSelectSuggestion?: (suggestion: Suggestion, index: number) => void;
+  welcomeScreen?: SlotValue<React$1.FC<WelcomeScreenProps>> | boolean;
+  onSubmitMessage?: (value: string) => void;
+  onStop?: () => void;
+  inputMode?: CopilotChatInputMode;
+  inputValue?: string;
+  onInputChange?: (value: string) => void;
+  onStartTranscribe?: () => void;
+  onCancelTranscribe?: () => void;
+  onFinishTranscribe?: () => void;
+  onFinishTranscribeWithAudio?: (audioBlob: Blob) => Promise<void>;
+  /**
+   * @deprecated Use the `input` slot's `disclaimer` prop instead:
+   * ```tsx
+   * <CopilotChat input={{ disclaimer: MyDisclaimer }} />
+   * ```
+   */
+  disclaimer?: SlotValue<React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>>;
+} & React$1.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatView({
+  messageView,
+  input,
+  scrollView,
+  suggestionView,
+  welcomeScreen,
+  messages,
+  autoScroll,
+  isRunning,
+  suggestions,
+  suggestionLoadingIndexes,
+  onSelectSuggestion,
+  onSubmitMessage,
+  onStop,
+  inputMode,
+  inputValue,
+  onInputChange,
+  onStartTranscribe,
+  onCancelTranscribe,
+  onFinishTranscribe,
+  onFinishTranscribeWithAudio,
+  disclaimer,
+  children,
+  className,
+  ...props
+}: CopilotChatViewProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatView {
+  const ScrollView: React$1.FC<React$1.HTMLAttributes<HTMLDivElement> & {
+    autoScroll?: boolean;
+    scrollToBottomButton?: SlotValue<React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>>;
+    feather?: SlotValue<React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>>;
+    inputContainerHeight?: number;
+    isResizing?: boolean;
+  }>;
+  const ScrollToBottomButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const Feather: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+  const WelcomeMessage: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+  const WelcomeScreen: React$1.FC<WelcomeScreenProps>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChat.d.ts
+type CopilotChatProps = Omit<CopilotChatViewProps, "messages" | "isRunning" | "suggestions" | "suggestionLoadingIndexes" | "onSelectSuggestion"> & {
+  agentId?: string;
+  threadId?: string;
+  labels?: Partial<CopilotChatLabels>;
+  chatView?: SlotValue<typeof CopilotChatView>;
+  isModalDefaultOpen?: boolean;
+  /**
+   * Error handler scoped to this chat's agent. Fires in addition to the
+   * provider-level onError (does not suppress it). Receives only errors
+   * whose context.agentId matches this chat's agent.
+   */
+  onError?: (event: {
+    error: Error;
+    code: CopilotKitCoreErrorCode;
+    context: Record<string, any>;
+  }) => void | Promise<void>;
+};
+declare function CopilotChat({
+  agentId,
+  threadId,
+  labels,
+  chatView,
+  isModalDefaultOpen,
+  onError,
+  ...props
+}: CopilotChatProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChat {
+  const View: typeof CopilotChatView;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotChatToggleButton.d.ts
+declare const DefaultOpenIcon: React$1.FC<React$1.SVGProps<SVGSVGElement>>;
+declare const DefaultCloseIcon: React$1.FC<React$1.SVGProps<SVGSVGElement>>;
+interface CopilotChatToggleButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+  /** Optional slot override for the chat (closed) icon. */
+  openIcon?: SlotValue<typeof DefaultOpenIcon>;
+  /** Optional slot override for the close icon. */
+  closeIcon?: SlotValue<typeof DefaultCloseIcon>;
+}
+declare const CopilotChatToggleButton: React$1.ForwardRefExoticComponent<CopilotChatToggleButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/v2/components/chat/CopilotModalHeader.d.ts
+type HeaderSlots = {
+  titleContent: typeof CopilotModalHeader.Title;
+  closeButton: typeof CopilotModalHeader.CloseButton;
+};
+type HeaderRestProps = {
+  title?: string;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">;
+type CopilotModalHeaderProps = WithSlots<HeaderSlots, HeaderRestProps>;
+declare function CopilotModalHeader({
+  title,
+  titleContent,
+  closeButton,
+  children,
+  className,
+  ...rest
+}: CopilotModalHeaderProps): string | number | bigint | boolean | react_jsx_runtime0.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
+declare namespace CopilotModalHeader {
+  var displayName: string;
+}
+declare namespace CopilotModalHeader {
+  const Title: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+  const CloseButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotSidebarView.d.ts
+type CopilotSidebarViewProps = CopilotChatViewProps & {
+  header?: SlotValue<typeof CopilotModalHeader>;
+  toggleButton?: SlotValue<typeof CopilotChatToggleButton>;
+  width?: number | string;
+  defaultOpen?: boolean;
+};
+declare function CopilotSidebarView({
+  header,
+  toggleButton,
+  width,
+  defaultOpen,
+  ...props
+}: CopilotSidebarViewProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotSidebarView {
+  var displayName: string;
+}
+declare namespace CopilotSidebarView {
+  /**
+   * Sidebar-specific welcome screen layout:
+   * - Suggestions at the top
+   * - Welcome message in the middle
+   * - Input fixed at the bottom (like normal chat)
+   */
+  const WelcomeScreen: React$1.FC<WelcomeScreenProps>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotPopupView.d.ts
+type CopilotPopupViewProps = CopilotChatViewProps & {
+  header?: SlotValue<typeof CopilotModalHeader>;
+  toggleButton?: SlotValue<typeof CopilotChatToggleButton>;
+  width?: number | string;
+  height?: number | string;
+  clickOutsideToClose?: boolean;
+  defaultOpen?: boolean;
+};
+declare function CopilotPopupView({
+  header,
+  toggleButton,
+  width,
+  height,
+  clickOutsideToClose,
+  defaultOpen,
+  className,
+  ...restProps
+}: CopilotPopupViewProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotPopupView {
+  var displayName: string;
+}
+declare namespace CopilotPopupView {
+  /**
+   * Popup-specific welcome screen layout:
+   * - Welcome message centered vertically
+   * - Suggestions just above input
+   * - Input fixed at the bottom
+   */
+  const WelcomeScreen: React$1.FC<WelcomeScreenProps>;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotSidebar.d.ts
+type CopilotSidebarProps = Omit<CopilotChatProps, "chatView"> & {
+  header?: CopilotSidebarViewProps["header"];
+  toggleButton?: CopilotSidebarViewProps["toggleButton"];
+  defaultOpen?: boolean;
+  width?: number | string;
+};
+declare function CopilotSidebar({
+  header,
+  toggleButton,
+  defaultOpen,
+  width,
+  ...chatProps
+}: CopilotSidebarProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotSidebar {
+  var displayName: string;
+}
+//#endregion
+//#region src/v2/components/chat/CopilotPopup.d.ts
+type CopilotPopupProps = Omit<CopilotChatProps, "chatView"> & {
+  header?: CopilotPopupViewProps["header"];
+  toggleButton?: CopilotPopupViewProps["toggleButton"];
+  defaultOpen?: boolean;
+  width?: CopilotPopupViewProps["width"];
+  height?: CopilotPopupViewProps["height"];
+  clickOutsideToClose?: CopilotPopupViewProps["clickOutsideToClose"];
+};
+declare function CopilotPopup({
+  header,
+  toggleButton,
+  defaultOpen,
+  width,
+  height,
+  clickOutsideToClose,
+  ...chatProps
+}: CopilotPopupProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotPopup {
+  var displayName: string;
+}
+//#endregion
+//#region src/v2/components/WildcardToolCallRender.d.ts
+declare const WildcardToolCallRender: ReactToolCallRenderer<any>;
+//#endregion
+//#region src/v2/components/CopilotKitInspector.d.ts
+type CopilotKitInspectorBaseProps = {
+  core?: CopilotKitCore | null;
+  [key: string]: unknown;
+};
+interface CopilotKitInspectorProps extends CopilotKitInspectorBaseProps {}
+declare const CopilotKitInspector: react.FC<CopilotKitInspectorProps>;
+//#endregion
+//#region src/v2/components/MCPAppsActivityRenderer.d.ts
+/**
+ * Activity type for MCP Apps events - must match the middleware's MCPAppsActivityType
+ */
+declare const MCPAppsActivityType = "mcp-apps";
+declare const MCPAppsActivityContentSchema: z.ZodObject<{
+  result: z.ZodObject<{
+    content: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    structuredContent: z.ZodOptional<z.ZodAny>;
+    isError: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    content?: any[] | undefined;
+    structuredContent?: any;
+    isError?: boolean | undefined;
+  }, {
+    content?: any[] | undefined;
+    structuredContent?: any;
+    isError?: boolean | undefined;
+  }>;
+  resourceUri: z.ZodString;
+  serverHash: z.ZodString;
+  serverId: z.ZodOptional<z.ZodString>;
+  toolInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  result: {
+    content?: any[] | undefined;
+    structuredContent?: any;
+    isError?: boolean | undefined;
+  };
+  resourceUri: string;
+  serverHash: string;
+  serverId?: string | undefined;
+  toolInput?: Record<string, unknown> | undefined;
+}, {
+  result: {
+    content?: any[] | undefined;
+    structuredContent?: any;
+    isError?: boolean | undefined;
+  };
+  resourceUri: string;
+  serverHash: string;
+  serverId?: string | undefined;
+  toolInput?: Record<string, unknown> | undefined;
+}>;
+type MCPAppsActivityContent = z.infer<typeof MCPAppsActivityContentSchema>;
+/**
+ * Props for the activity renderer component
+ */
+interface MCPAppsActivityRendererProps {
+  activityType: string;
+  content: MCPAppsActivityContent;
+  message: unknown;
+  agent: AbstractAgent | undefined;
+}
+/**
+ * MCP Apps Extension Activity Renderer
+ *
+ * Renders MCP Apps UI in a sandboxed iframe with full protocol support.
+ * Fetches resource content on-demand via proxied MCP requests.
+ */
+declare const MCPAppsActivityRenderer: React$1.FC<MCPAppsActivityRendererProps>;
+//#endregion
+//#region src/v2/hooks/use-render-tool-call.d.ts
+interface UseRenderToolCallProps {
+  toolCall: ToolCall;
+  toolMessage?: ToolMessage;
+}
+/**
+ * Hook that returns a function to render tool calls based on the render functions
+ * defined in CopilotKitProvider.
+ *
+ * @returns A function that takes a tool call and optional tool message and returns the rendered component
+ */
+declare function useRenderToolCall(): ({
+  toolCall,
+  toolMessage
+}: UseRenderToolCallProps) => React$1.ReactElement | null;
+//#endregion
+//#region src/v2/types/react-custom-message-renderer.d.ts
+type ReactCustomMessageRendererPosition = "before" | "after";
+interface ReactCustomMessageRenderer {
+  agentId?: string;
+  render: React.ComponentType<{
+    message: Message$2;
+    position: ReactCustomMessageRendererPosition;
+    runId: string;
+    messageIndex: number;
+    messageIndexInRun: number;
+    numberOfMessagesInRun: number;
+    agentId: string;
+    stateSnapshot: any;
+  }> | null;
+}
+//#endregion
+//#region src/v2/hooks/use-render-custom-messages.d.ts
+interface UseRenderCustomMessagesParams {
+  message: Message$2;
+  position: ReactCustomMessageRendererPosition;
+}
+declare function useRenderCustomMessages(): ((params: UseRenderCustomMessagesParams) => react_jsx_runtime0.JSX.Element | null) | null;
+//#endregion
+//#region src/v2/types/react-tool-call-renderer.d.ts
+interface ReactToolCallRenderer<T = unknown> {
+  name: string;
+  args: StandardSchemaV1<any, T>;
+  /**
+   * Optional agent ID to constrain this tool renderer to a specific agent.
+   * If specified, this renderer will only be used for the specified agent.
+   */
+  agentId?: string;
+  render: React.ComponentType<{
+    name: string;
+    args: Partial<T>;
+    status: ToolCallStatus.InProgress;
+    result: undefined;
+  } | {
+    name: string;
+    args: T;
+    status: ToolCallStatus.Executing;
+    result: undefined;
+  } | {
+    name: string;
+    args: T;
+    status: ToolCallStatus.Complete;
+    result: string;
+  }>;
+}
+//#endregion
+//#region src/v2/types/react-activity-message-renderer.d.ts
+interface ReactActivityMessageRenderer<TActivityContent> {
+  /**
+   * Activity type to match when rendering. Use "*" as a wildcard renderer.
+   */
+  activityType: string;
+  /**
+   * Optional agent ID to scope the renderer to a particular agent.
+   */
+  agentId?: string;
+  /**
+   * Schema describing the activity content payload.
+   */
+  content: StandardSchemaV1<any, TActivityContent>;
+  /**
+   * React component invoked to render the activity message.
+   */
+  render: React.ComponentType<{
+    activityType: string;
+    content: TActivityContent;
+    message: ActivityMessage;
+    agent: AbstractAgent | undefined;
+  }>;
+}
+//#endregion
+//#region src/v2/types/frontend-tool.d.ts
+type ReactFrontendTool<T extends Record<string, unknown> = Record<string, unknown>> = FrontendTool<T> & {
+  render?: ReactToolCallRenderer<T>["render"];
+};
+//#endregion
+//#region src/v2/types/human-in-the-loop.d.ts
+type ReactHumanInTheLoop<T extends Record<string, unknown> = Record<string, unknown>> = Omit<FrontendTool<T>, "handler"> & {
+  render: React$1.ComponentType<{
+    name: string;
+    description: string;
+    args: Partial<T>;
+    status: ToolCallStatus.InProgress;
+    result: undefined;
+    respond: undefined;
+  } | {
+    name: string;
+    description: string;
+    args: T;
+    status: ToolCallStatus.Executing;
+    result: undefined;
+    respond: (result: unknown) => Promise<void>;
+  } | {
+    name: string;
+    description: string;
+    args: T;
+    status: ToolCallStatus.Complete;
+    result: string;
+    respond: undefined;
+  }>;
+};
+//#endregion
+//#region src/v2/types/defineToolCallRenderer.d.ts
+/**
+ * Helper to define a type-safe tool call renderer entry.
+ * - Accepts a single object whose keys match ReactToolCallRenderer's fields: { name, args, render, agentId? }.
+ * - Derives `args` type from the provided schema (any Standard Schema V1 compatible library).
+ * - Ensures the render function param type exactly matches ReactToolCallRenderer<T>["render"]'s param.
+ * - For wildcard tools (name: "*"), args is optional and defaults to z.any()
+ */
+type RenderProps<T> = {
+  name: string;
+  args: Partial<T>;
+  status: ToolCallStatus.InProgress;
+  result: undefined;
+} | {
+  name: string;
+  args: T;
+  status: ToolCallStatus.Executing;
+  result: undefined;
+} | {
+  name: string;
+  args: T;
+  status: ToolCallStatus.Complete;
+  result: string;
+};
+declare function defineToolCallRenderer(def: {
+  name: "*";
+  render: (props: RenderProps<any>) => React$1.ReactElement;
+  agentId?: string;
+}): ReactToolCallRenderer<any>;
+declare function defineToolCallRenderer<S extends StandardSchemaV1>(def: {
+  name: string;
+  args: S;
+  render: (props: RenderProps<InferSchemaOutput<S>>) => React$1.ReactElement;
+  agentId?: string;
+}): ReactToolCallRenderer<InferSchemaOutput<S>>;
+//#endregion
+//#region src/v2/types/interrupt.d.ts
+interface InterruptEvent<TValue = unknown> {
+  name: string;
+  value: TValue;
+}
+interface InterruptHandlerProps<TValue = unknown> {
+  event: InterruptEvent<TValue>;
+  resolve: (response: unknown) => void;
+}
+interface InterruptRenderProps<TValue = unknown, TResult = unknown> {
+  event: InterruptEvent<TValue>;
+  result: TResult;
+  resolve: (response: unknown) => void;
+}
+//#endregion
+//#region src/v2/hooks/use-render-activity-message.d.ts
+declare function useRenderActivityMessage(): {
+  renderActivityMessage: (message: ActivityMessage) => React.ReactElement | null;
+  findRenderer: (activityType: string) => ReactActivityMessageRenderer<unknown> | null;
+};
+//#endregion
+//#region src/v2/hooks/use-frontend-tool.d.ts
+declare function useFrontendTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: ReactFrontendTool<T>, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-component.d.ts
+type InferRenderProps<T> = T extends StandardSchemaV1 ? InferSchemaOutput<T> : any;
+/**
+ * Registers a React component as a frontend tool renderer in chat.
+ *
+ * This hook is a convenience wrapper around `useFrontendTool` that:
+ * - builds a model-facing tool description,
+ * - forwards optional schema parameters (any Standard Schema V1 compatible library),
+ * - renders your component with tool call parameters.
+ *
+ * Use this when you want to display a typed visual component for a tool call
+ * without manually wiring a full frontend tool object.
+ *
+ * When `parameters` is provided, render props are inferred from the schema.
+ * When omitted, the render component may accept any props.
+ *
+ * @typeParam TSchema - Schema describing tool parameters, or `undefined` when no schema is given.
+ * @param config - Tool registration config.
+ * @param deps - Optional dependencies to refresh registration (same semantics as `useEffect`).
+ *
+ * @example
+ * ```tsx
+ * // Without parameters — render accepts any props
+ * useComponent({
+ *   name: "showGreeting",
+ *   render: ({ message }: { message: string }) => <div>{message}</div>,
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With parameters — render props inferred from schema
+ * useComponent({
+ *   name: "showWeatherCard",
+ *   parameters: z.object({ city: z.string() }),
+ *   render: ({ city }) => <div>{city}</div>,
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * useComponent(
+ *   {
+ *     name: "renderProfile",
+ *     parameters: z.object({ userId: z.string() }),
+ *     render: ProfileCard,
+ *     agentId: "support-agent",
+ *   },
+ *   [selectedAgentId],
+ * );
+ * ```
+ */
+declare function useComponent<TSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+  name: string;
+  description?: string;
+  parameters?: TSchema;
+  render: ComponentType<NoInfer<InferRenderProps<TSchema>>>;
+  agentId?: string;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-render-tool.d.ts
+interface RenderToolInProgressProps<S extends StandardSchemaV1> {
+  name: string;
+  parameters: Partial<InferSchemaOutput<S>>;
+  status: "inProgress";
+  result: undefined;
+}
+interface RenderToolExecutingProps<S extends StandardSchemaV1> {
+  name: string;
+  parameters: InferSchemaOutput<S>;
+  status: "executing";
+  result: undefined;
+}
+interface RenderToolCompleteProps<S extends StandardSchemaV1> {
+  name: string;
+  parameters: InferSchemaOutput<S>;
+  status: "complete";
+  result: string;
+}
+type RenderToolProps<S extends StandardSchemaV1> = RenderToolInProgressProps<S> | RenderToolExecutingProps<S> | RenderToolCompleteProps<S>;
+/**
+ * Registers a wildcard (`"*"`) renderer for tool calls.
+ *
+ * The wildcard renderer is used as a fallback when no exact name-matched
+ * renderer is registered for a tool call.
+ *
+ * @param config - Wildcard renderer configuration.
+ * @param deps - Optional dependencies to refresh registration.
+ *
+ * @example
+ * ```tsx
+ * useRenderTool(
+ *   {
+ *     name: "*",
+ *     render: ({ name, status }) => (
+ *       <div>
+ *         {status === "complete" ? "✓" : "⏳"} {name}
+ *       </div>
+ *     ),
+ *   },
+ *   [],
+ * );
+ * ```
+ */
+declare function useRenderTool(config: {
+  name: "*";
+  render: (props: any) => React.ReactElement;
+  agentId?: string;
+}, deps?: ReadonlyArray<unknown>): void;
+/**
+ * Registers a name-scoped renderer for tool calls.
+ *
+ * The provided `parameters` schema defines the typed shape of `props.parameters`
+ * in `render` for `executing` and `complete` states. Accepts any Standard Schema V1
+ * compatible library (Zod, Valibot, ArkType, etc.).
+ *
+ * @typeParam S - Schema type describing tool call parameters.
+ * @param config - Named renderer configuration.
+ * @param deps - Optional dependencies to refresh registration.
+ *
+ * @example
+ * ```tsx
+ * useRenderTool(
+ *   {
+ *     name: "searchDocs",
+ *     parameters: z.object({ query: z.string() }),
+ *     render: ({ status, parameters, result }) => {
+ *       if (status === "inProgress") return <div>Preparing...</div>;
+ *       if (status === "executing") return <div>Searching {parameters.query}</div>;
+ *       return <div>{result}</div>;
+ *     },
+ *   },
+ *   [],
+ * );
+ * ```
+ */
+declare function useRenderTool<S extends StandardSchemaV1>(config: {
+  name: string;
+  parameters: S;
+  render: (props: RenderToolProps<S>) => React.ReactElement;
+  agentId?: string;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-default-render-tool.d.ts
+type DefaultRenderProps = {
+  /** The name of the tool being called. */name: string; /** The parsed parameters passed to the tool call. */
+  parameters: unknown; /** Current execution status of the tool call. */
+  status: "inProgress" | "executing" | "complete"; /** The tool call result string, available only when `status` is `"complete"`. */
+  result: string | undefined;
+};
+/**
+ * Registers a wildcard (`"*"`) tool-call renderer via `useRenderTool`.
+ *
+ * - Call with no config to use CopilotKit's built-in default tool-call card.
+ * - Pass `config.render` to replace the default UI with your own fallback renderer.
+ *
+ * This is useful when you want a generic renderer for tools that do not have a
+ * dedicated `useRenderTool({ name: "..." })` registration.
+ *
+ * @param config - Optional custom wildcard render function.
+ * @param deps - Optional dependencies to refresh registration.
+ *
+ * @example
+ * ```tsx
+ * useDefaultRenderTool();
+ * ```
+ *
+ * @example
+ * ```tsx
+ * useDefaultRenderTool({
+ *   render: ({ name, status }) => <div>{name}: {status}</div>,
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * useDefaultRenderTool(
+ *   {
+ *     render: ({ name, result }) => (
+ *       <ToolEventRow title={name} payload={result} compact={compactMode} />
+ *     ),
+ *   },
+ *   [compactMode],
+ * );
+ * ```
+ */
+declare function useDefaultRenderTool(config?: {
+  render?: (props: DefaultRenderProps) => React$1.ReactElement;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-human-in-the-loop.d.ts
+declare function useHumanInTheLoop<T extends Record<string, unknown> = Record<string, unknown>>(tool: ReactHumanInTheLoop<T>, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-agent.d.ts
+declare enum UseAgentUpdate {
+  OnMessagesChanged = "OnMessagesChanged",
+  OnStateChanged = "OnStateChanged",
+  OnRunStatusChanged = "OnRunStatusChanged"
+}
+interface UseAgentProps {
+  agentId?: string;
+  updates?: UseAgentUpdate[];
+}
+declare function useAgent({
+  agentId,
+  updates
+}?: UseAgentProps): {
+  agent: AbstractAgent;
+};
+//#endregion
+//#region src/v2/hooks/use-agent-context.d.ts
+/**
+ * Represents any value that can be serialized to JSON.
+ */
+type JsonSerializable = string | number | boolean | null | JsonSerializable[] | {
+  [key: string]: JsonSerializable;
+};
+/**
+ * Context configuration for useAgentContext.
+ * Accepts any JSON-serializable value which will be converted to a string.
+ */
+interface AgentContextInput {
+  /** A human-readable description of what this context represents */
+  description: string;
+  /** The context value - will be converted to a JSON string if not already a string */
+  value: JsonSerializable;
+}
+declare function useAgentContext(context: AgentContextInput): void;
+//#endregion
+//#region src/v2/hooks/use-suggestions.d.ts
+interface UseSuggestionsOptions {
+  agentId?: string;
+}
+interface UseSuggestionsResult {
+  suggestions: Suggestion[];
+  reloadSuggestions: () => void;
+  clearSuggestions: () => void;
+  isLoading: boolean;
+}
+declare function useSuggestions({
+  agentId
+}?: UseSuggestionsOptions): UseSuggestionsResult;
+//#endregion
+//#region src/v2/hooks/use-configure-suggestions.d.ts
+type StaticSuggestionInput = Omit<Suggestion, "isLoading"> & Partial<Pick<Suggestion, "isLoading">>;
+type StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig, "suggestions"> & {
+  suggestions: StaticSuggestionInput[];
+};
+type SuggestionsConfigInput = DynamicSuggestionsConfig | StaticSuggestionsConfigInput;
+declare function useConfigureSuggestions(config: SuggestionsConfigInput | null | undefined, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/v2/hooks/use-interrupt.d.ts
+type InterruptHandlerFn<TValue, TResult> = (props: InterruptHandlerProps<TValue>) => TResult | PromiseLike<TResult>;
+type InterruptResultFromHandler<THandler> = THandler extends ((...args: never[]) => infer TResult) ? TResult extends PromiseLike<infer TResolved> ? TResolved | null : TResult | null : null;
+type InterruptResult<TValue, TResult> = InterruptResultFromHandler<InterruptHandlerFn<TValue, TResult>>;
+type InterruptRenderInChat = boolean | undefined;
+type UseInterruptReturn<TRenderInChat extends InterruptRenderInChat> = TRenderInChat extends false ? React$1.ReactElement | null : TRenderInChat extends true | undefined ? void : React$1.ReactElement | null | void;
+/**
+ * Configuration options for `useInterrupt`.
+ */
+interface UseInterruptConfigBase<TValue = unknown, TResult = never> {
+  /**
+   * Render function for the interrupt UI.
+   *
+   * This is called once an interrupt is finalized and accepted by `enabled` (if provided).
+   * Use `resolve` from render props to resume the agent run with user input.
+   */
+  render: (props: InterruptRenderProps<TValue, InterruptResult<TValue, TResult>>) => React$1.ReactElement;
+  /**
+   * Optional pre-render handler invoked when an interrupt is received.
+   *
+   * Return either a sync value or an async value to pass into `render` as `result`.
+   * Rejecting/throwing falls back to `result = null`.
+   */
+  handler?: InterruptHandlerFn<TValue, TResult>;
+  /**
+   * Optional predicate to filter which interrupts should be handled by this hook.
+   * Return `false` to ignore an interrupt.
+   */
+  enabled?: (event: InterruptEvent<TValue>) => boolean;
+  /** Optional agent id. Defaults to the current configured chat agent. */
+  agentId?: string;
+}
+type UseInterruptConfig<TValue = unknown, TResult = never, TRenderInChat extends InterruptRenderInChat = undefined> = UseInterruptConfigBase<TValue, TResult> & {
+  /** When true (default), the interrupt UI renders inside `<CopilotChat>` automatically. Set to false to render it yourself. */renderInChat?: TRenderInChat;
+};
+/**
+ * Handles agent interrupts (`on_interrupt`) with optional filtering, preprocessing, and resume behavior.
+ *
+ * The hook listens to custom events on the active agent, stores interrupt payloads per run,
+ * and surfaces a render callback once the run finalizes. Call `resolve` from your UI to resume
+ * execution with user-provided data.
+ *
+ * - `renderInChat: true` (default): the element is published into `<CopilotChat>` and this hook returns `void`.
+ * - `renderInChat: false`: the hook returns the interrupt element so you can place it anywhere in your component tree.
+ *
+ * `event.value` is typed as `any` since the interrupt payload shape depends on your agent.
+ * Type-narrow it in your callbacks (e.g. `handler`, `enabled`, `render`) as needed.
+ *
+ * @typeParam TResult - Inferred from `handler` return type. Exposed as `result` in `render`.
+ * @param config - Interrupt configuration (renderer, optional handler/filter, and render mode).
+ * @returns When `renderInChat` is `false`, returns the interrupt element (or `null` when idle).
+ * Otherwise returns `void` and publishes the element into chat. In `render`, `result` is always
+ * either the handler's resolved return value or `null` (including when no handler is provided,
+ * when filtering skips the interrupt, or when handler execution fails).
+ *
+ * @example
+ * ```tsx
+ * import { useInterrupt } from "@copilotkit/react-core/v2";
+ *
+ * function InterruptUI() {
+ *   useInterrupt({
+ *     render: ({ event, resolve }) => (
+ *       <div>
+ *         <p>{event.value.question}</p>
+ *         <button onClick={() => resolve({ approved: true })}>Approve</button>
+ *         <button onClick={() => resolve({ approved: false })}>Reject</button>
+ *       </div>
+ *     ),
+ *   });
+ *
+ *   return null;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * import { useInterrupt } from "@copilotkit/react-core/v2";
+ *
+ * function CustomPanel() {
+ *   const interruptElement = useInterrupt({
+ *     renderInChat: false,
+ *     enabled: (event) => event.value.startsWith("approval:"),
+ *     handler: async ({ event }) => ({ label: event.value.toUpperCase() }),
+ *     render: ({ event, result, resolve }) => (
+ *       <aside>
+ *         <strong>{result?.label ?? ""}</strong>
+ *         <button onClick={() => resolve({ value: event.value })}>Continue</button>
+ *       </aside>
+ *     ),
+ *   });
+ *
+ *   return <>{interruptElement}</>;
+ * }
+ * ```
+ */
+declare function useInterrupt<TResult = never, TRenderInChat extends InterruptRenderInChat = undefined>(config: UseInterruptConfig<any, TResult, TRenderInChat>): UseInterruptReturn<TRenderInChat>;
+//#endregion
+//#region src/v2/hooks/use-threads.d.ts
+/**
+ * A conversation thread managed by the Intelligence platform.
+ *
+ * Each thread has a unique `id`, an optional human-readable `name`, and
+ * timestamp fields tracking creation and update times.
+ */
+interface Thread extends ɵThread {}
+/**
+ * Configuration for the {@link useThreads} hook.
+ *
+ * Thread operations are scoped to the runtime-authenticated user and the
+ * provided agent on the Intelligence platform.
+ */
+interface UseThreadsInput {
+  /** The ID of the agent whose threads to list and manage. */
+  agentId: string;
+  /** When `true`, archived threads are included in the list. Defaults to `false`. */
+  includeArchived?: boolean;
+  /** Maximum number of threads to fetch per page. When set, enables cursor-based pagination. */
+  limit?: number;
+}
+/**
+ * Return value of the {@link useThreads} hook.
+ *
+ * The `threads` array is kept in sync with the platform via a realtime
+ * WebSocket subscription (when available) and is sorted most-recently-updated
+ * first. Mutations reject with an `Error` if the platform request fails.
+ */
+interface UseThreadsResult {
+  /**
+   * Threads for the current user/agent pair, sorted by most recently
+   * updated first. Updated in realtime when the platform pushes metadata
+   * events. Includes archived threads only when `includeArchived` is set.
+   */
+  threads: Thread[];
+  /**
+   * `true` while the initial thread list is being fetched from the platform.
+   * Subsequent realtime updates do not re-enter the loading state.
+   */
+  isLoading: boolean;
+  /**
+   * The most recent error from fetching threads or executing a mutation,
+   * or `null` when there is no error. Reset to `null` on the next
+   * successful fetch.
+   */
+  error: Error | null;
+  /**
+   * `true` when there are more threads available to fetch via
+   * {@link fetchNextPage}. Only meaningful when `limit` is set.
+   */
+  hasNextPage: boolean;
+  /**
+   * `true` while a subsequent page of threads is being fetched.
+   */
+  isFetchingNextPage: boolean;
+  /**
+   * Fetch the next page of threads. No-op when {@link hasNextPage} is
+   * `false` or a page fetch is already in progress.
+   */
+  fetchNextPage: () => void;
+  /**
+   * Rename a thread on the platform.
+   * Resolves when the server confirms the update; rejects on failure.
+   */
+  renameThread: (threadId: string, name: string) => Promise<void>;
+  /**
+   * Archive a thread on the platform.
+   * Archived threads are excluded from subsequent list results.
+   * Resolves when the server confirms the update; rejects on failure.
+   */
+  archiveThread: (threadId: string) => Promise<void>;
+  /**
+   * Permanently delete a thread from the platform.
+   * This is irreversible. Resolves when the server confirms deletion;
+   * rejects on failure.
+   */
+  deleteThread: (threadId: string) => Promise<void>;
+}
+/**
+ * React hook for listing and managing Intelligence platform threads.
+ *
+ * On mount the hook fetches the thread list for the runtime-authenticated user
+ * and the given `agentId`. When the Intelligence platform exposes a WebSocket
+ * URL, it also opens a realtime subscription so the `threads` array stays
+ * current without polling — thread creates, renames, archives, and deletes
+ * from any client are reflected immediately.
+ *
+ * Mutation methods (`renameThread`, `archiveThread`, `deleteThread`) return
+ * promises that resolve once the platform confirms the operation and reject
+ * with an `Error` on failure.
+ *
+ * @param input - Agent identifier and optional list controls.
+ * @returns Thread list state and stable mutation callbacks.
+ *
+ * @example
+ * ```tsx
+ * import { useThreads } from "@copilotkit/react-core";
+ *
+ * function ThreadList() {
+ *   const { threads, isLoading, renameThread, deleteThread } = useThreads({
+ *     agentId: "agent-1",
+ *   });
+ *
+ *   if (isLoading) return <p>Loading…</p>;
+ *
+ *   return (
+ *     <ul>
+ *       {threads.map((t) => (
+ *         <li key={t.id}>
+ *           {t.name ?? "Untitled"}
+ *           <button onClick={() => renameThread(t.id, "New name")}>Rename</button>
+ *           <button onClick={() => deleteThread(t.id)}>Delete</button>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useThreads({
+  agentId,
+  includeArchived,
+  limit
+}: UseThreadsInput): UseThreadsResult;
+//#endregion
+//#region src/v2/lib/react-core.d.ts
+interface CopilotKitCoreReactConfig extends CopilotKitCoreConfig {
+  renderToolCalls?: ReactToolCallRenderer<any>[];
+  renderActivityMessages?: ReactActivityMessageRenderer<any>[];
+  renderCustomMessages?: ReactCustomMessageRenderer[];
+}
+interface CopilotKitCoreReactSubscriber extends CopilotKitCoreSubscriber {
+  onRenderToolCallsChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    renderToolCalls: ReactToolCallRenderer<any>[];
+  }) => void | Promise<void>;
+  onInterruptElementChanged?: (event: {
+    copilotkit: CopilotKitCore;
+    interruptElement: React$1.ReactElement | null;
+  }) => void | Promise<void>;
+}
+declare class CopilotKitCoreReact extends CopilotKitCore {
+  private _renderToolCalls;
+  private _hookRenderToolCalls;
+  private _cachedMergedRenderToolCalls;
+  private _renderCustomMessages;
+  private _renderActivityMessages;
+  private _interruptElement;
+  constructor(config: CopilotKitCoreReactConfig);
+  get renderCustomMessages(): Readonly<ReactCustomMessageRenderer[]>;
+  get renderActivityMessages(): Readonly<ReactActivityMessageRenderer<any>>[];
+  get renderToolCalls(): Readonly<ReactToolCallRenderer<any>>[];
+  setRenderActivityMessages(renderers: ReactActivityMessageRenderer<any>[]): void;
+  setRenderCustomMessages(renderers: ReactCustomMessageRenderer[]): void;
+  setRenderToolCalls(renderToolCalls: ReactToolCallRenderer<any>[]): void;
+  addHookRenderToolCall(entry: ReactToolCallRenderer<any>): void;
+  removeHookRenderToolCall(name: string, agentId?: string): void;
+  private _notifyRenderToolCallsChanged;
+  get interruptElement(): React$1.ReactElement | null;
+  setInterruptElement(element: React$1.ReactElement | null): void;
+  subscribe(subscriber: CopilotKitCoreReactSubscriber): CopilotKitCoreSubscription;
+  /**
+   * Wait for pending React state updates before the follow-up agent run.
+   *
+   * When a frontend tool handler calls setState(), React 18 batches the update
+   * and schedules a commit via its internal scheduler (MessageChannel). The
+   * useAgentContext hook registers context via useLayoutEffect, which runs
+   * synchronously after React commits that batch.
+   *
+   * Awaiting a zero-delay timeout yields to the macrotask queue. React's
+   * MessageChannel task runs first, committing the pending state and running
+   * useLayoutEffect (which updates the context store). The follow-up runAgent
+   * call then reads fresh context.
+   */
+  waitForPendingFrameworkUpdates(): Promise<void>;
+}
+//#endregion
+//#region src/v2/providers/CopilotKitProvider.d.ts
+interface CopilotKitContextValue {
+  copilotkit: CopilotKitCoreReact;
+  /**
+   * Set of tool call IDs currently being executed.
+   * This is tracked at the provider level to ensure tool execution events
+   * are captured even before child components mount.
+   */
+  executingToolCallIds: ReadonlySet<string>;
+}
+interface CopilotKitProviderProps {
+  children: ReactNode;
+  runtimeUrl?: string;
+  headers?: Record<string, string>;
+  /**
+   * Credentials mode for fetch requests (e.g., "include" for HTTP-only cookies in cross-origin requests).
+   */
+  credentials?: RequestCredentials;
+  /**
+   * The Copilot Cloud public API key.
+   */
+  publicApiKey?: string;
+  /**
+   * Alias for `publicApiKey`
+   **/
+  publicLicenseKey?: string;
+  /**
+   * Signed license token for offline verification of premium features.
+   * Obtain from https://cloud.copilotkit.ai.
+   */
+  licenseToken?: string;
+  properties?: Record<string, unknown>;
+  useSingleEndpoint?: boolean;
+  agents__unsafe_dev_only?: Record<string, AbstractAgent>;
+  selfManagedAgents?: Record<string, AbstractAgent>;
+  renderToolCalls?: ReactToolCallRenderer<any>[];
+  renderActivityMessages?: ReactActivityMessageRenderer<any>[];
+  renderCustomMessages?: ReactCustomMessageRenderer[];
+  frontendTools?: ReactFrontendTool[];
+  humanInTheLoop?: ReactHumanInTheLoop[];
+  showDevConsole?: boolean | "auto";
+  /**
+   * Error handler called when CopilotKit encounters an error.
+   * Fires for all error types (runtime connection failures, agent errors, tool errors).
+   */
+  onError?: (event: {
+    error: Error;
+    code: CopilotKitCoreErrorCode;
+    context: Record<string, any>;
+  }) => void | Promise<void>;
+  /**
+   * Configuration for the A2UI (Agent-to-UI) renderer.
+   * The built-in A2UI renderer is activated automatically when the runtime reports
+   * that `a2ui` is configured in `CopilotRuntime`. This prop is optional and only
+   * needed if you want to override the default theme.
+   *
+   * @example
+   * ```tsx
+   * <CopilotKit runtimeUrl="/api/copilotkit" a2ui={{ theme: myCustomTheme }}>
+   *   {children}
+   * </CopilotKit>
+   * ```
+   */
+  a2ui?: {
+    /**
+     * Override the default A2UI viewer theme.
+     * When omitted, the built-in `viewerTheme` from `@copilotkit/a2ui-renderer` is used.
+     */
+    theme?: Theme;
+  };
+}
+declare const CopilotKitProvider: React$1.FC<CopilotKitProviderProps>;
+declare const useCopilotKit: () => CopilotKitContextValue;
+//#endregion
+//#region src/v2/a2ui/A2UIMessageRenderer.d.ts
+type A2UIMessageRendererOptions = {
+  theme: Theme;
+};
+declare function createA2UIMessageRenderer(options: A2UIMessageRendererOptions): ReactActivityMessageRenderer<any>;
+//#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 { CopilotSidebar as $, CrewsAgentState as $t, useFrontendTool as A, CopilotChatInputProps as At, useRenderCustomMessages as B, CoagentInChatRenderFunction as Bt, useAgentContext as C, CopilotChatUserMessage as Ct, useDefaultRenderTool as D, CopilotChatToolCallsView as Dt, useHumanInTheLoop as E, CopilotChatAssistantMessageProps as Et, defineToolCallRenderer as F, CopilotChatLabels as Ft, MCPAppsActivityContentSchema as G, CoAgentStateRender as Gt, ReactCustomMessageRendererPosition as H, CopilotContext as Ht, ReactHumanInTheLoop as I, useCopilotChatConfiguration as It, CopilotKitInspector as J, LangGraphInterruptActionSetterArgs as Jt, MCPAppsActivityRenderer as K, LangGraphInterruptAction as Kt, ReactFrontendTool as L, AudioRecorderError as Lt, InterruptEvent as M, CopilotChatConfigurationProvider as Mt, InterruptHandlerProps as N, CopilotChatConfigurationProviderProps as Nt, useRenderTool as O, CopilotChatToolCallsViewProps as Ot, InterruptRenderProps as P, CopilotChatConfigurationValue as Pt, CopilotPopupProps as Q, QueuedInterruptEvent as Qt, ReactActivityMessageRenderer as R, AudioRecorderState as Rt, JsonSerializable as S, CopilotChatReasoningMessageProps as St, useAgent as T, CopilotChatAssistantMessage as Tt, useRenderToolCall as U, CopilotContextParams as Ut, ReactCustomMessageRenderer as V, CopilotApiConfig as Vt, MCPAppsActivityContent as W, useCopilotContext as Wt, WildcardToolCallRender as X, LangGraphInterruptRenderHandlerProps as Xt, CopilotKitInspectorProps as Y, LangGraphInterruptRender as Yt, CopilotPopup as Z, LangGraphInterruptRenderProps as Zt, UseInterruptConfig as _, FrontendActionAvailability as _n, CopilotChatSuggestionView as _t, createA2UIMessageRenderer as a, CopilotChatSuggestionConfiguration as an, CopilotModalHeader as at, useSuggestions as b, CopilotChatSuggestionPillProps as bt, CopilotKitProviderProps as c, Tree as cn, CopilotChatToggleButtonProps as ct, CopilotKitCoreReactConfig as d, ActionRenderPropsNoArgs as dn, CopilotChat as dt, CrewsResponse as en, CopilotSidebarProps as et, CopilotKitCoreReactSubscriber as f, ActionRenderPropsNoArgsWait as fn, CopilotChatProps as ft, useThreads as g, FrontendAction as gn, CopilotChatMessageViewProps as gt, UseThreadsResult as h, CatchAllFrontendAction as hn, CopilotChatMessageView as ht, A2UIMessageRendererOptions as i, CrewsToolStateItem as in, CopilotSidebarViewProps as it, useRenderActivityMessage as j, ToolsMenuItem as jt, useComponent as k, CopilotChatInput as kt, useCopilotKit as l, TreeNode as ln, DefaultCloseIcon as lt, UseThreadsInput as m, CatchAllActionRenderProps as mn, CopilotChatViewProps as mt, defaultCopilotContextCategories as n, CrewsStateItem as nn, CopilotPopupViewProps as nt, CopilotKitContextValue as o, SystemMessageFunction as on, CopilotModalHeaderProps as ot, Thread as p, ActionRenderPropsWait as pn, CopilotChatView as pt, MCPAppsActivityType as q, LangGraphInterruptActionSetter as qt, CopilotKitProps as r, CrewsTaskStateItem as rn, CopilotSidebarView as rt, CopilotKitProvider as s, DocumentPointer as sn, CopilotChatToggleButton as st, CopilotKit as t, CrewsResponseStatus as tn, CopilotPopupView as tt, CopilotKitCoreReact as u, ActionRenderProps as un, DefaultOpenIcon as ut, useInterrupt as v, RenderFunctionStatus as vn, CopilotChatSuggestionViewProps as vt, UseAgentUpdate as w, CopilotChatUserMessageProps as wt, AgentContextInput as x, CopilotChatReasoningMessage as xt, useConfigureSuggestions as y, CopilotChatSuggestionPill as yt, ReactToolCallRenderer as z, CopilotChatAudioRecorder as zt };
+//# sourceMappingURL=copilotkit-DBzgOMby.d.cts.map