@copilotkit/react-core 1.61.1 → 1.62.0

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

@@ -1,7 +1,7 @@
 import * as react from "react";
 import React$1, { ComponentType, ReactNode } from "react";
 import { CopilotKitCore, CopilotKitCoreConfig, CopilotKitCoreErrorCode, CopilotKitCoreSubscriber, CopilotKitCoreSubscription, DynamicSuggestionsConfig, FrontendTool, StaticSuggestionsConfig, Suggestion, ToolCallStatus } from "@copilotkit/core";
-import { AbstractAgent, RunAgentResult } from "@ag-ui/client";
+import { AbstractAgent, Interrupt, ResumeEntry, RunAgentResult } from "@ag-ui/client";
 import { Action, Attachment, Attachment as Attachment$1, AttachmentModality, AttachmentsConfig, AttachmentsConfig as AttachmentsConfig$1, CopilotCloudConfig, CopilotErrorHandler, CopilotKitError, DebugConfig, FunctionCallHandler, InferSchemaOutput, InputContentSource, MappedParameterTypes, Parameter, StandardSchemaV1 } from "@copilotkit/shared";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { Streamdown } from "streamdown";
@@ -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;
@@ -1130,7 +1197,7 @@ type CopilotChatViewProps = WithSlots<{
    * className string, a props object, or a replacement component.
    */
   intelligenceIndicator?: SlotValue<typeof IntelligenceIndicatorView>;
-} & React$1.HTMLAttributes<HTMLDivElement>>;
+} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "inputMode">>;
 declare function CopilotChatView({
   messageView,
   input,
@@ -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[];
@@ -1499,7 +1903,11 @@ declare function useRenderCustomMessages(): ((params: UseRenderCustomMessagesPar
 //#region src/v2/types/react-tool-call-renderer.d.ts
 interface ReactToolCallRenderer<T = unknown> {
   name: string;
-  args: StandardSchemaV1<any, T>;
+  /**
+   * 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.
@@ -1644,18 +2052,49 @@ declare function defineToolCallRenderer<S extends StandardSchemaV1>(def: {
 }): ReactToolCallRenderer<InferSchemaOutput<S>>;
 //#endregion
 //#region src/v2/types/interrupt.d.ts
+/** 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 | 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 | 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>;
-  resolve: (response: unknown) => Promise<RunAgentResult>;
+  /** 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: (response: unknown) => Promise<RunAgentResult>;
+  resolve: InterruptResolveFn;
+  cancel: InterruptCancelFn;
 }
 //#endregion
 //#region src/v2/types/sandbox-function.d.ts
@@ -1727,7 +2166,7 @@ type InferRenderProps<T> = T extends StandardSchemaV1 ? InferSchemaOutput<T> : a
  * );
  * ```
  */
-declare function useComponent<TSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+declare function useComponent<TSchema extends StandardSchemaV1<any, Record<string, unknown>> | undefined = undefined>(config: {
   name: string;
   description?: string;
   parameters?: TSchema;
@@ -1982,230 +2421,57 @@ interface UseInterruptConfigBase<TValue = unknown, TResult = never> {
   /**
    * Render function for the interrupt UI.
    *
-   * This is called once an interrupt is finalized and accepted by `enabled` (if provided).
-   * Use `resolve` from render props to resume the agent run with user input.
+   * 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 either a sync value or an async value to pass into `render` as `result`.
+   * 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 should be handled by this hook.
-   * Return `false` to ignore an interrupt.
+   * 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. Set to false to render it yourself. */renderInChat?: TRenderInChat;
+  /** When true (default), the interrupt UI renders inside `<CopilotChat>` automatically. */renderInChat?: TRenderInChat;
 };
 /**
- * Handles agent interrupts (`on_interrupt`) with optional filtering, preprocessing, and resume behavior.
- *
- * The hook listens to custom events on the active agent, stores interrupt payloads per run,
- * and surfaces a render callback once the run finalizes. Call `resolve` from your UI to resume
- * execution with user-provided data.
- *
- * - `renderInChat: true` (default): the element is published into `<CopilotChat>` and this hook returns `void`.
- * - `renderInChat: false`: the hook returns the interrupt element so you can place it anywhere in your component tree.
- *
- * `event.value` is typed as `any` since the interrupt payload shape depends on your agent.
- * Type-narrow it in your callbacks (e.g. `handler`, `enabled`, `render`) as needed.
- *
- * @typeParam TResult - Inferred from `handler` return type. Exposed as `result` in `render`.
- * @param config - Interrupt configuration (renderer, optional handler/filter, and render mode).
- * @returns When `renderInChat` is `false`, returns the interrupt element (or `null` when idle).
- * Otherwise returns `void` and publishes the element into chat. In `render`, `result` is always
- * either the handler's resolved return value or `null` (including when no handler is provided,
- * when filtering skips the interrupt, or when handler execution fails).
+ * Handles agent interrupts with optional filtering, preprocessing, and resume behavior.
  *
- * @example
- * ```tsx
- * import { useInterrupt } from "@copilotkit/react-core/v2";
- *
- * function InterruptUI() {
- *   useInterrupt({
- *     render: ({ event, resolve }) => (
- *       <div>
- *         <p>{event.value.question}</p>
- *         <button onClick={() => resolve({ approved: true })}>Approve</button>
- *         <button onClick={() => resolve({ approved: false })}>Reject</button>
- *       </div>
- *     ),
- *   });
+ * 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`.
  *
- *   return null;
- * }
- * ```
+ * - `renderInChat: true` (default): the element is published into `<CopilotChat>`; returns `void`.
+ * - `renderInChat: false`: the hook returns the interrupt element for manual placement.
  *
  * @example
  * ```tsx
- * import { useInterrupt } from "@copilotkit/react-core/v2";
- *
- * function CustomPanel() {
- *   const interruptElement = useInterrupt({
- *     renderInChat: false,
- *     enabled: (event) => event.value.startsWith("approval:"),
- *     handler: async ({ event }) => ({ label: event.value.toUpperCase() }),
- *     render: ({ event, result, resolve }) => (
- *       <aside>
- *         <strong>{result?.label ?? ""}</strong>
- *         <button onClick={() => resolve({ value: event.value })}>Continue</button>
- *       </aside>
- *     ),
- *   });
- *
- *   return <>{interruptElement}</>;
- * }
+ * 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/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>;
-  /**
-   * Permanently delete a thread from the platform.
-   * This is irreversible. Resolves when the server confirms deletion;
-   * rejects on failure.
-   */
-  deleteThread: (threadId: string) => Promise<void>;
-}
-/**
- * React hook for listing and managing Intelligence platform threads.
- *
- * On mount the hook fetches the thread list for the runtime-authenticated user
- * and the given `agentId`. When the Intelligence platform exposes a WebSocket
- * URL, it also opens a realtime subscription so the `threads` array stays
- * current without polling — thread creates, renames, archives, and deletes
- * from any client are reflected immediately.
- *
- * Mutation methods (`renameThread`, `archiveThread`, `deleteThread`) return
- * promises that resolve once the platform confirms the operation and reject
- * with an `Error` on failure.
- *
- * @param input - Agent identifier and optional list controls.
- * @returns Thread list state and stable mutation callbacks.
- *
- * @example
- * ```tsx
- * import { useThreads } from "@copilotkit/react-core";
- *
- * function ThreadList() {
- *   const { threads, isLoading, renameThread, deleteThread } = useThreads({
- *     agentId: "agent-1",
- *   });
- *
- *   if (isLoading) return <p>Loading…</p>;
- *
- *   return (
- *     <ul>
- *       {threads.map((t) => (
- *         <li key={t.id}>
- *           {t.name ?? "Untitled"}
- *           <button onClick={() => renameThread(t.id, "New name")}>Rename</button>
- *           <button onClick={() => deleteThread(t.id)}>Delete</button>
- *         </li>
- *       ))}
- *     </ul>
- *   );
- * }
- * ```
- */
-declare function useThreads({
-  agentId,
-  includeArchived,
-  limit
-}: UseThreadsInput): UseThreadsResult;
-//#endregion
 //#region src/v2/hooks/use-learn-from-user-action.d.ts
 /**
  * Input to {@link UseLearnFromUserActionRecorder}, the function returned
@@ -2703,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. */
@@ -2712,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
@@ -2725,7 +3013,7 @@ declare function createA2UIMessageRenderer(options: A2UIMessageRendererOptions):
  *
  * TODO: Remove this `Omit` once this is resolved.
  */
-interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children"> {
+interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children" | "onError"> {
   /** Your CopilotKit public license key. */
   publicApiKey?: string;
   /** Your public license key for accessing Enterprise Intelligence Platform features. */
@@ -2889,5 +3177,5 @@ declare function CopilotKit({
 }: CopilotKitProps): react_jsx_runtime0.JSX.Element;
 declare const defaultCopilotContextCategories: string[];
 //#endregion
-export { InterruptEvent as $, CopilotChatSuggestionPill as $t, UseLearnFromUserActionRecorder as A, LangGraphInterruptRenderHandlerProps as An, CopilotSidebarViewProps as At, AgentContextInput as B, SystemMessageFunction as Bn, CopilotChatViewProps as Bt, UseAttachmentsReturn as C, CopilotContextParams as Cn, CopilotPopup as Ct, useLearnFromUserActionInCurrentThread as D, LangGraphInterruptActionSetter as Dn, CopilotPopupView as Dt, UseLearnFromUserActionInCurrentThreadRecorder as E, LangGraphInterruptAction as En, CopilotSidebarProps as Et, useThreads as F, CrewsResponseStatus as Fn, DefaultCloseIcon as Ft, useAgent as G, ActionRenderPropsNoArgs as Gn, IntelligenceIndicator as Gt, useAgentContext as H, Tree as Hn, CopilotChatMessageView as Ht, UseInterruptConfig as I, CrewsStateItem as In, DefaultOpenIcon as It, useRenderTool as J, CatchAllActionRenderProps as Jn, IntelligenceIndicatorStatus as Jt, useHumanInTheLoop as K, ActionRenderPropsNoArgsWait as Kn, IntelligenceIndicatorProps as Kt, useInterrupt as L, CrewsTaskStateItem as Ln, CopilotChat as Lt, Thread as M, QueuedInterruptEvent as Mn, CopilotModalHeaderProps as Mt, UseThreadsInput as N, CrewsAgentState as Nn, CopilotChatToggleButton as Nt, LearnFromUserActionInput as O, LangGraphInterruptActionSetterArgs as On, CopilotPopupViewProps as Ot, UseThreadsResult as P, CrewsResponse as Pn, CopilotChatToggleButtonProps as Pt, SandboxFunction as Q, RenderFunctionStatus as Qn, CopilotChatSuggestionViewProps as Qt, useConfigureSuggestions as R, CrewsToolStateItem as Rn, CopilotChatProps as Rt, UseAttachmentsProps as S, CopilotContext as Sn, CopilotChatAttachmentQueue as St, LearnFromUserActionInCurrentThreadInput as T, CoAgentStateRender as Tn, CopilotSidebar as Tt, useCapabilities as U, TreeNode as Un, CopilotChatMessageViewProps as Ut, JsonSerializable as V, DocumentPointer as Vn, AutoScrollMode as Vt, UseAgentUpdate as W, ActionRenderProps as Wn, INTELLIGENCE_TURN_HEAD as Wt, useFrontendTool as X, FrontendAction as Xn, IntelligenceIndicatorViewProps as Xt, useComponent as Y, CatchAllFrontendAction as Yn, IntelligenceIndicatorView as Yt, useRenderActivityMessage as Z, FrontendActionAvailability as Zn, CopilotChatSuggestionView as Zt, CopilotKitCoreReactSubscriber as _, AudioRecorderError as _n, WildcardToolCallRender as _t, A2UIUserAction as a, CopilotChatAssistantMessage as an, ReactActivityMessageRenderer as at, UseLearningContainersArgs as b, CoagentInChatRenderFunction as bn, AttachmentsConfig$1 as bt, SandboxFunctionsContext as c, CopilotChatToolCallsViewProps as cn, ReactCustomMessageRenderer as ct, CopilotKitProviderProps as d, ToolsMenuItem as dn, MCPAppsActivityContent as dt, CopilotChatSuggestionPillProps as en, InterruptHandlerProps as et, A2UIRecoveryRendererOptions as f, CopilotChatConfigurationProvider as fn, MCPAppsActivityContentSchema as ft, CopilotKitCoreReactConfig as g, useCopilotChatConfiguration as gn, CopilotKitInspectorProps as gt, CopilotKitCoreReact as h, CopilotChatLabels as hn, CopilotKitInspector as ht, A2UIMessageRendererOptions as i, CopilotChatUserMessageProps as in, ReactFrontendTool as it, useLearnFromUserAction as j, LangGraphInterruptRenderProps as jn, CopilotModalHeader as jt, LearnFromUserActionResult as k, LangGraphInterruptRender as kn, CopilotSidebarView as kt, useSandboxFunctions as l, CopilotChatInput as ln, ReactCustomMessageRendererPosition as lt, useCopilotKit as m, CopilotChatConfigurationValue as mn, MCPAppsActivityType as mt, defaultCopilotContextCategories as n, CopilotChatReasoningMessageProps as nn, defineToolCallRenderer as nt, createA2UIMessageRenderer as o, CopilotChatAssistantMessageProps as on, ReactToolCallRenderer as ot, CopilotKitContextValue as p, CopilotChatConfigurationProviderProps as pn, MCPAppsActivityRenderer as pt, useDefaultRenderTool as q, ActionRenderPropsWait as qn, getIntelligenceTurnAnchors as qt, CopilotKitProps as r, CopilotChatUserMessage as rn, ReactHumanInTheLoop as rt, InspectorAnchor as s, CopilotChatToolCallsView as sn, useRenderCustomMessages as st, CopilotKit as t, CopilotChatReasoningMessage as tn, InterruptRenderProps as tt, CopilotKitProvider as u, CopilotChatInputProps as un, useRenderToolCall as ut, UseLearningContainersInCurrentThreadArgs as v, AudioRecorderState as vn, Attachment$1 as vt, useAttachments as w, useCopilotContext as wn, CopilotPopupProps as wt, useLearningContainers as x, CopilotApiConfig as xn, CopilotChatAttachmentRenderer as xt, useLearningContainersInCurrentThread as y, CopilotChatAudioRecorder as yn, AttachmentModality as yt, useSuggestions as z, CopilotChatSuggestionConfiguration as zn, CopilotChatView as zt };
-//# sourceMappingURL=copilotkit-M1FiciGd.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