@copilotkit/react-core 1.51.4-next.7 → 1.51.4-next.8

package/src/hooks/use-coagent-state-render-bridge.helpers.ts

@@ -82,7 +82,10 @@ export function areStatesEquals(a: any, b: any) {
     ...bWithoutConstantKeys
   } = b;
 
-  return JSON.stringify(aWithoutConstantKeys) === JSON.stringify(bWithoutConstantKeys);
+  return (
+    JSON.stringify(aWithoutConstantKeys) ===
+    JSON.stringify(bWithoutConstantKeys)
+  );
 }
 
 export function isPlaceholderMessageId(messageId: string | undefined) {
@@ -93,7 +96,10 @@ export function isPlaceholderMessageName(messageName: string | undefined) {
   return messageName === "coagent-state-render";
 }
 
-export function readCachedMessageEntry(entry: any): { snapshot?: any; runId?: string } {
+export function readCachedMessageEntry(entry: any): {
+  snapshot?: any;
+  runId?: string;
+} {
   if (!entry || typeof entry !== "object") {
     return { snapshot: entry, runId: undefined };
   }
@@ -164,11 +170,16 @@ export function resolveClaim({
         action: ClaimAction.Override,
         nextClaim: { stateRenderId, runId, messageIndex },
         lockOthers:
-          runId === renderClaimedByOtherMessage.runId || isPlaceholderMessageId(claimedMessageId),
+          runId === renderClaimedByOtherMessage.runId ||
+          isPlaceholderMessageId(claimedMessageId),
       };
     }
 
-    if (runId && renderClaimedByOtherMessage.runId && runId !== renderClaimedByOtherMessage.runId) {
+    if (
+      runId &&
+      renderClaimedByOtherMessage.runId &&
+      runId !== renderClaimedByOtherMessage.runId
+    ) {
       return {
         canRender: true,
         action: ClaimAction.Override,
@@ -238,12 +249,16 @@ export function selectSnapshot({
     ? [...agentMessages].reverse().find((msg) => msg.role === "assistant")?.id
     : undefined;
   const latestSnapshot =
-    stateRenderId !== undefined ? caches.byStateRenderAndRun[`${stateRenderId}::latest`] : undefined;
+    stateRenderId !== undefined
+      ? caches.byStateRenderAndRun[`${stateRenderId}::latest`]
+      : undefined;
   const messageIndex = agentMessages
     ? agentMessages.findIndex((msg) => msg.id === messageId)
     : -1;
   const messageRole =
-    messageIndex >= 0 && agentMessages ? agentMessages[messageIndex]?.role : undefined;
+    messageIndex >= 0 && agentMessages
+      ? agentMessages[messageIndex]?.role
+      : undefined;
   let previousUserMessageId: string | undefined;
   if (messageIndex > 0 && agentMessages) {
     for (let i = messageIndex - 1; i >= 0; i -= 1) {
@@ -259,7 +274,9 @@ export function selectSnapshot({
     agentState !== undefined &&
     areStatesEquals(latestSnapshot, agentState);
   const shouldUseLiveState =
-    (Boolean(allowLiveState) || !lastAssistantId || messageId === lastAssistantId) &&
+    (Boolean(allowLiveState) ||
+      !lastAssistantId ||
+      messageId === lastAssistantId) &&
     !liveStateIsStale;
   const snapshot = stateSnapshotProp
     ? parseJson(stateSnapshotProp, stateSnapshotProp)
@@ -273,22 +290,32 @@ export function selectSnapshot({
     (stateSnapshotProp !== undefined || shouldUseLiveState);
 
   const messageCacheEntry = caches.byMessageId[messageId];
-  const cachedMessageSnapshot = readCachedMessageEntry(messageCacheEntry).snapshot;
+  const cachedMessageSnapshot =
+    readCachedMessageEntry(messageCacheEntry).snapshot;
   const cacheKey =
-    stateRenderId !== undefined ? `${stateRenderId}::${effectiveRunId}` : undefined;
+    stateRenderId !== undefined
+      ? `${stateRenderId}::${effectiveRunId}`
+      : undefined;
   let cachedSnapshot = cachedMessageSnapshot ?? caches.byMessageId[messageId];
-  if (cachedSnapshot === undefined && cacheKey && caches.byStateRenderAndRun[cacheKey] !== undefined) {
+  if (
+    cachedSnapshot === undefined &&
+    cacheKey &&
+    caches.byStateRenderAndRun[cacheKey] !== undefined
+  ) {
     cachedSnapshot = caches.byStateRenderAndRun[cacheKey];
   }
   if (
     cachedSnapshot === undefined &&
     stateRenderId &&
     previousUserMessageId &&
-    caches.byStateRenderAndRun[`${stateRenderId}::pending:${previousUserMessageId}`] !==
-      undefined
+    caches.byStateRenderAndRun[
+      `${stateRenderId}::pending:${previousUserMessageId}`
+    ] !== undefined
   ) {
     cachedSnapshot =
-      caches.byStateRenderAndRun[`${stateRenderId}::pending:${previousUserMessageId}`];
+      caches.byStateRenderAndRun[
+        `${stateRenderId}::pending:${previousUserMessageId}`
+      ];
   }
   if (
     cachedSnapshot === undefined &&
@@ -302,10 +329,16 @@ export function selectSnapshot({
   }
 
   const snapshotForClaim = existingClaim?.locked
-    ? existingClaim.stateSnapshot ?? cachedSnapshot
+    ? (existingClaim.stateSnapshot ?? cachedSnapshot)
     : hasSnapshotKeys
       ? snapshot
-      : existingClaim?.stateSnapshot ?? cachedSnapshot;
+      : (existingClaim?.stateSnapshot ?? cachedSnapshot);
 
-  return { snapshot, hasSnapshotKeys, cachedSnapshot, allowEmptySnapshot, snapshotForClaim };
+  return {
+    snapshot,
+    hasSnapshotKeys,
+    cachedSnapshot,
+    allowEmptySnapshot,
+    snapshotForClaim,
+  };
 }

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

@@ -1,4 +1,7 @@
-import { ReactCustomMessageRendererPosition, useAgent } from "@copilotkitnext/react";
+import {
+  ReactCustomMessageRendererPosition,
+  useAgent,
+} from "@copilotkitnext/react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import type { AgentSubscriber } from "@ag-ui/client";
 import { useCoAgentStateRenders } from "../context";
@@ -100,7 +103,10 @@ export interface CoAgentStateRenderBridgeProps {
   stateSnapshot: any;
 }
 
-export function useCoagentStateRenderBridge(agentId: string, props: CoAgentStateRenderBridgeProps) {
+export function useCoagentStateRenderBridge(
+  agentId: string,
+  props: CoAgentStateRenderBridgeProps,
+) {
   const { stateSnapshot, message } = props;
   const { coAgentStateRenders, claimsRef } = useCoAgentStateRenders();
   const { agent } = useAgent({ agentId });
@@ -134,18 +140,25 @@ export function useCoagentStateRenderBridge(agentId: string, props: CoAgentState
 
   const getStateRender = useCallback(
     (messageId: string) => {
-      return Object.entries(coAgentStateRenders).find(([stateRenderId, stateRender]) => {
-        if (claimsRef.current[messageId]) {
-          return stateRenderId === claimsRef.current[messageId].stateRenderId;
-        }
-        const matchingAgentName = stateRender.name === agentId;
-        const matchesNodeContext = stateRender.nodeName ? stateRender.nodeName === nodeName : true;
-        return matchingAgentName && matchesNodeContext;
-      });
+      return Object.entries(coAgentStateRenders).find(
+        ([stateRenderId, stateRender]) => {
+          if (claimsRef.current[messageId]) {
+            return stateRenderId === claimsRef.current[messageId].stateRenderId;
+          }
+          const matchingAgentName = stateRender.name === agentId;
+          const matchesNodeContext = stateRender.nodeName
+            ? stateRender.nodeName === nodeName
+            : true;
+          return matchingAgentName && matchesNodeContext;
+        },
+      );
     },
     [coAgentStateRenders, nodeName, agentId],
   );
-  const stateRenderEntry = useMemo(() => getStateRender(message.id), [getStateRender, message.id]);
+  const stateRenderEntry = useMemo(
+    () => getStateRender(message.id),
+    [getStateRender, message.id],
+  );
   const stateRenderId = stateRenderEntry?.[0];
   const stateRender = stateRenderEntry?.[1];
 
@@ -174,13 +187,17 @@ export function useCoagentStateRenderBridge(agentId: string, props: CoAgentState
 
     if (stateRender.handler) {
       stateRender.handler({
-        state: stateSnapshot ? parseJson(stateSnapshot, stateSnapshot) : (agent?.state ?? {}),
+        state: stateSnapshot
+          ? parseJson(stateSnapshot, stateSnapshot)
+          : (agent?.state ?? {}),
         nodeName: nodeName ?? "",
       });
     }
 
     if (stateRender.render) {
-      const status = agent?.isRunning ? RenderStatus.InProgress : RenderStatus.Complete;
+      const status = agent?.isRunning
+        ? RenderStatus.InProgress
+        : RenderStatus.Complete;
 
       if (typeof stateRender.render === "string") return stateRender.render;
 

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

@@ -44,7 +44,9 @@ function getClaimsStore(
   return claimsRef.current as ClaimsStore;
 }
 
-function getSnapshotCaches(claimsRef: React.MutableRefObject<Record<string, Claim>>): SnapshotCaches {
+function getSnapshotCaches(
+  claimsRef: React.MutableRefObject<Record<string, Claim>>,
+): SnapshotCaches {
   const store = getClaimsStore(claimsRef);
   return {
     byStateRenderAndRun: store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {},
@@ -65,7 +67,8 @@ export function useStateRenderRegistry({
   const store = getClaimsStore(claimsRef);
   const runId = message.runId;
   const cachedMessageEntry = store[LAST_SNAPSHOTS_BY_MESSAGE]?.[message.id];
-  const { runId: cachedMessageRunId } = readCachedMessageEntry(cachedMessageEntry);
+  const { runId: cachedMessageRunId } =
+    readCachedMessageEntry(cachedMessageEntry);
   const existingClaimRunId = claimsRef.current[message.id]?.runId;
   const effectiveRunId = getEffectiveRunId({
     existingClaimRunId,
@@ -85,7 +88,8 @@ export function useStateRenderRegistry({
         };
         const cacheKey = `${existingClaim.stateRenderId}::${existingClaim.runId ?? "pending"}`;
         snapshotCache[cacheKey] = existingClaim.stateSnapshot;
-        snapshotCache[`${existingClaim.stateRenderId}::latest`] = existingClaim.stateSnapshot;
+        snapshotCache[`${existingClaim.stateRenderId}::latest`] =
+          existingClaim.stateSnapshot;
         store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
 
         const messageCache = {
@@ -108,21 +112,24 @@ export function useStateRenderRegistry({
   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 { 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,
@@ -157,8 +164,13 @@ export function useStateRenderRegistry({
   }
 
   if (existingClaim && !existingClaim.locked && agentMessages?.length) {
-    const indexInAgentMessages = agentMessages.findIndex((msg: any) => msg.id === message.id);
-    if (indexInAgentMessages >= 0 && indexInAgentMessages < agentMessages.length - 1) {
+    const indexInAgentMessages = agentMessages.findIndex(
+      (msg: any) => msg.id === message.id,
+    );
+    if (
+      indexInAgentMessages >= 0 &&
+      indexInAgentMessages < agentMessages.length - 1
+    ) {
       existingClaim.locked = true;
     }
   }
@@ -206,7 +218,10 @@ export function useStateRenderRegistry({
       const messageCache = {
         ...(store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}),
       };
-      messageCache[message.id] = { snapshot: snapshotForClaim, runId: effectiveRunId };
+      messageCache[message.id] = {
+        snapshot: snapshotForClaim,
+        runId: effectiveRunId,
+      };
       store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
     }
   }

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

@@ -64,19 +64,28 @@ export function useCoAgentStateRender<T = any>(
   dependencies?: any[],
 ): void {
   const { chatComponentsCache, availableAgents } = useContext(CopilotContext);
-  const { setCoAgentStateRender, removeCoAgentStateRender, coAgentStateRenders } =
-    useCoAgentStateRenders();
+  const {
+    setCoAgentStateRender,
+    removeCoAgentStateRender,
+    coAgentStateRenders,
+  } = useCoAgentStateRenders();
   const idRef = useRef<string>(randomId());
   const { setBannerError, addToast } = useToast();
 
   useEffect(() => {
-    if (availableAgents?.length && !availableAgents.some((a) => a.name === action.name)) {
+    if (
+      availableAgents?.length &&
+      !availableAgents.some((a) => a.name === action.name)
+    ) {
       const message = `(useCoAgentStateRender): Agent "${action.name}" not found. Make sure the agent exists and is properly configured.`;
 
       // Route to banner instead of toast for consistency
       const agentError = new CopilotKitAgentDiscoveryError({
         agentName: action.name,
-        availableAgents: availableAgents.map((a) => ({ name: a.name, id: a.id })),
+        availableAgents: availableAgents.map((a) => ({
+          name: a.name,
+          id: a.id,
+        })),
       });
       setBannerError(agentError);
     }
@@ -98,26 +107,28 @@ export function useCoAgentStateRender<T = any>(
   useEffect(() => {
     // Check for duplicates by comparing against all other actions
     const currentId = idRef.current;
-    const hasDuplicate = Object.entries(coAgentStateRenders).some(([id, otherAction]) => {
-      // Skip comparing with self
-      if (id === currentId) return false;
+    const hasDuplicate = Object.entries(coAgentStateRenders).some(
+      ([id, otherAction]) => {
+        // Skip comparing with self
+        if (id === currentId) return false;
 
-      // Different agent names are never duplicates
-      if (otherAction.name !== action.name) return false;
+        // Different agent names are never duplicates
+        if (otherAction.name !== action.name) return false;
 
-      // Same agent names:
-      const hasNodeName = !!action.nodeName;
-      const hasOtherNodeName = !!otherAction.nodeName;
+        // Same agent names:
+        const hasNodeName = !!action.nodeName;
+        const hasOtherNodeName = !!otherAction.nodeName;
 
-      // If neither has nodeName, they're duplicates
-      if (!hasNodeName && !hasOtherNodeName) return true;
+        // If neither has nodeName, they're duplicates
+        if (!hasNodeName && !hasOtherNodeName) return true;
 
-      // If one has nodeName and other doesn't, they're not duplicates
-      if (hasNodeName !== hasOtherNodeName) return false;
+        // If one has nodeName and other doesn't, they're not duplicates
+        if (hasNodeName !== hasOtherNodeName) return false;
 
-      // If both have nodeName, they're duplicates only if the names match
-      return action.nodeName === otherAction.nodeName;
-    });
+        // If both have nodeName, they're duplicates only if the names match
+        return action.nodeName === otherAction.nodeName;
+      },
+    );
 
     if (hasDuplicate) {
       const message = action.nodeName

package/src/hooks/use-coagent.ts

@@ -113,7 +113,9 @@ interface UseCoagentOptionsBase {
   };
 }
 
-interface WithInternalStateManagementAndInitial<T> extends UseCoagentOptionsBase {
+interface WithInternalStateManagementAndInitial<
+  T,
+> extends UseCoagentOptionsBase {
   /**
    * The initial state of the agent.
    */
@@ -202,7 +204,9 @@ export type HintFunction = (params: HintFunctionParams) => Message | undefined;
  * We call these shared state experiences "agentic copilots". To get started using agentic copilots, which
  * we refer to as CoAgents, checkout the documentation at https://docs.copilotkit.ai/coagents/quickstart/langgraph.
  */
-export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentReturnType<T> {
+export function useCoAgent<T = any>(
+  options: UseCoagentOptions<T>,
+): UseCoagentReturnType<T> {
   const { agent } = useAgent({ agentId: options.name });
   const { copilotkit } = useCopilotKit();
   const nodeName = useAgentNodeName(options.name);
@@ -238,8 +242,15 @@ export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentRe
   }, [options.config, options.configurable]);
 
   const externalStateStr = useMemo(
-    () => (isExternalStateManagement(options) ? JSON.stringify(options.state) : undefined),
-    [isExternalStateManagement(options) ? JSON.stringify(options.state) : undefined],
+    () =>
+      isExternalStateManagement(options)
+        ? JSON.stringify(options.state)
+        : undefined,
+    [
+      isExternalStateManagement(options)
+        ? JSON.stringify(options.state)
+        : undefined,
+    ],
   );
 
   // Sync internal state with external state if state management is external

package/src/hooks/use-configure-chat-suggestions.tsx

@@ -8,9 +8,13 @@ import { StaticSuggestionsConfig, Suggestion } from "@copilotkitnext/core";
 import { useCopilotContext } from "../context";
 import { useEffect, useMemo } from "react";
 
-type StaticSuggestionInput = Omit<Suggestion, "isLoading"> & Partial<Pick<Suggestion, "isLoading">>;
+type StaticSuggestionInput = Omit<Suggestion, "isLoading"> &
+  Partial<Pick<Suggestion, "isLoading">>;
 
-type StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig, "suggestions"> & {
+type StaticSuggestionsConfigInput = Omit<
+  StaticSuggestionsConfig,
+  "suggestions"
+> & {
   suggestions: StaticSuggestionInput[];
 };
 
@@ -34,7 +38,12 @@ type DynamicSuggestionsConfigInput = {
    * Whether the suggestions are available. Defaults to `enabled`.
    * @default enabled
    */
-  available?: "enabled" | "disabled" | "always" | "before-first-message" | "after-first-message";
+  available?:
+    | "enabled"
+    | "disabled"
+    | "always"
+    | "before-first-message"
+    | "after-first-message";
 
   /**
    * An optional class name to apply to the suggestions.
@@ -54,7 +63,8 @@ export function useConfigureChatSuggestions(
   const resolvedAgentId = existingConfig?.agentId ?? "default";
   const { copilotkit } = useCopilotKit();
 
-  const available = config.available === "enabled" ? "always" : config.available;
+  const available =
+    config.available === "enabled" ? "always" : config.available;
 
   const finalSuggestionConfig = {
     ...config,

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

@@ -132,10 +132,19 @@
  */
 import { useEffect, useRef, useState } from "react";
 import { Parameter } from "@copilotkit/shared";
-import { CatchAllFrontendAction, FrontendAction } from "../types/frontend-action";
+import {
+  CatchAllFrontendAction,
+  FrontendAction,
+} from "../types/frontend-action";
 import { useFrontendTool, UseFrontendToolArgs } from "./use-frontend-tool";
-import { useRenderToolCall, UseRenderToolCallArgs } from "./use-render-tool-call";
-import { useHumanInTheLoop, UseHumanInTheLoopArgs } from "./use-human-in-the-loop";
+import {
+  useRenderToolCall,
+  UseRenderToolCallArgs,
+} from "./use-render-tool-call";
+import {
+  useHumanInTheLoop,
+  UseHumanInTheLoopArgs,
+} from "./use-human-in-the-loop";
 import { useCopilotContext } from "../context";
 
 // Helper to determine which component and action config to use

package/src/hooks/use-copilot-additional-instructions.ts

@@ -65,7 +65,10 @@ export interface UseCopilotAdditionalInstructionsOptions {
  * Adds the given instructions to the Copilot context.
  */
 export function useCopilotAdditionalInstructions(
-  { instructions, available = "enabled" }: UseCopilotAdditionalInstructionsOptions,
+  {
+    instructions,
+    available = "enabled",
+  }: UseCopilotAdditionalInstructionsOptions,
   dependencies?: any[],
 ) {
   const { setAdditionalInstructions } = useCopilotContext();
@@ -73,13 +76,23 @@ export function useCopilotAdditionalInstructions(
   useEffect(() => {
     if (available === "disabled") return;
 
-    setAdditionalInstructions((prevInstructions) => [...(prevInstructions || []), instructions]);
+    setAdditionalInstructions((prevInstructions) => [
+      ...(prevInstructions || []),
+      instructions,
+    ]);
 
     return () => {
       setAdditionalInstructions(
         (prevInstructions) =>
-          prevInstructions?.filter((instruction) => instruction !== instructions) || [],
+          prevInstructions?.filter(
+            (instruction) => instruction !== instructions,
+          ) || [],
       );
     };
-  }, [available, instructions, setAdditionalInstructions, ...(dependencies || [])]);
+  }, [
+    available,
+    instructions,
+    setAdditionalInstructions,
+    ...(dependencies || []),
+  ]);
 }

package/src/hooks/use-copilot-authenticated-action.ts

@@ -45,7 +45,10 @@ export function useCopilotAuthenticatedAction_c<T extends Parameter[]>(
         return authConfig_c?.SignInComponent
           ? React.createElement(authConfig_c.SignInComponent, {
               onSignInComplete: (authState) => {
-                setAuthStates_c?.((prev) => ({ ...prev, [action.name]: authState }));
+                setAuthStates_c?.((prev) => ({
+                  ...prev,
+                  [action.name]: authState,
+                }));
                 if (pendingActionRef.current) {
                   executeAction(pendingActionRef.current);
                   pendingActionRef.current = null;

package/src/hooks/use-copilot-chat-headless_c.ts

@@ -213,7 +213,9 @@ const createNonFunctionalReturn = (): UseCopilotChatReturn_c => ({
  * const { messages, sendMessage, suggestions, interrupt } = useCopilotChatHeadless_c();
  * ```
  */
-function useCopilotChatHeadless_c(options: UseCopilotChatOptions_c = {}): UseCopilotChatReturn_c {
+function useCopilotChatHeadless_c(
+  options: UseCopilotChatOptions_c = {},
+): UseCopilotChatReturn_c {
   const { copilotApiConfig, setBannerError } = useCopilotContext();
 
   // Check if publicApiKey is available
@@ -251,7 +253,11 @@ function useCopilotChatHeadless_c(options: UseCopilotChatOptions_c = {}): UseCop
 }
 
 export { defaultSystemMessage, useCopilotChatHeadless_c };
-export type { UseCopilotChatOptions_c, UseCopilotChatReturn_c, MCPServerConfig };
+export type {
+  UseCopilotChatOptions_c,
+  UseCopilotChatReturn_c,
+  MCPServerConfig,
+};
 
 const noKeyWarning = () => {
   styledConsole.logCopilotKitPlatformMessage();

package/src/hooks/use-copilot-chat-suggestions.tsx

@@ -67,9 +67,13 @@ import {
 import { useEffect } from "react";
 import { StaticSuggestionsConfig, Suggestion } from "@copilotkitnext/core";
 
-type StaticSuggestionInput = Omit<Suggestion, "isLoading"> & Partial<Pick<Suggestion, "isLoading">>;
+type StaticSuggestionInput = Omit<Suggestion, "isLoading"> &
+  Partial<Pick<Suggestion, "isLoading">>;
 
-type StaticSuggestionsConfigInput = Omit<StaticSuggestionsConfig, "suggestions"> & {
+type StaticSuggestionsConfigInput = Omit<
+  StaticSuggestionsConfig,
+  "suggestions"
+> & {
   suggestions: StaticSuggestionInput[];
 };
 
@@ -93,7 +97,12 @@ type DynamicSuggestionsConfigInput = {
    * Whether the suggestions are available. Defaults to `enabled`.
    * @default enabled
    */
-  available?: "enabled" | "disabled" | "always" | "before-first-message" | "after-first-message";
+  available?:
+    | "enabled"
+    | "disabled"
+    | "always"
+    | "before-first-message"
+    | "after-first-message";
 
   /**
    * An optional class name to apply to the suggestions.
@@ -113,7 +122,8 @@ export function useCopilotChatSuggestions(
   const resolvedAgentId = existingConfig?.agentId ?? "default";
 
   const available =
-    (config.available === "enabled" ? "always" : config.available) ?? "before-first-message";
+    (config.available === "enabled" ? "always" : config.available) ??
+    "before-first-message";
 
   const finalSuggestionConfig = {
     ...config,

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

@@ -101,7 +101,9 @@ export type UseCopilotChatReturn = Omit<
  * **Open Source Friendly** - Works without requiring a `publicApiKey`.
  */
 // TODO: Do we need this? If so, does it work properly? test.
-export function useCopilotChat(options: UseCopilotChatOptions = {}): UseCopilotChatReturn {
+export function useCopilotChat(
+  options: UseCopilotChatOptions = {},
+): UseCopilotChatReturn {
   const {
     visibleMessages,
     appendMessage,