@langchain/core 0.1.4 → 0.1.6

package/dist/prompts/chat.cjs

@@ -60,12 +60,27 @@ class MessagesPlaceholder extends BaseMessagePromptTemplate {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "optional", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.variableName = fields.variableName;
+        this.optional = fields.optional ?? false;
     }
     get inputVariables() {
         return [this.variableName];
     }
     validateInputOrThrow(input, variableName) {
+        if (this.optional && !input) {
+            return false;
+        }
+        else if (!input) {
+            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
+            error.name = "InputFormatError";
+            throw error;
+        }
         let isInputBaseMessage = false;
         if (Array.isArray(input)) {
             isInputBaseMessage = input.every((message) => (0, index_js_1.isBaseMessage)(message));
@@ -83,7 +98,7 @@ class MessagesPlaceholder extends BaseMessagePromptTemplate {
     }
     async formatMessages(values) {
         this.validateInputOrThrow(values[this.variableName], this.variableName);
-        return values[this.variableName];
+        return values[this.variableName] ?? [];
     }
 }
 exports.MessagesPlaceholder = MessagesPlaceholder;
@@ -255,6 +270,10 @@ function _coerceMessagePromptTemplateLike(messagePromptTemplateLike) {
         throw new Error(`Could not coerce message prompt template from input. Received message type: "${message._getType()}".`);
     }
 }
+function isMessagesPlaceholder(x) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return x.constructor.lc_name() === "MessagesPlaceholder";
+}
 /**
  * Class that represents a chat prompt. It extends the
  * BaseChatPromptTemplate and uses an array of BaseMessagePromptTemplate
@@ -357,7 +376,8 @@ class ChatPromptTemplate extends BaseChatPromptTemplate {
             }
             else {
                 const inputValues = promptMessage.inputVariables.reduce((acc, inputVariable) => {
-                    if (!(inputVariable in allValues)) {
+                    if (!(inputVariable in allValues) &&
+                        !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
                         throw new Error(`Missing value for input variable \`${inputVariable.toString()}\``);
                     }
                     acc[inputVariable] = allValues[inputVariable];

package/dist/prompts/chat.d.ts

@@ -35,18 +35,20 @@ export declare abstract class BaseMessagePromptTemplate<RunInput extends InputVa
  */
 export interface MessagesPlaceholderFields<T extends string> {
     variableName: T;
+    optional?: boolean;
 }
 /**
  * Class that represents a placeholder for messages in a chat prompt. It
  * extends the BaseMessagePromptTemplate.
  */
