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

package/src/v2/hooks/__tests__/use-threads.test.tsx

@@ -1,16 +1,38 @@
 import React from "react";
 import { act, renderHook, waitFor } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { useCopilotKit } from "../../providers/CopilotKitProvider";
-import { CopilotKitCoreRuntimeConnectionStatus } from "@copilotkit/core";
+import {
+  CopilotKitCoreRuntimeConnectionStatus,
+  ɵMAX_SOCKET_RETRIES,
+} from "@copilotkit/core";
 
 vi.mock("../../providers/CopilotKitProvider", () => ({
   useCopilotKit: vi.fn(),
 }));
 
 const mockUseCopilotKit = useCopilotKit as ReturnType<typeof vi.fn>;
+
+// Shape of the mock socket exposed via the hoisted `phoenix.sockets`
+// array. Defined as a named type so test-side assertions can drop the
+// blanket `any[]` cast and surface socket-API typos at compile time.
+interface MockChannelLike {
+  topic: string;
+  params: Record<string, unknown>;
+  left: boolean;
+  serverPush(event: string, payload: unknown): void;
+}
+interface MockSocketLike {
+  url: string;
+  connected: boolean;
+  disconnected: boolean;
+  channels: MockChannelLike[];
+  triggerError(error?: unknown): void;
+  triggerOpen(): void;
+}
+
 const phoenix = vi.hoisted(() => ({
-  sockets: [] as any[],
+  sockets: [] as MockSocketLike[],
 }));
 
 vi.mock("phoenix", () => {
@@ -31,13 +53,11 @@ vi.mock("phoenix", () => {
     topic: string;
     params: Record<string, unknown>;
     left = false;
-    channels: MockChannel[] = [];
 
     private handlers = new Map<
       string,
       Array<{ ref: number; callback: (payload: unknown) => void }>
     >();
-    private joinPush = new MockPush();
     private nextRef = 1;
 
     constructor(topic = "", params: Record<string, unknown> = {}) {
@@ -63,14 +83,24 @@ vi.mock("phoenix", () => {
         return;
       }
 
+      // Re-check after the early returns above: `off(event)` deletes the
+      // entry, so a subsequent `off(event, ref)` would otherwise hit a
+      // non-null assertion that lies and `.filter` on undefined.
+      const entries = this.handlers.get(event);
+      if (entries === undefined) {
+        return;
+      }
       this.handlers.set(
         event,
-        this.handlers.get(event)!.filter((entry) => entry.ref !== ref),
+        entries.filter((entry) => entry.ref !== ref),
       );
     }
 
     join(): MockPush {
-      return this.joinPush;
+      // Each rejoin must produce a distinct push instance — sharing
+      // one across joins lets stale "ok"/"error" callbacks from a
+      // prior join fire against a new join's listeners.
+      return new MockPush();
     }
 
     leave(): void {
@@ -101,10 +131,22 @@ vi.mock("phoenix", () => {
     }
 
     connect(): void {
+      // Phoenix sockets fire `onOpen` exactly once per WebSocket upgrade,
+      // and the upgrade is asynchronous. Tests must drive that transition
+      // explicitly via `triggerOpen()` so we exercise one open per
+      // connection — auto-firing here would either double-fire (when a
+      // test also calls `triggerOpen()`) or hide cases where production
+      // code forgets to await the open before joining a channel.
       this.connected = true;
     }
 
     disconnect(): void {
+      // Real Phoenix sockets flip `connected` back to false on disconnect —
+      // a mock that only sets `disconnected = true` lets a regression that
+      // forgets to clear `connected` slip through, since assertions like
+      // `socket.connected === false` would be vacuously satisfied by the
+      // initial value but never re-checked after a reconnect cycle.
+      this.connected = false;
       this.disconnected = true;
     }
 
@@ -139,9 +181,12 @@ vi.mock("phoenix", () => {
 });
 
 const fetchMock = vi.fn();
-globalThis.fetch = fetchMock;
+// Use `vi.stubGlobal` so the original `fetch` is restored automatically
+// by `vi.unstubAllGlobals()` below — direct `globalThis.fetch = ...`
+// assignment leaks the mock across test files in the same vitest worker.
+vi.stubGlobal("fetch", fetchMock);
 
-function getMockSockets(): any[] {
+function getMockSockets(): MockSocketLike[] {
   return phoenix.sockets;
 }
 
@@ -154,6 +199,8 @@ function setupCopilotKit(runtimeUrl = "http://localhost:4000") {
       intelligence: {
         wsUrl: "ws://localhost:4000/client",
       },
+      registerThreadStore: vi.fn(),
+      unregisterThreadStore: vi.fn(),
     },
   });
 }
@@ -198,9 +245,20 @@ describe("useThreads", () => {
   beforeEach(() => {
     phoenix.sockets.splice(0);
     fetchMock.mockReset();
+    // Reset before re-priming. setupCopilotKit() uses mockReturnValue, so a
+    // future test that uses mockReturnValueOnce would otherwise leak any
+    // un-consumed queued returns into the next test.
+    mockUseCopilotKit.mockReset();
     setupCopilotKit();
   });
 
+  afterAll(() => {
+    // Pair with `vi.stubGlobal("fetch", fetchMock)` above. Without this
+    // restoration the mock leaks into any sibling test file that runs in
+    // the same vitest worker and assumes a real `fetch`.
+    vi.unstubAllGlobals();
+  });
+
   it("fetches threads and subscribes to the user metadata channel", async () => {
     fetchMock
       .mockReturnValueOnce(
@@ -323,6 +381,9 @@ describe("useThreads", () => {
     await waitFor(() => {
       expect(result.current.threads).toHaveLength(1);
     });
+    // Identity-check the remaining thread so a regression that removes
+    // the wrong thread (e.g. a swapped index) is caught.
+    expect(result.current.threads[0].id).toBe("t-1");
   });
 
   it("renames a thread through the runtime contract", async () => {
@@ -343,10 +404,18 @@ describe("useThreads", () => {
       await result.current.renameThread("t-1", "Renamed");
     });
 
-    const [url, options] = fetchMock.mock.calls[2];
-    expect(url).toContain("/threads/t-1");
-    expect(options.method).toBe("PATCH");
-    expect(JSON.parse(options.body)).toMatchObject({
+    // Find the PATCH call by URL+method rather than a hardcoded index —
+    // a future change to the fetch order (or an extra startup fetch) must
+    // not silently miss the actual rename request.
+    const renameCall = fetchMock.mock.calls.find(
+      (args: unknown[]) =>
+        typeof args[0] === "string" &&
+        (args[0] as string).includes("/threads/t-1") &&
+        (args[1] as { method?: string } | undefined)?.method === "PATCH",
+    );
+    expect(renameCall).toBeDefined();
+    const [, renameOptions] = renameCall!;
+    expect(JSON.parse((renameOptions as { body: string }).body)).toMatchObject({
       agentId: "agent-1",
       name: "Renamed",
     });
@@ -372,17 +441,31 @@ describe("useThreads", () => {
       await result.current.deleteThread("t-1");
     });
 
-    expect(fetchMock.mock.calls[2][0]).toContain("/threads/t-2/archive");
-    expect(fetchMock.mock.calls[2][1].method).toBe("POST");
-    expect(JSON.parse(fetchMock.mock.calls[2][1].body)).toMatchObject({
-      agentId: "agent-1",
-    });
-
-    expect(fetchMock.mock.calls[3][0]).toContain("/threads/t-1");
-    expect(fetchMock.mock.calls[3][1].method).toBe("DELETE");
-    expect(JSON.parse(fetchMock.mock.calls[3][1].body)).toMatchObject({
-      agentId: "agent-1",
-    });
+    // Filter by URL+method rather than fixed indices (mirrors the rename
+    // test above). A future change to the startup fetch order — adding an
+    // /info call, splitting the join token, etc. — must not silently miss
+    // the actual archive/delete requests.
+    const archiveCall = fetchMock.mock.calls.find(
+      (args: unknown[]) =>
+        typeof args[0] === "string" &&
+        (args[0] as string).includes("/threads/t-2/archive") &&
+        (args[1] as { method?: string } | undefined)?.method === "POST",
+    );
+    expect(archiveCall).toBeDefined();
+    expect(
+      JSON.parse((archiveCall![1] as { body: string }).body),
+    ).toMatchObject({ agentId: "agent-1" });
+
+    const deleteCall = fetchMock.mock.calls.find(
+      (args: unknown[]) =>
+        typeof args[0] === "string" &&
+        (args[0] as string).includes("/threads/t-1") &&
+        (args[1] as { method?: string } | undefined)?.method === "DELETE",
+    );
+    expect(deleteCall).toBeDefined();
+    expect(JSON.parse((deleteCall![1] as { body: string }).body)).toMatchObject(
+      { agentId: "agent-1" },
+    );
   });
 
   it("exposes thread-scoped pagination properties", async () => {
@@ -414,6 +497,63 @@ describe("useThreads", () => {
     expect(typeof result.current.fetchMoreThreads).toBe("function");
   });
 
+  it("fetchMoreThreads fetches the next page with the cursor and appends threads", async () => {
+    const nextPageThreads = [
+      {
+        id: "t-3",
+        organizationId: "org-1",
+        agentId: "agent-1",
+        createdById: "user-1",
+        name: "Thread Three",
+        archived: false,
+        createdAt: "2026-01-03T00:00:00Z",
+        updatedAt: "2026-01-03T00:00:00Z",
+      },
+    ];
+
+    fetchMock
+      .mockReturnValueOnce(
+        jsonResponse({
+          threads: sampleThreads,
+          joinCode: "jc-1",
+          nextCursor: "cursor-abc",
+        }),
+      )
+      .mockReturnValueOnce(jsonResponse({ joinToken: "jt-1" }))
+      .mockReturnValueOnce(
+        jsonResponse({ threads: nextPageThreads, joinCode: "jc-1" }),
+      );
+
+    const { result } = renderHook(() => useThreads(defaultInput));
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.threads).toHaveLength(2);
+    expect(result.current.hasMoreThreads).toBe(true);
+
+    act(() => {
+      result.current.fetchMoreThreads();
+    });
+
+    await waitFor(() => {
+      expect(result.current.threads).toHaveLength(3);
+    });
+
+    const nextPageCall = fetchMock.mock.calls.find(
+      (args: unknown[]) =>
+        typeof args[0] === "string" &&
+        (args[0] as string).includes("cursor=cursor-abc"),
+    );
+    expect(nextPageCall).toBeDefined();
+    expect(nextPageCall![0]).toContain("agentId=agent-1");
+    expect(result.current.threads.map((t: { id: string }) => t.id)).toContain(
+      "t-3",
+    );
+    expect(result.current.threads).toHaveLength(3);
+  });
+
   it("does not expose organizationId or createdById on threads", async () => {
     fetchMock
       .mockReturnValueOnce(
@@ -455,10 +595,20 @@ describe("useThreads", () => {
     const socket = getMockSockets()[0];
     const channel = socket.channels[0];
 
+    // Threshold is sourced from production (ɵMAX_SOCKET_RETRIES) so a
+    // future change to the retry budget cannot silently desync the test.
+    // We fire all errors inside a single act to keep the rxjs cleanup
+    // synchronous with the assertions, then check the pre-threshold and
+    // post-threshold states by inspecting the socket between iterations.
     act(() => {
-      for (let index = 0; index < 5; index += 1) {
+      for (let index = 0; index < ɵMAX_SOCKET_RETRIES - 1; index += 1) {
         socket.triggerError();
       }
+      // Pre-threshold: teardown must NOT be premature.
+      expect(channel.left).toBe(false);
+      expect(socket.disconnected).toBe(false);
+      // The Nth error crosses the threshold and triggers teardown.
+      socket.triggerError();
     });
 
     expect(channel.left).toBe(true);
@@ -487,6 +637,47 @@ describe("useThreads", () => {
     expect(socket.disconnected).toBe(true);
   });
 
+  it("registers thread store on mount and unregisters on unmount", async () => {
+    const registerThreadStore = vi.fn();
+    const unregisterThreadStore = vi.fn();
+    // Use mockReturnValue (not mockReturnValueOnce) so the same spies are
+    // returned across all renders, including the cleanup render where
+    // unmount triggers the effect's cleanup function.
+    // runtimeConnectionStatus is set explicitly to Connected — the hook
+    // treats anything other than Connected as "do not dispatch context",
+    // and we want this test to exercise a fully-wired flow.
+    mockUseCopilotKit.mockReturnValue({
+      copilotkit: {
+        runtimeUrl: "http://localhost:4000",
+        runtimeConnectionStatus:
+          CopilotKitCoreRuntimeConnectionStatus.Connected,
+        headers: { Authorization: "Bearer test-token" },
+        intelligence: { wsUrl: "ws://localhost:4000/client" },
+        registerThreadStore,
+        unregisterThreadStore,
+      },
+    });
+
+    fetchMock
+      .mockReturnValueOnce(
+        jsonResponse({ threads: sampleThreads, joinCode: "jc-1" }),
+      )
+      .mockReturnValueOnce(jsonResponse({ joinToken: "jt-1" }));
+
+    const { unmount } = renderHook(() => useThreads(defaultInput));
+
+    await waitFor(() => {
+      expect(registerThreadStore).toHaveBeenCalledWith(
+        "agent-1",
+        expect.objectContaining({ select: expect.any(Function) }),
+      );
+    });
+
+    unmount();
+
+    expect(unregisterThreadStore).toHaveBeenCalledWith("agent-1");
+  });
+
   it("waits for runtimeConnectionStatus=Connected before fetching /threads", async () => {
     // Start in Connecting — hook should hold off on dispatching any request
     // so the initial list fetch includes wsUrl and avoids a redundant second
@@ -498,6 +689,8 @@ describe("useThreads", () => {
           CopilotKitCoreRuntimeConnectionStatus.Connecting,
         headers: { Authorization: "Bearer test-token" },
         intelligence: undefined,
+        registerThreadStore: vi.fn(),
+        unregisterThreadStore: vi.fn(),
       },
     });
 
@@ -509,8 +702,15 @@ describe("useThreads", () => {
 
     const { result, rerender } = renderHook(() => useThreads(defaultInput));
 
-    // Give effects a tick to settle; no fetch should occur while Connecting.
-    await new Promise((resolve) => setTimeout(resolve, 20));
+    // Flush React effects + microtasks deterministically. A bare
+    // setTimeout(20) raced the store-effect under load on slow machines.
+    // Chained microtask flushes inside `act` give every queued effect a
+    // chance to run without depending on real-time delay.
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
     expect(fetchMock).not.toHaveBeenCalled();
 
     // While waiting for Connected, the hook must surface isLoading=true so
@@ -529,6 +729,8 @@ describe("useThreads", () => {
           CopilotKitCoreRuntimeConnectionStatus.Connected,
         headers: { Authorization: "Bearer test-token" },
         intelligence: { wsUrl: "ws://localhost:4000/client" },
+        registerThreadStore: vi.fn(),
+        unregisterThreadStore: vi.fn(),
       },
     });
 

package/src/v2/hooks/use-agent.tsx

@@ -1,5 +1,4 @@
 import { useCopilotKit } from "../providers/CopilotKitProvider";
-import { useCopilotChatConfiguration } from "../providers/CopilotChatConfigurationProvider";
 import { useMemo, useEffect, useReducer, useRef } from "react";
 import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
 import { AbstractAgent, HttpAgent } from "@ag-ui/client";
@@ -23,7 +22,6 @@ const ALL_UPDATES: UseAgentUpdate[] = [
 
 export interface UseAgentProps {
   agentId?: string;
-  threadId?: string;
   updates?: UseAgentUpdate[];
   /**
    * Throttle interval (in milliseconds) for re-renders triggered by
@@ -50,80 +48,7 @@ export interface UseAgentProps {
   throttleMs?: number;
 }
 
-/**
- * Clone a registry agent for per-thread isolation.
- * Copies agent configuration (transport, headers, etc.) but resets conversation
- * state (messages, threadId, state) so each thread starts fresh.
- */
-function cloneForThread(
-  source: AbstractAgent,
-  threadId: string,
-  headers: Record<string, string>,
-): AbstractAgent {
-  const clone = source.clone();
-  if (clone === source) {
-    throw new Error(
-      `useAgent: ${source.constructor.name}.clone() returned the same instance. ` +
-        `clone() must return a new, independent object.`,
-    );
-  }
-  clone.threadId = threadId;
-  clone.setMessages([]);
-  clone.setState({});
-  if (clone instanceof HttpAgent) {
-    clone.headers = { ...headers };
-  }
-  return clone;
-}
-
-/**
- * Module-level WeakMap: registryAgent → (threadId → clone).
- * Shared across all useAgent() calls so that every component using the same
- * (agentId, threadId) pair receives the same agent instance. Using WeakMap
- * ensures the clone map is garbage-collected when the registry agent is
- * replaced (e.g. after reconnect or hot-reload).
- */
-export const globalThreadCloneMap = new WeakMap<
-  AbstractAgent,
-  Map<string, AbstractAgent>
->();
-
-/**
- * Look up an existing per-thread clone without creating one.
- * Returns undefined when no clone has been created yet for this pair.
- */
-export function getThreadClone(
-  registryAgent: AbstractAgent | undefined | null,
-  threadId: string | undefined | null,
-): AbstractAgent | undefined {
-  if (!registryAgent || !threadId) return undefined;
-  return globalThreadCloneMap.get(registryAgent)?.get(threadId);
-}
-
-function getOrCreateThreadClone(
-  existing: AbstractAgent,
-  threadId: string,
-  headers: Record<string, string>,
-): AbstractAgent {
-  let byThread = globalThreadCloneMap.get(existing);
-  if (!byThread) {
-    byThread = new Map();
-    globalThreadCloneMap.set(existing, byThread);
-  }
-  const cached = byThread.get(threadId);
-  if (cached) return cached;
-
-  const clone = cloneForThread(existing, threadId, headers);
-  byThread.set(threadId, clone);
-  return clone;
-}
-
-export function useAgent({
-  agentId,
-  threadId,
-  updates,
-  throttleMs,
-}: UseAgentProps = {}) {
+export function useAgent({ agentId, updates, throttleMs }: UseAgentProps = {}) {
   agentId ??= DEFAULT_AGENT_ID;
 
   const { copilotkit } = useCopilotKit();
@@ -131,12 +56,6 @@ export function useAgent({
   // subscribeToAgentWithOptions reads it from the core instance, but React needs the dep
   // to know when to re-subscribe.
   const providerThrottleMs = copilotkit.defaultThrottleMs;
-  // Fall back to the enclosing CopilotChatConfigurationProvider's threadId so
-  // that useAgent() called without explicit threadId (e.g. inside a custom
-  // message renderer) automatically uses the same per-thread clone as the
-  // CopilotChat component it lives within.
-  const chatConfig = useCopilotChatConfiguration();
-  threadId ??= chatConfig?.threadId;
 
   const [, forceUpdate] = useReducer((x) => x + 1, 0);
 
@@ -153,29 +72,11 @@ export function useAgent({
   );
 
   const agent: AbstractAgent = useMemo(() => {
-    // Use a composite key when threadId is provided so that different threads
-    // for the same agent get independent instances.
-    const cacheKey = threadId ? `${agentId}:${threadId}` : agentId;
-
     const existing = copilotkit.getAgent(agentId);
     if (existing) {
-      // Real agent found — clear any cached provisionals for this key and the
-      // bare agentId key (handles the case where a provisional was created
-      // before threadId was available, then the component re-renders with one).
-      provisionalAgentCache.current.delete(cacheKey);
+      // Real agent found — clear any cached provisional for this ID
       provisionalAgentCache.current.delete(agentId);
-
-      if (!threadId) {
-        // No threadId — return the shared registry agent (original behavior)
-        return existing;
-      }
-
-      // threadId provided — return the shared per-thread clone.
-      // The global WeakMap ensures all components using the same
-      // (registryAgent, threadId) pair receive the same instance, so state
-      // mutations (addMessage, setState) are visible everywhere. The WeakMap
-      // entry is GC-collected automatically when the registry agent is replaced.
-      return getOrCreateThreadClone(existing, threadId, copilotkit.headers);
+      return existing;
     }
 
     const isRuntimeConfigured = copilotkit.runtimeUrl !== undefined;
@@ -188,7 +89,7 @@ export function useAgent({
         status === CopilotKitCoreRuntimeConnectionStatus.Connecting)
     ) {
       // Return cached provisional if available (keeps reference stable)
-      const cached = provisionalAgentCache.current.get(cacheKey);
+      const cached = provisionalAgentCache.current.get(agentId);
       if (cached) {
         // Update headers on the cached agent in case they changed
         cached.headers = { ...copilotkit.headers };
@@ -203,10 +104,7 @@ export function useAgent({
       });
       // Apply current headers so runs/connects inherit them
       provisional.headers = { ...copilotkit.headers };
-      if (threadId) {
-        provisional.threadId = threadId;
-      }
-      provisionalAgentCache.current.set(cacheKey, provisional);
+      provisionalAgentCache.current.set(agentId, provisional);
       return provisional;
     }
 
@@ -219,10 +117,7 @@ export function useAgent({
       isRuntimeConfigured &&
       status === CopilotKitCoreRuntimeConnectionStatus.Error
     ) {
-      // Cache the provisional so that dep changes while in Error state (e.g.
-      // headers update) return the same agent reference, matching the
-      // Disconnected/Connecting path and preventing spurious re-subscriptions.
-      const cached = provisionalAgentCache.current.get(cacheKey);
+      const cached = provisionalAgentCache.current.get(agentId);
       if (cached) {
         cached.headers = { ...copilotkit.headers };
         return cached;
@@ -234,10 +129,7 @@ export function useAgent({
         runtimeMode: "pending",
       });
       provisional.headers = { ...copilotkit.headers };
-      if (threadId) {
-        provisional.threadId = threadId;
-      }
-      provisionalAgentCache.current.set(cacheKey, provisional);
+      provisionalAgentCache.current.set(agentId, provisional);
       return provisional;
     }
 
@@ -256,7 +148,6 @@ export function useAgent({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     agentId,
-    threadId,
     copilotkit.agents,
     copilotkit.runtimeConnectionStatus,
     copilotkit.runtimeUrl,

package/src/v2/hooks/use-render-activity-message.tsx

@@ -3,12 +3,10 @@ import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
 import { useCopilotKit, useCopilotChatConfiguration } from "../providers";
 import { useCallback, useMemo } from "react";
 import { ReactActivityMessageRenderer } from "../types";
-import { getThreadClone } from "./use-agent";
 
 export function useRenderActivityMessage() {
   const { copilotkit } = useCopilotKit();
-  const config = useCopilotChatConfiguration();
-  const agentId = config?.agentId ?? DEFAULT_AGENT_ID;
+  const agentId = useCopilotChatConfiguration()?.agentId ?? DEFAULT_AGENT_ID;
 
   const renderers = copilotkit.renderActivityMessages;
 
@@ -52,13 +50,7 @@ export function useRenderActivityMessage() {
       }
 
       const Component = renderer.render;
-      // Prefer the per-thread clone so that handleAction in ReactSurfaceHost
-      // calls runAgent on the same agent instance that CopilotChat renders from.
-      // Without this, button clicks accumulate messages on the registry agent
-      // while CopilotChat displays from the clone — responses appear to vanish.
-      const registryAgent = copilotkit.getAgent(agentId);
-      const agent =
-        getThreadClone(registryAgent, config?.threadId) ?? registryAgent;
+      const agent = copilotkit.getAgent(agentId);
 
       return (
         <Component
@@ -70,7 +62,7 @@ export function useRenderActivityMessage() {
         />
       );
     },
-    [agentId, config?.threadId, copilotkit, findRenderer],
+    [agentId, copilotkit, findRenderer],
   );
 
   return useMemo(

package/src/v2/hooks/use-render-custom-messages.tsx

@@ -1,5 +1,4 @@
 import { useCopilotChatConfiguration, useCopilotKit } from "../providers";
-import { getThreadClone } from "./use-agent";
 import { ReactCustomMessageRendererPosition } from "../types/react-custom-message-renderer";
 import { Message } from "@ag-ui/core";
 
@@ -39,11 +38,7 @@ export function useRenderCustomMessages() {
       copilotkit.getRunIdForMessage(agentId, threadId, message.id) ??
       copilotkit.getRunIdsForThread(agentId, threadId).slice(-1)[0];
     const runId = resolvedRunId ?? `missing-run-id:${message.id}`;
-    // Prefer the per-thread clone so that agent.messages reflects the actual
-    // conversation state (messages live on the clone, not the registry agent).
-    // Fall back to the registry agent when no clone exists (no threadId).
-    const registryAgent = copilotkit.getAgent(agentId);
-    const agent = getThreadClone(registryAgent, threadId) ?? registryAgent;
+    const agent = copilotkit.getAgent(agentId);
     if (!agent) {
       return null;
     }

package/src/v2/hooks/use-threads.tsx

@@ -253,6 +253,13 @@ export function useThreads({
   // realtime subscription or cached thread list stays usable while the
   // runtime recovers, and we don't re-trigger a fetch storm on transitions.
   const runtimeStatus = copilotkit.runtimeConnectionStatus;
+  useEffect(() => {
+    copilotkit.registerThreadStore(agentId, store);
+    return () => {
+      copilotkit.unregisterThreadStore(agentId);
+    };
+  }, [copilotkit, agentId, store]);
+
   useEffect(() => {
     if (!copilotkit.runtimeUrl) {
       store.setContext(null);
@@ -283,7 +290,6 @@ export function useThreads({
     headersKey,
     copilotkit.intelligence?.wsUrl,
     agentId,
-    copilotkit.headers,
     includeArchived,
     limit,
   ]);