@copilotkit/react-core 1.59.3 → 1.59.5-canary.1781104893

package/dist/{copilotkit-D16eCFkt.d.cts → copilotkit-CD3EqiJ4.d.cts}

@@ -881,12 +881,158 @@ declare const CopilotChatSuggestionView: React$1.ForwardRefExoticComponent<{
   loadingIndexes?: ReadonlyArray<number>;
 } & React$1.HTMLAttributes<HTMLDivElement>, "children"> & React$1.RefAttributes<HTMLDivElement>>;
 //#endregion
+//#region src/v2/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$2;
+  /**
+   * 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/v2/components/intelligence-indicator/IntelligenceIndicator.d.ts
+interface IntelligenceIndicatorProps {
+  /** The message this indicator is attached to. */
+  message: Message$2;
+  /**
+   * 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.
+ */
+declare function getIntelligenceTurnAnchors(messages: readonly Message$2[]): 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/v2/components/chat/CopilotChatMessageView.d.ts
 type CopilotChatMessageViewProps = Omit<WithSlots<{
   assistantMessage: typeof CopilotChatAssistantMessage;
   userMessage: typeof CopilotChatUserMessage;
   reasoningMessage: typeof CopilotChatReasoningMessage;
   cursor: typeof CopilotChatMessageView.Cursor;
+  intelligenceIndicator: typeof IntelligenceIndicatorView;
 }, {
   isRunning?: boolean;
   messages?: Message$2[];
@@ -904,6 +1050,7 @@ declare function CopilotChatMessageView({
   userMessage,
   reasoningMessage,
   cursor,
+  intelligenceIndicator,
   isRunning,
   children,
   className,
@@ -977,6 +1124,12 @@ type CopilotChatViewProps = WithSlots<{
    * ```
    */
   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>;
 } & React$1.HTMLAttributes<HTMLDivElement>>;
 declare function CopilotChatView({
   messageView,
@@ -1009,6 +1162,7 @@ declare function CopilotChatView({
   isConnecting,
   hasExplicitThreadId,
   disclaimer,
+  intelligenceIndicator,
   children,
   className,
   ...props
@@ -1303,62 +1457,6 @@ interface MCPAppsActivityRendererProps {
  */
 declare const MCPAppsActivityRenderer: React$1.FC<MCPAppsActivityRendererProps>;
 //#endregion
-//#region src/v2/components/intelligence-indicator/IntelligenceIndicator.d.ts
-interface IntelligenceIndicatorProps {
-  /** The message this indicator is attached to. */
-  message: Message$2;
-  /**
-   * 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 "Using
-   * CopilotKit Intelligence".
-   */
-  label?: string;
-}
-/**
- * The "Using CopilotKit Intelligence" pill. Auto-mounted by
- * `CopilotChatMessageView` for every message slot when
- * `copilotkit.intelligence` is configured — callers do not register
- * this themselves. Self-gates so only the canonical message renders a
- * pill.
- *
- * Render gates (all must hold):
- *   1. `copilotkit.intelligence !== undefined`
- *   2. The message is an assistant message with at least one tool call
- *      whose name matches {@link DEFAULT_TOOL_PATTERNS}
- *   3. The message is the *latest* such matching-assistant message in
- *      `agent.messages` — tool-result messages and prose-only assistant
- *      messages don't invalidate the slot, so the pill stays
- *      continuously through a multi-step tool chain.
- *   4. The phase machine is past `idle` (the pending-grace timer fired)
- *      and not yet `hidden`.
- *
- * Phase machine (per-instance, all timers local):
- *   - Starts in `idle` — nothing rendered.
- *   - `idle → 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.
- *   - `spinner → check` as soon as EITHER `agent.isRunning` flips
- *     false OR a non-tool-call-like message appears later in
- *     `agent.messages` (i.e. the agent has produced a "real"
- *     follow-up — prose answer or a new user turn).
- *   - `check → fading` after {@link CHECK_HOLD_MS}.
- *   - `fading → hidden` after {@link FADE_OUT_ANIMATION_MS}.
- *
- * Once `hidden`, the phase is sticky — a finished pill never re-spawns
- * on the same message. New runs mount fresh indicator instances on
- * their own assistant messages.
- *
- * The "exactly one pill at a time" guarantee is structural: only one
- * message satisfies the latest-matching-assistant gate at any moment.
- */
-declare function IntelligenceIndicator(props: IntelligenceIndicatorProps): React$1.ReactElement | null;
-//#endregion
 //#region src/v2/hooks/use-render-tool-call.d.ts
 interface UseRenderToolCallProps {
   toolCall: ToolCall;
@@ -2086,6 +2184,130 @@ declare function useThreads({
   limit
 }: UseThreadsInput): UseThreadsResult;
 //#endregion
+//#region src/v2/hooks/use-learn-from-user-action.d.ts
+/**
+ * Input to {@link UseLearnFromUserActionRecorder}, the function returned
+ * by {@link useLearnFromUserAction}. Captures a single UI interaction that
+ * the Intelligence platform'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 the Intelligence platform'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/v2/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/v2/hooks/use-attachments.d.ts
 interface UseAttachmentsProps {
   config?: AttachmentsConfig;
@@ -2129,6 +2351,95 @@ declare function useAttachments({
   config
 }: UseAttachmentsProps): UseAttachmentsReturn;
 //#endregion
+//#region src/v2/hooks/use-learning-containers.d.ts
+/**
+ * Arguments for {@link useLearningContainers}.
+ */
+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[];
+}
+/**
+ * Declaratively keeps a thread's learning containers 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],
+ *   });
+ *   // ...
+ * }
+ * ```
+ */
+declare function useLearningContainers({
+  threadId,
+  learningContainers
+}: UseLearningContainersArgs): void;
+//#endregion
+//#region src/v2/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.
+ */
+type UseLearningContainersInCurrentThreadArgs = Omit<UseLearningContainersArgs, "threadId">;
+/**
+ * Declaratively keeps the **current chat thread's** learning containers 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],
+ *   });
+ *   // ...
+ * }
+ * ```
+ */
+declare function useLearningContainersInCurrentThread({
+  learningContainers
+}: UseLearningContainersInCurrentThreadArgs): void;
+//#endregion
 //#region src/v2/lib/react-core.d.ts
 interface CopilotKitCoreReactConfig extends CopilotKitCoreConfig {
   renderToolCalls?: ReactToolCallRenderer<any>[];
@@ -2193,6 +2504,32 @@ interface CopilotKitContextValue {
 }
 declare const useCopilotKit: () => CopilotKitContextValue;
 //#endregion
+//#region src/v2/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/v2/providers/CopilotKitProvider.d.ts
 interface CopilotKitProviderProps {
   children: ReactNode;
@@ -2212,7 +2549,7 @@ interface CopilotKitProviderProps {
   publicLicenseKey?: string;
   /**
    * Signed license token for offline verification of premium features.
-   * Obtain from https://cloud.copilotkit.ai.
+   * Obtain from https://dashboard.operations.copilotkit.ai.
    */
   licenseToken?: string;
   properties?: Record<string, unknown>;
@@ -2303,6 +2640,12 @@ interface CopilotKitProviderProps {
      * schema if configured. Set to false to disable.
      */
     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;
   };
   /**
    * Default throttle interval (in milliseconds) for `useAgent` re-renders
@@ -2344,8 +2687,13 @@ type A2UIUserAction = {
 };
 type A2UIMessageRendererOptions = {
   theme: Theme; /** Optional component catalog to pass to A2UIProvider */
-  catalog?: any; /** Optional custom loading component shown while A2UI surface is generating. */
+  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;
 };
 declare function createA2UIMessageRenderer(options: A2UIMessageRendererOptions): ReactActivityMessageRenderer<any>;
 //#endregion
@@ -2363,13 +2711,13 @@ interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children"> {
   /**
    * Your Copilot Cloud API key.
    *
-   * Don't have it yet? Go to https://cloud.copilotkit.ai and get one for free.
+   * Don't have it yet? Go to https://dashboard.operations.copilotkit.ai and get one for free.
    */
   publicApiKey?: string;
   /**
    * Your public license key for accessing premium CopilotKit features.
    *
-   * Don't have it yet? Go to https://cloud.copilotkit.ai and get one for free.
+   * Don't have it yet? Go to https://dashboard.operations.copilotkit.ai and get one for free.
    */
   publicLicenseKey?: string;
   /**
@@ -2384,7 +2732,7 @@ interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children"> {
    * Restrict input to specific topics using guardrails.
    * @remarks
    *
-   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
+   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://dashboard.operations.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
    */
   guardrails_c?: {
     validTopics?: string[];
@@ -2485,7 +2833,7 @@ interface CopilotKitProps extends Omit<CopilotKitProviderProps, "children"> {
    * The auth config to use for the CopilotKit.
    * @remarks
    *
-   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
+   * This feature is only available when using CopilotKit's hosted cloud service. To use this feature, sign up at https://dashboard.operations.copilotkit.ai to get your publicApiKey. The feature allows restricting chat conversations to specific topics.
    */
   authConfig_c?: {
     SignInComponent: React.ComponentType<{
@@ -2545,5 +2893,5 @@ declare function CopilotKit({
 }: CopilotKitProps): react_jsx_runtime0.JSX.Element;
 declare const defaultCopilotContextCategories: string[];
 //#endregion
-export { IntelligenceIndicator as $, useCopilotChatConfiguration as $t, useAgentContext as A, ActionRenderPropsWait as An, CopilotChatViewProps as At, SandboxFunction as B, CopilotChatUserMessage as Bt, useThreads as C, SystemMessageFunction as Cn, CopilotChatToggleButton as Ct, useSuggestions as D, ActionRenderProps as Dn, CopilotChat as Dt, useConfigureSuggestions as E, TreeNode as En, DefaultOpenIcon as Et, useDefaultRenderTool as F, RenderFunctionStatus as Fn, CopilotChatSuggestionViewProps as Ft, ReactHumanInTheLoop as G, CopilotChatToolCallsViewProps as Gt, InterruptHandlerProps as H, CopilotChatAssistantMessage as Ht, useRenderTool as I, CopilotChatSuggestionPill as It, ReactToolCallRenderer as J, ToolsMenuItem as Jt, ReactFrontendTool as K, CopilotChatInput as Kt, useComponent as L, CopilotChatSuggestionPillProps as Lt, UseAgentUpdate as M, CatchAllFrontendAction as Mn, CopilotChatMessageView as Mt, useAgent as N, FrontendAction as Nn, CopilotChatMessageViewProps as Nt, AgentContextInput as O, ActionRenderPropsNoArgs as On, CopilotChatProps as Ot, useHumanInTheLoop as P, FrontendActionAvailability as Pn, CopilotChatSuggestionView as Pt, useRenderToolCall as Q, CopilotChatLabels as Qt, useFrontendTool as R, CopilotChatReasoningMessage as Rt, UseThreadsResult as S, CopilotChatSuggestionConfiguration as Sn, CopilotModalHeaderProps as St, useInterrupt as T, Tree as Tn, DefaultCloseIcon as Tt, InterruptRenderProps as U, CopilotChatAssistantMessageProps as Ut, InterruptEvent as V, CopilotChatUserMessageProps as Vt, defineToolCallRenderer as W, CopilotChatToolCallsView as Wt, ReactCustomMessageRenderer as X, CopilotChatConfigurationProviderProps as Xt, useRenderCustomMessages as Y, CopilotChatConfigurationProvider as Yt, ReactCustomMessageRendererPosition as Z, CopilotChatConfigurationValue as Zt, UseAttachmentsProps as _, CrewsResponse as _n, CopilotPopupView as _t, A2UIUserAction as a, CopilotContext as an, CopilotKitInspector as at, Thread as b, CrewsTaskStateItem as bn, CopilotSidebarViewProps as bt, SandboxFunctionsContext as c, CoAgentStateRender as cn, Attachment$1 as ct, CopilotKitProviderProps as d, LangGraphInterruptActionSetterArgs as dn, CopilotChatAttachmentRenderer as dt, AudioRecorderError as en, IntelligenceIndicatorProps as et, CopilotKitContextValue as f, LangGraphInterruptRender as fn, CopilotChatAttachmentQueue as ft, CopilotKitCoreReactSubscriber as g, CrewsAgentState as gn, CopilotSidebarProps as gt, CopilotKitCoreReactConfig as h, QueuedInterruptEvent as hn, CopilotSidebar as ht, A2UIMessageRendererOptions as i, CopilotApiConfig as in, MCPAppsActivityType as it, useCapabilities as j, CatchAllActionRenderProps as jn, AutoScrollMode as jt, JsonSerializable as k, ActionRenderPropsNoArgsWait as kn, CopilotChatView as kt, useSandboxFunctions as l, LangGraphInterruptAction as ln, AttachmentModality as lt, CopilotKitCoreReact as m, LangGraphInterruptRenderProps as mn, CopilotPopupProps as mt, defaultCopilotContextCategories as n, CopilotChatAudioRecorder as nn, MCPAppsActivityContentSchema as nt, createA2UIMessageRenderer as o, CopilotContextParams as on, CopilotKitInspectorProps as ot, useCopilotKit as p, LangGraphInterruptRenderHandlerProps as pn, CopilotPopup as pt, ReactActivityMessageRenderer as q, CopilotChatInputProps as qt, CopilotKitProps as r, CoagentInChatRenderFunction as rn, MCPAppsActivityRenderer as rt, InspectorAnchor as s, useCopilotContext as sn, WildcardToolCallRender as st, CopilotKit as t, AudioRecorderState as tn, MCPAppsActivityContent as tt, CopilotKitProvider as u, LangGraphInterruptActionSetter as un, AttachmentsConfig$1 as ut, UseAttachmentsReturn as v, CrewsResponseStatus as vn, CopilotPopupViewProps as vt, UseInterruptConfig as w, DocumentPointer as wn, CopilotChatToggleButtonProps as wt, UseThreadsInput as x, CrewsToolStateItem as xn, CopilotModalHeader as xt, useAttachments as y, CrewsStateItem as yn, CopilotSidebarView as yt, useRenderActivityMessage as z, CopilotChatReasoningMessageProps as zt };
-//# sourceMappingURL=copilotkit-D16eCFkt.d.cts.map
+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-CD3EqiJ4.d.cts.map