@copilotkit/vue 2.0.0-rc.3 → 2.0.0-rc.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/vue",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.30",
   "private": false,
   "description": "Vue 3 components and composables for CopilotKit",
   "keywords": [
@@ -59,18 +59,16 @@
   },
   "dependencies": {
     "@a2ui/web_core": "0.10.4",
-    "@ag-ui/client": "1.0.2",
-    "@ag-ui/core": "1.0.2",
-    "@copilotkit/core": "2.0.0-rc.3",
-    "@copilotkit/markdown-renderer": "2.0.0-rc.3",
-    "@copilotkit/mcp-apps-renderer": "2.0.0-rc.3",
-    "@copilotkit/shared": "2.0.0-rc.3",
-    "@copilotkit/web-components": "2.0.0-rc.3",
-    "@copilotkit/web-inspector": "2.0.0-rc.3",
-    "@jetbrains/websandbox": "^1.1.3",
-    "lucide-vue-next": "^0.525.0",
-    "zod": "^3.25.75",
-    "zod-to-json-schema": "^3.24.5"
+    "@ag-ui/client": "1.0.4",
+    "@ag-ui/core": "1.0.4",
+    "@copilotkit/a2ui-renderer": "2.0.0-rc.30",
+    "@copilotkit/core": "2.0.0-rc.30",
+    "@copilotkit/markdown": "2.0.0-rc.30",
+    "@copilotkit/mcp-apps-renderer": "2.0.0-rc.30",
+    "@copilotkit/shared": "2.0.0-rc.30",
+    "@copilotkit/web-components": "2.0.0-rc.30",
+    "@copilotkit/web-inspector": "2.0.0-rc.30",
+    "zod": "^4.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
@@ -94,6 +92,7 @@
     "vue": "^3.5.28",
     "vue-eslint-parser": "^10.4.0",
     "vue-tsc": "^2.1.10",
+    "zod-v3": "npm:zod@^3.25.76",
     "@copilotkit/typescript-config": "1.55.0-next.8"
   },
   "peerDependencies": {

package/src/__tests__/build-entries.test.ts

@@ -0,0 +1,29 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import type { LibraryOptions } from "vite";
+import config from "../../vite.config";
+import { useFrontendTool as v1UseFrontendTool } from "../hooks/use-frontend-tool";
+import { useFrontendTool as v2UseFrontendTool } from "../v2/hooks/use-frontend-tool";
+
+// The package's "./v2" export points at the build's "v2/index" entry, and "."
+// at "index". Each entry must build from the module that matches its export.
+const entries = (config.build?.lib as LibraryOptions).entry as Record<
+  string,
+  string
+>;
+
+// The first import transforms the whole entry from source, which takes more
+// than the 5s default when the suite runs next to other packages.
+describe("library build entries", { timeout: 30_000 }, () => {
+  it("builds @copilotkit/vue/v2 from the v2 module, with the v2 hooks", async () => {
+    const v2 = await import(/* @vite-ignore */ entries["v2/index"]!);
+
+    expect(v2.useFrontendTool).toBe(v2UseFrontendTool);
+  });
+
+  it("builds @copilotkit/vue from the root module, with the v1-compatible hooks", async () => {
+    const root = await import(/* @vite-ignore */ entries.index!);
+
+    expect(root.useFrontendTool).toBe(v1UseFrontendTool);
+  });
+});

package/src/hooks/__tests__/zod-parameters.test.ts

@@ -0,0 +1,520 @@
+import { describe, it, expect, vi } from "vitest";
+import { z } from "zod";
+import type { Parameter } from "@copilotkit/shared";
+import {
+  convertJsonSchemaToZodSchema,
+  getZodParameters,
+} from "../zod-parameters";
+
+describe("convertJsonSchemaToZodSchema", () => {
+  it("should convert a simple JSON schema to a Zod schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "number" },
+      },
+      required: ["name", "age"],
+    };
+
+    const expectedSchema = z.object({
+      name: z.string(),
+      age: z.number(),
+    });
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should convert a JSON schema with nested objects to a Zod schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        address: {
+          type: "object",
+          properties: {
+            street: { type: "string" },
+            city: { type: "string" },
+          },
+          required: ["street", "city"],
+        },
+      },
+      required: ["name", "address"],
+    };
+
+    const expectedSchema = z.object({
+      name: z.string(),
+      address: z.object({
+        street: z.string(),
+        city: z.string(),
+      }),
+    });
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should convert a JSON schema with arrays to a Zod schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        names: {
+          type: "array",
+          items: { type: "string" },
+        },
+      },
+      required: ["names"],
+    };
+
+    const expectedSchema = z.object({
+      names: z.array(z.string()),
+    });
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should convert a JSON schema with optional properties to a Zod schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "number", required: false },
+      },
+    };
+
+    const expectedSchema = z
+      .object({
+        name: z.string().optional(),
+        age: z.number().optional(),
+      })
+      .optional();
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, false);
+
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should convert a JSON schema with different types to a Zod schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "number" },
+        isAdmin: { type: "boolean" },
+      },
+      required: ["name", "age", "isAdmin"],
+    };
+
+    const expectedSchema = z.object({
+      name: z.string(),
+      age: z.number(),
+      isAdmin: z.boolean(),
+    });
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should handle edge case where JSON schema has no properties", () => {
+    const jsonSchema = {
+      type: "object",
+    };
+
+    const expectedSchema = z.object({});
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should preserve string enum constraints", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          description: "The status",
+          enum: ["todo", "done"],
+        },
+      },
+      required: ["status"],
+    };
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const statusSchema = (result as z.ZodObject<any>).shape.status;
+    expect(statusSchema).toBeInstanceOf(z.ZodEnum);
+    expect(statusSchema.options).toEqual(["todo", "done"]);
+  });
+
+  it("should handle null-union type ['string', 'null'] as nullable", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        nickname: {
+          type: ["string", "null"],
+          description: "Optional nickname",
+        },
+      },
+      required: ["nickname"],
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const shape = (result as z.ZodObject<any>).shape;
+
+    // The nickname field should accept both string and null
+    expect(shape.nickname.safeParse("hello").success).toBe(true);
+    expect(shape.nickname.safeParse(null).success).toBe(true);
+    expect(shape.nickname.safeParse(42).success).toBe(false);
+  });
+
+  it("should handle null-union type ['number', 'null'] as nullable number", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        score: {
+          type: ["number", "null"],
+        },
+      },
+      required: ["score"],
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const shape = (result as z.ZodObject<any>).shape;
+
+    expect(shape.score.safeParse(42).success).toBe(true);
+    expect(shape.score.safeParse(null).success).toBe(true);
+    expect(shape.score.safeParse("hello").success).toBe(false);
+  });
+
+  it("should handle edge case where JSON schema has no required properties", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "number" },
+      },
+    };
+
+    const expectedSchema = z
+      .object({
+        name: z.string().optional(),
+        age: z.number().optional(),
+      })
+      .optional();
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, false);
+    const resultSchemaJson = z.toJSONSchema(result);
+    const expectedSchemaJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  it("should resolve non-circular $ref definitions correctly", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        address: { $ref: "#/$defs/Address" },
+      },
+      required: ["address"],
+      $defs: {
+        Address: {
+          type: "object",
+          properties: {
+            street: { type: "string", description: "Street name" },
+            city: { type: "string", description: "City name" },
+          },
+          required: ["street", "city"],
+          description: "A postal address",
+        },
+      },
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const resultJson = z.toJSONSchema(result);
+
+    const expectedSchema = z.object({
+      address: z
+        .object({
+          street: z.string().describe("Street name"),
+          city: z.string().describe("City name"),
+        })
+        .describe("A postal address"),
+    });
+    const expectedJson = z.toJSONSchema(expectedSchema);
+
+    expect(resultJson).toStrictEqual(expectedJson);
+  });
+
+  it("should handle circular $ref without crashing and return z.any()", () => {
+    // A schema where Node references itself — this would cause infinite
+    // recursion without cycle detection.
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        root: { $ref: "#/$defs/Node" },
+      },
+      required: ["root"],
+      $defs: {
+        Node: {
+          type: "object",
+          properties: {
+            value: { type: "string", description: "Node value" },
+            child: { $ref: "#/$defs/Node" },
+          },
+          required: ["value"],
+          description: "A tree node",
+        },
+      },
+    };
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    // Must not throw or hang
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    expect(result).toBeDefined();
+
+    // The circular ref should have produced a console.warn
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Circular $ref detected"),
+    );
+
+    // The top-level shape should still have a "root" key that is an object
+    const shape = (result as z.ZodObject<any>).shape;
+    expect(shape.root).toBeDefined();
+
+    // Inside root, "value" should be a string and "child" should be z.any()
+    // (child is optional since it's not in required[], so unwrap ZodOptional)
+    const rootShape = (shape.root as z.ZodObject<any>).shape;
+    expect(rootShape.value).toBeInstanceOf(z.ZodString);
+    const child = rootShape.child;
+    if (child instanceof z.ZodOptional) {
+      expect(child.unwrap()).toBeInstanceOf(z.ZodAny);
+    } else {
+      expect(child).toBeInstanceOf(z.ZodAny);
+    }
+
+    warnSpy.mockRestore();
+  });
+
+  it("should resolve the same $ref used by multiple sibling properties", () => {
+    // Two properties reference the same $def — the visited set must NOT
+    // mark the second usage as circular.
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        billing: { $ref: "#/$defs/Address" },
+        shipping: { $ref: "#/$defs/Address" },
+      },
+      required: ["billing", "shipping"],
+      $defs: {
+        Address: {
+          type: "object",
+          properties: {
+            street: { type: "string", description: "Street" },
+            city: { type: "string", description: "City" },
+          },
+          required: ["street", "city"],
+          description: "An address",
+        },
+      },
+    };
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const shape = (result as z.ZodObject<any>).shape;
+
+    // Both should be fully resolved objects, NOT z.any()
+    expect(shape.billing).toBeInstanceOf(z.ZodObject);
+    expect(shape.shipping).toBeInstanceOf(z.ZodObject);
+
+    // No circular-ref warning should have been emitted
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+
+  it("should resolve a shared $ref used in different branches of a $ref chain", () => {
+    // Wrapper -> Container (via $ref) which has two children both using $ref to Leaf.
+    // Without set cloning, the second Leaf ref in Container would be wrongly flagged
+    // as circular because the first Leaf resolution already added it to the set.
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        wrapper: { $ref: "#/$defs/Container" },
+      },
+      required: ["wrapper"],
+      $defs: {
+        Container: {
+          type: "object",
+          properties: {
+            first: { $ref: "#/$defs/Leaf" },
+            second: { $ref: "#/$defs/Leaf" },
+          },
+          required: ["first", "second"],
+          description: "A container with two leaves",
+        },
+        Leaf: {
+          type: "object",
+          properties: {
+            label: { type: "string", description: "Leaf label" },
+          },
+          required: ["label"],
+          description: "A leaf node",
+        },
+      },
+    };
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const wrapperShape = (
+      (result as z.ZodObject<any>).shape.wrapper as z.ZodObject<any>
+    ).shape;
+
+    // Both first and second should be fully resolved Leaf objects
+    expect(wrapperShape.first).toBeInstanceOf(z.ZodObject);
+    expect(wrapperShape.second).toBeInstanceOf(z.ZodObject);
+
+    // No circular-ref warning should have been emitted
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+
+  it("should handle anyOf with $ref variants", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        pet: {
+          anyOf: [{ $ref: "#/$defs/Cat" }, { $ref: "#/$defs/Dog" }],
+          description: "A pet",
+        },
+      },
+      required: ["pet"],
+      $defs: {
+        Cat: {
+          type: "object",
+          properties: { meow: { type: "boolean" } },
+          required: ["meow"],
+        },
+        Dog: {
+          type: "object",
+          properties: { bark: { type: "boolean" } },
+          required: ["bark"],
+        },
+      },
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    expect(result).toBeDefined();
+
+    // Should produce a union inside the "pet" property
+    const petSchema = (result as z.ZodObject<any>).shape.pet;
+    expect(petSchema).toBeInstanceOf(z.ZodUnion);
+  });
+
+  it("should handle integer type as z.number()", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        count: { type: "integer", description: "A count" },
+      },
+      required: ["count"],
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const shape = (result as z.ZodObject<any>).shape;
+    expect(shape.count).toBeInstanceOf(z.ZodNumber);
+  });
+
+  it("should handle null type", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        empty: { type: "null", description: "Always null" },
+      },
+      required: ["empty"],
+    };
+
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+    const shape = (result as z.ZodObject<any>).shape;
+    expect(shape.empty).toBeInstanceOf(z.ZodNull);
+  });
+
+  it("should warn and return z.any() for unsupported schema types", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const jsonSchema = { type: "custom_unsupported" };
+    const result = convertJsonSchemaToZodSchema(jsonSchema, true);
+
+    expect(result).toBeInstanceOf(z.ZodAny);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'Unsupported JSON schema type "custom_unsupported"',
+      ),
+    );
+
+    warnSpy.mockRestore();
+  });
+});
+
+describe("getZodParameters", () => {
+  it("returns an empty object schema without parameters", () => {
+    expect(z.toJSONSchema(getZodParameters(undefined))).toStrictEqual(
+      z.toJSONSchema(z.object({})),
+    );
+  });
+
+  it("converts v1 parameters to a Zod object schema", () => {
+    const parameters: Parameter[] = [
+      { name: "name", type: "string", description: "User name" },
+      { name: "age", type: "number", required: false },
+      { name: "role", type: "string", enum: ["admin", "user"] },
+      {
+        name: "address",
+        type: "object",
+        attributes: [{ name: "city", type: "string" }],
+      },
+      { name: "tags", type: "string[]" },
+    ];
+
+    const schema = getZodParameters(parameters);
+
+    expect(
+      schema.safeParse({
+        name: "Ada",
+        role: "admin",
+        address: { city: "London" },
+        tags: ["a"],
+      }).success,
+    ).toBe(true);
+    expect(
+      schema.safeParse({
+        name: "Ada",
+        role: "owner",
+        address: { city: "London" },
+        tags: [],
+      }).success,
+    ).toBe(false);
+    expect(schema.safeParse({ role: "user" }).success).toBe(false);
+  });
+});

