@copilotkit/vue 2.0.0-rc.1 → 2.0.0-rc.2

package/src/v2/lib/__tests__/message-feedback.test.ts

@@ -0,0 +1,152 @@
+import { CopilotKitCore } from "@copilotkit/core";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  getMessageFeedback,
+  subscribeToMessageFeedback,
+  MESSAGE_FEEDBACK_EVENT_NAME,
+  setMessageFeedback,
+  ɵresetMessageFeedbackCache,
+} from "../message-feedback";
+
+const emoji = "👍";
+
+/** A Core that records what it emits, with its agent-text choice stubbed. */
+function capturingCore({ agentText = true } = {}) {
+  const copilotkit = new CopilotKitCore({});
+  vi.spyOn(copilotkit, "ɵlearningCapturesAgentText", "get").mockReturnValue(
+    agentText,
+  );
+  const emit = vi
+    .spyOn(copilotkit, "emitTrajectoryEvent")
+    .mockImplementation(() => {});
+  return { copilotkit, emit };
+}
+
+const reply = { id: "m1", role: "assistant" as const, content: "Approved." };
+
+const rate = (
+  copilotkit: CopilotKitCore,
+  feedback: { rating: "up" | "down"; comment?: string } | null,
+  message: { id: string; role: "assistant"; content: string } = reply,
+) =>
+  setMessageFeedback({
+    copilotkit,
+    agentId: "agent",
+    threadId: "thread",
+    message,
+    feedback,
+  });
+
+describe("message feedback store", () => {
+  beforeEach(() => ɵresetMessageFeedbackCache());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("cuts long text without splitting a character", () => {
+    const { copilotkit, emit } = capturingCore();
+
+    rate(
+      copilotkit,
+      { rating: "up", comment: emoji.repeat(1200) },
+      { id: "m1", role: "assistant", content: emoji.repeat(600) },
+    );
+
+    const [name, value] = emit.mock.calls[0]!;
+    expect(name).toBe(MESSAGE_FEEDBACK_EVENT_NAME);
+    expect(value).toMatchObject({
+      response: emoji.repeat(500),
+      comment: emoji.repeat(1000),
+    });
+  });
+
+  it("keeps the rating and sends each change, a removal as null", () => {
+    const { copilotkit, emit } = capturingCore();
+
+    rate(copilotkit, { rating: "up" });
+    expect(getMessageFeedback("agent", "thread", "m1")).toEqual({
+      rating: "up",
+    });
+    rate(copilotkit, null);
+
+    expect(getMessageFeedback("agent", "thread", "m1")).toBeUndefined();
+    expect(emit.mock.calls.map(([, value]) => value)).toEqual([
+      expect.objectContaining({ feedbackId: "thread:m1", rating: "up" }),
+      expect.objectContaining({ feedbackId: "thread:m1", rating: null }),
+    ]);
+  });
+
+  it("trims a comment and drops a blank one", () => {
+    const { copilotkit } = capturingCore();
+
+    rate(copilotkit, { rating: "down", comment: "   " });
+    expect(getMessageFeedback("agent", "thread", "m1")).toEqual({
+      rating: "down",
+    });
+    rate(copilotkit, { rating: "down", comment: "  padded  " });
+
+    expect(getMessageFeedback("agent", "thread", "m1")).toEqual({
+      rating: "down",
+      comment: "padded",
+    });
+  });
+
+  it("tells only the rated Thread's listeners", () => {
+    const { copilotkit } = capturingCore();
+    const rated = vi.fn();
+    const other = vi.fn();
+    subscribeToMessageFeedback("agent", "thread", rated);
+    subscribeToMessageFeedback("agent", "other", other);
+
+    rate(copilotkit, { rating: "up" });
+
+    expect(rated).toHaveBeenCalledTimes(1);
+    expect(other).not.toHaveBeenCalled();
+  });
+
+  it("keeps the object of a rating that did not change", () => {
+    const { copilotkit } = capturingCore();
+    rate(copilotkit, { rating: "up" });
+    const before = getMessageFeedback("agent", "thread", "m1");
+
+    rate(
+      copilotkit,
+      { rating: "down" },
+      { id: "m2", role: "assistant", content: "No." },
+    );
+
+    expect(getMessageFeedback("agent", "thread", "m1")).toBe(before);
+  });
+
+  it("treats message ids like object keys as plain ids", () => {
+    const { copilotkit } = capturingCore();
+
+    rate(
+      copilotkit,
+      { rating: "up" },
+      { id: "__proto__", role: "assistant", content: "" },
+    );
+
+    expect(getMessageFeedback("agent", "thread", "__proto__")).toEqual({
+      rating: "up",
+    });
+    expect(
+      getMessageFeedback("agent", "thread", "constructor"),
+    ).toBeUndefined();
+  });
+
+  it("leaves out the reply text when capture omits agent text", () => {
+    const { copilotkit, emit } = capturingCore({ agentText: false });
+
+    rate(copilotkit, { rating: "up" });
+
+    expect(emit.mock.calls[0]![1]).not.toHaveProperty("response");
+  });
+
+  it("names the reply's run when Core knows it", () => {
+    const { copilotkit, emit } = capturingCore();
+    vi.spyOn(copilotkit, "getRunIdForMessage").mockReturnValue("run-9");
+
+    rate(copilotkit, { rating: "up" });
+
+    expect(emit.mock.calls[0]![1]).toMatchObject({ runId: "run-9" });
+  });
+});

