@getzep/zep-cloud 3.0.0 → 3.0.1

package/dist/esm/wrapper/graph.mjs

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Graph as BaseGraph } from "../api/resources/graph/client/Client";
+import { entityModelToAPISchema, edgeModelToAPISchema } from "./ontology";
+export class Graph extends BaseGraph {
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setEntityTypes({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setEntityTypes(entityTypes, edgeTypes, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validatedEntityTypes = Object.keys(entityTypes).map((key) => {
+                const schema = entityTypes[key];
+                return entityModelToAPISchema(schema, key);
+            });
+            const validatedEdgeTypes = Object.keys(edgeTypes).map((key) => {
+                const schema = edgeTypes[key];
+                return edgeModelToAPISchema(schema, key);
+            });
+            return this.setEntityTypesInternal({
+                entityTypes: validatedEntityTypes,
+                edgeTypes: validatedEdgeTypes,
+            }, requestOptions);
+        });
+    }
+    /**
+     * Sets the entity and edge types for a project, replacing any existing ones.
+     *
+     * @param {Record<string, EntityType>} entityTypes
+     * @param {Record<string, EdgeType>} edgeTypes
+     * @param {Graph.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Zep.BadRequestError}
+     * @throws {@link Zep.InternalServerError}
+     *
+     * @example
+     *     const travelDestinationSchema: EntityType = {
+     *         description: "A travel destination entity",
+     *         fields: {
+     *             destination_name: entityFields.text("The name of travel destination"),
+     *         },
+     *     };
+     *
+     *     const isTravelingTo: EdgeType = {
+     *         description: "An edge representing a traveler going to a destination.",
+     *         fields: {
+     *             travel_date: entityFields.text("The date of the travel"),
+     *             purpose: entityFields.text("The purpose of the travel"),
+     *         },
+     *         sourceTargets: [
+     *             {
+     *                 source: "User",
+     *                 target: "TravelDestination",
+     *             }
+     *         ]
+     *     }
+     *
+     *     await client.graph.setOntology({
+     *         TravelDestination: travelDestinationSchema,
+     *     }, {
+     *         IS_TRAVELING_TO: isTravelingTo,
+     *     });
+     */
+    setOntology(entityTypes, edgeTypes, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setEntityTypes(entityTypes, edgeTypes, requestOptions);
+        });
+    }
+}

package/dist/esm/wrapper/index.d.mts

@@ -0,0 +1,5 @@
+import { ZepClient as BaseClient } from "../Client";
+import { Graph } from "./graph";
+export declare class ZepClient extends BaseClient {
+    get graph(): Graph;
+}

package/dist/esm/wrapper/index.mjs

@@ -0,0 +1,7 @@
+import { ZepClient as BaseClient } from "../Client";
+import { Graph } from "./graph";
+export class ZepClient extends BaseClient {
+    get graph() {
+        return new Graph(this._options);
+    }
+}

package/dist/esm/wrapper/ontology.d.mts