package/src/hooks/use-copilot-action.ts

@@ -7,7 +7,8 @@
 import type { WatchSource } from "vue";
 import type { WebMCPToolConfig } from "@copilotkit/core";
 import type { Parameter, MappedParameterTypes } from "@copilotkit/shared";
-import { getZodParameters, parseJson } from "@copilotkit/shared";
+import { parseJson } from "@copilotkit/shared";
+import { getZodParameters } from "./zod-parameters";
 import { useFrontendTool as useFrontendToolV2 } from "../v2/hooks/use-frontend-tool";
 import { useHumanInTheLoop as useHumanInTheLoopV2 } from "../v2/hooks/use-human-in-the-loop";
 import { useRenderTool as useRenderToolV2 } from "../v2/hooks/use-render-tool";

package/src/hooks/use-frontend-tool.ts

@@ -6,12 +6,9 @@
  */
 import type { WatchSource } from "vue";
 import type { WebMCPToolConfig } from "@copilotkit/core";
-import {
-  type Parameter,
-  type MappedParameterTypes,
-  getZodParameters,
-  parseJson,
-} from "@copilotkit/shared";
+import { parseJson } from "@copilotkit/shared";
+import type { Parameter, MappedParameterTypes } from "@copilotkit/shared";
+import { getZodParameters } from "./zod-parameters";
 import { useFrontendTool as useFrontendToolV2 } from "../v2/hooks/use-frontend-tool";
 import type { VueFrontendTool } from "../v2/types";