langchain 0.0.155 → 0.0.157

package/dist/embeddings/cloudflare_workersai.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudflareWorkersAIEmbeddings = void 0;
+const ai_1 = require("@cloudflare/ai");
+const chunk_js_1 = require("../util/chunk.cjs");
+const base_js_1 = require("./base.cjs");
+class CloudflareWorkersAIEmbeddings extends base_js_1.Embeddings {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "@cf/baai/bge-base-en-v1.5"
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "ai", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.binding) {
+            throw new Error("Must supply a Workers AI binding, eg { binding: env.AI }");
+        }
+        this.ai = new ai_1.Ai(fields.binding);
+        this.modelName = fields.modelName ?? this.modelName;
+        this.stripNewLines = fields.stripNewLines ?? this.stripNewLines;
+    }
+    async embedDocuments(texts) {
+        const batches = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.runEmbedding(batch));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batchResponse = batchResponses[i];
+            for (let j = 0; j < batchResponse.length; j += 1) {
+                embeddings.push(batchResponse[j]);
+            }
+        }
+        return embeddings;
+    }
+    async embedQuery(text) {
+        const data = await this.runEmbedding([
+            this.stripNewLines ? text.replace(/\n/g, " ") : text,
+        ]);
+        return data[0];
+    }
+    async runEmbedding(texts) {
+        return this.caller.call(async () => {
+            const response = await this.ai.run(this.modelName, {
+                text: texts,
+            });
+            return response.data;
+        });
+    }
+}
+exports.CloudflareWorkersAIEmbeddings = CloudflareWorkersAIEmbeddings;

package/dist/embeddings/cloudflare_workersai.d.ts

@@ -0,0 +1,28 @@
+import { Ai } from "@cloudflare/ai";
+import { Fetcher } from "@cloudflare/workers-types";
+import { Embeddings, EmbeddingsParams } from "./base.js";
+export interface CloudflareWorkersAIEmbeddingsParams extends EmbeddingsParams {
+    /** Binding */
+    binding: Fetcher;
+    /** Model name to use */
+    modelName?: string;
+    /**
+     * The maximum number of documents to embed in a single request.
+     */
+    batchSize?: number;
+    /**
+     * Whether to strip new lines from the input text. This is recommended by
+     * OpenAI, but may not be suitable for all use cases.
+     */
+    stripNewLines?: boolean;
+}
+export declare class CloudflareWorkersAIEmbeddings extends Embeddings {
+    modelName: string;
+    batchSize: number;
+    stripNewLines: boolean;
+    ai: Ai;
+    constructor(fields: CloudflareWorkersAIEmbeddingsParams);
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    embedQuery(text: string): Promise<number[]>;
+    private runEmbedding;
+}

package/dist/embeddings/cloudflare_workersai.js

@@ -0,0 +1,65 @@
+import { Ai } from "@cloudflare/ai";
+import { chunkArray } from "../util/chunk.js";
+import { Embeddings } from "./base.js";
+export class CloudflareWorkersAIEmbeddings extends Embeddings {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "@cf/baai/bge-base-en-v1.5"
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "ai", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.binding) {
+            throw new Error("Must supply a Workers AI binding, eg { binding: env.AI }");
+        }
+        this.ai = new Ai(fields.binding);
+        this.modelName = fields.modelName ?? this.modelName;
+        this.stripNewLines = fields.stripNewLines ?? this.stripNewLines;
+    }
+    async embedDocuments(texts) {
+        const batches = chunkArray(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.runEmbedding(batch));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batchResponse = batchResponses[i];
+            for (let j = 0; j < batchResponse.length; j += 1) {
+                embeddings.push(batchResponse[j]);
+            }
+        }
+        return embeddings;
+    }
+    async embedQuery(text) {
+        const data = await this.runEmbedding([
+            this.stripNewLines ? text.replace(/\n/g, " ") : text,
+        ]);
+        return data[0];
+    }
+    async runEmbedding(texts) {
+        return this.caller.call(async () => {
+            const response = await this.ai.run(this.modelName, {
+                text: texts,
+            });
+            return response.data;
+        });
+    }
+}

package/dist/experimental/autogpt/index.d.ts

@@ -1,4 +1,4 @@
-export { AutoGPTPrompt, AutoGPTPromptInput } from "./prompt.js";
+export { AutoGPTPrompt, type AutoGPTPromptInput } from "./prompt.js";
 export { AutoGPTOutputParser, preprocessJsonInput } from "./output_parser.js";
