@copilotkit/shared 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/src/utils/json-schema.test.ts

@@ -0,0 +1,383 @@
+import { z } from "zod";
+import {
+  convertJsonSchemaToZodSchema,
+  actionParametersToJsonSchema,
+  jsonSchemaToActionParameters,
+  JSONSchema,
+} from "../utils/json-schema";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { Parameter } from "../types";
+
+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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(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);
+
+    console.log(convertJsonSchemaToZodSchema(jsonSchema, false));
+
+    const resultSchemaJson = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+
+  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 = zodToJsonSchema(result);
+    const expectedSchemaJson = zodToJsonSchema(expectedSchema);
+
+    expect(resultSchemaJson).toStrictEqual(expectedSchemaJson);
+  });
+});
+
+describe("jsonSchemaToActionParameters", () => {
+  it("should convert a simple JSONSchema to Parameter array", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "User name" },
+        age: { type: "number", description: "User age" },
+      },
+      required: ["name"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      { name: "name", type: "string", description: "User name" },
+      { name: "age", type: "number", description: "User age", required: false },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should convert JSONSchema with enum to Parameter array", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        role: { type: "string", enum: ["admin", "user", "guest"], description: "User role" },
+      },
+      required: ["role"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      { name: "role", type: "string", enum: ["admin", "user", "guest"], description: "User role" },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should convert nested object JSONSchema to Parameter array", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "User name" },
+            age: { type: "number", description: "User age" },
+          },
+          required: ["name"],
+          description: "User information",
+        },
+      },
+      required: ["user"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      {
+        name: "user",
+        type: "object",
+        description: "User information",
+        attributes: [
+          { name: "name", type: "string", description: "User name" },
+          { name: "age", type: "number", description: "User age", required: false },
+        ],
+      },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should convert array JSONSchema to Parameter array", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "User tags",
+        },
+      },
+      required: ["tags"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      { name: "tags", type: "string[]", description: "User tags" },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should convert object array JSONSchema to Parameter array", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        addresses: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              street: { type: "string", description: "Street name" },
+              city: { type: "string", description: "City name" },
+            },
+            required: ["street"],
+          },
+          description: "User addresses",
+        },
+      },
+      required: ["addresses"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      {
+        name: "addresses",
+        type: "object[]",
+        description: "User addresses",
+        attributes: [
+          { name: "street", type: "string", description: "Street name" },
+          { name: "city", type: "string", description: "City name", required: false },
+        ],
+      },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should handle boolean types", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        isAdmin: { type: "boolean", description: "Is user an admin" },
+      },
+      required: ["isAdmin"],
+    };
+
+    const expectedParameters: Parameter[] = [
+      { name: "isAdmin", type: "boolean", description: "Is user an admin" },
+    ];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should handle empty object schema", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+    };
+
+    const expectedParameters: Parameter[] = [];
+
+    const result = jsonSchemaToActionParameters(jsonSchema);
+    expect(result).toEqual(expectedParameters);
+  });
+
+  it("should throw error for nested arrays", () => {
+    const jsonSchema: JSONSchema = {
+      type: "object",
+      properties: {
+        nestedArray: {
+          type: "array",
+          items: {
+            type: "array",
+            items: { type: "string" },
+          },
+          description: "Matrix of strings",
+        },
+      },
+      required: ["nestedArray"],
+    };
+
+    expect(() => jsonSchemaToActionParameters(jsonSchema)).toThrow(
+      "Nested arrays are not supported",
+    );
+  });
+
+  it("should ensure round-trip conversion works", () => {
+    const originalParameters: Parameter[] = [
+      { name: "name", type: "string", description: "User name" },
+      { name: "age", type: "number", description: "User age", required: false },
+      { name: "role", type: "string", enum: ["admin", "user"], description: "User role" },
+      {
+        name: "address",
+        type: "object",
+        description: "User address",
+        attributes: [
+          { name: "street", type: "string", description: "Street name" },
+          { name: "city", type: "string", description: "City name" },
+        ],
+      },
+      {
+        name: "contacts",
+        type: "object[]",
+        description: "User contacts",
+        attributes: [
+          { name: "type", type: "string", description: "Contact type" },
+          { name: "value", type: "string", description: "Contact value" },
+        ],
+      },
+    ];
+
+    const jsonSchema = actionParametersToJsonSchema(originalParameters);
+    const roundTripParameters = jsonSchemaToActionParameters(jsonSchema);
+
+    expect(roundTripParameters).toEqual(originalParameters);
+  });
+});

