langchain 0.0.202 → 0.0.204-rc.0

package/dist/experimental/masking/regex_masking_transformer.d.ts

@@ -0,0 +1,48 @@
+import { MaskingTransformer } from "./transformer.js";
+import type { HashFunction, MaskingPattern } from "./types.js";
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+export declare class RegexMaskingTransformer extends MaskingTransformer {
+    private patterns;
+    private hashFunction;
+    /**
+     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+     * Validates the provided patterns to ensure they conform to the expected structure.
+     *
+     * @param patterns - An object containing masking patterns. Each pattern should include
+     *                   a regular expression (`regex`) and optionally a `replacement` string
+     *                   or a `mask` function.
+     * @param hashFunction - An optional custom hash function to be used for masking.
+     */
+    constructor(patterns: {
+        [key: string]: MaskingPattern;
+    }, hashFunction?: HashFunction);
+    /**
+     * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+     * Throws an error if any pattern is found to be invalid.
+     *
+     * @param patterns - The patterns object to validate.
+     */
+    private validatePatterns;
+    /**
+     * Masks content in a message based on the defined patterns.
+     * @param message - The message to be masked.
+     * @param state - The current state containing original values.
+     * @returns A tuple of the masked message and the updated state.
+     */
+    transform(message: string, state: Map<string, string>): Promise<[string, Map<string, string>]>;
+    /**
+     * Rehydrates a masked message back to its original form using the provided state.
+     * @param message - The masked message to be rehydrated.
+     * @param state - The state map containing mappings of masked values to their original values.
+     * @returns The rehydrated (original) message.
+     */
+    rehydrate(message: string, state: Map<string, string>): Promise<string>;
+    /**
+     * Default hash function for creating unique hash values.
+     * @param input - The input string to hash.
+     * @returns The resulting hash as a string.
+     */
+    private defaultHashFunction;
+}

package/dist/experimental/masking/regex_masking_transformer.js

@@ -0,0 +1,141 @@
+import { MaskingTransformer } from "./transformer.js";
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+export class RegexMaskingTransformer extends MaskingTransformer {
+    /**
+     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+     * Validates the provided patterns to ensure they conform to the expected structure.
+     *
+     * @param patterns - An object containing masking patterns. Each pattern should include
+     *                   a regular expression (`regex`) and optionally a `replacement` string
+     *                   or a `mask` function.
+     * @param hashFunction - An optional custom hash function to be used for masking.
+     */
+    constructor(patterns, hashFunction) {
+        super();
+        Object.defineProperty(this, "patterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hashFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Validates the provided masking patterns before initializing the transformer.
+        // This ensures that each pattern has a valid regular expression.
+        this.validatePatterns(patterns);
+        // Assigns the validated patterns and the hash function to the transformer.
+        // If no custom hash function is provided, the default hash function is used.
+        this.patterns = patterns;
+        this.hashFunction = hashFunction || this.defaultHashFunction;
+    }
+    /**
+     * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+     * Throws an error if any pattern is found to be invalid.
+     *
+     * @param patterns - The patterns object to validate.
+     */
+    validatePatterns(patterns) {
+        for (const key of Object.keys(patterns)) {
+            const pattern = patterns[key];
+            // Checks that each pattern is an object and has a regex property that is an instance of RegExp.
+            // Throws an error if these conditions are not met, indicating an invalid pattern configuration.
+            if (!pattern ||
+                typeof pattern !== "object" ||
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(pattern.regex instanceof RegExp)) {
+                throw new Error("Invalid pattern configuration.");
+            }
+        }
+    }
+    /**
+     * Masks content in a message based on the defined patterns.
+     * @param message - The message to be masked.
+     * @param state - The current state containing original values.
+     * @returns A tuple of the masked message and the updated state.
+     */
+    async transform(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.");
+        }
+        // Holds the progressively masked message
+        let processedMessage = message;
+        // Initialize original values map with the current state or a new map
+        const originalValues = state || new Map();
+        // Iterate over each pattern defined in the transformer
+        for (const key of Object.keys(this.patterns)) {
+            const pattern = this.patterns[key];
+            // Apply the current pattern's regex to the message
+            processedMessage = processedMessage.replace(pattern.regex, (match) => {
+                // Determine the masked value: use the mask function if provided, else use the replacement string,
+                // else use the hash function.
+                const maskedValue = pattern.mask
+                    ? pattern.mask(match)
+                    : pattern.replacement ?? this.hashFunction(match);
+                // Store the mapping of the masked value to the original value (match)
+                originalValues.set(maskedValue, match);
+                // Return the masked value to replace the original value in the message
+                return maskedValue;
+            });
+        }
+        // Return the fully masked message and the state map with all original values
+        // Wrap the synchronous return values in Promise.resolve() to maintain compatibility
+        // with the MaskingParser's expectation of a Promise return type.
+        return [processedMessage, originalValues];
+    }
+    /**
+     * Rehydrates a masked message back to its original form using the provided state.
+     * @param message - The masked message to be rehydrated.
+     * @param state - The state map containing mappings of masked values to their original values.
+     * @returns The rehydrated (original) message.
+     */
+    async rehydrate(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
+        }
+        // Convert the state map to an array and use reduce to sequentially replace masked values with original values.
+        const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+            // Escape special characters in the masked string to ensure it can be used in a regular expression safely.
+            // This is necessary because masked values might contain characters that have special meanings in regex.
+            const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            // Replace all instances of the escaped masked value in the message with the original value.
+            // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.
+            return msg.replace(new RegExp(escapedMasked, "g"), original);
+        }, message);
+        return rehydratedMessage;
+    }
+    /**
+     * Default hash function for creating unique hash values.
+     * @param input - The input string to hash.
+     * @returns The resulting hash as a string.
+     */
+    defaultHashFunction(input) {
+        let hash = 0;
+        // Iterate over each character in the input string
+        for (let i = 0; i < input.length; i += 1) {
+            // Get ASCII value of the character
+            const char = input.charCodeAt(i);
+            // Combine the current hash with the new character and ensure it remains a 32-bit integer
+            hash = (hash << 5) - hash + char;
+            // Bitwise OR operation to convert to a 32-bit integer.
+            // This is a common technique to ensure the final hash value stays within the 32-bit limit,
+            // effectively wrapping the value when it becomes too large.
+            hash |= 0;
+        }
+        // Convert the numerical hash value to a string and return
+        return hash.toString();
+    }
+}

