@copilotkit/vue 1.75.1 → 1.76.0

package/src/v2/components/chat/__tests__/CopilotChatMessageView.slotMetaCost.test.ts

@@ -0,0 +1,187 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { defineComponent, h, nextTick, ref } from "vue";
+import { mount } from "@vue/test-utils";
+import type { Message } from "@ag-ui/core";
+import { CopilotKitCore } from "@copilotkit/core";
+import CopilotKitProvider from "../../../providers/CopilotKitProvider.vue";
+import CopilotChatConfigurationProvider from "../../../providers/CopilotChatConfigurationProvider.vue";
+import CopilotChatMessageView from "../CopilotChatMessageView.vue";
+import CopilotChat from "../CopilotChat.vue";
+import { renderWithCopilotKit } from "../../../__tests__/utils/mount";
+import { StateCapturingAgent } from "../../../__tests__/utils/agents";
+
+/**
+ * `getStateByRun` deep-clones the whole run state. The `#message-before` and
+ * `#message-after` slots used to resolve their meta props with six separate
+ * `getMeta()` calls per row, each of which cloned the state, whether or not
+ * the slot read `stateSnapshot` (#7507).
+ */
+
+const messages: Message[] = [
+  { id: "user-1", role: "user", content: "Hello" },
+  { id: "assistant-1", role: "assistant", content: "Hi there" },
+  { id: "user-2", role: "user", content: "Again" },
+];
+
+function installRunSpies() {
+  vi.spyOn(CopilotKitCore.prototype, "getRunIdForMessage").mockReturnValue(
+    "run-1",
+  );
+  return vi
+    .spyOn(CopilotKitCore.prototype, "getStateByRun")
+    .mockImplementation(() => ({ plan: "cloned" }));
+}
+
+function mountMessageView(
+  slots: Parameters<typeof h>[2],
+  providerProps: Record<string, unknown> = {},
+) {
+  return mount(CopilotKitProvider, {
+    props: { runtimeUrl: "/api/copilotkit", ...providerProps },
+    slots: {
+      default: () =>
+        h(
+          CopilotChatConfigurationProvider,
+          { threadId: "thread-1", agentId: "default" },
+          {
+            default: () => h(CopilotChatMessageView, { messages }, slots),
+          },
+        ),
+    },
+  });
+}
+
+describe("CopilotChatMessageView message slot meta cost", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("does not clone run state for a slot that never reads stateSnapshot", () => {
+    const getStateByRun = installRunSpies();
+
+    const wrapper = mountMessageView({
+      "message-before": ({ message }: { message: Message }) =>
+        h("span", { "data-testid": "before" }, message.id),
+      "message-after": ({ message }: { message: Message }) =>
+        h("span", { "data-testid": "after" }, message.id),
+    });
+
+    expect(wrapper.findAll("[data-testid='after']")).toHaveLength(3);
+    expect(wrapper.findAll("[data-testid='before']")).toHaveLength(3);
+    expect(getStateByRun).not.toHaveBeenCalled();
+  });
+
+  it("clones run state at most once per slot render when stateSnapshot is read", () => {
+    const getStateByRun = installRunSpies();
+    const received: unknown[] = [];
+
+    mountMessageView({
+      "message-after": (props: { stateSnapshot: unknown }) => {
+        received.push(props.stateSnapshot);
+        received.push(props.stateSnapshot);
+        return h("span");
+      },
+    });
+
+    expect(received).toHaveLength(6);
+    expect(
+      received.every((s) => (s as { plan: string }).plan === "cloned"),
+    ).toBe(true);
+    expect(getStateByRun).toHaveBeenCalledTimes(3);
+  });
+
+  it("still passes every meta prop to the slot", () => {
+    installRunSpies();
+    const received: Record<string, unknown>[] = [];
+
+    mountMessageView({
+      "message-after": (props: Record<string, unknown>) => {
+        received.push({ ...props });
+        return h("span");
+      },
+    });
+
+    expect(received).toHaveLength(3);
+    expect(received[1]).toMatchObject({
+      message: messages[1],
+      position: "after",
+      runId: "run-1",
+      agentId: "default",
+      stateSnapshot: { plan: "cloned" },
+    });
+    for (const props of received) {
+      expect(props).toHaveProperty("messageIndex");
+      expect(props).toHaveProperty("messageIndexInRun");
+      expect(props).toHaveProperty("numberOfMessagesInRun");
+    }
+  });
+
+  it("clones run state once per row for a provider custom message renderer", () => {
+    const getStateByRun = installRunSpies();
+    const received: unknown[] = [];
+    const renderer = defineComponent({
+      props: ["message", "position", "stateSnapshot"],
+      setup(props) {
+        return () => {
+          received.push(props.stateSnapshot);
+          return h("span", { "data-testid": "custom" });
+        };
+      },
+    });
+
+    const wrapper = mountMessageView(
+      {},
+      { renderCustomMessages: [{ render: renderer }] },
+    );
+
+    // One `before` and one `after` renderer per row.
+    expect(wrapper.findAll("[data-testid='custom']")).toHaveLength(6);
+    expect(
+      received.every((s) => (s as { plan: string }).plan === "cloned"),
+    ).toBe(true);
+    expect(getStateByRun).toHaveBeenCalledTimes(6);
+  });
+
+  it("re-renders slot content when state the slot reads changes", async () => {
+    installRunSpies();
+    const label = ref("first");
+
+    const wrapper = mountMessageView({
+      "message-after": ({ message }: { message: Message }) =>
+        h("span", { "data-testid": "after" }, `${message.id}:${label.value}`),
+    });
+
+    expect(wrapper.findAll("[data-testid='after']")[0]!.text()).toBe(
+      "user-1:first",
+    );
+
+    label.value = "second";
+    await nextTick();
+
+    expect(wrapper.findAll("[data-testid='after']")[0]!.text()).toBe(
+      "user-1:second",
+    );
+  });
+
+  it("keeps the snapshot lazy through CopilotChat slot forwarding", () => {
+    const getStateByRun = installRunSpies();
+    const agent = new StateCapturingAgent([], "default");
+    agent.setMessages(messages);
+
+    const { wrapper } = renderWithCopilotKit(
+      () =>
+        h(
+          CopilotChat,
+          { welcomeScreen: false },
+          {
+            "message-after": ({ message }: { message: Message }) =>
+              h("span", { "data-testid": "after" }, message.id),
+          },
+        ),
+      { agents: { default: agent } },
+    );
+
+    expect(wrapper.findAll("[data-testid='after']")).toHaveLength(3);
+    expect(getStateByRun).not.toHaveBeenCalled();
+  });
+});

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

