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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/react-core",
-  "version": "1.57.0-canary.1778082736",
+  "version": "1.57.0-canary.1778116520",
   "private": false,
   "keywords": [
     "ai",
@@ -46,6 +46,14 @@
       "require": "./dist/v2/index.cjs"
     },
     "./package.json": "./package.json",
+    "./v2/context": {
+      "import": "./dist/v2/context.mjs",
+      "require": "./dist/v2/context.cjs"
+    },
+    "./v2/headless": {
+      "import": "./dist/v2/headless.mjs",
+      "require": "./dist/v2/headless.cjs"
+    },
     "./v2/styles.css": "./dist/v2/index.css"
   },
   "publishConfig": {
@@ -73,11 +81,11 @@
     "untruncate-json": "^0.0.1",
     "use-stick-to-bottom": "^1.1.1",
     "zod-to-json-schema": "^3.24.5",
-    "@copilotkit/a2ui-renderer": "1.57.0-canary.1778082736",
-    "@copilotkit/core": "1.57.0-canary.1778082736",
-    "@copilotkit/runtime-client-gql": "1.57.0-canary.1778082736",
-    "@copilotkit/web-inspector": "1.57.0-canary.1778082736",
-    "@copilotkit/shared": "1.57.0-canary.1778082736"
+    "@copilotkit/a2ui-renderer": "1.57.0-canary.1778116520",
+    "@copilotkit/runtime-client-gql": "1.57.0-canary.1778116520",
+    "@copilotkit/core": "1.57.0-canary.1778116520",
+    "@copilotkit/shared": "1.57.0-canary.1778116520",
+    "@copilotkit/web-inspector": "1.57.0-canary.1778116520"
   },
   "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/MCPAppsActivityRenderer.tsx

@@ -281,6 +281,14 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
       resourceUri: string | null;
     }>({ inProgress: false, promise: null, resourceUri: null });
 
