langchain 0.0.154 → 0.0.156

package/dist/callbacks/handlers/tracer.js

@@ -21,7 +21,7 @@ export class BaseTracer extends BaseCallbackHandler {
     _addChildRun(parentRun, childRun) {
         parentRun.child_runs.push(childRun);
     }
-    _startTrace(run) {
+    async _startTrace(run) {
         if (run.parent_run_id !== undefined) {
             const parentRun = this.runMap.get(run.parent_run_id);
             if (parentRun) {
@@ -30,6 +30,7 @@ export class BaseTracer extends BaseCallbackHandler {
             }
         }
         this.runMap.set(run.id, run);
+        await this.onRunCreate?.(run);
     }
     async _endTrace(run) {
         const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
@@ -40,6 +41,7 @@ export class BaseTracer extends BaseCallbackHandler {
             await this.persistRun(run);
         }
         this.runMap.delete(run.id);
+        await this.onRunUpdate?.(run);
     }
     _getExecutionOrder(parentRunId) {
         const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
@@ -49,7 +51,7 @@ export class BaseTracer extends BaseCallbackHandler {
         }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -57,7 +59,7 @@ export class BaseTracer extends BaseCallbackHandler {
             : extraParams;
         const run = {
             id: runId,
-            name: llm.id[llm.id.length - 1],
+            name: name ?? llm.id[llm.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: llm,
@@ -75,10 +77,11 @@ export class BaseTracer extends BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onLLMStart?.(run);
+        return run;
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -86,7 +89,7 @@ export class BaseTracer extends BaseCallbackHandler {
             : extraParams;
         const run = {
             id: runId,
-            name: llm.id[llm.id.length - 1],
+            name: name ?? llm.id[llm.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: llm,
@@ -104,8 +107,9 @@ export class BaseTracer extends BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onLLMStart?.(run);
+        return run;
     }
     async handleLLMEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -120,6 +124,7 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onLLMEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleLLMError(error, runId) {
         const run = this.runMap.get(runId);
@@ -134,13 +139,14 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onLLMError?.(run);
         await this._endTrace(run);
+        return run;
     }
-    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType) {
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: chain.id[chain.id.length - 1],
+            name: name ?? chain.id[chain.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: chain,
@@ -158,8 +164,9 @@ export class BaseTracer extends BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onChainStart?.(run);
+        return run;
     }
     async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
@@ -177,6 +184,7 @@ export class BaseTracer extends BaseCallbackHandler {
         }
         await this.onChainEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
         const run = this.runMap.get(runId);
@@ -194,13 +202,14 @@ export class BaseTracer extends BaseCallbackHandler {
         }
         await this.onChainError?.(run);
         await this._endTrace(run);
+        return run;
     }
-    async handleToolStart(tool, input, runId, parentRunId, tags, metadata) {
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: tool.id[tool.id.length - 1],
+            name: name ?? tool.id[tool.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: tool,
@@ -218,8 +227,9 @@ export class BaseTracer extends BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onToolStart?.(run);
+        return run;
     }
     async handleToolEnd(output, runId) {
         const run = this.runMap.get(runId);
@@ -234,6 +244,7 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onToolEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleToolError(error, runId) {
         const run = this.runMap.get(runId);
@@ -248,6 +259,7 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onToolError?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleAgentAction(action, runId) {
         const run = this.runMap.get(runId);
@@ -276,12 +288,12 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onAgentEnd?.(run);
     }
-    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata) {
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
             id: runId,
-            name: retriever.id[retriever.id.length - 1],
+            name: name ?? retriever.id[retriever.id.length - 1],
             parent_run_id: parentRunId,
             start_time,
             serialized: retriever,
@@ -299,8 +311,9 @@ export class BaseTracer extends BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        this._startTrace(run);
+        await this._startTrace(run);
         await this.onRetrieverStart?.(run);
+        return run;
     }
     async handleRetrieverEnd(documents, runId) {
         const run = this.runMap.get(runId);
@@ -315,6 +328,7 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onRetrieverEnd?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleRetrieverError(error, runId) {
         const run = this.runMap.get(runId);
@@ -329,6 +343,7 @@ export class BaseTracer extends BaseCallbackHandler {
         });
         await this.onRetrieverError?.(run);
         await this._endTrace(run);
+        return run;
     }
     async handleText(text, runId) {
         const run = this.runMap.get(runId);
@@ -345,13 +360,14 @@ export class BaseTracer extends BaseCallbackHandler {
     async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
-            return;
+            throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
         }
         run.events.push({
             name: "new_token",
             time: new Date().toISOString(),
             kwargs: { token, idx, chunk: fields?.chunk },
         });
-        await this.onLLMNewToken?.(run);
+        await this.onLLMNewToken?.(run, token);
+        return run;
     }
 }

package/dist/chat_models/bedrock.cjs

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatBedrock = exports.convertMessagesToPrompt = exports.convertMessagesToPromptAnthropic = void 0;
+const signature_v4_1 = require("@smithy/signature-v4");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+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");
+function convertOneMessageToText(message, humanPrompt, aiPrompt) {
+    if (message._getType() === "human") {
+        return `${humanPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "ai") {
+        return `${aiPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "system") {
+        return `${humanPrompt} <admin>${message.content}</admin>`;
+    }
+    else if (index_js_1.ChatMessage.isInstance(message)) {
+        return `\n\n${message.role[0].toUpperCase() + message.role.slice(1)}: {message.content}`;
+    }
+    throw new Error(`Unknown role: ${message._getType()}`);
+}
+function convertMessagesToPromptAnthropic(messages, humanPrompt = "\n\nHuman:", aiPrompt = "\n\nAssistant:") {
+    const messagesCopy = [...messages];
+    if (messagesCopy.length === 0 ||
+        messagesCopy[messagesCopy.length - 1]._getType() !== "ai") {
+        messagesCopy.push(new index_js_1.AIMessage({ content: "" }));
+    }
+    return messagesCopy
+        .map((message) => convertOneMessageToText(message, humanPrompt, aiPrompt))
+        .join("");
+}
+exports.convertMessagesToPromptAnthropic = convertMessagesToPromptAnthropic;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+function convertMessagesToPrompt(messages, provider) {
+    if (provider === "anthropic") {
+        return convertMessagesToPromptAnthropic(messages);
+    }
+    throw new Error(`Provider ${provider} does not support chat.`);
+}
+exports.convertMessagesToPrompt = convertMessagesToPrompt;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `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
+ * region, and the maximum number of tokens to generate.
+ */
+class ChatBedrock extends base_js_1.SimpleChatModel {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    static lc_name() {
+        return "ChatBedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8)
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? (0, env_js_1.getEnvironmentVariable)("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? (0, credential_provider_node_1.defaultProvider)();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(messages, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), 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,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // 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",
+            },
+        });
+        const signer = new signature_v4_1.SignatureV4({
+            credentials: this.credentials,
+            service: "bedrock",
+            region: this.region,
+            sha256: sha256_js_1.Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        }));
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        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}`);
+                }
+                // console.log(decoder.decode(event.body));
+                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.ChatGenerationChunk({
+                        text,
+                        message: new index_js_1.AIMessageChunk({ content: text }),
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
+            }
+        }
+        else {
+            const json = await response.json();
+            const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+            yield new index_js_1.ChatGenerationChunk({
+                text,
+                message: new index_js_1.AIMessageChunk({ content: text }),
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+}
+exports.ChatBedrock = ChatBedrock;

package/dist/chat_models/bedrock.d.ts

@@ -0,0 +1,58 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { BaseBedrockInput, type CredentialType } from "../util/bedrock.js";
+import { SimpleChatModel, BaseChatModelParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { BaseMessage, ChatGenerationChunk } from "../schema/index.js";
+export declare function convertMessagesToPromptAnthropic(messages: BaseMessage[], humanPrompt?: string, aiPrompt?: string): string;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+export declare function convertMessagesToPrompt(messages: BaseMessage[], provider: string): string;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `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
+ * region, and the maximum number of tokens to generate.
+ */
+export declare class ChatBedrock extends SimpleChatModel implements BaseBedrockInput {
+    model: string;
+    region: string;
+    credentials: CredentialType;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    fetchFn: typeof fetch;
+    endpointHost?: string;
+    stopSequences?: string[];
+    modelKwargs?: Record<string, unknown>;
+    codec: EventStreamCodec;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    _llmType(): string;
+    static lc_name(): string;
+    constructor(fields?: Partial<BaseBedrockInput> & BaseChatModelParams);
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _readChunks(reader: any): {
+        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    };
+    _combineLLMOutput(): {};
+}