package/dist/experimental/masking/transformer.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingTransformer = void 0;
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+class MaskingTransformer {
+}
+exports.MaskingTransformer = MaskingTransformer;

package/dist/experimental/masking/transformer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+export declare abstract class MaskingTransformer {
+    abstract transform(message: string, state?: Map<string, string>): Promise<[string, Map<string, string>]>;
+    abstract rehydrate(message: string, state: Map<string, string>): Promise<string>;
+}

package/dist/experimental/masking/transformer.js

@@ -0,0 +1,5 @@
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+export class MaskingTransformer {
+}

package/dist/experimental/masking/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/experimental/masking/types.d.ts

@@ -0,0 +1,25 @@
+import { MaskingTransformer } from "./transformer.js";
+/**
+ * Configuration type for MaskingParser.
+ */
+export type MaskingParserConfig = {
+    transformers?: MaskingTransformer[];
+    defaultHashFunction?: HashFunction;
+    onMaskingStart?: HookFunction;
+    onMaskingEnd?: HookFunction;
+    onRehydratingStart?: HookFunction;
+    onRehydratingEnd?: HookFunction;
+};
+/**
+ *  Regex Masking Pattern used for masking in PIIMaskingTransformer.
+ */
+export type MaskingPattern = {
+    regex: RegExp;
+    replacement?: string;
+    mask?: (match: string) => string;
+};
+export type HookFunction = ((message: string) => Promise<void>) | ((message: string) => void);
+/**
+ * Represents a function that can hash a string input.
+ */
+export type HashFunction = (input: string) => string;

package/dist/experimental/masking/types.js

@@ -0,0 +1 @@
+export {};

package/dist/experimental/openai_assistant/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIAssistantRunnable = void 0;
-const openai_1 = require("openai");
+const openai_1 = require("@langchain/openai");
 const base_js_1 = require("../../schema/runnable/base.cjs");
 const time_js_1 = require("../../util/time.cjs");
 const base_js_2 = require("../../tools/base.cjs");
