@copilotkit/react-core 1.56.5-canary.1777972218 → 1.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/react-core",
-  "version": "1.56.5-canary.1777972218",
+  "version": "1.57.0",
   "private": false,
   "keywords": [
     "ai",
@@ -73,11 +73,11 @@
     "untruncate-json": "^0.0.1",
     "use-stick-to-bottom": "^1.1.1",
     "zod-to-json-schema": "^3.24.5",
-    "@copilotkit/core": "1.56.5-canary.1777972218",
-    "@copilotkit/a2ui-renderer": "1.56.5-canary.1777972218",
-    "@copilotkit/runtime-client-gql": "1.56.5-canary.1777972218",
-    "@copilotkit/shared": "1.56.5-canary.1777972218",
-    "@copilotkit/web-inspector": "1.56.5-canary.1777972218"
+    "@copilotkit/core": "1.57.0",
+    "@copilotkit/shared": "1.57.0",
+    "@copilotkit/a2ui-renderer": "1.57.0",
+    "@copilotkit/runtime-client-gql": "1.57.0",
+    "@copilotkit/web-inspector": "1.57.0"
   },
   "devDependencies": {
     "@tailwindcss/cli": "^4.1.11",

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

@@ -179,9 +179,10 @@ describe("useCopilotChatInternal – connectAgent guard", () => {
   });
 
   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.
+    // useAgent now returns a per-thread clone, so 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";
@@ -229,13 +230,13 @@ describe("useCopilotChatInternal – connectAgent guard", () => {
     });
   });
 
-  it("passes resolved agentId to useAgent", () => {
+  it("passes config threadId to useAgent", () => {
     applyMocks();
 
     renderHook(() => useCopilotChatInternal(), { wrapper: createWrapper() });
 
     expect(vi.mocked(useAgent)).toHaveBeenCalledWith(
-      expect.objectContaining({ agentId: "test-agent" }),
+      expect.objectContaining({ threadId: "config-thread-id" }),
     );
   });
 });

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