package/src/v2/lib/message-feedback.ts

@@ -0,0 +1,120 @@
+import type { AssistantMessage } from "@ag-ui/core";
+import type { CopilotKitCore } from "@copilotkit/core";
+
+/** Trajectory event name for a rating of one assistant message. */
+export const MESSAGE_FEEDBACK_EVENT_NAME = "message.feedback";
+
+/** Longest comment kept, in characters; the rest is cut so the event stays small. */
+export const MESSAGE_FEEDBACK_MAX_COMMENT_LENGTH = 1000;
+
+/** Longest excerpt of the rated response sent with the rating, in characters. */
+const RESPONSE_EXCERPT_LENGTH = 500;
+
+export type MessageFeedbackRating = "up" | "down";
+
+/** The rating this page gave one assistant message. */
+export interface MessageFeedback {
+  readonly rating: MessageFeedbackRating;
+  readonly comment?: string;
+}
+
+// Ratings given on this page, by message. Kept outside Vue, so a rated
+// message that scrolls out of a virtual list still shows its rating when it
+// comes back. Intelligence holds the ratings across page loads.
+const ratings = new Map<string, MessageFeedback>();
+const listeners = new Map<string, Set<() => void>>();
+
+const threadKey = (agentId: string, threadId: string) =>
+  JSON.stringify([agentId, threadId]);
+
+const messageKey = (agentId: string, threadId: string, messageId: string) =>
+  JSON.stringify([agentId, threadId, messageId]);
+
+/** Cuts `text` to `max` characters without splitting a surrogate pair. */
+const clip = (text: string, max: number): string => {
+  const characters = Array.from(text);
+  return characters.length > max ? characters.slice(0, max).join("") : text;
+};
+
+/** The comment as kept and sent: trimmed and capped, or none. */
+const normalizeComment = (comment: unknown): string | undefined => {
+  if (typeof comment !== "string") return undefined;
+  const text = clip(comment.trim(), MESSAGE_FEEDBACK_MAX_COMMENT_LENGTH);
+  return text === "" ? undefined : text;
+};
+
+/** The rating this page gave one message, if any. */
+export function getMessageFeedback(
+  agentId: string,
+  threadId: string,
+  messageId: string,
+): MessageFeedback | undefined {
+  return ratings.get(messageKey(agentId, threadId, messageId));
+}
+
+/** Calls `listener` whenever a rating in this Thread changes. */
+export function subscribeToMessageFeedback(
+  agentId: string,
+  threadId: string,
+  listener: () => void,
+): () => void {
+  const key = threadKey(agentId, threadId);
+  let set = listeners.get(key);
+  if (set === undefined) {
+    set = new Set();
+    listeners.set(key, set);
+  }
+  set.add(listener);
+  return () => {
+    set.delete(listener);
+    if (set.size === 0) listeners.delete(key);
+  };
+}
+
+/**
+ * Sets (or, with `null`, clears) this page's rating of one message and sends
+ * it to the active Trajectory. Every change is a new event; the newest event
+ * for a `feedbackId` is the current one. Like any Trajectory event, a change
+ * made while no Trajectory captures, for example during a reconnect, is not
+ * sent; the page still shows it.
+ */
+export function setMessageFeedback(params: {
+  copilotkit: CopilotKitCore;
+  agentId: string;
+  threadId: string;
+  message: AssistantMessage;
+  feedback: MessageFeedback | null;
+}): void {
+  const { copilotkit, agentId, threadId, message } = params;
+  const comment = normalizeComment(params.feedback?.comment);
+  const feedback: MessageFeedback | null = params.feedback && {
+    rating: params.feedback.rating,
+    ...(comment ? { comment } : {}),
+  };
+
+  const key = messageKey(agentId, threadId, message.id);
+  if (feedback) ratings.set(key, feedback);
+  else ratings.delete(key);
+  for (const listener of listeners.get(threadKey(agentId, threadId)) ?? [])
+    listener();
+
+  const runId = copilotkit.getRunIdForMessage(agentId, threadId, message.id);
+  copilotkit.emitTrajectoryEvent(MESSAGE_FEEDBACK_EVENT_NAME, {
+    feedbackId: `${threadId}:${message.id}`,
+    threadId,
+    messageId: message.id,
+    agentId,
+    ...(runId ? { runId } : {}),
+    rating: feedback?.rating ?? null,
+    ...(feedback?.comment ? { comment: feedback.comment } : {}),
+    // A custom sink set to omit agent text gets no excerpt of the reply.
+    ...(copilotkit.ɵlearningCapturesAgentText
+      ? { response: clip(message.content ?? "", RESPONSE_EXCERPT_LENGTH) }
+      : {}),
+  });
+}
+
+/** @internal Forgets every rating, so each test starts empty. */
+export function ɵresetMessageFeedbackCache(): void {
+  ratings.clear();
+}

