langchain 0.0.152 → 0.0.154

package/dist/schema/index.js

@@ -386,6 +386,54 @@ export class ChatGenerationChunk extends GenerationChunk {
         });
     }
 }
+/**
+ * Maps messages from an older format (V1) to the current `StoredMessage`
+ * format. If the message is already in the `StoredMessage` format, it is
+ * returned as is. Otherwise, it transforms the V1 message into a
+ * `StoredMessage`. This function is important for maintaining
+ * compatibility with older message formats.
+ */
+function mapV1MessageToStoredMessage(message) {
+    // TODO: Remove this mapper when we deprecate the old message format.
+    if (message.data !== undefined) {
+        return message;
+    }
+    else {
+        const v1Message = message;
+        return {
+            type: v1Message.type,
+            data: {
+                content: v1Message.text,
+                role: v1Message.role,
+                name: undefined,
+            },
+        };
+    }
+}
+export function mapStoredMessageToChatMessage(message) {
+    const storedMessage = mapV1MessageToStoredMessage(message);
+    switch (storedMessage.type) {
+        case "human":
+            return new HumanMessage(storedMessage.data);
+        case "ai":
+            return new AIMessage(storedMessage.data);
+        case "system":
+            return new SystemMessage(storedMessage.data);
+        case "function":
+            if (storedMessage.data.name === undefined) {
+                throw new Error("Name must be defined for function messages");
+            }
+            return new FunctionMessage(storedMessage.data);
+        case "chat": {
+            if (storedMessage.data.role === undefined) {
+                throw new Error("Role must be defined for chat messages");
+            }
+            return new ChatMessage(storedMessage.data);
+        }
+        default:
+            throw new Error(`Got unexpected type: ${storedMessage.type}`);
+    }
+}
 /**
  * Base PromptValue class. All prompt values should extend this class.
  */

package/dist/schema/output_parser.cjs

