@copilotkit/vue 1.79.1 → 1.80.0

package/src/v2/components/chat/__tests__/CopilotChatUserMessage.test.ts

@@ -1,9 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { h, nextTick } from "vue";
+import { defineComponent, h, nextTick } from "vue";
+import { render, screen } from "@testing-library/vue";
 import { mount } from "@vue/test-utils";
 import type { UserMessage } from "@ag-ui/core";
 import { CopilotChatDefaultLabels } from "../../../providers/types";
 import CopilotChatUserMessage from "../CopilotChatUserMessage.vue";
+import CopilotChatConfigurationProvider from "../../../providers/CopilotChatConfigurationProvider.vue";
 
 describe("CopilotChatUserMessage", () => {
   let originalClipboard: Clipboard | undefined;
@@ -101,6 +103,45 @@ describe("CopilotChatUserMessage", () => {
     ).toBe(false);
   });
 
+  it("names the branch buttons with the configured labels", () => {
+    const Host = defineComponent({
+      components: { CopilotChatConfigurationProvider, CopilotChatUserMessage },
+      setup() {
+        return {
+          message: {
+            id: "user-5",
+            role: "user",
+            timestamp: new Date(),
+            content: "Branch message",
+          } as UserMessage,
+          labels: {
+            userMessageToolbarPreviousBranchLabel: "Vorherige Antwort",
+            userMessageToolbarNextBranchLabel: "Nächste Antwort",
+          },
+          onSwitchToBranch: vi.fn(),
+        };
+      },
+      template: `
+        <CopilotChatConfigurationProvider thread-id="thread-1" :labels="labels">
+          <CopilotChatUserMessage
+            :message="message"
+            :branch-index="1"
+            :number-of-branches="3"
+            :on-switch-to-branch="onSwitchToBranch"
+          />
+        </CopilotChatConfigurationProvider>
+      `,
+    });
+    render(Host);
+
+    expect(
+      screen.getByRole("button", { name: "Vorherige Antwort" }),
+    ).toBeDefined();
+    expect(
+      screen.getByRole("button", { name: "Nächste Antwort" }),
+    ).toBeDefined();
+  });
+
   it("renders branch navigation and emits switch payload exactly once", async () => {
     const onSwitchToBranch = vi.fn();
     const message: UserMessage = {

package/src/v2/components/chat/__tests__/CopilotChatView.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import { defineComponent, h, nextTick, ref } from "vue";
 import { mount } from "@vue/test-utils";
+import { render, screen } from "@testing-library/vue";
 import type { AssistantMessage, Message, UserMessage } from "@ag-ui/core";
 import type { Suggestion } from "@copilotkit/core";
 import CopilotKitProvider from "../../../providers/CopilotKitProvider.vue";
@@ -404,6 +405,61 @@ describe("CopilotChatView", () => {
       .trigger("click");
   });
 
+  it("names the scroll-to-bottom button with the configured label", async () => {
+    const Host = defineComponent({
+      components: {
+        CopilotKitProvider,
+        CopilotChatConfigurationProvider,
+        CopilotChatView,
+      },
+      setup() {
+        return {
+          messages: createChatMessages(12),
+          labels: { chatScrollToBottomLabel: "Nach unten scrollen" },
+        };
+      },
+      template: `
+        <CopilotKitProvider runtime-url="/api/copilotkit">
+          <CopilotChatConfigurationProvider
+            thread-id="thread-1"
+            agent-id="default"
+            :labels="labels"
+          >
+            <CopilotChatView :messages="messages" />
+          </CopilotChatConfigurationProvider>
+        </CopilotKitProvider>
+      `,
+    });
+    render(Host);
+
+    // Let the initial auto-scroll settle, then scroll away from the bottom so
+    // the button appears.
+    const scrollElement = await screen.findByTestId("copilot-chat-view-scroll");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    let scrollTop = 0;
+    Object.defineProperty(scrollElement, "scrollHeight", {
+      configurable: true,
+      get: () => 1000,
+    });
+    Object.defineProperty(scrollElement, "clientHeight", {
+      configurable: true,
+      get: () => 300,
+    });
+    Object.defineProperty(scrollElement, "scrollTop", {
+      configurable: true,
+      get: () => scrollTop,
+      set: (value: number) => {
+        scrollTop = value;
+      },
+    });
+    scrollTop = 120;
+    scrollElement.dispatchEvent(new Event("scroll"));
+
+    expect(
+      await screen.findByRole("button", { name: "Nach unten scrollen" }),
+    ).toBeDefined();
+  });
+
   it("preserves scroll position when new messages arrive and the user is scrolled up", async () => {
     const messages = ref<Message[]>(createChatMessages(12));
 

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

@@ -92,6 +92,18 @@ export interface CopilotKitProviderProps {
     loadingComponent?: Component;
     includeSchema?: boolean;
   };
+  /** Configuration for the built-in MCP Apps renderer. */
+  mcpApps?: {
+    /**
+     * Restore `allow-same-origin` on the MCP App sandbox. Default `false`.
+     *
+     * **Unsafe.** The widget then runs with your page's origin: it can read
+     * your cookies, storage and DOM, and call your APIs as the signed-in user.
+     * Only set it for widgets you wrote and trust that need `localStorage`,
+     * `IndexedDB` or cookies. By default widgets get an opaque origin.
+     */
+    allowSameOriginFallback?: boolean;
+  };
   /**
    * Enable debug logging for the client-side event pipeline.
    *

package/src/v2/providers/CopilotKitProvider.vue

@@ -10,6 +10,7 @@ import {
   triggerRef,
   watch,
 } from "vue";
+import type { Component, FunctionalComponent } from "vue";
 import { z } from "zod";
 import type { AbstractAgent } from "@ag-ui/client";
 import { ToolCallStatus } from "@copilotkit/core";
@@ -91,6 +92,13 @@ const DEFAULT_DESIGN_SKILL = `When generating UI with generateSandboxedUi, follo
 - Minimal transitions (150ms) for hover/focus states only. No decorative animations.
 - Keep the UI focused and dense — avoid excessive padding. Use compact spacing (8–12px gaps, 10–14px padding in controls).`;
 
+/** The MCP Apps renderer with `mcpApps.allowSameOriginFallback` applied. */
+const SameOriginMCPAppsActivityRenderer: FunctionalComponent = (_, { attrs }) =>
+  h(MCPAppsActivityRenderer as Component, {
+    ...attrs,
+    allowSameOriginFallback: true,
+  });
+
 const props = withDefaults(defineProps<CopilotKitProviderProps>(), {
   headers: () => ({}),
   properties: () => ({}),
@@ -103,6 +111,7 @@ const props = withDefaults(defineProps<CopilotKitProviderProps>(), {
   openGenerativeUI: undefined,
   useSingleEndpoint: undefined,
   a2ui: undefined,
+  mcpApps: undefined,
   enableInspector: undefined,
 });
 
@@ -424,6 +433,8 @@ const builtInFrontendTools = computed<VueFrontendTool[]>(() => {
       description: GENERATE_SANDBOXED_UI_DESCRIPTION,
       parameters: GenerateSandboxedUiArgsSchema,
       handler: async () => "UI generated",
+      // This acknowledgement has no side effects and is safe to reconstruct.
+      reconnectBehavior: "resume-pending",
       followUp: true,
       render:
         OpenGenerativeUIToolRenderer as unknown as VueFrontendTool["render"],
@@ -438,8 +449,9 @@ const builtInActivityRenderers = computed<
     {
       activityType: MCPAppsActivityType,
       content: MCPAppsActivityContentSchema as unknown as z.ZodSchema<unknown>,
-      render:
-        MCPAppsActivityRenderer as unknown as VueActivityMessageRenderer<unknown>["render"],
+      render: (props.mcpApps?.allowSameOriginFallback
+        ? SameOriginMCPAppsActivityRenderer
+        : MCPAppsActivityRenderer) as unknown as VueActivityMessageRenderer<unknown>["render"],
     },
   ];
 

package/src/v2/providers/__tests__/CopilotKitProvider.sandboxReplay.test.ts

@@ -0,0 +1,157 @@
+import { cleanup, render, waitFor } from "@testing-library/vue";
+import { defineComponent } from "vue";
+import CopilotKitProvider from "../CopilotKitProvider.vue";
+import { useCopilotKit } from "../useCopilotKit";
+import { HttpAgent } from "@ag-ui/client";
+import type { Message } from "@ag-ui/client";
+import type { CopilotKitCore } from "@copilotkit/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+/** Capture the real provider core after its built-in sandbox tool is registered. */
+async function mountProvider() {
+  let core: CopilotKitCore | undefined;
+  const Capture = defineComponent({
+    /** Expose the injected core without retaining Vue's reactive wrapper. */
+    setup() {
+      core = useCopilotKit().copilotkit.value;
+      return () => null;
+    },
+  });
+  render(
+    defineComponent({
+      components: { CopilotKitProvider, Capture },
+      template:
+        '<CopilotKitProvider :open-generative-u-i="{}"><Capture /></CopilotKitProvider>',
+    }),
+  );
+  await waitFor(() =>
+    expect(core?.getTool({ toolName: "generateSandboxedUi" })).toBeDefined(),
+  );
+  if (!core) throw new Error("Missing core");
+  return core;
+}
+
+/** Hydrate imported tool calls with controlled approval and side-effect handlers. */
+async function setupReplay(completed = false) {
+  const core = await mountProvider();
+  const agent = new HttpAgent({
+    url: "https://runtime.invalid",
+    agentId: "default",
+    threadId: "imported-thread",
+  });
+  const saved: Message[] = [
+    {
+      id: "imported-message",
+      role: "assistant",
+      toolCalls: [
+        {
+          id: "sandbox-id",
+          type: "function",
+          function: {
+            name: "generateSandboxedUi",
+            arguments: JSON.stringify({ html: "<button>Calculator</button>" }),
+          },
+        },
+        {
+          id: "approval-id",
+          type: "function",
+          function: { name: "meeting", arguments: "{}" },
+        },
+        {
+          id: "side-effect-id",
+          type: "function",
+          function: { name: "sendEmail", arguments: "{}" },
+        },
+      ],
+    },
+  ];
+  if (completed)
+    saved.push(
+      {
+        id: "saved-sandbox",
+        role: "tool",
+        toolCallId: "sandbox-id",
+        content: "UI generated",
+      },
+      {
+        id: "saved-approval",
+        role: "tool",
+        toolCallId: "approval-id",
+        content: "approved",
+      },
+    );
+  vi.spyOn(agent, "connectAgent").mockImplementation(async () => {
+    agent.setMessages(structuredClone(saved));
+    return { result: undefined, newMessages: structuredClone(saved) };
+  });
+  const submissions: Message[][] = [];
+  const run = vi.spyOn(agent, "runAgent").mockImplementation(async () => {
+    submissions.push(structuredClone(agent.messages));
+    return { result: undefined, newMessages: [] };
+  });
+  let answer!: (value: string) => void;
+  const pending = new Promise<string>((resolve) => {
+    answer = resolve;
+  });
+  const approval = vi.fn(() => pending);
+  const sideEffect = vi.fn(async () => "sent");
+  core.addTool({
+    name: "meeting",
+    type: "human-in-the-loop",
+    handler: approval,
+  });
+  core.addTool({ name: "sendEmail", handler: sideEffect });
+  return { core, agent, saved, run, submissions, answer, approval, sideEffect };
+}
+
+describe("CopilotKitProvider — sandboxed UI replay", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("restores the original sandbox result before the pending approval continues", async () => {
+    const { core, agent, run, submissions, answer, approval, sideEffect } =
+      await setupReplay();
+    await core.connectAgent({ agent });
+    await waitFor(() => expect(approval).toHaveBeenCalledTimes(1));
+    expect(agent.messages).toContainEqual(
+      expect.objectContaining({
+        role: "tool",
+        toolCallId: "sandbox-id",
+        content: "UI generated",
+      }),
+    );
+    expect(run).not.toHaveBeenCalled();
+    answer("approved");
+    await waitFor(() => expect(run).toHaveBeenCalledTimes(1));
+    expect(
+      submissions[0]?.filter((message) => message.role === "tool"),
+    ).toEqual([
+      expect.objectContaining({
+        toolCallId: "sandbox-id",
+        content: "UI generated",
+      }),
+      expect.objectContaining({
+        toolCallId: "approval-id",
+        content: "approved",
+      }),
+    ]);
+    expect(sideEffect).not.toHaveBeenCalled();
+  });
+
+  it("leaves saved sandbox and approval results completed across repeated reconnects", async () => {
+    const { core, agent, saved, run, approval, sideEffect } =
+      await setupReplay(true);
+    const tool = core.getTool({ toolName: "generateSandboxedUi" });
+    if (!tool?.handler) throw new Error("Missing sandbox handler");
+    const handler = vi.spyOn(tool, "handler");
+    await core.connectAgent({ agent });
+    await core.connectAgent({ agent });
+    expect(agent.messages).toEqual(saved);
+    expect(handler).not.toHaveBeenCalled();
+    expect(approval).not.toHaveBeenCalled();
+    expect(sideEffect).not.toHaveBeenCalled();
+    expect(run).not.toHaveBeenCalled();
+  });
+});

package/src/v2/providers/types.ts

@@ -5,6 +5,8 @@ export const CopilotChatDefaultLabels = {
   chatInputToolbarFinishTranscribeButtonLabel: "Finish",
   chatInputToolbarAddButtonLabel: "Add photos or files",
   chatInputToolbarToolsButtonLabel: "Tools",
+  chatInputToolbarSendButtonLabel: "Send message",
+  chatInputToolbarStopButtonLabel: "Stop",
   assistantMessageToolbarCopyCodeLabel: "Copy",
   assistantMessageToolbarCopyCodeCopiedLabel: "Copied",
   assistantMessageToolbarCopyMessageLabel: "Copy",
@@ -14,10 +16,13 @@ export const CopilotChatDefaultLabels = {
   assistantMessageToolbarRegenerateLabel: "Regenerate",
   userMessageToolbarCopyMessageLabel: "Copy",
   userMessageToolbarEditMessageLabel: "Edit",
+  userMessageToolbarPreviousBranchLabel: "Previous branch",
+  userMessageToolbarNextBranchLabel: "Next branch",
   chatDisclaimerText:
     "AI can make mistakes. Please verify important information.",
   chatToggleOpenLabel: "Open chat",
   chatToggleCloseLabel: "Close chat",
+  chatScrollToBottomLabel: "Scroll to bottom",
   modalHeaderTitle: "CopilotKit Chat",
   welcomeMessageText: "How can I help you today?",
 } as const;