@copilotkit/react-core 1.55.0-next.8 → 1.55.0

package/src/v2/providers/__tests__/CopilotKitProvider.sandboxFunctions.test.tsx

@@ -0,0 +1,198 @@
+import { renderHook } from "@testing-library/react";
+import React from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { CopilotKitProvider, useCopilotKit } from "../CopilotKitProvider";
+import { useSandboxFunctions } from "../SandboxFunctionsContext";
+import type { SandboxFunction } from "../../types/sandbox-function";
+
+describe("CopilotKitProvider — openGenerativeUI.sandboxFunctions", () => {
+  beforeEach(() => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const makeSandboxFunction = (
+    name: string,
+    overrides?: Partial<SandboxFunction>,
+  ): SandboxFunction => ({
+    name,
+    description: `${name} description`,
+    parameters: z.object({ value: z.string() }),
+    handler: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  });
+
+  /** Helper: find the sandbox-functions context entry from the context record */
+  function findSandboxContext(
+    ctx: Record<string, { description: string; value: string }>,
+  ) {
+    return Object.values(ctx).find((c) =>
+      c.description.includes("Sandbox functions"),
+    );
+  }
+
+  describe("SandboxFunctionsContext", () => {
+    it("provides sandbox functions to children via context", () => {
+      const fns = [makeSandboxFunction("myFn")];
+
+      const { result } = renderHook(() => useSandboxFunctions(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: fns }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current).toHaveLength(1);
+      expect(result.current[0].name).toBe("myFn");
+    });
+
+    it("provides empty array when openGenerativeUI is not set", () => {
+      const { result } = renderHook(() => useSandboxFunctions(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider>{children}</CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current).toHaveLength(0);
+    });
+
+    it("provides empty array when sandboxFunctions is not set", () => {
+      const { result } = renderHook(() => useSandboxFunctions(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{}}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current).toHaveLength(0);
+    });
+  });
+
+  describe("agent context registration", () => {
+    it("registers agent context when sandbox functions are provided", () => {
+      const fns = [makeSandboxFunction("addToCart")];
+
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: fns }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      const sandboxContext = findSandboxContext(
+        result.current.copilotkit.context,
+      );
+      expect(sandboxContext).toBeDefined();
+
+      const parsed = JSON.parse(sandboxContext!.value);
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].name).toBe("addToCart");
+      expect(parsed[0].description).toBe("addToCart description");
+      expect(parsed[0].parameters).toBeDefined();
+      expect(parsed[0].parameters.type).toBe("object");
+    });
+
+    it("does not register agent context when sandbox functions are empty", () => {
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: [] }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      const sandboxContext = findSandboxContext(
+        result.current.copilotkit.context,
+      );
+      expect(sandboxContext).toBeUndefined();
+    });
+
+    it("does not register agent context when openGenerativeUI is omitted", () => {
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider>{children}</CopilotKitProvider>
+        ),
+      });
+
+      const sandboxContext = findSandboxContext(
+        result.current.copilotkit.context,
+      );
+      expect(sandboxContext).toBeUndefined();
+    });
+
+    it("includes multiple functions in agent context", () => {
+      const fns = [makeSandboxFunction("fnA"), makeSandboxFunction("fnB")];
+
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: fns }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      const sandboxContext = findSandboxContext(
+        result.current.copilotkit.context,
+      );
+      const parsed = JSON.parse(sandboxContext!.value);
+      expect(parsed).toHaveLength(2);
+      expect(parsed.map((f: any) => f.name)).toEqual(["fnA", "fnB"]);
+    });
+
+    it("converts parameters to JSON Schema in agent context", () => {
+      const fns = [
+        makeSandboxFunction("myFn", {
+          parameters: z.object({
+            itemId: z.string(),
+            quantity: z.number(),
+          }),
+        }),
+      ];
+
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: fns }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      const sandboxContext = findSandboxContext(
+        result.current.copilotkit.context,
+      );
+      const parsed = JSON.parse(sandboxContext!.value);
+      const params = parsed[0].parameters;
+
+      expect(params.type).toBe("object");
+      expect(params.properties.itemId).toEqual({ type: "string" });
+      expect(params.properties.quantity).toEqual({ type: "number" });
+    });
+
+    it("removes agent context on unmount", () => {
+      const fns = [makeSandboxFunction("myFn")];
+
+      const { result, unmount } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider openGenerativeUI={{ sandboxFunctions: fns }}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      const copilotkit = result.current.copilotkit;
+      expect(findSandboxContext(copilotkit.context)).toBeDefined();
+
+      unmount();
+
+      expect(findSandboxContext(copilotkit.context)).toBeUndefined();
+    });
+  });
+});

