@copilotkit/shared 0.0.0-feat-dynamic-copilotcloud-qa-20250117190454

package/src/types/openai-assistant.ts

@@ -0,0 +1,62 @@
+export interface FunctionDefinition {
+  /**
+   * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
+   * underscores and dashes, with a maximum length of 64.
+   */
+  name: string;
+  /**
+   * The parameters the functions accepts, described as a JSON Schema object. See the
+   * [guide](/docs/guides/gpt/function-calling) for examples, and the
+   * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
+   * documentation about the format.
+   *
+   * To describe a function that accepts no parameters, provide the value
+   * `{"type": "object", "properties": {}}`.
+   */
+  parameters: Record<string, unknown>;
+  /**
+   * A description of what the function does, used by the model to choose when and
+   * how to call the function.
+   */
+  description?: string;
+}
+
+export interface ToolDefinition {
+  type: "function";
+  function: FunctionDefinition;
+}
+
+export interface FunctionCallHandlerArguments {
+  messages: any[];
+  name: string;
+  args: any;
+}
+
+export type FunctionCallHandler = (args: FunctionCallHandlerArguments) => Promise<any>;
+
+export type CoAgentStateRenderHandlerArguments = {
+  name: string;
+  nodeName: string;
+  state: any;
+};
+
+export type CoAgentStateRenderHandler = (args: CoAgentStateRenderHandlerArguments) => Promise<any>;
+
+export type AssistantMessage = {
+  id: string;
+  role: "assistant";
+  content: Array<{
+    type: "text";
+    text: {
+      value: string;
+    };
+  }>;
+};
+
+export type JSONValue =
+  | null
+  | string
+  | number
+  | boolean
+  | { [x: string]: JSONValue }
+  | Array<JSONValue>;

package/src/types/utility.ts

@@ -0,0 +1 @@
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./json-schema";
+export * from "./random-id";

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

@@ -0,0 +1,169 @@
+import { z } from "zod";
+import { convertJsonSchemaToZodSchema } from "../utils/json-schema";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+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);
+  });
+});

package/src/utils/json-schema.ts

@@ -0,0 +1,154 @@
+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,
+  };
+}
+
+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");
+}

package/src/utils/random-id.ts

@@ -0,0 +1,5 @@
+import { v4 as uuidv4 } from "uuid";
+
+export function randomId() {
+  return "ck-" + uuidv4();
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../utilities/tsconfig/base.json",
+  "include": ["."],
+  "compilerOptions": {
+    "lib": ["es2017", "dom"],
+    "resolveJsonModule": true
+  },
+  "exclude": ["dist", "build", "node_modules", "**/*.test.ts", "**/*.test.tsx", "**/__tests__/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig, Options } from "tsup";
+
+export default defineConfig((options: Options) => ({
+  entry: ["src/**/*.{ts,tsx}"],
+  format: ["esm", "cjs"],
+  dts: true,
+  minify: false,
+  external: [],
+  sourcemap: true,
+  exclude: [
+    "**/*.test.ts", // Exclude TypeScript test files
+    "**/*.test.tsx", // Exclude TypeScript React test files
+    "**/__tests__/*", // Exclude any files inside a __tests__ directory
+  ],
+  ...options,
+}));

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}