@copilotkit/vue 1.75.2 → 1.76.0

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

package/src/v2/providers/__tests__/CopilotKitProvider.renderCustomMessages.e2e.test.ts

@@ -138,6 +138,8 @@ describe("CopilotKitProvider custom message renderers E2E", () => {
 
   it("renders stored state snapshots for sequential runs", async () => {
     const agent = new MockStepwiseAgent();
+    const firstRun = { threadId: agent.threadId, runId: "first-run" };
+    const secondRun = { threadId: agent.threadId, runId: "second-run" };
     const history: number[] = [];
 
     const emitSnapshot = async (count: number) => {
@@ -153,12 +155,12 @@ describe("CopilotKitProvider custom message renderers E2E", () => {
     const firstAssistantId = testId("assistant-message");
     await submitMessage("First question");
 
-    await agent.emit(runStartedEvent());
+    await agent.emit(runStartedEvent(firstRun));
     await emitSnapshot(1);
     await agent.emit(textMessageStartEvent(firstAssistantId));
     await agent.emit(textMessageContentEvent(firstAssistantId, "First answer"));
     await agent.emit(textMessageEndEvent(firstAssistantId));
-    await agent.emit(runFinishedEvent());
+    await agent.emit(runFinishedEvent(firstRun));
 
     await waitFor(() => {
       expect(
@@ -173,14 +175,14 @@ describe("CopilotKitProvider custom message renderers E2E", () => {
     const secondAssistantId = testId("assistant-message");
     await submitMessage("Second question");
 
-    await agent.emit(runStartedEvent());
+    await agent.emit(runStartedEvent(secondRun));
     await emitSnapshot(2);
     await agent.emit(textMessageStartEvent(secondAssistantId));
     await agent.emit(
       textMessageContentEvent(secondAssistantId, "Second answer"),
     );
     await agent.emit(textMessageEndEvent(secondAssistantId));
-    await agent.emit(runFinishedEvent());
+    await agent.emit(runFinishedEvent(secondRun));
     agent.complete();
 
     await waitFor(() => {