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

package/src/context/coagent-state-renders-context.tsx

@@ -0,0 +1,76 @@
+import React, {
+  createContext,
+  useContext,
+  useCallback,
+  useState,
+  useRef,
+  ReactNode,
+  RefObject,
+} from "react";
+import { CoAgentStateRender } from "../types/coagent-action";
+
+interface StateRenderClaim {
+  stateRenderId: string;
+  stateSnapshot?: any;
+  runId?: string;
+  locked?: boolean;
+}
+
+type ClaimsRef = Record<string, StateRenderClaim>;
+
+export interface CoAgentStateRendersContextValue {
+  coAgentStateRenders: Record<string, CoAgentStateRender<any>>;
+  setCoAgentStateRender: (id: string, stateRender: CoAgentStateRender<any>) => void;
+  removeCoAgentStateRender: (id: string) => void;
+  claimsRef: RefObject<ClaimsRef>;
+}
+
+const CoAgentStateRendersContext = createContext<CoAgentStateRendersContextValue | undefined>(
+  undefined,
+);
+
+export function CoAgentStateRendersProvider({ children }: { children: ReactNode }) {
+  const [coAgentStateRenders, setCoAgentStateRenders] = useState<
+    Record<string, CoAgentStateRender<any>>
+  >({});
+
+  const setCoAgentStateRender = useCallback((id: string, stateRender: CoAgentStateRender<any>) => {
+    setCoAgentStateRenders((prevPoints) => ({
+      ...prevPoints,
+      [id]: stateRender,
+    }));
+  }, []);
+
+  const removeCoAgentStateRender = useCallback((id: string) => {
+    setCoAgentStateRenders((prevPoints) => {
+      const newPoints = { ...prevPoints };
+      delete newPoints[id];
+      return newPoints;
+    });
+  }, []);
+
+  const claimsRef = useRef<ClaimsRef>({});
+
+  return (
+    <CoAgentStateRendersContext.Provider
+      value={{
+        coAgentStateRenders,
+        setCoAgentStateRender,
+        removeCoAgentStateRender,
+        claimsRef,
+      }}
+    >
+      {children}
+    </CoAgentStateRendersContext.Provider>
+  );
+}
+
+export function useCoAgentStateRenders() {
+  const context = useContext(CoAgentStateRendersContext);
+  if (!context) {
+    throw new Error("useCoAgentStateRenders must be used within CoAgentStateRendersProvider");
+  }
+  return context;
+}
+
+export { CoAgentStateRendersContext };

package/src/context/copilot-context.tsx

@@ -22,10 +22,10 @@ import {
 } from "@copilotkit/runtime-client-gql";
 import { Agent } from "@copilotkit/runtime-client-gql";
 import {
-  LangGraphInterruptAction,
+  LangGraphInterruptRender,
   LangGraphInterruptActionSetter,
+  QueuedInterruptEvent,
 } from "../types/interrupt-action";
-import { SuggestionItem } from "../utils/suggestions";
 
 /**
  * Interface for the configuration of the Copilot API.
@@ -95,10 +95,10 @@ export interface CopilotApiConfig {
 }
 
 export type InChatRenderFunction<TProps = ActionRenderProps<any> | CatchAllActionRenderProps<any>> =
-  (props: TProps) => string | JSX.Element;
+  (props: TProps) => string | React.JSX.Element;
 export type CoagentInChatRenderFunction = (
   props: CoAgentStateRenderProps<any>,
-) => string | JSX.Element | undefined | null;
+) => string | React.JSX.Element | undefined | null;
 
 export interface ChatComponentsCache {
   actions: Record<string, InChatRenderFunction | string>;
@@ -127,10 +127,9 @@ export interface CopilotContextParams {
   setAction: (id: string, action: FrontendAction<any>) => void;
   removeAction: (id: string) => void;
 
-  // coagent actions
-  coAgentStateRenders: Record<string, CoAgentStateRender<any>>;
-  setCoAgentStateRender: (id: string, stateRender: CoAgentStateRender<any>) => void;
-  removeCoAgentStateRender: (id: string) => void;
+  // registered actions for component-based rendering
+  setRegisteredActions: (actionConfig: any) => string;
+  removeRegisteredAction: (actionKey: string) => void;
 
   chatComponentsCache: React.RefObject<ChatComponentsCache>;
 
@@ -195,9 +194,6 @@ export interface CopilotContextParams {
   // i.e. when using `stop()` from `useChat`
   chatAbortControllerRef: React.MutableRefObject<AbortController | null>;
 
-  // runtime
-  runtimeClient: CopilotRuntimeClient;
-
   /**
    * The forwarded parameters to use for the task.
    */