@@ -339,6 +339,7 @@ export function useCopilotChatInternal({
   const resolvedAgentId = existingConfig?.agentId ?? "default";
   const { agent } = useAgent({
     agentId: resolvedAgentId,
+    threadId: existingConfig?.threadId,
   });
 
   // Track the last agent instance we called connect() on. Without this,

package/src/v2/components/chat/CopilotChat.tsx

@@ -118,6 +118,7 @@ export function CopilotChat({
 
   const { agent } = useAgent({
     agentId: resolvedAgentId,
+    threadId: resolvedThreadId,
     throttleMs,
   });
   const { copilotkit } = useCopilotKit();
@@ -234,8 +235,6 @@ export function CopilotChat({
       agent.abortController = connectAbortController;
     }
 
-    agent.threadId = resolvedThreadId;
-
     const connect = async (agent: AbstractAgent) => {
       try {
         await copilotkit.connectAgent({ agent });

package/src/v2/components/chat/CopilotChatMessageView.tsx

@@ -22,10 +22,9 @@ import {
 } from "@ag-ui/core";
 import { twMerge } from "tailwind-merge";
 import { useRenderActivityMessage, useRenderCustomMessages } from "../../hooks";
+import { getThreadClone } from "../../hooks/use-agent";
 import { useCopilotKit } from "../../providers/CopilotKitProvider";
 import { useCopilotChatConfiguration } from "../../providers/CopilotChatConfigurationProvider";
-import { IntelligenceIndicator } from "../intelligence-indicator";
-import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
 
 /**
  * Resolves a slot value into a { Component, slotProps } pair, handling the three
@@ -283,63 +282,25 @@ const MemoizedCustomMessage = React.memo(
       message: Message;
       position: "before" | "after";
     }) => React.ReactElement | null;
-    stateSnapshot: unknown;
-    numberOfMessagesInRun: number | undefined;
-    isInLatestRun: boolean | undefined;
-    isRunning: boolean;
+    stateSnapshot?: unknown;
   }) {
     return renderCustomMessage({ message, position });
   },
   (prevProps, nextProps) => {
-    // Skip the re-render unless an input that an authored renderer can
-    // observe has changed. Each branch returns false to invalidate.
+    // Only re-render if the message or position changed
     if (prevProps.message.id !== nextProps.message.id) return false;
     if (prevProps.position !== nextProps.position) return false;
+    // Compare message content - for assistant messages this is a string, for others may differ
     if (prevProps.message.content !== nextProps.message.content) return false;
     if (prevProps.message.role !== nextProps.message.role) return false;
-    // State snapshot — custom renderers may read it. Deep-compare via
-    // JSON.stringify (state-manager already deep-copies on each call, so
-    // reference equality would never hit anyway).
+    // Compare state snapshot - custom renderers may depend on state
     if (
       JSON.stringify(prevProps.stateSnapshot) !==
       JSON.stringify(nextProps.stateSnapshot)
     )
       return false;
-    // Re-render when this message's run grows. The runId-to-message
-    // association is unidirectional in StateManager (only set, never
-    // revoked except via clearAgentState/clearThreadState which wipe
-    // wholesale), so in practice this fires only on growth as new messages
-    // stream into the run. Slots in completed runs are unaffected — their
-    // count is stable once the run has finished.
-    if (prevProps.numberOfMessagesInRun !== nextProps.numberOfMessagesInRun)
-      return false;
-    // Re-render when this message's run stops being the latest run on the
-    // thread — e.g. a new run starts and previously-completed messages need
-    // to drop "is this the latest activity?" indicators. Only the slots
-    // belonging to the run that just lost its "latest" status are
-    // invalidated; the new run's slots and any older runs are unaffected.
-    if (prevProps.isInLatestRun !== nextProps.isInLatestRun) return false;
-    // Re-render when isRunning flips, but only for slots known to belong
-    // to the latest run (`isInLatestRun === true`). Slots whose run is
-    // older or whose run-id hasn't been recorded yet (undefined) are not
-    // invalidated on isRunning changes — this preserves the perf guarantee
-    // that completed messages skip re-renders during streaming.
-    //
-    // Renderers that gate solely on `agent.isRunning` and attach to a
-    // message added before any run started (e.g. a user message inserted
-    // before runAgent fires) won't observe the false→true transition for
-    // the first run. In practice this is rare; the canonical pattern is
-    // to gate on the slot's own runId membership (see
-    // intelligence-indicator/__tests__/IntelligenceIndicator.e2e.test.tsx
-    // for the recommended renderer shape).
-    if (
-      nextProps.isInLatestRun &&
-      prevProps.isRunning !== nextProps.isRunning
-    )
-      return false;
-    // Note: renderCustomMessage's reference is intentionally not compared —
-    // it's a closure that changes frequently. The inputs above are the only
-    // observable signals.
+    // Note: We don't compare renderCustomMessage function reference because it changes
+    // frequently. The message and state comparison is sufficient to determine if a re-render is needed.
     return true;
   },
 );
@@ -431,14 +392,18 @@ export function CopilotChatMessageView({
   // Subscribe to state changes so custom message renderers re-render when state updates.
   useEffect(() => {
     if (!config?.agentId) return;
-    const agent = copilotkit.getAgent(config.agentId);
+    const registryAgent = copilotkit.getAgent(config.agentId);
+    // Prefer the per-thread clone so that state changes from the running agent
+    // (which is the clone, not the registry) trigger re-renders.
+    const agent =
+      getThreadClone(registryAgent, config.threadId) ?? registryAgent;
     if (!agent) return;
 
     const subscription = agent.subscribe({
       onStateChanged: forceUpdate,
     });
     return () => subscription.unsubscribe();
-  }, [config?.agentId, copilotkit, forceUpdate]);
+  }, [config?.agentId, config?.threadId, copilotkit, forceUpdate]);
 
   // Subscribe to interrupt element changes for in-chat rendering.
   const [interruptElement, setInterruptElement] =
@@ -453,48 +418,6 @@ export function CopilotChatMessageView({
     return () => subscription.unsubscribe();
   }, [copilotkit]);
 
-  // Build per-run metadata once per render, not once per message. The two
-  // memo inputs MemoizedCustomMessage cares about (numberOfMessagesInRun and
-  // isInLatestRun) are both derived from the same scan of `messages` →
-  // `getRunIdForMessage`, so consolidating here turns an O(n²) per-render
-  // pass (one O(n) helper call per message) into a single O(n) pass.
-  //
-  // Re-fires whenever messages, the active agent/thread, or copilotkit
-  // changes. The internal messageToRun map can update without these props
-  // changing (a runId association lands one tick after the message is
-  // appended) — in that case the next external trigger refreshes. Note
-  // the `MemoizedCustomMessage` gate at the `isInLatestRun &&` check is
-  // strict-truthy — slots whose runId is still undefined during that
-  // pre-association window will not re-render on isRunning flips. The
-  // canonical pattern (see the IntelligenceIndicator e2e test) is to gate
-  // the renderer on the slot's own runId membership rather than `isRunning`
-  // alone, so the limitation doesn't bite typical use.
-  const runMetadata = useMemo(() => {
-    if (!config) return null;
-    const runIdByMessageId = new Map<string, string>();
-    for (const msg of messages) {
-      const r = copilotkit.getRunIdForMessage(
-        config.agentId,
-        config.threadId,
-        msg.id,
-      );
-      if (r) runIdByMessageId.set(msg.id, r);
-    }
-    const countByRunId = new Map<string, number>();
-    for (const r of runIdByMessageId.values()) {
-      countByRunId.set(r, (countByRunId.get(r) ?? 0) + 1);
-    }
-    let latestRunId: string | undefined;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const r = runIdByMessageId.get(messages[i]!.id);
-      if (r) {
-        latestRunId = r;
-        break;
-      }
-    }
-    return { runIdByMessageId, countByRunId, latestRunId };
-  }, [messages, config?.agentId, config?.threadId, copilotkit]);
-
   // Helper to get state snapshot for a message (used for memoization)
   const getStateSnapshotForMessage = (messageId: string): unknown => {
     if (!config) return undefined;
@@ -619,14 +542,6 @@ export function CopilotChatMessageView({
   const renderMessageBlock = (message: Message): React.ReactElement[] => {
     const elements: (React.ReactElement | null | undefined)[] = [];
     const stateSnapshot = getStateSnapshotForMessage(message.id);
-    const messageRunId = runMetadata?.runIdByMessageId.get(message.id);
-    const numberOfMessagesInRun = messageRunId
-      ? runMetadata?.countByRunId.get(messageRunId)
-      : undefined;
-    const isInLatestRun =
-      messageRunId === undefined
-        ? undefined
-        : messageRunId === runMetadata?.latestRunId;
 
     if (renderCustomMessage) {
       elements.push(
@@ -636,9 +551,6 @@ export function CopilotChatMessageView({
           position="before"
           renderCustomMessage={renderCustomMessage}
           stateSnapshot={stateSnapshot}
-          numberOfMessagesInRun={numberOfMessagesInRun}
-          isInLatestRun={isInLatestRun}
-          isRunning={isRunning}
         />,
       );
     }
@@ -692,29 +604,6 @@ export function CopilotChatMessageView({
           position="after"
           renderCustomMessage={renderCustomMessage}
           stateSnapshot={stateSnapshot}
-          numberOfMessagesInRun={numberOfMessagesInRun}
-          isInLatestRun={isInLatestRun}
-          isRunning={isRunning}
-        />,
-      );
-    }
-
-    // Auto-mount the IntelligenceIndicator on assistant message slots
-    // when the runtime is in intelligence mode. The component self-gates
-    // further (last in run, latest run, matching tool call) so only one
-    // pill renders at a time — but mounting it only for assistant
-    // messages avoids spinning up a `useAgent` subscription, a 200 ms
-    // poll interval, and four effects on every user/reasoning/activity
-    // slot just to have it return null at the role gate.
-    if (
-      copilotkit.intelligence !== undefined &&
-      message.role === "assistant"
-    ) {
-      elements.push(
-        <IntelligenceIndicator
-          key={`${message.id}-intelligence`}
-          message={message}
-          agentId={config?.agentId ?? DEFAULT_AGENT_ID}
         />,
       );
     }

package/src/v2/components/chat/CopilotChatView.tsx

@@ -89,8 +89,8 @@ export type CopilotChatViewProps = WithSlots<
     /**
      * When `true`, suppresses the welcome screen while a thread's initial
      * connect is in flight. Prevents the "How can I help you today?" flash
-     * that would otherwise appear between mounting an empty agent instance
-     * and the bootstrap messages arriving from /connect.
+     * that would otherwise appear between mounting an empty cloned agent and
+     * the bootstrap messages arriving from /connect.
      */
     isConnecting?: boolean;
     /**

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

@@ -9,7 +9,8 @@ import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
 
 /**
  * Mock agent that records every connectAgent() invocation and resolves
- * immediately with an empty run result.
+ * immediately with an empty run result. Tracking lives on the class so
+ * per-thread clones (from useAgent's WeakMap) share the counter.
  */
 class TrackingAgent extends MockStepwiseAgent {
   static connectCalls: Array<{
@@ -106,6 +107,7 @@ describe("CopilotChat welcome / connect integration", () => {
         expect(TrackingAgent.connectCalls.length).toBeGreaterThan(0);
       });
 
+      // The per-thread clone carries threadId; agentId is the default.
       expect(
         TrackingAgent.connectCalls.some((c) => c.threadId === "real-thread"),
       ).toBe(true);

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

@@ -1,7 +1,6 @@
 import React from "react";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { z } from "zod";
-import type { AbstractAgent } from "@ag-ui/client";
 import { EventType } from "@ag-ui/client";
 import {
   MockReconnectableAgent,
@@ -18,7 +17,9 @@ import {
   CopilotKitProvider,
   useCopilotKit,
 } from "../../../providers";
+import type { AbstractAgent } from "@ag-ui/client";
 import { IntelligenceAgent } from "@copilotkit/core";
+import { getThreadClone } from "../../../hooks/use-agent";
 import { createA2UIMessageRenderer } from "../../../a2ui/A2UIMessageRenderer";
 import type { Theme } from "@copilotkit/a2ui-renderer";
 import { CopilotChat } from "..";
@@ -305,28 +306,18 @@ describe("CopilotChat activity message rendering", () => {
     expect(capturedCopilotkit).toBeDefined();
   });
 
-  it("activity renderers receive the agent under the config agentId, not any other registered agent", async () => {
-    // Regression: the renderer's `agent` prop must come from
-    // `copilotkit.getAgent(config.agentId)` — the local registry id from
-    // CopilotChatConfigurationProvider — not from any other agent in the
-    // registry (e.g. a sibling chat's agent).
-    //
-    // The trap this catches is a refactor where the renderer pipeline keys
-    // on something other than `config.agentId` (e.g. for proxied
-    // registrations, accidentally keying on `proxy.remoteAgentId`). The
-    // assertion shape — "two agents in the registry, the renderer must
-    // receive the one matching config.agentId" — is generic to that bug
-    // class. The proxy-routing-specific behavior (registering a
-    // ProxiedCopilotRuntimeAgent with `remoteAgentId !== agentId` and
-    // verifying `getAgent(agentId)` returns the proxy, not the agent at
-    // remoteAgentId) is covered by `core-register-proxied-agent.test.ts`
-    // at the registry level.
-    const localAgent = new MockStepwiseAgent();
-    localAgent.agentId = "chat-1";
-    const otherAgent = new MockStepwiseAgent();
-    otherAgent.agentId = "default";
+  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() }),
@@ -337,9 +328,9 @@ describe("CopilotChat activity message rendering", () => {
     };
 
     renderWithCopilotKit({
-      agents: { "chat-1": localAgent, default: otherAgent },
-      agentId: "chat-1",
-      threadId: "thread-for-action-test",
+      agents: { [agentId]: agent },
+      agentId,
+      threadId,
       renderActivityMessages: [activityRenderer],
     });
 
@@ -351,22 +342,27 @@ describe("CopilotChat activity message rendering", () => {
       expect(screen.getByText("show me buttons")).toBeDefined();
     });
 
-    localAgent.emit(runStartedEvent());
-    localAgent.emit(
+    agent.emit(runStartedEvent());
+    agent.emit(
       activitySnapshotEvent({
         messageId: testId("activity-action"),
         activityType: "button-action",
         content: { label: "Click Me" },
       }),
     );
-    localAgent.emit(runFinishedEvent());
+    agent.emit(runFinishedEvent());
 
     await waitFor(() => {
       expect(screen.getByTestId("action-button")).toBeDefined();
     });
 
-    expect(capturedAgent).toBe(localAgent);
-    expect(capturedAgent).not.toBe(otherAgent);
+    // 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
   });
 
   it("restores a completed A2UI surface after reconnect from an event-native baseline", async () => {

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

@@ -49,11 +49,6 @@ class MockMCPProxyAgent extends AbstractAgent {
     this.runAgentResponses.set(method, response);
   }
 
-  addMessage(msg: Parameters<AbstractAgent["addMessage"]>[0]) {
-    this.addMessageCalls.push(msg as any);
-    return super.addMessage(msg);
-  }
-
   emit(event: BaseEvent) {
     if (event.type === EventType.RUN_STARTED) {
       this.isRunning = true;
@@ -75,6 +70,66 @@ class MockMCPProxyAgent extends AbstractAgent {
     });
   }
 
+  clone(): MockMCPProxyAgent {
+    const cloned = new MockMCPProxyAgent();
+    cloned.agentId = this.agentId;
+    type Internal = {
+      subject: Subject<BaseEvent>;
+      runAgentCalls: Array<{ input: Partial<RunAgentInput> }>;
+      addMessageCalls: Array<{ id: string; role: string; content: string }>;
+      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).addMessageCalls = (
+      this as unknown as Internal
+    ).addMessageCalls;
+    (cloned as unknown as Internal).runAgentResponses = (
+      this as unknown as Internal
+    ).runAgentResponses;
+
+    const registry = this;
+    Object.defineProperty(cloned, "isRunning", {
+      get() {
+        return registry.isRunning;
+      },
+      set(v: boolean) {
+        registry.isRunning = v;
+      },
+      configurable: true,
+      enumerable: true,
+    });
+
+    const proto = MockMCPProxyAgent.prototype;
+    cloned.runAgent = async function (
+      input?: Partial<RunAgentInput>,
+    ): Promise<RunAgentResult> {
+      const proxiedRequest = input?.forwardedProps?.__proxiedMCPRequest;
+      if (proxiedRequest) {
+        return registry.runAgent(input);
+      }
+      return proto.runAgent.call(cloned, input);
+    };
+
+    // Track addMessage calls on the clone (the component uses the clone)
+    const origAddMessage = cloned.addMessage.bind(cloned);
+    cloned.addMessage = function (msg: Parameters<typeof origAddMessage>[0]) {
+      registry.addMessageCalls.push(msg as any);
+      return origAddMessage(msg);
+    };
+
+    // Proxy run() calls so spies on the registry's run() see clone invocations
+    cloned.run = function (input: RunAgentInput): Observable<BaseEvent> {
+      return registry.run(input);
+    };
+
+    return cloned;
+  }
+
   async detachActiveRun(): Promise<void> {}
 
   run(_input: RunAgentInput): Observable<BaseEvent> {

package/src/v2/components/index.ts

@@ -5,4 +5,3 @@ export * from "./chat";
 export * from "./WildcardToolCallRender";
 export * from "./CopilotKitInspector";
 export * from "./MCPAppsActivityRenderer";
-export * from "./intelligence-indicator";