langchain 0.0.175 → 0.0.177

package/dist/retrievers/zep.cjs

@@ -47,6 +47,12 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "searchScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "searchType", {
             enumerable: true,
             configurable: true,
@@ -67,17 +73,18 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
         });
         this.sessionId = config.sessionId;
         this.topK = config.topK;
+        this.searchScope = config.searchScope;
         this.searchType = config.searchType;
         this.mmrLambda = config.mmrLambda;
         this.filter = config.filter;
         this.zepClientPromise = zep_js_1.ZepClient.init(config.url, config.apiKey);
     }
     /**
-     *  Converts an array of search results to an array of Document objects.
+     *  Converts an array of message search results to an array of Document objects.
      *  @param {MemorySearchResult[]} results - The array of search results.
      *  @returns {Document[]} An array of Document objects representing the search results.
      */
-    searchResultToDoc(results) {
+    searchMessageResultToDoc(results) {
         return results
             .filter((r) => r.message)
             .map(({ message: { content, metadata: messageMetadata } = {}, dist, ...rest }) => new document_js_1.Document({
@@ -85,6 +92,19 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
             metadata: { score: dist, ...messageMetadata, ...rest },
         }));
     }
+    /**
+     *  Converts an array of summary search results to an array of Document objects.
+     *  @param {MemorySearchResult[]} results - The array of search results.
+     *  @returns {Document[]} An array of Document objects representing the search results.
+     */
+    searchSummaryResultToDoc(results) {
+        return results
+            .filter((r) => r.summary)
+            .map(({ summary: { content, metadata: summaryMetadata } = {}, dist, ...rest }) => new document_js_1.Document({
+            pageContent: content ?? "",
+            metadata: { score: dist, ...summaryMetadata, ...rest },
+        }));
+    }
     /**
      *  Retrieves the relevant documents based on the given query.
      *  @param {string} query - The query string.
@@ -94,6 +114,7 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
         const payload = {
             text: query,
             metadata: this.filter,
+            search_scope: this.searchScope,
             search_type: this.searchType,
             mmr_lambda: this.mmrLambda,
         };
@@ -104,7 +125,9 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
         }
         try {
             const results = await zepClient.memory.searchMemory(this.sessionId, payload, this.topK);
-            return this.searchResultToDoc(results);
+            return this.searchScope === "summary"
+                ? this.searchSummaryResultToDoc(results)
+                : this.searchMessageResultToDoc(results);
         }
         catch (error) {
             // eslint-disable-next-line no-instanceof/no-instanceof

package/dist/retrievers/zep.d.ts

@@ -9,6 +9,7 @@ import { Document } from "../document.js";
  * @argument {string} url - The URL of the Zep API.
  * @argument {number} [topK] - The number of results to return.
  * @argument {string} [apiKey] - The API key for the Zep API.
+ * @argument [searchScope] [searchScope] - The scope of the search: "messages" or "summary".
  * @argument [searchType] [searchType] - The type of search to perform: "similarity" or "mmr".
  * @argument {number} [mmrLambda] - The lambda value for the MMR search.
  * @argument {Record<string, unknown>} [filter] - The metadata filter to apply to the search.
@@ -18,6 +19,7 @@ export interface ZepRetrieverConfig extends BaseRetrieverInput {
     url: string;
     topK?: number;
     apiKey?: string;
+    searchScope?: "messages" | "summary";
     searchType?: "similarity" | "mmr";
     mmrLambda?: number;
     filter?: Record<string, unknown>;
@@ -38,16 +40,23 @@ export declare class ZepRetriever extends BaseRetriever {
     zepClientPromise: Promise<ZepClient>;
     private sessionId;
     private topK?;
+    private searchScope?;
     private searchType?;
     private mmrLambda?;
     private filter?;
     constructor(config: ZepRetrieverConfig);
     /**
-     *  Converts an array of search results to an array of Document objects.
+     *  Converts an array of message search results to an array of Document objects.
      *  @param {MemorySearchResult[]} results - The array of search results.
      *  @returns {Document[]} An array of Document objects representing the search results.
      */
-    private searchResultToDoc;
+    private searchMessageResultToDoc;
+    /**
+     *  Converts an array of summary search results to an array of Document objects.
+     *  @param {MemorySearchResult[]} results - The array of search results.
+     *  @returns {Document[]} An array of Document objects representing the search results.
+     */
+    private searchSummaryResultToDoc;
     /**
      *  Retrieves the relevant documents based on the given query.
      *  @param {string} query - The query string.

package/dist/retrievers/zep.js

@@ -44,6 +44,12 @@ export class ZepRetriever extends BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "searchScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "searchType", {
             enumerable: true,
             configurable: true,
@@ -64,17 +70,18 @@ export class ZepRetriever extends BaseRetriever {
         });
         this.sessionId = config.sessionId;
         this.topK = config.topK;
+        this.searchScope = config.searchScope;
         this.searchType = config.searchType;
         this.mmrLambda = config.mmrLambda;
         this.filter = config.filter;
         this.zepClientPromise = ZepClient.init(config.url, config.apiKey);
     }
     /**
-     *  Converts an array of search results to an array of Document objects.
+     *  Converts an array of message search results to an array of Document objects.
      *  @param {MemorySearchResult[]} results - The array of search results.
      *  @returns {Document[]} An array of Document objects representing the search results.
      */
-    searchResultToDoc(results) {
+    searchMessageResultToDoc(results) {
         return results
             .filter((r) => r.message)
             .map(({ message: { content, metadata: messageMetadata } = {}, dist, ...rest }) => new Document({
@@ -82,6 +89,19 @@ export class ZepRetriever extends BaseRetriever {
             metadata: { score: dist, ...messageMetadata, ...rest },
         }));
     }
+    /**
+     *  Converts an array of summary search results to an array of Document objects.
+     *  @param {MemorySearchResult[]} results - The array of search results.
+     *  @returns {Document[]} An array of Document objects representing the search results.
+     */
+    searchSummaryResultToDoc(results) {
+        return results
+            .filter((r) => r.summary)
+            .map(({ summary: { content, metadata: summaryMetadata } = {}, dist, ...rest }) => new Document({
+            pageContent: content ?? "",
+            metadata: { score: dist, ...summaryMetadata, ...rest },
+        }));
+    }
     /**
      *  Retrieves the relevant documents based on the given query.
      *  @param {string} query - The query string.
@@ -91,6 +111,7 @@ export class ZepRetriever extends BaseRetriever {
         const payload = {
             text: query,
             metadata: this.filter,
+            search_scope: this.searchScope,
             search_type: this.searchType,
             mmr_lambda: this.mmrLambda,
         };
@@ -101,7 +122,9 @@ export class ZepRetriever extends BaseRetriever {
         }
         try {
             const results = await zepClient.memory.searchMemory(this.sessionId, payload, this.topK);
-            return this.searchResultToDoc(results);
+            return this.searchScope === "summary"
+                ? this.searchSummaryResultToDoc(results)
+                : this.searchMessageResultToDoc(results);
         }
         catch (error) {
             // eslint-disable-next-line no-instanceof/no-instanceof

package/dist/types/googlevertexai-types.d.ts

@@ -45,19 +45,21 @@ export interface GoogleVertexAIBaseLLMInput<AuthOptions> extends BaseLLMParams,
 export interface GoogleResponse {
     data: any;
 }
-export interface GoogleVertexAIBasePrediction extends GoogleResponse {
+export interface GoogleVertexAIBasePrediction {
     safetyAttributes?: any;
 }
-export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAIBasePrediction> {
-    data: {
-        predictions: PredictionType[];
-    };
+export interface GoogleVertexAILLMPredictions<PredictionType extends GoogleVertexAIBasePrediction> {
+    predictions: PredictionType[];
 }
+export type GoogleAbstractedClientOpsMethod = "GET" | "POST";
+export type GoogleAbstractedClientOpsResponseType = "json" | "stream";
+export type GoogleAbstractedClientOps = {
+    url?: string;
+    method?: GoogleAbstractedClientOpsMethod;
+    data?: unknown;
+    responseType?: GoogleAbstractedClientOpsResponseType;
+};
 export interface GoogleAbstractedClient {
-    request: (opts: {
-        url?: string;
-        method?: "GET" | "POST";
-        data?: unknown;
-    }) => unknown;
+    request: (opts: GoogleAbstractedClientOps) => unknown;
     getProjectId: () => Promise<string>;
 }

package/dist/util/bedrock.d.ts

@@ -33,6 +33,8 @@ export interface BaseBedrockInput {
     stopSequences?: string[];
     /** Additional kwargs to pass to the model. */
     modelKwargs?: Record<string, unknown>;
+    /** Whether or not to stream responses */
+    streaming: boolean;
 }
 type Dict = {
     [key: string]: unknown;

package/dist/util/googlevertexai-connection.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleVertexAILLMConnection = exports.GoogleVertexAIConnection = exports.GoogleConnection = void 0;
+exports.GoogleVertexAIStream = exports.GoogleVertexAILLMConnection = exports.simpleValue = exports.complexValue = exports.GoogleVertexAIConnection = exports.GoogleConnection = void 0;
 class GoogleConnection {
-    constructor(caller, client) {
+    constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -15,13 +15,19 @@ class GoogleConnection {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.caller = caller;
         this.client = client;
+        this.streaming = streaming ?? false;
     }
     async _request(data, options) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const opts = {
             url,
             method,
@@ -29,6 +35,12 @@ class GoogleConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
+        if (this.streaming) {
+            opts.responseType = "stream";
+        }
+        else {
+            opts.responseType = "json";
+        }
         try {
             const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
@@ -42,8 +54,8 @@ class GoogleConnection {
 }
 exports.GoogleConnection = GoogleConnection;
 class GoogleVertexAIConnection extends GoogleConnection {
-    constructor(fields, caller, client) {
-        super(caller, client);
+    constructor(fields, caller, client, streaming) {
+        super(caller, client, streaming);
         Object.defineProperty(this, "endpoint", {
             enumerable: true,
             configurable: true,
@@ -73,9 +85,86 @@ class GoogleVertexAIConnection extends GoogleConnection {
     }
 }
 exports.GoogleVertexAIConnection = GoogleVertexAIConnection;
+function complexValue(value) {
+    if (value === null || typeof value === "undefined") {
+        // I dunno what to put here. An error, probably
+        return undefined;
+    }
+    else if (typeof value === "object") {
+        if (Array.isArray(value)) {
+            return {
+                list_val: value.map((avalue) => complexValue(avalue)),
+            };
+        }
+        else {
+            const ret = {};
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const v = value;
+            Object.keys(v).forEach((key) => {
+                ret[key] = complexValue(v[key]);
+            });
+            return { struct_val: ret };
+        }
+    }
+    else if (typeof value === "number") {
+        if (Number.isInteger(value)) {
+            return { int_val: value };
+        }
+        else {
+            return { float_val: value };
+        }
+    }
+    else {
+        return {
+            string_val: [value],
+        };
+    }
+}
+exports.complexValue = complexValue;
+function simpleValue(val) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+        // eslint-disable-next-line no-prototype-builtins
+        if (val.hasOwnProperty("stringVal")) {
+            return val.stringVal[0];
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("boolVal")) {
+            return val.boolVal[0];
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("listVal")) {
+            const { listVal } = val;
+            return listVal.map((aval) => simpleValue(aval));
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("structVal")) {
+            const ret = {};
+            const struct = val.structVal;
+            Object.keys(struct).forEach((key) => {
+                ret[key] = simpleValue(struct[key]);
+            });
+            return ret;
+        }
+        else {
+            const ret = {};
+            const struct = val;
+            Object.keys(struct).forEach((key) => {
+                ret[key] = simpleValue(struct[key]);
+            });
+            return ret;
+        }
+    }
+    else if (Array.isArray(val)) {
+        return val.map((aval) => simpleValue(aval));
+    }
+    else {
+        return val;
+    }
+}
+exports.simpleValue = simpleValue;
 class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller, client) {
-        super(fields, caller, client);
+    constructor(fields, caller, client, streaming) {
+        super(fields, caller, client, streaming);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
@@ -93,16 +182,215 @@ class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
     }
     async buildUrl() {
         const projectId = await this.client.getProjectId();
-        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const method = this.streaming ? "serverStreamingPredict" : "predict";
+        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:${method}`;
         return url;
     }
-    async request(instances, parameters, options) {
-        const data = {
+    formatStreamingData(inputs, parameters) {
+        return {
+            inputs: [inputs.map((i) => complexValue(i))],
+            parameters: complexValue(parameters),
+        };
+    }
+    formatStandardData(instances, parameters) {
+        return {
             instances,
             parameters,
         };
+    }
+    formatData(instances, parameters) {
+        return this.streaming
+            ? this.formatStreamingData(instances, parameters)
+            : this.formatStandardData(instances, parameters);
+    }
+    async request(instances, parameters, options) {
+        const data = this.formatData(instances, parameters);
         const response = await this._request(data, options);
         return response;
     }
 }
 exports.GoogleVertexAILLMConnection = GoogleVertexAILLMConnection;
+class GoogleVertexAIStream {
+    constructor() {
+        Object.defineProperty(this, "_buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "_bufferOpen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_firstRun", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        // Set up a potential Promise that the handler can resolve.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkResolution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // If there is no Promise (it is null), the handler must add it to the queue
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // A queue that will collect chunks while there is no Promise
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    /**
+     * Add data to the buffer. This may cause chunks to be generated, if available.
+     * @param data
+     */
+    appendBuffer(data) {
+        this._buffer += data;
+        // Our first time, skip to the opening of the array
+        if (this._firstRun) {
+            this._skipTo("[");
+            this._firstRun = false;
+        }
+        this._parseBuffer();
+    }
+    /**
+     * Indicate there is no more data that will be added to the text buffer.
+     * This should be called when all the data has been read and added to indicate
+     * that we should process everything remaining in the buffer.
+     */
+    closeBuffer() {
+        this._bufferOpen = false;
+        this._parseBuffer();
+    }
+    /**
+     * Skip characters in the buffer till we get to the start of an object.
+     * Then attempt to read a full object.
+     * If we do read a full object, turn it into a chunk and send it to the chunk handler.
+     * Repeat this for as much as we can.
+     */
+    _parseBuffer() {
+        let obj = null;
+        do {
+            this._skipTo("{");
+            obj = this._getFullObject();
+            if (obj !== null) {
+                const chunk = this._simplifyObject(obj);
+                this._handleChunk(chunk);
+            }
+        } while (obj !== null);
+        if (!this._bufferOpen) {
+            // No more data will be added, and we have parsed everything we could,
+            // so everything else is garbage.
+            this._handleChunk(null);
+            this._buffer = "";
+        }
+    }
+    /**
+     * If the string is present, move the start of the buffer to the first occurrence
+     * of that string. This is useful for skipping over elements or parts that we're not
+     * really interested in parsing. (ie - the opening characters, comma separators, etc.)
+     * @param start The string to start the buffer with
+     */
+    _skipTo(start) {
+        const index = this._buffer.indexOf(start);
+        if (index > 0) {
+            this._buffer = this._buffer.slice(index);
+        }
+    }
+    /**
+     * Given what is in the buffer, parse a single object out of it.
+     * If a complete object isn't available, return null.
+     * Assumes that we are at the start of an object to parse.
+     */
+    _getFullObject() {
+        let ret = null;
+        // Loop while we don't have something to return AND we have something in the buffer
+        let index = 0;
+        while (ret === null && this._buffer.length > index) {
+            // Advance to the next close bracket after our current index
+            index = this._buffer.indexOf("}", index + 1);
+            // If we don't find one, exit with null
+            if (index === -1) {
+                return null;
+            }
+            // If we have one, try to turn it into an object to return
+            try {
+                const objStr = this._buffer.substring(0, index + 1);
+                ret = JSON.parse(objStr);
+                // We only get here if it parsed it ok
+                // If we did turn it into an object, remove it from the buffer
+                this._buffer = this._buffer.slice(index + 1);
+            }
+            catch (xx) {
+                // It didn't parse it correctly, so we swallow the exception and continue
+            }
+        }
+        return ret;
+    }
+    _simplifyObject(obj) {
+        return simpleValue(obj);
+    }
+    /**
+     * Register that we have another chunk available for consumption.
+     * If we are waiting for a chunk, resolve the promise waiting for it immediately.
+     * If not, then add it to the queue.
+     * @param chunk
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _handleChunk(chunk) {
+        if (this._chunkPending) {
+            this._chunkResolution(chunk);
+            this._chunkPending = null;
+        }
+        else {
+            this._chunkQueue.push(chunk);
+        }
+    }
+    /**
+     * Get the next chunk that is coming from the stream.
+     * This chunk may be null, usually indicating the last chunk in the stream.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async nextChunk() {
+        if (this._chunkQueue.length > 0) {
+            // If there is data in the queue, return the next queue chunk
+            return this._chunkQueue.shift();
+        }
+        else {
+            // Otherwise, set up a promise that handleChunk will cause to be resolved
+            this._chunkPending = new Promise((resolve) => {
+                this._chunkResolution = resolve;
+            });
+            return this._chunkPending;
+        }
+    }
+    /**
+     * Is the stream done?
+     * A stream is only done if all of the following are true:
+     * - There is no more data to be added to the text buffer
+     * - There is no more data in the text buffer
+     * - There are no chunks that are waiting to be consumed
+     */
+    get streamDone() {
+        return (!this._bufferOpen &&
+            this._buffer.length === 0 &&
+            this._chunkQueue.length === 0 &&
+            this._chunkPending === null);
+    }
+}
+exports.GoogleVertexAIStream = GoogleVertexAIStream;