package/src/v2/providers/__tests__/CopilotKitProvider.test.tsx

@@ -573,6 +573,76 @@ describe("CopilotKitProvider", () => {
     });
   });
 
+  describe("useSingleEndpoint → runtimeTransport mapping", () => {
+    it("maps useSingleEndpoint=true to 'single' transport", () => {
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider useSingleEndpoint={true}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current.copilotkit.runtimeTransport).toBe("single");
+    });
+
+    it("maps useSingleEndpoint=false to 'rest' transport", () => {
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider useSingleEndpoint={false}>
+            {children}
+          </CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current.copilotkit.runtimeTransport).toBe("rest");
+    });
+
+    it("maps omitted useSingleEndpoint to 'auto' transport", () => {
+      const { result } = renderHook(() => useCopilotKit(), {
+        wrapper: ({ children }) => (
+          <CopilotKitProvider>{children}</CopilotKitProvider>
+        ),
+      });
+
+      expect(result.current.copilotkit.runtimeTransport).toBe("auto");
+    });
+
+    it("updates transport when useSingleEndpoint prop changes", () => {
+      let capturedCopilotkit: ReturnType<typeof useCopilotKit>["copilotkit"];
+
+      function Collector({ children }: { children?: React.ReactNode }) {
+        const { copilotkit } = useCopilotKit();
+        capturedCopilotkit = copilotkit;
+        return <>{children}</>;
+      }
+
+      const { rerender } = render(
+        <CopilotKitProvider useSingleEndpoint={false}>
+          <Collector />
+        </CopilotKitProvider>,
+      );
+
+      expect(capturedCopilotkit!.runtimeTransport).toBe("rest");
+
+      rerender(
+        <CopilotKitProvider useSingleEndpoint={true}>
+          <Collector />
+        </CopilotKitProvider>,
+      );
+
+      expect(capturedCopilotkit!.runtimeTransport).toBe("single");
+
+      rerender(
+        <CopilotKitProvider>
+          <Collector />
+        </CopilotKitProvider>,
+      );
+
+      expect(capturedCopilotkit!.runtimeTransport).toBe("auto");
+    });
+  });
+
   describe("Edge cases", () => {
     it("handles empty arrays for tools", () => {
       const { result } = renderHook(() => useCopilotKit(), {
@@ -583,6 +653,7 @@ describe("CopilotKitProvider", () => {
         ),
       });
 
+      // No built-in tools when openGenerativeUI is not configured
       expect(result.current.copilotkit.tools).toHaveLength(0);
       expect(result.current.copilotkit.renderToolCalls).toHaveLength(0);
     });

package/src/v2/providers/index.ts

@@ -12,3 +12,10 @@ export {
   type CopilotKitProviderProps,
   type CopilotKitContextValue,
 } from "./CopilotKitProvider";
+
+export type { Anchor as InspectorAnchor } from "@copilotkit/web-inspector";
+
+export {
+  SandboxFunctionsContext,
+  useSandboxFunctions,
+} from "./SandboxFunctionsContext";

package/src/v2/styles/globals.css

@@ -119,7 +119,8 @@
 }
 
 @theme {
-  --animate-pulse-cursor: pulse-cursor 0.9s cubic-bezier(0.4, 0, 0.2, 1) infinite;
+  --animate-pulse-cursor: pulse-cursor 0.9s cubic-bezier(0.4, 0, 0.2, 1)
+    infinite;
   @keyframes pulse-cursor {
     0%,
     100% {

package/src/v2/types/index.ts

@@ -5,3 +5,4 @@ export * from "./frontend-tool";
 export * from "./human-in-the-loop";
 export * from "./defineToolCallRenderer";
 export * from "./interrupt";
+export * from "./sandbox-function";

package/src/v2/types/sandbox-function.ts

@@ -0,0 +1,11 @@
+import type { StandardSchemaV1 } from "@copilotkit/shared";
+
+export type SandboxFunction<
+  TParams extends StandardSchemaV1 = StandardSchemaV1,
+> = {
+  name: string;
+  description: string;
+  parameters: TParams;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handler: (args: any) => Promise<unknown>;
+};