@copilotkit/react-core 1.55.3-canary.1776243725 → 1.55.3-canary.1776979102

package/src/v2/components/chat/__tests__/CopilotChat.e2e.test.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect } from "react";
-import { screen, fireEvent, waitFor, act } from "@testing-library/react";
+import { screen, fireEvent, waitFor } from "@testing-library/react";
 import { z } from "zod";
 import { defineToolCallRenderer, ReactToolCallRenderer } from "../../../types";
 import {
@@ -1060,128 +1060,6 @@ describe("CopilotChat E2E - Chat Basics and Streaming Patterns", () => {
       agent.complete();
     });
 
-    it("should not auto-collapse when user manually toggled during streaming", async () => {
-      const agent = new MockStepwiseAgent();
-      renderWithCopilotKit({ agent });
-
-      const input = await screen.findByRole("textbox");
-      fireEvent.change(input, { target: { value: "User toggle test" } });
-      fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
-
-      await waitFor(() => {
-        expect(screen.getByText("User toggle test")).toBeDefined();
-      });
-
-      const reasoningId = testId("reasoning");
-      const textId = testId("text");
-
-      // Start streaming reasoning — panel should auto-open
-      agent.emit(runStartedEvent());
-      agent.emit(reasoningStartEvent(reasoningId));
-      agent.emit(reasoningMessageStartEvent(reasoningId));
-      agent.emit(
-        reasoningMessageContentEvent(reasoningId, "Deep analysis in progress"),
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Thinking…")).toBeDefined();
-      });
-
-      // Panel should be open (aria-expanded="true") while streaming
-      await waitFor(() => {
-        const header = screen.getByText("Thinking…");
-        const button = header.closest("button");
-        expect(button?.getAttribute("aria-expanded")).toBe("true");
-      });
-
-      // User manually collapses during streaming — this sets userToggledRef
-      const header = screen.getByText("Thinking…");
-      const button = header.closest("button");
-      act(() => {
-        if (button) {
-          fireEvent.click(button);
-        }
-      });
-
-      // Should now be collapsed by user action
-      await waitFor(() => {
-        const btn = screen.getByText("Thinking…").closest("button");
-        expect(btn?.getAttribute("aria-expanded")).toBe("false");
-      });
-
-      // Now streaming ends — because userToggledRef is true, the panel
-      // should stay in whatever state the user set (collapsed).
-      agent.emit(reasoningMessageEndEvent(reasoningId));
-      agent.emit(reasoningEndEvent(reasoningId));
-      agent.emit(textChunkEvent(textId, "Done."));
-      agent.emit(runFinishedEvent());
-      agent.complete();
-
-      // Panel should remain collapsed (not flash open then closed)
-      await waitFor(() => {
-        const btn = screen.getByText(/Thought for/).closest("button");
-        expect(btn?.getAttribute("aria-expanded")).toBe("false");
-      });
-    });
-
-    it("should keep panel open when user re-expands during streaming", async () => {
-      const agent = new MockStepwiseAgent();
-      renderWithCopilotKit({ agent });
-
-      const input = await screen.findByRole("textbox");
-      fireEvent.change(input, {
-        target: { value: "Re-expand toggle test" },
-      });
-      fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
-
-      await waitFor(() => {
-        expect(screen.getByText("Re-expand toggle test")).toBeDefined();
-      });
-
-      const reasoningId = testId("reasoning");
-      const textId = testId("text");
-
-      // Start streaming reasoning — panel auto-opens
-      agent.emit(runStartedEvent());
-      agent.emit(reasoningStartEvent(reasoningId));
-      agent.emit(reasoningMessageStartEvent(reasoningId));
-      agent.emit(reasoningMessageContentEvent(reasoningId, "Thinking hard"));
-
-      await waitFor(() => {
-        const btn = screen.getByText("Thinking…").closest("button");
-        expect(btn?.getAttribute("aria-expanded")).toBe("true");
-      });
-
-      // User collapses, then re-expands (both set userToggledRef = true)
-      const headerEl = screen.getByText("Thinking…");
-      const btn = headerEl.closest("button");
-      act(() => {
-        if (btn) {
-          fireEvent.click(btn); // collapse
-          fireEvent.click(btn); // re-expand
-        }
-      });
-
-      await waitFor(() => {
-        const b = screen.getByText("Thinking…").closest("button");
-        expect(b?.getAttribute("aria-expanded")).toBe("true");
-      });
-
-      // Streaming ends — because userToggledRef is true, panel should
-      // stay in the user's chosen state (open).
-      agent.emit(reasoningMessageEndEvent(reasoningId));
-      agent.emit(reasoningEndEvent(reasoningId));
-      agent.emit(textChunkEvent(textId, "All done."));
-      agent.emit(runFinishedEvent());
-      agent.complete();
-
-      // Panel should remain open (not auto-collapse)
-      await waitFor(() => {
-        const b = screen.getByText(/Thought for/).closest("button");
-        expect(b?.getAttribute("aria-expanded")).toBe("true");
-      });
-    });
-
     it("should expand and collapse reasoning content on click", async () => {
       const agent = new MockStepwiseAgent();
       renderWithCopilotKit({ agent });
@@ -1216,16 +1094,12 @@ describe("CopilotChat E2E - Chat Basics and Streaming Patterns", () => {
         expect(button?.getAttribute("aria-expanded")).toBe("false");
       });
 
-      // Click to expand — wrap in act() so React 18 flushes the state
-      // update synchronously instead of deferring it through the scheduler,
-      // which can race with waitFor polling on slow CI runners.
+      // Click to expand
       const header = screen.getByText(/Thought for/);
       const button = header.closest("button");
-      act(() => {
-        if (button) {
-          fireEvent.click(button);
-        }
-      });
+      if (button) {
+        fireEvent.click(button);
+      }
 
       // Should now be expanded
       await waitFor(() => {

package/src/v2/components/chat/__tests__/CopilotChatActivityRendering.e2e.test.tsx

@@ -11,8 +11,6 @@ import {
 } from "../../../__tests__/utils/test-helpers";
 import { ReactActivityMessageRenderer } from "../../../types";
 import { useCopilotKit } from "../../../providers";
-import { AbstractAgent } from "@ag-ui/client";
-import { getThreadClone } from "../../../hooks/use-agent";
 
 describe("CopilotChat activity message rendering", () => {
   it("renders custom components for activity snapshots", async () => {
@@ -150,62 +148,4 @@ describe("CopilotChat activity message rendering", () => {
     expect(capturedCopilotkit).toBeDefined();
   });
 
-  it("passes the per-thread clone (not the registry agent) to activity message renderers", async () => {
-    // Regression test for: A2UI button clicks firing runAgent on the registry
-    // agent instead of the per-thread clone that CopilotChat renders from.
-    // Caused by useRenderActivityMessage calling copilotkit.getAgent() directly
-    // instead of getThreadClone(registryAgent, threadId) ?? registryAgent.
-    const agent = new MockStepwiseAgent();
-    const agentId = "action-agent";
-    agent.agentId = agentId;
-    const threadId = "thread-for-action-test";
-
-    let capturedAgent: AbstractAgent | undefined;
-
-    const activityRenderer: ReactActivityMessageRenderer<{ label: string }> = {
-      activityType: "button-action",
-      content: z.object({ label: z.string() }),
-      render: ({ content, agent: renderedAgent }) => {
-        capturedAgent = renderedAgent;
-        return <button data-testid="action-button">{content.label}</button>;
-      },
-    };
-
-    renderWithCopilotKit({
-      agents: { [agentId]: agent },
-      agentId,
-      threadId,
-      renderActivityMessages: [activityRenderer],
-    });
-
-    const input = await screen.findByRole("textbox");
-    fireEvent.change(input, { target: { value: "show me buttons" } });
-    fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
-
-    await waitFor(() => {
-      expect(screen.getByText("show me buttons")).toBeDefined();
-    });
-
-    agent.emit(runStartedEvent());
-    agent.emit(
-      activitySnapshotEvent({
-        messageId: testId("activity-action"),
-        activityType: "button-action",
-        content: { label: "Click Me" },
-      }),
-    );
-    agent.emit(runFinishedEvent());
-
-    await waitFor(() => {
-      expect(screen.getByTestId("action-button")).toBeDefined();
-    });
-
-    // CopilotChat creates a per-thread clone via useAgent. The activity renderer
-    // must receive that clone so that handleAction → runAgent targets the same
-    // instance chat is rendering from.
-    const clone = getThreadClone(agent, threadId);
-    expect(clone).toBeDefined();
-    expect(capturedAgent).toBe(clone);
-    expect(capturedAgent).not.toBe(agent); // must NOT be the registry agent
-  });
 });

package/src/v2/components/chat/__tests__/CopilotChatAssistantMessage.test.tsx

@@ -669,7 +669,7 @@ describe("CopilotChatAssistantMessage", () => {
 
       await waitFor(() => {
         expect(consoleSpy).toHaveBeenCalledWith(
-          "Failed to copy to clipboard:",
+          "Failed to copy message:",
           expect.any(Error),
         );
       });

package/src/v2/components/chat/__tests__/CopilotChatToolRendering.e2e.test.tsx

@@ -250,11 +250,8 @@ class MockStepwiseAgent extends AbstractAgent {
   }
 
   clone(): MockStepwiseAgent {
-    const cloned = new MockStepwiseAgent();
-    cloned.agentId = this.agentId;
-    (cloned as unknown as { subject: Subject<BaseEvent> }).subject =
-      this.subject;
-    return cloned;
+    // For tests, return same instance so we can keep controlling it.
+    return this;
   }
 
   async detachActiveRun(): Promise<void> {}

package/src/v2/components/chat/__tests__/CopilotChatToolRerenders.e2e.test.tsx

@@ -52,11 +52,8 @@ class MockStepwiseAgent extends AbstractAgent {
   }
 
   clone(): MockStepwiseAgent {
-    const cloned = new MockStepwiseAgent();
-    cloned.agentId = this.agentId;
-    (cloned as unknown as { subject: Subject<BaseEvent> }).subject =
-      this.subject;
-    return cloned;
+    // For tests, return same instance so we can keep controlling it.
+    return this;
   }
 
   async detachActiveRun(): Promise<void> {}

package/src/v2/components/chat/__tests__/MCPAppsActivityRenderer.e2e.test.tsx

@@ -79,61 +79,7 @@ class MockMCPProxyAgent extends AbstractAgent {
   }
 
   clone(): MockMCPProxyAgent {
-    const cloned = new MockMCPProxyAgent();
-    cloned.agentId = this.agentId;
-    type Internal = {
-      subject: Subject<BaseEvent>;
-      runAgentCalls: Array<{ input: Partial<RunAgentInput> }>;
-      runAgentResponses: Map<string, unknown>;
-    };
-    (cloned as unknown as Internal).subject = (
-      this as unknown as Internal
-    ).subject;
-    (cloned as unknown as Internal).runAgentCalls = (
-      this as unknown as Internal
-    ).runAgentCalls;
-    (cloned as unknown as Internal).runAgentResponses = (
-      this as unknown as Internal
-    ).runAgentResponses;
-    // Share isRunning with the original so that emit(runFinishedEvent()) on the
-    // registry is visible to waitForAgentIdle() which now receives the clone.
-    //
-    // Also proxy runAgent dynamically so tests that monkey-patch agent.runAgent
-    // after renderWithCopilotKit (which creates the clone) still take effect.
-    // The clone is created and cached before tests can override runAgent, so a
-    // static copy would always see the pre-patch prototype method.
-    const registry = this;
-    Object.defineProperty(cloned, "isRunning", {
-      get() {
-        return registry.isRunning;
-      },
-      set(v: boolean) {
-        registry.isRunning = v;
-      },
-      configurable: true,
-      enumerable: true,
-    });
-    // Override runAgent so that:
-    // - Proxied MCP requests delegate to registry.runAgent (picking up any
-    //   monkey-patches the test installed after renderWithCopilotKit).
-    // - User-message runs call the prototype method with `this = clone` so
-    //   that clone.messages is updated (CopilotKit renders clone.messages).
-    const proto = MockMCPProxyAgent.prototype;
-    cloned.runAgent = async function (
-      input?: Partial<RunAgentInput>,
-    ): Promise<RunAgentResult> {
-      const proxiedRequest = input?.forwardedProps?.__proxiedMCPRequest;
-      if (proxiedRequest) {
-        // Delegate to the registry so that monkey-patches applied by tests
-        // (e.g. "throws an error", "uses a controlled promise") take effect.
-        return registry.runAgent(input);
-      }
-      // For user-message runs: call the prototype method bound to the clone
-      // so AbstractAgent.runAgent processes events on clone and updates
-      // clone.messages (which is what CopilotKit reads to render messages).
-      return proto.runAgent.call(cloned, input);
-    };
-    return cloned;
+    return this;
   }
 
   async detachActiveRun(): Promise<void> {}

package/src/v2/hooks/__tests__/use-agent-context-timing.e2e.test.tsx

@@ -42,16 +42,8 @@ describe("useAgentContext timing - follow-up run sees updated context", () => {
      * with no new messages — which is fine; we only need to capture context.
      */
     class ContextCapturingAgent extends MockStepwiseAgent {
-      // Shared so the clone and original both see the captured contexts
       public contextPerRun: Context[][] = [];
 
-      clone(): this {
-        const cloned = super.clone();
-        (cloned as unknown as ContextCapturingAgent).contextPerRun =
-          this.contextPerRun;
-        return cloned;
-      }
-
       async runAgent(
         parameters?: RunAgentParameters,
         subscriber?: AgentSubscriber,

package/src/v2/hooks/__tests__/use-agent-throttle.test.tsx

@@ -313,7 +313,7 @@ describe("useAgent throttleMs", () => {
     expect(screen.getByTestId("count").textContent).toBe("3");
   });
 
-  it("with throttleMs, onStateChanged still fires immediately", async () => {
+  it("with throttleMs, onStateChanged still fires immediately", () => {
     const TestComponent = createTestComponent({
       updates: [
         UseAgentUpdate.OnMessagesChanged,
@@ -330,8 +330,8 @@ describe("useAgent throttleMs", () => {
       notifyMessagesChanged(mockAgent);
     });
 
-    // Fire onStateChanged 10ms later — fires via microtask batch (not synchronously)
-    await act(async () => {
+    // Fire onStateChanged 10ms later — should render immediately, not throttled
+    act(() => {
       vi.advanceTimersByTime(10);
       mockAgent.state = { count: 42 };
       notifyStateChanged(mockAgent);
@@ -372,7 +372,7 @@ describe("useAgent throttleMs", () => {
     expect(renderCount.current).toBe(countBeforeUnmount);
   });
 
-  it("with throttleMs and updates excluding OnMessagesChanged, throttle is a no-op", async () => {
+  it("with throttleMs and updates excluding OnMessagesChanged, throttle is a no-op", () => {
     const TestComponent = createTestComponent({
       updates: [UseAgentUpdate.OnStateChanged],
       throttleMs: 100,
@@ -380,8 +380,8 @@ describe("useAgent throttleMs", () => {
 
     render(<TestComponent />);
 
-    // Only onStateChanged is subscribed — fires via microtask batch
-    await act(async () => {
+    // Only onStateChanged is subscribed — should fire immediately
+    act(() => {
       mockAgent.state = { value: "test" };
       notifyStateChanged(mockAgent);
     });
@@ -649,7 +649,7 @@ describe("useAgent throttleMs", () => {
     expect(renderCount.current).toBe(rendersAfterMount + 1);
   });
 
-  it("with throttleMs, onRunInitialized still fires immediately during throttle window", async () => {
+  it("with throttleMs, onRunInitialized still fires immediately during throttle window", () => {
     const renderCount = { current: 0 };
     const TestComponent = createTestComponent({
       updates: [
@@ -670,13 +670,13 @@ describe("useAgent throttleMs", () => {
     });
     expect(renderCount.current).toBe(rendersAfterMount + 1);
 
-    // Fire onRunInitialized 10ms later — fires via microtask batch
-    await act(async () => {
+    // Fire onRunInitialized 10ms later — should render immediately
+    act(() => {
       vi.advanceTimersByTime(10);
       notifyRunInitialized(mockAgent);
     });
 
-    // Run status notification fires via microtask batch
+    // Run status notification is NOT throttled — renders immediately
     expect(renderCount.current).toBe(rendersAfterMount + 2);
   });
 

package/src/v2/hooks/__tests__/use-agent.e2e.test.tsx

@@ -19,21 +19,10 @@ import { CopilotChat } from "../../components/chat/CopilotChat";
  * Mock agent that captures RunAgentInput to verify state is passed correctly
  */
 class StateCapturingMockAgent extends MockStepwiseAgent {
-  // Shared via a container so the clone and original both see the same value
-  private _capture: { lastRunInput?: RunAgentInput } = {};
-
-  get lastRunInput(): RunAgentInput | undefined {
-    return this._capture.lastRunInput;
-  }
-
-  clone(): this {
-    const cloned = super.clone();
-    (cloned as unknown as StateCapturingMockAgent)._capture = this._capture;
-    return cloned;
-  }
+  public lastRunInput?: RunAgentInput;
 
   run(input: RunAgentInput): Observable<BaseEvent> {
-    this._capture.lastRunInput = input;
+    this.lastRunInput = input;
     return super.run(input);
   }
 }

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

@@ -502,24 +502,13 @@ describe("useFrontendTool E2E - Dynamic Registration", () => {
   describe("Agent input plumbing", () => {
     it("forwards registered frontend tools to runAgent input", async () => {
       class InstrumentedMockAgent extends MockStepwiseAgent {
-        // Shared so the clone and original both see the captured parameters
-        private _capture: { lastRunParameters?: RunAgentParameters } = {};
-
-        get lastRunParameters(): RunAgentParameters | undefined {
-          return this._capture.lastRunParameters;
-        }
-
-        clone(): this {
-          const cloned = super.clone();
-          (cloned as unknown as InstrumentedMockAgent)._capture = this._capture;
-          return cloned;
-        }
+        public lastRunParameters?: RunAgentParameters;
 
         async runAgent(
           parameters?: RunAgentParameters,
           subscriber?: AgentSubscriber,
         ) {
-          this._capture.lastRunParameters = parameters;
+          this.lastRunParameters = parameters;
           return super.runAgent(parameters, subscriber);
         }
       }
@@ -579,16 +568,8 @@ describe("useFrontendTool E2E - Dynamic Registration", () => {
       class OneShotToolCallAgent extends AbstractAgent {
         private runCount = 0;
         clone(): OneShotToolCallAgent {
-          const cloned = new OneShotToolCallAgent();
-          cloned.agentId = this.agentId;
-          // Share runCount via reference so the second run emits different args
-          Object.defineProperty(cloned, "runCount", {
-            get: () => this.runCount,
-            set: (v: number) => {
-              this.runCount = v;
-            },
-          });
-          return cloned;
+          // Keep state across runs so the second run emits different args
+          return this;
         }
         async detachActiveRun(): Promise<void> {}
         run(_input: RunAgentInput): Observable<BaseEvent> {

package/src/v2/hooks/index.ts

@@ -8,7 +8,6 @@ export { useRenderTool } from "./use-render-tool";
 export { useDefaultRenderTool } from "./use-default-render-tool";
 export { useHumanInTheLoop } from "./use-human-in-the-loop";
 export { useAgent, UseAgentUpdate } from "./use-agent";
-export { useCapabilities } from "./use-capabilities";
 export { useAgentContext } from "./use-agent-context";
 export type { AgentContextInput, JsonSerializable } from "./use-agent-context";
 export { useSuggestions } from "./use-suggestions";