test(core,react-core): port isolation regression tests to registerProxiedAgent

Re-adds the isolation coverage that the per-thread cloning revert deleted,
rewritten against the explicit-registration model:

- 9 new core-level tests in core-register-proxied-agent.test.ts cover the
  cases from the deleted use-agent-thread-isolation.test.tsx — distinct
  instances when two proxies target the same remoteAgentId, message and
  state isolation between proxies, independent threadId per proxy, shared
  outbound URL (both route to remoteAgentId), getAgent identity, pending
  registration before runtime connect, registration with a remote id the
  runtime doesn't yet know, and re-register-after-unregister yielding a
  fresh proxy.

- 1 new react-core test in CopilotChatActivityRendering.e2e.test.tsx
  replaces the deleted "passes the per-thread clone to activity message
  renderers" regression test. The clone-vs-registry trap is gone in the
  new model, so the test is reframed: the renderer must receive the agent
  registered under the local agentId, not any other agent in the registry
  (e.g. the runtime-side id a proxy might route to).

Total: +10 tests. Core 415 → 424, react-core 1150 → 1151.

Author: mme

packages/core/src/__tests__/core-register-proxied-agent.test.ts

@@ -112,3 +112,188 @@ describe("CopilotKitCore.registerProxiedAgent", () => {
     expect(agent.headers?.Authorization).toBe("Bearer abc");
   });
 });
+
+/**
+ * Isolation behavior — ports the cases from the deleted
+ * `use-agent-thread-isolation.test.tsx` to the new explicit-registration model.
+ *
+ * The old design implicitly cloned a registry agent per (agentId, threadId).
+ * The new model: callers register a distinct proxy per logical "chat", each
+ * with its own local agentId. Multiple proxies can point at the same
+ * `remoteAgentId` to share a runtime agent without sharing in-memory state.
+ */
+describe("CopilotKitCore.registerProxiedAgent — isolation", () => {
+  let core: CopilotKitCore;
+
+  beforeEach(() => {
+    core = new CopilotKitCore({ runtimeUrl: "http://localhost:4000" });
+  });
+
+  it("two proxies registered against the same remoteAgentId are distinct instances", () => {
+    const a = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    const b = core.registerProxiedAgent({
+      agentId: "chat-2",
+      remoteAgentId: "default",
+    });
+
+    expect(a.agent).not.toBe(b.agent);
+    expect(core.getAgent("chat-1")).toBe(a.agent);
+    expect(core.getAgent("chat-2")).toBe(b.agent);
+    expect(a.agent.agentId).toBe("chat-1");
+    expect(b.agent.agentId).toBe("chat-2");
+    expect(a.agent.remoteAgentId).toBe("default");
+    expect(b.agent.remoteAgentId).toBe("default");
+  });
+
+  it("two proxies share the same outbound URL (both route to remoteAgentId)", () => {
+    const a = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    const b = core.registerProxiedAgent({
+      agentId: "chat-2",
+      remoteAgentId: "default",
+    });
+
+    const urlA = (a.agent as unknown as { url: string }).url;
+    const urlB = (b.agent as unknown as { url: string }).url;
+    expect(urlA).toBe(urlB);
+    expect(urlA).toContain("/agent/default/run");
+    expect(urlA).not.toContain("chat-1");
+    expect(urlA).not.toContain("chat-2");
+  });
+
+  it("isolates messages between two proxies pointing to the same remoteAgentId", () => {
+    const a = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    const b = core.registerProxiedAgent({
+      agentId: "chat-2",
+      remoteAgentId: "default",
+    });
+
+    a.agent.addMessage({
+      id: "msg-a-1",
+      role: "user",
+      content: "hello from chat-1",
+    });
+
+    expect(a.agent.messages).toHaveLength(1);
+    expect(b.agent.messages).toHaveLength(0);
+
+    b.agent.addMessage({
+      id: "msg-b-1",
+      role: "user",
+      content: "hello from chat-2",
+    });
+
+    expect(a.agent.messages).toHaveLength(1);
+    expect(b.agent.messages).toHaveLength(1);
+    expect(a.agent.messages[0]?.id).toBe("msg-a-1");
+    expect(b.agent.messages[0]?.id).toBe("msg-b-1");
+  });
+
+  it("isolates state between two proxies pointing to the same remoteAgentId", () => {
+    const a = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    const b = core.registerProxiedAgent({
+      agentId: "chat-2",
+      remoteAgentId: "default",
+    });
+
+    a.agent.setState({ counter: 1 });
+    b.agent.setState({ counter: 99 });
+
+    expect(a.agent.state).toEqual({ counter: 1 });
+    expect(b.agent.state).toEqual({ counter: 99 });
+  });
+
+  it("each proxy can hold its own threadId without affecting others", () => {
+    const a = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    const b = core.registerProxiedAgent({
+      agentId: "chat-2",
+      remoteAgentId: "default",
+    });
+
+    a.agent.threadId = "thread-a";
+    b.agent.threadId = "thread-b";
+
+    expect(a.agent.threadId).toBe("thread-a");
+    expect(b.agent.threadId).toBe("thread-b");
+  });
+
+  it("getAgent returns the same proxy instance across calls (no per-call clone)", () => {
+    const { agent } = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+
+    expect(core.getAgent("chat-1")).toBe(agent);
+    expect(core.getAgent("chat-1")).toBe(agent);
+  });
+
+  it("registering before runtime connects yields a proxy in pending runtimeMode", () => {
+    // Disconnected core (no runtime URL set) — proxy still mints, but in a
+    // mode that doesn't try to call out before /info has been resolved.
+    const offlineCore = new CopilotKitCore({});
+    const { agent } = offlineCore.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    expect(agent).toBeInstanceOf(ProxiedCopilotRuntimeAgent);
+    // The proxy is registered and queryable even with no runtime URL.
+    expect(offlineCore.getAgent("chat-1")).toBe(agent);
+  });
+
+  it("a proxy registered with a remote id that doesn't (yet) exist on the runtime is still usable for in-memory ops", () => {
+    // The runtime might not know `phantom` — the proxy is opaque about that.
+    // Registering doesn't validate against /info; the user vouches for the
+    // remote id. Local subscriber bookkeeping (messages, state, threadId)
+    // works regardless.
+    const { agent } = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "phantom",
+    });
+
+    agent.addMessage({ id: "m", role: "user", content: "test" });
+    agent.setState({ ok: true });
+    agent.threadId = "t";
+
+    expect(agent.messages).toHaveLength(1);
+    expect(agent.state).toEqual({ ok: true });
+    expect(agent.threadId).toBe("t");
+    expect(agent.remoteAgentId).toBe("phantom");
+  });
+
+  it("registering, unregistering, and re-registering the same agentId yields a fresh proxy", () => {
+    const first = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+    first.agent.addMessage({
+      id: "m-1",
+      role: "user",
+      content: "before unregister",
+    });
+
+    first.unregister();
+
+    const second = core.registerProxiedAgent({
+      agentId: "chat-1",
+      remoteAgentId: "default",
+    });
+
+    expect(second.agent).not.toBe(first.agent);
+    // The fresh proxy starts empty — no carry-over from the previous proxy.
+    expect(second.agent.messages).toHaveLength(0);
+  });
+});