package/src/utils/json-schema.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { Parameter } from "../types";
+
+export type JSONSchemaString = {
+  type: "string";
+  description?: string;
+  enum?: string[];
+};
+
+export type JSONSchemaNumber = {
+  type: "number";
+  description?: string;
+};
+
+export type JSONSchemaBoolean = {
+  type: "boolean";
+  description?: string;
+};
+
+export type JSONSchemaObject = {
+  type: "object";
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  description?: string;
+};
+
+export type JSONSchemaArray = {
+  type: "array";
+  items: JSONSchema;
+  description?: string;
+};
+
+export type JSONSchema =
+  | JSONSchemaString
+  | JSONSchemaNumber
+  | JSONSchemaBoolean
+  | JSONSchemaObject
+  | JSONSchemaArray;
+
+export function actionParametersToJsonSchema(actionParameters: Parameter[]): JSONSchema {
+  // Create the parameters object based on the argumentAnnotations
+  let parameters: { [key: string]: any } = {};
+  for (let parameter of actionParameters || []) {
+    parameters[parameter.name] = convertAttribute(parameter);
+  }
+
+  let requiredParameterNames: string[] = [];
+  for (let arg of actionParameters || []) {
+    if (arg.required !== false) {
+      requiredParameterNames.push(arg.name);
+    }
+  }
+
+  // Create the ChatCompletionFunctions object
+  return {
+    type: "object",
+    properties: parameters,
+    required: requiredParameterNames,
+  };
+}
+
+// Convert JSONSchema to Parameter[]
+export function jsonSchemaToActionParameters(jsonSchema: JSONSchema): Parameter[] {
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    return [];
+  }
+
+  const parameters: Parameter[] = [];
+  const requiredFields = jsonSchema.required || [];
+
+  for (const [name, schema] of Object.entries(jsonSchema.properties)) {
+    const parameter = convertJsonSchemaToParameter(name, schema, requiredFields.includes(name));
+    parameters.push(parameter);
+  }
+
+  return parameters;
+}
+
+// Convert JSONSchema property to Parameter
+function convertJsonSchemaToParameter(
+  name: string,
+  schema: JSONSchema,
+  isRequired: boolean,
+): Parameter {
+  const baseParameter: Parameter = {
+    name,
+    description: schema.description,
+  };
+
+  if (!isRequired) {
+    baseParameter.required = false;
+  }
+
+  switch (schema.type) {
+    case "string":
+      return {
+        ...baseParameter,
+        type: "string",
+        ...(schema.enum && { enum: schema.enum }),
+      };
+    case "number":
+    case "boolean":
+      return {
+        ...baseParameter,
+        type: schema.type,
+      };
+    case "object":
+      if (schema.properties) {
+        const attributes: Parameter[] = [];
+        const requiredFields = schema.required || [];
+
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+          attributes.push(
+            convertJsonSchemaToParameter(propName, propSchema, requiredFields.includes(propName)),
+          );
+        }
+
+        return {
+          ...baseParameter,
+          type: "object",
+          attributes,
+        };
+      }
+      return {
+        ...baseParameter,
+        type: "object",
+      };
+    case "array":
+      if (schema.items.type === "object" && "properties" in schema.items) {
+        const attributes: Parameter[] = [];
+        const requiredFields = schema.items.required || [];
+
+        for (const [propName, propSchema] of Object.entries(schema.items.properties || {})) {
+          attributes.push(
+            convertJsonSchemaToParameter(propName, propSchema, requiredFields.includes(propName)),
+          );
+        }
+
+        return {
+          ...baseParameter,
+          type: "object[]",
+          attributes,
+        };
+      } else if (schema.items.type === "array") {
+        throw new Error("Nested arrays are not supported");
+      } else {
+        return {
+          ...baseParameter,
+          type: `${schema.items.type}[]`,
+        };
+      }
+    default:
+      return {
+        ...baseParameter,
+        type: "string",
+      };
+  }
+}
+
+function convertAttribute(attribute: Parameter): JSONSchema {
+  switch (attribute.type) {
+    case "string":
+      return {
+        type: "string",
+        description: attribute.description,
+        ...(attribute.enum && { enum: attribute.enum }),
+      };
+    case "number":
+    case "boolean":
+      return {
+        type: attribute.type,
+        description: attribute.description,
+      };
+    case "object":
+    case "object[]":
+      const properties = attribute.attributes?.reduce(
+        (acc, attr) => {
+          acc[attr.name] = convertAttribute(attr);
+          return acc;
+        },
+        {} as Record<string, any>,
+      );
+      const required = attribute.attributes
+        ?.filter((attr) => attr.required !== false)
+        .map((attr) => attr.name);
+      if (attribute.type === "object[]") {
+        return {
+          type: "array",
+          items: {
+            type: "object",
+            ...(properties && { properties }),
+            ...(required && required.length > 0 && { required }),
+          },
+          description: attribute.description,
+        };
+      }
+      return {
+        type: "object",
+        description: attribute.description,
+        ...(properties && { properties }),
+        ...(required && required.length > 0 && { required }),
+      };
+    default:
+      // Handle arrays of primitive types and undefined attribute.type
+      if (attribute.type?.endsWith("[]")) {
+        const itemType = attribute.type.slice(0, -2);
+        return {
+          type: "array",
+          items: { type: itemType as any },
+          description: attribute.description,
+        };
+      }
+      // Fallback for undefined type or any other unexpected type
+      return {
+        type: "string",
+        description: attribute.description,
+      };
+  }
+}
+
+export function convertJsonSchemaToZodSchema(jsonSchema: any, required: boolean): z.ZodSchema {
+  if (jsonSchema.type === "object") {
+    const spec: { [key: string]: z.ZodSchema } = {};
+
+    if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) {
+      return !required ? z.object(spec).optional() : z.object(spec);
+    }
+
+    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+      spec[key] = convertJsonSchemaToZodSchema(
+        value,
+        jsonSchema.required ? jsonSchema.required.includes(key) : false,
+      );
+    }
+    let schema = z.object(spec).describe(jsonSchema.description);
+    return required ? schema : schema.optional();
+  } else if (jsonSchema.type === "string") {
+    let schema = z.string().describe(jsonSchema.description);
+    return required ? schema : schema.optional();
+  } else if (jsonSchema.type === "number") {
+    let schema = z.number().describe(jsonSchema.description);
+    return required ? schema : schema.optional();
+  } else if (jsonSchema.type === "boolean") {
+    let schema = z.boolean().describe(jsonSchema.description);
+    return required ? schema : schema.optional();
+  } else if (jsonSchema.type === "array") {
+    let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
+    let schema = z.array(itemSchema).describe(jsonSchema.description);
+    return required ? schema : schema.optional();
+  }
+  throw new Error("Invalid JSON schema");
+}
+
+export function getZodParameters<T extends [] | Parameter[] | undefined>(parameters: T): any {
+  if (!parameters) return z.object({});
+  const jsonParams = actionParametersToJsonSchema(parameters);
+  return convertJsonSchemaToZodSchema(jsonParams, true);
+}