@@ -39,7 +39,7 @@ class OpenAIAssistantRunnable extends base_js_1.Runnable {
             writable: true,
             value: void 0
         });
-        this.client = fields.client ?? new openai_1.OpenAI(fields?.clientOptions);
+        this.client = fields.client ?? new openai_1.OpenAIClient(fields?.clientOptions);
         this.assistantId = fields.assistantId;
         this.asAgent = fields.asAgent ?? this.asAgent;
     }
@@ -51,7 +51,7 @@ class OpenAIAssistantRunnable extends base_js_1.Runnable {
             }
             return tool;
         }) ?? [];
-        const oaiClient = client ?? new openai_1.OpenAI(clientOptions);
+        const oaiClient = client ?? new openai_1.OpenAIClient(clientOptions);
         const assistant = await oaiClient.beta.assistants.create({
             name,
             instructions,

package/dist/experimental/openai_assistant/index.d.ts

@@ -1,4 +1,4 @@
-import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
+import { type ClientOptions, OpenAIClient } from "@langchain/openai";
 import { Runnable } from "../../schema/runnable/base.js";
 import type { RunnableConfig } from "../../schema/runnable/config.js";
 import type { OpenAIAssistantFinish, OpenAIAssistantAction, OpenAIToolType } from "./schema.js";

package/dist/experimental/openai_assistant/index.js

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAIClient } from "openai";
+import { OpenAIClient } from "@langchain/openai";
 import { Runnable } from "../../schema/runnable/base.js";
 import { sleep } from "../../util/time.js";
 import { StructuredTool } from "../../tools/base.js";

package/dist/experimental/openai_assistant/schema.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAI as OpenAIClient } from "openai";
+import type { OpenAIClient } from "@langchain/openai";
 import type { AgentFinish, AgentAction } from "../../schema/index.js";
 export type OpenAIAssistantFinish = AgentFinish & {
     runId: string;

package/dist/experimental/openai_files/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIFiles = void 0;
-const openai_1 = require("openai");
+const openai_1 = require("@langchain/openai");
 const serializable_js_1 = require("../../load/serializable.cjs");
 class OpenAIFiles extends serializable_js_1.Serializable {
     constructor(fields) {
@@ -18,7 +18,7 @@ class OpenAIFiles extends serializable_js_1.Serializable {
             writable: true,
             value: void 0
         });
-        this.oaiClient = fields?.client ?? new openai_1.OpenAI(fields?.clientOptions);
+        this.oaiClient = fields?.client ?? new openai_1.OpenAIClient(fields?.clientOptions);
     }
     /**
      * Upload file

package/dist/experimental/openai_files/index.d.ts

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAIClient, type ClientOptions } from "openai";
+import { OpenAIClient, type ClientOptions } from "@langchain/openai";
 import { Serializable } from "../../load/serializable.js";
 export type OpenAIFilesInput = {
     client?: OpenAIClient;

package/dist/experimental/openai_files/index.js

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAIClient } from "openai";
+import { OpenAIClient } from "@langchain/openai";
 import { Serializable } from "../../load/serializable.js";
 export class OpenAIFiles extends Serializable {
     constructor(fields) {

package/dist/graphs/neo4j_graph.cjs

@@ -10,259 +10,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Neo4jGraph = void 0;
-const neo4j_driver_1 = __importStar(require("neo4j-driver"));
-/**
- * @security *Security note*: Make sure that the database connection uses credentials
- * that are narrowly-scoped to only include necessary permissions.
- * Failure to do so may result in data corruption or loss, since the calling
- * code may attempt commands that would result in deletion, mutation
- * of data if appropriately prompted or reading sensitive data if such
- * data is present in the database.
- * The best way to guard against such negative outcomes is to (as appropriate)
- * limit the permissions granted to the credentials used with this tool.
- * For example, creating read only users for the database is a good way to
- * ensure that the calling code cannot mutate or delete data.
- *
- * @link See https://js.langchain.com/docs/security for more information.
- */
-class Neo4jGraph {
-    constructor({ url, username, password, database = "neo4j", }) {
-        Object.defineProperty(this, "driver", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "database", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ""
-        });
-        Object.defineProperty(this, "structuredSchema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                nodeProps: {},
-                relProps: {},
-                relationships: [],
-            }
-        });
-        try {
-            this.driver = neo4j_driver_1.default.driver(url, neo4j_driver_1.default.auth.basic(username, password));
-            this.database = database;
-        }
-        catch (error) {
-            throw new Error("Could not create a Neo4j driver instance. Please check the connection details.");
-        }
-    }
-    static async initialize(config) {
-        const graph = new Neo4jGraph(config);
-        try {
-            await graph.verifyConnectivity();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            console.log("Failed to verify connection.");
-        }
-        try {
-            await graph.refreshSchema();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            const message = [
-                "Could not use APOC procedures.",
-                "Please ensure the APOC plugin is installed in Neo4j and that",
-                "'apoc.meta.data()' is allowed in Neo4j configuration",
-            ].join("\n");
-            throw new Error(message);
-        }
-        finally {
-            console.log("Schema refreshed successfully.");
-        }
-        return graph;
-    }
-    getSchema() {
-        return this.schema;
-    }
-    getStructuredSchema() {
-        return this.structuredSchema;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async query(query, params = {}) {
-        try {
-            const result = await this.driver.executeQuery(query, params, {
-                database: this.database,
-            });
-            return toObjects(result.records);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            if (
-            // eslint-disable-next-line
-            error instanceof neo4j_driver_1.Neo4jError &&
-                error.code === "Neo.ClientError.Procedure.ProcedureNotFound") {
-                throw new Error("Procedure not found in Neo4j.");
-            }
-        }
-        return undefined;
-    }
-    async verifyConnectivity() {
-        await this.driver.verifyAuthentication();
-    }
-    async refreshSchema() {
-        const nodePropertiesQuery = `
-      CALL apoc.meta.data()
-      YIELD label, other, elementType, type, property
-      WHERE NOT type = "RELATIONSHIP" AND elementType = "node"
-      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
-      RETURN {labels: nodeLabels, properties: properties} AS output
-    `;
-        const relPropertiesQuery = `
-      CALL apoc.meta.data()
-      YIELD label, other, elementType, type, property
-      WHERE NOT type = "RELATIONSHIP" AND elementType = "relationship"
-      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
-      RETURN {type: nodeLabels, properties: properties} AS output
-    `;
-        const relQuery = `
-      CALL apoc.meta.data()
-      YIELD label, other, elementType, type, property
-      WHERE type = "RELATIONSHIP" AND elementType = "node"
-      UNWIND other AS other_node
-      RETURN {start: label, type: property, end: toString(other_node)} AS output
-    `;
-        // Assuming query method is defined and returns a Promise
-        const nodeProperties = (await this.query(nodePropertiesQuery))?.map((el) => el.output);
-        const relationshipsProperties = (await this.query(relPropertiesQuery))?.map((el) => el.output);
-        const relationships = (await this.query(relQuery))?.map((el) => el.output);
-        // Structured schema similar to Python's dictionary comprehension
-        this.structuredSchema = {
-            nodeProps: Object.fromEntries(nodeProperties?.map((el) => [el.labels, el.properties]) || []),
-            relProps: Object.fromEntries(relationshipsProperties?.map((el) => [el.type, el.properties]) || []),
-            relationships: relationships || [],
-        };
-        // Format node properties
-        const formattedNodeProps = nodeProperties?.map((el) => {
-            const propsStr = el.properties
-                .map((prop) => `${prop.property}: ${prop.type}`)
-                .join(", ");
-            return `${el.labels} {${propsStr}}`;
-        });
-        // Format relationship properties
-        const formattedRelProps = relationshipsProperties?.map((el) => {
-            const propsStr = el.properties
-                .map((prop) => `${prop.property}: ${prop.type}`)
-                .join(", ");
-            return `${el.type} {${propsStr}}`;
-        });
-        // Format relationships
-        const formattedRels = relationships?.map((el) => `(:${el.start})-[:${el.type}]->(:${el.end})`);
-        // Combine all formatted elements into a single string
-        this.schema = [
-            "Node properties are the following:",
-            formattedNodeProps?.join(", "),
-            "Relationship properties are the following:",
-            formattedRelProps?.join(", "),
-            "The relationships are the following:",
-            formattedRels?.join(", "),
-        ].join("\n");
-    }
-    async close() {
-        await this.driver.close();
-    }
-}
-exports.Neo4jGraph = Neo4jGraph;
-function toObjects(records) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const recordValues = records.map((record) => {
-        const rObj = record.toObject();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const out = {};
-        Object.keys(rObj).forEach((key) => {
-            out[key] = itemIntToString(rObj[key]);
-        });
-        return out;
-    });
-    return recordValues;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function itemIntToString(item) {
-    if (neo4j_driver_1.default.isInt(item))
-        return item.toString();
-    if (Array.isArray(item))
-        return item.map((ii) => itemIntToString(ii));
-    if (["number", "string", "boolean"].indexOf(typeof item) !== -1)
-        return item;
-    if (item === null)
-        return item;
-    if (typeof item === "object")
-        return objIntToString(item);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function objIntToString(obj) {
-    const entry = extractFromNeoObjects(obj);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let newObj = null;
-    if (Array.isArray(entry)) {
-        newObj = entry.map((item) => itemIntToString(item));
-    }
-    else if (entry !== null && typeof entry === "object") {
-        newObj = {};
-        Object.keys(entry).forEach((key) => {
-            newObj[key] = itemIntToString(entry[key]);
-        });
-    }
-    return newObj;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractFromNeoObjects(obj) {
-    if (
-    // eslint-disable-next-line
-    obj instanceof neo4j_driver_1.default.types.Node ||
-        // eslint-disable-next-line
-        obj instanceof neo4j_driver_1.default.types.Relationship) {
-        return obj.properties;
-        // eslint-disable-next-line
-    }
-    else if (obj instanceof neo4j_driver_1.default.types.Path) {
-        // eslint-disable-next-line
-        return [].concat.apply([], extractPathForRows(obj));
-    }
-    return obj;
-}
-const extractPathForRows = (path) => {
-    let { segments } = path;
-    // Zero length path. No relationship, end === start
-    if (!Array.isArray(path.segments) || path.segments.length < 1) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        segments = [{ ...path, end: null }];
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return segments.map((segment) => [
-        objIntToString(segment.start),
-        objIntToString(segment.relationship),
-        objIntToString(segment.end),
-    ].filter((part) => part !== null));
-};
+__exportStar(require("@langchain/community/graphs/neo4j_graph"), exports);

package/dist/graphs/neo4j_graph.d.ts

@@ -1,63 +1 @@
-interface Neo4jGraphConfig {
-    url: string;
-    username: string;
-    password: string;
-    database?: string;
-}
-interface StructuredSchema {
-    nodeProps: {
-        [key: NodeType["labels"]]: NodeType["properties"];
-    };
-    relProps: {
-        [key: RelType["type"]]: RelType["properties"];
-    };
-    relationships: PathType[];
-}
-type NodeType = {
-    labels: string;
-    properties: {
-        property: string;
-        type: string;
-    }[];
-};
-type RelType = {
-    type: string;
-    properties: {
-        property: string;
-        type: string;
-    }[];
-};
-type PathType = {
-    start: string;
-    type: string;
-    end: string;
-};
-/**
- * @security *Security note*: Make sure that the database connection uses credentials
- * that are narrowly-scoped to only include necessary permissions.
- * Failure to do so may result in data corruption or loss, since the calling
- * code may attempt commands that would result in deletion, mutation
- * of data if appropriately prompted or reading sensitive data if such
- * data is present in the database.
- * The best way to guard against such negative outcomes is to (as appropriate)
- * limit the permissions granted to the credentials used with this tool.
- * For example, creating read only users for the database is a good way to
- * ensure that the calling code cannot mutate or delete data.
- *
- * @link See https://js.langchain.com/docs/security for more information.
- */
-export declare class Neo4jGraph {
-    private driver;
-    private database;
-    private schema;
-    private structuredSchema;
-    constructor({ url, username, password, database, }: Neo4jGraphConfig);
-    static initialize(config: Neo4jGraphConfig): Promise<Neo4jGraph>;
-    getSchema(): string;
-    getStructuredSchema(): StructuredSchema;
-    query(query: string, params?: any): Promise<any[] | undefined>;
-    verifyConnectivity(): Promise<void>;
-    refreshSchema(): Promise<void>;
-    close(): Promise<void>;
-}
-export {};
+export * from "@langchain/community/graphs/neo4j_graph";