@@ -21,6 +21,10 @@ import CopilotChatToolCallsView from "../CopilotChatToolCallsView.vue";
 import { useFrontendTool } from "../../../hooks/use-frontend-tool";
 import type { VueFrontendTool } from "../../../types";
 import type { VueToolCallRendererRenderProps } from "../../../types/vue-tool-call-renderer";
+import {
+  runStartedEvent,
+  runFinishedEvent,
+} from "../../../__tests__/utils/test-helpers";
 
 afterEach(() => {
   cleanup();
@@ -43,7 +47,7 @@ class MockStreamingAgent extends AbstractAgent {
       const messageId = `m_${Date.now()}`;
       const toolCallId = `tc_${Date.now()}`;
 
-      observer.next({ type: EventType.RUN_STARTED } as BaseEvent);
+      observer.next(runStartedEvent(_input));
       observer.next({
         type: EventType.TEXT_MESSAGE_CHUNK,
         messageId,
@@ -68,7 +72,7 @@ class MockStreamingAgent extends AbstractAgent {
         messageId: `${messageId}_result`,
         content: JSON.stringify({ temperature: 21, unit: "celsius" }),
       } as BaseEvent);
-      observer.next({ type: EventType.RUN_FINISHED } as BaseEvent);
+      observer.next(runFinishedEvent(_input));
       observer.complete();
     });
   }
@@ -492,9 +496,7 @@ describe("Streaming in-progress without timers", () => {
     const messageId = "m_step";
     const toolCallId = "tc_step";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TEXT_MESSAGE_CHUNK,
       messageId,
@@ -543,9 +545,7 @@ describe("Streaming in-progress without timers", () => {
       expect(el.textContent).toContain("21");
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 });
@@ -586,9 +586,7 @@ describe("Executing State Transitions", () => {
     const messageId = "m_exec";
     const toolCallId = "tc_exec";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -603,9 +601,7 @@ describe("Executing State Transitions", () => {
       expect(status.textContent).toMatch(/Value: test/);
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
 
     await waitFor(() => {
@@ -653,9 +649,7 @@ describe("Multiple Tool Calls in Same Message", () => {
     const toolCallId2 = "tc_2";
     const toolCallId3 = "tc_3";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId: toolCallId1,
@@ -714,9 +708,7 @@ describe("Multiple Tool Calls in Same Message", () => {
       expect(screen.getByTestId("tool1-third").textContent).toContain("C");
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 });
@@ -747,9 +739,7 @@ describe("Partial Args Accumulation", () => {
     const messageId = "m_partial";
     const toolCallId = "tc_partial";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -801,9 +791,7 @@ describe("Partial Args Accumulation", () => {
       expect(tool.textContent).toMatch(/Status: (complete|inProgress)/i);
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 });
@@ -885,7 +873,7 @@ describe("toolCallId parity for registered renderers", () => {
     const messageId = "m_id";
     const toolCallId = "tc_id_parity";
 
-    await agent.emit({ type: EventType.RUN_STARTED } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -900,7 +888,7 @@ describe("toolCallId parity for registered renderers", () => {
       expect(el.textContent).toContain(`id:${toolCallId}`);
     });
 
-    await agent.emit({ type: EventType.RUN_FINISHED } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
 
     await waitFor(() => {
@@ -948,6 +936,8 @@ describe("toolCallId parity for registered renderers", () => {
 describe("Status Persistence After Agent Stops", () => {
   it("should remain in InProgress status after agent stops if no result", async () => {
     const agent = new MockStepwiseAgent();
+    const firstRun = { threadId: agent.threadId, runId: "first-run" };
+    const secondRun = { threadId: agent.threadId, runId: "second-run" };
     renderChatHarness({
       agent,
       frontendTools: [
@@ -967,9 +957,7 @@ describe("Status Persistence After Agent Stops", () => {
     const messageId = "msg_status";
     const toolCallId = "tc_status";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent(firstRun));
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -983,9 +971,7 @@ describe("Status Persistence After Agent Stops", () => {
       expect(statusElement.textContent).toBe("inProgress");
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent(firstRun));
 
     await waitFor(() => {
       const statusElement = screen.getByTestId("status");
@@ -996,9 +982,7 @@ describe("Status Persistence After Agent Stops", () => {
     expect(statusElement.textContent).toBe("inProgress");
     expect(statusElement.textContent).not.toBe("complete");
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent(secondRun));
     await agent.emit({
       type: EventType.TOOL_CALL_RESULT,
       toolCallId,
@@ -1011,9 +995,7 @@ describe("Status Persistence After Agent Stops", () => {
       expect(statusEl.textContent).toBe("complete");
     });
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent(secondRun));
     await agent.complete();
   });
 });

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

@@ -17,6 +17,10 @@ import CopilotKitProvider from "../../../providers/CopilotKitProvider.vue";
 import CopilotChatConfigurationProvider from "../../../providers/CopilotChatConfigurationProvider.vue";
 import CopilotChat from "../CopilotChat.vue";
 import type { VueFrontendTool } from "../../../types";
+import {
+  runStartedEvent,
+  runFinishedEvent,
+} from "../../../__tests__/utils/test-helpers";
 
 afterEach(() => {
   cleanup();
@@ -183,9 +187,7 @@ describe("Tool Call Re-render Prevention", () => {
     const messageId = "m_rerender_test";
     const toolCallId = "tc_rerender_test";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -252,9 +254,7 @@ describe("Tool Call Re-render Prevention", () => {
     expect(screen.getByTestId("location").textContent).toBe("Paris");
     expect(screen.getByTestId("result").textContent).toContain("temperature");
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 
@@ -302,9 +302,7 @@ describe("Tool Call Re-render Prevention", () => {
     const messageId = "m_search";
     const toolCallId = "tc_search";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -334,9 +332,7 @@ describe("Tool Call Re-render Prevention", () => {
     const renderCountAfterText = toolRenderCount;
     expect(renderCountAfterText).toBe(renderCountAfterToolCall);
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 
@@ -384,9 +380,7 @@ describe("Tool Call Re-render Prevention", () => {
     const messageId = "m_search_update";
     const toolCallId = "tc_search_update";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -422,9 +416,7 @@ describe("Tool Call Re-render Prevention", () => {
     expect(capturedArgs).toContain("Rea");
     expect(capturedArgs).toContain("React hooks");
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 
@@ -471,9 +463,7 @@ describe("Tool Call Re-render Prevention", () => {
     const messageId = "m_data";
     const toolCallId = "tc_data";
 
-    await agent.emit({
-      type: EventType.RUN_STARTED,
-    } as BaseEvent);
+    await agent.emit(runStartedEvent());
     await agent.emit({
       type: EventType.TOOL_CALL_CHUNK,
       toolCallId,
@@ -508,9 +498,7 @@ describe("Tool Call Re-render Prevention", () => {
     expect(capturedStatuses).toContain(ToolCallStatus.InProgress);
     expect(capturedStatuses).toContain(ToolCallStatus.Complete);
 
-    await agent.emit({
-      type: EventType.RUN_FINISHED,
-    } as BaseEvent);
+    await agent.emit(runFinishedEvent());
     await agent.complete();
   });
 });

package/src/v2/components/chat/copilotChatToolCallItemRender.ts

@@ -1,4 +1,5 @@
 import type { Message, ToolCall, ToolMessage } from "@ag-ui/core";
+import { contentToText } from "@ag-ui/core";
 import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
 import { ToolCallStatus } from "@copilotkit/core";
 import { partialJSONParse } from "@copilotkit/shared";
@@ -53,7 +54,7 @@ export function getToolCallRenderProps(
       name: toolCall.function.name,
       args: parsedArgs,
       status: ToolCallStatus.Complete,
-      result: toolMessage.content,
+      result: contentToText(toolMessage.content),
       toolCall,
       toolMessage,
     };
@@ -84,7 +85,7 @@ export function getCoreRenderProps(
       toolCallId: toolCall.id,
       args: parsedArgs,
       status: ToolCallStatus.Complete,
-      result: toolMessage.content,
+      result: contentToText(toolMessage.content),
     };
   }
 

package/src/v2/hooks/__tests__/use-agent-headers.test.ts

@@ -0,0 +1,83 @@
+import { AbstractAgent, HttpAgent } from "@ag-ui/client";
+import { defineComponent, h, nextTick } from "vue";
+import { describe, expect, it } from "vitest";
+import { mountWithProvider } from "../../__tests__/utils/mount";
+import { useAgent } from "../use-agent";
+
+// Models an HttpAgent from another installed copy of @ag-ui/client.
+class ForeignHttpAgent extends AbstractAgent {
+  url = "https://agent.example";
+  headers: Record<string, string> = {
+    Authorization: "Bearer agent-token",
+    "X-Agent": "agent",
+  };
+  abortController = new AbortController();
+
+  run(): never {
+    throw new Error("This test does not run the agent");
+  }
+}
+
+describe("useAgent headers (Vue-specific semantics)", () => {
+  it.each([
+    [
+      "HttpAgent",
+      () =>
+        new HttpAgent({
+          url: "https://agent.example",
+          headers: { Authorization: "Bearer agent-token", "X-Agent": "agent" },
+        }),
+    ],
+    ["foreign HttpAgent", () => new ForeignHttpAgent()],
+  ] as const)(
+    "preserves %s headers when the provider changes headers",
+    async (_name, createAgent) => {
+      const agent = createAgent();
+      let headersAfterHook: Record<string, string> | undefined;
+      const Child = defineComponent({
+        setup() {
+          useAgent();
+          headersAfterHook = { ...agent.headers };
+          return () => null;
+        },
+      });
+      const { wrapper } = mountWithProvider(() => h(Child), {
+        runtimeUrl: undefined,
+        agents__unsafe_dev_only: { default: agent },
+        headers: { "X-Core": "initial" },
+      });
+
+      try {
+        expect(headersAfterHook).toEqual({
+          Authorization: "Bearer agent-token",
+          "X-Agent": "agent",
+          "X-Core": "initial",
+        });
+        expect(agent.headers).toEqual({
+          Authorization: "Bearer agent-token",
+          "X-Agent": "agent",
+          "X-Core": "initial",
+        });
+
+        await wrapper.setProps({
+          headers: { Authorization: "Bearer core-token", "X-Core": "updated" },
+        });
+        await nextTick();
+        expect(agent.headers).toEqual({
+          Authorization: "Bearer core-token",
+          "X-Agent": "agent",
+          "X-Core": "updated",
+        });
+
+        await wrapper.setProps({ headers: {} });
+        await nextTick();
+        expect(agent.headers).toEqual({
+          Authorization: "Bearer agent-token",
+          "X-Agent": "agent",
+        });
+      } finally {
+        wrapper.unmount();
+      }
+    },
+  );
+});

package/src/v2/hooks/__tests__/use-agent-stability.test.ts

@@ -34,6 +34,7 @@ describe("useAgent stability during runtime connection", () => {
     // need a no-op subscription object here; stability/ref-identity behavior
     // is orthogonal to subscribe internals.
     subscribeToAgentWithOptions: ReturnType<typeof vi.fn>;
+    applyHeadersToAgent: ReturnType<typeof vi.fn>;
   };
 
   let mockCopilotkit: MockCopilotkit;
@@ -49,6 +50,7 @@ describe("useAgent stability during runtime connection", () => {
       headers: {},
       agents: {},
       subscribeToAgentWithOptions: vi.fn(() => ({ unsubscribe: vi.fn() })),
+      applyHeadersToAgent: vi.fn(),
     });
     mockCopilotkit = copilotkitRef.value;
 

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

@@ -2,7 +2,7 @@ import { defineComponent } from "vue";
 import { screen, fireEvent, waitFor, cleanup } from "@testing-library/vue";
 import { afterEach, describe, expect, it } from "vitest";
 import { EventType } from "@ag-ui/client";
-import type { BaseEvent, RunAgentInput } from "@ag-ui/client";
+import type { BaseEvent, RunAgentInput, RunErrorEvent } from "@ag-ui/client";
 import type { Observable } from "rxjs";
 import {
   MockStepwiseAgent,
@@ -174,9 +174,11 @@ describe("useAgent e2e", () => {
         expect(screen.getByTestId("status").textContent).toBe("running");
       });
 
-      await agent.emit({
+      const errorEvent: RunErrorEvent = {
         type: EventType.RUN_ERROR,
-      } as BaseEvent);
+        message: "The agent run failed",
+      };
+      await agent.emit(errorEvent);
       await agent.complete();
 
       await waitFor(() => {

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

@@ -665,7 +665,7 @@ describe("useFrontendTool E2E - Dynamic Registration", () => {
             const messageId = testId(`m-${this.runCount}`);
             const toolCallId = testId(`tc-${this.runCount}`);
             const valueArg = this.runCount === 1 ? "first call" : "second call";
-            observer.next({ type: EventType.RUN_STARTED } as BaseEvent);
+            observer.next(runStartedEvent(_input));
             observer.next({
               type: EventType.TOOL_CALL_CHUNK,
               toolCallId,
@@ -673,7 +673,7 @@ describe("useFrontendTool E2E - Dynamic Registration", () => {
               parentMessageId: messageId,
               delta: JSON.stringify({ value: valueArg }),
             } as BaseEvent);
-            observer.next({ type: EventType.RUN_FINISHED } as BaseEvent);
+            observer.next(runFinishedEvent(_input));
             observer.complete();
             return () => {};
           });

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

@@ -1,11 +1,11 @@
 import { computed, shallowRef, toValue, triggerRef, watch } from "vue";
 import type { MaybeRefOrGetter } from "vue";
 import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
-import { HttpAgent } from "@ag-ui/client";
 import type { AbstractAgent } from "@ag-ui/client";
 import {
   ProxiedCopilotRuntimeAgent,
   CopilotKitCoreRuntimeConnectionStatus,
+  ɵisHttpAgent,
 } from "@copilotkit/core";
 import type {
   CopilotRuntimeTransport,
@@ -392,8 +392,8 @@ export function useAgent(props: UseAgentProps = {}) {
         ),
     ],
     ([currentAgent]) => {
-      if (currentAgent instanceof HttpAgent) {
-        currentAgent.headers = { ...copilotkit.value.headers };
+      if (ɵisHttpAgent(currentAgent)) {
+        copilotkit.value.applyHeadersToAgent(currentAgent);
       }
     },
     { immediate: true },

package/src/v2/index.ts

@@ -1,6 +1,11 @@
 // Re-export core (framework-agnostic)
 export * from "@copilotkit/core";
 export * from "@ag-ui/client";
+// AG-UI 1.0 moved the zod validators from `@ag-ui/client` to this subpath.
+// Re-export them so existing imports keep working. Both modules export
+// PROTOCOL_VERSION, so name it once to keep it from being ambiguous.
+export * from "@ag-ui/core/schemas";
+export { PROTOCOL_VERSION } from "@ag-ui/client";
 
 // Local V2 vue code
 export * from "./components";