package/src/v2/providers/CopilotChatConfigurationProvider.vue

@@ -1,8 +1,9 @@
 <script setup lang="ts">
-import { computed, inject, provide, ref } from "vue";
+import { computed, inject, onMounted, provide, ref, watch } from "vue";
 import type { ComputedRef } from "vue";
 import { DEFAULT_AGENT_ID, randomUUID } from "@copilotkit/shared";
-import { CopilotChatConfigurationKey } from "./keys";
+import type { OpenThreadRegistration } from "@copilotkit/core";
+import { CopilotChatConfigurationKey, CopilotKitKey } from "./keys";
 import { CopilotChatDefaultLabels } from "./types";
 import type { CopilotChatConfigurationValue, CopilotChatLabels } from "./types";
 import type { CopilotChatConfigurationProviderProps } from "./CopilotChatConfigurationProvider.types";
@@ -61,6 +62,32 @@ const resolvedThreadId = computed(() => {
   return fallbackThreadId;
 });
 
+// Tell Core which Thread this view shows, so captured interactions can link
+// to it. This provider also works without a CopilotKitProvider, and then there
+// is nothing to register with. Registration starts on mount, so a server
+// render never registers a Thread that it can't unregister.
+const copilotKitContext = inject(CopilotKitKey, null);
+let openThread: OpenThreadRegistration | null = null;
+onMounted(() => {
+  watch(
+    () => [copilotKitContext?.copilotkit.value, resolvedAgentId.value] as const,
+    ([core, agentId], _previous, onCleanup) => {
+      if (!core) return;
+      const registration = core.registerOpenThread({
+        agentId,
+        threadId: resolvedThreadId.value,
+      });
+      openThread = registration;
+      onCleanup(() => {
+        registration.unregister();
+        openThread = null;
+      });
+    },
+    { immediate: true },
+  );
+  watch(resolvedThreadId, (threadId) => openThread?.update(threadId));
+});
+
 const resolvedHasExplicitThreadId = computed(() => {
   if (propIsAuthoritative.value) return true;
   const own = activeThreadOverride.value

package/src/v2/providers/CopilotKitProvider.types.ts

@@ -1,8 +1,10 @@
+import type { A2UIRecoveryRendererOptions } from "../components/a2ui/A2UIRecoveryStates";
 import type { AbstractAgent } from "@ag-ui/client";
 import type {
   CopilotKitCoreErrorCode,
   CopilotKitHeadersSource,
   CopilotKitMessageFilter,
+  LearningConfig,
 } from "@copilotkit/core";
 import type { DebugConfig } from "@copilotkit/shared";
 import type {
@@ -26,6 +28,17 @@ export interface CopilotKitProviderProps {
    */
   headers?: CopilotKitHeadersSource;
   credentials?: RequestCredentials;
+  /**
+   * CSP nonce for the `<style>` tag CopilotKit adds. Set it when your
+   * Content-Security-Policy limits `style-src` to a nonce.
+   */
+  nonce?: string;
+  /**
+   * Set to `false` when you import `@copilotkit/core/styles.css` yourself, so
+   * browsers cache the CSS as a file. CopilotKit then adds no `<style>` tag.
+   * @default true
+   */
+  injectStyles?: boolean;
   /**
    * Rewrites the message list sent to runtime agents on every run.
    *
@@ -107,6 +120,12 @@ export interface CopilotKitProviderProps {
      * `a2ui_params["guidelines"]["composition_guide"]` in Python).
      */
     includeSchema?: boolean;
+    /**
+     * Options for the A2UI error-recovery status UI: how long before the
+     * transient "Retrying…" hint appears, after how many attempts, and how
+     * much retry/debug detail to surface. When omitted, defaults apply.
+     */
+    recovery?: A2UIRecoveryRendererOptions;
   };
   /** Configuration for the built-in MCP Apps renderer. */
   mcpApps?: {
@@ -137,4 +156,42 @@ export interface CopilotKitProviderProps {
    * - `{ events?: boolean; lifecycle?: boolean; verbose?: boolean }` for granular control.
    */
   debug?: DebugConfig;
+  /**
+   * Turns on interaction capture (`@copilotkit/learning`). `learning` (short
+   * for `:learning="true"`) records with the default options; pass an object
+   * for options. `false` or omitting the prop turns capture off and cancels
+   * startup. Without a sink, Core authenticates with the runtime and sends
+   * browser events to Intelligence; a custom sink keeps the standalone
+   * collector behavior. Updated settings apply to the next Trajectory.
+   *
+   * Capture starts after mount. Set `trajectoryId` to use your own ID;
+   * otherwise the provider generates one. The generated ID stays the same
+   * across rerenders, reconnects and option changes; turning capture off,
+   * setting `autoStart: false` or supplying a `trajectoryId` ends it, and the
+   * next generated Trajectory gets a new ID. Read the active ID from
+   * `copilotkit.trajectoryId`.
+   *
+   * Set `autoStart: false` to start capture yourself with `startTrajectory()`.
+   * Capture stops on unmount, including manually started Trajectories.
+   *
+   * @example
+   * <CopilotKitProvider runtime-url="/api/copilotkit" learning>
+   */
+  learning?: boolean | CopilotKitLearningOptions;
 }
+
+/** The object form of the `learning` prop. */
+export type CopilotKitLearningOptions = LearningConfig & {
+  /**
+   * Starts a Trajectory after mount. Defaults to `true`; set `false` to call
+   * `startTrajectory()` yourself.
+   */
+  autoStart?: boolean;
+  trajectoryId?: string;
+  /**
+   * Used only by explicit custom sinks. Authenticated capture warns and ignores
+   * this option; assign Learning Spaces on the server with
+   * `getTrajectoryLearningContainerIds` on `CopilotKitIntelligence`.
+   */
+  learningContainerIds?: string[];
+};

package/src/v2/providers/CopilotKitProvider.vue

@@ -1,5 +1,8 @@
 <script setup lang="ts">
-import { GENERATE_SANDBOXED_UI_DESCRIPTION } from "@copilotkit/shared";
+import {
+  GENERATE_SANDBOXED_UI_DESCRIPTION,
+  randomUUID,
+} from "@copilotkit/shared";
 import {
   computed,
   h,
@@ -43,7 +46,12 @@ import {
   MCPAppsActivityRenderer,
   MCPAppsActivityType,
 } from "../components/MCPAppsActivityRenderer";
-import { CopilotKitKey, InspectorKey, SandboxFunctionsKey } from "./keys";
+import {
+  CopilotKitKey,
+  CopilotStyleOptionsKey,
+  InspectorKey,
+  SandboxFunctionsKey,
+} from "./keys";
 import type { VueInspectorOpenRequest } from "./keys";
 import { MARKDOWN_RENDERER_KEY } from "./markdown-renderer";
 import {
@@ -53,7 +61,10 @@ import {
 import type { LicenseContextValue } from "./license-context";
 import CopilotKitInspector from "../components/CopilotKitInspector.vue";
 import LicenseWarningBanner from "../components/LicenseWarningBanner.vue";
-import type { CopilotKitProviderProps } from "./CopilotKitProvider.types";
+import type {
+  CopilotKitLearningOptions,
+  CopilotKitProviderProps,
+} from "./CopilotKitProvider.types";
 import type {
   SandboxFunction,
   VueActivityMessageRenderer,
@@ -114,8 +125,17 @@ const props = withDefaults(defineProps<CopilotKitProviderProps>(), {
   a2ui: undefined,
   mcpApps: undefined,
   enableInspector: undefined,
+  nonce: undefined,
+  injectStyles: true,
+  // A missing boolean prop would otherwise read as `false`.
+  learning: undefined,
 });
 
+provide(
+  CopilotStyleOptionsKey,
+  computed(() => ({ nonce: props.nonce, inject: props.injectStyles })),
+);
+
 const shouldRenderInspector = ref(false);
 
 function updateInspectorVisibility(): void {
@@ -471,6 +491,7 @@ const builtInActivityRenderers = computed<
         theme: props.a2ui?.theme ?? viewerTheme,
         catalog: props.a2ui?.catalog,
         loadingComponent: props.a2ui?.loadingComponent,
+        recovery: props.a2ui?.recovery,
       }),
     );
   }
@@ -495,6 +516,19 @@ const applyDefaultThrottleMs = (core: CopilotKitCoreVue) => {
   core.setDefaultThrottleMs(props.defaultThrottleMs);
 };
 
+function toLearningConfig(
+  learning: boolean | CopilotKitLearningOptions | undefined,
+): CopilotKitLearningOptions | undefined {
+  // `true` uses the default authenticated capture options.
+  if (learning === true) return {};
+  if (learning === false || learning === undefined) return undefined;
+  // `autoStart` only controls the provider; Core never receives it.
+  const { autoStart: _autoStart, ...config } = learning;
+  return config;
+}
+
+const learningConfig = computed(() => toLearningConfig(props.learning));
+
 const createCopilotKit = () => {
   const core = new CopilotKitCoreVue({
     runtimeUrl: chatApiEndpoint.value,
@@ -514,6 +548,7 @@ const createCopilotKit = () => {
     renderActivityMessages: allRenderActivityMessages.value,
     renderCustomMessages: allRenderCustomMessages.value,
     debug: props.debug,
+    learning: learningConfig.value,
   });
   // Initialize synchronously so child hooks can read the value on first render.
   applyDefaultThrottleMs(core);
@@ -696,8 +731,95 @@ onMounted(() => {
   runtimeEntitlementRetryPending.value =
     copilotkit.value.runtimeEntitlementRetryPending;
   didMountRef.value = true;
+  // After the runtime URL is set, so CopilotKit's own runtime traffic is never
+  // captured. Created here, the watchers stop (and stop capture) on unmount.
+  watchLearning();
 });
 
+const learningEnabled = computed(() => learningConfig.value !== undefined);
+// `true` is the options-free form, so only an object can opt out.
+const learningAutoStart = computed(
+  () =>
+    learningEnabled.value &&
+    (typeof props.learning !== "object" || props.learning.autoStart !== false),
+);
+const suppliedTrajectoryId = computed(() =>
+  learningAutoStart.value ? learningConfig.value?.trajectoryId : undefined,
+);
+const generatesTrajectoryId = computed(
+  () => learningAutoStart.value && suppliedTrajectoryId.value === undefined,
+);
+
+function watchLearning() {
+  let learningContainerIds = learningConfig.value?.learningContainerIds;
+
+  watch(
+    [learningConfig, learningAutoStart],
+    ([config, autoStart]) => {
+      copilotkit.value.setLearningConfig(config);
+      learningContainerIds = config?.learningContainerIds;
+      // Automatic starts report unsupported options in Core. With manual
+      // starts, the provider's container option is not part of
+      // startTrajectory() options.
+      if (
+        config?.sink === undefined &&
+        !autoStart &&
+        config?.learningContainerIds !== undefined
+      ) {
+        console.warn(
+          "[CopilotKit] learningContainerIds is supported only with a custom sink. Authenticated Trajectory capture ignores it; assign Learning Spaces on the server with getTrajectoryLearningContainerIds on CopilotKitIntelligence, and remove learningContainerIds from the capture options.",
+        );
+      }
+    },
+    { immediate: true },
+  );
+
+  // Watched as a boolean so a new inline `learning` object warns once.
+  watch(
+    () =>
+      !learningAutoStart.value &&
+      learningConfig.value?.trajectoryId !== undefined,
+    (ignoresTrajectoryId) => {
+      if (!ignoresTrajectoryId) return;
+      console.warn(
+        "[CopilotKit] learning.trajectoryId is ignored when autoStart is false; pass the ID to startTrajectory() instead.",
+      );
+    },
+    { immediate: true },
+  );
+
+  // Runs only when these change, so option changes that keep generating keep
+  // the generated Trajectory; generating again starts one with a new ID.
+  watch(
+    [learningEnabled, generatesTrajectoryId, suppliedTrajectoryId],
+    ([enabled, generates, supplied], _previous, onCleanup) => {
+      if (!enabled) return;
+      let disposed = false;
+      const core = copilotkit.value;
+      const trajectoryId = generates ? randomUUID() : supplied;
+      if (trajectoryId !== undefined) {
+        void core
+          .startTrajectory({ trajectoryId, learningContainerIds })
+          .catch(() => {
+            // Expected authentication/connection failures resolve with an
+            // error result; Core reports them to LearningConfig.onError or
+            // warns once. Consume unexpected rejections without logging
+            // credentials or errors from a previous start after a new
+            // Trajectory has already started.
+            if (!disposed) {
+              console.warn("[CopilotKit] Failed to start interaction capture.");
+            }
+          });
+      }
+      onCleanup(() => {
+        disposed = true;
+        core.stopTrajectory();
+      });
+    },
+    { immediate: true },
+  );
+}
+
 const a2uiTheme = computed(() => props.a2ui?.theme);
 const a2uiCatalog = computed(() => props.a2ui?.catalog);
 const a2uiLoadingComponent = computed(() => props.a2ui?.loadingComponent);

package/src/v2/providers/__tests__/CopilotChatConfigurationProvider.openThread.test.ts

@@ -0,0 +1,69 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { defineComponent, h, nextTick, ref } from "vue";
+import { mount } from "@vue/test-utils";
+import { CopilotKitCore } from "@copilotkit/core";
+import CopilotKitProvider from "../CopilotKitProvider.vue";
+import CopilotChatConfigurationProvider from "../CopilotChatConfigurationProvider.vue";
+
+// Core links captured interactions to the Thread that a chat view shows, as
+// React's CopilotChatConfigurationProvider does.
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function spyOnRegistration() {
+  const registration = { update: vi.fn(), unregister: vi.fn() };
+  const register = vi
+    .spyOn(CopilotKitCore.prototype, "registerOpenThread")
+    .mockReturnValue(registration);
+  return { register, registration };
+}
+
+describe("CopilotChatConfigurationProvider open Thread", () => {
+  it("registers its Thread, follows Thread changes, and unregisters on unmount", async () => {
+    const { register, registration } = spyOnRegistration();
+    const threadId = ref("t-1");
+    const App = defineComponent({
+      setup: () => () =>
+        h(
+          CopilotKitProvider,
+          { runtimeUrl: "/api/copilotkit" },
+          {
+            default: () =>
+              h(
+                CopilotChatConfigurationProvider,
+                { agentId: "agent-a", threadId: threadId.value },
+                { default: () => h("div") },
+              ),
+          },
+        ),
+    });
+    const wrapper = mount(App);
+
+    expect(register).toHaveBeenCalledTimes(1);
+    expect(register).toHaveBeenCalledWith({
+      agentId: "agent-a",
+      threadId: "t-1",
+    });
+
+    threadId.value = "t-2";
+    await nextTick();
+    expect(registration.update).toHaveBeenLastCalledWith("t-2");
+    expect(register).toHaveBeenCalledTimes(1);
+
+    wrapper.unmount();
+    expect(registration.unregister).toHaveBeenCalledTimes(1);
+  });
+
+  it("works without a CopilotKitProvider", () => {
+    const { register } = spyOnRegistration();
+    const wrapper = mount(CopilotChatConfigurationProvider, {
+      props: { agentId: "agent-a", threadId: "t-1" },
+      slots: { default: () => h("div") },
+    });
+
+    expect(register).not.toHaveBeenCalled();
+    wrapper.unmount();
+  });
+});