@getzep/zep-cloud 3.0.1 → 3.0.3

package/dist/esm/version.mjs

@@ -1 +0,0 @@
-export const SDK_VERSION = "3.0.0";

package/dist/esm/wrapper/graph.mjs

@@ -1,110 +0,0 @@
-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.mjs

@@ -1,7 +0,0 @@
-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.mjs

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