-export { AutoGPT, AutoGPTInput } from "./agent.js";
-export { AutoGPTAction } from "./schema.js";
+export { AutoGPT, type AutoGPTInput } from "./agent.js";
+export type { AutoGPTAction } from "./schema.js";

package/dist/experimental/babyagi/index.d.ts

@@ -1,4 +1,4 @@
 export { TaskCreationChain } from "./task_creation.js";
 export { TaskExecutionChain } from "./task_execution.js";
 export { TaskPrioritizationChain } from "./task_prioritization.js";
-export { BabyAGI, Task, BabyAGIInputs } from "./agent.js";
+export { BabyAGI, type Task, type BabyAGIInputs } from "./agent.js";

package/dist/experimental/plan_and_execute/index.d.ts

@@ -1,3 +1,3 @@
 export { PlanAndExecuteAgentExecutor } from "./agent_executor.js";
-export { BasePlanner, BaseStepContainer, BaseStepExecutor, StepAction, StepResult, Step, Plan, ListStepContainer, LLMPlanner, ChainStepExecutor, } from "./base.js";
+export { BasePlanner, BaseStepContainer, BaseStepExecutor, type StepAction, type StepResult, type Step, type Plan, ListStepContainer, LLMPlanner, ChainStepExecutor, } from "./base.js";
 export { PlanOutputParser } from "./outputParser.js";

