@copilotkit/react-core 1.51.3-next.6 → 1.51.3-next.7

package/src/hooks/use-coagent-state-render-bridge.tsx

@@ -2,27 +2,9 @@ import { ReactCustomMessageRendererPosition, useAgent } from "@copilotkitnext/re
 import { useCallback, useEffect, useMemo, useState } from "react";
 import type { AgentSubscriber } from "@ag-ui/client";
 import { useCoAgentStateRenders } from "../context";
-import { dataToUUID, parseJson } from "@copilotkit/shared";
-
-function getStateWithoutConstantKeys(state: any) {
-  if (!state) return {};
-  const { messages, tools, copilotkit, ...stateWithoutConstantKeys } = state;
-  return stateWithoutConstantKeys;
-}
-
-// Function that compares states, without the constant keys
-function areStatesEquals(a: any, b: any) {
-  if ((a && !b) || (!a && b)) return false;
-  const { messages, tools, copilotkit, ...aWithoutConstantKeys } = a;
-  const {
-    messages: bMessages,
-    tools: bTools,
-    copilotkit: bCopilotkit,
-    ...bWithoutConstantKeys
-  } = b;
-
-  return JSON.stringify(aWithoutConstantKeys) === JSON.stringify(bWithoutConstantKeys);
-}
+import { parseJson } from "@copilotkit/shared";
+import { RenderStatus } from "./use-coagent-state-render-bridge.helpers";
+import { useStateRenderRegistry } from "./use-coagent-state-render-registry";
 
 /**
  * Bridge hook that connects agent state renders to chat messages.
@@ -119,15 +101,12 @@ export interface CoAgentStateRenderBridgeProps {
 }
 
 export function useCoagentStateRenderBridge(agentId: string, props: CoAgentStateRenderBridgeProps) {
-  const { stateSnapshot, messageIndexInRun, message } = props;
+  const { stateSnapshot, message } = props;
   const { coAgentStateRenders, claimsRef } = useCoAgentStateRenders();
   const { agent } = useAgent({ agentId });
   const [nodeName, setNodeName] = useState<string | undefined>(undefined);
   const [, forceUpdate] = useState(0);
 
-  const runId = props.runId ?? message.runId;
-  const effectiveRunId = runId || "pending";
-
   useEffect(() => {
     if (!agent) return;
     const subscriber: AgentSubscriber = {
@@ -166,107 +145,33 @@ export function useCoagentStateRenderBridge(agentId: string, props: CoAgentState
     },
     [coAgentStateRenders, nodeName, agentId],
   );
+  const stateRenderEntry = useMemo(() => getStateRender(message.id), [getStateRender, message.id]);
+  const stateRenderId = stateRenderEntry?.[0];
+  const stateRender = stateRenderEntry?.[1];
 
-  // Message ID-based claim system - A state render can only be claimed by one message ID
-  const handleRenderRequest = ({
-    stateRenderId,
-    messageId,
-    runId,
-    stateSnapshot: renderSnapshot,
-  }: {
-    stateRenderId: string;
-    messageId: string;
-    runId?: string;
-    stateSnapshot?: any;
-  }): boolean => {
-    // Check if this message has already claimed this state render
-    if (claimsRef.current[messageId]) {
-      const canRender = claimsRef.current[messageId].stateRenderId === stateRenderId;
-
-      // Update runId if it doesn't exist
-      if (
-        canRender &&
-        runId &&
-        (!claimsRef.current[messageId].runId || claimsRef.current[messageId].runId === "pending")
-      ) {
-        claimsRef.current[messageId].runId = runId;
-      }
-
-      return canRender;
-    }
-
-    // Do not allow render if any other message has claimed this state render
-    const renderClaimedByOtherMessage = Object.values(claimsRef.current).find(
-      (c) =>
-        c.stateRenderId === stateRenderId &&
-        dataToUUID(getStateWithoutConstantKeys(c.stateSnapshot)) ===
-          dataToUUID(getStateWithoutConstantKeys(renderSnapshot)),
-    );
-    if (renderClaimedByOtherMessage) {
-      // If:
-      //   - state render already claimed
-      //   - snapshot exists in the claiming object and is different from current,
-      if (
-        renderSnapshot &&
-        renderClaimedByOtherMessage.stateSnapshot &&
-        !areStatesEquals(renderClaimedByOtherMessage.stateSnapshot, renderSnapshot)
-      ) {
-        claimsRef.current[messageId] = { stateRenderId, runId };
-        return true;
-      }
-      return false;
-    }
-
-    // No existing claim anywhere yet – allow this message to claim even if we already know the runId.
-    if (!runId) {
-      return false;
-    }
-
-    claimsRef.current[messageId] = { stateRenderId, runId };
-    return true;
+  const registryMessage = {
+    ...message,
+    runId: props.runId ?? message.runId,
   };
+  const { canRender } = useStateRenderRegistry({
+    agentId,
+    stateRenderId,
+    message: registryMessage,
+    messageIndex: props.messageIndex,
+    stateSnapshot,
+    agentState: agent?.state,
+    agentMessages: agent?.messages,
+    claimsRef,
+  });
 
   return useMemo(() => {
-    if (messageIndexInRun !== 0) {
-      return null;
-    }
-
-    const [stateRenderId, stateRender] = getStateRender(message.id) ?? [];
-
     if (!stateRender || !stateRenderId) {
       return null;
     }
-
-    // Is there any state we can use?
-    const snapshot = stateSnapshot ? parseJson(stateSnapshot, stateSnapshot) : agent?.state;
-
-    // Synchronously check/claim - returns true if this message can render
-    const canRender = handleRenderRequest({
-      stateRenderId,
-      messageId: message.id,
-      runId: effectiveRunId,
-      stateSnapshot: snapshot,
-    });
     if (!canRender) {
       return null;
     }
 
-    // If we found state, and given that now there's a claim for the current message, let's save it in the claim
-    if (snapshot) {
-      const existingSnapshot = claimsRef.current[message.id].stateSnapshot;
-      const snapshotChanged =
-        stateSnapshot &&
-        existingSnapshot !== undefined &&
-        !areStatesEquals(existingSnapshot, snapshot);
-
-      if (!claimsRef.current[message.id].locked || snapshotChanged) {
-        claimsRef.current[message.id].stateSnapshot = snapshot;
-        if (stateSnapshot) {
-          claimsRef.current[message.id].locked = true;
-        }
-      }
-    }
-
     if (stateRender.handler) {
       stateRender.handler({
         state: stateSnapshot ? parseJson(stateSnapshot, stateSnapshot) : (agent?.state ?? {}),
@@ -275,7 +180,7 @@ export function useCoagentStateRenderBridge(agentId: string, props: CoAgentState
     }
 
     if (stateRender.render) {
-      const status = agent?.isRunning ? "inProgress" : "complete";
+      const status = agent?.isRunning ? RenderStatus.InProgress : RenderStatus.Complete;
 
       if (typeof stateRender.render === "string") return stateRender.render;
 
@@ -287,14 +192,14 @@ export function useCoagentStateRenderBridge(agentId: string, props: CoAgentState
       });
     }
   }, [
-    getStateRender,
-    stateSnapshot,
+    stateRender,
+    stateRenderId,
     agent?.state,
     agent?.isRunning,
     nodeName,
-    effectiveRunId,
     message.id,
-    messageIndexInRun,
+    stateSnapshot,
+    canRender,
   ]);
 }
 

package/src/hooks/use-coagent-state-render-registry.ts

@@ -0,0 +1,215 @@
+import { useEffect } from "react";
+import {
+  areStatesEquals,
+  ClaimAction,
+  getEffectiveRunId,
+  isPlaceholderMessageId,
+  isPlaceholderMessageName,
+  readCachedMessageEntry,
+  resolveClaim,
+  selectSnapshot,
+  type Claim,
+  type ClaimsByMessageId,
+  type SnapshotCaches,
+  type StateRenderContext,
+} from "./use-coagent-state-render-bridge.helpers";
+
+export interface StateRenderRegistryInput {
+  agentId: string;
+  stateRenderId?: string;
+  message: { id: string; runId?: string; name?: string };
+  messageIndex?: number;
+  stateSnapshot?: any;
+  agentState?: any;
+  agentMessages?: Array<{ id: string; role?: string }>;
+  claimsRef: React.MutableRefObject<Record<string, Claim>>;
+}
+
+export interface StateRenderRegistryResult {
+  canRender: boolean;
+}
+
+const LAST_SNAPSHOTS_BY_RENDER_AND_RUN = "__lastSnapshotsByStateRenderIdAndRun";
+const LAST_SNAPSHOTS_BY_MESSAGE = "__lastSnapshotsByMessageId";
+
+type SnapshotByMessageEntry = { snapshot: any; runId?: string } | any;
+type ClaimsStore = Record<string, Claim> & {
+  [LAST_SNAPSHOTS_BY_RENDER_AND_RUN]?: Record<string, any>;
+  [LAST_SNAPSHOTS_BY_MESSAGE]?: Record<string, SnapshotByMessageEntry>;
+};
+
+function getClaimsStore(
+  claimsRef: React.MutableRefObject<Record<string, Claim>>,
+): ClaimsStore {
+  return claimsRef.current as ClaimsStore;
+}
+
+function getSnapshotCaches(claimsRef: React.MutableRefObject<Record<string, Claim>>): SnapshotCaches {
+  const store = getClaimsStore(claimsRef);
+  return {
+    byStateRenderAndRun: store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {},
+    byMessageId: store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {},
+  };
+}
+
+export function useStateRenderRegistry({
+  agentId,
+  stateRenderId,
+  message,
+  messageIndex,
+  stateSnapshot,
+  agentState,
+  agentMessages,
+  claimsRef,
+}: StateRenderRegistryInput): StateRenderRegistryResult {
+  const store = getClaimsStore(claimsRef);
+  const runId = message.runId;
+  const cachedMessageEntry = store[LAST_SNAPSHOTS_BY_MESSAGE]?.[message.id];
+  const { runId: cachedMessageRunId } = readCachedMessageEntry(cachedMessageEntry);
+  const existingClaimRunId = claimsRef.current[message.id]?.runId;
+  const effectiveRunId = getEffectiveRunId({
+    existingClaimRunId,
+    cachedMessageRunId,
+    runId,
+  });
+
+  useEffect(() => {
+    return () => {
+      const existingClaim = claimsRef.current[message.id];
+      if (
+        existingClaim?.stateSnapshot &&
+        Object.keys(existingClaim.stateSnapshot).length > 0
+      ) {
+        const snapshotCache = {
+          ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+        };
+        const cacheKey = `${existingClaim.stateRenderId}::${existingClaim.runId ?? "pending"}`;
+        snapshotCache[cacheKey] = existingClaim.stateSnapshot;
+        snapshotCache[`${existingClaim.stateRenderId}::latest`] = existingClaim.stateSnapshot;
+        store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+
+        const messageCache = {
+          ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+        };
+        messageCache[message.id] = {
+          snapshot: existingClaim.stateSnapshot,
+          runId: existingClaim.runId ?? effectiveRunId,
+        };
+        store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+      }
+      delete claimsRef.current[message.id];
+    };
+  }, [claimsRef, effectiveRunId, message.id]);
+
+  if (!stateRenderId) {
+    return { canRender: false };
+  }
+
+  const caches = getSnapshotCaches(claimsRef);
+  const existingClaim = claimsRef.current[message.id] as Claim | undefined;
+
+  const { snapshot, hasSnapshotKeys, allowEmptySnapshot, snapshotForClaim } = selectSnapshot({
+    messageId: message.id,
+    messageName: message.name,
+    allowLiveState:
+      isPlaceholderMessageName(message.name) || isPlaceholderMessageId(message.id),
+    skipLatestCache:
+      isPlaceholderMessageName(message.name) || isPlaceholderMessageId(message.id),
+    stateRenderId,
+    effectiveRunId,
+    stateSnapshotProp: stateSnapshot,
+    agentState,
+    agentMessages,
+    existingClaim,
+    caches,
+  });
+
+  const resolution = resolveClaim({
+    claims: claimsRef.current as ClaimsByMessageId,
+    context: {
+      agentId,
+      messageId: message.id,
+      stateRenderId,
+      runId: effectiveRunId,
+      messageIndex,
+    } satisfies StateRenderContext,
+    stateSnapshot: snapshotForClaim,
+  });
+
+  if (resolution.action === ClaimAction.Block) {
+    return { canRender: false };
+  }
+
+  if (resolution.updateRunId && claimsRef.current[message.id]) {
+    claimsRef.current[message.id].runId = resolution.updateRunId;
+  }
+
+  if (resolution.nextClaim) {
+    claimsRef.current[message.id] = resolution.nextClaim;
+  }
+
+  if (resolution.lockOthers) {
+    Object.entries(claimsRef.current).forEach(([id, claim]) => {
+      if (id !== message.id && claim.stateRenderId === stateRenderId) {
+        claim.locked = true;
+      }
+    });
+  }
+
+  if (existingClaim && !existingClaim.locked && agentMessages?.length) {
+    const indexInAgentMessages = agentMessages.findIndex((msg: any) => msg.id === message.id);
+    if (indexInAgentMessages >= 0 && indexInAgentMessages < agentMessages.length - 1) {
+      existingClaim.locked = true;
+    }
+  }
+
+  const existingSnapshot = claimsRef.current[message.id].stateSnapshot;
+  const snapshotChanged =
+    stateSnapshot &&
+    existingSnapshot !== undefined &&
+    !areStatesEquals(existingSnapshot, snapshot);
+
+  if (
+    snapshot &&
+    (stateSnapshot || hasSnapshotKeys || allowEmptySnapshot) &&
+    (!claimsRef.current[message.id].locked || snapshotChanged)
+  ) {
+    if (!claimsRef.current[message.id].locked || snapshotChanged) {
+      claimsRef.current[message.id].stateSnapshot = snapshot;
+      const snapshotCache = {
+        ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+      };
+      const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+      snapshotCache[cacheKey] = snapshot;
+      snapshotCache[`${stateRenderId}::latest`] = snapshot;
+      store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+      const messageCache = {
+        ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+      };
+      messageCache[message.id] = { snapshot, runId: effectiveRunId };
+      store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+      if (stateSnapshot) {
+        claimsRef.current[message.id].locked = true;
+      }
+    }
+  } else if (snapshotForClaim) {
+    const existingSnapshot = claimsRef.current[message.id].stateSnapshot;
+    if (!existingSnapshot) {
+      claimsRef.current[message.id].stateSnapshot = snapshotForClaim;
+      const snapshotCache = {
+        ...(store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {}),
+      };
+      const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+      snapshotCache[cacheKey] = snapshotForClaim;
+      snapshotCache[`${stateRenderId}::latest`] = snapshotForClaim;
+      store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+      const messageCache = {
+        ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
+      };
+      messageCache[message.id] = { snapshot: snapshotForClaim, runId: effectiveRunId };
+      store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+    }
+  }
+
+  return { canRender: true };
+}

package/src/hooks/use-copilot-chat_internal.ts

@@ -324,7 +324,8 @@ export function useCopilotChatInternal({
         if (error instanceof AGUIConnectNotImplementedError) {
           // connect not implemented, ignore
         } else {
-          throw error;
+          console.error("CopilotChat: connectAgent failed", error);
+          // Error will be reported through subscription
         }
       }
     };
@@ -412,7 +413,12 @@ export function useCopilotChatInternal({
       agent?.setMessages(historyCutoff);
 
       if (agent) {
-        copilotkit.runAgent({ agent });
+        try {
+          await copilotkit.runAgent({ agent });
+        } catch (error) {
+          console.error("CopilotChat: runAgent failed during reload", error);
+          // Error will be reported through subscription
+        }
       }
       return;
     },
@@ -451,6 +457,7 @@ export function useCopilotChatInternal({
           await copilotkit.runAgent({ agent });
         } catch (error) {
           console.error("CopilotChat: runAgent failed", error);
+          // Error will be reported through subscription
         }
       }
     },
@@ -526,46 +533,92 @@ export function useCopilotChatInternal({
       const bridgeRenderer =
         legacyCustomMessageRenderer || renderCustomMessage
           ? () => {
-              const customRender = renderCustomMessage?.({
-                message,
-                position: "before",
-              });
-              if (customRender) {
-                return customRender;
+              if (legacyCustomMessageRenderer) {
+                return legacyCustomMessageRenderer({ message, position: "before" });
+              }
+              try {
+                return renderCustomMessage?.({ message, position: "before" }) ?? null;
+              } catch (error) {
+                console.warn(
+                  "[CopilotKit] renderCustomMessages failed, falling back to legacy renderer",
+                  error,
+                );
+                return null;
               }
-              return legacyCustomMessageRenderer?.({ message, position: "before" });
             }
           : null;
 
       if (bridgeRenderer) {
-        return { ...message, generativeUI: bridgeRenderer };
+        // Attach a position so react-ui can render the custom UI above the assistant content.
+        return {
+          ...message,
+          generativeUI: bridgeRenderer,
+          generativeUIPosition: "before" as const,
+        };
       }
       return message;
     });
 
     const hasAssistantMessages = processedMessages.some((msg) => msg.role === "assistant");
-
-    // TODO: what is this?
-    // if (legacyCustomMessageRenderer && !hasAssistantMessages) {
-    //   const placeholderId = `coagent-state-render-${resolvedAgentId}`;
-    //   const placeholderMessage: Message = {
-    //     id: placeholderId,
-    //     role: "assistant",
-    //     content: "",
-    //     name: "coagent-state-render",
-    //   };
-    //   processedMessages = [
-    //     ...processedMessages,
-    //     {
-    //       ...placeholderMessage,
-    //       generativeUI: () =>
-    //         legacyCustomMessageRenderer({
-    //           message: placeholderMessage,
-    //           position: "before",
-    //         }),
-    //     } as Message,
-    //   ];
-    // }
+    const canUseCustomRenderer = Boolean(
+      renderCustomMessage && copilotkit?.getAgent?.(resolvedAgentId),
+    );
+    const placeholderRenderer = legacyCustomMessageRenderer
+      ? legacyCustomMessageRenderer
+      : canUseCustomRenderer
+        ? renderCustomMessage
+        : null;
+
+    const shouldRenderPlaceholder =
+      Boolean(agent?.isRunning) || Boolean(agent?.state && Object.keys(agent.state).length);
+
+    const effectiveThreadId = threadId ?? agent?.threadId ?? "default";
+    let latestUserIndex = -1;
+    for (let i = processedMessages.length - 1; i >= 0; i -= 1) {
+      if (processedMessages[i].role === "user") {
+        latestUserIndex = i;
+        break;
+      }
+    }
+    const latestUserMessageId =
+      latestUserIndex >= 0 ? processedMessages[latestUserIndex].id : undefined;
+    const currentRunId = latestUserMessageId
+      ? copilotkit.getRunIdForMessage(resolvedAgentId, effectiveThreadId, latestUserMessageId) ||
+        `pending:${latestUserMessageId}`
+      : undefined;
+    const hasAssistantForCurrentRun =
+      latestUserIndex >= 0
+        ? processedMessages
+            .slice(latestUserIndex + 1)
+            .some((msg) => msg.role === "assistant")
+        : hasAssistantMessages;
+
+    // Insert a placeholder assistant message so state snapshots can render before any
+    // assistant text exists for the current run.
+    if (placeholderRenderer && shouldRenderPlaceholder && !hasAssistantForCurrentRun) {
+      const placeholderId = currentRunId
+        ? `coagent-state-render-${resolvedAgentId}-${currentRunId}`
+        : `coagent-state-render-${resolvedAgentId}`;
+      const placeholderMessage: Message = {
+        id: placeholderId,
+        role: "assistant",
+        content: "",
+        name: "coagent-state-render",
+        runId: currentRunId,
+      };
+      processedMessages = [
+        ...processedMessages,
+        {
+          ...placeholderMessage,
+          generativeUIPosition: "before" as const,
+          generativeUI: () =>
+            placeholderRenderer({
+              message: placeholderMessage,
+              position: "before",
+            }),
+        } as Message,
+      ];
+    }
 
     return processedMessages;
   }, [
@@ -573,8 +626,11 @@ export function useCopilotChatInternal({
     lazyToolRendered,
     allMessages,
     renderCustomMessage,
-    // legacyCustomMessageRenderer,
+    legacyCustomMessageRenderer,
     resolvedAgentId,
+    copilotkit,
+    agent?.isRunning,
+    agent?.state,
   ]);
 
   const renderedSuggestions = useMemo(() => {
@@ -650,7 +706,10 @@ function useLegacyCoagentRenderer({
 
     return ({ message, position }: LegacyRenderParams) => {
       const effectiveThreadId = threadId ?? agent.threadId ?? "default";
-      const existingRunId = copilotkit.getRunIdForMessage(agentId, effectiveThreadId, message.id);
+      const providedRunId = (message as any).runId as string | undefined;
+      const existingRunId = providedRunId
+        ? providedRunId
+        : copilotkit.getRunIdForMessage(agentId, effectiveThreadId, message.id);
       const runId = existingRunId || `pending:${message.id}`;
       const messageIndex = Math.max(
         agent.messages.findIndex((msg) => msg.id === message.id),

package/src/setupTests.ts

@@ -17,6 +17,7 @@ jest.mock("@copilotkit/shared", () => ({
       return defaultValue;
     }
   }),
+  dataToUUID: jest.fn((data) => JSON.stringify(data)),
   randomId: jest.fn(() => "test-random-id"),
   CopilotKitAgentDiscoveryError: jest.fn(),
   randomUUID: jest.fn(() => "mock-thread-id"),

package/src/test-helpers/copilot-context.ts

@@ -0,0 +1,91 @@
+import type { CopilotContextParams, CopilotApiConfig } from "../context";
+
+const noop = () => {};
+
+const copilotApiConfig: CopilotApiConfig = {
+  chatApiEndpoint: "http://localhost",
+  headers: {},
+};
+
+export function createTestCopilotContext(
+  overrides: Partial<CopilotContextParams> = {},
+): CopilotContextParams {
+  return {
+    actions: {},
+    setAction: noop,
+    removeAction: noop,
+
+    setRegisteredActions: () => "action-id",
+    removeRegisteredAction: noop,
+
+    chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },
+    getFunctionCallHandler: () => async () => {},
+
+    addContext: () => "context-id",
+    removeContext: noop,
+    getAllContext: () => [],
+    getContextString: () => "",
+
+    addDocumentContext: () => "document-id",
+    removeDocumentContext: noop,
+    getDocumentsContext: () => [],
+
+    isLoading: false,
+    setIsLoading: noop,
+
+    chatSuggestionConfiguration: {},
+    addChatSuggestionConfiguration: noop,
+    removeChatSuggestionConfiguration: noop,
+
+    chatInstructions: "",
+    setChatInstructions: noop,
+
+    additionalInstructions: [],
+    setAdditionalInstructions: noop,
+
+    copilotApiConfig,
+
+    showDevConsole: false,
+
+    coagentStates: {},
+    setCoagentStates: noop,
+    coagentStatesRef: { current: {} },
+    setCoagentStatesWithRef: noop,
+
+    agentSession: null,
+    setAgentSession: noop,
+
+    agentLock: null,
+
+    threadId: "",
+    setThreadId: noop,
+
+    runId: null,
+    setRunId: noop,
+
+    chatAbortControllerRef: { current: null },
+
+    forwardedParameters: {},
+    availableAgents: [],
+
+    extensions: {},
+    setExtensions: noop,
+
+    interruptActions: {},
+    setInterruptAction: noop,
+    removeInterruptAction: noop,
+    interruptEventQueue: {},
+    addInterruptEvent: noop,
+    resolveInterruptEvent: noop,
+
+    onError: noop,
+
+    bannerError: null,
+    setBannerError: noop,
+    internalErrorHandlers: {},
+    setInternalErrorHandler: noop,
+    removeInternalErrorHandler: noop,
+
+    ...overrides,
+  };
+}