@@ -221,9 +217,12 @@ export interface CopilotContextParams {
 
   extensions: ExtensionsInput;
   setExtensions: React.Dispatch<React.SetStateAction<ExtensionsInput>>;
-  langGraphInterruptAction: LangGraphInterruptAction | null;
-  setLangGraphInterruptAction: LangGraphInterruptActionSetter;
-  removeLangGraphInterruptAction: (threadId: string) => void;
+  interruptActions: Record<string, LangGraphInterruptRender>;
+  setInterruptAction: LangGraphInterruptActionSetter;
+  removeInterruptAction: (actionId: string) => void;
+  interruptEventQueue: Record<string, QueuedInterruptEvent[]>;
+  addInterruptEvent: (queuedEvent: QueuedInterruptEvent) => void;
+  resolveInterruptEvent: (threadId: string, eventId: string, response: string) => void;
 
   /**
    * Optional trace handler for comprehensive debugging and observability.
@@ -246,9 +245,8 @@ const emptyCopilotContext: CopilotContextParams = {
   setAction: () => {},
   removeAction: () => {},
 
-  coAgentStateRenders: {},
-  setCoAgentStateRender: () => {},
-  removeCoAgentStateRender: () => {},
+  setRegisteredActions: () => "",
+  removeRegisteredAction: () => {},
 
   chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },
   getContextString: (documents: DocumentPointer[], categories: string[]) =>
@@ -271,7 +269,6 @@ const emptyCopilotContext: CopilotContextParams = {
   getDocumentsContext: (categories: string[]) => returnAndThrowInDebug([]),
   addDocumentContext: () => returnAndThrowInDebug(""),
   removeDocumentContext: () => {},
-  runtimeClient: {} as any,
 
   copilotApiConfig: new (class implements CopilotApiConfig {
     get chatApiEndpoint(): string {
@@ -306,9 +303,12 @@ const emptyCopilotContext: CopilotContextParams = {
   availableAgents: [],
   extensions: {},
   setExtensions: () => {},
-  langGraphInterruptAction: null,
-  setLangGraphInterruptAction: () => {},
-  removeLangGraphInterruptAction: () => {},
+  interruptActions: {},
+  setInterruptAction: () => {},
+  removeInterruptAction: () => {},
+  interruptEventQueue: {},
+  addInterruptEvent: () => {},
+  resolveInterruptEvent: () => {},
   onError: () => {},
   bannerError: null,
   setBannerError: () => {},

package/src/context/copilot-messages-context.tsx

@@ -4,13 +4,13 @@
 
 import { Message } from "@copilotkit/runtime-client-gql";
 import React from "react";
-import { SuggestionItem } from "../utils/suggestions";
+import { Suggestion } from "@copilotkitnext/core";
 
 export interface CopilotMessagesContextParams {
   messages: Message[];
   setMessages: React.Dispatch<React.SetStateAction<Message[]>>; // suggestions state
-  suggestions: SuggestionItem[];
-  setSuggestions: React.Dispatch<React.SetStateAction<SuggestionItem[]>>;
+  suggestions: Suggestion[];
+  setSuggestions: React.Dispatch<React.SetStateAction<Suggestion[]>>;
 }
 
 const emptyCopilotContext: CopilotMessagesContextParams = {

package/src/context/index.ts

@@ -1,8 +1,16 @@
 export { CopilotContext, useCopilotContext } from "./copilot-context";
 export { CopilotMessagesContext, useCopilotMessagesContext } from "./copilot-messages-context";
+export {
+  CoAgentStateRendersContext,
+  CoAgentStateRendersProvider,
+  useCoAgentStateRenders,
+} from "./coagent-state-renders-context";
+export { ThreadsContext, ThreadsProvider, useThreads } from "./threads-context";
 export type {
   CopilotContextParams,
   CoagentInChatRenderFunction,
   CopilotApiConfig,
 } from "./copilot-context";
 export type { CopilotMessagesContextParams } from "./copilot-messages-context";
+export type { CoAgentStateRendersContextValue } from "./coagent-state-renders-context";
+export type { ThreadsContextValue, ThreadsProviderProps } from "./threads-context";

package/src/context/threads-context.tsx

@@ -0,0 +1,41 @@
+import React, { createContext, useContext, useState, ReactNode, SetStateAction } from "react";
+import { randomUUID } from "@copilotkit/shared";
+
+export interface ThreadsContextValue {
+  threadId: string;
+  setThreadId: (value: SetStateAction<string>) => void;
+}
+
+const ThreadsContext = createContext<ThreadsContextValue | undefined>(undefined);
+
+export interface ThreadsProviderProps {
+  children: ReactNode;
+  threadId?: string;
+}
+
+export function ThreadsProvider({ children, threadId: explicitThreadId }: ThreadsProviderProps) {
+  const [internalThreadId, setThreadId] = useState<string>(explicitThreadId ?? randomUUID());
+
+  const threadId = internalThreadId;
+
+  return (
+    <ThreadsContext.Provider
+      value={{
+        threadId,
+        setThreadId,
+      }}
+    >
+      {children}
+    </ThreadsContext.Provider>
+  );
+}
+
+export function useThreads() {
+  const context = useContext(ThreadsContext);
+  if (!context) {
+    throw new Error("useThreads must be used within ThreadsProvider");
+  }
+  return context;
+}
+
+export { ThreadsContext };

package/src/hooks/__tests__/use-coagent-config.test.ts

@@ -1,8 +1,43 @@
-import { renderHook } from "@testing-library/react";
+import { renderHook, waitFor } from "@testing-library/react";
 import { useCoAgent } from "../use-coagent";
+import type { AgentSubscriber } from "@ag-ui/client";
+
+// Mock functions for @copilotkitnext/react
+const mockSetState = jest.fn();
+const mockRunAgent = jest.fn();
+const mockAbortRun = jest.fn();
+const mockSubscribe = jest.fn();
+const mockSetProperties = jest.fn();
+
+// Store the last subscriber for triggering events
+let lastSubscriber: AgentSubscriber | null = null;
+
+const mockAgent = {
+  agentId: "test-agent",
+  state: { count: 0 },
+  isRunning: false,
+  threadId: "thread-123",
+  setState: mockSetState,
+  runAgent: mockRunAgent,
+  abortRun: mockAbortRun,
+  subscribe: mockSubscribe.mockImplementation((subscriber: AgentSubscriber) => {
+    lastSubscriber = subscriber;
+    return {
+      unsubscribe: jest.fn(),
+    };
+  }),
+};
 
-// Mock the dependencies
-const mockSetCoagentStatesWithRef = jest.fn();
+jest.mock("@copilotkitnext/react", () => ({
+  useAgent: jest.fn(() => ({ agent: mockAgent })),
+  useCopilotKit: jest.fn(() => ({
+    copilotkit: {
+      setProperties: mockSetProperties,
+    },
+  })),
+}));
+
+// Mock other dependencies
 const mockAppendMessage = jest.fn();
 const mockRunChatCompletion = jest.fn();
 
@@ -27,7 +62,6 @@ jest.mock("../../context", () => ({
     availableAgents: [],
     coagentStates: {},
     coagentStatesRef: { current: {} },
-    setCoagentStatesWithRef: mockSetCoagentStatesWithRef,
     threadId: "test-thread",
     copilotApiConfig: {
       headers: {},
@@ -61,14 +95,10 @@ jest.mock("../../components/copilot-provider/copilot-messages", () => ({
 describe("useCoAgent config synchronization", () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    mockSetCoagentStatesWithRef.mockImplementation((updater) => {
-      if (typeof updater === "function") {
-        updater({});
-      }
-    });
+    lastSubscriber = null;
   });
 
-  it("should call setCoagentStatesWithRef when config changes", () => {
+  it("should call setProperties when config changes", async () => {
     const { rerender } = renderHook(
       ({ config }) =>
         useCoAgent({
@@ -82,16 +112,20 @@ describe("useCoAgent config synchronization", () => {
     );
 
     // Clear the initial calls
-    mockSetCoagentStatesWithRef.mockClear();
+    mockSetProperties.mockClear();
 
     // Change config
     rerender({ config: { configurable: { model: "gpt-4o" } } });
 
-    // Should have called setCoagentStatesWithRef with new config
-    expect(mockSetCoagentStatesWithRef).toHaveBeenCalledWith(expect.any(Function));
+    // Wait for effect to complete and verify setProperties was called
+    await waitFor(() => {
+      expect(mockSetProperties).toHaveBeenCalledWith({
+        configurable: { model: "gpt-4o" },
+      });
+    });
   });
 
-  it("should not call setCoagentStatesWithRef when config is unchanged", () => {
+  it("should not call setProperties when config is unchanged", () => {
     const config = { configurable: { model: "gpt-4" } };
 
     const { rerender } = renderHook(
@@ -107,16 +141,16 @@ describe("useCoAgent config synchronization", () => {
     );
 
     // Clear the initial calls
-    mockSetCoagentStatesWithRef.mockClear();
+    mockSetProperties.mockClear();
 
-    // Re-render with same config
+    // Re-render with same config reference
     rerender({ config });
 
-    // Should not have called setCoagentStatesWithRef
-    expect(mockSetCoagentStatesWithRef).not.toHaveBeenCalled();
+    // Should not have called setProperties
+    expect(mockSetProperties).not.toHaveBeenCalled();
   });
 
-  it("should handle backward compatibility with configurable prop", () => {
+  it("should handle backward compatibility with configurable prop", async () => {
     const { rerender } = renderHook(
       ({ configurable }) =>
         useCoAgent({
@@ -130,23 +164,32 @@ describe("useCoAgent config synchronization", () => {
     );
 
     // Clear the initial calls
-    mockSetCoagentStatesWithRef.mockClear();
+    mockSetProperties.mockClear();
 
     // Change configurable prop
     rerender({ configurable: { model: "gpt-4o" } });
 
-    // Should have called setCoagentStatesWithRef
-    expect(mockSetCoagentStatesWithRef).toHaveBeenCalledWith(expect.any(Function));
+    // Wait for effect to complete and verify setProperties was called
+    await waitFor(() => {
+      expect(mockSetProperties).toHaveBeenCalledWith({
+        configurable: { model: "gpt-4o" },
+      });
+    });
   });
 
-  it("should update config while preserving other state properties", () => {
-    let capturedUpdater: any = null;
+  it("should not call setProperties when both config and configurable are undefined", () => {
+    renderHook(() =>
+      useCoAgent({
+        name: "test-agent",
+        initialState: { count: 0 },
+      }),
+    );
 
-    mockSetCoagentStatesWithRef.mockImplementation((updater) => {
-      capturedUpdater = updater;
-      return updater;
-    });
+    // Should not have called setProperties
+    expect(mockSetProperties).not.toHaveBeenCalled();
+  });
 
+  it("should handle deeply nested config changes", async () => {
     const { rerender } = renderHook(
       ({ config }) =>
         useCoAgent({
@@ -155,137 +198,154 @@ describe("useCoAgent config synchronization", () => {
           config,
         }),
       {
-        initialProps: { config: { configurable: { model: "gpt-4" } } },
+        initialProps: {
+          config: {
+            configurable: {
+              model: "gpt-4",
+              settings: { temperature: 0.5 },
+            },
+          },
+        },
       },
     );
 
-    // Clear the initial calls and reset captured updater
-    mockSetCoagentStatesWithRef.mockClear();
-    capturedUpdater = null;
-
-    // Change config
-    rerender({ config: { configurable: { model: "gpt-4o" } } });
-
-    // Should have called setCoagentStatesWithRef
-    expect(mockSetCoagentStatesWithRef).toHaveBeenCalledWith(expect.any(Function));
-    expect(capturedUpdater).toBeTruthy();
+    // Clear the initial calls
+    mockSetProperties.mockClear();
 
-    // Test the updater function behavior
-    const prevState = {
-      "test-agent": {
-        name: "test-agent",
-        state: { count: 5 },
-        config: { configurable: { model: "gpt-4" } },
-        running: true,
-        active: true,
-        threadId: "thread-123",
-        nodeName: "test-node",
-        runId: "run-456",
+    // Change nested config
+    rerender({
+      config: {
+        configurable: {
+          model: "gpt-4",
+          settings: { temperature: 0.7 }, // Only nested property changed
+        },
       },
-    };
-
-    const newState = capturedUpdater(prevState);
+    });
 
-    // Verify the state is updated correctly
-    expect(newState).toEqual({
-      "test-agent": {
-        name: "test-agent",
-        state: { count: 5 }, // State preserved
-        config: { configurable: { model: "gpt-4o" } }, // Config updated
-        running: true, // Other properties preserved
-        active: true,
-        threadId: "thread-123",
-        nodeName: "test-node",
-        runId: "run-456",
-      },
+    // Wait for effect to complete and verify setProperties was called
+    await waitFor(() => {
+      expect(mockSetProperties).toHaveBeenCalledWith({
+        configurable: {
+          model: "gpt-4",
+          settings: { temperature: 0.7 },
+        },
+      });
     });
   });
 
-  it("should create new agent state when agent doesn't exist", () => {
-    let capturedUpdater: any = null;
+  describe("State Management", () => {
+    // Helper to create mock subscriber params
+    const createMockParams = (stateOverride: any = {}) => ({
+      messages: [],
+      state: stateOverride,
+      agent: mockAgent as any,
+      input: {} as any,
+    });
+
+    it("should initialize agent state via onRunInitialized event", () => {
+      // Set agent to have NO state (empty object)
+      mockAgent.state = {} as any;
+
+      renderHook(() =>
+        useCoAgent({
+          name: "test-agent",
+          initialState: { count: 42 },
+        }),
+      );
+
+      // Verify subscription was created
+      expect(mockSubscribe).toHaveBeenCalled();
+      expect(lastSubscriber).toBeTruthy();
+
+      // Clear any initial state calls
+      mockSetState.mockClear();
+
+      // Trigger onRunInitialized with no run state
+      lastSubscriber?.onRunInitialized?.(createMockParams({}));
+
+      // Should set state to initialState
+      expect(mockSetState).toHaveBeenCalledWith({ count: 42 });
 
-    mockSetCoagentStatesWithRef.mockImplementation((updater) => {
-      capturedUpdater = updater;
-      return updater;
+      // Reset agent state
+      mockAgent.state = { count: 0 };
     });
 
-    const { rerender } = renderHook(
-      ({ config }) =>
+    it("should preserve existing agent state on onRunInitialized", () => {
+      // Set agent to have existing state
+      mockAgent.state = { count: 100 };
+
+      renderHook(() =>
         useCoAgent({
           name: "test-agent",
-          initialState: { count: 0 },
-          config,
+          initialState: { count: 42 },
         }),
-      {
-        initialProps: { config: { configurable: { model: "gpt-4" } } },
-      },
-    );
+      );
 
-    // Clear the initial calls and reset captured updater
-    mockSetCoagentStatesWithRef.mockClear();
-    capturedUpdater = null;
+      // Clear any initial state calls
+      mockSetState.mockClear();
 
-    // Change config
-    rerender({ config: { configurable: { model: "gpt-4o" } } });
+      // Trigger onRunInitialized with no new state
+      lastSubscriber?.onRunInitialized?.(createMockParams({}));
+
+      // Should NOT override existing state
+      expect(mockSetState).not.toHaveBeenCalled();
+
+      // Reset agent state
+      mockAgent.state = { count: 0 };
+    });
 
-    // Should have called setCoagentStatesWithRef
-    expect(mockSetCoagentStatesWithRef).toHaveBeenCalledWith(expect.any(Function));
-    expect(capturedUpdater).toBeTruthy();
+    it("should prioritize run state over initialState", () => {
+      renderHook(() =>
+        useCoAgent({
+          name: "test-agent",
+          initialState: { count: 42 },
+        }),
+      );
 
-    // Test the updater function behavior with empty previous state
-    const prevState = {}; // No existing agent state
+      // Clear any initial state calls
+      mockSetState.mockClear();
 
-    const newState = capturedUpdater(prevState);
+      // Trigger onRunInitialized with state from the run
+      lastSubscriber?.onRunInitialized?.(createMockParams({ count: 999 }));
 
-    // Verify the state creates a new agent state with default values
-    expect(newState).toEqual({
-      "test-agent": {
-        name: "test-agent",
-        state: { count: 0 }, // Uses initialState
-        config: { configurable: { model: "gpt-4o" } }, // New config
-        running: false, // Default values
-        active: false,
-        threadId: undefined,
-        nodeName: undefined,
-        runId: undefined,
-      },
+      // Should use run state, not initialState
+      expect(mockSetState).toHaveBeenCalledWith({ count: 999 });
     });
-  });
 
-  it("should handle deeply nested config changes", () => {
-    const { rerender } = renderHook(
-      ({ config }) =>
+    it("should handle setState with object updates", () => {
+      const { result } = renderHook(() =>
         useCoAgent({
           name: "test-agent",
           initialState: { count: 0 },
-          config,
         }),
-      {
-        initialProps: {
-          config: {
-            configurable: {
-              model: "gpt-4",
-              settings: { temperature: 0.5 },
-            },
-          },
-        },
-      },
-    );
+      );
 
-    // Clear the initial calls
-    mockSetCoagentStatesWithRef.mockClear();
+      // Update state with object
+      result.current.setState({ count: 5 });
 
-    // Change nested config
-    rerender({
-      config: {
-        configurable: {
-          model: "gpt-4",
-          settings: { temperature: 0.7 }, // Only nested property changed
-        },
-      },
+      // Should merge with existing state
+      expect(mockSetState).toHaveBeenCalledWith({ count: 5 });
     });
 
-    // Should detect the nested change
-    expect(mockSetCoagentStatesWithRef).toHaveBeenCalledWith(expect.any(Function));
+    it("should handle setState with function updaters", () => {
+      // Set current agent state
+      mockAgent.state = { count: 10 };
+
+      const { result } = renderHook(() =>
+        useCoAgent({
+          name: "test-agent",
+          initialState: { count: 0 },
+        }),
+      );
+
+      // Update state with function
+      result.current.setState((prev) => ({ count: (prev?.count || 0) + 5 }));
+
+      // Should call function with current state and set result
+      expect(mockSetState).toHaveBeenCalledWith({ count: 15 });
+
+      // Reset agent state
+      mockAgent.state = { count: 0 };
+    });
   });
 });