@@ -162,20 +162,52 @@ class BytesOutputParser extends BaseTransformOutputParser {
 }
 exports.BytesOutputParser = BytesOutputParser;
 /**
- * Custom error class used to handle exceptions related to output parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
+ * Exception that output parsers should raise to signify a parsing error.
+ *
+ * This exists to differentiate parsing errors from other code or execution errors
+ * that also may arise inside the output parser. OutputParserExceptions will be
+ * available to catch and handle in ways to fix the parsing error, while other
+ * errors will be raised.
+ *
+ * @param message - The error that's being re-raised or an error message.
+ * @param llmOutput - String model output which is error-ing.
+ * @param observation - String explanation of error which can be passed to a
+ *     model to try and remediate the issue.
+ * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
+ *     after an OutputParserException has been raised. This gives the underlying
+ *     model driving the agent the context that the previous output was improperly
+ *     structured, in the hopes that it will update the output to the correct
+ *     format.
  */
 class OutputParserException extends Error {
-    constructor(message, output) {
+    constructor(message, llmOutput, observation, sendToLLM = false) {
         super(message);
-        Object.defineProperty(this, "output", {
+        Object.defineProperty(this, "llmOutput", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.output = output;
+        Object.defineProperty(this, "observation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sendToLLM", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.llmOutput = llmOutput;
+        this.observation = observation;
+        this.sendToLLM = sendToLLM;
+        if (sendToLLM) {
+            if (observation === undefined || llmOutput === undefined) {
+                throw new Error("Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true");
+            }
+        }
     }
 }
 exports.OutputParserException = OutputParserException;

package/dist/schema/output_parser.d.ts

@@ -118,11 +118,26 @@ export declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Ar
     getFormatInstructions(): string;
 }
 /**
- * Custom error class used to handle exceptions related to output parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
+ * Exception that output parsers should raise to signify a parsing error.
+ *
+ * This exists to differentiate parsing errors from other code or execution errors
+ * that also may arise inside the output parser. OutputParserExceptions will be
+ * available to catch and handle in ways to fix the parsing error, while other
+ * errors will be raised.
+ *
+ * @param message - The error that's being re-raised or an error message.
+ * @param llmOutput - String model output which is error-ing.
+ * @param observation - String explanation of error which can be passed to a
+ *     model to try and remediate the issue.
+ * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
+ *     after an OutputParserException has been raised. This gives the underlying
+ *     model driving the agent the context that the previous output was improperly
+ *     structured, in the hopes that it will update the output to the correct
+ *     format.
  */
 export declare class OutputParserException extends Error {
-    output?: string;
-    constructor(message: string, output?: string);
+    llmOutput?: string;
+    observation?: string;
+    sendToLLM: boolean;
+    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
 }

package/dist/schema/output_parser.js

@@ -154,19 +154,51 @@ export class BytesOutputParser extends BaseTransformOutputParser {
     }
 }
 /**
- * Custom error class used to handle exceptions related to output parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
+ * Exception that output parsers should raise to signify a parsing error.
+ *
+ * This exists to differentiate parsing errors from other code or execution errors
+ * that also may arise inside the output parser. OutputParserExceptions will be
+ * available to catch and handle in ways to fix the parsing error, while other
+ * errors will be raised.
+ *
+ * @param message - The error that's being re-raised or an error message.
+ * @param llmOutput - String model output which is error-ing.
+ * @param observation - String explanation of error which can be passed to a
+ *     model to try and remediate the issue.
+ * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
+ *     after an OutputParserException has been raised. This gives the underlying
+ *     model driving the agent the context that the previous output was improperly
+ *     structured, in the hopes that it will update the output to the correct
+ *     format.
  */
 export class OutputParserException extends Error {
-    constructor(message, output) {
+    constructor(message, llmOutput, observation, sendToLLM = false) {
         super(message);
-        Object.defineProperty(this, "output", {
+        Object.defineProperty(this, "llmOutput", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.output = output;
+        Object.defineProperty(this, "observation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sendToLLM", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.llmOutput = llmOutput;
+        this.observation = observation;
+        this.sendToLLM = sendToLLM;
+        if (sendToLLM) {
+            if (observation === undefined || llmOutput === undefined) {
+                throw new Error("Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true");
+            }
+        }
     }
 }

package/dist/schema/runnable/base.cjs

@@ -37,7 +37,7 @@ class Runnable extends serializable_js_1.Serializable {
      */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableBinding({ bound: this, kwargs });
+        return new RunnableBinding({ bound: this, kwargs, config: {} });
     }
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
@@ -48,19 +48,33 @@ class Runnable extends serializable_js_1.Serializable {
         return new RunnableEach({ bound: this });
     }
     /**
-     * Bind arguments to a Runnable, returning a new Runnable.
+     * Add retry logic to an existing runnable.
      * @param kwargs
-     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableRetry({
             bound: this,
             kwargs: {},
+            config: {},
             maxAttemptNumber: fields?.stopAfterAttempt,
             ...fields,
         });
     }
+    /**
+     * Bind config to a Runnable, returning a new Runnable.
+     * @param config New configuration parameters to attach to the new runnable.
+     * @returns A new RunnableBinding with a config matching what's passed.
+     */
+    withConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableBinding({
+            bound: this,
+            config,
+            kwargs: {},
+        });
+    }
     /**
      * Create a new runnable from the current one that will try invoking
      * other passed fallback runnables if the initial invocation fails.
@@ -312,6 +326,12 @@ class RunnableBinding extends Runnable {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "kwargs", {
             enumerable: true,
             configurable: true,
@@ -320,35 +340,70 @@ class RunnableBinding extends Runnable {
         });
         this.bound = fields.bound;
         this.kwargs = fields.kwargs;
+        this.config = fields.config;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _mergeConfig(options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const copy = { ...this.config };
+        if (options) {
+            for (const key of Object.keys(options)) {
+                if (key === "metadata") {
+                    copy[key] = { ...copy[key], ...options[key] };
+                }
+                else if (key === "tags") {
+                    copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
+                }
+                else {
+                    copy[key] = options[key] ?? copy[key];
+                }
+            }
+        }
+        return copy;
     }
     bind(kwargs) {
-        return new RunnableBinding({
+        return this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
+            config: this.config,
+        });
+    }
+    withConfig(config) {
+        return this.constructor({
+            bound: this.bound,
+            kwargs: this.kwargs,
+            config: { ...this.config, ...config },
+        });
+    }
+    withRetry(fields) {
+        return this.constructor({
+            bound: this.bound.withRetry(fields),
+            kwargs: this.kwargs,
+            config: this.config,
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, { ...options, ...this.kwargs });
+        return this.bound.invoke(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? options.map((individualOption) => ({
+            ? options.map((individualOption) => this._mergeConfig({
                 ...individualOption,
                 ...this.kwargs,
             }))
-            : { ...options, ...this.kwargs };
+            : this._mergeConfig({ ...options, ...this.kwargs });
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, { ...options, ...this.kwargs });
+        yield* this.bound._streamIterator(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async stream(input, options) {
-        return this.bound.stream(input, { ...options, ...this.kwargs });
+        return this.bound.stream(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, options);
+        yield* this.bound.transform(generator, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/schema/runnable/base.d.ts

@@ -33,14 +33,20 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     map(): Runnable<RunInput[], RunOutput[], CallOptions>;
     /**
-     * Bind arguments to a Runnable, returning a new Runnable.
+     * Add retry logic to an existing runnable.
      * @param kwargs
-     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields?: {
         stopAfterAttempt?: number;
         onFailedAttempt?: RunnableRetryFailedAttemptHandler;
     }): RunnableRetry<RunInput, RunOutput, CallOptions>;
+    /**
+     * Bind config to a Runnable, returning a new Runnable.
+     * @param config New configuration parameters to attach to the new runnable.
+     * @returns A new RunnableBinding with a config matching what's passed.
+     */
+    withConfig(config: RunnableConfig): RunnableBinding<RunInput, RunOutput, CallOptions>;
     /**
      * Create a new runnable from the current one that will try invoking
      * other passed fallback runnables if the initial invocation fails.
@@ -122,18 +128,26 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
 export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig> = {
     bound: Runnable<RunInput, RunOutput, CallOptions>;
     kwargs: Partial<CallOptions>;
+    config: RunnableConfig;
 };
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
  */
-export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends BaseCallbackConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
+export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;
     bound: Runnable<RunInput, RunOutput, CallOptions>;
+    config: RunnableConfig;
     protected kwargs: Partial<CallOptions>;
     constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
+    _mergeConfig(options?: Record<string, any>): Partial<CallOptions>;
     bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
+    withConfig(config: RunnableConfig): RunnableBinding<RunInput, RunOutput, CallOptions>;
+    withRetry(fields?: {
+        stopAfterAttempt?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    }): RunnableRetry<RunInput, RunOutput, CallOptions>;
     invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
         returnExceptions?: false;

package/dist/schema/runnable/base.js

@@ -31,7 +31,7 @@ export class Runnable extends Serializable {
      */
     bind(kwargs) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableBinding({ bound: this, kwargs });
+        return new RunnableBinding({ bound: this, kwargs, config: {} });
     }
     /**
      * Return a new Runnable that maps a list of inputs to a list of outputs,
@@ -42,19 +42,33 @@ export class Runnable extends Serializable {
         return new RunnableEach({ bound: this });
     }
     /**
-     * Bind arguments to a Runnable, returning a new Runnable.
+     * Add retry logic to an existing runnable.
      * @param kwargs
-     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
      */
     withRetry(fields) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableRetry({
             bound: this,
             kwargs: {},
+            config: {},
             maxAttemptNumber: fields?.stopAfterAttempt,
             ...fields,
         });
     }
+    /**
+     * Bind config to a Runnable, returning a new Runnable.
+     * @param config New configuration parameters to attach to the new runnable.
+     * @returns A new RunnableBinding with a config matching what's passed.
+     */
+    withConfig(config) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableBinding({
+            bound: this,
+            config,
+            kwargs: {},
+        });
+    }
     /**
      * Create a new runnable from the current one that will try invoking
      * other passed fallback runnables if the initial invocation fails.
@@ -305,6 +319,12 @@ export class RunnableBinding extends Runnable {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "kwargs", {
             enumerable: true,
             configurable: true,
@@ -313,35 +333,70 @@ export class RunnableBinding extends Runnable {
         });
         this.bound = fields.bound;
         this.kwargs = fields.kwargs;
+        this.config = fields.config;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _mergeConfig(options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const copy = { ...this.config };
+        if (options) {
+            for (const key of Object.keys(options)) {
+                if (key === "metadata") {
+                    copy[key] = { ...copy[key], ...options[key] };
+                }
+                else if (key === "tags") {
+                    copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
+                }
+                else {
+                    copy[key] = options[key] ?? copy[key];
+                }
+            }
+        }
+        return copy;
     }
     bind(kwargs) {
-        return new RunnableBinding({
+        return this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
+            config: this.config,
+        });
+    }
+    withConfig(config) {
+        return this.constructor({
+            bound: this.bound,
+            kwargs: this.kwargs,
+            config: { ...this.config, ...config },
+        });
+    }
+    withRetry(fields) {
+        return this.constructor({
+            bound: this.bound.withRetry(fields),
+            kwargs: this.kwargs,
+            config: this.config,
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, { ...options, ...this.kwargs });
+        return this.bound.invoke(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? options.map((individualOption) => ({
+            ? options.map((individualOption) => this._mergeConfig({
                 ...individualOption,
                 ...this.kwargs,
             }))
-            : { ...options, ...this.kwargs };
+            : this._mergeConfig({ ...options, ...this.kwargs });
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, { ...options, ...this.kwargs });
+        yield* this.bound._streamIterator(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async stream(input, options) {
-        return this.bound.stream(input, { ...options, ...this.kwargs });
+        return this.bound.stream(input, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, options);
+        yield* this.bound.transform(generator, this._mergeConfig({ ...options, ...this.kwargs }));
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/stores/message/utils.cjs

@@ -1,32 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapChatMessagesToStoredMessages = exports.mapStoredMessagesToChatMessages = exports.mapV1MessageToStoredMessage = void 0;
+exports.mapChatMessagesToStoredMessages = exports.mapStoredMessagesToChatMessages = void 0;
 const index_js_1 = require("../../schema/index.cjs");
-/**
- * Maps messages from an older format (V1) to the current `StoredMessage`
- * format. If the message is already in the `StoredMessage` format, it is
- * returned as is. Otherwise, it transforms the V1 message into a
- * `StoredMessage`. This function is important for maintaining
- * compatibility with older message formats.
- */
-function mapV1MessageToStoredMessage(message) {
-    // TODO: Remove this mapper when we deprecate the old message format.
-    if (message.data !== undefined) {
-        return message;
-    }
-    else {
-        const v1Message = message;
-        return {
-            type: v1Message.type,
-            data: {
-                content: v1Message.text,
-                role: v1Message.role,
-                name: undefined,
-            },
-        };
-    }
-}
-exports.mapV1MessageToStoredMessage = mapV1MessageToStoredMessage;
 /**
  * Transforms an array of `StoredMessage` instances into an array of
  * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
@@ -36,30 +11,7 @@ exports.mapV1MessageToStoredMessage = mapV1MessageToStoredMessage;
  * messages for use in a chat context.
  */
 function mapStoredMessagesToChatMessages(messages) {
-    return messages.map((message) => {
-        const storedMessage = mapV1MessageToStoredMessage(message);
-        switch (storedMessage.type) {
-            case "human":
-                return new index_js_1.HumanMessage(storedMessage.data);
-            case "ai":
-                return new index_js_1.AIMessage(storedMessage.data);
-            case "system":
-                return new index_js_1.SystemMessage(storedMessage.data);
-            case "function":
-                if (storedMessage.data.name === undefined) {
-                    throw new Error("Name must be defined for function messages");
-                }
-                return new index_js_1.FunctionMessage(storedMessage.data);
-            case "chat": {
-                if (storedMessage.data.role === undefined) {
-                    throw new Error("Role must be defined for chat messages");
-                }
-                return new index_js_1.ChatMessage(storedMessage.data);
-            }
-            default:
-                throw new Error(`Got unexpected type: ${storedMessage.type}`);
-        }
-    });
+    return messages.map(index_js_1.mapStoredMessageToChatMessage);
 }
 exports.mapStoredMessagesToChatMessages = mapStoredMessagesToChatMessages;
 /**

package/dist/stores/message/utils.d.ts

@@ -1,17 +1,4 @@
 import { BaseMessage, StoredMessage } from "../../schema/index.js";
-interface StoredMessageV1 {
-    type: string;
-    role: string | undefined;
-    text: string;
-}
-/**
- * Maps messages from an older format (V1) to the current `StoredMessage`
- * format. If the message is already in the `StoredMessage` format, it is
- * returned as is. Otherwise, it transforms the V1 message into a
- * `StoredMessage`. This function is important for maintaining
- * compatibility with older message formats.
- */
-export declare function mapV1MessageToStoredMessage(message: StoredMessage | StoredMessageV1): StoredMessage;
 /**
  * Transforms an array of `StoredMessage` instances into an array of
  * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
@@ -28,4 +15,3 @@ export declare function mapStoredMessagesToChatMessages(messages: StoredMessage[
  * is used to prepare chat messages for storage.
  */
 export declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
-export {};