@copilotkit/react-core 1.61.2 → 1.62.1

package/dist/{copilotkit-Bpt1c_-q.d.mts → copilotkit-DnLpJ2Cl.d.mts}

@@ -543,7 +543,74 @@ interface CopilotChatConfigurationValue {
   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;
@@ -1242,15 +1309,31 @@ declare const CopilotChatToggleButton: React$1.ForwardRefExoticComponent<Copilot
 type HeaderSlots = {
   titleContent: typeof CopilotModalHeader.Title;
   closeButton: typeof CopilotModalHeader.CloseButton;
+  drawerLauncher: typeof CopilotModalHeader.DrawerLauncher;
 };
 type HeaderRestProps = {
   title?: string;
 } & Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">;
-type CopilotModalHeaderProps = WithSlots<HeaderSlots, HeaderRestProps>;
+/**
+ * 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
@@ -1261,6 +1344,13 @@ declare namespace CopilotModalHeader {
 declare namespace CopilotModalHeader {
   const Title: React$1.FC<React$1.HTMLAttributes<HTMLDivElement>>;
   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/v2/components/chat/CopilotSidebarView.d.ts
@@ -1366,6 +1456,320 @@ declare namespace CopilotPopup {
   var displayName: string;
 }
 //#endregion
+//#region src/v2/hooks/use-threads.d.ts
+/**
+ * A conversation thread managed by the Intelligence platform.
+ *
+ * Each thread has a unique `id`, an optional human-readable `name`, and
+ * timestamp fields tracking creation and update times.
+ */
+interface Thread {
+  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 the Intelligence platform.
+ */
+interface UseThreadsInput {
+  /** The ID of the agent whose threads to list and manage. */
+  agentId: string;
+  /** When `true`, archived threads are included in the list. Defaults to `false`. */
+  includeArchived?: boolean;
+  /** Maximum number of threads to fetch per page. When set, enables cursor-based pagination. */
+  limit?: number;
+  /**
+   * 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;
+  /**
+   * `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 Intelligence platform threads.
+ *
+ * On mount the hook fetches the thread list for the runtime-authenticated user
+ * and the given `agentId`. When the Intelligence platform exposes a WebSocket
+ * URL, it also opens a realtime subscription so the `threads` array stays
+ * current without polling — thread creates, renames, archives, and deletes
+ * from any client are reflected immediately.
+ *
+ * Mutation methods (`renameThread`, `archiveThread`, `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/v2/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;
+  /**
+   * 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 nine 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`.
+ *
+ * License gating is two-pronged: the locked view shows when no license is configured
+ * (the runtime reported no license status) OR the `threads` feature is
+ * explicitly unlicensed. While unlicensed, the thread fetch is skipped entirely
+ * so an unlicensed 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" publicLicenseKey="ck_pub_...">
+ *   <CopilotChat />
+ *   <CopilotThreadsDrawer />
+ * </CopilotKitProvider>
+ * ```
+ */
+declare function CopilotThreadsDrawer({
+  agentId,
+  onThreadSelect,
+  onNewThread,
+  onLicensed,
+  licenseUrl,
+  renderRow,
+  label,
+  limit,
+  "data-testid": dataTestId
+}: CopilotThreadsDrawerProps): React$1.ReactElement | null;
+declare namespace CopilotThreadsDrawer {
+  var displayName: string;
+}
+//#endregion
 //#region src/v2/components/chat/CopilotChatAttachmentQueue.d.ts
 interface CopilotChatAttachmentQueueProps {
   attachments: Attachment[];
@@ -2068,152 +2472,6 @@ type UseInterruptConfig<TValue = unknown, TResult = never, TRenderInChat extends
  */
 declare function useInterrupt<TResult = never, TRenderInChat extends InterruptRenderInChat = undefined>(config: UseInterruptConfig<any, TResult, TRenderInChat>): UseInterruptReturn<TRenderInChat>;
 //#endregion
-//#region src/v2/hooks/use-threads.d.ts
-/**
- * A conversation thread managed by the Intelligence platform.
- *
- * Each thread has a unique `id`, an optional human-readable `name`, and
- * timestamp fields tracking creation and update times.
- */
-interface Thread {
-  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 the Intelligence platform.
- */
-interface UseThreadsInput {
-  /** The ID of the agent whose threads to list and manage. */
-  agentId: string;
-  /** When `true`, archived threads are included in the list. Defaults to `false`. */
-  includeArchived?: boolean;
-  /** Maximum number of threads to fetch per page. When set, enables cursor-based pagination. */
-  limit?: number;
-}
-/**
- * Return value of the {@link useThreads} hook.
- *
- * The `threads` array is kept in sync with the platform via a realtime
- * WebSocket subscription (when available) and is sorted most-recently-updated
- * first. Mutations reject with an `Error` if the platform request fails.
- */
-interface UseThreadsResult {
-  /**
-   * Threads for the current user/agent pair, sorted by most recently
-   * updated first. Updated in realtime when the platform pushes metadata
-   * events. Includes archived threads only when `includeArchived` is set.
-   */
-  threads: Thread[];
-  /**
-   * `true` while the initial thread list is being fetched from the platform.
-   * Subsequent realtime updates do not re-enter the loading state.
-   */
-  isLoading: boolean;
-  /**
-   * The most recent error from fetching threads or executing a mutation,
-   * or `null` when there is no error. Reset to `null` on the next
-   * successful fetch.
-   */
-  error: Error | null;
-  /**
-   * `true` when there are more threads available to fetch via
-   * {@link fetchMoreThreads}. Only meaningful when `limit` is set.
-   */
-  hasMoreThreads: boolean;
-  /**
-   * `true` while a subsequent page of threads is being fetched.
-   */
-  isFetchingMoreThreads: boolean;
-  /**
-   * Fetch the next page of threads. No-op when {@link hasMoreThreads} is
-   * `false` or a fetch is already in progress.
-   */
-  fetchMoreThreads: () => 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 Intelligence platform threads.
- *
- * On mount the hook fetches the thread list for the runtime-authenticated user
- * and the given `agentId`. When the Intelligence platform exposes a WebSocket
- * URL, it also opens a realtime subscription so the `threads` array stays
- * current without polling — thread creates, renames, archives, and deletes
- * from any client are reflected immediately.
- *
- * Mutation methods (`renameThread`, `archiveThread`, `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
-}: UseThreadsInput): UseThreadsResult;
-//#endregion
 //#region src/v2/hooks/use-learn-from-user-action.d.ts
 /**
  * Input to {@link UseLearnFromUserActionRecorder}, the function returned
@@ -2711,6 +2969,22 @@ type A2UIUserAction = {
   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. */
@@ -2720,6 +2994,12 @@ type A2UIMessageRendererOptions = {
    * "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
@@ -2897,5 +3177,5 @@ declare function CopilotKit({
 }: CopilotKitProps): react_jsx_runtime0.JSX.Element;
 declare const defaultCopilotContextCategories: string[];
 //#endregion
-export { Interrupt as $, CatchAllFrontendAction as $n, IntelligenceIndicatorView as $t, UseLearnFromUserActionRecorder as A, LangGraphInterruptAction as An, CopilotSidebarProps as At, AgentContextInput as B, CrewsStateItem as Bn, DefaultOpenIcon as Bt, UseAttachmentsReturn as C, CopilotChatAudioRecorder as Cn, AttachmentModality as Ct, useLearnFromUserActionInCurrentThread as D, CopilotContextParams as Dn, CopilotPopup as Dt, UseLearnFromUserActionInCurrentThreadRecorder as E, CopilotContext as En, CopilotChatAttachmentQueue as Et, useThreads as F, LangGraphInterruptRenderProps as Fn, CopilotModalHeader as Ft, useAgent as G, DocumentPointer as Gn, AutoScrollMode as Gt, useAgentContext as H, CrewsToolStateItem as Hn, CopilotChatProps as Ht, UseInterruptConfig as I, QueuedInterruptEvent as In, CopilotModalHeaderProps as It, useRenderTool as J, ActionRenderProps as Jn, INTELLIGENCE_TURN_HEAD as Jt, useHumanInTheLoop as K, Tree as Kn, CopilotChatMessageView as Kt, useInterrupt as L, CrewsAgentState as Ln, CopilotChatToggleButton as Lt, Thread as M, LangGraphInterruptActionSetterArgs as Mn, CopilotPopupViewProps as Mt, UseThreadsInput as N, LangGraphInterruptRender as Nn, CopilotSidebarView as Nt, LearnFromUserActionInput as O, useCopilotContext as On, CopilotPopupProps as Ot, UseThreadsResult as P, LangGraphInterruptRenderHandlerProps as Pn, CopilotSidebarViewProps as Pt, SandboxFunction as Q, CatchAllActionRenderProps as Qn, IntelligenceIndicatorStatus as Qt, useConfigureSuggestions as R, CrewsResponse as Rn, CopilotChatToggleButtonProps as Rt, UseAttachmentsProps as S, AudioRecorderState as Sn, Attachment$1 as St, LearnFromUserActionInCurrentThreadInput as T, CopilotApiConfig as Tn, CopilotChatAttachmentRenderer as Tt, useCapabilities as U, CopilotChatSuggestionConfiguration as Un, CopilotChatView as Ut, JsonSerializable as V, CrewsTaskStateItem as Vn, CopilotChat as Vt, UseAgentUpdate as W, SystemMessageFunction as Wn, CopilotChatViewProps as Wt, useFrontendTool as X, ActionRenderPropsNoArgsWait as Xn, IntelligenceIndicatorProps as Xt, useComponent as Y, ActionRenderPropsNoArgs as Yn, IntelligenceIndicator as Yt, useRenderActivityMessage as Z, ActionRenderPropsWait as Zn, getIntelligenceTurnAnchors as Zt, CopilotKitCoreReactSubscriber as _, CopilotChatConfigurationProviderProps as _n, MCPAppsActivityRenderer as _t, A2UIUserAction as a, CopilotChatReasoningMessage as an, ResumeEntry as at, UseLearningContainersArgs as b, useCopilotChatConfiguration as bn, CopilotKitInspectorProps as bt, SandboxFunctionsContext as c, CopilotChatUserMessageProps as cn, ReactFrontendTool as ct, CopilotKitProviderProps as d, CopilotChatToolCallsView as dn, useRenderCustomMessages as dt, IntelligenceIndicatorViewProps as en, FrontendAction as er, InterruptCancelFn as et, A2UIRecoveryRendererOptions as f, CopilotChatToolCallsViewProps as fn, ReactCustomMessageRenderer as ft, CopilotKitCoreReactConfig as g, CopilotChatConfigurationProvider as gn, MCPAppsActivityContentSchema as gt, CopilotKitCoreReact as h, ToolsMenuItem as hn, MCPAppsActivityContent as ht, A2UIMessageRendererOptions as i, CopilotChatSuggestionPillProps as in, InterruptResolveFn as it, useLearnFromUserAction as j, LangGraphInterruptActionSetter as jn, CopilotPopupView as jt, LearnFromUserActionResult as k, CoAgentStateRender as kn, CopilotSidebar as kt, useSandboxFunctions as l, CopilotChatAssistantMessage as ln, ReactActivityMessageRenderer as lt, useCopilotKit as m, CopilotChatInputProps as mn, useRenderToolCall as mt, defaultCopilotContextCategories as n, CopilotChatSuggestionViewProps as nn, RenderFunctionStatus as nr, InterruptHandlerProps as nt, createA2UIMessageRenderer as o, CopilotChatReasoningMessageProps as on, defineToolCallRenderer as ot, CopilotKitContextValue as p, CopilotChatInput as pn, ReactCustomMessageRendererPosition as pt, useDefaultRenderTool as q, TreeNode as qn, CopilotChatMessageViewProps as qt, CopilotKitProps as r, CopilotChatSuggestionPill as rn, InterruptRenderProps as rt, InspectorAnchor as s, CopilotChatUserMessage as sn, ReactHumanInTheLoop as st, CopilotKit as t, CopilotChatSuggestionView as tn, FrontendActionAvailability as tr, InterruptEvent as tt, CopilotKitProvider as u, CopilotChatAssistantMessageProps as un, ReactToolCallRenderer as ut, UseLearningContainersInCurrentThreadArgs as v, CopilotChatConfigurationValue as vn, MCPAppsActivityType as vt, useAttachments as w, CoagentInChatRenderFunction as wn, AttachmentsConfig$1 as wt, useLearningContainers as x, AudioRecorderError as xn, WildcardToolCallRender as xt, useLearningContainersInCurrentThread as y, CopilotChatLabels as yn, CopilotKitInspector as yt, useSuggestions as z, CrewsResponseStatus as zn, DefaultCloseIcon as zt };
-//# sourceMappingURL=copilotkit-Bpt1c_-q.d.mts.map
+export { InterruptHandlerProps as $, ActionRenderPropsNoArgs as $n, IntelligenceIndicator as $t, LearnFromUserActionResult as A, CopilotContext as An, useThreads as At, useCapabilities as B, QueuedInterruptEvent as Bn, CopilotModalHeaderProps as Bt, UseAttachmentsProps as C, CopilotChatLabels as Cn, CopilotChatAttachmentQueue as Ct, UseLearnFromUserActionInCurrentThreadRecorder as D, CopilotChatAudioRecorder as Dn, Thread as Dt, LearnFromUserActionInCurrentThreadInput as E, AudioRecorderState as En, CopilotThreadsDrawerRowRenderer as Et, useConfigureSuggestions as F, LangGraphInterruptActionSetter as Fn, CopilotPopupView as Ft, useRenderTool as G, CrewsTaskStateItem as Gn, CopilotChat as Gt, useAgent as H, CrewsResponse as Hn, CopilotChatToggleButtonProps as Ht, useSuggestions as I, LangGraphInterruptActionSetterArgs as In, CopilotPopupViewProps as It, useRenderActivityMessage as J, SystemMessageFunction as Jn, CopilotChatViewProps as Jt, useComponent as K, CrewsToolStateItem as Kn, CopilotChatProps as Kt, AgentContextInput as L, LangGraphInterruptRender as Ln, CopilotSidebarView as Lt, useLearnFromUserAction as M, useCopilotContext as Mn, CopilotPopupProps as Mt, UseInterruptConfig as N, CoAgentStateRender as Nn, CopilotSidebar as Nt, useLearnFromUserActionInCurrentThread as O, CoagentInChatRenderFunction as On, UseThreadsInput as Ot, useInterrupt as P, LangGraphInterruptAction as Pn, CopilotSidebarProps as Pt, InterruptEvent as Q, ActionRenderProps as Qn, INTELLIGENCE_TURN_HEAD as Qt, JsonSerializable as R, LangGraphInterruptRenderHandlerProps as Rn, CopilotSidebarViewProps as Rt, useLearningContainers as S, CopilotChatConfigurationValue as Sn, CopilotChatAttachmentRenderer as St, useAttachments as T, AudioRecorderError as Tn, CopilotThreadsDrawerProps as Tt, useHumanInTheLoop as U, CrewsResponseStatus as Un, DefaultCloseIcon as Ut, UseAgentUpdate as V, CrewsAgentState as Vn, CopilotChatToggleButton as Vt, useDefaultRenderTool as W, CrewsStateItem as Wn, DefaultOpenIcon as Wt, Interrupt as X, Tree as Xn, CopilotChatMessageView as Xt, SandboxFunction as Y, DocumentPointer as Yn, AutoScrollMode as Yt, InterruptCancelFn as Z, TreeNode as Zn, CopilotChatMessageViewProps as Zt, CopilotKitCoreReactConfig as _, CopilotChatInput as _n, CopilotKitInspectorProps as _t, A2UIMessageRendererOptions as a, CopilotChatSuggestionView as an, FrontendActionAvailability as ar, ReactFrontendTool as at, useLearningContainersInCurrentThread as b, CopilotChatConfigurationProvider as bn, AttachmentModality as bt, InspectorAnchor as c, CopilotChatSuggestionPillProps as cn, useRenderCustomMessages as ct, CopilotKitProvider as d, CopilotChatUserMessage as dn, useRenderToolCall as dt, IntelligenceIndicatorProps as en, ActionRenderPropsNoArgsWait as er, InterruptRenderProps as et, CopilotKitProviderProps as f, CopilotChatUserMessageProps as fn, MCPAppsActivityContent as ft, CopilotKitCoreReact as g, CopilotChatToolCallsViewProps as gn, CopilotKitInspector as gt, useCopilotKit as h, CopilotChatToolCallsView as hn, MCPAppsActivityType as ht, A2UIActionInterceptor as i, IntelligenceIndicatorViewProps as in, FrontendAction as ir, ReactHumanInTheLoop as it, UseLearnFromUserActionRecorder as j, CopilotContextParams as jn, CopilotPopup as jt, LearnFromUserActionInput as k, CopilotApiConfig as kn, UseThreadsResult as kt, SandboxFunctionsContext as l, CopilotChatReasoningMessage as ln, ReactCustomMessageRenderer as lt, CopilotKitContextValue as m, CopilotChatAssistantMessageProps as mn, MCPAppsActivityRenderer as mt, defaultCopilotContextCategories as n, IntelligenceIndicatorStatus as nn, CatchAllActionRenderProps as nr, ResumeEntry as nt, A2UIUserAction as o, CopilotChatSuggestionViewProps as on, RenderFunctionStatus as or, ReactActivityMessageRenderer as ot, A2UIRecoveryRendererOptions as p, CopilotChatAssistantMessage as pn, MCPAppsActivityContentSchema as pt, useFrontendTool as q, CopilotChatSuggestionConfiguration as qn, CopilotChatView as qt, CopilotKitProps as r, IntelligenceIndicatorView as rn, CatchAllFrontendAction as rr, defineToolCallRenderer as rt, createA2UIMessageRenderer as s, CopilotChatSuggestionPill as sn, ReactToolCallRenderer as st, CopilotKit as t, getIntelligenceTurnAnchors as tn, ActionRenderPropsWait as tr, InterruptResolveFn as tt, useSandboxFunctions as u, CopilotChatReasoningMessageProps as un, ReactCustomMessageRendererPosition as ut, CopilotKitCoreReactSubscriber as v, CopilotChatInputProps as vn, WildcardToolCallRender as vt, UseAttachmentsReturn as w, useCopilotChatConfiguration as wn, CopilotThreadsDrawer as wt, UseLearningContainersArgs as x, CopilotChatConfigurationProviderProps as xn, AttachmentsConfig$1 as xt, UseLearningContainersInCurrentThreadArgs as y, ToolsMenuItem as yn, Attachment$1 as yt, useAgentContext as z, LangGraphInterruptRenderProps as zn, CopilotModalHeader as zt };
+//# sourceMappingURL=copilotkit-DnLpJ2Cl.d.mts.map