packages/react-core/src/v2/components/chat/__tests__/CopilotChatActivityRendering.e2e.test.tsx

@@ -1,6 +1,7 @@
 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,
@@ -304,6 +305,66 @@ 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. the runtime-side id a proxy might route to).
+    //
+    // Pre-#3525 → #3630 cycle, this manifested as a clone-vs-registry split.
+    // In the explicit-registration model the trap is different: a refactor
+    // could accidentally key on a proxy's `remoteAgentId` instead of its
+    // local `agentId`. This test pins the local-id contract by mounting two
+    // distinct mock agents and asserting the renderer receives the one that
+    // matches `config.agentId`.
+    const localAgent = new MockStepwiseAgent();
+    localAgent.agentId = "chat-1";
+    const otherAgent = new MockStepwiseAgent();
+    otherAgent.agentId = "default";
+
+    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: { "chat-1": localAgent, default: otherAgent },
+      agentId: "chat-1",
+      threadId: "thread-for-action-test",
+      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();
+    });
+
+    localAgent.emit(runStartedEvent());
+    localAgent.emit(
+      activitySnapshotEvent({
+        messageId: testId("activity-action"),
+        activityType: "button-action",
+        content: { label: "Click Me" },
+      }),
+    );
+    localAgent.emit(runFinishedEvent());
+
+    await waitFor(() => {
+      expect(screen.getByTestId("action-button")).toBeDefined();
+    });
+
+    expect(capturedAgent).toBe(localAgent);
+    expect(capturedAgent).not.toBe(otherAgent);
+  });
+
   it("restores a completed A2UI surface after reconnect from an event-native baseline", async () => {
     const agent = new MockReconnectableAgent();
     const threadId = testId("a2ui-thread");