@copilotkit/react-core 0.0.0-fix-debug-infosys-20251107151227 → 0.0.0-fix-restore-handle-method-node-http-20251222114321

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

@@ -1,23 +1,67 @@
-import { useRef, useEffect, useCallback, useState, useMemo } from "react";
-import { AgentSession, useCopilotContext, CopilotContextParams } from "../context/copilot-context";
-import { useCopilotMessagesContext, CopilotMessagesContextParams } from "../context";
+import { useRef, useEffect, useCallback, useMemo, useState, createElement } from "react";
+import { useCopilotContext } from "../context/copilot-context";
 import { SystemMessageFunction } from "../types";
-import { useChat, AppendMessageOptions } from "./use-chat";
-import { defaultCopilotContextCategories } from "../components";
-import { CoAgentStateRenderHandlerArguments } from "@copilotkit/shared";
 import { useAsyncCallback } from "../components/error-boundary/error-utils";
-import { reloadSuggestions as generateSuggestions } from "../utils";
-import type { SuggestionItem } from "../utils";
-
 import { Message } from "@copilotkit/shared";
-import {
-  Role as gqlRole,
-  TextMessage,
-  aguiToGQL,
-  gqlToAGUI,
-  Message as DeprecatedGqlMessage,
-} from "@copilotkit/runtime-client-gql";
+import { gqlToAGUI, Message as DeprecatedGqlMessage } from "@copilotkit/runtime-client-gql";
 import { useLangGraphInterruptRender } from "./use-langgraph-interrupt-render";
