@copilotkit/vue 1.75.2 → 1.77.0

package/src/v2/components/chat/__tests__/CopilotChat.clearOnFresh.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { defineComponent, h, nextTick } from "vue";
+import { defineComponent, h, nextTick, ref } from "vue";
 import { flushPromises, mount } from "@vue/test-utils";
 import CopilotKitProvider from "../../../providers/CopilotKitProvider.vue";
 import CopilotChatConfigurationProvider from "../../../providers/CopilotChatConfigurationProvider.vue";
@@ -14,6 +14,134 @@ import CopilotChat from "../CopilotChat.vue";
 //     configuration transitions to a fresh, non-explicit thread via
 //     startNewThread()
 describe("CopilotChat clear-on-fresh", () => {
+  it.each(["clearReplayCursor", "clearReconnectCursor"] as const)(
+    "clears state and the captured %s cursor on a fresh selection",
+    async (method) => {
+      const agent = new StateCapturingAgent();
+      const cursors = new Map<string, string>();
+      Object.defineProperty(agent, method, {
+        value: (threadId: string) => cursors.delete(threadId),
+      });
+      const threadId = ref("saved");
+      const explicit = ref(true);
+      const wrapper = mount(CopilotKitProvider, {
+        props: { agents__unsafe_dev_only: { default: agent } },
+        slots: {
+          default: () =>
+            h(
+              CopilotChatConfigurationProvider,
+              { threadId: threadId.value, hasExplicitThreadId: explicit.value },
+              { default: () => h(CopilotChat, { welcomeScreen: false }) },
+            ),
+        },
+      });
+      await flushPromises();
+      agent.setState({ saved: true });
+      agent.pendingInterrupts = [{ id: "approval-A", reason: "confirmation" }];
+      cursors.set("saved", "last-event");
+      cursors.set("other", "keep-other");
+      threadId.value = "fresh";
+      explicit.value = false;
+      await flushPromises();
+      expect(agent.state).toEqual({});
+      expect(agent.pendingInterrupts).toEqual([]);
+      expect(cursors.get("saved")).toBeUndefined();
+      expect(cursors.get("other")).toBe("keep-other");
+      wrapper.unmount();
+    },
+  );
+  it.each(["fresh", "saved", "other", "via-fresh", "swap"])(
+    "protects %s from an abandoned connect that completes later",
+    async (destination) => {
+      let releaseDetach = () => {};
+      let releaseConnect = () => {};
+      let pendingDetach: Promise<void> | undefined;
+      const oldConnect = new Promise<void>((resolve) => {
+        releaseConnect = resolve;
+      });
+      const cursors = new Map<string, string>();
+      const requests: (string | null)[] = [];
+      class ReplayAgent extends StateCapturingAgent {
+        clearReplayCursor(threadId: string) {
+          cursors.delete(threadId);
+        }
+        async detachActiveRun() {
+          await pendingDetach;
+          await super.detachActiveRun();
+        }
+        async connectAgent(
+          ...args: Parameters<StateCapturingAgent["connectAgent"]>
+        ) {
+          requests.push(cursors.get(this.threadId) ?? null);
+          const first = requests.length === 1;
+          const result = await super.connectAgent(...args);
+          if (first) await oldConnect;
+          return result;
+        }
+      }
+      const agent = new ReplayAgent();
+      let currentAgent = agent;
+      const threadId = ref("saved");
+      const explicit = ref(true);
+      const wrapper = mount(CopilotKitProvider, {
+        props: { agents__unsafe_dev_only: { default: agent } },
+        slots: {
+          default: () =>
+            h(
+              CopilotChatConfigurationProvider,
+              { threadId: threadId.value, hasExplicitThreadId: explicit.value },
+              { default: () => h(CopilotChat, { welcomeScreen: false }) },
+            ),
+        },
+      });
+      await flushPromises();
+      expect(requests).toEqual([null]);
+      pendingDetach = new Promise<void>((resolve) => {
+        releaseDetach = resolve;
+      });
+      cursors.set("saved", "old-event");
+      threadId.value = "fresh";
+      explicit.value = false;
+      await nextTick();
+      if (destination === "via-fresh") {
+        threadId.value = "fresh-again";
+        await nextTick();
+      }
+      if (destination === "swap") {
+        currentAgent = new ReplayAgent();
+        await wrapper.setProps({
+          agents__unsafe_dev_only: { default: currentAgent },
+        });
+      }
+      const target =
+        destination === "via-fresh" || destination === "swap"
+          ? "saved"
+          : destination;
+      if (target !== "fresh") {
+        threadId.value = target;
+        explicit.value = true;
+        await nextTick();
+      }
+      expect(requests).toEqual([null]);
+      cursors.set("saved", "late-event");
+      releaseDetach();
+      await flushPromises();
+      expect(requests).toEqual(target === "fresh" ? [null] : [null, null]);
+      currentAgent.setState({ current: true });
+      currentAgent.pendingInterrupts = [
+        { id: "approval-new", reason: "confirmation" },
+      ];
+      cursors.set(target, "new-event");
+      releaseConnect();
+      await flushPromises();
+      expect(currentAgent.state).toEqual({ current: true });
+      expect(currentAgent.pendingInterrupts).toEqual([
+        { id: "approval-new", reason: "confirmation" },
+      ]);
+      expect(cursors.get(target)).toBe("new-event");
+      wrapper.unmount();
+    },
+  );
   it("does not clear messages on initial mount", async () => {
     const agent = new StateCapturingAgent();
     // Spy before mount: attaching afterwards can never observe a mount-time
@@ -133,7 +261,7 @@ describe("CopilotChat clear-on-fresh", () => {
     await nextTick();
     expect(currentThreadId).toBe("elsewhere");
 
-    newAgent!.setMessages([{ id: "m1", role: "user", content: "hi" } as never]);
+    newAgent!.setMessages([{ id: "m1", role: "user", content: "hi" }]);
     expect(newAgent!.messages.length).toBe(1);
 
     // Switch back non-explicitly. Any `setMessages([])` observed here must come

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

@@ -3,6 +3,7 @@ import { computed, defineComponent, onMounted } from "vue";
 import type { PropType } from "vue";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { EventType } from "@ag-ui/client";
+import type { RunErrorEvent } from "@ag-ui/client";
 import { z } from "zod";
 import { useConfigureSuggestions } from "../../../hooks/use-configure-suggestions";
 import {
@@ -189,7 +190,11 @@ describe("CopilotChat E2E - Chat Basics and Streaming Patterns", () => {
         );
       });
 
-      await agent.emit({ type: EventType.RUN_ERROR } as any);
+      const errorEvent: RunErrorEvent = {
+        type: EventType.RUN_ERROR,
+        message: "Test run failed",
+      };
+      await agent.emit(errorEvent);
       await agent.complete();
 
       await waitFor(() => {

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/__tests__/CopilotPopupView.slots.e2e.test.ts

@@ -540,6 +540,26 @@ describe("CopilotPopupView Slot System E2E Tests", () => {
   });
 
   describe("8. Integration Tests", () => {
+    it("keeps the transparent-background utility on the positioning wrapper", () => {
+      const Host = defineComponent({
+        components: { CopilotPopupView },
+        setup() {
+          return { sampleMessages };
+        },
+        template: `<CopilotPopupView :messages="sampleMessages" :default-open="true" />`,
+      });
+
+      const { container } = renderInWrapper(Host);
+      const popup = container.querySelector("[data-copilot-popup]");
+      const positioningWrapper = popup?.parentElement;
+
+      expect(positioningWrapper?.hasAttribute("data-copilotkit")).toBe(true);
+      // jsdom does not load the generated stylesheet; this guards the utility-class contract only.
+      expect(positioningWrapper?.classList.contains("cpk:bg-transparent")).toBe(
+        true,
+      );
+    });
+
     it("should render popup with all default components when open", () => {
       const Host = defineComponent({
         components: { CopilotPopupView },

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