@copilotkit/react-core 1.57.3 → 1.58.0

package/src/hooks/__tests__/use-coagent-state-render.test.tsx

@@ -1,356 +0,0 @@
-import { vi, type Mock } from "vitest";
-import React, { type ReactNode } from "react";
-import { render, renderHook, waitFor } from "@testing-library/react";
-import { useCoAgentStateRender } from "../use-coagent-state-render";
-import type { CoAgentStateRender } from "../../types/coagent-action";
-import {
-  CoAgentStateRendersProvider,
-  CopilotContext,
-  useCoAgentStateRenders,
-} from "../../context";
-import { CopilotKitAgentDiscoveryError, randomId } from "@copilotkit/shared";
-import { createTestCopilotContext } from "../../test-helpers/copilot-context";
-
-const addToast = vi.fn();
-const setBannerError = vi.fn();
-
-vi.mock("../../components/toast/toast-provider", () => ({
-  useToast: () => ({
-    addToast,
-    setBannerError,
-  }),
-}));
-
-function createWrapper(
-  copilotContextValue: ReturnType<typeof createTestCopilotContext>,
-) {
-  return function Wrapper({ children }: { children: ReactNode }) {
-    return (
-      <CopilotContext.Provider value={copilotContextValue}>
-        <CoAgentStateRendersProvider>{children}</CoAgentStateRendersProvider>
-      </CopilotContext.Provider>
-    );
-  };
-}
-
-function useHarness<T>(
-  action: Parameters<typeof useCoAgentStateRender<T>>[0],
-  deps?: unknown[],
-) {
-  useCoAgentStateRender(action, deps);
-  return useCoAgentStateRenders();
-}
-
-function HookUser<T>({
-  action,
-  deps,
-}: {
-  action: CoAgentStateRender<T>;
-  deps?: unknown[];
-}) {
-  useCoAgentStateRender(action, deps);
-  return null;
-}
-
-function getSingleEntry<T>(renders: Record<string, T>) {
-  const entries = Object.entries(renders);
-  expect(entries).toHaveLength(1);
-  return entries[0];
-}
-
-describe("useCoAgentStateRender (hook behaviors)", () => {
-  let idCounter = 0;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    idCounter = 0;
-    (randomId as Mock).mockImplementation(
-      () => `test-random-id-${++idCounter}`,
-    );
-  });
-
-  it("registers state render and writes to the render cache", async () => {
-    const chatComponentsCache = {
-      current: { actions: {}, coAgentStateRenders: {} },
-    };
-    const wrapper = createWrapper(
-      createTestCopilotContext({
-        chatComponentsCache,
-      }),
-    );
-
-    const renderFn = vi.fn(() => null);
-
-    const { result } = renderHook(
-      () =>
-        useHarness({
-          name: "agent-a",
-          nodeName: "node-1",
-          render: renderFn,
-        }),
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(Object.keys(result.current.coAgentStateRenders)).toHaveLength(1);
-    });
-
-    expect(
-      chatComponentsCache.current.coAgentStateRenders["agent-a-node-1"],
-    ).toBe(renderFn);
-  });
-
-  it("mutates handler + cache in place when dependencies are omitted", async () => {
-    const chatComponentsCache = {
-      current: { actions: {}, coAgentStateRenders: {} },
-    };
-    const wrapper = createWrapper(
-      createTestCopilotContext({
-        chatComponentsCache,
-      }),
-    );
-
-    const handlerOne = vi.fn();
-    const handlerTwo = vi.fn();
-    const renderOne = vi.fn(() => null);
-    const renderTwo = vi.fn(() => null);
-
-    const { result, rerender } = renderHook(
-      ({ handler, renderFn }) =>
-        useHarness({
-          name: "agent-b",
-          handler,
-          render: renderFn,
-        }),
-      {
-        wrapper,
-        initialProps: { handler: handlerOne, renderFn: renderOne },
-      },
-    );
-
-    await waitFor(() => {
-      expect(Object.keys(result.current.coAgentStateRenders)).toHaveLength(1);
-    });
-
-    const initialRenders = result.current.coAgentStateRenders;
-    const [id, initialRender] = getSingleEntry(initialRenders);
-
-    expect(initialRender.handler).toBe(handlerOne);
-    expect(
-      chatComponentsCache.current.coAgentStateRenders["agent-b-global"],
-    ).toBe(renderOne);
-
-    rerender({ handler: handlerTwo, renderFn: renderTwo });
-
-    expect(result.current.coAgentStateRenders).toBe(initialRenders);
-    expect(result.current.coAgentStateRenders[id].handler).toBe(handlerTwo);
-    expect(
-      chatComponentsCache.current.coAgentStateRenders["agent-b-global"],
-    ).toBe(renderTwo);
-  });
-
-  it("re-registers when dependencies change", async () => {
-    const wrapper = createWrapper(createTestCopilotContext());
-
-    const handlerOne = vi.fn();
-    const handlerTwo = vi.fn();
-
-    const { result, rerender } = renderHook(
-      ({ deps, handler }) =>
-        useHarness(
-          {
-            name: "agent-c",
-            handler,
-          },
-          deps,
-        ),
-      {
-        wrapper,
-        initialProps: { deps: [0], handler: handlerOne },
-      },
-    );
-
-    await waitFor(() => {
-      expect(Object.keys(result.current.coAgentStateRenders)).toHaveLength(1);
-    });
-
-    const initialRenders = result.current.coAgentStateRenders;
-    const [id] = Object.keys(initialRenders);
-
-    rerender({ deps: [1], handler: handlerTwo });
-
-    await waitFor(() => {
-      expect(result.current.coAgentStateRenders).not.toBe(initialRenders);
-    });
-
-    expect(result.current.coAgentStateRenders[id].handler).toBe(handlerTwo);
-  });
-
-  it("re-registers when string render changes", async () => {
-    const chatComponentsCache = {
-      current: { actions: {}, coAgentStateRenders: {} },
-    };
-    const wrapper = createWrapper(
-      createTestCopilotContext({
-        chatComponentsCache,
-      }),
-    );
-
-    const { result, rerender } = renderHook(
-      ({ renderValue }) =>
-        useHarness({
-          name: "agent-d",
-          render: renderValue,
-        }),
-      {
-        wrapper,
-        initialProps: { renderValue: "Step 1" },
-      },
-    );
-
-    await waitFor(() => {
-      expect(Object.keys(result.current.coAgentStateRenders)).toHaveLength(1);
-    });
-
-    const initialRenders = result.current.coAgentStateRenders;
-    rerender({ renderValue: "Step 2" });
-
-    await waitFor(() => {
-      expect(result.current.coAgentStateRenders).not.toBe(initialRenders);
-    });
-
-    expect(
-      chatComponentsCache.current.coAgentStateRenders["agent-d-global"],
-    ).toBe("Step 2");
-  });
-
-  it("warns when duplicate registrations target the same agent + node", async () => {
-    const copilotContextValue = createTestCopilotContext();
-
-    function DuplicateHarness() {
-      return (
-        <>
-          <HookUser
-            action={{
-              name: "agent-dup",
-              nodeName: "node-x",
-              handler: vi.fn(),
-            }}
-          />
-          <HookUser
-            action={{
-              name: "agent-dup",
-              nodeName: "node-x",
-              handler: vi.fn(),
-            }}
-          />
-        </>
-      );
-    }
-
-    render(
-      <CopilotContext.Provider value={copilotContextValue}>
-        <CoAgentStateRendersProvider>
-          <DuplicateHarness />
-        </CoAgentStateRendersProvider>
-      </CopilotContext.Provider>,
-    );
-
-    await waitFor(() => {
-      expect(addToast).toHaveBeenCalled();
-    });
-
-    expect(addToast).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: "warning",
-        message:
-          "Found multiple state renders for agent agent-dup and node node-x. State renders might get overridden",
-      }),
-    );
-  });
-
-  it("does not warn when duplicate agents target different nodes", async () => {
-    const copilotContextValue = createTestCopilotContext();
-
-    function NonDuplicateHarness() {
-      return (
-        <>
-          <HookUser
-            action={{
-              name: "agent-ok",
-              nodeName: "node-a",
-              handler: vi.fn(),
-            }}
-          />
-          <HookUser
-            action={{
-              name: "agent-ok",
-              nodeName: "node-b",
-              handler: vi.fn(),
-            }}
-          />
-        </>
-      );
-    }
-
-    render(
-      <CopilotContext.Provider value={copilotContextValue}>
-        <CoAgentStateRendersProvider>
-          <NonDuplicateHarness />
-        </CoAgentStateRendersProvider>
-      </CopilotContext.Provider>,
-    );
-
-    await waitFor(() => {
-      expect(addToast).not.toHaveBeenCalled();
-    });
-  });
-
-  it("surfaces missing agents in the banner error state", async () => {
-    const availableAgents = [{ name: "known-agent", id: "agent-1" }];
-    const wrapper = createWrapper(
-      createTestCopilotContext({
-        availableAgents,
-      }),
-    );
-
-    renderHook(
-      () =>
-        useHarness({
-          name: "missing-agent",
-          handler: vi.fn(),
-        }),
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(CopilotKitAgentDiscoveryError).toHaveBeenCalledWith({
-        agentName: "missing-agent",
-        availableAgents: [{ name: "known-agent", id: "agent-1" }],
-      });
-      expect(setBannerError).toHaveBeenCalled();
-    });
-  });
-
-  it("does not surface banner errors when agent is available", async () => {
-    const availableAgents = [{ name: "agent-present", id: "agent-2" }];
-    const wrapper = createWrapper(
-      createTestCopilotContext({
-        availableAgents,
-      }),
-    );
-
-    renderHook(
-      () =>
-        useHarness({
-          name: "agent-present",
-          handler: vi.fn(),
-        }),
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(setBannerError).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/hooks/__tests__/use-copilot-chat-internal-connect.test.tsx

@@ -1,241 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from "vitest";
-import React from "react";
-import { renderHook, act } from "@testing-library/react";
-import { useCopilotChatInternal } from "../use-copilot-chat_internal";
-import { CoAgentStateRendersProvider, CopilotContext } from "../../context";
-import { createTestCopilotContext } from "../../test-helpers/copilot-context";
-import { useAgent, useCopilotKit, useCopilotChatConfiguration } from "../../v2";
-import { CopilotKitCoreRuntimeConnectionStatus } from "@copilotkit/core";
-
-// ---------------------------------------------------------------------------
-// Mutable state that tests can tweak between renders
-// ---------------------------------------------------------------------------
-let mockRuntimeConnectionStatus: CopilotKitCoreRuntimeConnectionStatus =
-  CopilotKitCoreRuntimeConnectionStatus.Disconnected;
-const mockConnectAgent = vi.fn().mockResolvedValue(undefined);
-
-const mockAgent: Record<string, unknown> = {
-  messages: [],
-  state: {},
-  isRunning: false,
-  subscribe: vi.fn(() => ({ unsubscribe: vi.fn() })),
-  setMessages: vi.fn(),
-  setState: vi.fn(),
-  addMessage: vi.fn(),
-  abortRun: vi.fn(),
-  runAgent: vi.fn(),
-  detachActiveRun: vi.fn().mockResolvedValue(undefined),
-  threadId: undefined as string | undefined,
-};
-
-let mockConfigThreadId: string | undefined = "config-thread-id";
-
-// ---------------------------------------------------------------------------
-// Module mocks
-// ---------------------------------------------------------------------------
-vi.mock("../../v2", () => ({
-  useAgent: vi.fn(() => ({ agent: mockAgent })),
-  useCopilotKit: vi.fn(() => ({
-    copilotkit: {
-      connectAgent: mockConnectAgent,
-      runtimeConnectionStatus: mockRuntimeConnectionStatus,
-      getRunIdForMessage: vi.fn(),
-      runAgent: vi.fn(),
-      clearSuggestions: vi.fn(),
-      addSuggestionsConfig: vi.fn(),
-      reloadSuggestions: vi.fn(),
-      subscribe: vi.fn(() => ({ unsubscribe: vi.fn() })),
-      interruptElement: null,
-    },
-  })),
-  useCopilotChatConfiguration: vi.fn(() => ({
-    agentId: "test-agent",
-    threadId: mockConfigThreadId,
-  })),
-  useRenderCustomMessages: vi.fn(() => undefined),
-  useSuggestions: vi.fn(() => ({ suggestions: [], isLoading: false })),
-}));
-
-vi.mock("../../components/toast/toast-provider", () => ({
-  useToast: () => ({
-    setBannerError: vi.fn(),
-    addToast: vi.fn(),
-  }),
-}));
-
-vi.mock("../../components/error-boundary/error-utils", () => ({
-  useAsyncCallback: <T extends (...args: unknown[]) => unknown>(fn: T) => fn,
-}));
-
-vi.mock("../use-langgraph-interrupt-render", () => ({
-  useLangGraphInterruptRender: vi.fn(() => null),
-}));
-
-vi.mock("../use-lazy-tool-renderer", () => ({
-  useLazyToolRenderer: vi.fn(() => () => null),
-}));
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Re-apply the mock return values. Because `vi.mock` factory runs once at
- * module load, we need to update the mock implementations to pick up the
- * mutable variables that tests change.
- */
-function applyMocks() {
-  vi.mocked(useCopilotKit).mockReturnValue({
-    copilotkit: {
-      connectAgent: mockConnectAgent,
-      runtimeConnectionStatus: mockRuntimeConnectionStatus,
-      getRunIdForMessage: vi.fn(),
-      runAgent: vi.fn(),
-      clearSuggestions: vi.fn(),
-      addSuggestionsConfig: vi.fn(),
-      reloadSuggestions: vi.fn(),
-      subscribe: vi.fn(() => ({ unsubscribe: vi.fn() })),
-      interruptElement: null,
-    },
-  } as any);
-
-  vi.mocked(useCopilotChatConfiguration).mockReturnValue({
-    agentId: "test-agent",
-    threadId: mockConfigThreadId,
-  } as any);
-
-  vi.mocked(useAgent).mockReturnValue({ agent: mockAgent } as any);
-}
-
-function createWrapper() {
-  const copilotContextValue = createTestCopilotContext();
-  return function Wrapper({ children }: { children: React.ReactNode }) {
-    return (
-      <CopilotContext.Provider value={copilotContextValue}>
-        <CoAgentStateRendersProvider>{children}</CoAgentStateRendersProvider>
-      </CopilotContext.Provider>
-    );
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("useCopilotChatInternal – connectAgent guard", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Disconnected;
-    mockConnectAgent.mockResolvedValue(undefined);
-    mockAgent.threadId = undefined;
-    mockAgent.messages = [];
-    mockAgent.state = {};
-    mockAgent.isRunning = false;
-    mockConfigThreadId = "config-thread-id";
-  });
-
-  it("does not call connectAgent when status is Disconnected", () => {
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Disconnected;
-    applyMocks();
-
-    renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
-
-    expect(mockConnectAgent).not.toHaveBeenCalled();
-  });
-
-  it("does not call connectAgent when status is Connecting", () => {
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Connecting;
-    applyMocks();
-
-    renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
-
-    expect(mockConnectAgent).not.toHaveBeenCalled();
-  });
-
-  it("calls connectAgent once when status transitions to Connected", async () => {
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Disconnected;
-    applyMocks();
-
-    const { rerender } = renderHook(() => useCopilotChatInternal(), {
-      wrapper: createWrapper(),
-    });
-
-    expect(mockConnectAgent).not.toHaveBeenCalled();
-
-    // Transition to Connected
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Connected;
-    applyMocks();
-
-    rerender();
-
-    // Wait for the async connectAgent call
-    await vi.waitFor(() => {
-      expect(mockConnectAgent).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it("does not call connectAgent when threadId matches (same agent instance, no re-render)", async () => {
-    // The wrapper guards via lastConnectedAgentRef: connect fires once per
-    // agent instance, not once per render. After the first connect, further
-    // re-renders with the same agent do not trigger another connect.
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Connected;
-    mockAgent.threadId = "config-thread-id";
-    applyMocks();
-
-    const { rerender } = renderHook(() => useCopilotChatInternal(), {
-      wrapper: createWrapper(),
-    });
-
-    await vi.waitFor(() => {
-      expect(mockConnectAgent).toHaveBeenCalledTimes(1);
-    });
-
-    // Re-render with same agent — should NOT connect again
-    rerender();
-    await vi.waitFor(() => {
-      expect(mockConnectAgent).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it("calls connectAgent when config threadId is missing", async () => {
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Connected;
-    mockConfigThreadId = undefined;
-    applyMocks();
-
-    renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
-
-    await vi.waitFor(() => {
-      expect(mockConnectAgent).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it("calls connectAgent when status is Connected and threadIds differ", async () => {
-    mockRuntimeConnectionStatus =
-      CopilotKitCoreRuntimeConnectionStatus.Connected;
-    mockAgent.threadId = "old-thread-id"; // differs from config
-    applyMocks();
-
-    renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
-
-    await vi.waitFor(() => {
-      expect(mockConnectAgent).toHaveBeenCalledTimes(1);
-      expect(mockConnectAgent).toHaveBeenCalledWith({ agent: mockAgent });
-    });
-  });
-
-  it("passes resolved agentId to useAgent", () => {
-    applyMocks();
-
-    renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
-
-    expect(vi.mocked(useAgent)).toHaveBeenCalledWith(
-      expect.objectContaining({ agentId: "test-agent" }),
-    );
-  });
-});

package/src/hooks/__tests__/use-frontend-tool-available.test.tsx

@@ -1,72 +0,0 @@
-import { vi } from "vitest";
-import React from "react";
-import { render, waitFor } from "@testing-library/react";
-import { useFrontendTool } from "../use-frontend-tool";
-
-// Track what gets passed to the v2 hook
-let lastV2ToolCall: any = null;
-
-vi.mock("../../v2", () => ({
-  useFrontendTool: vi.fn((tool: any) => {
-    lastV2ToolCall = tool;
-  }),
-}));
-
-describe("useFrontendTool available passthrough (v1 → v2)", () => {
-  beforeEach(() => {
-    lastV2ToolCall = null;
-  });
-
-  it("converts available: 'disabled' to false for v2", () => {
-    const Component: React.FC = () => {
-      useFrontendTool({
-        name: "testTool",
-        description: "Test tool",
-        available: "disabled",
-        parameters: [],
-        handler: async () => "done",
-      });
-      return null;
-    };
-
-    render(<Component />);
-
-    expect(lastV2ToolCall).toBeDefined();
-    expect(lastV2ToolCall.available).toBe(false);
-  });
-
-  it("converts available: 'enabled' to true for v2", () => {
-    const Component: React.FC = () => {
-      useFrontendTool({
-        name: "testTool",
-        description: "Test tool",
-        available: "enabled",
-        parameters: [],
-        handler: async () => "done",
-      });
-      return null;
-    };
-
-    render(<Component />);
-
-    expect(lastV2ToolCall).toBeDefined();
-    expect(lastV2ToolCall.available).toBe(true);
-  });
-
-  it("does not include available when not specified", () => {
-    const Component: React.FC = () => {
-      useFrontendTool({
-        name: "testTool",
-        description: "Test tool",
-        parameters: [],
-        handler: async () => "done",
-      });
-      return null;
-    };
-
-    render(<Component />);
-
-    expect(lastV2ToolCall).toBeDefined();
-    expect(lastV2ToolCall.available).toBeUndefined();
-  });
-});