langchain 0.0.189 → 0.0.190

package/dist/schema/runnable/passthrough.cjs

@@ -32,7 +32,30 @@ class RunnableAssign extends base_js_1.Runnable {
 }
 exports.RunnableAssign = RunnableAssign;
 /**
- * A runnable that passes through the input.
+ * A runnable to passthrough inputs unchanged or with additional keys.
+ *
+ * This runnable behaves almost like the identity function, except that it
+ * can be configured to add additional keys to the output, if the input is
+ * an object.
+ *
+ * The example below demonstrates how to use `RunnablePassthrough to
+ * passthrough the input from the `.invoke()`
+ *
+ * @example
+ * ```typescript
+ * const chain = RunnableSequence.from([
+ *   {
+ *     question: new RunnablePassthrough(),
+ *     context: async () => loadContextFromStore(),
+ *   },
+ *   prompt,
+ *   llm,
+ *   outputParser,
+ * ]);
+ * const response = await chain.invoke(
+ *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
+ * );
+ * ```
  */
 class RunnablePassthrough extends base_js_1.Runnable {
     constructor() {
@@ -56,6 +79,34 @@ class RunnablePassthrough extends base_js_1.Runnable {
     async invoke(input, options) {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
+    /**
+     * A runnable that assigns key-value pairs to the input.
+     *
+     * The example below shows how you could use it with an inline function.
+     *
+     * @example
+     * ```typescript
+     * const prompt =
+     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
+     * Question: {question}
+     * SQL Query:`);
+     *
+     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
+     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
+     * // In this case, we're passing the schema.
+     * const sqlQueryGeneratorChain = RunnableSequence.from([
+     *   RunnablePassthrough.assign({
+     *     schema: async () => db.getTableInfo(),
+     *   }),
+     *   prompt,
+     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new StringOutputParser(),
+     * ]);
+     * const result = await sqlQueryGeneratorChain.invoke({
+     *   question: "How many employees are there?",
+     * });
+     * ```
+     */
     static assign(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     mapping) {

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

@@ -10,12 +10,63 @@ export declare class RunnableAssign<RunInput extends Record<string, any> = any,
     invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
 }
 /**
- * A runnable that passes through the input.
+ * A runnable to passthrough inputs unchanged or with additional keys.
+ *
+ * This runnable behaves almost like the identity function, except that it
+ * can be configured to add additional keys to the output, if the input is
+ * an object.
+ *
+ * The example below demonstrates how to use `RunnablePassthrough to
+ * passthrough the input from the `.invoke()`
+ *
+ * @example
+ * ```typescript
+ * const chain = RunnableSequence.from([
+ *   {
+ *     question: new RunnablePassthrough(),
+ *     context: async () => loadContextFromStore(),
+ *   },
+ *   prompt,
+ *   llm,
+ *   outputParser,
+ * ]);
+ * const response = await chain.invoke(
+ *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
+ * );
+ * ```
  */
 export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+    /**
+     * A runnable that assigns key-value pairs to the input.
+     *
+     * The example below shows how you could use it with an inline function.
+     *
+     * @example
+     * ```typescript
+     * const prompt =
+     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
+     * Question: {question}
+     * SQL Query:`);
+     *
+     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
+     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
+     * // In this case, we're passing the schema.
+     * const sqlQueryGeneratorChain = RunnableSequence.from([
+     *   RunnablePassthrough.assign({
+     *     schema: async () => db.getTableInfo(),
+     *   }),
+     *   prompt,
+     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new StringOutputParser(),
+     * ]);
+     * const result = await sqlQueryGeneratorChain.invoke({
+     *   question: "How many employees are there?",
+     * });
+     * ```
+     */
     static assign(mapping: Record<string, RunnableLike<Record<string, unknown>, any>>): RunnableAssign<Record<string, unknown>, Record<string, unknown>>;
 }

package/dist/schema/runnable/passthrough.js

@@ -28,7 +28,30 @@ export class RunnableAssign extends Runnable {
     }
 }
 /**
- * A runnable that passes through the input.
+ * A runnable to passthrough inputs unchanged or with additional keys.
+ *
+ * This runnable behaves almost like the identity function, except that it
+ * can be configured to add additional keys to the output, if the input is
+ * an object.
+ *
+ * The example below demonstrates how to use `RunnablePassthrough to
+ * passthrough the input from the `.invoke()`
+ *
+ * @example
+ * ```typescript
+ * const chain = RunnableSequence.from([
+ *   {
+ *     question: new RunnablePassthrough(),
+ *     context: async () => loadContextFromStore(),
+ *   },
+ *   prompt,
+ *   llm,
+ *   outputParser,
+ * ]);
+ * const response = await chain.invoke(
+ *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
+ * );
+ * ```
  */
 export class RunnablePassthrough extends Runnable {
     constructor() {
@@ -52,6 +75,34 @@ export class RunnablePassthrough extends Runnable {
     async invoke(input, options) {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
+    /**
+     * A runnable that assigns key-value pairs to the input.
+     *
+     * The example below shows how you could use it with an inline function.
+     *
+     * @example
+     * ```typescript
+     * const prompt =
+     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
+     * Question: {question}
+     * SQL Query:`);
+     *
+     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
+     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
+     * // In this case, we're passing the schema.
+     * const sqlQueryGeneratorChain = RunnableSequence.from([
+     *   RunnablePassthrough.assign({
+     *     schema: async () => db.getTableInfo(),
+     *   }),
+     *   prompt,
+     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
+     *   new StringOutputParser(),
+     * ]);
+     * const result = await sqlQueryGeneratorChain.invoke({
+     *   question: "How many employees are there?",
+     * });
+     * ```
+     */
     static assign(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     mapping) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.189",
+  "version": "0.0.190",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {