langchain 0.0.154 → 0.0.155

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

@@ -0,0 +1,181 @@
+// @ts-nocheck
+// Inlined because of ESM import issues
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+const _hasOwnProperty = Object.prototype.hasOwnProperty;
+export function hasOwnProperty(obj, key) {
+    return _hasOwnProperty.call(obj, key);
+}
+export function _objectKeys(obj) {
+    if (Array.isArray(obj)) {
+        const keys = new Array(obj.length);
+        for (let k = 0; k < keys.length; k++) {
+            keys[k] = "" + k;
+        }
+        return keys;
+    }
+    if (Object.keys) {
+        return Object.keys(obj);
+    }
+    let keys = [];
+    for (let i in obj) {
+        if (hasOwnProperty(obj, i)) {
+            keys.push(i);
+        }
+    }
+    return keys;
+}
+/**
+ * Deeply clone the object.
+ * https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+ * @param  {any} obj value to clone
+ * @return {any} cloned obj
+ */
+export function _deepClone(obj) {
+    switch (typeof obj) {
+        case "object":
+            return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
+        case "undefined":
+            return null; //this is how JSON.stringify behaves for array items
+        default:
+            return obj; //no need to clone primitives
+    }
+}
+//3x faster than cached /^\d+$/.test(str)
+export function isInteger(str) {
+    let i = 0;
+    const len = str.length;
+    let charCode;
+    while (i < len) {
+        charCode = str.charCodeAt(i);
+        if (charCode >= 48 && charCode <= 57) {
+            i++;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Escapes a json pointer path
+ * @param path The raw pointer
+ * @return the Escaped path
+ */
+export function escapePathComponent(path) {
+    if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
+        return path;
+    return path.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export function unescapePathComponent(path) {
+    return path.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+export function _getPathRecursive(root, obj) {
+    let found;
+    for (let key in root) {
+        if (hasOwnProperty(root, key)) {
+            if (root[key] === obj) {
+                return escapePathComponent(key) + "/";
+            }
+            else if (typeof root[key] === "object") {
+                found = _getPathRecursive(root[key], obj);
+                if (found != "") {
+                    return escapePathComponent(key) + "/" + found;
+                }
+            }
+        }
+    }
+    return "";
+}
+export function getPath(root, obj) {
+    if (root === obj) {
+        return "/";
+    }
+    const path = _getPathRecursive(root, obj);
+    if (path === "") {
+        throw new Error("Object not found in root");
+    }
+    return `/${path}`;
+}
+/**
+ * Recursively checks whether an object has any undefined values inside.
+ */
+export function hasUndefined(obj) {
+    if (obj === undefined) {
+        return true;
+    }
+    if (obj) {
+        if (Array.isArray(obj)) {
+            for (let i = 0, len = obj.length; i < len; i++) {
+                if (hasUndefined(obj[i])) {
+                    return true;
+                }
+            }
+        }
+        else if (typeof obj === "object") {
+            const objKeys = _objectKeys(obj);
+            const objKeysLength = objKeys.length;
+            for (var i = 0; i < objKeysLength; i++) {
+                if (hasUndefined(obj[objKeys[i]])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function patchErrorMessageFormatter(message, args) {
+    const messageParts = [message];
+    for (const key in args) {
+        const value = typeof args[key] === "object"
+            ? JSON.stringify(args[key], null, 2)
+            : args[key]; // pretty print
+        if (typeof value !== "undefined") {
+            messageParts.push(`${key}: ${value}`);
+        }
+    }
+    return messageParts.join("\n");
+}
+export class PatchError extends Error {
+    constructor(message, name, index, operation, tree) {
+        super(patchErrorMessageFormatter(message, { name, index, operation, tree }));
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: name
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: index
+        });
+        Object.defineProperty(this, "operation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: operation
+        });
+        Object.defineProperty(this, "tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tree
+        });
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359
+        this.message = patchErrorMessageFormatter(message, {
+            name,
+            index,
+            operation,
+            tree,
+        });
+    }
+}

package/dist/util/googlevertexai-webauth.cjs

@@ -11,19 +11,23 @@ class WebGoogleAuth {
             writable: true,
             value: void 0
         });
+        const accessToken = options?.accessToken;
         const credentials = options?.credentials ??
             (0, env_js_1.getEnvironmentVariable)("GOOGLE_VERTEX_AI_WEB_CREDENTIALS");
         if (credentials === undefined)
             throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS or pass credentials into "authOptions.credentials".`);
         const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
-        this.options = { ...options, credentials, scope };
+        this.options = { ...options, accessToken, credentials, scope };
     }
     async getProjectId() {
         const credentials = (0, google_1.getCredentials)(this.options.credentials);
         return credentials.project_id;
     }
     async request(opts) {
-        const accessToken = await (0, google_1.getAccessToken)(this.options);
+        let { accessToken } = this.options;
+        if (accessToken === undefined) {
+            accessToken = await (0, google_1.getAccessToken)(this.options);
+        }
         if (opts.url == null)
             throw new Error("Missing URL");
         const fetchOptions = {

package/dist/util/googlevertexai-webauth.d.ts

@@ -3,6 +3,7 @@ import type { GoogleVertexAIAbstractedClient } from "../types/googlevertexai-typ
 export type WebGoogleAuthOptions = {
     credentials: string | Credentials;
     scope?: string | string[];
+    accessToken?: string;
 };
 export declare class WebGoogleAuth implements GoogleVertexAIAbstractedClient {
     options: WebGoogleAuthOptions;

package/dist/util/googlevertexai-webauth.js

@@ -8,19 +8,23 @@ export class WebGoogleAuth {
             writable: true,
             value: void 0
         });
+        const accessToken = options?.accessToken;
         const credentials = options?.credentials ??
             getEnvironmentVariable("GOOGLE_VERTEX_AI_WEB_CREDENTIALS");
         if (credentials === undefined)
             throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS or pass credentials into "authOptions.credentials".`);
         const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
-        this.options = { ...options, credentials, scope };
+        this.options = { ...options, accessToken, credentials, scope };
     }
     async getProjectId() {
         const credentials = getCredentials(this.options.credentials);
         return credentials.project_id;
     }
     async request(opts) {
-        const accessToken = await getAccessToken(this.options);
+        let { accessToken } = this.options;
+        if (accessToken === undefined) {
+            accessToken = await getAccessToken(this.options);
+        }
         if (opts.url == null)
             throw new Error("Missing URL");
         const fetchOptions = {

package/dist/util/stream.cjs

@@ -1,47 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableReadableStream = exports.readableStreamToAsyncIterable = void 0;
+exports.IterableReadableStream = void 0;
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
-function readableStreamToAsyncIterable(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-stream, preventCancel = false) {
-    if (stream[Symbol.asyncIterator]) {
-        return stream[Symbol.asyncIterator]();
-    }
-    const reader = stream.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result.done)
-                    reader.releaseLock(); // release lock when stream becomes closed
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock(); // release lock when stream becomes errored
-                throw e;
-            }
-        },
-        async return() {
-            if (!preventCancel) {
-                const cancelPromise = reader.cancel(); // cancel first, but don't await yet
-                reader.releaseLock(); // release lock first
-                await cancelPromise; // now await it
-            }
-            else {
-                reader.releaseLock();
-            }
-            return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-}
-exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
 class IterableReadableStream extends ReadableStream {
     constructor() {
         super(...arguments);
@@ -75,7 +38,7 @@ class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined };
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -86,7 +49,6 @@ class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             start(controller) {
                 return pump();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 function pump() {
                     return reader.read().then(({ done, value }) => {
                         // When no more data needs to be consumed, close the stream

package/dist/util/stream.d.ts

@@ -1,11 +1,10 @@
-export declare function readableStreamToAsyncIterable(stream: any, preventCancel?: boolean): any;
 export declare class IterableReadableStream<T> extends ReadableStream<T> {
     reader: ReadableStreamDefaultReader<T>;
     ensureReader(): void;
     next(): Promise<ReadableStreamReadResult<T>>;
     return(): Promise<{
         done: boolean;
-        value: undefined;
+        value: T;
     }>;
     [Symbol.asyncIterator](): this;
     static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;

package/dist/util/stream.js

@@ -2,42 +2,6 @@
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
-export function readableStreamToAsyncIterable(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-stream, preventCancel = false) {
-    if (stream[Symbol.asyncIterator]) {
-        return stream[Symbol.asyncIterator]();
-    }
-    const reader = stream.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result.done)
-                    reader.releaseLock(); // release lock when stream becomes closed
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock(); // release lock when stream becomes errored
-                throw e;
-            }
-        },
-        async return() {
-            if (!preventCancel) {
-                const cancelPromise = reader.cancel(); // cancel first, but don't await yet
-                reader.releaseLock(); // release lock first
-                await cancelPromise; // now await it
-            }
-            else {
-                reader.releaseLock();
-            }
-            return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-}
 export class IterableReadableStream extends ReadableStream {
     constructor() {
         super(...arguments);
@@ -71,7 +35,7 @@ export class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined };
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -82,7 +46,6 @@ export class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             start(controller) {
                 return pump();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 function pump() {
                     return reader.read().then(({ done, value }) => {
                         // When no more data needs to be consumed, close the stream

package/dist/vectorstores/pgvector.cjs

@@ -173,7 +173,7 @@ class PGVectorStore extends base_js_1.VectorStore {
             }
             catch (e) {
                 console.error(e);
-                throw new Error(`Error inserting: ${chunk[1]}`);
+                throw new Error(`Error inserting: ${e.message}`);
             }
         }
     }

package/dist/vectorstores/pgvector.js

@@ -167,7 +167,7 @@ export class PGVectorStore extends VectorStore {
             }
             catch (e) {
                 console.error(e);
-                throw new Error(`Error inserting: ${chunk[1]}`);
+                throw new Error(`Error inserting: ${e.message}`);
             }
         }
     }