package/src/utils/random-id.ts

@@ -0,0 +1,42 @@
+import { v4 as uuidv4, validate, v5 as uuidv5 } from "uuid";
+
+export function randomId() {
+  return "ck-" + uuidv4();
+}
+
+export function randomUUID() {
+  return uuidv4();
+}
+
+/**
+ * Recursively converts an object to a serializable form by converting functions to their string representation.
+ */
+function toSerializable(value: unknown): unknown {
+  if (typeof value === "function") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(toSerializable);
+  }
+  if (value !== null && typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const key of Object.keys(value)) {
+      result[key] = toSerializable((value as Record<string, unknown>)[key]);
+    }
+    return result;
+  }
+  return value;
+}
+
+export function dataToUUID(input: string | object, namespace?: string): string {
+  const BASE_NAMESPACE = "e4b01160-ff74-4c6e-9b27-d53cd930fe8e";
+  // Since namespace needs to be a uuid, we are creating a uuid for it.
+  const boundNamespace = namespace ? uuidv5(namespace, BASE_NAMESPACE) : BASE_NAMESPACE;
+
+  const stringInput = typeof input === "string" ? input : JSON.stringify(toSerializable(input));
+  return uuidv5(stringInput, boundNamespace);
+}
+
+export function isValidUUID(uuid: string) {
+  return validate(uuid);
+}