@copilotkit/react-core 1.56.2 → 1.56.4-canary.1777529757

package/src/v2/components/chat/__tests__/CopilotChat.absentThreadConnect.test.tsx

@@ -0,0 +1,66 @@
+import React from "react";
+import { describe, it, expect, vi } from "vitest";
+import { render } from "@testing-library/react";
+import { EMPTY, Observable } from "rxjs";
+import { type BaseEvent, type RunAgentInput } from "@ag-ui/client";
+import { MockStepwiseAgent } from "../../../__tests__/utils/test-helpers";
+import { CopilotKitProvider } from "../../../providers/CopilotKitProvider";
+import { CopilotChatConfigurationProvider } from "../../../providers/CopilotChatConfigurationProvider";
+import { CopilotChat } from "../CopilotChat";
+
+describe("CopilotChat avoids /connect for locally-generated threadIds (ENT-314)", () => {
+  function buildAgentWithConnectSpy(): {
+    agent: MockStepwiseAgent;
+    connectSpy: ReturnType<typeof vi.fn>;
+  } {
+    const connectSpy = vi.fn();
+    class SpyAgent extends MockStepwiseAgent {
+      connect(input: RunAgentInput): Observable<BaseEvent> {
+        connectSpy(input);
+        return EMPTY;
+      }
+    }
+    return { agent: new SpyAgent(), connectSpy };
+  }
+
+  it("does not call connect() when no threadId is supplied", async () => {
+    const { agent, connectSpy } = buildAgentWithConnectSpy();
+
+    render(
+      <CopilotKitProvider agents__unsafe_dev_only={{ default: agent }}>
+        <CopilotChat welcomeScreen={false} />
+      </CopilotKitProvider>,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(connectSpy).not.toHaveBeenCalled();
+  });
+
+  it("calls connect() when a threadId is supplied via props", async () => {
+    const { agent, connectSpy } = buildAgentWithConnectSpy();
+
+    render(
+      <CopilotKitProvider agents__unsafe_dev_only={{ default: agent }}>
+        <CopilotChat welcomeScreen={false} threadId="user-thread-abc" />
+      </CopilotKitProvider>,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(connectSpy).toHaveBeenCalled();
+  });
+
+  it("calls connect() when a threadId is supplied via configuration provider", async () => {
+    const { agent, connectSpy } = buildAgentWithConnectSpy();
+
+    render(
+      <CopilotKitProvider agents__unsafe_dev_only={{ default: agent }}>
+        <CopilotChatConfigurationProvider threadId="config-thread-xyz">
+          <CopilotChat welcomeScreen={false} />
+        </CopilotChatConfigurationProvider>
+      </CopilotKitProvider>,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(connectSpy).toHaveBeenCalled();
+  });
+});

package/src/v2/components/chat/__tests__/CopilotChat.suggestionsAlways.test.tsx

@@ -0,0 +1,189 @@
+import React from "react";
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { beforeEach, vi } from "vitest";
+import { useConfigureSuggestions } from "../../../hooks/use-configure-suggestions";
+import { CopilotChat } from "../CopilotChat";
+import { CopilotKitProvider } from "../../../providers/CopilotKitProvider";
+import {
+  MockStepwiseAgent,
+  runStartedEvent,
+  runFinishedEvent,
+  textChunkEvent,
+  testId,
+} from "../../../__tests__/utils/test-helpers";
+import type { AutoScrollMode } from "../normalize-auto-scroll";
+
+// jsdom doesn't implement scrollTo; pin-to-send mode calls it from a rAF
+// callback, so without this stub the cleanup throws an unhandled error.
+beforeEach(() => {
+  HTMLElement.prototype.scrollTo = vi.fn();
+});
+
+const STATIC_SUGGESTIONS = [
+  { title: "Say hello", message: "Hello there!" },
+  { title: "Get help", message: "Can you help me?" },
+];
+
+const ChatWithStaticAlwaysSuggestions: React.FC<{
+  autoScroll?: AutoScrollMode | boolean;
+  consumerAgentId?: string;
+}> = ({ autoScroll, consumerAgentId }) => {
+  useConfigureSuggestions({
+    suggestions: STATIC_SUGGESTIONS,
+    available: "always",
+    ...(consumerAgentId ? { consumerAgentId } : {}),
+  });
+
+  return <CopilotChat autoScroll={autoScroll} />;
+};
+
+function renderChat({
+  agent,
+  autoScroll,
+  consumerAgentId,
+}: {
+  agent: MockStepwiseAgent;
+  autoScroll?: AutoScrollMode | boolean;
+  consumerAgentId?: string;
+}) {
+  return render(
+    <CopilotKitProvider agents__unsafe_dev_only={{ default: agent }}>
+      <div style={{ height: 400 }}>
+        <ChatWithStaticAlwaysSuggestions
+          autoScroll={autoScroll}
+          consumerAgentId={consumerAgentId}
+        />
+      </div>
+    </CopilotKitProvider>,
+  );
+}
+
+describe("CopilotChat - static suggestions with available:'always'", () => {
+  it("should show suggestions on the welcome screen", async () => {
+    const agent = new MockStepwiseAgent();
+    renderChat({ agent, consumerAgentId: "default" });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Say hello")).toBeDefined();
+      expect(screen.getByText("Get help")).toBeDefined();
+    });
+  });
+
+  it("should show suggestions on the welcome screen with global config (no consumerAgentId)", async () => {
+    const agent = new MockStepwiseAgent();
+    renderChat({ agent });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Say hello")).toBeDefined();
+      expect(screen.getByText("Get help")).toBeDefined();
+    });
+  });
+
+  it("should keep suggestions visible during a run", async () => {
+    const agent = new MockStepwiseAgent();
+    renderChat({ agent, consumerAgentId: "default" });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Say hello")).toBeDefined();
+    });
+
+    const input = await screen.findByRole("textbox");
+    fireEvent.change(input, { target: { value: "Hi!" } });
+    fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
+
+    await waitFor(() => {
+      expect(screen.getByText("Hi!")).toBeDefined();
+    });
+
+    const messageId = testId("msg");
+    agent.emit(runStartedEvent());
+    agent.emit(textChunkEvent(messageId, "Hello! How can I help?"));
+
+    // Suggestions must remain visible even while the run is still in progress
+    await waitFor(
+      () => {
+        expect(screen.getByText("Say hello")).toBeDefined();
+        expect(screen.getByText("Get help")).toBeDefined();
+      },
+      { timeout: 3000 },
+    );
+
+    agent.emit(runFinishedEvent());
+    agent.complete();
+
+    await waitFor(() => {
+      expect(screen.getByText("Hello! How can I help?")).toBeDefined();
+    });
+
+    // And still visible after the run completes
+    await waitFor(
+      () => {
+        expect(screen.getByText("Say hello")).toBeDefined();
+        expect(screen.getByText("Get help")).toBeDefined();
+      },
+      { timeout: 3000 },
+    );
+  });
+
+  it("should keep suggestions visible during a run in pin-to-send mode", async () => {
+    const agent = new MockStepwiseAgent();
+    renderChat({ agent, autoScroll: "pin-to-send" });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("Say hello")).toBeDefined();
+    });
+
+    const input = await screen.findByRole("textbox");
+    fireEvent.change(input, { target: { value: "Hi!" } });
+    fireEvent.keyDown(input, { key: "Enter", code: "Enter" });
+
+    await waitFor(() => {
+      expect(screen.getByText("Hi!")).toBeDefined();
+    });
+
+    const messageId = testId("msg");
+    agent.emit(runStartedEvent());
+    agent.emit(textChunkEvent(messageId, "Hello! How can I help?"));
+
+    // Suggestions must remain visible even while the run is still in progress
+    await waitFor(
+      () => {
+        expect(screen.getByText("Say hello")).toBeDefined();
+        expect(screen.getByText("Get help")).toBeDefined();
+      },
+      { timeout: 3000 },
+    );
+
+    agent.emit(runFinishedEvent());
+    agent.complete();
+
+    await waitFor(() => {
+      expect(screen.getByText("Hello! How can I help?")).toBeDefined();
+    });
+
+    // And still visible after the run completes
+    await waitFor(
+      () => {
+        expect(screen.getByText("Say hello")).toBeDefined();
+        expect(screen.getByText("Get help")).toBeDefined();
+      },
+      { timeout: 3000 },
+    );
+  });
+});