package/dist/graphs/neo4j_graph.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo4jGraph = void 0;
+const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
+class Neo4jGraph {
+    constructor({ url, username, password, database = "neo4j", }) {
+        Object.defineProperty(this, "driver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "database", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        try {
+            this.driver = neo4j_driver_1.default.driver(url, neo4j_driver_1.default.auth.basic(username, password));
+            this.database = database;
+        }
+        catch (error) {
+            throw new Error("Could not create a Neo4j driver instance. Please check the connection details.");
+        }
+    }
+    static async initialize(config) {
+        const graph = new Neo4jGraph(config);
+        try {
+            await graph.verifyConnectivity();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            console.log("Failed to verify connection.");
+        }
+        try {
+            await graph.refreshSchema();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            throw new Error(`Error: ${error.message}`);
+        }
+        finally {
+            console.log("Schema refreshed successfully.");
+        }
+        return graph;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    // 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());
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async verifyConnectivity() {
+        const session = this.driver.session({ database: this.database });
+        await session.close();
+    }
+    async refreshSchema() {
+        const nodePropertiesQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE NOT type = "RELATIONSHIP" AND elementType = "node"
+      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
+      RETURN {labels: nodeLabels, properties: properties} AS output
+    `;
+        const relPropertiesQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE NOT type = "RELATIONSHIP" AND elementType = "relationship"
+      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
+      RETURN {type: nodeLabels, properties: properties} AS output
+    `;
+        const relQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE type = "RELATIONSHIP" AND elementType = "node"
+      UNWIND other AS other_node
+      RETURN "(:" + label + ")-[:" + property + "]->(:" + toString(other_node) + ")" AS output
+    `;
+        const nodeProperties = await this.query(nodePropertiesQuery);
+        const relationshipsProperties = await this.query(relPropertiesQuery);
+        const relationships = await this.query(relQuery);
+        this.schema = `
+      Node properties are the following:
+      ${nodeProperties.map((el) => el.output)}
+
+      Relationship properties are the following:
+      ${relationshipsProperties.map((el) => el.output)}
+
+      The relationships are the following:
+      ${relationships.map((el) => el.output)}
+    `;
+    }
+}
+exports.Neo4jGraph = Neo4jGraph;

package/dist/graphs/neo4j_graph.d.ts

@@ -0,0 +1,18 @@
+interface Neo4jGraphConfig {
+    url: string;
+    username: string;
+    password: string;
+    database?: string;
+}
+export declare class Neo4jGraph {
+    private driver;
+    private database;
+    private schema;
+    constructor({ url, username, password, database, }: Neo4jGraphConfig);
+    static initialize(config: Neo4jGraphConfig): Promise<Neo4jGraph>;
+    getSchema(): string;
+    query(query: string, params?: any): Promise<any[]>;
+    verifyConnectivity(): Promise<void>;
+    refreshSchema(): Promise<void>;
+}
+export {};

package/dist/graphs/neo4j_graph.js

@@ -0,0 +1,105 @@
+import neo4j from "neo4j-driver";
+export class Neo4jGraph {
+    constructor({ url, username, password, database = "neo4j", }) {
+        Object.defineProperty(this, "driver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "database", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        try {
+            this.driver = neo4j.driver(url, neo4j.auth.basic(username, password));
+            this.database = database;
+        }
+        catch (error) {
+            throw new Error("Could not create a Neo4j driver instance. Please check the connection details.");
+        }
+    }
+    static async initialize(config) {
+        const graph = new Neo4jGraph(config);
+        try {
+            await graph.verifyConnectivity();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            console.log("Failed to verify connection.");
+        }
+        try {
+            await graph.refreshSchema();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            throw new Error(`Error: ${error.message}`);
+        }
+        finally {
+            console.log("Schema refreshed successfully.");
+        }
+        return graph;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    // 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());
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async verifyConnectivity() {
+        const session = this.driver.session({ database: this.database });
+        await session.close();
+    }
+    async refreshSchema() {
+        const nodePropertiesQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE NOT type = "RELATIONSHIP" AND elementType = "node"
+      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
+      RETURN {labels: nodeLabels, properties: properties} AS output
+    `;
+        const relPropertiesQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE NOT type = "RELATIONSHIP" AND elementType = "relationship"
+      WITH label AS nodeLabels, collect({property:property, type:type}) AS properties
+      RETURN {type: nodeLabels, properties: properties} AS output
+    `;
+        const relQuery = `
+      CALL apoc.meta.data()
+      YIELD label, other, elementType, type, property
+      WHERE type = "RELATIONSHIP" AND elementType = "node"
+      UNWIND other AS other_node
+      RETURN "(:" + label + ")-[:" + property + "]->(:" + toString(other_node) + ")" AS output
+    `;
+        const nodeProperties = await this.query(nodePropertiesQuery);
+        const relationshipsProperties = await this.query(relPropertiesQuery);
+        const relationships = await this.query(relQuery);
+        this.schema = `
+      Node properties are the following:
+      ${nodeProperties.map((el) => el.output)}
+
+      Relationship properties are the following:
+      ${relationshipsProperties.map((el) => el.output)}
+
+      The relationships are the following:
+      ${relationships.map((el) => el.output)}
+    `;
+    }
+}

package/dist/llms/bedrock.cjs

@@ -1,67 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bedrock = void 0;
-const signature_v4_1 = require("@aws-sdk/signature-v4");
+const signature_v4_1 = require("@smithy/signature-v4");
 const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
-const protocol_http_1 = require("@aws-sdk/protocol-http");
+const protocol_http_1 = require("@smithy/protocol-http");
 const eventstream_codec_1 = require("@smithy/eventstream-codec");
 const util_utf8_1 = require("@smithy/util-utf8");
 const sha256_js_1 = require("@aws-crypto/sha256-js");
+const bedrock_js_1 = require("../util/bedrock.cjs");
 const env_js_1 = require("../util/env.cjs");
 const base_js_1 = require("./base.cjs");
 const index_js_1 = require("../schema/index.cjs");
-/**
- * A helper class used within the `Bedrock` class. It is responsible for
- * preparing the input and output for the Bedrock service. It formats the
- * input prompt based on the provider (e.g., "anthropic", "ai21",
- * "amazon") and extracts the generated text from the service response.
- */
-class BedrockLLMInputOutputAdapter {
-    /** Adapter class to prepare the inputs from Langchain to a format
-    that LLM model expects. Also, provides a helper function to extract
-    the generated text from the model response. */
-    static prepareInput(provider, prompt, maxTokens = 50, temperature = 0) {
-        const inputBody = {};
-        if (provider === "anthropic") {
-            inputBody.prompt = prompt;
-            inputBody.max_tokens_to_sample = maxTokens;
-            inputBody.temperature = temperature;
-        }
-        else if (provider === "ai21") {
-            inputBody.prompt = prompt;
-            inputBody.maxTokens = maxTokens;
-            inputBody.temperature = temperature;
-        }
-        else if (provider === "amazon") {
-            inputBody.inputText = prompt;
-            inputBody.textGenerationConfig = {
-                maxTokenCount: maxTokens,
-                temperature,
-            };
-        }
-        return inputBody;
-    }
-    /**
-     * Extracts the generated text from the service response.
-     * @param provider The provider name.
-     * @param responseBody The response body from the service.
-     * @returns The generated text.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static prepareOutput(provider, responseBody) {
-        if (provider === "anthropic") {
-            return responseBody.completion;
-        }
-        else if (provider === "ai21") {
-            return responseBody.data.text;
-        }
-        return responseBody.outputText;
-    }
-}
 /**
  * A type of Large Language Model (LLM) that interacts with the Bedrock
  * service. It extends the base `LLM` class and implements the
- * `BedrockInput` interface. The class is designed to authenticate and
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
  * interact with the Bedrock service, which is a part of Amazon Web
  * Services (AWS). It uses AWS credentials for authentication and can be
  * configured with various parameters such as the model to use, the AWS
@@ -74,6 +27,9 @@ class Bedrock extends base_js_1.LLM {
     _llmType() {
         return "bedrock";
     }
+    static lc_name() {
+        return "Bedrock";
+    }
     constructor(fields) {
         super(fields ?? {});
         Object.defineProperty(this, "model", {
@@ -112,7 +68,19 @@ class Bedrock extends base_js_1.LLM {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpointUrl", {
+        Object.defineProperty(this, "endpointHost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelKwargs", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -138,7 +106,9 @@ class Bedrock extends base_js_1.LLM {
         this.temperature = fields?.temperature ?? this.temperature;
         this.maxTokens = fields?.maxTokens ?? this.maxTokens;
         this.fetchFn = fields?.fetchFn ?? fetch;
-        this.endpointUrl = fields?.endpointUrl;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
     }
     /** Call out to Bedrock service model.
       Arguments:
@@ -159,10 +129,11 @@ class Bedrock extends base_js_1.LLM {
     }
     async *_streamResponseChunks(prompt, options, runManager) {
         const provider = this.model.split(".")[0];
-        const service = "bedrock";
-        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature);
-        const endpointUrl = this.endpointUrl ?? `${service}.${this.region}.amazonaws.com`;
-        const url = new URL(`https://${endpointUrl}/model/${this.model}/invoke-with-response-stream`);
+        const service = "bedrock-runtime";
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
         const request = new protocol_http_1.HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -174,12 +145,12 @@ class Bedrock extends base_js_1.LLM {
                 // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
                 host: url.host,
                 accept: "application/json",
-                "Content-Type": "application/json",
+                "content-type": "application/json",
             },
         });
         const signer = new signature_v4_1.SignatureV4({
             credentials: this.credentials,
-            service,
+            service: "bedrock",
             region: this.region,
             sha256: sha256_js_1.Sha256,
         });
@@ -193,15 +164,34 @@ class Bedrock extends base_js_1.LLM {
         if (response.status < 200 || response.status >= 300) {
             throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
-        const reader = response.body?.getReader();
-        for await (const chunk of this._readChunks(reader)) {
-            const event = this.codec.decode(chunk);
-            if (event.headers[":event-type"].value !== "chunk" ||
-                event.headers[":content-type"].value !== "application/json") {
-                throw Error(`Failed to get event chunk: got ${chunk}`);
+        if (provider === "anthropic") {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            for await (const chunk of this._readChunks(reader)) {
+                const event = this.codec.decode(chunk);
+                if ((event.headers[":event-type"] !== undefined &&
+                    event.headers[":event-type"].value !== "chunk") ||
+                    event.headers[":content-type"].value !== "application/json") {
+                    throw Error(`Failed to get event chunk: got ${chunk}`);
+                }
+                const body = JSON.parse(decoder.decode(event.body));
+                if (body.message) {
+                    throw new Error(body.message);
+                }
+                if (body.bytes !== undefined) {
+                    const chunkResult = JSON.parse(Buffer.from(body.bytes, "base64").toString());
+                    const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, chunkResult);
+                    yield new index_js_1.GenerationChunk({
+                        text,
+                        generationInfo: {},
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
             }
-            const body = JSON.parse(Buffer.from(JSON.parse(new TextDecoder("utf-8").decode(event.body)).bytes, "base64").toString());
-            const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, body);
+        }
+        else {
+            const json = await response.json();
+            const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
             yield new index_js_1.GenerationChunk({
                 text,
                 generationInfo: {},