@@ -0,0 +1,416 @@
+import { z } from "zod";
+import { Zep } from "../index";
+export declare enum EntityPropertyType {
+    Text = "Text",
+    Int = "Int",
+    Float = "Float",
+    Boolean = "Boolean"
+}
+export declare const EntityTypeBaseField: z.ZodObject<{
+    type: z.ZodNativeEnum<typeof EntityPropertyType>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType;
+    description: string;
+}, {
+    type: EntityPropertyType;
+    description: string;
+}>;
+export interface EntityField<V = any> {
+    description: string;
+    value?: V;
+}
+export declare const EntityTypeTextFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>;
+export type EntityTextField = z.infer<typeof EntityTypeTextFieldSchema>;
+export declare const EntityTypeIntFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>;
+export type EntityIntField = z.infer<typeof EntityTypeIntFieldSchema>;
+export declare const EntityTypeFloatFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>;
+export type EntityFloatField = z.infer<typeof EntityTypeFloatFieldSchema>;
+export declare const EntityTypeBooleanFieldSchema: z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>;
+export type EntityBooleanField = z.infer<typeof EntityTypeBooleanFieldSchema>;
+export declare const EntityTypeFieldSchema: z.ZodUnion<[z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>]>;
+export type SupportedEntityField = EntityTextField | EntityIntField | EntityFloatField | EntityBooleanField;
+export declare const EntityFields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Text>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}, {
+    type: EntityPropertyType.Text;
+    description: string;
+    value?: string | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Int>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Int;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Float>;
+    value: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}, {
+    type: EntityPropertyType.Float;
+    description: string;
+    value?: number | undefined;
+}>, z.ZodObject<{
+    description: z.ZodString;
+} & {
+    type: z.ZodLiteral<EntityPropertyType.Boolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}, {
+    type: EntityPropertyType.Boolean;
+    description: string;
+    value?: boolean | undefined;
+}>]>>;
+export declare const EntityTypeSchema: z.ZodObject<{
+    description: z.ZodDefault<z.ZodString>;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Text>;
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Int>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Float>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Boolean>;
+        value: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+}, {
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    description?: string | undefined;
+}>;
+export declare const EdgeTypeSchema: z.ZodObject<{
+    description: z.ZodDefault<z.ZodString>;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Text>;
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Int>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Float>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }, {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    }>, z.ZodObject<{
+        description: z.ZodString;
+    } & {
+        type: z.ZodLiteral<EntityPropertyType.Boolean>;
+        value: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }, {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>]>>;
+} & {
+    sourceTargets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source?: string | undefined;
+        target?: string | undefined;
+    }, {
+        source?: string | undefined;
+        target?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    sourceTargets?: {
+        source?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+}, {
+    fields: Record<string, {
+        type: EntityPropertyType.Text;
+        description: string;
+        value?: string | undefined;
+    } | {
+        type: EntityPropertyType.Int;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Float;
+        description: string;
+        value?: number | undefined;
+    } | {
+        type: EntityPropertyType.Boolean;
+        description: string;
+        value?: boolean | undefined;
+    }>;
+    description?: string | undefined;
+    sourceTargets?: {
+        source?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+}>;
+export type EntityType = z.infer<typeof EntityTypeSchema>;
+export type EdgeType = z.infer<typeof EdgeTypeSchema>;
+export type EntityData<T extends EntityType> = {
+    [P in keyof T["fields"]]: T["fields"][P] extends {
+        value?: infer V;
+    } ? V : never;
+};
+export type EdgeData<T extends EdgeType> = {
+    [P in keyof T["fields"]]: T["fields"][P] extends {
+        value?: infer V;
+    } ? V : never;
+};
+export declare const entityFields: {
+    text: (description: string) => EntityTextField;
+    integer: (description: string) => EntityIntField;
+    float: (description: string) => EntityFloatField;
+    boolean: (description: string) => EntityBooleanField;
+};
+export declare function entityModelToAPISchema(entityType: EntityType, name: string): Zep.EntityType;
+export declare function edgeModelToAPISchema(entityType: EdgeType, name: string): Zep.EdgeType;

package/dist/esm/wrapper/ontology.mjs

@@ -0,0 +1,95 @@
+import { z } from "zod";
+export var EntityPropertyType;
+(function (EntityPropertyType) {
+    EntityPropertyType["Text"] = "Text";
+    EntityPropertyType["Int"] = "Int";
+    EntityPropertyType["Float"] = "Float";
+    EntityPropertyType["Boolean"] = "Boolean";
+})(EntityPropertyType || (EntityPropertyType = {}));
+export const EntityTypeBaseField = z.object({
+    type: z.nativeEnum(EntityPropertyType),
+    description: z.string(),
+});
+export const EntityTypeTextFieldSchema = EntityTypeBaseField.extend({
+    type: z.literal(EntityPropertyType.Text),
+    value: z.string().optional(),
+});
+export const EntityTypeIntFieldSchema = EntityTypeBaseField.extend({
+    type: z.literal(EntityPropertyType.Int),
+    value: z.number().int().optional(),
+});
+export const EntityTypeFloatFieldSchema = EntityTypeBaseField.extend({
+    type: z.literal(EntityPropertyType.Float),
+    value: z.number().optional(),
+});
+export const EntityTypeBooleanFieldSchema = EntityTypeBaseField.extend({
+    type: z.literal(EntityPropertyType.Boolean),
+    value: z.boolean().optional(),
+});
+export const EntityTypeFieldSchema = z.union([
+    EntityTypeTextFieldSchema,
+    EntityTypeIntFieldSchema,
+    EntityTypeFloatFieldSchema,
+    EntityTypeBooleanFieldSchema,
+]);
+export const EntityFields = z.record(EntityTypeFieldSchema);
+export const EntityTypeSchema = z.object({
+    description: z.string().default(""),
+    fields: z.record(EntityTypeFieldSchema),
+});
+const EdgeSourceTarget = z.object({
+    source: z.string().optional(),
+    target: z.string().optional(),
+});
+export const EdgeTypeSchema = EntityTypeSchema.extend({
+    sourceTargets: z.array(EdgeSourceTarget).optional(),
+});
+export const entityFields = {
+    text: (description) => {
+        return EntityTypeTextFieldSchema.parse({
+            type: EntityPropertyType.Text,
+            description,
+        });
+    },
+    integer: (description) => {
+        return EntityTypeIntFieldSchema.parse({
+            type: EntityPropertyType.Int,
+            description,
+        });
+    },
+    float: (description) => {
+        return EntityTypeFloatFieldSchema.parse({
+            type: EntityPropertyType.Float,
+            description,
+        });
+    },
+    boolean: (description) => {
+        return EntityTypeBooleanFieldSchema.parse({
+            type: EntityPropertyType.Boolean,
+            description,
+        });
+    },
+};
+export function entityModelToAPISchema(entityType, name) {
+    return {
+        name,
+        description: entityType.description,
+        properties: Object.entries(entityType.fields).map(([fieldName, fieldDef]) => ({
+            name: fieldName,
+            type: fieldDef.type,
+            description: fieldDef.description,
+        })),
+    };
+}
+export function edgeModelToAPISchema(entityType, name) {
+    return {
+        name,
+        description: entityType.description,
+        sourceTargets: entityType.sourceTargets,
+        properties: Object.entries(entityType.fields).map(([fieldName, fieldDef]) => ({
+            name: fieldName,
+            type: fieldDef.type,
+            description: fieldDef.description,
+        })),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getzep/zep-cloud",
-    "version": "3.0.0",
+    "version": "3.0.1",
     "private": false,
     "repository": "https://github.com/getzep/zep-js",
     "description": "Zep: Fast, scalable building blocks for production LLM apps",
@@ -49,7 +49,8 @@
         "test": "jest --config jest.config.mjs",
         "test:unit": "jest --selectProjects unit",
         "test:browser": "jest --selectProjects browser",
-        "test:wire": "jest --selectProjects wire"
+        "test:wire": "jest --selectProjects wire",
+        "prepack": "yarn build"
     },
     "dependencies": {
         "zod": "^3.23.8"