+import {
+  useAgent,
+  useCopilotChatConfiguration,
+  useCopilotKit,
+  useRenderCustomMessages,
+  useSuggestions,
+} from "@copilotkitnext/react";
+import { Suggestion } from "@copilotkitnext/core";
+import { useLazyToolRenderer } from "./use-lazy-tool-renderer";
+import { AbstractAgent, AGUIConnectNotImplementedError } from "@ag-ui/client";
+import {
+  CoAgentStateRenderBridge,
+  type CoAgentStateRenderBridgeProps,
+} from "./use-coagent-state-render-bridge";
+
+/**
+ * The type of suggestions to use in the chat.
+ *
+ * `auto` - Suggestions are generated automatically.
+ * `manual` - Suggestions are controlled programmatically.
+ * `SuggestionItem[]` - Static suggestions array.
+ */
+export type ChatSuggestions = "auto" | "manual" | Omit<Suggestion, "isLoading">[];
+
+export interface AppendMessageOptions {
+  /**
+   * Whether to run the chat completion after appending the message. Defaults to `true`.
+   */
+  followUp?: boolean;
+  /**
+   * Whether to clear the suggestions after appending the message. Defaults to `true`.
+   */
+  clearSuggestions?: boolean;
+}
+
+export interface OnStopGenerationArguments {
+  /**
+   * The name of the currently executing agent.
+   */
+  currentAgentName: string | undefined;
+
+  /**
+   * The messages in the chat.
+   */
+  messages: Message[];
+}
+
+export type OnReloadMessagesArguments = OnStopGenerationArguments & {
+  /**
+   * The message on which "regenerate" was pressed
+   */
+  messageId: string;
+};
+
+export type OnStopGeneration = (args: OnStopGenerationArguments) => void;
+
+export type OnReloadMessages = (args: OnReloadMessagesArguments) => void;
 
 export interface UseCopilotChatOptions {
   /**
@@ -46,6 +90,29 @@ export interface UseCopilotChatOptions {
    * Disables inclusion of CopilotKit’s default system message. When true, no system message is sent (this also suppresses any custom message from <code>makeSystemMessage</code>).
    */
   disableSystemMessage?: boolean;
+  /**
+   * Controls the behavior of suggestions in the chat interface.
+   *
+   * `auto` (default) - Suggestions are generated automatically:
+   *   - When the chat is first opened (empty state)
+   *   - After each message exchange completes
+   *   - Uses configuration from `useCopilotChatSuggestions` hooks
+   *
+   * `manual` - Suggestions are controlled programmatically:
+   *   - Use `setSuggestions()` to set custom suggestions
+   *   - Use `generateSuggestions()` to trigger AI generation
+   *   - Access via `useCopilotChat` hook
+   *
+   * `SuggestionItem[]` - Static suggestions array:
+   *   - Always shows the same suggestions
+   *   - No AI generation involved
+   */
+  suggestions?: ChatSuggestions;
+
+  onInProgress?: (isLoading: boolean) => void;
+  onSubmitMessage?: (messageContent: string) => Promise<void> | void;
+  onStopGeneration?: OnStopGeneration;
+  onReloadMessages?: OnReloadMessages;
 }
 
 export interface MCPServerConfig {
@@ -53,6 +120,14 @@ export interface MCPServerConfig {
   apiKey?: string;
 }
 
+// Old suggestion item interface, for returning from useCopilotChatInternal
+interface SuggestionItem {
+  title: string;
+  message: string;
+  partial?: boolean;
+  className?: string;
+}
+
 export interface UseCopilotChatReturn {
   /**
    * @deprecated use `messages` instead, this is an old non ag-ui version of the messages
@@ -161,6 +236,18 @@ export interface UseCopilotChatReturn {
    */
   isLoading: boolean;
 
+  /**
+   * Whether the chat agent is available to generate responses
+   *
+   * ```tsx
+   * if (isAvailable) {
+   *   console.log("Loading...");
+   * } else {
+   *   console.log("Not loading");
+   * }
+   */
+  isAvailable: boolean;
+
   /** Manually trigger chat completion (advanced usage) */
   runChatCompletion: () => Promise<Message[]>;
 
@@ -174,13 +261,13 @@ export interface UseCopilotChatReturn {
    * Current suggestions array
    * Use this to read the current suggestions or in conjunction with setSuggestions for manual control
    */
-  suggestions: SuggestionItem[];
+  suggestions: Suggestion[];
 
   /**
    * Manually set suggestions
    * Useful for manual mode or custom suggestion workflows
    */
-  setSuggestions: (suggestions: SuggestionItem[]) => void;
+  setSuggestions: (suggestions: Omit<Suggestion, "isLoading">[]) => void;
 
   /**
    * Trigger AI-powered suggestion generation
@@ -205,287 +292,296 @@ export interface UseCopilotChatReturn {
 
   /** Interrupt content for human-in-the-loop workflows */
   interrupt: string | React.ReactElement | null;
-}
 
-let globalSuggestionPromise: Promise<void> | null = null;
-
-export function useCopilotChat(options: UseCopilotChatOptions = {}): UseCopilotChatReturn {
-  const makeSystemMessage = options.makeSystemMessage ?? defaultSystemMessage;
-  const {
-    getContextString,
-    getFunctionCallHandler,
-    copilotApiConfig,
-    isLoading,
-    setIsLoading,
-    chatInstructions,
-    actions,
-    coagentStatesRef,
-    setCoagentStatesWithRef,
-    coAgentStateRenders,
-    agentSession,
-    setAgentSession,
-    forwardedParameters,
-    agentLock,
-    threadId,
-    setThreadId,
-    runId,
-    setRunId,
-    chatAbortControllerRef,
-    extensions,
-    setExtensions,
-    langGraphInterruptAction,
-    setLangGraphInterruptAction,
-    chatSuggestionConfiguration,
-
-    runtimeClient,
-  } = useCopilotContext();
-  const { messages, setMessages, suggestions, setSuggestions } = useCopilotMessagesContext();
-
-  // Simple state for MCP servers (keep for interface compatibility)
-  const [mcpServers, setLocalMcpServers] = useState<MCPServerConfig[]>([]);
-
-  // Basic suggestion state for programmatic control
-  const suggestionsAbortControllerRef = useRef<AbortController | null>(null);
-  const isLoadingSuggestionsRef = useRef<boolean>(false);
-
-  const abortSuggestions = useCallback(
-    (clear: boolean = true) => {
-      suggestionsAbortControllerRef.current?.abort("suggestions aborted by user");
-      suggestionsAbortControllerRef.current = null;
-      if (clear) {
-        setSuggestions([]);
-      }
-    },
-    [setSuggestions],
-  );
+  agent?: ReturnType<typeof useAgent>["agent"];
 
-  // Memoize context with stable dependencies only
-  const stableContext = useMemo(() => {
-    return {
-      actions,
-      copilotApiConfig,
-      chatSuggestionConfiguration,
-      messages,
-      setMessages,
-      getContextString,
-      runtimeClient,
-    };
-  }, [
-    JSON.stringify(Object.keys(actions)),
-    copilotApiConfig.chatApiEndpoint,
-    messages.length,
-    Object.keys(chatSuggestionConfiguration).length,
-  ]);
+  threadId?: string;
+}
 
-  // Programmatic suggestion generation function
-  const generateSuggestionsFunc = useCallback(async () => {
-    // If a global suggestion is running, ignore this call
-    if (globalSuggestionPromise) {
-      return globalSuggestionPromise;
-    }
+export function useCopilotChatInternal({
+  suggestions,
+  onInProgress,
+  onSubmitMessage,
+  onStopGeneration,
+  onReloadMessages,
+}: UseCopilotChatOptions = {}): UseCopilotChatReturn {
+  const { copilotkit } = useCopilotKit();
+  const { threadId, agentSession } = useCopilotContext();
+  const existingConfig = useCopilotChatConfiguration();
+  const [agentAvailable, setAgentAvailable] = useState(false);
+
+  // Apply priority: props > existing config > defaults
+  const resolvedAgentId = existingConfig?.agentId ?? "default";
+  const { agent } = useAgent({ agentId: resolvedAgentId });
 
-    globalSuggestionPromise = (async () => {
+  useEffect(() => {
+    const connect = async (agent: AbstractAgent) => {
+      setAgentAvailable(false);
       try {
-        abortSuggestions();
-        isLoadingSuggestionsRef.current = true;
-        suggestionsAbortControllerRef.current = new AbortController();
-
-        setSuggestions([]);
-
-        await generateSuggestions(
-          stableContext as CopilotContextParams & CopilotMessagesContextParams,
-          chatSuggestionConfiguration,
-          setSuggestions,
-          suggestionsAbortControllerRef,
-        );
+        await copilotkit.connectAgent({ agent });
+        setAgentAvailable(true);
       } catch (error) {
-        // Re-throw to allow caller to handle the error
-        throw error;
-      } finally {
-        isLoadingSuggestionsRef.current = false;
-        globalSuggestionPromise = null;
+        if (error instanceof AGUIConnectNotImplementedError) {
+          // connect not implemented, ignore
+        } else {
+          throw error;
+        }
       }
-    })();
+    };
+    if (agent && existingConfig?.threadId && agent.threadId !== existingConfig.threadId) {
+      agent.threadId = existingConfig.threadId;
+      connect(agent);
+    }
+    return () => {};
+  }, [existingConfig?.threadId, agent, copilotkit, resolvedAgentId]);
 
-    return globalSuggestionPromise;
-  }, [stableContext, chatSuggestionConfiguration, setSuggestions, abortSuggestions]);
+  useEffect(() => {
+    onInProgress?.(Boolean(agent?.isRunning));
+  }, [agent?.isRunning, onInProgress]);
 
-  const resetSuggestions = useCallback(() => {
-    setSuggestions([]);
-  }, [setSuggestions]);
+  const interrupt = useLangGraphInterruptRender(agent);
 
-  // MCP servers logic
-  useEffect(() => {
-    if (mcpServers.length > 0) {
-      const serversCopy = [...mcpServers];
-      copilotApiConfig.mcpServers = serversCopy;
-      if (!copilotApiConfig.properties) {
-        copilotApiConfig.properties = {};
-      }
-      copilotApiConfig.properties.mcpServers = serversCopy;
-    }
-  }, [mcpServers, copilotApiConfig]);
-
-  const setMcpServers = useCallback((servers: MCPServerConfig[]) => {
-    setLocalMcpServers(servers);
-  }, []);
-
-  // Move these function declarations above the useChat call
-  const onCoAgentStateRender = useAsyncCallback(
-    async (args: CoAgentStateRenderHandlerArguments) => {
-      const { name, nodeName, state } = args;
-      let action = Object.values(coAgentStateRenders).find(
-        (action) => action.name === name && action.nodeName === nodeName,
+  const reset = () => {
+    agent?.setMessages([]);
+    agent?.setState(null);
+  };
+
+  const deleteMessage = useCallback(
+    (messageId: string) => {
+      const filteredMessages = (agent?.messages ?? []).filter(
+        (message) => message.id !== messageId,
       );
-      if (!action) {
-        action = Object.values(coAgentStateRenders).find(
-          (action) => action.name === name && !action.nodeName,
-        );
-      }
-      if (action) {
-        await action.handler?.({ state, nodeName });
-      }
+      agent?.setMessages(filteredMessages);
     },
-    [coAgentStateRenders],
+    [agent?.setMessages, agent?.messages],
   );
 
-  const makeSystemMessageCallback = useCallback(() => {
-    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
-    // this always gets the latest context string
-    const contextString = getContextString([], defaultCopilotContextCategories); // TODO: make the context categories configurable
-
-    return new TextMessage({
-      content: systemMessageMaker(contextString, chatInstructions),
-      role: gqlRole.System,
-    });
-  }, [getContextString, makeSystemMessage, chatInstructions]);
-
-  const deleteMessage = useCallback(
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = useCallback(
     (messageId: string) => {
-      setMessages((prev) => prev.filter((message) => message.id !== messageId));
+      return latestDelete.current(messageId);
     },
-    [setMessages],
+    [latestDelete],
   );
 
-  // Get chat helpers with updated config
-  const { append, reload, stop, runChatCompletion } = useChat({
-    ...options,
-    actions: Object.values(actions),
-    copilotConfig: copilotApiConfig,
-    initialMessages: aguiToGQL(options.initialMessages || []),
-    onFunctionCall: getFunctionCallHandler(),
-    onCoAgentStateRender,
-    messages,
-    setMessages,
-    makeSystemMessageCallback,
-    isLoading,
-    setIsLoading,
-    coagentStatesRef,
-    setCoagentStatesWithRef,
-    agentSession,
-    setAgentSession,
-    forwardedParameters,
-    threadId,
-    setThreadId,
-    runId,
-    setRunId,
-    chatAbortControllerRef,
-    agentLock,
-    extensions,
-    setExtensions,
-    langGraphInterruptAction,
-    setLangGraphInterruptAction,
-    disableSystemMessage: options.disableSystemMessage,
-  });
+  const currentSuggestions = useSuggestions({ agentId: resolvedAgentId });
 
-  const latestAppend = useUpdatedRef(append);
-  const latestAppendFunc = useAsyncCallback(
-    async (message: DeprecatedGqlMessage, options?: AppendMessageOptions) => {
-      abortSuggestions(options?.clearSuggestions);
-      return await latestAppend.current(message, options);
+  const reload = useAsyncCallback(
+    async (reloadMessageId: string): Promise<void> => {
+      const messages = agent?.messages ?? [];
+      // TODO: get isLoading
+      const isLoading = false;
+      if (isLoading || messages.length === 0) {
+        return;
+      }
+
+      const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
+      if (reloadMessageIndex === -1) {
+        console.warn(`Message with id ${reloadMessageId} not found`);
+        return;
+      }
+
+      const reloadMessageRole = messages[reloadMessageIndex].role;
+      if (reloadMessageRole !== "assistant") {
+        console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
+        return;
+      }
+      let historyCutoff: Message[] = [messages[0]];
+
+      if (messages.length > 2 && reloadMessageIndex !== 0) {
+        // message to regenerate from is now first.
+        // Work backwards to find the first the closest user message
+        const lastUserMessageBeforeRegenerate = messages
+          .slice(0, reloadMessageIndex)
+          .reverse()
+          .find((msg) => msg.role === "user");
+
+        if (!lastUserMessageBeforeRegenerate) {
+          historyCutoff = [messages[0]];
+        } else {
+          const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
+            (msg) => msg.id === lastUserMessageBeforeRegenerate.id,
+          );
+          // Include the user message, remove everything after it
+          historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
+        }
+      } else if (messages.length > 2 && reloadMessageIndex === 0) {
+        historyCutoff = [messages[0], messages[1]];
+      }
+
+      agent?.setMessages(historyCutoff);
+
+      if (agent) {
+        copilotkit.runAgent({ agent });
+      }
+      return;
     },
-    [latestAppend],
+    [agent?.setMessages, copilotkit?.runAgent],
   );
 
   const latestSendMessageFunc = useAsyncCallback(
     async (message: Message, options?: AppendMessageOptions) => {
-      abortSuggestions(options?.clearSuggestions);
-      return await latestAppend.current(aguiToGQL([message])[0] as DeprecatedGqlMessage, options);
-    },
-    [latestAppend],
-  );
-
-  const latestReload = useUpdatedRef(reload);
-  const latestReloadFunc = useAsyncCallback(
-    async (messageId: string) => {
-      return await latestReload.current(messageId);
+      if (!agent) return;
+      const followUp = options?.followUp ?? true;
+      if (options?.clearSuggestions) {
+        copilotkit.clearSuggestions(resolvedAgentId);
+      }
+      agent?.addMessage(message);
+      if (followUp) {
+        try {
+          await copilotkit.runAgent({ agent });
+        } catch (error) {
+          console.error("CopilotChat: runAgent failed", error);
+        }
+      }
+      if (onSubmitMessage) {
+        const content =
+          typeof message.content === "string"
+            ? message.content
+            : message.content && "text" in message.content
+              ? message.content.text
+              : message.content && "filename" in message.content
+                ? message.content.filename
+                : "";
+        onSubmitMessage(content);
+      }
     },
-    [latestReload],
+    [agent, copilotkit, resolvedAgentId, onSubmitMessage],
   );
 
-  const latestStop = useUpdatedRef(stop);
-  const latestStopFunc = useCallback(() => {
-    return latestStop.current();
-  }, [latestStop]);
-
-  const latestDelete = useUpdatedRef(deleteMessage);
-  const latestDeleteFunc = useCallback(
-    (messageId: string) => {
-      return latestDelete.current(messageId);
+  const latestAppendFunc = useAsyncCallback(
+    async (message: DeprecatedGqlMessage, options?: AppendMessageOptions) => {
+      return latestSendMessageFunc(gqlToAGUI([message])[0], options);
     },
-    [latestDelete],
+    [latestSendMessageFunc],
   );
 
-  const latestSetMessages = useUpdatedRef(setMessages);
   const latestSetMessagesFunc = useCallback(
     (messages: Message[] | DeprecatedGqlMessage[]) => {
       if (messages.every((message) => message instanceof DeprecatedGqlMessage)) {
-        return latestSetMessages.current(messages as DeprecatedGqlMessage[]);
+        return agent?.setMessages?.(gqlToAGUI(messages));
       }
-      return latestSetMessages.current(aguiToGQL(messages));
+      return agent?.setMessages?.(messages);
     },
-    [latestSetMessages],
+    [agent?.setMessages, agent],
   );
 
-  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
-  const latestRunChatCompletionFunc = useAsyncCallback(async () => {
-    return await latestRunChatCompletion.current!();
-  }, [latestRunChatCompletion]);
-
-  const reset = useCallback(() => {
-    latestStopFunc();
-    setMessages([]);
-    setRunId(null);
-    setCoagentStatesWithRef({});
-    let initialAgentSession: AgentSession | null = null;
-    if (agentLock) {
-      initialAgentSession = {
-        agentName: agentLock,
-      };
-    }
-    setAgentSession(initialAgentSession);
-    // Reset suggestions when chat is reset
-    resetSuggestions();
-  }, [
-    latestStopFunc,
-    setMessages,
-    setThreadId,
-    setCoagentStatesWithRef,
-    setAgentSession,
-    agentLock,
-    resetSuggestions,
-  ]);
+  const latestReload = useUpdatedRef(reload);
+  const latestReloadFunc = useAsyncCallback(
+    async (messageId: string) => {
+      onReloadMessages?.({
+        messageId,
+        currentAgentName: agent?.agentId,
+        messages: agent?.messages ?? [],
+      });
+      return await latestReload.current(messageId);
+    },
+    [latestReload, agent, onReloadMessages],
+  );
+
+  const latestStopFunc = useCallback(() => {
+    onStopGeneration?.({
+      currentAgentName: agent?.agentId,
+      messages: agent?.messages ?? [],
+    });
+    return agent?.abortRun?.();
+  }, [onStopGeneration, agent]);
 
   const latestReset = useUpdatedRef(reset);
   const latestResetFunc = useCallback(() => {
     return latestReset.current();
   }, [latestReset]);
 
-  const interrupt = useLangGraphInterruptRender();
+  const lazyToolRendered = useLazyToolRenderer();
+  const renderCustomMessage = useRenderCustomMessages();
+  const legacyCustomMessageRenderer = useLegacyCoagentRenderer({
+    copilotkit,
+    agent,
+    agentId: resolvedAgentId,
+    threadId: existingConfig?.threadId ?? threadId,
+  });
+  const allMessages = agent?.messages ?? [];
+  const resolvedMessages = useMemo(() => {
+    let processedMessages = allMessages.map((message) => {
+      if (message.role !== "assistant") {
+        return message;
+      }
+
+      const lazyRendered = lazyToolRendered(message, allMessages);
+      if (lazyRendered) {
+        const renderedGenUi = lazyRendered();
+        if (renderedGenUi) {
+          return { ...message, generativeUI: () => renderedGenUi };
+        }
+      }
+
+      const bridgeRenderer =
+        legacyCustomMessageRenderer || renderCustomMessage
+          ? () => {
+              const customRender = renderCustomMessage?.({
+                message,
+                position: "before",
+              });
+              if (customRender) {
+                return customRender;
+              }
+              return legacyCustomMessageRenderer?.({ message, position: "before" });
+            }
+          : null;
+
+      if (bridgeRenderer) {
+        return { ...message, generativeUI: bridgeRenderer };
+      }
+      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,
+    //   ];
+    // }
+
+    return processedMessages;
+  }, [
+    agent?.messages,
+    lazyToolRendered,
+    allMessages,
+    renderCustomMessage,
+    // legacyCustomMessageRenderer,
+    resolvedAgentId,
+  ]);
 
+  const renderedSuggestions = useMemo(() => {
+    if (Array.isArray(suggestions)) {
+      return {
+        suggestions: suggestions.map((s) => ({ ...s, isLoading: false })),
+        isLoading: false,
+      };
+    }
+    return currentSuggestions;
+  }, [suggestions, currentSuggestions]);
+
+  // @ts-ignore
   return {
-    visibleMessages: messages,
-    messages: gqlToAGUI(messages, actions, coAgentStateRenders),
+    messages: resolvedMessages,
     sendMessage: latestSendMessageFunc,
     appendMessage: latestAppendFunc,
     setMessages: latestSetMessagesFunc,
@@ -493,16 +589,19 @@ export function useCopilotChat(options: UseCopilotChatOptions = {}): UseCopilotC
     stopGeneration: latestStopFunc,
     reset: latestResetFunc,
     deleteMessage: latestDeleteFunc,
-    runChatCompletion: latestRunChatCompletionFunc,
-    isLoading,
-    mcpServers,
-    setMcpServers,
-    suggestions,
-    setSuggestions,
-    generateSuggestions: generateSuggestionsFunc,
-    resetSuggestions,
-    isLoadingSuggestions: isLoadingSuggestionsRef.current,
+    isAvailable: agentAvailable,
+    isLoading: Boolean(agent?.isRunning),
+    // mcpServers,
+    // setMcpServers,
+    suggestions: renderedSuggestions.suggestions,
+    setSuggestions: (suggestions: Omit<Suggestion, "isLoading">[]) =>
+      copilotkit.addSuggestionsConfig({ suggestions }),
+    generateSuggestions: async () => copilotkit.reloadSuggestions(resolvedAgentId),
+    resetSuggestions: () => copilotkit.clearSuggestions(resolvedAgentId),
+    isLoadingSuggestions: renderedSuggestions.isLoading,
     interrupt,
+    agent,
+    threadId,
   };
 }
 
@@ -518,6 +617,54 @@ function useUpdatedRef<T>(value: T) {
   return ref;
 }
 
+type LegacyRenderParams = {
+  message: Message;
+  position: "before" | "after";
+};
+
+type LegacyRenderer = ((args: LegacyRenderParams) => any) | null;
+
+function useLegacyCoagentRenderer({
+  copilotkit,
+  agent,
+  agentId,
+  threadId,
+}: {
+  copilotkit: ReturnType<typeof useCopilotKit>["copilotkit"];
+  agent?: AbstractAgent;
+  agentId: string;
+  threadId?: string;
+}): LegacyRenderer {
+  return useMemo(() => {
+    if (!copilotkit || !agent) {
+      return null;
+    }
+
+    return ({ message, position }: LegacyRenderParams) => {
+      const effectiveThreadId = threadId ?? agent.threadId ?? "default";
+      const existingRunId = copilotkit.getRunIdForMessage(agentId, effectiveThreadId, message.id);
+      const runId = existingRunId || `pending:${message.id}`;
+      const messageIndex = Math.max(
+        agent.messages.findIndex((msg) => msg.id === message.id),
+        0,
+      );
+
+      const bridgeProps: CoAgentStateRenderBridgeProps = {
+        message: message as any,
+        position,
+        runId,
+        messageIndex,
+        messageIndexInRun: 0,
+        numberOfMessagesInRun: 1,
+        agentId,
+        stateSnapshot: (message as any).state,
+      };
+
+      return createElement(CoAgentStateRenderBridge, bridgeProps) as any;
+    };
+  }, [agent, agentId, copilotkit, threadId]);
+}
+
 export function defaultSystemMessage(
   contextString: string,
   additionalInstructions?: string,