langchain 0.0.163 → 0.0.165

package/dist/graphs/neo4j_graph.js

@@ -53,18 +53,19 @@ export class Neo4jGraph {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async query(query, params = {}) {
-        const session = this.driver.session({ database: this.database });
         try {
-            const result = await session.run(query, params);
-            return result.records.map((record) => record.toObject());
+            const result = await this.driver.executeQuery(query, params, {
+                database: this.database,
+            });
+            return toObjects(result.records);
         }
-        finally {
-            await session.close();
+        catch (error) {
+            // ignore errors
         }
+        return undefined;
     }
     async verifyConnectivity() {
-        const session = this.driver.session({ database: this.database });
-        await session.close();
+        await this.driver.verifyAuthentication();
     }
     async refreshSchema() {
         const nodePropertiesQuery = `
@@ -93,13 +94,88 @@ export class Neo4jGraph {
         const relationships = await this.query(relQuery);
         this.schema = `
       Node properties are the following:
-      ${nodeProperties.map((el) => el.output)}
+      ${JSON.stringify(nodeProperties?.map((el) => el.output))}
 
       Relationship properties are the following:
-      ${relationshipsProperties.map((el) => el.output)}
+      ${JSON.stringify(relationshipsProperties?.map((el) => el.output))}
 
       The relationships are the following:
-      ${relationships.map((el) => el.output)}
+      ${JSON.stringify(relationships?.map((el) => el.output))}
     `;
     }
+    async close() {
+        await this.driver.close();
+    }
 }
+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.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.types.Node ||
+        // eslint-disable-next-line
+        obj instanceof neo4j.types.Relationship) {
+        return obj.properties;
+        // eslint-disable-next-line
+    }
+    else if (obj instanceof neo4j.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));
+};

package/dist/llms/bedrock.cjs

@@ -130,6 +130,9 @@ class Bedrock extends base_js_1.LLM {
             provider,
         });
         const json = await response.json();
+        if (!response.ok) {
+            throw new Error(`Error ${response.status}: ${json.message ?? JSON.stringify(json)}`);
+        }
         const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
         return text;
     }

package/dist/llms/bedrock.js

@@ -127,6 +127,9 @@ export class Bedrock extends LLM {
             provider,
         });
         const json = await response.json();
+        if (!response.ok) {
+            throw new Error(`Error ${response.status}: ${json.message ?? JSON.stringify(json)}`);
+        }
         const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
         return text;
     }

package/dist/llms/portkey.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Portkey = exports.getPortkeySession = exports.PortkeySession = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const portkey_ai_1 = require("portkey-ai");
+const index_js_1 = require("../schema/index.cjs");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+const readEnv = (env, default_val) => (0, env_js_1.getEnvironmentVariable)(env) ?? default_val;
+class PortkeySession {
+    constructor(options = {}) {
+        Object.defineProperty(this, "portkey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!options.apiKey) {
+            /* eslint-disable no-param-reassign */
+            options.apiKey = readEnv("PORTKEY_API_KEY");
+        }
+        if (!options.baseURL) {
+            /* eslint-disable no-param-reassign */
+            options.baseURL = readEnv("PORTKEY_BASE_URL", "https://api.portkey.ai");
+        }
+        this.portkey = new portkey_ai_1.Portkey({});
+        this.portkey.llms = [{}];
+        if (!options.apiKey) {
+            throw new Error("Set Portkey ApiKey in PORTKEY_API_KEY env variable");
+        }
+        this.portkey = new portkey_ai_1.Portkey(options);
+    }
+}
+exports.PortkeySession = PortkeySession;
+const defaultPortkeySession = [];
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+function getPortkeySession(options = {}) {
+    let session = defaultPortkeySession.find((session) => lodash_1.default.isEqual(session.options, options))?.session;
+    if (!session) {
+        session = new PortkeySession(options);
+        defaultPortkeySession.push({ session, options });
+    }
+    return session;
+}
+exports.getPortkeySession = getPortkeySession;
+class Portkey extends base_js_1.BaseLLM {
+    constructor(init) {
+        super(init ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "baseURL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "llms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = init?.apiKey;
+        this.baseURL = init?.baseURL;
+        this.mode = init?.mode;
+        this.llms = init?.llms;
+        this.session = getPortkeySession({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            llms: this.llms,
+            mode: this.mode,
+        });
+    }
+    _llmType() {
+        return "portkey";
+    }
+    async _generate(prompts, options, _) {
+        const choices = [];
+        for (let i = 0; i < prompts.length; i += 1) {
+            const response = await this.session.portkey.completions.create({
+                prompt: prompts[i],
+                ...options,
+                stream: false,
+            });
+            choices.push(response.choices);
+        }
+        const generations = choices.map((promptChoices) => promptChoices.map((choice) => ({
+            text: choice.text ?? "",
+            generationInfo: {
+                finishReason: choice.finish_reason,
+                logprobs: choice.logprobs,
+            },
+        })));
+        return {
+            generations,
+        };
+    }
+    async *_streamResponseChunks(input, options, runManager) {
+        const response = await this.session.portkey.completions.create({
+            prompt: input,
+            ...options,
+            stream: true,
+        });
+        for await (const data of response) {
+            const choice = data?.choices[0];
+            if (!choice) {
+                continue;
+            }
+            const chunk = new index_js_1.GenerationChunk({
+                text: choice.text ?? "",
+                generationInfo: {
+                    finishReason: choice.finish_reason,
+                },
+            });
+            yield chunk;
+            void runManager?.handleLLMNewToken(chunk.text ?? "");
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+    }
+}
+exports.Portkey = Portkey;

package/dist/llms/portkey.d.ts

@@ -0,0 +1,33 @@
+import { LLMOptions, Portkey as _Portkey } from "portkey-ai";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { GenerationChunk, LLMResult } from "../schema/index.js";
+import { BaseLLM } from "./base.js";
+interface PortkeyOptions {
+    apiKey?: string;
+    baseURL?: string;
+    mode?: string;
+    llms?: [LLMOptions] | null;
+}
+export declare class PortkeySession {
+    portkey: _Portkey;
+    constructor(options?: PortkeyOptions);
+}
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+export declare function getPortkeySession(options?: PortkeyOptions): PortkeySession;
+export declare class Portkey extends BaseLLM {
+    apiKey?: string;
+    baseURL?: string;
+    mode?: string;
+    llms?: [LLMOptions] | null;
+    session: PortkeySession;
+    constructor(init?: Partial<Portkey>);
+    _llmType(): string;
+    _generate(prompts: string[], options: this["ParsedCallOptions"], _?: CallbackManagerForLLMRun): Promise<LLMResult>;
+    _streamResponseChunks(input: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+}
+export {};

package/dist/llms/portkey.js

@@ -0,0 +1,138 @@
+import _ from "lodash";
+import { Portkey as _Portkey } from "portkey-ai";
+import { GenerationChunk } from "../schema/index.js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { BaseLLM } from "./base.js";
+const readEnv = (env, default_val) => getEnvironmentVariable(env) ?? default_val;
+export class PortkeySession {
+    constructor(options = {}) {
+        Object.defineProperty(this, "portkey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!options.apiKey) {
+            /* eslint-disable no-param-reassign */
+            options.apiKey = readEnv("PORTKEY_API_KEY");
+        }
+        if (!options.baseURL) {
+            /* eslint-disable no-param-reassign */
+            options.baseURL = readEnv("PORTKEY_BASE_URL", "https://api.portkey.ai");
+        }
+        this.portkey = new _Portkey({});
+        this.portkey.llms = [{}];
+        if (!options.apiKey) {
+            throw new Error("Set Portkey ApiKey in PORTKEY_API_KEY env variable");
+        }
+        this.portkey = new _Portkey(options);
+    }
+}
+const defaultPortkeySession = [];
+/**
+ * Get a session for the Portkey API. If one already exists with the same options,
+ * it will be returned. Otherwise, a new session will be created.
+ * @param options
+ * @returns
+ */
+export function getPortkeySession(options = {}) {
+    let session = defaultPortkeySession.find((session) => _.isEqual(session.options, options))?.session;
+    if (!session) {
+        session = new PortkeySession(options);
+        defaultPortkeySession.push({ session, options });
+    }
+    return session;
+}
+export class Portkey extends BaseLLM {
+    constructor(init) {
+        super(init ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "baseURL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "llms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = init?.apiKey;
+        this.baseURL = init?.baseURL;
+        this.mode = init?.mode;
+        this.llms = init?.llms;
+        this.session = getPortkeySession({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            llms: this.llms,
+            mode: this.mode,
+        });
+    }
+    _llmType() {
+        return "portkey";
+    }
+    async _generate(prompts, options, _) {
+        const choices = [];
+        for (let i = 0; i < prompts.length; i += 1) {
+            const response = await this.session.portkey.completions.create({
+                prompt: prompts[i],
+                ...options,
+                stream: false,
+            });
+            choices.push(response.choices);
+        }
+        const generations = choices.map((promptChoices) => promptChoices.map((choice) => ({
+            text: choice.text ?? "",
+            generationInfo: {
+                finishReason: choice.finish_reason,
+                logprobs: choice.logprobs,
+            },
+        })));
+        return {
+            generations,
+        };
+    }
+    async *_streamResponseChunks(input, options, runManager) {
+        const response = await this.session.portkey.completions.create({
+            prompt: input,
+            ...options,
+            stream: true,
+        });
+        for await (const data of response) {
+            const choice = data?.choices[0];
+            if (!choice) {
+                continue;
+            }
+            const chunk = new GenerationChunk({
+                text: choice.text ?? "",
+                generationInfo: {
+                    finishReason: choice.finish_reason,
+                },
+            });
+            yield chunk;
+            void runManager?.handleLLMNewToken(chunk.text ?? "");
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+    }
+}

package/dist/llms/sagemaker_endpoint.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SageMakerEndpoint = exports.BaseSageMakerContentHandler = void 0;
 const client_sagemaker_runtime_1 = require("@aws-sdk/client-sagemaker-runtime");
+const index_js_1 = require("../schema/index.cjs");
 const base_js_1 = require("./base.cjs");
 /**
  * A handler class to transform input from LLM to a format that SageMaker
@@ -32,14 +33,12 @@ const base_js_1 = require("./base.cjs");
  */
 class BaseSageMakerContentHandler {
     constructor() {
-        /** The MIME type of the input data passed to endpoint */
         Object.defineProperty(this, "contentType", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "text/plain"
         });
-        /** The MIME type of the response data returned from endpoint */
         Object.defineProperty(this, "accepts", {
             enumerable: true,
             configurable: true,
@@ -51,16 +50,17 @@ class BaseSageMakerContentHandler {
 exports.BaseSageMakerContentHandler = BaseSageMakerContentHandler;
 /**
  * The SageMakerEndpoint class is used to interact with SageMaker
- * Inference Endpoint models. It extends the LLM class and overrides the
- * _call method to transform the input and output between the LLM and the
- * SageMaker endpoint using the provided content handler. The class uses
- * AWS client for authentication, which automatically loads credentials.
+ * Inference Endpoint models. It uses the AWS client for authentication,
+ * which automatically loads credentials.
  * If a specific credential profile is to be used, the name of the profile
  * from the ~/.aws/credentials file must be passed. The credentials or
  * roles used should have the required policies to access the SageMaker
  * endpoint.
  */
 class SageMakerEndpoint extends base_js_1.LLM {
+    static lc_name() {
+        return "SageMakerEndpoint";
+    }
     get lc_secrets() {
         return {
             "clientOptions.credentials.accessKeyId": "AWS_ACCESS_KEY_ID",
@@ -69,39 +69,44 @@ class SageMakerEndpoint extends base_js_1.LLM {
         };
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(fields);
         Object.defineProperty(this, "endpointName", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "contentHandler", {
+        Object.defineProperty(this, "modelKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelKwargs", {
+        Object.defineProperty(this, "endpointKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpointKwargs", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "client", {
+        Object.defineProperty(this, "contentHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const regionName = fields.clientOptions.region;
-        if (!regionName) {
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.clientOptions.region) {
             throw new Error(`Please pass a "clientOptions" object with a "region" field to the constructor`);
         }
         const endpointName = fields?.endpointName;
@@ -116,13 +121,33 @@ class SageMakerEndpoint extends base_js_1.LLM {
         this.contentHandler = fields.contentHandler;
         this.endpointKwargs = fields.endpointKwargs;
         this.modelKwargs = fields.modelKwargs;
+        this.streaming = fields.streaming ?? false;
         this.client = new client_sagemaker_runtime_1.SageMakerRuntimeClient(fields.clientOptions);
     }
     _llmType() {
         return "sagemaker_endpoint";
     }
+    /**
+     * Calls the SageMaker endpoint and retrieves the result.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @param {CallbackManagerForLLMRun} _runManager Optional run manager.
+     * @returns {Promise<string>} A promise that resolves to the generated string.
+     */
     /** @ignore */
-    async _call(prompt, options) {
+    async _call(prompt, options, _runManager) {
+        return this.streaming
+            ? await this.streamingCall(prompt, options)
+            : await this.noStreamingCall(prompt, options);
+    }
+    async streamingCall(prompt, options) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options)) {
+            chunks.push(chunk.text);
+        }
+        return chunks.join("");
+    }
+    async noStreamingCall(prompt, options) {
         const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
         const { contentType, accepts } = this.contentHandler;
         const response = await this.caller.call(() => this.client.send(new client_sagemaker_runtime_1.InvokeEndpointCommand({
@@ -137,5 +162,42 @@ class SageMakerEndpoint extends base_js_1.LLM {
         }
         return this.contentHandler.transformOutput(response.Body);
     }
+    /**
+     * Streams response chunks from the SageMaker endpoint.
+     * @param {string} prompt The input prompt.
+     * @param {this["ParsedCallOptions"]} options Parsed call options.
+     * @returns {AsyncGenerator<GenerationChunk>} An asynchronous generator yielding generation chunks.
+     */
+    async *_streamResponseChunks(prompt, options) {
+        const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
+        const { contentType, accepts } = this.contentHandler;
+        const stream = await this.caller.call(() => this.client.send(new client_sagemaker_runtime_1.InvokeEndpointWithResponseStreamCommand({
+            EndpointName: this.endpointName,
+            Body: body,
+            ContentType: contentType,
+            Accept: accepts,
+            ...this.endpointKwargs,
+        }), { abortSignal: options.signal }));
+        if (!stream.Body) {
+            throw new Error("Inference result missing Body");
+        }
+        for await (const chunk of stream.Body) {
+            if (chunk.PayloadPart && chunk.PayloadPart.Bytes) {
+                yield new index_js_1.GenerationChunk({
+                    text: await this.contentHandler.transformOutput(chunk.PayloadPart.Bytes),
+                    generationInfo: {
+                        ...chunk,
+                        response: undefined,
+                    },
+                });
+            }
+            else if (chunk.InternalStreamFailure) {
+                throw new Error(chunk.InternalStreamFailure.message);
+            }
+            else if (chunk.ModelStreamError) {
+                throw new Error(chunk.ModelStreamError.message);
+            }
+        }
+    }
 }
 exports.SageMakerEndpoint = SageMakerEndpoint;