langchain 0.0.177 → 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/util/iflytek_websocket_stream.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWebSocketStream = void 0;
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+class BaseWebSocketStream {
+    constructor(url, options = {}) {
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "close", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (options.signal?.aborted) {
+            throw new DOMException("This operation was aborted", "AbortError");
+        }
+        this.url = url;
+        const ws = this.openWebSocket(url, options);
+        const closeWithInfo = ({ code, reason } = {}) => ws.close(code, reason);
+        this.connection = new Promise((resolve, reject) => {
+            ws.onopen = () => {
+                resolve({
+                    readable: new ReadableStream({
+                        start(controller) {
+                            ws.onmessage = ({ data }) => controller.enqueue(data);
+                            ws.onerror = (e) => controller.error(e);
+                        },
+                        cancel: closeWithInfo,
+                    }),
+                    writable: new WritableStream({
+                        write(chunk) {
+                            ws.send(chunk);
+                        },
+                        abort() {
+                            ws.close();
+                        },
+                        close: closeWithInfo,
+                    }),
+                    protocol: ws.protocol,
+                    extensions: ws.extensions,
+                });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        this.closed = new Promise((resolve, reject) => {
+            ws.onclose = ({ code, reason }) => {
+                resolve({ code, reason });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        if (options.signal) {
+            // eslint-disable-next-line no-param-reassign
+            options.signal.onabort = () => ws.close();
+        }
+        this.close = closeWithInfo;
+    }
+}
+exports.BaseWebSocketStream = BaseWebSocketStream;

package/dist/util/iflytek_websocket_stream.d.ts

@@ -0,0 +1,27 @@
+export interface WebSocketConnection<T extends Uint8Array | string = Uint8Array | string> {
+    readable: ReadableStream<T>;
+    writable: WritableStream<T>;
+    protocol: string;
+    extensions: string;
+}
+export interface WebSocketCloseInfo {
+    code?: number;
+    reason?: string;
+}
+export interface WebSocketStreamOptions {
+    protocols?: string[];
+    signal?: AbortSignal;
+}
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export declare abstract class BaseWebSocketStream<T extends Uint8Array | string = Uint8Array | string> {
+    readonly url: string;
+    readonly connection: Promise<WebSocketConnection<T>>;
+    readonly closed: Promise<WebSocketCloseInfo>;
+    readonly close: (closeInfo?: WebSocketCloseInfo) => void;
+    constructor(url: string, options?: WebSocketStreamOptions);
+    abstract openWebSocket(url: string, options: WebSocketStreamOptions): WebSocket;
+}

package/dist/util/iflytek_websocket_stream.js

@@ -0,0 +1,77 @@
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export class BaseWebSocketStream {
+    constructor(url, options = {}) {
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "close", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (options.signal?.aborted) {
+            throw new DOMException("This operation was aborted", "AbortError");
+        }
+        this.url = url;
+        const ws = this.openWebSocket(url, options);
+        const closeWithInfo = ({ code, reason } = {}) => ws.close(code, reason);
+        this.connection = new Promise((resolve, reject) => {
+            ws.onopen = () => {
+                resolve({
+                    readable: new ReadableStream({
+                        start(controller) {
+                            ws.onmessage = ({ data }) => controller.enqueue(data);
+                            ws.onerror = (e) => controller.error(e);
+                        },
+                        cancel: closeWithInfo,
+                    }),
+                    writable: new WritableStream({
+                        write(chunk) {
+                            ws.send(chunk);
+                        },
+                        abort() {
+                            ws.close();
+                        },
+                        close: closeWithInfo,
+                    }),
+                    protocol: ws.protocol,
+                    extensions: ws.extensions,
+                });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        this.closed = new Promise((resolve, reject) => {
+            ws.onclose = ({ code, reason }) => {
+                resolve({ code, reason });
+                ws.removeEventListener("error", reject);
+            };
+            ws.addEventListener("error", reject);
+        });
+        if (options.signal) {
+            // eslint-disable-next-line no-param-reassign
+            options.signal.onabort = () => ws.close();
+        }
+        this.close = closeWithInfo;
+    }
+}