package/src/v2/components/chat/__tests__/CopilotChat.welcomeGate.test.tsx

@@ -0,0 +1,186 @@
+import React from "react";
+import { render, screen, waitFor } from "@testing-library/react";
+import { describe, it, expect, beforeEach } from "vitest";
+import { CopilotKitProvider } from "../../../providers/CopilotKitProvider";
+import { CopilotChatConfigurationProvider } from "../../../providers/CopilotChatConfigurationProvider";
+import { CopilotChat } from "../CopilotChat";
+import { MockStepwiseAgent } from "../../../__tests__/utils/test-helpers";
+import { DEFAULT_AGENT_ID } from "@copilotkit/shared";
+
+/**
+ * Mock agent that records every connectAgent() invocation and resolves
+ * immediately with an empty run result. Tracking lives on the class so
+ * per-thread clones (from useAgent's WeakMap) share the counter.
+ */
+class TrackingAgent extends MockStepwiseAgent {
+  static connectCalls: Array<{
+    threadId: string | undefined;
+    agentId: string | undefined;
+  }> = [];
+
+  static reset() {
+    TrackingAgent.connectCalls = [];
+  }
+
+  async connectAgent(
+    _params: unknown,
+    _subscriber: unknown,
+  ): Promise<{ result: unknown; newMessages: [] }> {
+    TrackingAgent.connectCalls.push({
+      threadId: this.threadId,
+      agentId: this.agentId,
+    });
+    return { result: undefined, newMessages: [] };
+  }
+}
+
+function renderWithKit(ui: React.ReactNode, agent: TrackingAgent) {
+  return render(
+    <CopilotKitProvider agents__unsafe_dev_only={{ [DEFAULT_AGENT_ID]: agent }}>
+      <div style={{ height: 400 }}>{ui}</div>
+    </CopilotKitProvider>,
+  );
+}
+
+/**
+ * Regression coverage for fix/welcome-not-showing-at-all.
+ *
+ * The underlying bug: the v1 <CopilotKit> wrapper pipes a ThreadsProvider-
+ * minted UUID through to CopilotChatConfigurationProvider as `threadId`.
+ * CopilotChat previously treated any non-empty providedThreadId as "caller
+ * supplied a real backend thread" and (a) fired /connect (→ 404 for an
+ * auto-minted UUID) and (b) suppressed the welcome screen forever. The
+ * fix threads an `hasExplicitThreadId` signal through the provider chain;
+ * these tests pin the contract that /connect and welcome-screen gating
+ * now follow that signal rather than `!!threadId`.
+ */
+describe("CopilotChat welcome / connect integration", () => {
+  beforeEach(() => {
+    TrackingAgent.reset();
+  });
+
+  describe("v1 bridge scenario (config provider marks threadId as non-explicit)", () => {
+    it("does not call connectAgent and shows the welcome screen", async () => {
+      const agent = new TrackingAgent();
+      agent.agentId = DEFAULT_AGENT_ID;
+
+      renderWithKit(
+        <CopilotChatConfigurationProvider
+          threadId="auto-minted-uuid"
+          hasExplicitThreadId={false}
+        >
+          <CopilotChat />
+        </CopilotChatConfigurationProvider>,
+        agent,
+      );
+
+      // Give the connect-effect a chance to misfire.
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(TrackingAgent.connectCalls).toHaveLength(0);
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+  });
+
+  describe("plain CopilotChat (no threadId anywhere)", () => {
+    it("does not call connectAgent and shows the welcome screen", async () => {
+      const agent = new TrackingAgent();
+      agent.agentId = DEFAULT_AGENT_ID;
+
+      renderWithKit(<CopilotChat />, agent);
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(TrackingAgent.connectCalls).toHaveLength(0);
+      expect(screen.getByTestId("copilot-welcome-screen")).toBeDefined();
+    });
+  });
+
+  describe("explicit threadId via CopilotChat prop", () => {
+    it("calls connectAgent with that threadId and suppresses the welcome screen", async () => {
+      const agent = new TrackingAgent();
+      agent.agentId = DEFAULT_AGENT_ID;
+
+      renderWithKit(<CopilotChat threadId="real-thread" />, agent);
+
+      await waitFor(() => {
+        expect(TrackingAgent.connectCalls.length).toBeGreaterThan(0);
+      });
+
+      // The per-thread clone carries threadId; agentId is the default.
+      expect(
+        TrackingAgent.connectCalls.some((c) => c.threadId === "real-thread"),
+      ).toBe(true);
+
+      // Welcome screen is suppressed even after connect resolves, because the
+      // thread was caller-picked (hasExplicitThreadId=true).
+      expect(screen.queryByTestId("copilot-welcome-screen")).toBeNull();
+    });
+  });
+
+  describe("explicit threadId via wrapping CopilotChatConfigurationProvider", () => {
+    it("inherits explicitness from the provider and connects", async () => {
+      const agent = new TrackingAgent();
+      agent.agentId = DEFAULT_AGENT_ID;
+
+      renderWithKit(
+        <CopilotChatConfigurationProvider threadId="from-config">
+          <CopilotChat />
+        </CopilotChatConfigurationProvider>,
+        agent,
+      );
+
+      await waitFor(() => {
+        expect(TrackingAgent.connectCalls.length).toBeGreaterThan(0);
+      });
+
+      expect(
+        TrackingAgent.connectCalls.some((c) => c.threadId === "from-config"),
+      ).toBe(true);
+      expect(screen.queryByTestId("copilot-welcome-screen")).toBeNull();
+    });
+  });
+
+  describe("thread switch between two explicit threads", () => {
+    it("keeps the welcome screen hidden across the switch", async () => {
+      const agent = new TrackingAgent();
+      agent.agentId = DEFAULT_AGENT_ID;
+
+      const { rerender } = renderWithKit(
+        <CopilotChat threadId="thread-a" />,
+        agent,
+      );
+
+      await waitFor(() => {
+        expect(
+          TrackingAgent.connectCalls.some((c) => c.threadId === "thread-a"),
+        ).toBe(true);
+      });
+      // After thread-a's connect resolves, welcome must still be hidden
+      // because the thread is caller-picked.
+      expect(screen.queryByTestId("copilot-welcome-screen")).toBeNull();
+
+      rerender(
+        <CopilotKitProvider
+          agents__unsafe_dev_only={{ [DEFAULT_AGENT_ID]: agent }}
+        >
+          <div style={{ height: 400 }}>
+            <CopilotChat threadId="thread-b" />
+          </div>
+        </CopilotKitProvider>,
+      );
+
+      // During the switch (lastConnected="thread-a" !== "thread-b") isConnecting
+      // is true — welcome must not flash.
+      expect(screen.queryByTestId("copilot-welcome-screen")).toBeNull();
+
+      await waitFor(() => {
+        expect(
+          TrackingAgent.connectCalls.some((c) => c.threadId === "thread-b"),
+        ).toBe(true);
+      });
+      // And after thread-b's connect resolves.
+      expect(screen.queryByTestId("copilot-welcome-screen")).toBeNull();
+    });
+  });
+});