+    // Destructure resource identifiers so the fetch effect's deps array tracks
+    // primitives, not the `content` object reference. `content` gets a new
+    // identity on every ACTIVITY_SNAPSHOT from the MCP middleware, which would
+    // otherwise re-fire the effect mid-stream and race with `agent.messages`
+    // catching up to the server — triggering LangGraph's regenerate path and
+    // an infinite "Message not found" loop.
+    const { resourceUri, serverHash, serverId } = content;
+
     // Callback to send a message to the iframe
     const sendToIframe = useCallback((msg: JSONRPCMessage) => {
       if (iframeRef.current?.contentWindow) {
@@ -328,8 +336,6 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
     // Effect 0: Fetch the resource content on mount
     // Uses ref-based deduplication to handle React StrictMode double-mounting
     useEffect(() => {
-      const { resourceUri, serverHash, serverId } = content;
-
       // Check if we already have a fetch in progress for this resource
       // This handles StrictMode double-mounting - second mount reuses first mount's promise
       if (
@@ -416,7 +422,7 @@ export const MCPAppsActivityRenderer: React.FC<MCPAppsActivityRendererProps> =
         });
 
       // No cleanup needed - we want the fetch to complete even if StrictMode unmounts
-    }, [agent, content]);
+    }, [agent, resourceUri, serverHash, serverId]);
 
     // Effect 1: Setup sandbox proxy iframe and communication (after resource is fetched)
     useEffect(() => {

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

@@ -8,12 +8,11 @@ import React, {
 } from "react";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { ScrollElementContext } from "./scroll-element-context";
-import type { WithSlots } from "../../lib/slots";
-import { renderSlot, isReactComponentType } from "../../lib/slots";
+import { WithSlots, renderSlot, isReactComponentType } from "../../lib/slots";
 import CopilotChatAssistantMessage from "./CopilotChatAssistantMessage";
 import CopilotChatUserMessage from "./CopilotChatUserMessage";
 import CopilotChatReasoningMessage from "./CopilotChatReasoningMessage";
-import type {
+import {
   ActivityMessage,
   AssistantMessage,
   Message,
@@ -23,10 +22,9 @@ import type {
 } 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
@@ -394,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] =
@@ -606,23 +608,6 @@ export function CopilotChatMessageView({
       );
     }
 
-    // Auto-mount the IntelligenceIndicator on assistant message slots
-    // when the runtime is in intelligence mode. The component self-gates
-    // further (latest matching-assistant slot, pending tool-call grace
-    // window) so only one pill renders at a time — mounting only for
-    // assistant messages avoids the per-slot `useAgent` subscription
-    // and four effects on user/reasoning/activity slots that would just
-    // return null at the role gate anyway.
-    if (copilotkit.intelligence !== undefined && message.role === "assistant") {
-      elements.push(
-        <IntelligenceIndicator
-          key={`${message.id}-intelligence`}
-          message={message}
-          agentId={config?.agentId ?? DEFAULT_AGENT_ID}
-        />,
-      );
-    }
-
     return elements.filter(Boolean) as React.ReactElement[];
   };
 

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.runtimeAgentId`). 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 `runtimeAgentId !== agentId` and
-    // verifying `getAgent(agentId)` returns the proxy, not the agent at
-    // runtimeAgentId) 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__/MCPAppsActivityRenderer.e2e.test.tsx

@@ -788,6 +788,108 @@ describe("MCP Apps Activity Renderer E2E", () => {
     });
   });
 
+  describe("Effect Re-fire Prevention", () => {
+    // Helper: count proxied resources/read calls for a given URI.
+    const readCountFor = (agent: MockMCPProxyAgent, uri: string) =>
+      agent.runAgentCalls.filter(
+        (call) =>
+          call.input.forwardedProps?.__proxiedMCPRequest?.method ===
+            "resources/read" &&
+          (
+            call.input.forwardedProps?.__proxiedMCPRequest as {
+              params?: { uri?: string };
+            }
+          )?.params?.uri === uri,
+      ).length;
+
+    it("does not refetch when content reference changes but resourceUri/serverHash/serverId are unchanged", async () => {
+      // Regression: ACTIVITY_SNAPSHOT events from the MCP middleware mutate
+      // content.result on every chat re-render, giving `content` a new object
+      // identity. The fetch effect must depend on the resource identifiers
+      // (primitives), not the content reference, otherwise it re-fires
+      // mid-stream and races with `agent.messages` -> "Message not found" loop.
+      const agent = new MockMCPProxyAgent();
+      const agentId = "mcp-test-agent";
+      agent.agentId = agentId;
+
+      agent.setRunAgentResponse("resources/read", {
+        contents: [
+          {
+            uri: "ui://stable/resource",
+            mimeType: "text/html",
+            text: "<html><body>Stable</body></html>",
+          },
+        ],
+      });
+
+      renderWithCopilotKit({
+        agents: { [agentId]: agent },
+        agentId,
+      });
+
+      const input = await screen.findByRole("textbox");
+      fireEvent.change(input, { target: { value: "Stable" } });
+      fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
+
+      await waitFor(() => {
+        expect(screen.getByText("Stable")).toBeDefined();
+      });
+
+      const messageId = testId("mcp-stable");
+
+      // First snapshot: initial mount triggers a fetch.
+      agent.emit(runStartedEvent());
+      agent.emit(
+        activitySnapshotEvent({
+          messageId,
+          activityType: MCPAppsActivityType,
+          content: mcpAppsActivityContent({
+            resourceUri: "ui://stable/resource",
+            serverHash: "stable-hash",
+            result: {
+              content: [{ type: "text", text: "first" }],
+              isError: false,
+            },
+          }),
+        }),
+      );
+      agent.emit(runFinishedEvent());
+
+      await waitFor(
+        () => {
+          expect(readCountFor(agent, "ui://stable/resource")).toBe(1);
+        },
+        { timeout: 2000 },
+      );
+
+      // Second snapshot: same identifiers, fresh content reference (mutated
+      // result). Should NOT refire the fetch effect.
+      agent.emit(runStartedEvent());
+      agent.emit(
+        activitySnapshotEvent({
+          messageId,
+          activityType: MCPAppsActivityType,
+          content: mcpAppsActivityContent({
+            resourceUri: "ui://stable/resource",
+            serverHash: "stable-hash",
+            result: {
+              content: [{ type: "text", text: "second" }],
+              isError: false,
+            },
+          }),
+        }),
+      );
+      agent.emit(runFinishedEvent());
+
+      // Give any incorrect re-fire a chance to land before asserting.
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      });
+
+      expect(readCountFor(agent, "ui://stable/resource")).toBe(1);
+    });
+  });
+
   describe("Content Types", () => {
     it("handles text content from resource", async () => {
       const agent = new MockMCPProxyAgent();

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";

package/src/v2/context.ts

@@ -0,0 +1,62 @@
+"use client";
+
+import { createContext, useContext, useEffect, useReducer } from "react";
+import { CopilotKitCoreReact } from "./lib/react-core";
+import type { CopilotKitCoreReactConfig } from "./lib/react-core";
+import type { LicenseContextValue } from "@copilotkit/shared";
+
+// Re-export so headless.ts (and consumers) reference the same type declaration.
+export { CopilotKitCoreReact };
+export type { CopilotKitCoreReactConfig };
+
+export interface CopilotKitContextValue {
+  copilotkit: CopilotKitCoreReact;
+  /**
+   * Set of tool call IDs currently being executed.
+   * This is tracked at the provider level to ensure tool execution events
+   * are captured even before child components mount.
+   */
+  executingToolCallIds: ReadonlySet<string>;
+}
+
+export const EMPTY_SET: ReadonlySet<string> = new Set();
+
+export const CopilotKitContext = createContext<CopilotKitContextValue | null>(
+  null,
+);
+
+export const useCopilotKit = (): CopilotKitContextValue => {
+  const context = useContext(CopilotKitContext);
+  const [, forceUpdate] = useReducer((x: number) => x + 1, 0);
+
+  if (!context) {
+    throw new Error("useCopilotKit must be used within CopilotKitProvider");
+  }
+  useEffect(() => {
+    const subscription = context.copilotkit.subscribe({
+      onRuntimeConnectionStatusChanged: () => {
+        forceUpdate();
+      },
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return context;
+};
+
+// License context — shared between web and RN providers.
+// Default is permissive (all features allowed) — providers override via createLicenseContextValue.
+// Inlined here to avoid a runtime import from @copilotkit/shared, which pulls in
+// Node-only deps (jose) that break React Native's Metro bundler.
+export const LicenseContext = createContext<LicenseContextValue>({
+  status: null,
+  license: null,
+  checkFeature: () => true,
+  getLimit: () => null,
+} as LicenseContextValue);
+
+export const useLicenseContext = (): LicenseContextValue =>
+  useContext(LicenseContext);

package/src/v2/headless.ts

@@ -0,0 +1,42 @@
+/**
+ * Headless (platform-agnostic) exports from @copilotkit/react-core/v2.
+ *
+ * No CSS, no web UI components, no DOM dependencies.
+ * Used by @copilotkit/react-native.
+ */
+
+// Re-export from context (which is external in this build) so the .d.ts
+// references the same type declaration. This avoids a nominal type mismatch
+// caused by private class members being declared in two separate .d.ts files.
+export { CopilotKitCoreReact } from "./context";
+export type { CopilotKitCoreReactConfig } from "./context";
+
+// Chat configuration provider (no UI, just context)
+export {
+  CopilotChatConfigurationProvider,
+  useCopilotChatConfiguration,
+  CopilotChatDefaultLabels,
+  type CopilotChatLabels,
+  type CopilotChatConfigurationValue,
+  type CopilotChatConfigurationProviderProps,
+} from "./providers/CopilotChatConfigurationProvider";
+
+// Platform-agnostic hooks
+export { useAgent, type UseAgentUpdate } from "./hooks/use-agent";
+export { useFrontendTool } from "./hooks/use-frontend-tool";
+export { useComponent } from "./hooks/use-component";
+export { useHumanInTheLoop } from "./hooks/use-human-in-the-loop";
+export { useInterrupt, type UseInterruptConfig } from "./hooks/use-interrupt";
+export { useSuggestions } from "./hooks/use-suggestions";
+export { useConfigureSuggestions } from "./hooks/use-configure-suggestions";
+export {
+  useAgentContext,
+  type AgentContextInput,
+  type JsonSerializable,
+} from "./hooks/use-agent-context";
+export {
+  useThreads,
+  type Thread,
+  type UseThreadsInput,
+  type UseThreadsResult,
+} from "./hooks/use-threads";

package/src/v2/hooks/__tests__/standard-schema.test.tsx

@@ -6,12 +6,12 @@ import * as v from "valibot";
 import { type } from "arktype";
 import { useRenderTool, type RenderToolProps } from "../use-render-tool";
 import { useComponent } from "../use-component";
-import { useCopilotKit } from "../../providers/CopilotKitProvider";
+import { useCopilotKit } from "../../context";
 import { useFrontendTool } from "../use-frontend-tool";
 import type { ReactToolCallRenderer } from "../../types/react-tool-call-renderer";
 import type { StandardSchemaV1 } from "@copilotkit/shared";
 
-vi.mock("../../providers/CopilotKitProvider", () => ({
+vi.mock("../../context", () => ({
   useCopilotKit: vi.fn(),
 }));
 

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

@@ -2,10 +2,10 @@ import React, { useState } from "react";
 import { render, act } from "@testing-library/react";
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { useAgentContext, type AgentContextInput } from "../use-agent-context";
-import { useCopilotKit } from "../../providers/CopilotKitProvider";
+import { useCopilotKit } from "../../context";
 
-// Mock the CopilotKitProvider
-vi.mock("../../providers/CopilotKitProvider", () => ({
+// Mock the CopilotKit context
+vi.mock("../../context", () => ({
   useCopilotKit: vi.fn(),
 }));