-export declare class MessagesPlaceholder<RunInput extends InputValues = any> extends BaseMessagePromptTemplate<RunInput> {
+export declare class MessagesPlaceholder<RunInput extends InputValues = any> extends BaseMessagePromptTemplate<RunInput> implements MessagesPlaceholderFields<Extract<keyof RunInput, string>> {
     static lc_name(): string;
     variableName: Extract<keyof RunInput, string>;
+    optional: boolean;
     constructor(variableName: Extract<keyof RunInput, string>);
     constructor(fields: MessagesPlaceholderFields<Extract<keyof RunInput, string>>);
     get inputVariables(): Extract<keyof RunInput, string>[];
-    validateInputOrThrow(input: Array<unknown>, variableName: Extract<keyof RunInput, string>): input is BaseMessage[];
+    validateInputOrThrow(input: Array<unknown> | undefined, variableName: Extract<keyof RunInput, string>): input is BaseMessage[];
     formatMessages(values: TypedPromptInputValues<RunInput>): Promise<BaseMessage[]>;
 }
 /**

package/dist/prompts/chat.js

@@ -56,12 +56,27 @@ export class MessagesPlaceholder extends BaseMessagePromptTemplate {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "optional", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.variableName = fields.variableName;
+        this.optional = fields.optional ?? false;
     }
     get inputVariables() {
         return [this.variableName];
     }
     validateInputOrThrow(input, variableName) {
+        if (this.optional && !input) {
+            return false;
+        }
+        else if (!input) {
+            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
+            error.name = "InputFormatError";
+            throw error;
+        }
         let isInputBaseMessage = false;
         if (Array.isArray(input)) {
             isInputBaseMessage = input.every((message) => isBaseMessage(message));
@@ -79,7 +94,7 @@ export class MessagesPlaceholder extends BaseMessagePromptTemplate {
     }
     async formatMessages(values) {
         this.validateInputOrThrow(values[this.variableName], this.variableName);
-        return values[this.variableName];
+        return values[this.variableName] ?? [];
     }
 }
 /**
@@ -244,6 +259,10 @@ function _coerceMessagePromptTemplateLike(messagePromptTemplateLike) {
         throw new Error(`Could not coerce message prompt template from input. Received message type: "${message._getType()}".`);
     }
 }
+function isMessagesPlaceholder(x) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return x.constructor.lc_name() === "MessagesPlaceholder";
+}
 /**
  * Class that represents a chat prompt. It extends the
  * BaseChatPromptTemplate and uses an array of BaseMessagePromptTemplate
@@ -346,7 +365,8 @@ export class ChatPromptTemplate extends BaseChatPromptTemplate {
             }
             else {
                 const inputValues = promptMessage.inputVariables.reduce((acc, inputVariable) => {
-                    if (!(inputVariable in allValues)) {
+                    if (!(inputVariable in allValues) &&
+                        !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
                         throw new Error(`Missing value for input variable \`${inputVariable.toString()}\``);
                     }
                     acc[inputVariable] = allValues[inputVariable];

package/dist/runnables/base.cjs

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 const p_retry_1 = __importDefault(require("p-retry"));
 const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
@@ -31,6 +31,18 @@ class Runnable extends serializable_js_1.Serializable {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    getName(suffix) {
+        const name = 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.name ?? this.constructor.lc_name() ?? this.constructor.name;
+        return suffix ? `${name}${suffix}` : name;
     }
     /**
      * Bind arguments to a Runnable, returning a new Runnable.
@@ -145,17 +157,19 @@ class Runnable extends serializable_js_1.Serializable {
             tags: options.tags,
             metadata: options.metadata,
             runName: options.runName,
+            configurable: options.configurable,
         };
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
         delete callOptions.runName;
+        delete callOptions.configurable;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
         let output;
         try {
             output = await func.bind(this)(input, options, runManager);
@@ -178,8 +192,8 @@ class Runnable extends serializable_js_1.Serializable {
      */
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(optionsList.map(config_js_1.getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName)));
+        const callbackManagers = await Promise.all(optionsList.map(config_js_1.getCallbackManagerForConfig));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
         let outputs;
         try {
             outputs = await func(inputs, optionsList, runManagers, batchOptions);
@@ -201,16 +215,10 @@ class Runnable extends serializable_js_1.Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
-        let runManager;
-        const serializedRepresentation = this.toJSON();
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const inputGeneratorWithSetup = new stream_js_1.AsyncGeneratorWithSetup(inputGenerator, async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()));
         async function* wrapInputForTracing() {
-            for await (const chunk of inputGenerator) {
-                if (!runManager) {
-                    // Start the run manager AFTER the iterator starts to preserve
-                    // tracing order
-                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName);
-                }
+            for await (const chunk of inputGeneratorWithSetup) {
                 if (finalInputSupported) {
                     if (finalInput === undefined) {
                         finalInput = chunk;
@@ -218,7 +226,7 @@ class Runnable extends serializable_js_1.Serializable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalInput = finalInput.concat(chunk);
+                            finalInput = (0, stream_js_1.concat)(finalInput, chunk);
                         }
                         catch {
                             finalInput = undefined;
@@ -229,9 +237,8 @@ class Runnable extends serializable_js_1.Serializable {
                 yield chunk;
             }
         }
-        const wrappedInputGenerator = wrapInputForTracing();
         try {
-            const outputIterator = transformer(wrappedInputGenerator, runManager, options);
+            const outputIterator = transformer(wrapInputForTracing(), inputGeneratorWithSetup.setup, options);
             for await (const chunk of outputIterator) {
                 yield chunk;
                 if (finalOutputSupported) {
@@ -241,7 +248,7 @@ class Runnable extends serializable_js_1.Serializable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
+                            finalOutput = (0, stream_js_1.concat)(finalOutput, chunk);
                         }
                         catch {
                             finalOutput = undefined;
@@ -252,14 +259,16 @@ class Runnable extends serializable_js_1.Serializable {
             }
         }
         catch (e) {
+            const runManager = await inputGeneratorWithSetup.setup;
             await runManager?.handleChainError(e, undefined, undefined, undefined, {
                 inputs: _coerceToDict(finalInput, "input"),
             });
             throw e;
         }
+        const runManager = await inputGeneratorWithSetup.setup;
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
-    _patchConfig(config = {}, callbackManager = undefined) {
+    _patchConfig(config = {}, callbackManager = undefined, recursionLimit = undefined) {
         const newConfig = { ...config };
         if (callbackManager !== undefined) {
             /**
@@ -269,6 +278,9 @@ class Runnable extends serializable_js_1.Serializable {
             delete newConfig.runName;
             return { ...newConfig, callbacks: callbackManager };
         }
+        if (recursionLimit !== undefined) {
+            newConfig.recursionLimit = recursionLimit;
+        }
         return newConfig;
     }
     /**
@@ -284,6 +296,23 @@ class Runnable extends serializable_js_1.Serializable {
             last: _coerceToRunnable(coerceable),
         });
     }
+    /**
+     * Pick keys from the dict output of this runnable. Returns a new runnable.
+     */
+    pick(keys) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return this.pipe(new RunnablePick(keys));
+    }
+    /**
+     * Assigns new fields to the dict output of this runnable. Returns a new runnable.
+     */
+    assign(mapping) {
+        return this.pipe(
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        new RunnableAssign(
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        new RunnableMap({ steps: mapping })));
+    }
     /**
      * Default implementation of transform, which buffers input and then calls stream.
      * Subclasses should override this method if they can start producing output while
@@ -301,7 +330,7 @@ class Runnable extends serializable_js_1.Serializable {
                 // Make a best effort to gather, for any type that supports concat.
                 // This method should throw an error if gathering fails.
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                finalChunk = finalChunk.concat(chunk);
+                finalChunk = (0, stream_js_1.concat)(finalChunk, chunk);
             }
         }
         yield* this._streamIterator(finalChunk, options);
@@ -451,6 +480,9 @@ class RunnableBinding extends Runnable {
         this.config = fields.config;
         this.configFactories = fields.configFactories;
     }
+    getName(suffix) {
+        return this.bound.getName(suffix);
+    }
     async _mergeConfig(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options) {
@@ -460,21 +492,24 @@ class RunnableBinding extends Runnable {
             : []));
     }
     bind(kwargs) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
             config: this.config,
         });
     }
     withConfig(config) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound,
             kwargs: this.kwargs,
             config: { ...this.config, ...config },
         });
     }
     withRetry(fields) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound.withRetry(fields),
             kwargs: this.kwargs,
             config: this.config,
@@ -776,12 +811,13 @@ class RunnableSequence extends Runnable {
         this.first = fields.first;
         this.middle = fields.middle ?? this.middle;
         this.last = fields.last;
+        this.name = fields.name;
     }
     get steps() {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         let finalOutput;
@@ -803,7 +839,7 @@ class RunnableSequence extends Runnable {
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map(config_js_1.getCallbackMangerForConfig));
+        const callbackManagers = await Promise.all(configList.map(config_js_1.getCallbackManagerForConfig));
         const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
@@ -824,7 +860,7 @@ class RunnableSequence extends Runnable {
         return finalOutputs;
     }
     async *_streamIterator(input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         const steps = [this.first, ...this.middle, this.last];
         let concatSupported = true;
@@ -847,7 +883,7 @@ class RunnableSequence extends Runnable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
+                            finalOutput = (0, stream_js_1.concat)(finalOutput, chunk);
                         }
                         catch (e) {
                             finalOutput = undefined;
@@ -873,6 +909,7 @@ class RunnableSequence extends Runnable {
                     ...coerceable.middle,
                 ]),
                 last: coerceable.last,
+                name: this.name ?? coerceable.name,
             });
         }
         else {
@@ -880,6 +917,7 @@ class RunnableSequence extends Runnable {
                 first: this.first,
                 middle: [...this.middle, this.last],
                 last: _coerceToRunnable(coerceable),
+                name: this.name,
             });
         }
     }
@@ -888,11 +926,12 @@ class RunnableSequence extends Runnable {
         return Array.isArray(thing.middle) && Runnable.isRunnable(thing);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static from([first, ...runnables]) {
+    static from([first, ...runnables], name) {
         return new RunnableSequence({
             first: _coerceToRunnable(first),
             middle: runnables.slice(0, -1).map(_coerceToRunnable),
             last: _coerceToRunnable(runnables[runnables.length - 1]),
+            name,
         });
     }
 }
@@ -949,7 +988,7 @@ class RunnableMap extends Runnable {
         return new RunnableMap({ steps });
     }
     async invoke(input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
         }, undefined, undefined, undefined, undefined, options?.runName);
@@ -957,7 +996,7 @@ class RunnableMap extends Runnable {
         const output = {};
         try {
             await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
-                output[key] = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild(key)));
+                output[key] = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild(`map:key:${key}`)));
             }));
         }
         catch (e) {
@@ -967,6 +1006,38 @@ class RunnableMap extends Runnable {
         await runManager?.handleChainEnd(output);
         return output;
     }
+    async *_transform(generator, runManagerPromise, options) {
+        // shallow copy steps to ignore changes while iterating
+        const steps = { ...this.steps };
+        // each step gets a copy of the input iterator
+        const inputCopies = (0, stream_js_1.atee)(generator, Object.keys(steps).length);
+        const runManager = await runManagerPromise;
+        // start the first iteration of each output iterator
+        const tasks = new Map(Object.entries(steps).map(([key, runnable], i) => {
+            const gen = runnable.transform(inputCopies[i], this._patchConfig(options, runManager?.getChild(`map:key:${key}`)));
+            return [key, gen.next().then((result) => ({ key, gen, result }))];
+        }));
+        // yield chunks as they become available,
+        // starting new iterations as needed,
+        // until all iterators are done
+        while (tasks.size) {
+            const { key, result, gen } = await Promise.race(tasks.values());
+            tasks.delete(key);
+            if (!result.done) {
+                yield { [key]: result.value };
+                tasks.set(key, gen.next().then((result) => ({ key, gen, result })));
+            }
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
 }
 exports.RunnableMap = RunnableMap;
 /**
@@ -1000,13 +1071,57 @@ class RunnableLambda extends Runnable {
     async _invoke(input, config, runManager) {
         let output = await this.func(input, { config });
         if (output && Runnable.isRunnable(output)) {
-            output = await output.invoke(input, this._patchConfig(config, runManager?.getChild()));
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
+            }
+            output = await output.invoke(input, this._patchConfig(config, runManager?.getChild(), (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1));
         }
         return output;
     }
     async invoke(input, options) {
         return this._callWithConfig(this._invoke, input, options);
     }
+    async *_transform(generator, runManagerPromise, config) {
+        let finalChunk;
+        for await (const chunk of generator) {
+            if (finalChunk === undefined) {
+                finalChunk = chunk;
+            }
+            else {
+                // Make a best effort to gather, for any type that supports concat.
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    finalChunk = (0, stream_js_1.concat)(finalChunk, chunk);
+                }
+                catch (e) {
+                    finalChunk = chunk;
+                }
+            }
+        }
+        const output = await this.func(finalChunk, { config });
+        if (output && Runnable.isRunnable(output)) {
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
+            }
+            const runManager = await runManagerPromise;
+            const stream = await output.stream(finalChunk, this._patchConfig(config, runManager?.getChild(), (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1));
+            for await (const chunk of stream) {
+                yield chunk;
+            }
+        }
+        else {
+            yield output;
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
 }
 exports.RunnableLambda = RunnableLambda;
 class RunnableParallel extends RunnableMap {
@@ -1127,3 +1242,147 @@ function _coerceToRunnable(coerceable) {
     }
 }
 exports._coerceToRunnable = _coerceToRunnable;
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+class RunnableAssign extends Runnable {
+    static lc_name() {
+        return "RunnableAssign";
+    }
+    constructor(fields) {
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (fields instanceof RunnableMap) {
+            // eslint-disable-next-line no-param-reassign
+            fields = { mapper: fields };
+        }
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mapper = fields.mapper;
+    }
+    async invoke(input, options) {
+        const mapperResult = await this.mapper.invoke(input, options);
+        return {
+            ...input,
+            ...mapperResult,
+        };
+    }
+    async *_transform(generator, runManagerPromise, options) {
+        // collect mapper keys
+        const mapperKeys = this.mapper.getStepsKeys();
+        // create two input gens, one for the mapper, one for the input
+        const [forPassthrough, forMapper] = (0, stream_js_1.atee)(generator);
+        const runManager = await runManagerPromise;
+        // create mapper output gen
+        const mapperOutput = this.mapper.transform(forMapper, this._patchConfig(options, runManager?.getChild()));
+        // start the mapper
+        const firstMapperChunkPromise = mapperOutput.next();
+        // yield the passthrough
+        for await (const chunk of forPassthrough) {
+            if (typeof chunk !== "object" || Array.isArray(chunk)) {
+                throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof chunk}`);
+            }
+            const filtered = Object.fromEntries(Object.entries(chunk).filter(([key]) => !mapperKeys.includes(key)));
+            if (Object.keys(filtered).length > 0) {
+                yield filtered;
+            }
+        }
+        // yield the mapper output
+        yield (await firstMapperChunkPromise).value;
+        for await (const chunk of mapperOutput) {
+            yield chunk;
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
+}
+exports.RunnableAssign = RunnableAssign;
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+class RunnablePick extends Runnable {
+    static lc_name() {
+        return "RunnablePick";
+    }
+    constructor(fields) {
+        if (typeof fields === "string" || Array.isArray(fields)) {
+            // eslint-disable-next-line no-param-reassign
+            fields = { keys: fields };
+        }
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "keys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keys = fields.keys;
+    }
+    async _pick(input) {
+        if (typeof this.keys === "string") {
+            return input[this.keys];
+        }
+        else {
+            const picked = this.keys
+                .map((key) => [key, input[key]])
+                .filter((v) => v[1] !== undefined);
+            return picked.length === 0 ? undefined : Object.fromEntries(picked);
+        }
+    }
+    async invoke(input, options) {
+        return this._callWithConfig(this._pick.bind(this), input, options);
+    }
+    async *_transform(generator) {
+        for await (const chunk of generator) {
+            const picked = await this._pick(chunk);
+            if (picked !== undefined) {
+                yield picked;
+            }
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
+}
+exports.RunnablePick = RunnablePick;