langchain 0.0.178 → 0.0.179

package/dist/util/fast-json-patch/src/duplex.cjs

@@ -0,0 +1,237 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = exports.generate = exports.observe = exports.unobserve = void 0;
+// Inlined because of ESM import issues
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2013-2021 Joachim Wester
+ * MIT license
+ */
+const helpers_js_1 = require("./helpers.cjs");
+const core_js_1 = require("./core.cjs");
+var beforeDict = new WeakMap();
+class Mirror {
+    constructor(obj) {
+        Object.defineProperty(this, "obj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.obj = obj;
+    }
+}
+class ObserverInfo {
+    constructor(callback, observer) {
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "observer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.callback = callback;
+        this.observer = observer;
+    }
+}
+function getMirror(obj) {
+    return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+    return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+    mirror.observers.delete(observer.callback);
+}
+/**
+ * Detach an observer from an object
+ */
+function unobserve(root, observer) {
+    observer.unobserve();
+}
+exports.unobserve = unobserve;
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+function observe(obj, callback) {
+    var patches = [];
+    var observer;
+    var mirror = getMirror(obj);
+    if (!mirror) {
+        mirror = new Mirror(obj);
+        beforeDict.set(obj, mirror);
+    }
+    else {
+        const observerInfo = getObserverFromMirror(mirror, callback);
+        observer = observerInfo && observerInfo.observer;
+    }
+    if (observer) {
+        return observer;
+    }
+    observer = {};
+    mirror.value = (0, helpers_js_1._deepClone)(obj);
+    if (callback) {
+        observer.callback = callback;
+        observer.next = null;
+        var dirtyCheck = () => {
+            generate(observer);
+        };
+        var fastCheck = () => {
+            clearTimeout(observer.next);
+            observer.next = setTimeout(dirtyCheck);
+        };
+        if (typeof window !== "undefined") {
+            //not Node
+            window.addEventListener("mouseup", fastCheck);
+            window.addEventListener("keyup", fastCheck);
+            window.addEventListener("mousedown", fastCheck);
+            window.addEventListener("keydown", fastCheck);
+            window.addEventListener("change", fastCheck);
+        }
+    }
+    observer.patches = patches;
+    observer.object = obj;
+    observer.unobserve = () => {
+        generate(observer);
+        clearTimeout(observer.next);
+        removeObserverFromMirror(mirror, observer);
+        if (typeof window !== "undefined") {
+            window.removeEventListener("mouseup", fastCheck);
+            window.removeEventListener("keyup", fastCheck);
+            window.removeEventListener("mousedown", fastCheck);
+            window.removeEventListener("keydown", fastCheck);
+            window.removeEventListener("change", fastCheck);
+        }
+    };
+    mirror.observers.set(callback, new ObserverInfo(callback, observer));
+    return observer;
+}
+exports.observe = observe;
+/**
+ * Generate an array of patches from an observer
+ */
+function generate(observer, invertible = false) {
+    var mirror = beforeDict.get(observer.object);
+    _generate(mirror.value, observer.object, observer.patches, "", invertible);
+    if (observer.patches.length) {
+        (0, core_js_1.applyPatch)(mirror.value, observer.patches);
+    }
+    var temp = observer.patches;
+    if (temp.length > 0) {
+        observer.patches = [];
+        if (observer.callback) {
+            observer.callback(temp);
+        }
+    }
+    return temp;
+}
+exports.generate = generate;
+// Dirty check if obj is different from mirror, generate patches and update mirror
+function _generate(mirror, obj, patches, path, invertible) {
+    if (obj === mirror) {
+        return;
+    }
+    if (typeof obj.toJSON === "function") {
+        obj = obj.toJSON();
+    }
+    var newKeys = (0, helpers_js_1._objectKeys)(obj);
+    var oldKeys = (0, helpers_js_1._objectKeys)(mirror);
+    var changed = false;
+    var deleted = false;
+    //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)"
+    for (var t = oldKeys.length - 1; t >= 0; t--) {
+        var key = oldKeys[t];
+        var oldVal = mirror[key];
+        if ((0, helpers_js_1.hasOwnProperty)(obj, key) &&
+            !(obj[key] === undefined &&
+                oldVal !== undefined &&
+                Array.isArray(obj) === false)) {
+            var newVal = obj[key];
+            if (typeof oldVal == "object" &&
+                oldVal != null &&
+                typeof newVal == "object" &&
+                newVal != null &&
+                Array.isArray(oldVal) === Array.isArray(newVal)) {
+                _generate(oldVal, newVal, patches, path + "/" + (0, helpers_js_1.escapePathComponent)(key), invertible);
+            }
+            else {
+                if (oldVal !== newVal) {
+                    changed = true;
+                    if (invertible) {
+                        patches.push({
+                            op: "test",
+                            path: path + "/" + (0, helpers_js_1.escapePathComponent)(key),
+                            value: (0, helpers_js_1._deepClone)(oldVal),
+                        });
+                    }
+                    patches.push({
+                        op: "replace",
+                        path: path + "/" + (0, helpers_js_1.escapePathComponent)(key),
+                        value: (0, helpers_js_1._deepClone)(newVal),
+                    });
+                }
+            }
+        }
+        else if (Array.isArray(mirror) === Array.isArray(obj)) {
+            if (invertible) {
+                patches.push({
+                    op: "test",
+                    path: path + "/" + (0, helpers_js_1.escapePathComponent)(key),
+                    value: (0, helpers_js_1._deepClone)(oldVal),
+                });
+            }
+            patches.push({
+                op: "remove",
+                path: path + "/" + (0, helpers_js_1.escapePathComponent)(key),
+            });
+            deleted = true; // property has been deleted
+        }
+        else {
+            if (invertible) {
+                patches.push({ op: "test", path, value: mirror });
+            }
+            patches.push({ op: "replace", path, value: obj });
+            changed = true;
+        }
+    }
+    if (!deleted && newKeys.length == oldKeys.length) {
+        return;
+    }
+    for (var t = 0; t < newKeys.length; t++) {
+        var key = newKeys[t];
+        if (!(0, helpers_js_1.hasOwnProperty)(mirror, key) && obj[key] !== undefined) {
+            patches.push({
+                op: "add",
+                path: path + "/" + (0, helpers_js_1.escapePathComponent)(key),
+                value: (0, helpers_js_1._deepClone)(obj[key]),
+            });
+        }
+    }
+}
+/**
+ * Create an array of patches from the differences in two objects
+ */
+function compare(tree1, tree2, invertible = false) {
+    var patches = [];
+    _generate(tree1, tree2, patches, "", invertible);
+    return patches;
+}
+exports.compare = compare;

package/dist/util/fast-json-patch/src/duplex.d.ts

@@ -0,0 +1,23 @@
+import { Operation } from "./core.js";
+export interface Observer<T> {
+    object: T;
+    patches: Operation[];
+    unobserve: () => void;
+    callback: (patches: Operation[]) => void;
+}
+/**
+ * Detach an observer from an object
+ */
+export declare function unobserve<T>(root: T, observer: Observer<T>): void;
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+export declare function observe<T>(obj: Object | Array<T>, callback?: (patches: Operation[]) => void): Observer<T>;
+/**
+ * Generate an array of patches from an observer
+ */
+export declare function generate<T>(observer: Observer<Object>, invertible?: boolean): Operation[];
+/**
+ * Create an array of patches from the differences in two objects
+ */
+export declare function compare(tree1: Object | Array<any>, tree2: Object | Array<any>, invertible?: boolean): Operation[];

package/dist/util/fast-json-patch/src/duplex.js

@@ -0,0 +1,230 @@
+// @ts-nocheck
+// Inlined because of ESM import issues
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2013-2021 Joachim Wester
+ * MIT license
+ */
+import { _deepClone, _objectKeys, escapePathComponent, hasOwnProperty, } from "./helpers.js";
+import { applyPatch } from "./core.js";
+var beforeDict = new WeakMap();
+class Mirror {
+    constructor(obj) {
+        Object.defineProperty(this, "obj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.obj = obj;
+    }
+}
+class ObserverInfo {
+    constructor(callback, observer) {
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "observer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.callback = callback;
+        this.observer = observer;
+    }
+}
+function getMirror(obj) {
+    return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+    return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+    mirror.observers.delete(observer.callback);
+}
+/**
+ * Detach an observer from an object
+ */
+export function unobserve(root, observer) {
+    observer.unobserve();
+}
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+export function observe(obj, callback) {
+    var patches = [];
+    var observer;
+    var mirror = getMirror(obj);
+    if (!mirror) {
+        mirror = new Mirror(obj);
+        beforeDict.set(obj, mirror);
+    }
+    else {
+        const observerInfo = getObserverFromMirror(mirror, callback);
+        observer = observerInfo && observerInfo.observer;
+    }
+    if (observer) {
+        return observer;
+    }
+    observer = {};
+    mirror.value = _deepClone(obj);
+    if (callback) {
+        observer.callback = callback;
+        observer.next = null;
+        var dirtyCheck = () => {
+            generate(observer);
+        };
+        var fastCheck = () => {
+            clearTimeout(observer.next);
+            observer.next = setTimeout(dirtyCheck);
+        };
+        if (typeof window !== "undefined") {
+            //not Node
+            window.addEventListener("mouseup", fastCheck);
+            window.addEventListener("keyup", fastCheck);
+            window.addEventListener("mousedown", fastCheck);
+            window.addEventListener("keydown", fastCheck);
+            window.addEventListener("change", fastCheck);
+        }
+    }
+    observer.patches = patches;
+    observer.object = obj;
+    observer.unobserve = () => {
+        generate(observer);
+        clearTimeout(observer.next);
+        removeObserverFromMirror(mirror, observer);
+        if (typeof window !== "undefined") {
+            window.removeEventListener("mouseup", fastCheck);
+            window.removeEventListener("keyup", fastCheck);
+            window.removeEventListener("mousedown", fastCheck);
+            window.removeEventListener("keydown", fastCheck);
+            window.removeEventListener("change", fastCheck);
+        }
+    };
+    mirror.observers.set(callback, new ObserverInfo(callback, observer));
+    return observer;
+}
+/**
+ * Generate an array of patches from an observer
+ */
+export function generate(observer, invertible = false) {
+    var mirror = beforeDict.get(observer.object);
+    _generate(mirror.value, observer.object, observer.patches, "", invertible);
+    if (observer.patches.length) {
+        applyPatch(mirror.value, observer.patches);
+    }
+    var temp = observer.patches;
+    if (temp.length > 0) {
+        observer.patches = [];
+        if (observer.callback) {
+            observer.callback(temp);
+        }
+    }
+    return temp;
+}
+// Dirty check if obj is different from mirror, generate patches and update mirror
+function _generate(mirror, obj, patches, path, invertible) {
+    if (obj === mirror) {
+        return;
+    }
+    if (typeof obj.toJSON === "function") {
+        obj = obj.toJSON();
+    }
+    var newKeys = _objectKeys(obj);
+    var oldKeys = _objectKeys(mirror);
+    var changed = false;
+    var deleted = false;
+    //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)"
+    for (var t = oldKeys.length - 1; t >= 0; t--) {
+        var key = oldKeys[t];
+        var oldVal = mirror[key];
+        if (hasOwnProperty(obj, key) &&
+            !(obj[key] === undefined &&
+                oldVal !== undefined &&
+                Array.isArray(obj) === false)) {
+            var newVal = obj[key];
+            if (typeof oldVal == "object" &&
+                oldVal != null &&
+                typeof newVal == "object" &&
+                newVal != null &&
+                Array.isArray(oldVal) === Array.isArray(newVal)) {
+                _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
+            }
+            else {
+                if (oldVal !== newVal) {
+                    changed = true;
+                    if (invertible) {
+                        patches.push({
+                            op: "test",
+                            path: path + "/" + escapePathComponent(key),
+                            value: _deepClone(oldVal),
+                        });
+                    }
+                    patches.push({
+                        op: "replace",
+                        path: path + "/" + escapePathComponent(key),
+                        value: _deepClone(newVal),
+                    });
+                }
+            }
+        }
+        else if (Array.isArray(mirror) === Array.isArray(obj)) {
+            if (invertible) {
+                patches.push({
+                    op: "test",
+                    path: path + "/" + escapePathComponent(key),
+                    value: _deepClone(oldVal),
+                });
+            }
+            patches.push({
+                op: "remove",
+                path: path + "/" + escapePathComponent(key),
+            });
+            deleted = true; // property has been deleted
+        }
+        else {
+            if (invertible) {
+                patches.push({ op: "test", path, value: mirror });
+            }
+            patches.push({ op: "replace", path, value: obj });
+            changed = true;
+        }
+    }
+    if (!deleted && newKeys.length == oldKeys.length) {
+        return;
+    }
+    for (var t = 0; t < newKeys.length; t++) {
+        var key = newKeys[t];
+        if (!hasOwnProperty(mirror, key) && obj[key] !== undefined) {
+            patches.push({
+                op: "add",
+                path: path + "/" + escapePathComponent(key),
+                value: _deepClone(obj[key]),
+            });
+        }
+    }
+}
+/**
+ * Create an array of patches from the differences in two objects
+ */
+export function compare(tree1, tree2, invertible = false) {
+    var patches = [];
+    _generate(tree1, tree2, patches, "", invertible);
+    return patches;
+}

package/dist/vectorstores/convex.d.ts

@@ -14,12 +14,33 @@ export type ConvexVectorStoreConfig<DataModel extends GenericDataModel, TableNam
     id: string;
 }, object | null>> = {
     readonly ctx: GenericActionCtx<DataModel>;
+    /**
+     * Defaults to "documents"
+     */
     readonly table?: TableName;
+    /**
+     * Defaults to "byEmbedding"
+     */
     readonly index?: IndexName;
+    /**
+     * Defaults to "text"
+     */
     readonly textField?: TextFieldName;
+    /**
+     * Defaults to "embedding"
+     */
     readonly embeddingField?: EmbeddingFieldName;
+    /**
+     * Defaults to "metadata"
+     */
     readonly metadataField?: MetadataFieldName;
+    /**
+     * Defaults to `internal.langchain.db.insert`
+     */
     readonly insert?: InsertMutation;
+    /**
+     * Defaults to `internal.langchain.db.get`
+     */
     readonly get?: GetQuery;
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.178",
+  "version": "0.0.179",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {
@@ -82,6 +82,9 @@
     "chains.cjs",
     "chains.js",
     "chains.d.ts",
+    "chains/combine_documents/reduce.cjs",
+    "chains/combine_documents/reduce.js",
+    "chains/combine_documents/reduce.d.ts",
     "chains/load.cjs",
     "chains/load.js",
     "chains/load.d.ts",
@@ -526,6 +529,9 @@
     "schema/output_parser.cjs",
     "schema/output_parser.js",
     "schema/output_parser.d.ts",
+    "schema/prompt_template.cjs",
+    "schema/prompt_template.js",
+    "schema/prompt_template.d.ts",
     "schema/query_constructor.cjs",
     "schema/query_constructor.js",
     "schema/query_constructor.d.ts",
@@ -1491,6 +1497,11 @@
       "import": "./chains.js",
       "require": "./chains.cjs"
     },
+    "./chains/combine_documents/reduce": {
+      "types": "./chains/combine_documents/reduce.d.ts",
+      "import": "./chains/combine_documents/reduce.js",
+      "require": "./chains/combine_documents/reduce.cjs"
+    },
     "./chains/load": {
       "types": "./chains/load.d.ts",
       "import": "./chains/load.js",
@@ -2231,6 +2242,11 @@
       "import": "./schema/output_parser.js",
       "require": "./schema/output_parser.cjs"
     },
+    "./schema/prompt_template": {
+      "types": "./schema/prompt_template.d.ts",
+      "import": "./schema/prompt_template.js",
+      "require": "./schema/prompt_template.cjs"
+    },
     "./schema/query_constructor": {
       "types": "./schema/query_constructor.d.ts",
       "import": "./schema/query_constructor.js",

package/schema/prompt_template.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/schema/prompt_template.cjs');

package/schema/prompt_template.d.ts

@@ -0,0 +1 @@
+export * from '../dist/schema/prompt_template.js'

package/schema/prompt_template.js

@@ -0,0 +1 @@
+export * from '../dist/schema/prompt_template.js'