@copilotkit/react-core 2.0.0-next.1 → 2.0.0-rc.1

package/dist/index.d.cts

@@ -0,0 +1,3450 @@
+import { a as useMarkdownRenderer, c as ReactActivityMessageRenderer, i as MarkdownRendererProvider, l as GenerativeUIConfig, n as MarkdownRenderer, r as MarkdownRendererProps, s as GenerativeUIChatSurfaceProps, t as DefaultMarkdownRendererProps } from "./MarkdownRendererContext-B4Us6mwL.cjs";
+import * as react from "react";
+import React$1, { ComponentType, ReactNode } from "react";
+import { Attachment, Attachment as Attachment$1, AttachmentModality, AttachmentsConfig, AttachmentsConfig as AttachmentsConfig$1, DebugConfig, InferSchemaOutput, InputContentSource as InputContentSource$1, LicenseContextValue, StandardSchemaV1 } from "@copilotkit/shared";
+import { z } from "zod";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ActivityMessage as ActivityMessage$1, AgentCapabilities as AgentCapabilities$1, AssistantMessage as AssistantMessage$1, Message as Message$1, ReasoningMessage as ReasoningMessage$1, ToolCall as ToolCall$1, ToolMessage as ToolMessage$1, UserMessage as UserMessage$1 } from "@ag-ui/core";
+import { ACTIVITY_HISTORY_METADATA, AGUIConnectNotImplementedError, AGUIError, AGUIEvent, AGUIEventByType, AGUIEventOf, AGUI_METADATA_KEY, AbstractAgent, AbstractAgent as AbstractAgent$1, ActivityDeltaEvent, ActivityDeltaEventProps, ActivityMessage, ActivitySnapshotEvent, ActivitySnapshotEventProps, AddOperation, AgentCapabilities, AgentConfig, AgentDebugConfig, AgentStateMutation, AgentSubscriber, AgentSubscriberParams, AssistantMessage, Attributable, AudioInputContent, AudioInputPart, AudioPart, BackwardCompatibility_0_0_39, BackwardCompatibility_0_0_45, BackwardCompatibility_0_0_57, BaseEvent, BaseEventFields, BaseEventProps, BaseMessage, CompatibilityBoundary, ContentPart, Context, CopyOperation, CustomEvent, CustomEventProps, DataSource, DebugLogger, DebugLoggerInput, DeveloperMessage, DocumentInputContent, DocumentInputPart, DocumentPart, Event, EventPayloadOf, EventType, ExecutionCapabilities, FileSource, FilterToolCallsMiddleware, FunctionCall, FunctionMiddleware, HttpAgent, HttpAgentConfig, HttpAgentFetchFn, HumanInTheLoopCapabilities, IdentityCapabilities, ImageInputContent, ImageInputPart, ImagePart, InputContent, InputContentDataSource, InputContentPart, InputContentSource, InputContentUrlSource, Interrupt, JsonPatch, JsonPatchOperation, JsonPointer, Message, MessagesSnapshotEvent, MessagesSnapshotEventProps, Metadata, Middleware, MiddlewareFunction, MoveOperation, MultiAgentCapabilities, MultimodalCapabilities, MultimodalInputCapabilities, MultimodalOutputCapabilities, OutputCapabilities, PROTOCOL_VERSION, PartSource, RawEvent, RawEventProps, ReasoningCapabilities, ReasoningEncryptedValueEvent, ReasoningEncryptedValueEventProps, ReasoningEncryptedValueSubtype, ReasoningEndEvent, ReasoningEndEventProps, ReasoningMessage, ReasoningMessageChunkEvent, ReasoningMessageChunkEventProps, ReasoningMessageContentEvent, ReasoningMessageContentEventProps, ReasoningMessageEndEvent, ReasoningMessageEndEventProps, ReasoningMessageStartEvent, ReasoningMessageStartEventProps, ReasoningStartEvent, ReasoningStartEventProps, RemoveOperation, ReplaceOperation, ResolvedAgentDebugConfig, ResumeEntry, ResumeStatus, Role, RunAgentInput, RunAgentParameters, RunAgentResult, RunAgentResult as RunAgentResult$1, RunErrorEvent, RunErrorEventProps, RunFinishedCancelledOutcome, RunFinishedEvent, RunFinishedEventProps, RunFinishedInterruptOutcome, RunFinishedOutcome, RunFinishedSuccessOutcome, RunStartedEvent, RunStartedEventProps, State, StateCapabilities, StateDeltaEvent, StateDeltaEventProps, StateSnapshotEvent, StateSnapshotEventProps, StepFinishedEvent, StepFinishedEventProps, StepStartedEvent, StepStartedEventProps, SubagentErrorEvent, SubagentErrorEventProps, SubagentFinishedEvent, SubagentFinishedEventProps, SubagentFinishedOutcome, SubagentFinishedSuccessOutcome, SubagentFinishedSuspendedOutcome, SubagentInfo, SubagentRunId, SubagentStartedEvent, SubagentStartedEventProps, SystemMessage, TestOperation, TextInputContent, TextMessageChunkEvent, TextMessageChunkEventProps, TextMessageContentEvent, TextMessageContentEventProps, TextMessageEndEvent, TextMessageEndEventProps, TextMessageRole, TextMessageStartEvent, TextMessageStartEventProps, TextPart, TokenUsage, Tool, ToolCall, ToolCallArgsEvent, ToolCallArgsEventProps, ToolCallChunkEvent, ToolCallChunkEventProps, ToolCallEndEvent, ToolCallEndEventProps, ToolCallResultEvent, ToolCallResultEventProps, ToolCallStartEvent, ToolCallStartEventProps, ToolMessage, ToolsCapabilities, TransportCapabilities, UnrecognizedEvent, UrlSource, UserMessage, VideoInputContent, VideoInputPart, VideoPart, aggregateTokenUsage, authoritativeActivityTypes, buildResumeArray, compactEvents, contentHasMedia, contentToText, convertToLegacyEvents, createDebugLogger, defaultApplyEvents, enforceEvents, enforceOutgoingInput, getRunOutcome, isInterruptExpired, isRecognizedEvent, mergeMetadata, omitOptionalNulls, parseProtoStream, parseSSEStream, randomUUID, resolveAgentDebugConfig, resolveDebugLogger, runHttpRequest, structuredClone_, tokenUsageFromAiSdkUsage, tokenUsageFromLangChainMetadata, transformChunks, transformHttpEventStream, verifyEvents, withAuthoritativeActivityTypes } from "@ag-ui/client";
+import { A2UIMarkdownOperation, A2UI_FENCE_LANGUAGE, ActionConfig, ActionCreator, ActionFromCreator, ActionFromCreators, ActionGroupConfig, ActionGroupResult, AgentRegistry, AgentThreadLockedError, AnyAction, ChildIdsOf, ChildWalkOptions, ContextStore, CopilotKitCore, CopilotKitCore as CopilotKitCore$1, CopilotKitCoreAddAgentParams, CopilotKitCoreCatalogComponent, CopilotKitCoreConfig, CopilotKitCoreConfig as CopilotKitCoreConfig$1, CopilotKitCoreConnectAgentParams, CopilotKitCoreContinuationHandoff, CopilotKitCoreErrorCode, CopilotKitCoreErrorCode as CopilotKitCoreErrorCode$1, CopilotKitCoreFriendsAccess, CopilotKitCoreGetSuggestionsResult, CopilotKitCoreGetToolParams, CopilotKitCoreRegisterProxiedAgentParams, CopilotKitCoreRegisterProxiedAgentResult, CopilotKitCoreRunAgentParams, CopilotKitCoreRunToolParams, CopilotKitCoreRunToolResult, CopilotKitCoreRuntimeConnectionStatus, CopilotKitCoreStopAgentParams, CopilotKitCoreSubscriber, CopilotKitCoreSubscriber as CopilotKitCoreSubscriber$1, CopilotKitCoreSubscription, CopilotKitCoreSubscription as CopilotKitCoreSubscription$1, CopilotKitHeaderResolutionError, CopilotKitHeadersSource, CopilotKitHeadersSource as CopilotKitHeadersSource$1, CopilotKitMessageFilter, CopilotKitMessageFilter as CopilotKitMessageFilter$1, CopilotRuntimeTransport, DispatchingEffect, DispatchingEffectOptions, DynamicSuggestionsConfig, DynamicSuggestionsConfig as DynamicSuggestionsConfig$1, Effect, EmptyActionConfig, FrontendTool, FrontendTool as FrontendTool$1, FrontendToolHandlerContext, FrontendToolReconnectBehavior, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, InspectorActiveThreadPayload, InspectorMetadataV1, InspectorStopViewingPayload, InspectorViewThreadPayload, InspectorViewThreadResultPayload, IntelligenceAgent, IntelligenceAgentConfig, IntelligenceRuntimeInfo, JsonValue, LearningConfig, LearningConfig as LearningConfig$1, LegacyLearningConfig, MEMORY_ERROR_REGISTRY, MarkdownSegment, MarkdownToken, MarkdownTokenList, Memory, Memory as Memory$1, MemoryChanges, MemoryChanges as MemoryChanges$1, MemoryError, MemoryErrorCategory, MemoryErrorCode, MemoryErrorRegistryEntry, MemoryKind, MemoryRealtimeStatus, MemoryRealtimeStatus as MemoryRealtimeStatus$1, MemoryScope, NewMemory, NewMemory as NewMemory$1, NonDispatchingEffect, NonDispatchingEffectOptions, OpenThreadRegistration, ParseMarkdownOptions, PropsActionConfig, ProxiedCopilotRuntimeAgent, ProxiedCopilotRuntimeAgentConfig, Reducer, RunCompletionAware, RunHandler, RuntimeLicenseStatus, RuntimeMode, ScopedContext, ScopedProperties, Selector, StartResult, StateManager, StaticSuggestionsConfig, StaticSuggestionsConfig as StaticSuggestionsConfig$1, Store, StoreLifecycleAction, SubscribeToAgentOptions, SubscribeToAgentSubscriber, Suggestion, Suggestion as Suggestion$1, SuggestionAvailability, SuggestionEngine, SuggestionsConfig, SurfaceSegment, ThreadEndpointRuntimeInfo, ThreadRunActivityNotification, Tokens, ToolCallStatus, ToolCallStatus as ToolCallStatus$1, TrajectoryStartOptions, WebMCPModelContext, WebMCPRegistry, WebMCPToolAnnotations, WebMCPToolConfig, classifySurfaceCards, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, extractCompleteArrayItems, extractFenceOperations, extractStringField, flattenInformationalCards, getMarkdownOperationSurfaceId, getWebMCPModelContext, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseMarkdown, parseToolArguments, prepareSurfaceOperations, props, segmentSurfaceProse, select, splitA2UIMarkdown, ɵCOPILOTKIT_FEATURES, ɵCopilotKitFeature, ɵGenerativeUIDebugFunction, ɵGenerativeUIDebugPromptSection, ɵGenerativeUIDebugRun, ɵGenerativeUIDebugSnapshot, ɵGenerativeUIDebugSource, ɵGenerativeUIDebugSurface, ɵInterruptDecision, ɵInterruptEvent, ɵInterruptState, ɵInterruptToolResult, ɵMAX_SOCKET_RETRIES, ɵMemoryEnvironment, ɵMemoryMetadataEvent, ɵMemoryRuntimeContext, ɵMemoryState, ɵMemoryStore, ɵPendingInterrupt, ɵPhoenixChannelLike, ɵPhoenixChannelOptions, ɵPhoenixChannelSession, ɵPhoenixJoinOutcome, ɵPhoenixPushLike, ɵPhoenixSocketLike, ɵPhoenixSocketOptions, ɵPhoenixSocketSession, ɵPhoenixSocketSignal, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, ɵThread, ɵThreadEnvironment, ɵThreadMetadataEvent, ɵThreadRuntimeContext, ɵThreadSelectors, ɵThreadStore, ɵclearAgentInterruptState, ɵcreateMemoryStore, ɵcreateThreadSelectors, ɵcreateThreadStore, ɵgetAgentInterruptState, ɵisCopilotKitFeature, ɵisHttpAgent, ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents, ɵwithHeaderDefaults } from "@copilotkit/core";
+import { ActivityDeltaEventSchema, ActivityMessageSchema, ActivitySnapshotEventSchema, AddOperationSchema, AgentCapabilitiesSchema, AssistantMessageSchema, AttributableSchema, AudioInputContentSchema, AudioInputPartSchema, AudioPartSchema, BaseEventSchema, BaseMessageSchema, ContentPartSchema, ContextSchema, CopyOperationSchema, CustomEventSchema, DataSourceSchema, DeveloperMessageSchema, DocumentInputContentSchema, DocumentInputPartSchema, DocumentPartSchema, EventSchema, EventSchemas, EventTypeSchema, ExecutionCapabilitiesSchema, FileSourceSchema, FunctionCallSchema, HumanInTheLoopCapabilitiesSchema, IdentityCapabilitiesSchema, ImageInputContentSchema, ImageInputPartSchema, ImagePartSchema, InputContentDataSourceSchema, InputContentSchema, InputContentSourceSchema, InputContentUrlSourceSchema, InterruptSchema, JsonPatchOperationSchema, JsonPatchSchema, JsonPointerSchema, MessageSchema, MessagesSnapshotEventSchema, MetadataSchema, MoveOperationSchema, MultiAgentCapabilitiesSchema, MultimodalCapabilitiesSchema, MultimodalInputCapabilitiesSchema, MultimodalOutputCapabilitiesSchema, OptionalMetadataSchema, OutputCapabilitiesSchema, PartSourceSchema, RawEventSchema, ReasoningCapabilitiesSchema, ReasoningEncryptedValueEventSchema, ReasoningEncryptedValueSubtypeSchema, ReasoningEndEventSchema, ReasoningMessageChunkEventSchema, ReasoningMessageContentEventSchema, ReasoningMessageEndEventSchema, ReasoningMessageSchema, ReasoningMessageStartEventSchema, ReasoningStartEventSchema, RemoveOperationSchema, ReplaceOperationSchema, ResumeEntrySchema, RoleSchema, RunAgentInputSchema, RunErrorEventSchema, RunFinishedCancelledOutcomeSchema, RunFinishedEventSchema, RunFinishedInterruptOutcomeSchema, RunFinishedOutcomeSchema, RunFinishedSuccessOutcomeSchema, RunStartedEventSchema, StateCapabilitiesSchema, StateDeltaEventSchema, StateSchema, StateSnapshotEventSchema, StepFinishedEventSchema, StepStartedEventSchema, SubagentErrorEventSchema, SubagentFinishedEventSchema, SubagentFinishedOutcomeSchema, SubagentFinishedSuccessOutcomeSchema, SubagentFinishedSuspendedOutcomeSchema, SubagentInfoSchema, SubagentRunIdSchema, SubagentStartedEventSchema, SystemMessageSchema, TestOperationSchema, TextInputContentSchema, TextMessageChunkEventSchema, TextMessageContentEventSchema, TextMessageEndEventSchema, TextMessageRoleSchema, TextMessageStartEventSchema, TextPartSchema, TokenUsageSchema, ToolCallArgsEventSchema, ToolCallChunkEventSchema, ToolCallEndEventSchema, ToolCallResultEventSchema, ToolCallSchema, ToolCallStartEventSchema, ToolMessageSchema, ToolSchema, ToolsCapabilitiesSchema, TransportCapabilitiesSchema, UrlSourceSchema, UserMessageSchema, VideoInputContentSchema, VideoInputPartSchema, VideoPartSchema } from "@ag-ui/core/schemas";
+import { MCPAppsActivityContent, MCPAppsActivityContent as MCPAppsActivityContent$1, MCPAppsActivityContentSchema, MCPAppsActivityType, ɵMcpFollowUpHost, ɵrunMcpFollowUp } from "@copilotkit/mcp-apps-renderer/activity";
+import { Theme, Theme as A2UITheme, defaultTheme as a2uiDefaultTheme } from "@copilotkit/a2ui-renderer";
+import { Anchor as InspectorAnchor } from "@copilotkit/web-inspector";
+
+//#region src/components/chat/BasicMarkdownRenderer.d.ts
+/**
+ * Dependency-light built-in markdown renderer (basic GFM). Walks the
+ * framework-agnostic token tree from `@copilotkit/core` into React elements.
+ * No syntax highlighting, no math, no table/image action buttons — plug in a
+ * custom renderer via `CopilotKitProvider markdownRenderer={...}` for those.
+ */
+declare function BasicMarkdownRenderer({
+  content,
+  className
+}: MarkdownRendererProps): react_jsx_runtime0.JSX.Element | null;
+declare namespace BasicMarkdownRenderer {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/chat/StreamingMarkdownDefaultRenderer.d.ts
+/**
+ * react-core's built-in default markdown renderer — a thin adapter over
+ * `@copilotkit/markdown-renderer`'s streaming renderer. Maps the pluggable
+ * renderer contract (`{ content, isStreaming, className }`) onto the streaming
+ * renderer for streaming-safe incremental rendering + per-token animation.
+ * Still overridable via the slot/provider pluggable interface.
+ */
+declare function StreamingMarkdownDefaultRenderer({
+  content,
+  isStreaming,
+  className,
+  nodeRenderers,
+  caret,
+  options,
+  onLinkClick,
+  onCitationClick
+}: MarkdownRendererProps & DefaultMarkdownRendererProps): react_jsx_runtime0.JSX.Element | null;
+declare namespace StreamingMarkdownDefaultRenderer {
+  var displayName: string;
+}
+//#endregion
+//#region src/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/providers/CopilotChatConfigurationProvider.d.ts
+declare const CopilotChatDefaultLabels: {
+  chatInputPlaceholder: string;
+  chatInputToolbarStartTranscribeButtonLabel: string;
+  chatInputToolbarCancelTranscribeButtonLabel: string;
+  chatInputToolbarFinishTranscribeButtonLabel: string;
+  chatInputToolbarAddButtonLabel: string;
+  chatInputToolbarToolsButtonLabel: string;
+  chatInputToolbarSendButtonLabel: string;
+  chatInputToolbarStopButtonLabel: string;
+  assistantMessageToolbarCopyCodeLabel: string;
+  assistantMessageToolbarCopyCodeCopiedLabel: string;
+  assistantMessageToolbarCopyMessageLabel: string;
+  assistantMessageToolbarInspectorLabel: string;
+  assistantMessageToolbarInspectorDescription: string;
+  assistantMessageToolbarInspectorLocalOnlyLabel: string;
+  assistantMessageToolbarInspectorLocalOnlyDescription: string;
+  assistantMessageToolbarInspectorTitle: string;
+  assistantMessageToolbarInspectorHideLabel: string;
+  assistantMessageToolbarInspectorHideDescription: string;
+  assistantMessageToolbarThumbsUpLabel: string;
+  assistantMessageToolbarThumbsDownLabel: string;
+  assistantMessageFeedbackCommentPlaceholder: string;
+  assistantMessageFeedbackCommentSubmitLabel: string;
+  assistantMessageToolbarReadAloudLabel: string;
+  assistantMessageToolbarRegenerateLabel: string;
+  userMessageToolbarCopyMessageLabel: string;
+  userMessageToolbarEditMessageLabel: string;
+  userMessageToolbarPreviousBranchLabel: string;
+  userMessageToolbarNextBranchLabel: string;
+  chatDisclaimerText: string;
+  chatToggleOpenLabel: string;
+  chatToggleCloseLabel: string;
+  chatScrollToBottomLabel: string;
+  modalHeaderTitle: string;
+  welcomeMessageText: string;
+  reasoningMessageThinkingLabel: string;
+  chatInputSlashMenuLabel: string;
+  chatInputSlashMenuEmptyText: string;
+  attachmentRemoveButtonLabel: string;
+  attachmentPlayVideoButtonLabel: string;
+  attachmentPreviewCloseButtonLabel: string;
+  modalHeaderCloseButtonLabel: string;
+  modalHeaderThreadsButtonLabel: string;
+  sidebarLabel: string;
+};
+type CopilotChatLabels = typeof CopilotChatDefaultLabels;
+interface CopilotChatConfigurationValue {
+  labels: CopilotChatLabels;
+  agentId: string;
+  threadId: string;
+  isModalOpen: boolean;
+  setModalOpen: (open: boolean) => void;
+  /**
+   * Whether the thread-list drawer is open. A sibling boolean to `isModalOpen`
+   * (deliberately NOT folded into a tri-state enum): on desktop the chat modal
+   * and the drawer coexist, so two independent booleans are required.
+   */
+  drawerOpen: boolean;
+  /**
+   * Toggles the drawer open state. On mobile viewports (`<768px`) opening the
+   * drawer closes the chat modal (mutual exclusion); on desktop there is no
+   * constraint.
+   */
+  setDrawerOpen: (open: boolean) => void;
+  /**
+   * True once a `<CopilotThreadsDrawer>` wrapper has registered itself with this chat
+   * configuration. The header thread-list launcher renders ONLY when this is
+   * set, so chats with no drawer stay byte-for-byte unchanged.
+   */
+  drawerRegistered: boolean;
+  /**
+   * Called by the drawer wrapper on mount to announce its presence (and flip
+   * `drawerRegistered`). Returns a cleanup function that de-registers the
+   * drawer on unmount.
+   *
+   * @returns A cleanup callback that reverses the registration.
+   */
+  registerDrawer: () => () => void;
+  /**
+   * Internal: registers the modal-close setter of the provider that actually
+   * owns the rendered modal (a descendant that supplied `isModalDefaultOpen`),
+   * so the drawer's mobile mutual-exclusion — owned by the top-most provider —
+   * closes the modal that is genuinely on screen rather than the top-most
+   * provider's own (possibly unrendered) modal state.
+   *
+   * @param closeModal - A setter the drawer may call to close the rendered modal.
+   * @returns A cleanup callback that de-registers the closer.
+   */
+  ɵregisterModalCloser: (closeModal: (open: boolean) => void) => () => void;
+  hasExplicitThreadId: boolean;
+  /**
+   * Imperatively sets the active thread for this chat configuration.
+   *
+   * Use this to drive the rendered thread without a host callback — e.g. a
+   * `<CopilotThreadsDrawer>` selecting a thread row sets it explicitly so the chat
+   * connects to that backend thread.
+   *
+   * Guarded like the top-level `<CopilotKit>` provider's `setThreadId`: when
+   * the consumer controls the threadId via the `threadId` prop on this
+   * provider, this is a no-op (a warning is logged) so a prop-controlled
+   * threadId is never silently overridden.
+   *
+   * @param threadId - The thread id to make active.
+   * @param options.explicit - Whether the thread is a caller choice. Defaults
+   *   to `true` (a picked thread). Pass `false` to set a non-explicit thread
+   *   so the welcome screen shows (see {@link startNewThread}).
+   */
+  setActiveThreadId: (threadId: string, options?: {
+    explicit?: boolean;
+  }) => void;
+  /**
+   * Resets the active thread to a fresh, non-explicit client-side thread: a
+   * newly minted UUID with `hasExplicitThreadId=false`, so the welcome screen
+   * shows. Pairs with the core `startNewThread()` to clear the conversation
+   * with no host wiring.
+   *
+   * Guarded identically to {@link setActiveThreadId}: a no-op when the
+   * threadId is prop-controlled.
+   */
+  startNewThread: () => void;
+}
+interface CopilotChatConfigurationProviderProps {
+  children: ReactNode;
+  labels?: Partial<CopilotChatLabels>;
+  agentId?: string;
+  threadId?: string;
+  hasExplicitThreadId?: boolean;
+  isModalDefaultOpen?: boolean;
+}
+declare const CopilotChatConfigurationProvider: React$1.FC<CopilotChatConfigurationProviderProps>;
+declare const useCopilotChatConfiguration: () => CopilotChatConfigurationValue | null;
+//#endregion
+//#region src/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/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;
+  /**
+   * Set to `true` when the input sits at the bottom of its container as a
+   * flex-last-child (visible position is driven by layout, not CSS
+   * positioning). Triggers reservation of bottom space for the fixed
+   * CopilotKit license banner via the
+   * `--copilotkit-license-banner-offset` CSS var so the two don't overlap.
+   *
+   * Not needed when `positioning === "absolute"`; that mode already pins the
+   * input to the bottom and picks up the same reservation automatically.
+   * Leave unset (default `false`) for inputs rendered mid-layout such as the
+   * welcome screen, where the banner offset would push the input off-center.
+   */
+  bottomAnchored?: 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;
+};
+/**
+ * The chat composer: a text area with the add-menu, voice and send/stop
+ * buttons, and a slash-command menu that lists `toolsMenu` items once the text
+ * starts with "/".
+ */
+declare function CopilotChatInput({
+  mode,
+  onSubmitMessage,
+  onStop,
+  isRunning,
+  onStartTranscribe,
+  onCancelTranscribe,
+  onFinishTranscribe,
+  onFinishTranscribeWithAudio,
+  onAddFile,
+  onChange,
+  value,
+  toolsMenu,
+  autoFocus,
+  positioning,
+  keyboardHeight,
+  containerRef,
+  showDisclaimer,
+  bottomAnchored,
+  textArea,
+  sendButton,
+  startTranscribeButton,
+  cancelTranscribeButton,
+  finishTranscribeButton,
+  addMenuButton,
+  audioRecorder,
+  disclaimer,
+  children,
+  className,
+  ...props
+}: CopilotChatInputProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatInput {
+  /**
+   * The icon-only send button. Its accessible name is
+   * `labels.chatInputToolbarSendButtonLabel` unless an `aria-label` is passed;
+   * the input passes `labels.chatInputToolbarStopButtonLabel` while the button
+   * stops a run.
+   */
+  const SendButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  /**
+   * An icon-only toolbar button. `labels[labelKey]` is both its accessible
+   * name and its tooltip text.
+   */
+  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>>;
+  /**
+   * The "+" button that opens the attachment and tools menu. Its accessible
+   * name and tooltip come from `labels.chatInputToolbarAddButtonLabel`.
+   */
+  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/components/chat/tool-call-layout.d.ts
+/**
+ * How the chat shows tool calls.
+ *
+ * - `"grouped"` (default): calls made in a row share one card, collapsed to a
+ *   summary ("Used 3 tools") that opens to a row per call.
+ * - `"line"`: the same grouping as a quiet line of text, like the reasoning
+ *   message's "Thought for 4 seconds".
+ * - `"stacked"`: the latest call on top of a stack of the earlier ones; click
+ *   to fan the stack out into its cards.
+ * - `"turn"`: the agent works in the open (narration, then a row per call),
+ *   and when the reply is done everything before it folds into "Worked for 9s".
+ * - `"separate"`: every call gets its own card, as before grouping existed.
+ *
+ * Only calls drawn by a renderer that opts into grouping (`group: true`) are
+ * grouped; CopilotKit's built-in card from `useDefaultRenderTool()` does. Any
+ * other call always shows on its own and splits the group around it.
+ */
+type CopilotChatToolCallDisplay = "grouped" | "line" | "stacked" | "turn" | "separate";
+/** One tool call and, once it has finished, the message carrying its result. */
+interface ToolCallEntry {
+  toolCall: ToolCall$1;
+  toolMessage?: ToolMessage$1;
+}
+//#endregion
+//#region src/components/chat/CopilotChatToolCallGroup.d.ts
+type CopilotChatToolCallGroupAppearance = "card" | "line" | "stack";
+interface CopilotChatToolCallGroupProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+  /** The calls in the group, in order. */
+  calls: ToolCallEntry[];
+  /** Renders one call through the registered renderers. */
+  renderCall: (call: ToolCallEntry) => React$1.ReactNode;
+  /**
+   * - `"card"` (default): one card with a summary header and a row per call.
+   * - `"line"`: a quiet line of text that opens to a list of rows.
+   * - `"stack"`: the latest call on a stack of the earlier ones.
+   */
+  appearance?: CopilotChatToolCallGroupAppearance;
+  /** The agent is running and nothing follows the group, so more calls may join it. */
+  isActive?: boolean;
+}
+/**
+ * Tool calls made in a row, collapsed into one summary. While a call runs the
+ * summary names it ("Running read_file  src/app.ts"); once they're all done it
+ * reads "Used 3 tools" and opens to the calls.
+ *
+ * Each call is drawn by its registered renderer. CopilotKit's built-in card
+ * (`useDefaultRenderTool`) draws a compact row inside the card and line
+ * appearances and an open stack; a custom wildcard renderer draws whatever it
+ * draws.
+ */
+declare function CopilotChatToolCallGroup({
+  calls,
+  renderCall,
+  appearance,
+  isActive,
+  className,
+  ...props
+}: CopilotChatToolCallGroupProps): react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/chat/CopilotChatToolCallsView.d.ts
+type CopilotChatToolCallsViewProps = {
+  message: AssistantMessage$1;
+  messages?: Message$1[];
+  /**
+   * How to show the calls (see `CopilotChatToolCallDisplay`). Inside a message
+   * view it follows the view's `toolCallDisplay`; on its own it defaults to
+   * `"grouped"`.
+   */
+  display?: CopilotChatToolCallDisplay;
+  /**
+   * Draws a group of calls made in a row: a component, a class name for the
+   * default group, or props for it (e.g. `{ appearance: "line" }`).
+   */
+  group?: SlotValue<typeof CopilotChatToolCallGroup>;
+};
+declare function CopilotChatToolCallsView({
+  message,
+  messages,
+  display: displayProp,
+  group
+}: CopilotChatToolCallsViewProps): react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/chat/CopilotChatAssistantMessage.d.ts
+type CopilotChatFeedbackMessage = AssistantMessage$1 & {
+  rawEvent?: unknown;
+};
+type CopilotChatAssistantMessageProps = WithSlots<{
+  markdownRenderer: typeof CopilotChatAssistantMessage.MarkdownRenderer;
+  toolbar: typeof CopilotChatAssistantMessage.Toolbar;
+  copyButton: typeof CopilotChatAssistantMessage.CopyButton;
+  inspectorButton: typeof CopilotChatAssistantMessage.InspectorButton;
+  thumbsUpButton: typeof CopilotChatAssistantMessage.ThumbsUpButton;
+  thumbsDownButton: typeof CopilotChatAssistantMessage.ThumbsDownButton;
+  readAloudButton: typeof CopilotChatAssistantMessage.ReadAloudButton;
+  regenerateButton: typeof CopilotChatAssistantMessage.RegenerateButton;
+  toolCallsView: typeof CopilotChatToolCallsView;
+}, {
+  onThumbsUp?: (message: CopilotChatFeedbackMessage) => void;
+  onThumbsDown?: (message: CopilotChatFeedbackMessage) => void;
+  onReadAloud?: (message: AssistantMessage$1) => void;
+  onRegenerate?: (message: AssistantMessage$1) => void;
+  message: AssistantMessage$1;
+  messages?: Message$1[];
+  isRunning?: boolean;
+  /**
+   * Whether this is the last message the chat renders. The message view
+   * passes it, because the rendered list can differ from `messages` when
+   * `transformMessages` drops, replaces or reorders messages. Defaults to
+   * comparing against the last entry of `messages`.
+   */
+  isLatest?: boolean;
+  additionalToolbarItems?: React$1.ReactNode;
+  toolbarVisible?: boolean;
+  /**
+   * The comment field of a reply rating, inside the popover next to the
+   * chosen thumb. Shown only while Automatic Learning records ratings; it
+   * renders after `children`, so a `children` layout does not place it.
+   */
+  feedbackComment?: SlotValue<typeof CopilotChatAssistantMessage.FeedbackComment>;
+} & React$1.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatAssistantMessage({
+  message,
+  messages,
+  isRunning,
+  isLatest,
+  onThumbsUp,
+  onThumbsDown,
+  onReadAloud,
+  onRegenerate,
+  additionalToolbarItems,
+  toolbarVisible,
+  markdownRenderer,
+  toolbar,
+  copyButton,
+  inspectorButton,
+  thumbsUpButton,
+  thumbsDownButton,
+  readAloudButton,
+  regenerateButton,
+  feedbackComment: feedbackCommentSlot,
+  toolCallsView,
+  children,
+  className,
+  ...props
+}: CopilotChatAssistantMessageProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatAssistantMessage {
+  const MarkdownRenderer: React$1.FC<MarkdownRendererProps & DefaultMarkdownRendererProps & {
+    /** Id of the rendered message. The markdown transport finds its fences by it. */messageId?: string;
+  }>;
+  const Toolbar: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+  const ToolbarButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    title: string;
+    tooltip?: React$1.ReactNode;
+    tooltipClassName?: string;
+    children: React$1.ReactNode;
+  }>;
+  const CopyButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const InspectorButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ThumbsUpButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const ThumbsDownButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  /**
+   * The comment field of a rating, shown in a popover next to the chosen
+   * thumb. Enter saves; Send appears once the text differs from the saved
+   * comment. The popover marks itself `data-copilotkit-ignore`, so Learning
+   * records the saved comment but not the typing; outside it, mark the
+   * field yourself.
+   */
+  const FeedbackComment: React$1.FC<{
+    value: string; /** The comment already saved. */
+    savedComment: string;
+    inputRef?: React$1.Ref<HTMLInputElement>;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+    onEditingChange?: (editing: boolean) => void;
+    /**
+     * Focus left the form for `next`, or for no focusable element when null.
+     * Not called when the window loses focus.
+     */
+    onLeave?: (next: Element | null) => void;
+    className?: string;
+  }>;
+  const ReadAloudButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  const RegenerateButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+}
+//#endregion
+//#region src/components/chat/CopilotChatUserMessage.d.ts
+interface CopilotChatUserMessageOnEditMessageProps {
+  message: UserMessage$1;
+}
+interface CopilotChatUserMessageOnSwitchToBranchProps {
+  message: UserMessage$1;
+  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$1;
+  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>>;
+  /**
+   * Previous/next buttons and an "n/m" counter for switching between branches
+   * of a user message. Renders only with more than one branch and an
+   * `onSwitchToBranch` handler. The buttons are named by
+   * `labels.userMessageToolbarPreviousBranchLabel` and
+   * `labels.userMessageToolbarNextBranchLabel`.
+   */
+  const BranchNavigation: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    currentBranch?: number;
+    numberOfBranches?: number;
+    onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
+    message: UserMessage$1;
+  }>;
+}
+//#endregion
+//#region src/components/chat/CopilotChatReasoningMessage.d.ts
+type CopilotChatReasoningMessageProps = WithSlots<{
+  header: typeof CopilotChatReasoningMessage.Header;
+  contentView: typeof CopilotChatReasoningMessage.Content;
+  toggle: typeof CopilotChatReasoningMessage.Toggle;
+}, {
+  message: ReasoningMessage$1;
+  messages?: Message$1[];
+  isRunning?: boolean;
+  /**
+   * Whether this is the last message the chat renders. The message view
+   * passes it, because the rendered list can differ from `messages` when
+   * `transformMessages` drops, replaces or reorders messages. Defaults to
+   * comparing against the last entry of `messages`.
+   */
+  isLatest?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>>;
+/**
+ * A reasoning message as a collapsible block. While the model reasons it is
+ * open and the header shows `labels.reasoningMessageThinkingLabel`; when
+ * streaming ends it collapses and the header reads "Thought for …". The
+ * `header` slot also receives `elapsedSeconds`.
+ */
+declare function CopilotChatReasoningMessage({
+  message,
+  messages,
+  isRunning,
+  isLatest: isLatestProp,
+  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;
+    /**
+     * Seconds spent reasoning so far, updated every second while streaming.
+     * The default label formats it in English ("Thought for 12 seconds");
+     * a custom header can use it to build a localized label.
+     */
+    elapsedSeconds?: number;
+  }>;
+  const Content: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    isStreaming?: boolean;
+    hasContent?: boolean;
+  }>;
+  const Toggle: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+    isOpen?: boolean;
+  }>;
+}
+//#endregion
+//#region src/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/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$1[];
+  onSelectSuggestion?: (suggestion: Suggestion$1, 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$1[];
+    onSelectSuggestion?: (suggestion: Suggestion$1, index: number) => void;
+    loadingIndexes?: ReadonlyArray<number>;
+  } & React$1.HTMLAttributes<HTMLDivElement>) => React$1.ReactNode) | undefined;
+} & Omit<{
+  suggestions: Suggestion$1[];
+  onSelectSuggestion?: (suggestion: Suggestion$1, index: number) => void;
+  loadingIndexes?: ReadonlyArray<number>;
+} & React$1.HTMLAttributes<HTMLDivElement>, "children"> & React$1.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/chat/CopilotChatWorkSummary.d.ts
+interface CopilotChatWorkSummaryProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+  /** The agent is still working on this reply. */
+  isWorking: boolean;
+  /** Whether the work (narration and tool calls) is showing. */
+  isOpen: boolean;
+  /** The tool calls the reply made. */
+  calls: ToolCallEntry[];
+  /**
+   * How long the agent has worked on the reply, in ms, summed over its runs
+   * so time spent waiting between them doesn't count. Only known for replies
+   * this client watched start; without it the summary shows the tool count.
+   */
+  elapsedMs?: number;
+  /** When the current run started (epoch ms), while the agent is working. */
+  workingSince?: number;
+}
+/**
+ * The line at the top of a reply in the `"turn"` tool-call display. While the
+ * agent works it reads "Working 4s"; once the reply is done it reads "Worked
+ * for 9s · 7 tools" and toggles the work it folded away.
+ */
+declare function CopilotChatWorkSummary({
+  isWorking,
+  isOpen,
+  calls,
+  elapsedMs,
+  workingSince,
+  className,
+  ...props
+}: CopilotChatWorkSummaryProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/intelligence-indicator/IntelligenceIndicatorView.d.ts
+/** Lifecycle state the brain hands the face. */
+type IntelligenceIndicatorStatus = "in-progress" | "finished";
+interface IntelligenceIndicatorViewProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+  /** The assistant message this indicator is attached to. */
+  message: Message$1;
+  /**
+   * Whether the intelligence work is still running (`in-progress`) or
+   * has settled (`finished`). Drives the icon morph and chrome
+   * fade-out via the `data-status` attribute on the wrapper.
+   */
+  status: IntelligenceIndicatorStatus;
+  /** The visible label, e.g. "Using CopilotKit Intelligence". */
+  label: string;
+}
+/**
+ * The presentational "CopilotKit Intelligence" face — the default
+ * rendered by the {@link IntelligenceIndicator} brain and the default
+ * value for the `intelligenceIndicator` slot.
+ *
+ * Layout: a glassmorphism pill (the `__chrome` layer) wrapping an icon
+ * and a label. The icon is two overlaid SVG paths — a spinner arc and a
+ * checkmark — whose geometry lives in each path's `d` ATTRIBUTE so it
+ * renders in every browser (the CSS `d:` property is Chrome-only).
+ *
+ * Two states, driven by the `data-status` attribute (see globals.css
+ * for the exact timing):
+ *  1. **In-progress.** The arc spins (CSS rotation) inside the pill and
+ *     the checkmark is hidden. Label + icon are a saturated purple.
+ *  2. **Finished.** The arc fades out mid-spin while the checkmark draws
+ *     itself in upright (animated `stroke-dashoffset`); the pill chrome
+ *     fades away; and the label + icon settle from purple to a neutral
+ *     gray, with the label slanting slightly (a `transform: skewX`
+ *     faux-italic, so it interpolates with the color instead of snapping
+ *     and never reflows). The result reads as quiet "history metadata"
+ *     rather than an active spinner. The label text itself never changes
+ *     — the static check plus the color/slant shift carry the "done"
+ *     meaning, so no wording change is needed.
+ *
+ * All motion is gated behind `prefers-reduced-motion` (globals.css):
+ * when reduced motion is requested the arc does not spin and the two
+ * states swap instantly, without transitions.
+ *
+ * Customize via the `intelligenceIndicator` slot on `CopilotChat`:
+ * a className string restyles the wrapper, a props object tweaks
+ * the default (`{ label }`), and a component replaces it entirely
+ * with full control over visuals and timing.
+ */
+declare function IntelligenceIndicatorView({
+  message,
+  status,
+  label,
+  className,
+  ...rest
+}: IntelligenceIndicatorViewProps): React$1.ReactElement;
+//#endregion
+//#region src/components/intelligence-indicator/IntelligenceIndicator.d.ts
+interface IntelligenceIndicatorProps {
+  /** The message this indicator is attached to. */
+  message: Message$1;
+  /**
+   * Agent id whose run state the indicator tracks. Pass through from
+   * the surrounding chat configuration; mounting from
+   * `CopilotChatMessageView` resolves this automatically.
+   */
+  agentId: string;
+  /**
+   * Optional override for the visible label. Defaults to
+   * "CopilotKit Intelligence".
+   */
+  label?: string;
+  /**
+   * Slot override for the presentational face. A className string, a
+   * props object, or a full replacement component — see
+   * {@link IntelligenceIndicatorView}. Forwarded from the
+   * `intelligenceIndicator` slot on `CopilotChat`.
+   */
+  intelligenceIndicator?: SlotValue<typeof IntelligenceIndicatorView>;
+}
+/**
+ * Stable turn id for the messages that precede the first user message (a turn
+ * with no opening user message of its own). Used as the React key so the
+ * indicator for that turn never collides with a real user-message id.
+ */
+declare const INTELLIGENCE_TURN_HEAD = "__cpk_turn_head__";
+/**
+ * Map each Intelligence-using turn to its anchor message — the FIRST bash-using
+ * assistant message of the turn — and a stable turn id (the id of the user
+ * message that opened the turn, or {@link INTELLIGENCE_TURN_HEAD} for the
+ * pre-first-user turn). Returns `Map<anchorMessageId, turnId>`.
+ *
+ * Anchoring to the FIRST (not last) bash-using message keeps the indicator
+ * fixed in place for the whole turn: later bash steps don't reposition it, so
+ * the spinner never abruptly jumps mid-turn (bug 1). `CopilotChatMessageView`
+ * emits exactly one `IntelligenceIndicator` per entry, keyed by the turn id and
+ * positioned at the anchor; the per-turn key also lets every past turn keep its
+ * own indicator in scroll-back.
+ *
+ * `visibleMessages` is what actually renders, when that differs from
+ * `messages` (the chat's `transformMessages`). Turns are still read from the
+ * full list, so hiding a user message does not merge its turn into the one
+ * before it, and anchors are only chosen among visible messages. A message the
+ * transform built itself joins the turn of the visible message before it.
+ */
+declare function getIntelligenceTurnAnchors(messages: readonly Message$1[], visibleMessages?: readonly Message$1[]): Map<string, string>;
+/**
+ * The "Using CopilotKit Intelligence" indicator brain. Auto-mounted by
+ * `CopilotChatMessageView` — once per Intelligence-using turn, at that
+ * turn's anchor message and keyed by the turn id (see
+ * {@link getIntelligenceTurnAnchors}). Callers do not register this
+ * themselves. It owns the run subscription and the phase machine and
+ * renders its swappable face via the `intelligenceIndicator` slot.
+ *
+ * Placement (which message anchors the turn) is decided by the view, so
+ * this component does not self-gate its own placement; it only derives
+ * in-progress/finished for the turn it was mounted on.
+ *
+ * Render gates (all must hold):
+ *   1. `copilotkit.intelligence !== undefined`
+ *   2. The (anchor) message is an assistant message with at least one
+ *      tool call whose name matches {@link DEFAULT_TOOL_PATTERNS}.
+ *   3. The phase machine is past `hidden`.
+ *
+ * Because the view keys each indicator by its turn id, the instance moves
+ * with the anchor across a hand-off (no remount, no spinner restart), and
+ * every prior Intelligence-using turn keeps its own persistent indicator
+ * in chat history.
+ *
+ * Phase machine (per-instance, all timers local):
+ *   - Starts in `hidden`, unless the message mounts onto an
+ *     already-completed turn (no pending work, agent stopped or a
+ *     real follow-up already present), in which case the lazy
+ *     `useState` initializer starts directly in `finished`. This is
+ *     what avoids a "hidden flash" on history replay.
+ *   - `hidden → spinner` once a matching tool call has been pending
+ *     (no `tool`-role result with a matching `toolCallId`) for
+ *     {@link PENDING_THRESHOLD_MS}. Replay flashes (tool call + result
+ *     in the same tick) never cross this threshold.
+ *   - `hidden → finished` if after the grace window the turn is
+ *     already complete (no pending work AND
+ *     `sawRealFollowup || !agent.isRunning`). Handles very fast tools
+ *     whose result lands within the grace window.
+ *   - `spinner → finished` as soon as EITHER `agent.isRunning` flips
+ *     false OR a non-tool-call-like message appears later in
+ *     `agent.messages` (i.e. the agent produced a "real" follow-up —
+ *     prose answer or a new user turn).
+ *   - `finished` is terminal: the indicator settles into its
+ *     persistent tag form and stays mounted.
+ */
+declare function IntelligenceIndicator(props: IntelligenceIndicatorProps): React$1.ReactElement | null;
+//#endregion
+//#region src/components/chat/CopilotChatMessageView.d.ts
+/** What the view passes the wrapper of a message group. */
+interface MessageGroupWrapperProps<S = unknown> {
+  /** The group's key, as returned by `groupMessages`. */
+  groupKey: string;
+  /** The messages in the group, in order. */
+  messages: Message$1[];
+  /** The default rendering of the group's messages. */
+  children: React$1.ReactNode;
+  /**
+   * State the view keeps for this group, keyed by `groupKey`. It survives the
+   * row leaving the window and the wrapper remounting, is dropped once the key
+   * no longer appears, and is cleared when the thread changes. `undefined`
+   * until first set.
+   */
+  state: S | undefined;
+  setState: (next: S) => void;
+}
+/** Several messages rendered as one row, inside an app-provided wrapper. */
+interface MessageGroup<S = unknown> {
+  type: "group";
+  /**
+   * Identifies the group across renders: its React key and the key its state
+   * is held under. Keep it stable while the thread streams, e.g. the id of the
+   * group's first message.
+   */
+  key: string;
+  messages: Message$1[];
+  /**
+   * Define it once at module level. A component created inside
+   * `groupMessages` is a new type on every call and remounts each time.
+   */
+  wrapper: React$1.ComponentType<MessageGroupWrapperProps<S>>;
+}
+/** One row of the message list: a single message, or a group of them. */
+type MessageRow = {
+  type: "message";
+  message: Message$1;
+} | MessageGroup;
+/** A row holding a single message, rendered as it would be ungrouped. */
+declare function messageRow(message: Message$1): MessageRow;
+/** A row holding a group of messages, rendered inside `wrapper`. */
+declare function messageGroup<S>(group: Omit<MessageGroup<S>, "type">): MessageRow;
+type CopilotChatMessageViewProps = Omit<WithSlots<{
+  assistantMessage: typeof CopilotChatAssistantMessage;
+  userMessage: typeof CopilotChatUserMessage;
+  reasoningMessage: typeof CopilotChatReasoningMessage;
+  cursor: typeof CopilotChatMessageView.Cursor;
+  intelligenceIndicator: typeof IntelligenceIndicatorView; /** The "Working… / Worked for 9s" line of the `"turn"` tool-call display. */
+  workSummary: typeof CopilotChatWorkSummary;
+}, {
+  isRunning?: boolean;
+  messages?: Message$1[];
+  /**
+   * Reshapes the message list before it renders: drop, replace or reorder
+   * messages with the whole list in view. Receives the list after duplicate
+   * ids are merged. Row keys, virtualization and rendering all work off
+   * the returned list, so a dropped message takes no row.
+   *
+   * Tool-call cards still look up their results in the full list, so
+   * hiding tool-result messages here does not strip results from them.
+   *
+   * Memoized on the input list and this function — pass a stable function
+   * (e.g. `useCallback`) or it reruns on every render.
+   */
+  transformMessages?: (messages: Message$1[]) => Message$1[];
+  /**
+   * Splits the message list into rows. Return `messageRow(message)` for a
+   * message that renders on its own, and `messageGroup({ key, messages,
+   * wrapper })` for messages that render together inside `wrapper` — a
+   * collapsible block of tool calls, say. Receives the list after
+   * `transformMessages`. Each row is one virtualized row.
+   *
+   * Return each message in at most one row. Tool-call cards still find
+   * their results in the full list.
+   *
+   * Memoized on its input and this function — pass a stable function.
+   */
+  groupMessages?: (messages: Message$1[]) => MessageRow[];
+  /**
+   * Whether reply thumbs record ratings for Automatic Learning once a
+   * Trajectory has started. Defaults to `true`; set `false` to keep the
+   * thumbs to your own `onThumbsUp` / `onThumbsDown` handlers and slots.
+   */
+  messageFeedback?: boolean;
+  /**
+   * How tool calls show. Defaults to `"grouped"`: calls made in a row
+   * share one card that opens to a row per call. `"line"` and `"stacked"`
+   * group them too; `"turn"` folds a reply's whole working phase into
+   * "Worked for 9s" once it's done; `"separate"` gives every call its own
+   * card. Calls with a renderer of their own always show on their own.
+   */
+  toolCallDisplay?: CopilotChatToolCallDisplay;
+} & React$1.HTMLAttributes<HTMLDivElement>>, "children"> & {
+  children?: (props: {
+    isRunning: boolean;
+    messages: Message$1[];
+    messageElements: React$1.ReactElement[];
+    interruptElement: React$1.ReactElement | null;
+  }) => React$1.ReactElement;
+};
+declare function CopilotChatMessageView({
+  messages,
+  assistantMessage,
+  userMessage,
+  reasoningMessage,
+  cursor,
+  intelligenceIndicator,
+  workSummary,
+  isRunning,
+  transformMessages,
+  groupMessages,
+  messageFeedback,
+  toolCallDisplay,
+  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/components/chat/normalize-auto-scroll.d.ts
+type AutoScrollMode = "pin-to-bottom" | "pin-to-send" | "none";
+//#endregion
+//#region src/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: React$1.ComponentType<CopilotChatInputProps>;
+  suggestionView: typeof CopilotChatSuggestionView;
+}, {
+  messages?: Message$1[];
+  autoScroll?: AutoScrollMode | boolean;
+  isRunning?: boolean;
+  suggestions?: Suggestion$1[];
+  suggestionLoadingIndexes?: ReadonlyArray<number>;
+  onSelectSuggestion?: (suggestion: Suggestion$1, 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>;
+  attachments?: Attachment$1[];
+  onRemoveAttachment?: (id: string) => void;
+  onAddFile?: () => void;
+  dragOver?: boolean;
+  onDragOver?: (e: React$1.DragEvent) => void;
+  onDragLeave?: (e: React$1.DragEvent) => void;
+  onDrop?: (e: React$1.DragEvent) => void;
+  /**
+   * When `true`, suppresses the welcome screen while a thread's initial
+   * connect is in flight. Prevents the "How can I help you today?" flash
+   * that would otherwise appear between mounting an empty agent instance
+   * and the bootstrap messages arriving from /connect.
+   */
+  isConnecting?: boolean;
+  /**
+   * When `true`, the caller has explicitly picked a thread (via `threadId`
+   * prop or `CopilotChatConfigurationProvider`). Suppresses the welcome
+   * screen unconditionally — a caller-managed thread targets a specific
+   * conversation and should render its messages (or an empty panel during
+   * connect) rather than a generic "start a new chat" greeting.
+   */
+  hasExplicitThreadId?: boolean;
+  /**
+   * @deprecated Use the `input` slot's `disclaimer` prop instead:
+   * ```tsx
+   * <CopilotChat input={{ disclaimer: MyDisclaimer }} />
+   * ```
+   */
+  disclaimer?: SlotValue<React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>>;
+  /**
+   * Slot for the "Using CopilotKit Intelligence" indicator. Pass-through
+   * to `CopilotChatMessageView`'s `intelligenceIndicator` slot — accepts a
+   * className string, a props object, or a replacement component.
+   */
+  intelligenceIndicator?: SlotValue<typeof IntelligenceIndicatorView>;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "inputMode">>;
+declare function CopilotChatView({
+  messageView,
+  input,
+  scrollView,
+  suggestionView,
+  welcomeScreen,
+  messages,
+  autoScroll,
+  isRunning,
+  suggestions,
+  suggestionLoadingIndexes,
+  onSelectSuggestion,
+  onSubmitMessage,
+  onStop,
+  inputMode,
+  inputValue,
+  onInputChange,
+  onStartTranscribe,
+  onCancelTranscribe,
+  onFinishTranscribe,
+  onFinishTranscribeWithAudio,
+  attachments,
+  onRemoveAttachment,
+  onAddFile,
+  dragOver,
+  onDragOver,
+  onDragLeave,
+  onDrop,
+  isConnecting,
+  hasExplicitThreadId,
+  disclaimer,
+  intelligenceIndicator,
+  children,
+  className,
+  ...props
+}: CopilotChatViewProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChatView {
+  const ScrollView: React$1.FC<React$1.HTMLAttributes<HTMLDivElement> & {
+    autoScroll?: AutoScrollMode | boolean;
+    scrollThreadId?: string;
+    scrollToBottomButton?: SlotValue<React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>>;
+    feather?: SlotValue<React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>>;
+    inputContainerHeight?: number;
+    isResizing?: boolean;
+  }>;
+  /**
+   * Scrolls the message list to the latest message. Shown while the user is
+   * scrolled up; its accessible name is `labels.chatScrollToBottomLabel`.
+   */
+  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/components/chat/CopilotChat.d.ts
+type CopilotChatProps = Omit<CopilotChatViewProps, "messages" | "isRunning" | "suggestions" | "suggestionLoadingIndexes" | "onSelectSuggestion" | "attachments" | "onRemoveAttachment" | "onAddFile" | "dragOver" | "onDragOver" | "onDragLeave" | "onDrop"> & {
+  agentId?: string;
+  threadId?: string;
+  labels?: Partial<CopilotChatLabels>;
+  /**
+   * Enable Inspector message shortcuts for this chat (enabled by default).
+   * An explicit CopilotKit provider enableInspector value takes priority.
+   * Shortcuts only appear in local development while Inspector is visible.
+   */
+  inspectorTools?: boolean; /** Accepts a className, partial props, or any component with CopilotChatView props — static namespace members are not required. */
+  chatView?: SlotValue<React$1.ComponentType<CopilotChatViewProps>>;
+  isModalDefaultOpen?: boolean; /** Enable multimodal file attachments (images, audio, video, documents). */
+  attachments?: AttachmentsConfig$1;
+  /**
+   * 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$1;
+    context: Record<string, any>;
+  }) => void | Promise<void>;
+  /**
+   * Throttle interval (in milliseconds) for re-renders triggered by message
+   * change notifications. Overrides the provider-level `defaultThrottleMs`
+   * for this chat instance. Forwarded to the internal `useAgent()` hook,
+   * which resolves the effective throttle value.
+   *
+   * @default undefined — inherits from provider `defaultThrottleMs`;
+   * if that is also unset, re-renders are unthrottled. Note: passing
+   * `throttleMs={0}` explicitly disables throttling for this instance
+   * even when the provider specifies a non-zero `defaultThrottleMs`.
+   */
+  throttleMs?: number;
+  /**
+   * Experimental. Wrapper for generative UI surfaces rendered in this chat.
+   * Receives `{ surfaceId, isStreaming, error, children }`.
+   */
+  generativeUISurface?: React$1.ComponentType<GenerativeUIChatSurfaceProps>;
+};
+declare function CopilotChat({
+  agentId,
+  threadId,
+  labels,
+  inspectorTools,
+  chatView,
+  isModalDefaultOpen,
+  attachments: attachmentsConfig,
+  onError,
+  throttleMs,
+  generativeUISurface,
+  ...props
+}: CopilotChatProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotChat {
+  const View: typeof CopilotChatView;
+}
+//#endregion
+//#region src/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/components/chat/CopilotModalHeader.d.ts
+type HeaderSlots = {
+  titleContent: typeof CopilotModalHeader.Title;
+  closeButton: typeof CopilotModalHeader.CloseButton;
+  drawerLauncher: typeof CopilotModalHeader.DrawerLauncher;
+};
+type HeaderRestProps = {
+  title?: string;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">;
+/**
+ * Payload handed to the optional `children` render function. `drawerLauncher`
+ * is nullable because the launcher is rendered only when a drawer has
+ * registered — when none is present, custom layouts receive `null` and can omit
+ * the launcher slot entirely.
+ */
+type HeaderChildrenPayload = {
+  titleContent: React$1.ReactElement;
+  closeButton: React$1.ReactElement;
+  drawerLauncher: React$1.ReactElement | null;
+  title?: string;
+} & Omit<HeaderRestProps, "title">;
+type CopilotModalHeaderProps = Omit<WithSlots<HeaderSlots, HeaderRestProps>, "children"> & {
+  children?: (props: HeaderChildrenPayload) => React$1.ReactNode;
+};
+declare function CopilotModalHeader({
+  title,
+  titleContent,
+  closeButton,
+  drawerLauncher,
+  children,
+  className,
+  ...rest
+}: CopilotModalHeaderProps): string | number | bigint | boolean | 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> | react_jsx_runtime0.JSX.Element | null | undefined;
+declare namespace CopilotModalHeader {
+  var displayName: string;
+}
+declare namespace CopilotModalHeader {
+  const Title: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
+  /**
+   * Closes the popup or sidebar. Its accessible name is
+   * `labels.modalHeaderCloseButtonLabel`.
+   */
+  const CloseButton: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+  /**
+   * The thread-list launcher button. Rendered in the header ONLY when a
+   * `<CopilotThreadsDrawer>` wrapper has registered with the chat configuration; it
+   * toggles the drawer open state. The stable `data-testid` is the focus-return
+   * target for the drawer wrapper on cancel/back/backdrop/Escape.
+   */
+  const DrawerLauncher: React$1.FC<React$1.ButtonHTMLAttributes<HTMLButtonElement>>;
+}
+//#endregion
+//#region src/components/chat/CopilotSidebarView.d.ts
+type CopilotSidebarViewProps = CopilotChatViewProps & {
+  /** Accepts a className, partial props, or any component with CopilotModalHeader props — static namespace members are not required. */header?: SlotValue<React$1.ComponentType<CopilotModalHeaderProps>>;
+  toggleButton?: SlotValue<typeof CopilotChatToggleButton>;
+  width?: number | string;
+  defaultOpen?: boolean;
+  position?: "left" | "right";
+};
+/**
+ * The chat in a side panel: a `complementary` region named by
+ * `labels.sidebarLabel`, with a header, the chat view and a toggle button.
+ */
+declare function CopilotSidebarView({
+  header,
+  toggleButton,
+  width,
+  defaultOpen,
+  position,
+  ...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/components/chat/CopilotPopupView.d.ts
+type CopilotPopupViewProps = CopilotChatViewProps & {
+  /** Accepts a className, partial props, or any component with CopilotModalHeader props — static namespace members are not required. */header?: SlotValue<React$1.ComponentType<CopilotModalHeaderProps>>;
+  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/components/chat/CopilotSidebar.d.ts
+type CopilotSidebarProps = Omit<CopilotChatProps, "chatView"> & {
+  header?: CopilotSidebarViewProps["header"];
+  toggleButton?: CopilotSidebarViewProps["toggleButton"];
+  defaultOpen?: boolean;
+  /**
+   * Controlled open state. When supplied, the host owns whether the sidebar is
+   * open: the sidebar renders this value and never changes it on its own.
+   * Pair it with `onOpenChange` to react to the toggle button. Omit it (and use
+   * `defaultOpen`) to let the sidebar manage its own state.
+   */
+  open?: boolean;
+  /**
+   * Called with the requested state whenever the sidebar asks to open or close
+   * (the toggle button, or the thread drawer on mobile). In controlled mode
+   * nothing moves until the host updates `open`.
+   */
+  onOpenChange?: (open: boolean) => void;
+  width?: number | string;
+  position?: CopilotSidebarViewProps["position"];
+};
+declare function CopilotSidebar({
+  header,
+  toggleButton,
+  defaultOpen,
+  open,
+  onOpenChange,
+  width,
+  position,
+  ...chatProps
+}: CopilotSidebarProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotSidebar {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/chat/CopilotPopup.d.ts
+type CopilotPopupProps = Omit<CopilotChatProps, "chatView"> & {
+  header?: CopilotPopupViewProps["header"];
+  toggleButton?: CopilotPopupViewProps["toggleButton"];
+  defaultOpen?: boolean;
+  /**
+   * Controlled open state. When supplied, the host owns whether the popup is
+   * open: the popup renders this value and never changes it on its own. Pair it
+   * with `onOpenChange` to react to the toggle button and to click-outside.
+   * Omit it (and use `defaultOpen`) to let the popup manage its own state.
+   */
+  open?: boolean;
+  /**
+   * Called with the requested state whenever the popup asks to open or close
+   * (the toggle button, click-outside, or the thread drawer on mobile). In
+   * controlled mode nothing moves until the host updates `open`.
+   */
+  onOpenChange?: (open: boolean) => void;
+  width?: CopilotPopupViewProps["width"];
+  height?: CopilotPopupViewProps["height"];
+  clickOutsideToClose?: CopilotPopupViewProps["clickOutsideToClose"];
+};
+declare function CopilotPopup({
+  header,
+  toggleButton,
+  defaultOpen,
+  open,
+  onOpenChange,
+  width,
+  height,
+  clickOutsideToClose,
+  ...chatProps
+}: CopilotPopupProps): react_jsx_runtime0.JSX.Element;
+declare namespace CopilotPopup {
+  var displayName: string;
+}
+//#endregion
+//#region src/hooks/use-threads.d.ts
+/**
+ * A conversation thread managed by CopilotKit Intelligence.
+ *
+ * Each thread has a unique `id`, an optional human-readable `name`, and
+ * timestamp fields tracking creation and update times.
+ */
+interface Thread {
+  id: string;
+  agentId: string;
+  name: string | null;
+  archived: boolean;
+  createdAt: string;
+  updatedAt: string;
+  /**
+   * ISO-8601 timestamp of the most recent agent run on this thread. Absent
+   * when the thread has never been run. Prefer this over `updatedAt` for
+   * user-facing "last activity" displays — it is not bumped by metadata-only
+   * actions like rename or archive.
+   */
+  lastRunAt?: string;
+}
+/**
+ * Configuration for the {@link useThreads} hook.
+ *
+ * Thread operations are scoped to the runtime-authenticated user and the
+ * provided agent on CopilotKit Intelligence.
+ */
+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;
+  /**
+   * When `false`, the hook stays inert: no runtime context is dispatched, so
+   * NO thread-list fetch or realtime subscription is issued. Used by gated
+   * surfaces (e.g. an unlicensed `<CopilotThreadsDrawer>`) that must not touch the
+   * network until the gate opens. Defaults to `true`.
+   *
+   * Flipping `enabled` back to `true` resumes normal fetching on the next
+   * effect run; mutations are likewise short-circuited while disabled.
+   */
+  enabled?: boolean;
+}
+/**
+ * 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.
+   *
+   * This channel folds together developer/config errors (missing runtime URL,
+   * runtime without thread endpoints) and genuine list-load/mutation failures.
+   * End-user surfaces that must not leak config errors should prefer
+   * {@link listError}, which excludes the config/runtime-setup errors.
+   */
+  error: Error | null;
+  /**
+   * The most recent genuine list-load or mutation error from the platform, or
+   * `null`. Unlike {@link error}, this EXCLUDES developer/config errors (a
+   * missing runtime URL, or a runtime that does not advertise thread
+   * endpoints), so an end-user surface can render it directly without leaking
+   * a developer-facing configuration message into the UI.
+   */
+  listError: Error | null;
+  /**
+   * The error from the most recent FAILED next-page (fetch-more) load, or
+   * `null`. Tracked separately from {@link listError} so a paginated-load
+   * failure surfaces an inline "couldn't load more" affordance while the
+   * already-loaded list stays visible. Cleared when a fetch-more is retried or
+   * succeeds.
+   */
+  fetchMoreError: Error | null;
+  /**
+   * `true` when there are more threads available to fetch via
+   * {@link fetchMoreThreads}. Only meaningful when `limit` is set.
+   */
+  hasMoreThreads: boolean;
+  /**
+   * `true` while a subsequent page of threads is being fetched.
+   */
+  isFetchingMoreThreads: boolean;
+  /**
+   * `true` while at least one thread mutation (rename, archive, unarchive,
+   * delete) is awaiting a server response. Mutations apply optimistically, so
+   * this is primarily useful for disabling controls or showing a subtle
+   * in-flight indicator.
+   */
+  isMutating: boolean;
+  /**
+   * Fetch the next page of threads. No-op when {@link hasMoreThreads} is
+   * `false` or a fetch is already in progress.
+   */
+  fetchMoreThreads: () => void;
+  /**
+   * Re-fetch the thread list from the platform without clearing the current
+   * list. Backs the drawer's error-state Retry and the Active/All filter
+   * refetch. No-op until the runtime is connected.
+   */
+  refetchThreads: () => void;
+  /**
+   * Reset to a fresh, non-explicit client-side thread so the welcome screen
+   * shows. Lazy creation: no row appears in {@link threads} until the new
+   * thread's first run persists server-side.
+   */
+  startNewThread: () => 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>;
+  /**
+   * Restore a previously archived thread on the platform.
+   * The thread re-appears in default (non-archived) list results.
+   * Resolves when the server confirms the update; rejects on failure.
+   */
+  unarchiveThread: (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 CopilotKit Intelligence threads.
+ *
+ * On mount the hook fetches the thread list for the runtime-authenticated user
+ * and the given `agentId`. When CopilotKit Intelligence 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`, `unarchiveThread`,
+ * `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,
+  enabled
+}: UseThreadsInput): UseThreadsResult;
+//#endregion
+//#region src/components/chat/CopilotThreadsDrawer.d.ts
+/**
+ * Per-row content render function. Receives a thread and returns the React
+ * node to project into the element's `slot="row:{id}"`. Returning `null`
+ * (or omitting the prop) falls back to the element's built-in row name.
+ */
+type CopilotThreadsDrawerRowRenderer = (thread: Thread) => React$1.ReactNode;
+/**
+ * Props for {@link CopilotThreadsDrawer}.
+ *
+ * The drawer is a thin controller around the framework-agnostic
+ * `<copilotkit-threads-drawer>` custom element. It feeds the element domain data
+ * (threads/loading/error from {@link useThreads}, the active thread from the
+ * chat configuration) and routes the element's outbound DOM events back into
+ * core thread operations and chat-configuration changes.
+ */
+interface CopilotThreadsDrawerProps {
+  /**
+   * The agent whose threads to list and manage. Defaults to the agent of the
+   * surrounding chat configuration, or the platform default when none is set.
+   */
+  agentId?: string;
+  /**
+   * Optional escape-hatch called when the user picks a thread row. The wrapper
+   * additionally focuses the chat input. When omitted, the wrapper drives the
+   * surrounding chat configuration directly (`setActiveThreadId`), so a bare
+   * `<CopilotThreadsDrawer>` switches the rendered thread with no host wiring. Provide
+   * this only to take control of the active thread yourself (e.g. a v1
+   * `setThreadId`); when provided it is preferred over the provider.
+   */
+  onThreadSelect?: (threadId: string) => void;
+  /**
+   * Optional escape-hatch called when the user starts a new thread (the
+   * element's "+ New" button). The wrapper always resets the core thread store
+   * to a fresh, non-explicit client-side thread (`startNewThread`). When this
+   * is omitted, the wrapper also resets the surrounding chat configuration to a
+   * fresh non-explicit thread (`startNewThread`) so the welcome screen shows
+   * with no host wiring. Provide this only to clear your own active thread;
+   * when provided it is preferred over the provider.
+   */
+  onNewThread?: () => void;
+  /** Called when the Upgrade CTA is clicked. */
+  onLicensed?: () => void;
+  /**
+   * Destination the locked view's Upgrade CTA opens in a new tab. Defaults to
+   * the element's built-in CopilotKit Intelligence docs URL when omitted. Set
+   * to an empty string to suppress the default navigation and handle the click
+   * yourself via `onLicensed`.
+   */
+  licenseUrl?: string;
+  /**
+   * Optional per-row content. Rendered as light-DOM children with
+   * `slot="row:{id}"` so the element projects them in place of the default
+   * row name. Return `null` for a given row to keep the element's default.
+   */
+  renderRow?: CopilotThreadsDrawerRowRenderer;
+  /**
+   * Accessible + default-header label for the drawer region. Sets the custom
+   * element's `aria-label` and the default header text (shown when no
+   * `slot="header"` content is projected). Defaults to the element's built-in
+   * `"Threads"` when omitted.
+   */
+  label?: string;
+  /**
+   * Heading for the "Recent Conversations" section above the thread list. Sets
+   * the custom element's `recent-label` attribute. Defaults to the element's
+   * built-in `"Recent Conversations"` when omitted.
+   */
+  recentLabel?: string;
+  /**
+   * Whether the drawer offers a collapse toggle. Sets the custom element's
+   * `collapsible` PROPERTY. When `false`, the drawer has no collapse toggle and
+   * is always expanded. Defaults to the element's built-in `true` when omitted.
+   */
+  collapsible?: boolean;
+  /**
+   * Called when the drawer's collapsed state changes (via the element's collapse
+   * toggle), with the new collapsed state. Mirrors the element's
+   * `collapse-change` event.
+   */
+  onCollapseChange?: (collapsed: boolean) => void;
+  /**
+   * Page size for thread pagination. When set, threads are fetched in pages of
+   * this size and the drawer shows a "Load more" control while more remain.
+   * When omitted, the full list loads at once and no pagination control shows.
+   */
+  limit?: number;
+  /**
+   * `data-testid` set on the underlying custom element (handy in tests and for
+   * targeting from a host page). Defaults to `"copilot-threads-drawer"`.
+   */
+  "data-testid"?: string;
+}
+/**
+ * React wrapper for the shadow-DOM `<copilotkit-threads-drawer>` threads drawer.
+ *
+ * Responsibilities:
+ * - Registers the custom element on the client (SSR-safe; nothing renders
+ *   during prerender to avoid hydration mismatch).
+ * - Feeds the element domain data: `threads`, `loading`, `error`,
+ *   `activeThreadId`, `licensed`, fetch-more state.
+ * - Routes the element's outbound events to core thread operations
+ *   ({@link useThreads}) and chat-configuration changes.
+ * - Registers with the surrounding chat configuration so the header
+ *   thread-list launcher appears, and binds the element `open` state to the
+ *   configuration's `drawerOpen`.
+ *
+ * Intelligence gating is two-pronged: the locked view shows when the runtime
+ * reports no active entitlement OR the `threads` feature is unavailable. While
+ * unavailable, the thread fetch is skipped entirely so the drawer issues no
+ * network requests.
+ *
+ * Thread switching needs no host wiring: when `onThreadSelect`/`onNewThread`
+ * are omitted, the wrapper drives the surrounding chat configuration directly
+ * ({@link CopilotChatConfigurationValue.setActiveThreadId} /
+ * {@link CopilotChatConfigurationValue.startNewThread}), so a bare drawer
+ * connects to the picked thread and shows the welcome screen on "+ New". Pass
+ * the callbacks only to take control yourself.
+ *
+ * @example
+ * ```tsx
+ * // Callback-free: the drawer drives the chat configuration itself.
+ * <CopilotKitProvider runtimeUrl="/api/copilotkit">
+ *   <CopilotChat />
+ *   <CopilotThreadsDrawer />
+ * </CopilotKitProvider>
+ * ```
+ */
+declare function CopilotThreadsDrawer({
+  agentId,
+  onThreadSelect,
+  onNewThread,
+  onLicensed,
+  licenseUrl,
+  renderRow,
+  label,
+  recentLabel,
+  collapsible,
+  onCollapseChange,
+  limit,
+  "data-testid": dataTestId
+}: CopilotThreadsDrawerProps): React$1.ReactElement | null;
+declare namespace CopilotThreadsDrawer {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/chat/CopilotChatAttachmentQueue.d.ts
+interface CopilotChatAttachmentQueueProps {
+  attachments: Attachment$1[];
+  onRemoveAttachment: (id: string) => void;
+  className?: string;
+}
+/**
+ * The attachments queued in the composer, each with a preview and a remove
+ * button named by `labels.attachmentRemoveButtonLabel`.
+ */
+declare const CopilotChatAttachmentQueue: React$1.FC<CopilotChatAttachmentQueueProps>;
+//#endregion
+//#region src/components/chat/CopilotChatAttachmentRenderer.d.ts
+interface CopilotChatAttachmentRendererProps {
+  type: "image" | "audio" | "video" | "document";
+  source: InputContentSource$1;
+  filename?: string;
+  className?: string;
+}
+declare const CopilotChatAttachmentRenderer: React$1.FC<CopilotChatAttachmentRendererProps>;
+//#endregion
+//#region src/components/WildcardToolCallRender.d.ts
+/**
+ * Catch-all (`"*"`) tool-call renderer that shows CopilotKit's default
+ * tool-call card for any tool without a dedicated renderer.
+ */
+declare const WildcardToolCallRender: ReactToolCallRenderer<any>;
+//#endregion
+//#region src/components/CopilotKitInspectorContext.d.ts
+type CopilotKitInspectorOpenRequest = {
+  messageId: string;
+  threadId?: string;
+  agentId?: string;
+};
+//#endregion
+//#region src/components/CopilotKitInspector.d.ts
+interface CopilotKitInspectorProps {
+  core?: CopilotKitCore$1 | null;
+  onVisibilityChange?: (visible: boolean) => void;
+  openRequest?: CopilotKitInspectorOpenRequest | null;
+}
+declare const CopilotKitInspector: react.FC<CopilotKitInspectorProps>;
+//#endregion
+//#region src/components/MCPAppsActivityRenderer.d.ts
+/**
+ * Props for the activity renderer component
+ */
+interface MCPAppsActivityRendererProps {
+  activityType: string;
+  content: MCPAppsActivityContent$1;
+  message: unknown;
+  agent: AbstractAgent$1 | undefined;
+  /**
+   * Restore `allow-same-origin` on the sandbox. Unsafe: the widget runs with
+   * the host page's origin. Set via `mcpApps.allowSameOriginFallback` on
+   * `CopilotKitProvider`.
+   */
+  allowSameOriginFallback?: boolean;
+}
+/**
+ * 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. The React shell
+ * owns the iframe; `bindMcpApp` owns the protocol.
+ */
+declare const MCPAppsActivityRenderer: React$1.FC<MCPAppsActivityRendererProps>;
+//#endregion
+//#region src/components/OpenGenerativeUIRenderer.d.ts
+declare const OpenGenerativeUIActivityType = "open-generative-ui";
+declare const OpenGenerativeUIContentSchema: z.ZodObject<{
+  initialHeight: z.ZodOptional<z.ZodNumber>;
+  generating: z.ZodOptional<z.ZodBoolean>;
+  css: z.ZodOptional<z.ZodString>;
+  cssComplete: z.ZodOptional<z.ZodBoolean>;
+  html: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  htmlComplete: z.ZodOptional<z.ZodBoolean>;
+  jsFunctions: z.ZodOptional<z.ZodString>;
+  jsFunctionsComplete: z.ZodOptional<z.ZodBoolean>;
+  jsExpressions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  jsExpressionsComplete: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+  html?: string[] | undefined;
+  initialHeight?: number | undefined;
+  generating?: boolean | undefined;
+  css?: string | undefined;
+  cssComplete?: boolean | undefined;
+  htmlComplete?: boolean | undefined;
+  jsFunctions?: string | undefined;
+  jsFunctionsComplete?: boolean | undefined;
+  jsExpressions?: string[] | undefined;
+  jsExpressionsComplete?: boolean | undefined;
+}, {
+  html?: string[] | undefined;
+  initialHeight?: number | undefined;
+  generating?: boolean | undefined;
+  css?: string | undefined;
+  cssComplete?: boolean | undefined;
+  htmlComplete?: boolean | undefined;
+  jsFunctions?: string | undefined;
+  jsFunctionsComplete?: boolean | undefined;
+  jsExpressions?: string[] | undefined;
+  jsExpressionsComplete?: boolean | undefined;
+}>;
+type OpenGenerativeUIContent = z.infer<typeof OpenGenerativeUIContentSchema>;
+/**
+ * Schema for the generateSandboxedUi tool call arguments.
+ * Used by the frontend tool renderer to display placeholder messages.
+ */
+declare const GenerateSandboxedUiArgsSchema: z.ZodObject<{
+  initialHeight: z.ZodOptional<z.ZodNumber>;
+  placeholderMessages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  css: z.ZodOptional<z.ZodString>;
+  html: z.ZodOptional<z.ZodString>;
+  jsFunctions: z.ZodOptional<z.ZodString>;
+  jsExpressions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+  html?: string | undefined;
+  initialHeight?: number | undefined;
+  css?: string | undefined;
+  jsFunctions?: string | undefined;
+  jsExpressions?: string[] | undefined;
+  placeholderMessages?: string[] | undefined;
+}, {
+  html?: string | undefined;
+  initialHeight?: number | undefined;
+  css?: string | undefined;
+  jsFunctions?: string | undefined;
+  jsExpressions?: string[] | undefined;
+  placeholderMessages?: string[] | undefined;
+}>;
+type GenerateSandboxedUiArgs = z.infer<typeof GenerateSandboxedUiArgsSchema>;
+interface OpenGenerativeUIActivityRendererProps {
+  activityType: string;
+  content: OpenGenerativeUIContent;
+  message: unknown;
+  agent: unknown;
+}
+/**
+ * Outer wrapper — absorbs every parent re-render but only forwards
+ * throttled content snapshots to the memoized inner component.
+ */
+declare const OpenGenerativeUIActivityRenderer: React$1.FC<OpenGenerativeUIActivityRendererProps>;
+/**
+ * Frontend tool renderer for generateSandboxedUi.
+ * Displays placeholder messages while the UI is being generated.
+ */
+declare const OpenGenerativeUIToolRenderer: React$1.FC<{
+  name: string;
+  args: Partial<GenerateSandboxedUiArgs>;
+  status: ToolCallStatus$1.InProgress;
+  result: undefined;
+} | {
+  name: string;
+  args: GenerateSandboxedUiArgs;
+  status: ToolCallStatus$1.Executing;
+  result: undefined;
+} | {
+  name: string;
+  args: GenerateSandboxedUiArgs;
+  status: ToolCallStatus$1.Complete;
+  result: string;
+}>;
+//#endregion
+//#region src/types/react-tool-call-renderer.d.ts
+interface ReactToolCallRenderer<T = unknown> {
+  name: string;
+  /**
+   * Schema describing the tool arguments. Optional — renderers registered for
+   * tools without parameters (e.g. HITL confirm dialogs) have no schema.
+   */
+  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;
+  /**
+   * Whether calls this renderer draws join the chat's tool-call groups (see
+   * `toolCallDisplay` on `CopilotChatMessageView`). CopilotKit's built-in card
+   * sets it; a renderer that leaves it unset always shows its calls on their
+   * own, since the chat can't tell what it draws (it may even draw nothing).
+   */
+  group?: boolean;
+  render: React.ComponentType<{
+    name: string;
+    toolCallId: string;
+    args: Partial<T>;
+    status: ToolCallStatus$1.InProgress;
+    result: undefined;
+  } | {
+    name: string;
+    toolCallId: string;
+    args: T;
+    status: ToolCallStatus$1.Executing;
+    result: undefined;
+  } | {
+    name: string;
+    toolCallId: string;
+    args: T;
+    status: ToolCallStatus$1.Complete;
+    result: string;
+  }>;
+}
+//#endregion
+//#region src/hooks/use-render-tool-call.d.ts
+interface UseRenderToolCallProps {
+  toolCall: ToolCall$1;
+  toolMessage?: ToolMessage$1;
+}
+/**
+ * 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/types/react-custom-message-renderer.d.ts
+type ReactCustomMessageRendererPosition = "before" | "after";
+interface ReactCustomMessageRenderer {
+  agentId?: string;
+  render: React.ComponentType<{
+    message: Message$1;
+    position: ReactCustomMessageRendererPosition;
+    runId: string;
+    messageIndex: number;
+    messageIndexInRun: number;
+    numberOfMessagesInRun: number;
+    agentId: string;
+    stateSnapshot: any;
+  }> | null;
+}
+//#endregion
+//#region src/hooks/use-render-custom-messages.d.ts
+interface UseRenderCustomMessagesParams {
+  message: Message$1;
+  position: ReactCustomMessageRendererPosition;
+}
+declare function useRenderCustomMessages(): ((params: UseRenderCustomMessagesParams) => react_jsx_runtime0.JSX.Element | null) | null;
+//#endregion
+//#region src/types/frontend-tool.d.ts
+type ReactFrontendTool<T extends Record<string, unknown> = Record<string, unknown>> = FrontendTool$1<T> & {
+  render?: ReactToolCallRenderer<T>["render"];
+};
+//#endregion
+//#region src/types/human-in-the-loop.d.ts
+type ReactHumanInTheLoop<T extends Record<string, unknown> = Record<string, unknown>> = Omit<FrontendTool$1<T>, "handler"> & {
+  /**
+   * Render the human-in-the-loop UI for this tool call.
+   *
+   * Beyond the tool call's `args`/`status`/`result`, the render props carry
+   * attribution:
+   * - `toolCallId` — the AG-UI tool call id, unique per interrupt. It is the
+   *   stable key for correlating this interrupt with runtime (sub)agent
+   *   attribution — e.g. the `agentId` reported by `onToolExecutionStart`, or
+   *   per-run attribution stamped on the event stream — so the UI can label
+   *   the interrupt with the agent that actually raised it.
+   * - `agentId` — the agent this tool was *registered* to (the tool's own
+   *   `agentId`), or `undefined` for an unscoped tool. This is the static
+   *   registration scope; it is NOT necessarily the runtime (sub)agent that
+   *   raised the interrupt. For runtime attribution, correlate `toolCallId`
+   *   with the event-stream/`onToolExecutionStart` agent id.
+   */
+  render: React$1.ComponentType<{
+    name: string;
+    description: string;
+    toolCallId: string;
+    agentId?: string;
+    args: Partial<T>;
+    status: ToolCallStatus$1.InProgress;
+    result: undefined;
+    respond: undefined;
+  } | {
+    name: string;
+    description: string;
+    toolCallId: string;
+    agentId?: string;
+    args: T;
+    status: ToolCallStatus$1.Executing;
+    result: undefined;
+    respond: (result: unknown) => Promise<void>;
+  } | {
+    name: string;
+    description: string;
+    toolCallId: string;
+    agentId?: string;
+    args: T;
+    status: ToolCallStatus$1.Complete;
+    result: string;
+    respond: undefined;
+  }>;
+};
+//#endregion
+//#region src/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;
+  toolCallId: string;
+  args: Partial<T>;
+  status: ToolCallStatus$1.InProgress;
+  result: undefined;
+} | {
+  name: string;
+  toolCallId: string;
+  args: T;
+  status: ToolCallStatus$1.Executing;
+  result: undefined;
+} | {
+  name: string;
+  toolCallId: string;
+  args: T;
+  status: ToolCallStatus$1.Complete;
+  result: string;
+};
+declare function defineToolCallRenderer(def: {
+  name: "*";
+  render: (props: RenderProps<any>) => React$1.ReactElement | null;
+  agentId?: string;
+  group?: boolean;
+}): ReactToolCallRenderer<any>;
+declare function defineToolCallRenderer<S extends StandardSchemaV1>(def: {
+  name: string;
+  args: S;
+  render: (props: RenderProps<InferSchemaOutput<S>>) => React$1.ReactElement | null;
+  agentId?: string;
+  group?: boolean;
+}): ReactToolCallRenderer<InferSchemaOutput<S>>;
+//#endregion
+//#region src/types/interrupt.d.ts
+/** Name of the legacy custom event agents emit to signal an interrupt. */
+declare const INTERRUPT_EVENT_NAME = "on_interrupt";
+/** Legacy custom-event interrupt payload (agent emits a custom `on_interrupt` event). */
+interface InterruptEvent<TValue = unknown> {
+  name: string;
+  value: TValue;
+}
+/**
+ * Resolve the agent with user input for an interrupt.
+ *
+ * - Standard interrupts: records `{ status: "resolved", payload }` for the target
+ *   interrupt (defaults to the primary one). Resumes once every open interrupt is
+ *   addressed; returns the resume run result, or `void` while still awaiting others.
+ * - Legacy interrupts: resumes immediately via `command.resume = payload`.
+ */
+type InterruptResolveFn = (payload?: unknown, interruptId?: string) => Promise<RunAgentResult$1 | void>;
+/**
+ * Cancel an interrupt.
+ *
+ * - Standard interrupts: records `{ status: "cancelled" }` for the target interrupt
+ *   (defaults to the primary one), then resumes once all are addressed.
+ * - Legacy interrupts: dismisses the pending interrupt without resuming.
+ */
+type InterruptCancelFn = (interruptId?: string) => Promise<RunAgentResult$1 | void>;
+interface InterruptHandlerProps<TValue = unknown> {
+  /**
+   * Legacy event shape (`{ name, value }`). Always present for back-compat: for
+   * standard interrupts, `value` is the primary `Interrupt` and `name` is `"on_interrupt"`.
+   * Prefer `interrupt` / `interrupts` for standard interrupts.
+   */
+  event: InterruptEvent<TValue>;
+  /** Primary standard interrupt (`interrupts[0]`), or `null` for legacy interrupts. */
+  interrupt: Interrupt | null;
+  /** All open standard interrupts (empty array for legacy interrupts). */
+  interrupts: Interrupt[];
+  resolve: InterruptResolveFn;
+  cancel: InterruptCancelFn;
+}
+interface InterruptRenderProps<TValue = unknown, TResult = unknown> {
+  event: InterruptEvent<TValue>;
+  interrupt: Interrupt | null;
+  interrupts: Interrupt[];
+  result: TResult;
+  resolve: InterruptResolveFn;
+  cancel: InterruptCancelFn;
+}
+//#endregion
+//#region src/types/sandbox-function.d.ts
+type SandboxFunction<TParams extends StandardSchemaV1 = StandardSchemaV1> = {
+  name: string;
+  description: string;
+  parameters: TParams;
+  handler: (args: any) => Promise<unknown>;
+};
+//#endregion
+//#region src/hooks/use-render-activity-message.d.ts
+declare function useRenderActivityMessage(): {
+  renderActivityMessage: (message: ActivityMessage$1) => React.ReactElement | null;
+  findRenderer: (activityType: string) => ReactActivityMessageRenderer<unknown> | null;
+};
+//#endregion
+//#region src/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/hooks/use-frontend-tools.d.ts
+/**
+ * Register a list of frontend tools whose length can change between renders.
+ *
+ * `useFrontendTool` registers exactly one tool per call, so it cannot be called
+ * in a loop over a runtime-length list without breaking the rules of hooks.
+ * This hook runs a single effect over the whole array instead, which makes it
+ * safe to build the list from state, props, or a server response.
+ *
+ * Tools are keyed by `name` plus `agentId`, the same as `useFrontendTool`. A
+ * tool that disappears from the array is unregistered on the next render, and
+ * every tool is unregistered on unmount. Renderers stay registered after
+ * unmount so past tool calls still render in the chat history.
+ *
+ * @param tools - The tools to register. May be empty and may change length.
+ * @param deps - Extra dependencies that force re-registration, compared by
+ * identity like the second argument of `useEffect`. Use this when a handler
+ * closes over a value that is not part of the tool definition. Keep the array
+ * a constant length across renders.
+ *
+ * @example
+ * Register one tool per item in application state:
+ * ```tsx
+ * const [reports, setReports] = useState<Report[]>([]);
+ *
+ * useFrontendTools(
+ *   reports.map((report) => ({
+ *     name: `open_${report.id}`,
+ *     description: `Open the ${report.title} report`,
+ *     handler: async () => navigate(`/reports/${report.id}`),
+ *   })),
+ *   [navigate],
+ * );
+ * ```
+ *
+ * @example
+ * Register tools described by the backend:
+ * ```tsx
+ * const { data } = useQuery(fetchToolDescriptors);
+ *
+ * useFrontendTools(
+ *   (data ?? []).map((descriptor) => ({
+ *     name: descriptor.name,
+ *     description: descriptor.description,
+ *     parameters: z.object({ query: z.string() }),
+ *     handler: async ({ query }) => runDescriptor(descriptor.id, query),
+ *   })),
+ * );
+ * ```
+ */
+declare function useFrontendTools(tools: ReadonlyArray<ReactFrontendTool<any>> | undefined, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/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<any, Record<string, unknown>> | undefined = undefined>(config: {
+  name: string;
+  description?: string;
+  parameters?: TSchema;
+  render: ComponentType<NoInfer<InferRenderProps<TSchema>>>;
+  agentId?: string;
+  followUp?: boolean;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/hooks/use-render-tool.d.ts
+interface RenderToolInProgressProps<S extends StandardSchemaV1> {
+  name: string;
+  toolCallId: string;
+  parameters: Partial<InferSchemaOutput<S>>;
+  status: "inProgress";
+  result: undefined;
+}
+interface RenderToolExecutingProps<S extends StandardSchemaV1> {
+  name: string;
+  toolCallId: string;
+  parameters: InferSchemaOutput<S>;
+  status: "executing";
+  result: undefined;
+}
+interface RenderToolCompleteProps<S extends StandardSchemaV1> {
+  name: string;
+  toolCallId: 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 | null;
+  agentId?: string; /** Let the chat group the calls this renderer draws (see `toolCallDisplay`). */
+  group?: boolean;
+}, 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 | null;
+  agentId?: string; /** Let the chat group the calls this renderer draws (see `toolCallDisplay`). */
+  group?: boolean;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/hooks/use-default-render-tool.d.ts
+type DefaultRenderProps = {
+  /** The name of the tool being called. */name: string; /** The id of the tool call being rendered. */
+  toolCallId: 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 | null;
+  /**
+   * Let the chat group calls your `render` draws, like it groups the
+   * built-in card's (see `toolCallDisplay` on `CopilotChatMessageView`).
+   * Off by default for a custom `render`, since it may draw nothing.
+   */
+  group?: boolean;
+}, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/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/hooks/use-agent.d.ts
+declare enum UseAgentUpdate {
+  OnMessagesChanged = "OnMessagesChanged",
+  OnStateChanged = "OnStateChanged",
+  OnRunStatusChanged = "OnRunStatusChanged"
+}
+interface UseAgentPropsBase {
+  updates?: UseAgentUpdate[];
+  /**
+   * Throttle interval (in milliseconds) for re-renders triggered by
+   * `onMessagesChanged` and `onStateChanged` notifications. Useful to reduce
+   * re-render frequency during high-frequency streaming updates.
+   *
+   * Uses a leading+trailing pattern with a shared window — first update
+   * fires immediately, subsequent updates within the window are coalesced,
+   * and a trailing timer ensures the most recent update fires after the
+   * window expires. See `CopilotKitCore.subscribeToAgentWithOptions` in `@copilotkit/core`
+   * for details.
+   *
+   * Resolved as: `throttleMs ?? provider defaultThrottleMs ?? 0`.
+   * Passing `throttleMs={0}` explicitly disables throttling even when the
+   * provider specifies a non-zero `defaultThrottleMs`.
+   *
+   * Run lifecycle callbacks (`onRunInitialized`, `onRunFinalized`,
+   * `onRunFailed`, `onRunErrorEvent`) always fire immediately.
+   *
+   * @default undefined
+   * When unset, inherits from the provider's `defaultThrottleMs`;
+   * if that is also unset, the effective value is `0` (no throttle).
+   */
+  throttleMs?: number;
+}
+/**
+ * Thread-scoped variant. `agentId`, `runtimeAgentId`, and `threadId` are a
+ * matched set: together they give this hook a *private* agent — registered
+ * under the local `agentId`, routing outbound to `runtimeAgentId` — that is
+ * safe to pin a thread onto. None of the three is meaningful without the other
+ * two, so all are required here.
+ */
+interface UseAgentThreadScopedProps {
+  /**
+   * The name to register this hook's proxied agent under.
+   *
+   * Required, and must not already be taken. The usual fallbacks (the chat
+   * configuration's agentId, then `DEFAULT_AGENT_ID`) name agents that already
+   * exist, and registering over one either throws `already registered` or
+   * silently shadows it, depending on whether runtime discovery has landed — so
+   * the caller has to name it.
+   */
+  agentId: string;
+  /**
+   * Thread to scope the agent's run to. Written onto the underlying agent, so
+   * `/agent/run`, `/agent/connect`, and `/agent/stop` address this thread.
+   *
+   * REQUIRES `runtimeAgentId`. A runtime agent registered under a given id is a
+   * singleton, so writing a per-hook threadId directly onto it would let two
+   * `useAgent` calls that share an `agentId` clobber each other's thread.
+   * Passing a distinct local `agentId` plus the `runtimeAgentId` it routes to
+   * gives this hook a private proxied agent to pin the thread onto instead of a
+   * shared one.
+   */
+  threadId: string;
+  /**
+   * The id of the runtime agent to route outbound requests to, while this hook
+   * exposes a distinct local `agentId`. Registers a proxied agent via
+   * `CopilotKitCore.registerProxiedAgent`, letting several frontend agents
+   * (e.g. one per open thread) mount against a single runtime agent without a
+   * shared-singleton collision.
+   *
+   * When set, `agentId` is the *local* registry id (must not collide with an
+   * existing local or runtime-discovered agent) and `runtimeAgentId` is the
+   * runtime agent the proxy addresses on `/agent/run` etc.
+   *
+   * REQUIRES `threadId`. Registering a private agent is only worth doing to
+   * scope a thread to it; without a `threadId` the private agent would take its
+   * thread from the chat configuration, which is what binding to the shared
+   * agent via `agentId` alone already does — just with an extra registration
+   * and a local id to keep unique.
+   */
+  runtimeAgentId: string;
+}
+/**
+ * Default variant: neither `threadId` nor `runtimeAgentId`. The hook binds to
+ * the shared agent registered under `agentId` and leaves its threadId to the
+ * chat configuration (or to the agent's own auto-minted UUID).
+ *
+ * Both props are typed `undefined` here rather than omitted so that supplying
+ * either one on its own fails to match *both* branches — that is the
+ * type-level enforcement of the all-or-nothing rule.
+ */
+interface UseAgentUnscopedProps {
+  /**
+   * Agent to bind to. Resolution precedence: this property, then the surrounding
+   * chat configuration's agentId, then the global default.
+   */
+  agentId?: string;
+  /** Requires `runtimeAgentId`. See {@link UseAgentThreadScopedProps.threadId}. */
+  threadId?: undefined;
+  /** Requires `threadId`. See {@link UseAgentThreadScopedProps.runtimeAgentId}. */
+  runtimeAgentId?: undefined;
+}
+/**
+ * Props for {@link useAgent}.
+ *
+ * There are exactly two valid shapes, and the type admits nothing in between:
+ *
+ * - **Bind to an agent** — `useAgent()`, `useAgent({ agentId })`. The shared
+ *   instance from the registry; the thread comes from the chat configuration.
+ * - **Bind a private agent to a thread** —
+ *   `useAgent({ agentId, runtimeAgentId, threadId })`. All three required.
+ *
+ * So `useAgent({ agentId, threadId })`, `useAgent({ agentId, runtimeAgentId })`,
+ * and `useAgent({ runtimeAgentId, threadId })` are all compile errors. Each
+ * partial combination is either unsafe (a thread scoped onto a shared singleton)
+ * or pointless (a private agent with no thread, or one registered over an id
+ * that already belongs to a real agent).
+ */
+type UseAgentProps = UseAgentPropsBase & (UseAgentThreadScopedProps | UseAgentUnscopedProps);
+declare function useAgent({
+  agentId,
+  threadId,
+  runtimeAgentId,
+  updates,
+  throttleMs
+}?: UseAgentProps): {
+  agent: AbstractAgent$1;
+  /**
+   * Whether `agent` is the real, runtime-synced (or locally-registered) agent
+   * rather than a provisional stand-in returned while the runtime is still
+   * connecting (or in an error state).
+   *
+   * `agent` is always a fully-constructed `AbstractAgent`, so calling
+   * `agent.subscribe(...)`, `agent.setState(...)`, etc. is always safe. But
+   * while `isReady` is `false` the instance is a placeholder that will be
+   * swapped for the real agent once the runtime `/info` sync resolves, at
+   * which point `agent` changes reference and dependent effects re-run.
+   * Guard on `isReady` when you only want to act against the real agent —
+   * e.g. subscribing to run-lifecycle events you don't want to miss during
+   * the provisional window (#5000).
+   */
+  isReady: boolean;
+};
+//#endregion
+//#region src/hooks/use-capabilities.d.ts
+/**
+ * Returns the capabilities declared by the given agent (or the agent resolved
+ * from the surrounding chat configuration, falling back to the default agent).
+ * Capabilities are populated from the runtime `/info` response at connection
+ * time. The hook reads them synchronously from the agent instance — there is
+ * no separate loading state, but the value will be `undefined` until the
+ * runtime handshake completes.
+ *
+ * @param agentId - Optional agent ID. If omitted, inherits the surrounding
+ *          chat configuration's agent, falling back to the default agent.
+ * @returns The agent's capabilities, or `undefined` if the agent doesn't
+ *          declare capabilities.
+ */
+declare function useCapabilities(agentId?: string): AgentCapabilities$1 | undefined;
+//#endregion
+//#region src/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/hooks/use-suggestions.d.ts
+interface UseSuggestionsOptions {
+  agentId?: string;
+}
+interface UseSuggestionsResult {
+  suggestions: Suggestion$1[];
+  reloadSuggestions: () => void;
+  clearSuggestions: () => void;
+  isLoading: boolean;
+}
+declare function useSuggestions({
+  agentId
+}?: UseSuggestionsOptions): UseSuggestionsResult;
+//#endregion
+//#region src/hooks/use-configure-suggestions.d.ts
+type StaticSuggestionInput = Omit<Suggestion$1, "isLoading"> & Partial<Pick<Suggestion$1, "isLoading">>;
+type StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig$1, "suggestions"> & {
+  suggestions: StaticSuggestionInput[];
+};
+type SuggestionsConfigInput = DynamicSuggestionsConfig$1 | StaticSuggestionsConfigInput;
+declare function useConfigureSuggestions(config: SuggestionsConfigInput | null | undefined, deps?: ReadonlyArray<unknown>): void;
+//#endregion
+//#region src/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;
+/** Recognize thenables returned by interrupt preprocessing handlers. */
+/**
+ * Configuration options for `useInterrupt`.
+ */
+interface UseInterruptConfigBase<TValue = unknown, TResult = never> {
+  /**
+   * Render function for the interrupt UI.
+   *
+   * Receives both the standard `interrupt`/`interrupts` and the legacy `event`.
+   * Call `resolve(payload)` to resume with user input, or `cancel()` to cancel.
+   */
+  render: (props: InterruptRenderProps<TValue, InterruptResult<TValue, TResult>>) => React$1.ReactElement;
+  /**
+   * Optional pre-render handler invoked when an interrupt is received.
+   * Return a sync or async value to expose as `result` in `render`.
+   * Rejecting/throwing falls back to `result = null`.
+   */
+  handler?: InterruptHandlerFn<TValue, TResult>;
+  /**
+   * Optional predicate to filter which interrupts this hook handles.
+   * Receives the legacy-compatible event (for standard interrupts, `value` is
+   * the primary `Interrupt`). Return `false` to ignore.
+   */
+  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. */renderInChat?: TRenderInChat;
+};
+/**
+ * Handles agent interrupts with optional filtering, preprocessing, and resume behavior.
+ *
+ * Supports both the AG-UI standard interrupt flow (`RUN_FINISHED` with
+ * `outcome.type === "interrupt"`) and the legacy custom-event flow
+ * (`on_interrupt`). For standard interrupts, `render` receives `interrupt`
+ * (the primary one) and `interrupts` (the full open set); call `resolve(payload)`
+ * to resume or `cancel()` to cancel. Resuming addresses the targeted interrupt
+ * and, once every open interrupt is addressed, submits a single spec `resume`
+ * array via `copilotkit.runAgent`.
+ *
+ * - `renderInChat: true` (default): the element is published into `<CopilotChat>`; returns `void`.
+ * - `renderInChat: false`: the hook returns the interrupt element for manual placement.
+ *
+ * @example
+ * ```tsx
+ * useInterrupt({
+ *   render: ({ interrupt, resolve, cancel }) => (
+ *     <div>
+ *       <p>{interrupt?.message}</p>
+ *       <button onClick={() => resolve({ approved: true })}>Approve</button>
+ *       <button onClick={() => cancel()}>Cancel</button>
+ *     </div>
+ *   ),
+ * });
+ * ```
+ */
+declare function useInterrupt<TResult = never, TRenderInChat extends InterruptRenderInChat = undefined>(config: UseInterruptConfig<any, TResult, TRenderInChat>): UseInterruptReturn<TRenderInChat>;
+//#endregion
+//#region src/hooks/use-memories.d.ts
+/**
+ * Return value of the {@link useMemories} hook.
+ *
+ * The `memories` array is the server-authoritative list for the current user.
+ * It is hydrated from a REST snapshot and kept current by realtime
+ * `memory_metadata` deltas from the store's own channel. Mutations resolve
+ * once the platform confirms the operation and reject with an `Error` on
+ * failure.
+ */
+interface UseMemoriesResult {
+  /**
+   * Memories for the current user, newest first. Updated in realtime when
+   * the platform pushes `memory_metadata` events.
+   */
+  memories: Memory$1[];
+  /**
+   * `true` while the initial memory snapshot is being fetched. Subsequent
+   * realtime updates do not re-enter the loading state.
+   */
+  isLoading: boolean;
+  /**
+   * The most recent error from fetching memories or executing a mutation, or
+   * `null` when there is no error. Cleared on the next fetch attempt, on a
+   * successful fetch, when the runtime context changes, and on a successful
+   * mutation (a failed mutation replaces it with that mutation's error).
+   */
+  error: Error | null;
+  /**
+   * `true` when the platform memory routes are available. Set to `false`
+   * after a 404 or 501, indicating memory is not supported by the current
+   * runtime configuration.
+   */
+  isAvailable: boolean;
+  /**
+   * Health of the realtime connection that streams live `memory_metadata`
+   * deltas. Distinct from `isAvailable`/`error` (which describe the REST list
+   * route): `"connecting"` while the socket opens/joins, `"connected"` once
+   * live deltas are flowing, and `"unavailable"` once the socket permanently
+   * gives up — at which point the list is a frozen snapshot. Lets the UI drop a
+   * "live" indicator instead of showing it over stale data.
+   */
+  realtimeStatus: MemoryRealtimeStatus$1;
+  /**
+   * Re-fetch the memory snapshot from the platform. Resolves once the re-pull
+   * settles; rejects if it fails or the store is torn down mid-flight.
+   */
+  refresh: () => Promise<void>;
+  /**
+   * Create a memory. Resolves to the stored memory (server-authoritative);
+   * rejects on failure.
+   */
+  addMemory: (input: NewMemory$1) => Promise<Memory$1>;
+  /**
+   * Supersede a memory: the old memory is retired and a new one is created.
+   * Resolves to the new memory (its `id` differs from `id`); rejects on
+   * failure.
+   *
+   * Supersede is a FULL replacement, not a partial patch: `changes` is the
+   * complete definition of the new memory. You must re-supply `content` and
+   * `kind`, and an omitted `sourceThreadIds` resets the new memory's source
+   * threads to empty — it does not preserve the prior memory's value.
+   */
+  updateMemory: (id: string, changes: MemoryChanges$1) => Promise<Memory$1>;
+  /**
+   * Retire a memory (non-lossy delete). Resolves when the server confirms;
+   * rejects on failure.
+   */
+  removeMemory: (id: string) => Promise<void>;
+}
+/**
+ * React hook for listing and managing platform memories.
+ *
+ * Reads the memory store owned and wired by `CopilotKitCore`. On mount the
+ * hook exposes the live list plus stable `addMemory` / `updateMemory` /
+ * `removeMemory` / `refresh` callbacks. Mutations are server-authoritative:
+ * each resolves once the platform confirms the operation and rejects with an
+ * `Error` on failure.
+ *
+ * Realtime updates are automatic: the core's memory store opens its own
+ * `user_meta:memories:<joinCode>` channel and applies `memory_metadata` deltas
+ * to the list. You can still call `refresh()` to re-pull the REST snapshot on
+ * demand.
+ *
+ * @returns Memory list state and stable mutation callbacks.
+ *
+ * @example
+ * ```tsx
+ * import { useMemories } from "@copilotkit/react-core";
+ *
+ * function MemoryList() {
+ *   const { memories, isLoading, isAvailable, addMemory, removeMemory } =
+ *     useMemories();
+ *
+ *   if (!isAvailable) return null;
+ *   if (isLoading) return <p>Loading…</p>;
+ *
+ *   return (
+ *     <ul>
+ *       {memories.map((m) => (
+ *         <li key={m.id}>
+ *           {m.content}
+ *           <button onClick={() => removeMemory(m.id)}>Delete</button>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useMemories(): UseMemoriesResult;
+//#endregion
+//#region src/hooks/use-learn-from-user-action.d.ts
+/**
+ * Input to {@link UseLearnFromUserActionRecorder}, the function returned
+ * by {@link useLearnFromUserAction}. Captures a single UI interaction that
+ * CopilotKit Intelligence's auto-curated knowledge base loop will distill
+ * into the team's `/project` notes.
+ */
+interface LearnFromUserActionInput {
+  /** Thread the action is associated with. May be unknown to the platform. */
+  threadId: string;
+  /** Short, agent-readable summary of what the user did. Optional. */
+  title?: string | null;
+  /** Optional longer explanation. */
+  description?: string | null;
+  /** Free-form, JSON-serializable snapshot describing the action. Optional. */
+  data?: unknown;
+  /** ISO-8601 client-asserted timestamp. Defaults to server NOW() when absent. */
+  occurredAt?: string;
+  /**
+   * Caller-supplied idempotency key. When omitted, `recordAnnotation` generates a
+   * fresh UUID per call so retries collapse to the original row at the
+   * platform. Supply your own to keep a single semantic event idempotent
+   * across calls (e.g. a React re-render or a manual retry button).
+   */
+  clientEventId?: string;
+}
+/** Outcome returned by the recorder function. */
+interface LearnFromUserActionResult {
+  /** Platform-assigned id of the user-action row. */
+  id: string;
+  /** True when the platform recognized this `clientEventId` as a retry. */
+  duplicate: boolean;
+}
+/** Recorder function returned by {@link useLearnFromUserAction}. */
+type UseLearnFromUserActionRecorder = (input: LearnFromUserActionInput) => Promise<LearnFromUserActionResult>;
+/**
+ * Record a user UI interaction in CopilotKit Intelligence's user-actions
+ * stream. The platform's auto-curated knowledge base agent reads these
+ * (alongside finished agent runs) and writes free-form Obsidian-flavored
+ * markdown to `/project`, where any agent in the same project can later
+ * read it via the `copilotkit_knowledge_base_shell` MCP tool.
+ *
+ * The hook returns a stable function. Calling it issues a request to the
+ * customer's CopilotKit runtime (`POST ${runtimeUrl}/annotate`), which
+ * resolves the Intel user from the BFF's auth and forwards to the
+ * platform — the Intel API key never reaches the browser.
+ *
+ * If `clientEventId` is omitted `recordAnnotation` generates a UUID per call,
+ * so a naive double-call (e.g. React 18 strict-mode double-mount, or a retry
+ * after a network blip on a fresh Promise) is naturally safe. Supply your
+ * own key when a single semantic event must remain idempotent across
+ * multiple `learnFromUserAction(...)` calls.
+ *
+ * @example
+ * ```tsx
+ * import { useLearnFromUserAction } from "@copilotkit/react-core";
+ *
+ * function SettingsPage({ threadId }) {
+ *   const learnFromUserAction = useLearnFromUserAction();
+ *
+ *   const onRename = (oldName: string, newName: string) => {
+ *     void learnFromUserAction({
+ *       threadId,
+ *       title: "Renamed project",
+ *       data: { previous: { name: oldName }, next: { name: newName } },
+ *     });
+ *   };
+ * }
+ * ```
+ */
+declare function useLearnFromUserAction(): UseLearnFromUserActionRecorder;
+//#endregion
+//#region src/hooks/use-learn-from-user-action-in-current-thread.d.ts
+/**
+ * Input to {@link UseLearnFromUserActionInCurrentThreadRecorder} — same as
+ * {@link LearnFromUserActionInput} minus `threadId`, which is sourced from
+ * the surrounding `<CopilotChatConfigurationProvider>` at call time.
+ */
+type LearnFromUserActionInCurrentThreadInput = Omit<LearnFromUserActionInput, "threadId">;
+/** Recorder function returned by {@link useLearnFromUserActionInCurrentThread}. */
+type UseLearnFromUserActionInCurrentThreadRecorder = (input: LearnFromUserActionInCurrentThreadInput) => Promise<LearnFromUserActionResult>;
+/**
+ * Record a user UI interaction against the **current chat's** thread. The
+ * `threadId` is sourced from the surrounding
+ * `<CopilotChatConfigurationProvider>` (the same provider `<CopilotChat>`,
+ * `<CopilotSidebar>`, and friends set up), so callers in a chat-aware
+ * subtree don't need to thread an id through manually.
+ *
+ * Throws on **call** (not on mount) when there is no chat-config provider
+ * in scope — matches the "throw on call when runtimeUrl is missing"
+ * behavior of {@link useLearnFromUserAction}. Mounting the hook in a branch
+ * that never fires is harmless.
+ *
+ * The recorder does NOT accept a `threadId` override. If you need to
+ * record against an explicit thread, use {@link useLearnFromUserAction}
+ * directly — two hooks, two crisp contracts, no mode confusion.
+ *
+ * This hook always uses `config.threadId`, regardless of whether the
+ * surrounding chat config minted it internally or received one from
+ * the caller. Auto-minted threads simply mean the action lands under
+ * a thread the platform never saw — the writer agent still distills
+ * user-action-only threads (it does not require the thread to exist
+ * in `cpki.threads`), so the loop keeps learning.
+ *
+ * @example
+ * ```tsx
+ * import { useLearnFromUserActionInCurrentThread } from "@copilotkit/react-core";
+ *
+ * function SettingsPanel() {
+ *   const learnFromUserAction = useLearnFromUserActionInCurrentThread();
+ *
+ *   const onRename = (oldName: string, newName: string) => {
+ *     void learnFromUserAction({
+ *       title: "Renamed project",
+ *       data: { previous: { name: oldName }, next: { name: newName } },
+ *     });
+ *   };
+ *
+ *   // ...
+ * }
+ * ```
+ */
+declare function useLearnFromUserActionInCurrentThread(): UseLearnFromUserActionInCurrentThreadRecorder;
+//#endregion
+//#region src/hooks/use-attachments.d.ts
+interface UseAttachmentsProps {
+  config?: AttachmentsConfig$1;
+}
+interface UseAttachmentsReturn {
+  /** Currently selected attachments (uploading + ready). */
+  attachments: Attachment$1[];
+  /** Whether attachments are enabled. */
+  enabled: boolean;
+  /** Whether the user is dragging a file over the drop zone. */
+  dragOver: boolean;
+  /** Ref for the hidden file input element. */
+  fileInputRef: React$1.RefObject<HTMLInputElement | null>;
+  /** Ref for the container element (used for scoped paste handling). */
+  containerRef: React$1.RefObject<HTMLDivElement | null>;
+  /** Process an array of files (validate, upload, add to state). */
+  processFiles: (files: File[]) => Promise<void>;
+  /** Handler for `<input type="file" onChange>`. */
+  handleFileUpload: (e: React$1.ChangeEvent<HTMLInputElement>) => Promise<void>;
+  /** Handler for `onDragOver` on the drop zone. */
+  handleDragOver: (e: React$1.DragEvent) => void;
+  /** Handler for `onDragLeave` on the drop zone. */
+  handleDragLeave: (e: React$1.DragEvent) => void;
+  /** Handler for `onDrop` on the drop zone. */
+  handleDrop: (e: React$1.DragEvent) => Promise<void>;
+  /** Remove an attachment by ID. */
+  removeAttachment: (id: string) => void;
+  /**
+   * Consume ready attachments and clear the queue.
+   * Returns the attachments that were ready; resets the file input.
+   * No-ops if the queue is already empty (no state update triggered).
+   */
+  consumeAttachments: () => Attachment$1[];
+}
+/**
+ * Hook that manages file attachment state — uploads, drag-and-drop, paste,
+ * and lifecycle. All returned callbacks are referentially stable across
+ * renders (via useCallback) to avoid destabilizing downstream memoization.
+ */
+declare function useAttachments({
+  config
+}: UseAttachmentsProps): UseAttachmentsReturn;
+//#endregion
+//#region src/hooks/use-learning-containers.d.ts
+/**
+ * Arguments for {@link useLearningContainers}.
+ *
+ * @deprecated This interface supports only the legacy plural-container
+ * annotation. Configure `getLearningContainerId` on `CopilotKitIntelligence`
+ * for new Intelligence runtimes.
+ */
+interface UseLearningContainersArgs {
+  /** Thread to apply the learning-container selection to. */
+  threadId: string;
+  /**
+   * The ordered list of learning container identifiers to activate for this
+   * thread. Defaults to `["project"]` on the backend when absent.
+   */
+  learningContainers: readonly string[];
+}
+/**
+ * Legacy compatibility hook that keeps a thread's plural learning-container
+ * annotation in sync by emitting
+ * `set_learning_containers` annotations via the CopilotKit runtime annotate
+ * endpoint (`POST ${runtimeUrl}/annotate`).
+ *
+ * **Emit rules:**
+ * - On mount with `["project"]` (the backend default) → does NOT emit.
+ *   Absence of an annotation equals the default, so the round-trip is skipped.
+ * - On mount with any other value → emits immediately.
+ * - On any subsequent content change (including a switch back to
+ *   `["project"]`) → emits (a deliberate switch is always recorded).
+ * - On unmount or threadId change → emits a reset to `["project"]`
+ *   so the backend is left in a clean state for the next consumer.
+ *   Changing `learningContainers` within the same thread does NOT reset the
+ *   thread; only the new value is emitted.
+ *
+ * Content-equality is evaluated via `JSON.stringify` so a fresh array literal
+ * with the same items does NOT trigger a redundant emit.
+ *
+ * If `runtimeUrl` is absent, all emits are silently skipped.
+ *
+ * @example
+ * ```tsx
+ * function ThreadPane({ threadId, userScope }: Props) {
+ *   useLearningContainers({
+ *     threadId,
+ *     learningContainers: [userScope],
+ *   });
+ *   // ...
+ * }
+ * ```
+ *
+ * @deprecated This hook supports only the legacy plural-container annotation.
+ * Configure `getLearningContainerId` on `CopilotKitIntelligence` for new
+ * Intelligence runtimes.
+ */
+declare function useLearningContainers({
+  threadId,
+  learningContainers
+}: UseLearningContainersArgs): void;
+//#endregion
+//#region src/hooks/use-learning-containers-in-current-thread.d.ts
+/**
+ * Arguments for {@link useLearningContainersInCurrentThread}.
+ * Same as {@link UseLearningContainersArgs} minus `threadId`, which is
+ * sourced from the surrounding `<CopilotChatConfigurationProvider>` at
+ * render time.
+ *
+ * @deprecated This type supports only the legacy plural-container annotation.
+ * Configure `getLearningContainerId` on `CopilotKitIntelligence` for new
+ * Intelligence runtimes.
+ */
+type UseLearningContainersInCurrentThreadArgs = Omit<UseLearningContainersArgs, "threadId">;
+/**
+ * Legacy compatibility hook that keeps the **current chat thread's** plural
+ * learning-container annotation in sync. The `threadId` is sourced from the surrounding
+ * `<CopilotChatConfigurationProvider>` (the same provider `<CopilotChat>`,
+ * `<CopilotSidebar>`, and friends set up), so callers in a chat-aware
+ * subtree don't need to thread an id through manually.
+ *
+ * **Throws on render** when there is no chat-config provider in scope or
+ * when the provider does not yet have an active `threadId`. Mount the hook
+ * inside a subtree that is guaranteed to have a thread context.
+ *
+ * If you need to manage an explicit thread, use {@link useLearningContainers}
+ * directly — two hooks, two crisp contracts, no mode confusion.
+ *
+ * @throws When no `CopilotChatConfigurationProvider` is in scope or when the
+ *         active `threadId` is absent/empty.
+ *
+ * @example
+ * ```tsx
+ * function ThreadPanel({ scope }: Props) {
+ *   useLearningContainersInCurrentThread({
+ *     learningContainers: [scope],
+ *   });
+ *   // ...
+ * }
+ * ```
+ *
+ * @deprecated This hook supports only the legacy plural-container annotation.
+ * Configure `getLearningContainerId` on `CopilotKitIntelligence` for new
+ * Intelligence runtimes.
+ */
+declare function useLearningContainersInCurrentThread({
+  learningContainers
+}: UseLearningContainersInCurrentThreadArgs): void;
+//#endregion
+//#region src/lib/react-core.d.ts
+interface CopilotKitCoreReactConfig extends CopilotKitCoreConfig$1 {
+  renderToolCalls?: ReactToolCallRenderer<any>[];
+  renderActivityMessages?: ReactActivityMessageRenderer<any>[];
+  renderCustomMessages?: ReactCustomMessageRenderer[];
+}
+interface CopilotKitCoreReactSubscriber extends CopilotKitCoreSubscriber$1 {
+  onRenderToolCallsChanged?: (event: {
+    copilotkit: CopilotKitCore$1;
+    renderToolCalls: ReactToolCallRenderer<any>[];
+  }) => void | Promise<void>;
+  onInterruptElementChanged?: (event: {
+    copilotkit: CopilotKitCore$1;
+    interruptElement: React$1.ReactElement | null;
+  }) => void | Promise<void>;
+}
+declare class CopilotKitCoreReact extends CopilotKitCore$1 {
+  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$1;
+  /**
+   * 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/context.d.ts
+interface CopilotKitContextValue {
+  copilotkit: CopilotKitCoreReact;
+  /**
+   * Whether CopilotKit should automatically mount Intelligence indicators.
+   * Defaults to true when omitted for compatibility with custom providers.
+   */
+  showIntelligenceIndicator?: boolean;
+  /**
+   * 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>;
+}
+declare const useCopilotKit: () => CopilotKitContextValue;
+declare const useLicenseContext: () => LicenseContextValue;
+//#endregion
+//#region src/a2ui/A2UIRecoveryStates.d.ts
+/**
+ * Shared pre-paint lifecycle states for the A2UI surface renderer (OSS-162).
+ *
+ * The A2UI middleware drives the WHOLE generative-UI lifecycle on a single
+ * `a2ui-surface` activity (one stable messageId, `replace: true`), so the states
+ * below swap IN PLACE and the painted surface ultimately replaces them:
+ *
+ *   building  → animated skeleton + "Building interface" (+ optional ~N tokens)
+ *   retrying  → same skeleton; once perceptible, the sub-label becomes
+ *               "Retrying generation… (N/M attempts)" (threshold-gated so a fast
+ *               transient retry never flashes), with debug detail per debugExposure
+ *   failed    → a clean hard-failure card (replacing the skeleton), developer
+ *               detail tucked into an expander gated by debugExposure
+ *   painted   → the surface renderer owns the UI (these states render nothing)
+ *
+ * Timing (`showAfterMs` / `showAfterAttempts`) and how much debug detail to surface
+ * (`debugExposure`) are client concerns; the server can override `debugExposure`
+ * by stamping it onto the activity content (it wins over the client option).
+ */
+type A2UIRecoveryRendererOptions = {
+  /** Delay (ms) before the "Retrying…" sub-label becomes visible. Default 2000. */showAfterMs?: number; /** Show the "Retrying…" sub-label immediately once `attempt` reaches this. Default 2. */
+  showAfterAttempts?: number; /** How much retry/debug detail to surface. Default "collapsed". */
+  debugExposure?: "hidden" | "collapsed" | "verbose";
+};
+//#endregion
+//#region src/providers/CopilotKitProvider.d.ts
+interface CopilotKitProviderProps {
+  children: ReactNode;
+  runtimeUrl?: string;
+  /**
+   * Headers sent with every request. A record, or a sync or async builder
+   * that runs when each request is sent. An inline arrow is fine. The builder
+   * should be cheap; cache tokens in it (Clerk's `getToken()` already does).
+   */
+  headers?: CopilotKitHeadersSource$1;
+  /**
+   * Credentials mode for fetch requests (e.g., "include" for HTTP-only cookies in cross-origin requests).
+   */
+  credentials?: RequestCredentials;
+  /**
+   * Rewrites the message list sent to runtime agents on every run.
+   *
+   * CopilotKit sends the whole thread each time. When your agent already
+   * stores the conversation, most of that payload is waste, and an agent that
+   * merges the inbound list with its own store can show the model every turn
+   * twice. Return the messages to send:
+   *
+   * ```tsx
+   * <CopilotKit
+   *   runtimeUrl="/api/copilotkit"
+   *   messageFilter={(messages) => messages.slice(-1)}
+   * />
+   * ```
+   *
+   * The filter changes the request body only. The transcript the UI renders is
+   * untouched. Broken tool-call pairs are repaired before the request is sent,
+   * so a filter this blunt cannot strand a tool result mid-HITL.
+   *
+   * Agents reached through your CopilotRuntime honor this. An agent your app
+   * passes in directly does not, and neither Intelligence runs nor suggestion
+   * runs are ever filtered.
+   *
+   * Prefer a stable reference (`useCallback`). An inline arrow re-registers the
+   * filter on every render, which is harmless but needless.
+   */
+  messageFilter?: CopilotKitMessageFilter$1;
+  /** Your CopilotKit public license key. */
+  publicApiKey?: string;
+  /** Your public license key for accessing CopilotKit Intelligence features. */
+  publicLicenseKey?: string;
+  /**
+   * Signed license token for offline verification of CopilotKit Intelligence features.
+   * Obtain from https://dashboard.operations.copilotkit.ai.
+   */
+  licenseToken?: string;
+  properties?: Record<string, unknown>;
+  /**
+   * The id of the agent every `<CopilotChat>` under this provider talks to,
+   * unless a chat names its own with the `agentId` prop.
+   *
+   * This is the v2 replacement for the v1 `<CopilotKit agent="...">` prop. Set
+   * it here and you never need the v1 compatibility provider just to name an
+   * agent. Defaults to `"default"`.
+   */
+  agentId?: string;
+  useSingleEndpoint?: boolean;
+  agents__unsafe_dev_only?: Record<string, AbstractAgent$1>;
+  selfManagedAgents?: Record<string, AbstractAgent$1>;
+  renderToolCalls?: ReactToolCallRenderer<any>[];
+  renderActivityMessages?: ReactActivityMessageRenderer<any>[];
+  renderCustomMessages?: ReactCustomMessageRenderer[];
+  /**
+   * Global markdown renderer used by assistant/reasoning messages. Overrides the
+   * built-in basic renderer. A per-message `markdownRenderer` slot still wins
+   * over this. Plug in your own (e.g. a streamdown wrapper) to restore rich
+   * rendering — CopilotKit ships only the basic renderer.
+   */
+  markdownRenderer?: MarkdownRenderer;
+  frontendTools?: ReactFrontendTool[];
+  humanInTheLoop?: ReactHumanInTheLoop[];
+  /**
+   * Configuration for OpenGenerativeUI — sandboxed UI generated by the LLM.
+   *
+   * @example
+   * ```tsx
+   * <CopilotKit
+   *   runtimeUrl="/api/copilotkit"
+   *   openGenerativeUI={{
+   *     sandboxFunctions: [{ name: "addToCart", description: "…", parameters: schema, handler: fn }],
+   *   }}
+   * >
+   * ```
+   */
+  openGenerativeUI?: {
+    /**
+     * Functions made available inside sandboxed iframes.
+     * Each function is described to the LLM via agent context and exposed
+     * via websandbox's `localApi`.
+     *
+     * Inside the iframe, call them with:
+     * ```js
+     * await Websandbox.connection.remote.<functionName>(args)
+     * ```
+     */
+    sandboxFunctions?: SandboxFunction[];
+    /**
+     * Design guidelines injected as agent context for the `generateSandboxedUi` tool.
+     * Override this to control the visual style of generated UIs.
+     *
+     * A sensible default is provided if omitted.
+     */
+    designSkill?: string;
+  };
+  /**
+   * @deprecated This prop no longer controls the Inspector. Use
+   * `enableInspector` instead.
+   */
+  showDevConsole?: boolean | "auto";
+  /**
+   * Disable the CopilotKit Inspector in development.
+   * The Inspector is enabled by default in development browser builds on
+   * localhost/loopback. It is always disabled on remote hosts, in production,
+   * and during server rendering. Temporary Inspector hides also hide its
+   * message shortcuts.
+   * An explicit value takes priority over CopilotChat's inspectorTools prop.
+   */
+  enableInspector?: boolean;
+  /**
+   * Whether to automatically mount the Intelligence indicator in chat.
+   *
+   * @default true
+   */
+  showIntelligenceIndicator?: boolean;
+  /**
+   * 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$1;
+    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;
+    /**
+     * Optional component catalog to pass to the A2UI renderer.
+     * When omitted, the default basicCatalog is used.
+     */
+    catalog?: any;
+    /**
+     * Optional custom loading component shown while an A2UI surface is generating.
+     * When omitted, a default animated skeleton is shown.
+     */
+    loadingComponent?: React$1.ComponentType;
+    /**
+     * When true (the default), the full component schemas from the catalog are
+     * sent as agent context so the agent knows what components and props are
+     * available. The A2UI middleware can overwrite this with a server-side
+     * schema if configured.
+     *
+     * When false, the agent context still describes the catalog, but only by its
+     * catalog ID and the names of its custom components, without their JSON
+     * schemas. The component schema entry and the A2UI generation and design
+     * guidelines are not sent. With the CopilotKit LangGraph middleware's
+     * injected A2UI tool, the A2UI subagent then gets the component names only;
+     * a host can still give it a composition guide through the middleware's
+     * guidelines (`a2uiParams.guidelines.compositionGuide` in TypeScript,
+     * `a2ui_params["guidelines"]["composition_guide"]` in Python).
+     */
+    includeSchema?: boolean;
+    /**
+     * Options for the A2UI error-recovery status UI (OSS-162): how long before
+     * the transient "Retrying…" hint appears, after how many attempts, and how
+     * much retry/debug detail to surface. When omitted, sane defaults apply.
+     */
+    recovery?: A2UIRecoveryRendererOptions;
+  };
+  /**
+   * Experimental. Native generative UI: `generativeUI={{ ui }}`, where `ui`
+   * comes from `createGenerativeUI`. The agent renders your React components
+   * into chat or into `<GenerativeUISurface id>` mounts. Props that match
+   * the declared state and events that match the declared functions are
+   * bound by the library, and the model does not see them.
+   */
+  generativeUI?: GenerativeUIConfig;
+  /**
+   * Configuration for the built-in MCP Apps renderer.
+   *
+   * @example
+   * ```tsx
+   * <CopilotKit runtimeUrl="/api/copilotkit" mcpApps={{ allowSameOriginFallback: true }}>
+   *   {children}
+   * </CopilotKit>
+   * ```
+   */
+  mcpApps?: {
+    /**
+     * Restore `allow-same-origin` on the MCP App sandbox. Default `false`.
+     *
+     * **Unsafe.** The widget then runs with your page's origin: it can read
+     * your cookies, storage and DOM, and call your APIs as the signed-in user.
+     * Only set it for widgets you wrote and trust that need `localStorage`,
+     * `IndexedDB` or cookies. By default widgets get an opaque origin.
+     */
+    allowSameOriginFallback?: boolean;
+  };
+  /**
+   * Default throttle interval (in milliseconds) for `useAgent` re-renders
+   * triggered by `OnMessagesChanged` notifications. This value is used as
+   * a fallback when neither the `useAgent()` hook nor `<CopilotChat>` /
+   * `<CopilotSidebar>` / `<CopilotPopup>` specify an explicit `throttleMs`.
+   *
+   * @default undefined (components/hooks without an explicit throttleMs will be unthrottled)
+   */
+  defaultThrottleMs?: number;
+  /**
+   * Enable debug logging for the client-side event pipeline.
+   */
+  debug?: DebugConfig;
+  /**
+   * Turns on interaction capture (`@copilotkit/learning`). `learning` (short
+   * for `learning={true}`) records with the default options; pass an object
+   * for options. `false` or omitting the prop turns capture off and cancels
+   * startup. Without a sink, Core authenticates with the runtime and sends
+   * browser events to Intelligence; a custom sink keeps the standalone
+   * collector behavior. Updated settings apply to the next Trajectory.
+   *
+   * Capture starts after mount. Set `trajectoryId` to use your own ID;
+   * otherwise the provider generates one. The generated ID stays the same
+   * across rerenders, reconnects and option changes; turning capture off,
+   * setting `autoStart: false` or supplying a `trajectoryId` ends it, and the
+   * next generated Trajectory gets a new ID. Read the active ID from
+   * `copilotkit.trajectoryId`.
+   *
+   * Set `autoStart: false` to start capture yourself with `startTrajectory()`.
+   * Capture stops on unmount, including manually started Trajectories.
+   *
+   * @example
+   * <CopilotKitProvider runtimeUrl="/api/copilotkit" learning>
+   */
+  learning?: boolean | LearningProp;
+}
+type LearningProp = LearningConfig$1 & {
+  /**
+   * Starts a Trajectory after mount. Defaults to `true`; set `false` to call
+   * `startTrajectory()` yourself.
+   */
+  autoStart?: boolean;
+  trajectoryId?: string;
+  /**
+   * Used only by explicit custom sinks. Authenticated capture warns and ignores
+   * this option; assign Learning Spaces on the server with
+   * `getTrajectoryLearningContainerIds` on `CopilotKitIntelligence`.
+   */
+  learningContainerIds?: string[];
+};
+/** Provide a shared core instance and synchronize runtime, tool, and UI configuration. */
+declare const CopilotKitProvider: React$1.FC<CopilotKitProviderProps>;
+//#endregion
+//#region src/providers/SandboxFunctionsContext.d.ts
+declare const SandboxFunctionsContext: react.Context<readonly SandboxFunction[]>;
+declare function useSandboxFunctions(): readonly SandboxFunction[];
+//#endregion
+//#region src/a2ui/A2UIMessageRenderer.d.ts
+/**
+ * User action with dataContextPath, as dispatched by A2UI components.
+ */
+type A2UIUserAction = {
+  name: string;
+  sourceComponentId: string;
+  surfaceId: string;
+  timestamp: string;
+  context?: Record<string, unknown>;
+  dataContextPath?: string;
+};
+/**
+ * Intercept an A2UI user action before it reaches the agent.
+ *
+ * Called with the dispatched action and a `forward` helper that runs the agent
+ * with the (optionally modified) action. The return value drives the default
+ * forwarding:
+ * - return `null` → the app handled it client-side (e.g. a `navigate` event);
+ *   the action is NOT forwarded to the agent.
+ * - return an `A2UIUserAction` → that (possibly modified) action is forwarded.
+ * - return `undefined` / `void` → the original action is forwarded unchanged.
+ *
+ * `forward` is provided for advanced cases where you want to do async work and
+ * forward manually; if you call it yourself, return `null` to suppress the
+ * default forward and avoid running the agent twice.
+ */
+type A2UIActionInterceptor = (action: A2UIUserAction, forward: (action?: A2UIUserAction) => Promise<void>) => void | A2UIUserAction | null | Promise<void | A2UIUserAction | null>;
+type A2UIMessageRendererOptions = {
+  theme: Theme; /** Optional component catalog to pass to A2UIProvider */
+  catalog?: any; /** Optional custom loading component shown while the A2UI surface is building. */
+  loadingComponent?: React.ComponentType;
+  /**
+   * Pre-paint recovery/loading UX options (OSS-162): timing before the
+   * "Retrying…" sub-label appears + how much retry/debug detail to surface.
+   */
+  recovery?: A2UIRecoveryRendererOptions;
+  /**
+   * Intercept actions before they reach the agent. Lets an app handle an action
+   * client-side (e.g. `navigate`) instead of forwarding every action. See
+   * {@link A2UIActionInterceptor}.
+   */
+  onAction?: A2UIActionInterceptor;
+};
+declare function createA2UIMessageRenderer(options: A2UIMessageRendererOptions): ReactActivityMessageRenderer<any>;
+//#endregion
+export { type A2UIActionInterceptor, type A2UIMarkdownOperation, type A2UIMessageRendererOptions, type A2UIRecoveryRendererOptions, type A2UITheme, type A2UIUserAction, A2UI_FENCE_LANGUAGE, ACTIVITY_HISTORY_METADATA, AGUIConnectNotImplementedError, AGUIError, type AGUIEvent, type AGUIEventByType, type AGUIEventOf, AGUI_METADATA_KEY, AbstractAgent, type ActionConfig, type ActionCreator, type ActionFromCreator, type ActionFromCreators, type ActionGroupConfig, type ActionGroupResult, type ActivityDeltaEvent, type ActivityDeltaEventProps, ActivityDeltaEventSchema, type ActivityMessage, ActivityMessageSchema, type ActivitySnapshotEvent, type ActivitySnapshotEventProps, ActivitySnapshotEventSchema, type AddOperation, AddOperationSchema, type AgentCapabilities, AgentCapabilitiesSchema, type AgentConfig, type AgentContextInput, type AgentDebugConfig, AgentRegistry, type AgentStateMutation, type AgentSubscriber, type AgentSubscriberParams, AgentThreadLockedError, type AnyAction, type AssistantMessage, AssistantMessageSchema, type Attachment, type AttachmentModality, type AttachmentsConfig, type Attributable, AttributableSchema, type AudioInputContent, AudioInputContentSchema, type AudioInputPart, AudioInputPartSchema, type AudioPart, AudioPartSchema, AudioRecorderError, type AudioRecorderState, type AutoScrollMode, BackwardCompatibility_0_0_39, BackwardCompatibility_0_0_45, BackwardCompatibility_0_0_57, type BaseEvent, type BaseEventFields, type BaseEventProps, BaseEventSchema, type BaseMessage, BaseMessageSchema, BasicMarkdownRenderer, type ChildIdsOf, type ChildWalkOptions, CompatibilityBoundary, type ContentPart, ContentPartSchema, type Context, ContextSchema, ContextStore, CopilotChat, CopilotChatAssistantMessage, type CopilotChatAssistantMessageProps, CopilotChatAttachmentQueue, CopilotChatAttachmentRenderer, CopilotChatAudioRecorder, CopilotChatConfigurationProvider, type CopilotChatConfigurationProviderProps, type CopilotChatConfigurationValue, type CopilotChatFeedbackMessage, CopilotChatInput, type CopilotChatInputProps, type CopilotChatLabels, CopilotChatMessageView, type CopilotChatMessageViewProps, type CopilotChatProps, CopilotChatReasoningMessage, type CopilotChatReasoningMessageProps, CopilotChatSuggestionPill, type CopilotChatSuggestionPillProps, CopilotChatSuggestionView, type CopilotChatSuggestionViewProps, CopilotChatToggleButton, DefaultCloseIcon as CopilotChatToggleButtonCloseIcon, DefaultOpenIcon as CopilotChatToggleButtonOpenIcon, type CopilotChatToggleButtonProps, type CopilotChatToolCallDisplay, CopilotChatToolCallGroup, type CopilotChatToolCallGroupAppearance, type CopilotChatToolCallGroupProps, CopilotChatToolCallsView, type CopilotChatToolCallsViewProps, CopilotChatUserMessage, type CopilotChatUserMessageProps, CopilotChatView, type CopilotChatViewProps, CopilotChatWorkSummary, type CopilotChatWorkSummaryProps, type CopilotKitContextValue, CopilotKitCore, type CopilotKitCoreAddAgentParams, type CopilotKitCoreCatalogComponent, type CopilotKitCoreConfig, type CopilotKitCoreConnectAgentParams, type CopilotKitCoreContinuationHandoff, CopilotKitCoreErrorCode, type CopilotKitCoreFriendsAccess, type CopilotKitCoreGetSuggestionsResult, type CopilotKitCoreGetToolParams, CopilotKitCoreReact, type CopilotKitCoreReactConfig, CopilotKitCoreReactSubscriber, type CopilotKitCoreRegisterProxiedAgentParams, type CopilotKitCoreRegisterProxiedAgentResult, type CopilotKitCoreRunAgentParams, type CopilotKitCoreRunToolParams, type CopilotKitCoreRunToolResult, CopilotKitCoreRuntimeConnectionStatus, type CopilotKitCoreStopAgentParams, type CopilotKitCoreSubscriber, type CopilotKitCoreSubscription, CopilotKitHeaderResolutionError, type CopilotKitHeadersSource, CopilotKitInspector, CopilotKitInspectorProps, type CopilotKitMessageFilter, CopilotKitProvider, type CopilotKitProviderProps, CopilotModalHeader, type CopilotModalHeaderProps, CopilotPopup, type CopilotPopupProps, CopilotPopupView, type CopilotPopupViewProps, type CopilotRuntimeTransport, CopilotSidebar, type CopilotSidebarProps, CopilotSidebarView, type CopilotSidebarViewProps, CopilotThreadsDrawer, type CopilotThreadsDrawerProps, type CopilotThreadsDrawerRowRenderer, type CopyOperation, CopyOperationSchema, type CustomEvent, type CustomEventProps, CustomEventSchema, type DataSource, DataSourceSchema, DebugLogger, type DebugLoggerInput, DefaultMarkdownRendererProps, type DeveloperMessage, DeveloperMessageSchema, type DispatchingEffect, type DispatchingEffectOptions, type DocumentInputContent, DocumentInputContentSchema, type DocumentInputPart, DocumentInputPartSchema, type DocumentPart, DocumentPartSchema, type DynamicSuggestionsConfig, type Effect, type EmptyActionConfig, type Event, type EventPayloadOf, EventSchema, EventSchemas, EventType, EventTypeSchema, type ExecutionCapabilities, ExecutionCapabilitiesSchema, type FileSource, FileSourceSchema, FilterToolCallsMiddleware, type FrontendTool, type FrontendToolHandlerContext, type FrontendToolReconnectBehavior, type FunctionCall, FunctionCallSchema, FunctionMiddleware, GenerateSandboxedUiArgs, GenerateSandboxedUiArgsSchema, HttpAgent, type HttpAgentConfig, type HttpAgentFetchFn, type HumanInTheLoopCapabilities, HumanInTheLoopCapabilitiesSchema, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, INTELLIGENCE_TURN_HEAD, INTERRUPT_EVENT_NAME, type IdentityCapabilities, IdentityCapabilitiesSchema, type ImageInputContent, ImageInputContentSchema, type ImageInputPart, ImageInputPartSchema, type ImagePart, ImagePartSchema, type InputContent, type InputContentDataSource, InputContentDataSourceSchema, type InputContentPart, InputContentSchema, type InputContentSource, InputContentSourceSchema, type InputContentUrlSource, InputContentUrlSourceSchema, type InspectorActiveThreadPayload, type InspectorAnchor, type InspectorMetadataV1, type InspectorStopViewingPayload, type InspectorViewThreadPayload, type InspectorViewThreadResultPayload, IntelligenceAgent, type IntelligenceAgentConfig, IntelligenceIndicator, type IntelligenceIndicatorProps, type IntelligenceIndicatorStatus, IntelligenceIndicatorView, type IntelligenceIndicatorViewProps, type IntelligenceRuntimeInfo, type Interrupt, InterruptCancelFn, type InterruptEvent, type InterruptHandlerProps, type InterruptRenderProps, InterruptResolveFn, InterruptSchema, type JsonPatch, type JsonPatchOperation, JsonPatchOperationSchema, JsonPatchSchema, type JsonPointer, JsonPointerSchema, type JsonSerializable, type JsonValue, type LearnFromUserActionInCurrentThreadInput, type LearnFromUserActionInput, type LearnFromUserActionResult, type LearningConfig, type LegacyLearningConfig, type MCPAppsActivityContent, MCPAppsActivityContentSchema, MCPAppsActivityRenderer, MCPAppsActivityType, MEMORY_ERROR_REGISTRY, MarkdownRenderer, MarkdownRendererProps, MarkdownRendererProvider, type MarkdownSegment, type MarkdownToken, type MarkdownTokenList, type Memory, type MemoryChanges, MemoryError, type MemoryErrorCategory, type MemoryErrorCode, type MemoryErrorRegistryEntry, type MemoryKind, type MemoryRealtimeStatus, type MemoryScope, type Message, type MessageGroup, type MessageGroupWrapperProps, type MessageRow, MessageSchema, type MessagesSnapshotEvent, type MessagesSnapshotEventProps, MessagesSnapshotEventSchema, type Metadata, MetadataSchema, Middleware, type MiddlewareFunction, type MoveOperation, MoveOperationSchema, type MultiAgentCapabilities, MultiAgentCapabilitiesSchema, type MultimodalCapabilities, MultimodalCapabilitiesSchema, type MultimodalInputCapabilities, MultimodalInputCapabilitiesSchema, type MultimodalOutputCapabilities, MultimodalOutputCapabilitiesSchema, type NewMemory, type NonDispatchingEffect, type NonDispatchingEffectOptions, OpenGenerativeUIActivityRenderer, OpenGenerativeUIActivityType, OpenGenerativeUIContent, OpenGenerativeUIContentSchema, OpenGenerativeUIToolRenderer, type OpenThreadRegistration, OptionalMetadataSchema, type OutputCapabilities, OutputCapabilitiesSchema, PROTOCOL_VERSION, type ParseMarkdownOptions, type PartSource, PartSourceSchema, type PropsActionConfig, ProxiedCopilotRuntimeAgent, type ProxiedCopilotRuntimeAgentConfig, type RawEvent, type RawEventProps, RawEventSchema, ReactActivityMessageRenderer, ReactCustomMessageRenderer, ReactCustomMessageRendererPosition, ReactFrontendTool, ReactHumanInTheLoop, ReactToolCallRenderer, type ReasoningCapabilities, ReasoningCapabilitiesSchema, type ReasoningEncryptedValueEvent, type ReasoningEncryptedValueEventProps, ReasoningEncryptedValueEventSchema, type ReasoningEncryptedValueSubtype, ReasoningEncryptedValueSubtypeSchema, type ReasoningEndEvent, type ReasoningEndEventProps, ReasoningEndEventSchema, type ReasoningMessage, type ReasoningMessageChunkEvent, type ReasoningMessageChunkEventProps, ReasoningMessageChunkEventSchema, type ReasoningMessageContentEvent, type ReasoningMessageContentEventProps, ReasoningMessageContentEventSchema, type ReasoningMessageEndEvent, type ReasoningMessageEndEventProps, ReasoningMessageEndEventSchema, ReasoningMessageSchema, type ReasoningMessageStartEvent, type ReasoningMessageStartEventProps, ReasoningMessageStartEventSchema, type ReasoningStartEvent, type ReasoningStartEventProps, ReasoningStartEventSchema, type Reducer, type RemoveOperation, RemoveOperationSchema, type ReplaceOperation, ReplaceOperationSchema, type ResolvedAgentDebugConfig, type ResumeEntry, ResumeEntrySchema, type ResumeStatus, type Role, RoleSchema, type RunAgentInput, RunAgentInputSchema, type RunAgentParameters, type RunAgentResult, type RunCompletionAware, type RunErrorEvent, type RunErrorEventProps, RunErrorEventSchema, type RunFinishedCancelledOutcome, RunFinishedCancelledOutcomeSchema, type RunFinishedEvent, type RunFinishedEventProps, RunFinishedEventSchema, type RunFinishedInterruptOutcome, RunFinishedInterruptOutcomeSchema, type RunFinishedOutcome, RunFinishedOutcomeSchema, type RunFinishedSuccessOutcome, RunFinishedSuccessOutcomeSchema, RunHandler, type RunStartedEvent, type RunStartedEventProps, RunStartedEventSchema, type RuntimeLicenseStatus, type RuntimeMode, SandboxFunction, SandboxFunctionsContext, type ScopedContext, type ScopedProperties, type Selector, type StartResult, type State, type StateCapabilities, StateCapabilitiesSchema, type StateDeltaEvent, type StateDeltaEventProps, StateDeltaEventSchema, StateManager, StateSchema, type StateSnapshotEvent, type StateSnapshotEventProps, StateSnapshotEventSchema, type StaticSuggestionsConfig, type StepFinishedEvent, type StepFinishedEventProps, StepFinishedEventSchema, type StepStartedEvent, type StepStartedEventProps, StepStartedEventSchema, type Store, type StoreLifecycleAction, StreamingMarkdownDefaultRenderer, type SubagentErrorEvent, type SubagentErrorEventProps, SubagentErrorEventSchema, type SubagentFinishedEvent, type SubagentFinishedEventProps, SubagentFinishedEventSchema, type SubagentFinishedOutcome, SubagentFinishedOutcomeSchema, type SubagentFinishedSuccessOutcome, SubagentFinishedSuccessOutcomeSchema, type SubagentFinishedSuspendedOutcome, SubagentFinishedSuspendedOutcomeSchema, type SubagentInfo, SubagentInfoSchema, type SubagentRunId, SubagentRunIdSchema, type SubagentStartedEvent, type SubagentStartedEventProps, SubagentStartedEventSchema, type SubscribeToAgentOptions, type SubscribeToAgentSubscriber, type Suggestion, type SuggestionAvailability, SuggestionEngine, type SuggestionsConfig, type SurfaceSegment, type SystemMessage, SystemMessageSchema, type TestOperation, TestOperationSchema, type TextInputContent, TextInputContentSchema, type TextMessageChunkEvent, type TextMessageChunkEventProps, TextMessageChunkEventSchema, type TextMessageContentEvent, type TextMessageContentEventProps, TextMessageContentEventSchema, type TextMessageEndEvent, type TextMessageEndEventProps, TextMessageEndEventSchema, type TextMessageRole, TextMessageRoleSchema, type TextMessageStartEvent, type TextMessageStartEventProps, TextMessageStartEventSchema, type TextPart, TextPartSchema, type Thread, type ThreadEndpointRuntimeInfo, type ThreadRunActivityNotification, type TokenUsage, TokenUsageSchema, type Tokens, type Tool, type ToolCall, type ToolCallArgsEvent, type ToolCallArgsEventProps, ToolCallArgsEventSchema, type ToolCallChunkEvent, type ToolCallChunkEventProps, ToolCallChunkEventSchema, type ToolCallEndEvent, type ToolCallEndEventProps, ToolCallEndEventSchema, type ToolCallEntry, type ToolCallResultEvent, type ToolCallResultEventProps, ToolCallResultEventSchema, ToolCallSchema, type ToolCallStartEvent, type ToolCallStartEventProps, ToolCallStartEventSchema, ToolCallStatus, type ToolMessage, ToolMessageSchema, ToolSchema, type ToolsCapabilities, ToolsCapabilitiesSchema, type ToolsMenuItem, type TrajectoryStartOptions, type TransportCapabilities, TransportCapabilitiesSchema, type UnrecognizedEvent, type UrlSource, UrlSourceSchema, UseAgentUpdate, type UseAttachmentsProps, type UseAttachmentsReturn, type UseInterruptConfig, type UseLearnFromUserActionInCurrentThreadRecorder, type UseLearnFromUserActionRecorder, type UseLearningContainersArgs, type UseLearningContainersInCurrentThreadArgs, type UseMemoriesResult, type UseThreadsInput, type UseThreadsResult, type UserMessage, UserMessageSchema, type VideoInputContent, VideoInputContentSchema, type VideoInputPart, VideoInputPartSchema, type VideoPart, VideoPartSchema, type WebMCPModelContext, WebMCPRegistry, type WebMCPToolAnnotations, type WebMCPToolConfig, WildcardToolCallRender, a2uiDefaultTheme, aggregateTokenUsage, authoritativeActivityTypes, buildResumeArray, classifySurfaceCards, compactEvents, completePartialMarkdown, contentHasMedia, contentToText, convertToLegacyEvents, createA2UIMessageRenderer, createActionGroup, createDebugLogger, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, defaultApplyEvents, defineToolCallRenderer, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, enforceEvents, enforceOutgoingInput, ensureObjectArgs, extractCompleteArrayItems, extractFenceOperations, extractStringField, flattenInformationalCards, getIntelligenceTurnAnchors, getMarkdownOperationSurfaceId, getRunOutcome, getWebMCPModelContext, isAbortError, isInspectorThreadBridgeEnabled, isInterruptExpired, isRecognizedEvent, isRunCompletionAware, mergeMetadata, messageGroup, messageRow, ofType, omitOptionalNulls, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseMarkdown, parseProtoStream, parseSSEStream, parseToolArguments, prepareSurfaceOperations, props, randomUUID, resolveAgentDebugConfig, resolveDebugLogger, runHttpRequest, segmentSurfaceProse, select, splitA2UIMarkdown, structuredClone_, tokenUsageFromAiSdkUsage, tokenUsageFromLangChainMetadata, transformChunks, transformHttpEventStream, useAgent, useAgentContext, useAttachments, useCapabilities, useComponent, useConfigureSuggestions, useCopilotChatConfiguration, useCopilotKit, useDefaultRenderTool, useFrontendTool, useFrontendTools, useHumanInTheLoop, useInterrupt, useLearnFromUserAction, useLearnFromUserActionInCurrentThread, useLearningContainers, useLearningContainersInCurrentThread, useLicenseContext, useMarkdownRenderer, useMemories, useRenderActivityMessage, useRenderCustomMessages, useRenderTool, useRenderToolCall, useSandboxFunctions, useSuggestions, useThreads, verifyEvents, withAuthoritativeActivityTypes, ɵCOPILOTKIT_FEATURES, type ɵCopilotKitFeature, type ɵGenerativeUIDebugFunction, type ɵGenerativeUIDebugPromptSection, type ɵGenerativeUIDebugRun, type ɵGenerativeUIDebugSnapshot, type ɵGenerativeUIDebugSource, type ɵGenerativeUIDebugSurface, type ɵInterruptDecision, type ɵInterruptEvent, ɵInterruptState, type ɵInterruptToolResult, ɵMAX_SOCKET_RETRIES, type ɵMcpFollowUpHost, type ɵMemoryEnvironment, type ɵMemoryMetadataEvent, type ɵMemoryRuntimeContext, type ɵMemoryState, type ɵMemoryStore, type ɵPendingInterrupt, type ɵPhoenixChannelLike, type ɵPhoenixChannelOptions, type ɵPhoenixChannelSession, type ɵPhoenixJoinOutcome, type ɵPhoenixPushLike, type ɵPhoenixSocketLike, type ɵPhoenixSocketOptions, type ɵPhoenixSocketSession, type ɵPhoenixSocketSignal, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, type ɵThread, type ɵThreadEnvironment, type ɵThreadMetadataEvent, type ɵThreadRuntimeContext, type ɵThreadSelectors, type ɵThreadStore, ɵclearAgentInterruptState, ɵcreateMemoryStore, ɵcreateThreadSelectors, ɵcreateThreadStore, ɵgetAgentInterruptState, ɵisCopilotKitFeature, ɵisHttpAgent, ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵrunMcpFollowUp, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents, ɵwithHeaderDefaults };
+//# sourceMappingURL=index.d.cts.map