@langchain/core 0.3.14 → 0.3.16

package/dist/language_models/chat_models.cjs

@@ -132,9 +132,13 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         }
     }
     getLsParams(options) {
+        const providerName = this.getName().startsWith("Chat")
+            ? this.getName().replace("Chat", "")
+            : this.getName();
         return {
             ls_model_type: "chat",
             ls_stop: options.stop,
+            ls_provider: providerName,
         };
     }
     /** @ignore */

package/dist/language_models/chat_models.js

@@ -128,9 +128,13 @@ export class BaseChatModel extends BaseLanguageModel {
         }
     }
     getLsParams(options) {
+        const providerName = this.getName().startsWith("Chat")
+            ? this.getName().replace("Chat", "")
+            : this.getName();
         return {
             ls_model_type: "chat",
             ls_stop: options.stop,
+            ls_provider: providerName,
         };
     }
     /** @ignore */

package/dist/runnables/base.cjs

@@ -746,6 +746,43 @@ class Runnable extends serializable_js_1.Serializable {
 exports.Runnable = Runnable;
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
+ * @example
+ * ```typescript
+ * import {
+ *   type RunnableConfig,
+ *   RunnableLambda,
+ * } from "@langchain/core/runnables";
+ *
+ * const enhanceProfile = (
+ *   profile: Record<string, any>,
+ *   config?: RunnableConfig
+ * ) => {
+ *   if (config?.configurable?.role) {
+ *     return { ...profile, role: config.configurable.role };
+ *   }
+ *   return profile;
+ * };
+ *
+ * const runnable = RunnableLambda.from(enhanceProfile);
+ *
+ * // Bind configuration to the runnable to set the user's role dynamically
+ * const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
+ * const userRunnable = runnable.bind({ configurable: { role: "User" } });
+ *
+ * const result1 = await adminRunnable.invoke({
+ *   name: "Alice",
+ *   email: "alice@example.com"
+ * });
+ *
+ * // { name: "Alice", email: "alice@example.com", role: "Admin" }
+ *
+ * const result2 = await userRunnable.invoke({
+ *   name: "Bob",
+ *   email: "bob@example.com"
+ * });
+ *
+ * // { name: "Bob", email: "bob@example.com", role: "User" }
+ * ```
  */
 class RunnableBinding extends Runnable {
     static lc_name() {
@@ -898,6 +935,24 @@ exports.RunnableBinding = RunnableBinding;
 /**
  * A runnable that delegates calls to another runnable
  * with each element of the input sequence.
+ * @example
+ * ```typescript
+ * import { RunnableEach, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const toUpperCase = (input: string): string => input.toUpperCase();
+ * const addGreeting = (input: string): string => `Hello, ${input}!`;
+ *
+ * const upperCaseLambda = RunnableLambda.from(toUpperCase);
+ * const greetingLambda = RunnableLambda.from(addGreeting);
+ *
+ * const chain = new RunnableEach({
+ *   bound: upperCaseLambda.pipe(greetingLambda),
+ * });
+ *
+ * const result = await chain.invoke(["alice", "bob", "carol"])
+ *
+ * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
+ * ```
  */
 class RunnableEach extends Runnable {
     static lc_name() {
@@ -974,6 +1029,45 @@ exports.RunnableEach = RunnableEach;
 /**
  * Base class for runnables that can be retried a
  * specified number of times.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableRetry,
+ * } from "@langchain/core/runnables";
+ *
+ * // Simulate an API call that fails
+ * const simulateApiCall = (input: string): string => {
+ *   console.log(`Attempting API call with input: ${input}`);
+ *   throw new Error("API call failed due to network issue");
+ * };
+ *
+ * const apiCallLambda = RunnableLambda.from(simulateApiCall);
+ *
+ * // Apply retry logic using the .withRetry() method
+ * const apiCallWithRetry = apiCallLambda.withRetry({ stopAfterAttempt: 3 });
+ *
+ * // Alternatively, create a RunnableRetry instance manually
+ * const manualRetry = new RunnableRetry({
+ *   bound: apiCallLambda,
+ *   maxAttemptNumber: 3,
+ *   config: {},
+ * });
+ *
+ * // Example invocation using the .withRetry() method
+ * const res = await apiCallWithRetry
+ *   .invoke("Request 1")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ *
+ * // Example invocation using the manual retry instance
+ * const res2 = await manualRetry
+ *   .invoke("Request 2")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ * ```
  */
 class RunnableRetry extends RunnableBinding {
     static lc_name() {
@@ -1502,7 +1596,30 @@ function assertNonTraceableFunction(func) {
     }
 }
 /**
- * A runnable that runs a callable.
+ * A runnable that wraps an arbitrary function that takes a single argument.
+ * @example
+ * ```typescript
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const add = (input: { x: number; y: number }) => input.x + input.y;
+ *
+ * const multiply = (input: { value: number; multiplier: number }) =>
+ *   input.value * input.multiplier;
+ *
+ * // Create runnables for the functions
+ * const addLambda = RunnableLambda.from(add);
+ * const multiplyLambda = RunnableLambda.from(multiply);
+ *
+ * // Chain the lambdas for a mathematical operation
+ * const chainedLambda = addLambda.pipe((result) =>
+ *   multiplyLambda.invoke({ value: result, multiplier: 2 })
+ * );
+ *
+ * // Example invocation of the chainedLambda
+ * const result = await chainedLambda.invoke({ x: 2, y: 3 });
+ *
+ * // Will log "10" (since (2 + 3) * 2 = 10)
+ * ```
  */
 class RunnableLambda extends Runnable {
     static lc_name() {
@@ -1682,6 +1799,39 @@ class RunnableLambda extends Runnable {
     }
 }
 exports.RunnableLambda = RunnableLambda;
+/**
+ * A runnable that runs a mapping of runnables in parallel,
+ * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const addYears = (age: number): number => age + 5;
+ * const yearsToFifty = (age: number): number => 50 - age;
+ * const yearsToHundred = (age: number): number => 100 - age;
+ *
+ * const addYearsLambda = RunnableLambda.from(addYears);
+ * const milestoneFiftyLambda = RunnableLambda.from(yearsToFifty);
+ * const milestoneHundredLambda = RunnableLambda.from(yearsToHundred);
+ *
+ * // Pipe will coerce objects into RunnableParallel by default, but we
+ * // explicitly instantiate one here to demonstrate
+ * const sequence = addYearsLambda.pipe(
+ *   RunnableParallel.from({
+ *     years_to_fifty: milestoneFiftyLambda,
+ *     years_to_hundred: milestoneHundredLambda,
+ *   })
+ * );
+ *
+ * // Invoke the sequence with a single age input
+ * const res = sequence.invoke(25);
+ *
+ * // { years_to_fifty: 25, years_to_hundred: 75 }
+ * ```
+ */
 class RunnableParallel extends RunnableMap {
 }
 exports.RunnableParallel = RunnableParallel;
@@ -1703,6 +1853,55 @@ exports.RunnableParallel = RunnableParallel;
  * When streaming, fallbacks will only be called on failures during the initial
  * stream creation. Errors that occur after a stream starts will not fallback
  * to the next Runnable.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableWithFallbacks,
+ * } from "@langchain/core/runnables";
+ *
+ * const primaryOperation = (input: string): string => {
+ *   if (input !== "safe") {
+ *     throw new Error("Primary operation failed due to unsafe input");
+ *   }
+ *   return `Processed: ${input}`;
+ * };
+ *
+ * // Define a fallback operation that processes the input differently
+ * const fallbackOperation = (input: string): string =>
+ *   `Fallback processed: ${input}`;
+ *
+ * const primaryRunnable = RunnableLambda.from(primaryOperation);
+ * const fallbackRunnable = RunnableLambda.from(fallbackOperation);
+ *
+ * // Apply the fallback logic using the .withFallbacks() method
+ * const runnableWithFallback = primaryRunnable.withFallbacks([fallbackRunnable]);
+ *
+ * // Alternatively, create a RunnableWithFallbacks instance manually
+ * const manualFallbackChain = new RunnableWithFallbacks({
+ *   runnable: primaryRunnable,
+ *   fallbacks: [fallbackRunnable],
+ * });
+ *
+ * // Example invocation using .withFallbacks()
+ * const res = await runnableWithFallback
+ *   .invoke("unsafe input")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Fallback processed: unsafe input"
+ *
+ * // Example invocation using manual instantiation
+ * const res = await manualFallbackChain
+ *   .invoke("safe")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Processed: safe"
+ * ```
  */
 class RunnableWithFallbacks extends Runnable {
     static lc_name() {
@@ -1873,6 +2072,34 @@ function _coerceToRunnable(coerceable) {
 exports._coerceToRunnable = _coerceToRunnable;
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableAssign,
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const calculateAge = (x: { birthYear: number }): { age: number } => {
+ *   const currentYear = new Date().getFullYear();
+ *   return { age: currentYear - x.birthYear };
+ * };
+ *
+ * const createGreeting = (x: { name: string }): { greeting: string } => {
+ *   return { greeting: `Hello, ${x.name}!` };
+ * };
+ *
+ * const mapper = RunnableParallel.from({
+ *   age_step: RunnableLambda.from(calculateAge),
+ *   greeting_step: RunnableLambda.from(createGreeting),
+ * });
+ *
+ * const runnableAssign = new RunnableAssign({ mapper });
+ *
+ * const res = await runnableAssign.invoke({ name: "Alice", birthYear: 1990 });
+ *
+ * // { name: "Alice", birthYear: 1990, age_step: { age: 34 }, greeting_step: { greeting: "Hello, Alice!" } }
+ * ```
  */
 class RunnableAssign extends Runnable {
     static lc_name() {
@@ -1956,6 +2183,27 @@ class RunnableAssign extends Runnable {
 exports.RunnableAssign = RunnableAssign;
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * Useful for streaming, can be automatically created and chained by calling `runnable.pick();`.
+ * @example
+ * ```typescript
+ * import { RunnablePick } from "@langchain/core/runnables";
+ *
+ * const inputData = {
+ *   name: "John",
+ *   age: 30,
+ *   city: "New York",
+ *   country: "USA",
+ *   email: "john.doe@example.com",
+ *   phone: "+1234567890",
+ * };
+ *
+ * const basicInfoRunnable = new RunnablePick(["name", "city"]);
+ *
+ * // Example invocation
+ * const res = await basicInfoRunnable.invoke(inputData);
+ *
+ * // { name: 'John', city: 'New York' }
+ * ```
  */
 class RunnablePick extends Runnable {
     static lc_name() {

package/dist/runnables/base.d.ts

@@ -317,6 +317,43 @@ export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends Runnabl
 };
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
+ * @example
+ * ```typescript
+ * import {
+ *   type RunnableConfig,
+ *   RunnableLambda,
+ * } from "@langchain/core/runnables";
+ *
+ * const enhanceProfile = (
+ *   profile: Record<string, any>,
+ *   config?: RunnableConfig
+ * ) => {
+ *   if (config?.configurable?.role) {
+ *     return { ...profile, role: config.configurable.role };
+ *   }
+ *   return profile;
+ * };
+ *
+ * const runnable = RunnableLambda.from(enhanceProfile);
+ *
+ * // Bind configuration to the runnable to set the user's role dynamically
+ * const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
+ * const userRunnable = runnable.bind({ configurable: { role: "User" } });
+ *
+ * const result1 = await adminRunnable.invoke({
+ *   name: "Alice",
+ *   email: "alice@example.com"
+ * });
+ *
+ * // { name: "Alice", email: "alice@example.com", role: "Admin" }
+ *
+ * const result2 = await userRunnable.invoke({
+ *   name: "Bob",
+ *   email: "bob@example.com"
+ * });
+ *
+ * // { name: "Bob", email: "bob@example.com", role: "User" }
+ * ```
  */
 export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
     static lc_name(): string;
@@ -374,6 +411,24 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
 /**
  * A runnable that delegates calls to another runnable
  * with each element of the input sequence.
+ * @example
+ * ```typescript
+ * import { RunnableEach, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const toUpperCase = (input: string): string => input.toUpperCase();
+ * const addGreeting = (input: string): string => `Hello, ${input}!`;
+ *
+ * const upperCaseLambda = RunnableLambda.from(toUpperCase);
+ * const greetingLambda = RunnableLambda.from(addGreeting);
+ *
+ * const chain = new RunnableEach({
+ *   bound: upperCaseLambda.pipe(greetingLambda),
+ * });
+ *
+ * const result = await chain.invoke(["alice", "bob", "carol"])
+ *
+ * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
+ * ```
  */
 export declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions extends RunnableConfig> extends Runnable<RunInputItem[], RunOutputItem[], CallOptions> {
     static lc_name(): string;
@@ -423,6 +478,45 @@ export declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions exten
 /**
  * Base class for runnables that can be retried a
  * specified number of times.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableRetry,
+ * } from "@langchain/core/runnables";
+ *
+ * // Simulate an API call that fails
+ * const simulateApiCall = (input: string): string => {
+ *   console.log(`Attempting API call with input: ${input}`);
+ *   throw new Error("API call failed due to network issue");
+ * };
+ *
+ * const apiCallLambda = RunnableLambda.from(simulateApiCall);
+ *
+ * // Apply retry logic using the .withRetry() method
+ * const apiCallWithRetry = apiCallLambda.withRetry({ stopAfterAttempt: 3 });
+ *
+ * // Alternatively, create a RunnableRetry instance manually
+ * const manualRetry = new RunnableRetry({
+ *   bound: apiCallLambda,
+ *   maxAttemptNumber: 3,
+ *   config: {},
+ * });
+ *
+ * // Example invocation using the .withRetry() method
+ * const res = await apiCallWithRetry
+ *   .invoke("Request 1")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ *
+ * // Example invocation using the manual retry instance
+ * const res2 = await manualRetry
+ *   .invoke("Request 2")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ * ```
  */
 export declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends RunnableBinding<RunInput, RunOutput, CallOptions> {
     static lc_name(): string;
@@ -548,7 +642,30 @@ export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<Run
     static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
 }
 /**
- * A runnable that runs a callable.
+ * A runnable that wraps an arbitrary function that takes a single argument.
+ * @example
+ * ```typescript
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const add = (input: { x: number; y: number }) => input.x + input.y;
+ *
+ * const multiply = (input: { value: number; multiplier: number }) =>
+ *   input.value * input.multiplier;
+ *
+ * // Create runnables for the functions
+ * const addLambda = RunnableLambda.from(add);
+ * const multiplyLambda = RunnableLambda.from(multiply);
+ *
+ * // Chain the lambdas for a mathematical operation
+ * const chainedLambda = addLambda.pipe((result) =>
+ *   multiplyLambda.invoke({ value: result, multiplier: 2 })
+ * );
+ *
+ * // Example invocation of the chainedLambda
+ * const result = await chainedLambda.invoke({ x: 2, y: 3 });
+ *
+ * // Will log "10" (since (2 + 3) * 2 = 10)
+ * ```
  */
 export declare class RunnableLambda<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
     static lc_name(): string;
@@ -565,6 +682,39 @@ export declare class RunnableLambda<RunInput, RunOutput, CallOptions extends Run
     transform(generator: AsyncGenerator<RunInput>, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
 }
+/**
+ * A runnable that runs a mapping of runnables in parallel,
+ * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const addYears = (age: number): number => age + 5;
+ * const yearsToFifty = (age: number): number => 50 - age;
+ * const yearsToHundred = (age: number): number => 100 - age;
+ *
+ * const addYearsLambda = RunnableLambda.from(addYears);
+ * const milestoneFiftyLambda = RunnableLambda.from(yearsToFifty);
+ * const milestoneHundredLambda = RunnableLambda.from(yearsToHundred);
+ *
+ * // Pipe will coerce objects into RunnableParallel by default, but we
+ * // explicitly instantiate one here to demonstrate
+ * const sequence = addYearsLambda.pipe(
+ *   RunnableParallel.from({
+ *     years_to_fifty: milestoneFiftyLambda,
+ *     years_to_hundred: milestoneHundredLambda,
+ *   })
+ * );
+ *
+ * // Invoke the sequence with a single age input
+ * const res = sequence.invoke(25);
+ *
+ * // { years_to_fifty: 25, years_to_hundred: 75 }
+ * ```
+ */
 export declare class RunnableParallel<RunInput> extends RunnableMap<RunInput> {
 }
 /**
@@ -585,6 +735,55 @@ export declare class RunnableParallel<RunInput> extends RunnableMap<RunInput> {
  * When streaming, fallbacks will only be called on failures during the initial
  * stream creation. Errors that occur after a stream starts will not fallback
  * to the next Runnable.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableWithFallbacks,
+ * } from "@langchain/core/runnables";
+ *
+ * const primaryOperation = (input: string): string => {
+ *   if (input !== "safe") {
+ *     throw new Error("Primary operation failed due to unsafe input");
+ *   }
+ *   return `Processed: ${input}`;
+ * };
+ *
+ * // Define a fallback operation that processes the input differently
+ * const fallbackOperation = (input: string): string =>
+ *   `Fallback processed: ${input}`;
+ *
+ * const primaryRunnable = RunnableLambda.from(primaryOperation);
+ * const fallbackRunnable = RunnableLambda.from(fallbackOperation);
+ *
+ * // Apply the fallback logic using the .withFallbacks() method
+ * const runnableWithFallback = primaryRunnable.withFallbacks([fallbackRunnable]);
+ *
+ * // Alternatively, create a RunnableWithFallbacks instance manually
+ * const manualFallbackChain = new RunnableWithFallbacks({
+ *   runnable: primaryRunnable,
+ *   fallbacks: [fallbackRunnable],
+ * });
+ *
+ * // Example invocation using .withFallbacks()
+ * const res = await runnableWithFallback
+ *   .invoke("unsafe input")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Fallback processed: unsafe input"
+ *
+ * // Example invocation using manual instantiation
+ * const res = await manualFallbackChain
+ *   .invoke("safe")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Processed: safe"
+ * ```
  */
 export declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
     static lc_name(): string;
@@ -613,6 +812,34 @@ export interface RunnableAssignFields<RunInput> {
 }
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableAssign,
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const calculateAge = (x: { birthYear: number }): { age: number } => {
+ *   const currentYear = new Date().getFullYear();
+ *   return { age: currentYear - x.birthYear };
+ * };
+ *
+ * const createGreeting = (x: { name: string }): { greeting: string } => {
+ *   return { greeting: `Hello, ${x.name}!` };
+ * };
+ *
+ * const mapper = RunnableParallel.from({
+ *   age_step: RunnableLambda.from(calculateAge),
+ *   greeting_step: RunnableLambda.from(createGreeting),
+ * });
+ *
+ * const runnableAssign = new RunnableAssign({ mapper });
+ *
+ * const res = await runnableAssign.invoke({ name: "Alice", birthYear: 1990 });
+ *
+ * // { name: "Alice", birthYear: 1990, age_step: { age: 34 }, greeting_step: { greeting: "Hello, Alice!" } }
+ * ```
  */
 export declare class RunnableAssign<RunInput extends Record<string, any> = Record<string, any>, RunOutput extends Record<string, any> = Record<string, any>, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnableAssignFields<RunInput> {
     static lc_name(): string;
@@ -630,6 +857,27 @@ export interface RunnablePickFields {
 }
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * Useful for streaming, can be automatically created and chained by calling `runnable.pick();`.
+ * @example
+ * ```typescript
+ * import { RunnablePick } from "@langchain/core/runnables";
+ *
+ * const inputData = {
+ *   name: "John",
+ *   age: 30,
+ *   city: "New York",
+ *   country: "USA",
+ *   email: "john.doe@example.com",
+ *   phone: "+1234567890",
+ * };
+ *
+ * const basicInfoRunnable = new RunnablePick(["name", "city"]);
+ *
+ * // Example invocation
+ * const res = await basicInfoRunnable.invoke(inputData);
+ *
+ * // { name: 'John', city: 'New York' }
+ * ```
  */
 export declare class RunnablePick<RunInput extends Record<string, any> = Record<string, any>, RunOutput extends Record<string, any> | any = Record<string, any> | any, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnablePickFields {
     static lc_name(): string;

package/dist/runnables/base.js

@@ -738,6 +738,43 @@ export class Runnable extends Serializable {
 }
 /**
  * A runnable that delegates calls to another runnable with a set of kwargs.
+ * @example
+ * ```typescript
+ * import {
+ *   type RunnableConfig,
+ *   RunnableLambda,
+ * } from "@langchain/core/runnables";
+ *
+ * const enhanceProfile = (
+ *   profile: Record<string, any>,
+ *   config?: RunnableConfig
+ * ) => {
+ *   if (config?.configurable?.role) {
+ *     return { ...profile, role: config.configurable.role };
+ *   }
+ *   return profile;
+ * };
+ *
+ * const runnable = RunnableLambda.from(enhanceProfile);
+ *
+ * // Bind configuration to the runnable to set the user's role dynamically
+ * const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
+ * const userRunnable = runnable.bind({ configurable: { role: "User" } });
+ *
+ * const result1 = await adminRunnable.invoke({
+ *   name: "Alice",
+ *   email: "alice@example.com"
+ * });
+ *
+ * // { name: "Alice", email: "alice@example.com", role: "Admin" }
+ *
+ * const result2 = await userRunnable.invoke({
+ *   name: "Bob",
+ *   email: "bob@example.com"
+ * });
+ *
+ * // { name: "Bob", email: "bob@example.com", role: "User" }
+ * ```
  */
 export class RunnableBinding extends Runnable {
     static lc_name() {
@@ -889,6 +926,24 @@ export class RunnableBinding extends Runnable {
 /**
  * A runnable that delegates calls to another runnable
  * with each element of the input sequence.
+ * @example
+ * ```typescript
+ * import { RunnableEach, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const toUpperCase = (input: string): string => input.toUpperCase();
+ * const addGreeting = (input: string): string => `Hello, ${input}!`;
+ *
+ * const upperCaseLambda = RunnableLambda.from(toUpperCase);
+ * const greetingLambda = RunnableLambda.from(addGreeting);
+ *
+ * const chain = new RunnableEach({
+ *   bound: upperCaseLambda.pipe(greetingLambda),
+ * });
+ *
+ * const result = await chain.invoke(["alice", "bob", "carol"])
+ *
+ * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
+ * ```
  */
 export class RunnableEach extends Runnable {
     static lc_name() {
@@ -964,6 +1019,45 @@ export class RunnableEach extends Runnable {
 /**
  * Base class for runnables that can be retried a
  * specified number of times.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableRetry,
+ * } from "@langchain/core/runnables";
+ *
+ * // Simulate an API call that fails
+ * const simulateApiCall = (input: string): string => {
+ *   console.log(`Attempting API call with input: ${input}`);
+ *   throw new Error("API call failed due to network issue");
+ * };
+ *
+ * const apiCallLambda = RunnableLambda.from(simulateApiCall);
+ *
+ * // Apply retry logic using the .withRetry() method
+ * const apiCallWithRetry = apiCallLambda.withRetry({ stopAfterAttempt: 3 });
+ *
+ * // Alternatively, create a RunnableRetry instance manually
+ * const manualRetry = new RunnableRetry({
+ *   bound: apiCallLambda,
+ *   maxAttemptNumber: 3,
+ *   config: {},
+ * });
+ *
+ * // Example invocation using the .withRetry() method
+ * const res = await apiCallWithRetry
+ *   .invoke("Request 1")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ *
+ * // Example invocation using the manual retry instance
+ * const res2 = await manualRetry
+ *   .invoke("Request 2")
+ *   .catch((error) => {
+ *     console.error("Failed after multiple retries:", error.message);
+ *   });
+ * ```
  */
 export class RunnableRetry extends RunnableBinding {
     static lc_name() {
@@ -1488,7 +1582,30 @@ function assertNonTraceableFunction(func) {
     }
 }
 /**
- * A runnable that runs a callable.
+ * A runnable that wraps an arbitrary function that takes a single argument.
+ * @example
+ * ```typescript
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const add = (input: { x: number; y: number }) => input.x + input.y;
+ *
+ * const multiply = (input: { value: number; multiplier: number }) =>
+ *   input.value * input.multiplier;
+ *
+ * // Create runnables for the functions
+ * const addLambda = RunnableLambda.from(add);
+ * const multiplyLambda = RunnableLambda.from(multiply);
+ *
+ * // Chain the lambdas for a mathematical operation
+ * const chainedLambda = addLambda.pipe((result) =>
+ *   multiplyLambda.invoke({ value: result, multiplier: 2 })
+ * );
+ *
+ * // Example invocation of the chainedLambda
+ * const result = await chainedLambda.invoke({ x: 2, y: 3 });
+ *
+ * // Will log "10" (since (2 + 3) * 2 = 10)
+ * ```
  */
 export class RunnableLambda extends Runnable {
     static lc_name() {
@@ -1667,6 +1784,39 @@ export class RunnableLambda extends Runnable {
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
+/**
+ * A runnable that runs a mapping of runnables in parallel,
+ * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const addYears = (age: number): number => age + 5;
+ * const yearsToFifty = (age: number): number => 50 - age;
+ * const yearsToHundred = (age: number): number => 100 - age;
+ *
+ * const addYearsLambda = RunnableLambda.from(addYears);
+ * const milestoneFiftyLambda = RunnableLambda.from(yearsToFifty);
+ * const milestoneHundredLambda = RunnableLambda.from(yearsToHundred);
+ *
+ * // Pipe will coerce objects into RunnableParallel by default, but we
+ * // explicitly instantiate one here to demonstrate
+ * const sequence = addYearsLambda.pipe(
+ *   RunnableParallel.from({
+ *     years_to_fifty: milestoneFiftyLambda,
+ *     years_to_hundred: milestoneHundredLambda,
+ *   })
+ * );
+ *
+ * // Invoke the sequence with a single age input
+ * const res = sequence.invoke(25);
+ *
+ * // { years_to_fifty: 25, years_to_hundred: 75 }
+ * ```
+ */
 export class RunnableParallel extends RunnableMap {
 }
 /**
@@ -1687,6 +1837,55 @@ export class RunnableParallel extends RunnableMap {
  * When streaming, fallbacks will only be called on failures during the initial
  * stream creation. Errors that occur after a stream starts will not fallback
  * to the next Runnable.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableLambda,
+ *   RunnableWithFallbacks,
+ * } from "@langchain/core/runnables";
+ *
+ * const primaryOperation = (input: string): string => {
+ *   if (input !== "safe") {
+ *     throw new Error("Primary operation failed due to unsafe input");
+ *   }
+ *   return `Processed: ${input}`;
+ * };
+ *
+ * // Define a fallback operation that processes the input differently
+ * const fallbackOperation = (input: string): string =>
+ *   `Fallback processed: ${input}`;
+ *
+ * const primaryRunnable = RunnableLambda.from(primaryOperation);
+ * const fallbackRunnable = RunnableLambda.from(fallbackOperation);
+ *
+ * // Apply the fallback logic using the .withFallbacks() method
+ * const runnableWithFallback = primaryRunnable.withFallbacks([fallbackRunnable]);
+ *
+ * // Alternatively, create a RunnableWithFallbacks instance manually
+ * const manualFallbackChain = new RunnableWithFallbacks({
+ *   runnable: primaryRunnable,
+ *   fallbacks: [fallbackRunnable],
+ * });
+ *
+ * // Example invocation using .withFallbacks()
+ * const res = await runnableWithFallback
+ *   .invoke("unsafe input")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Fallback processed: unsafe input"
+ *
+ * // Example invocation using manual instantiation
+ * const res = await manualFallbackChain
+ *   .invoke("safe")
+ *   .catch((error) => {
+ *     console.error("Failed after all attempts:", error.message);
+ *   });
+ *
+ * // "Processed: safe"
+ * ```
  */
 export class RunnableWithFallbacks extends Runnable {
     static lc_name() {
@@ -1855,6 +2054,34 @@ export function _coerceToRunnable(coerceable) {
 }
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * @example
+ * ```typescript
+ * import {
+ *   RunnableAssign,
+ *   RunnableLambda,
+ *   RunnableParallel,
+ * } from "@langchain/core/runnables";
+ *
+ * const calculateAge = (x: { birthYear: number }): { age: number } => {
+ *   const currentYear = new Date().getFullYear();
+ *   return { age: currentYear - x.birthYear };
+ * };
+ *
+ * const createGreeting = (x: { name: string }): { greeting: string } => {
+ *   return { greeting: `Hello, ${x.name}!` };
+ * };
+ *
+ * const mapper = RunnableParallel.from({
+ *   age_step: RunnableLambda.from(calculateAge),
+ *   greeting_step: RunnableLambda.from(createGreeting),
+ * });
+ *
+ * const runnableAssign = new RunnableAssign({ mapper });
+ *
+ * const res = await runnableAssign.invoke({ name: "Alice", birthYear: 1990 });
+ *
+ * // { name: "Alice", birthYear: 1990, age_step: { age: 34 }, greeting_step: { greeting: "Hello, Alice!" } }
+ * ```
  */
 export class RunnableAssign extends Runnable {
     static lc_name() {
@@ -1937,6 +2164,27 @@ export class RunnableAssign extends Runnable {
 }
 /**
  * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ * Useful for streaming, can be automatically created and chained by calling `runnable.pick();`.
+ * @example
+ * ```typescript
+ * import { RunnablePick } from "@langchain/core/runnables";
+ *
+ * const inputData = {
+ *   name: "John",
+ *   age: 30,
+ *   city: "New York",
+ *   country: "USA",
+ *   email: "john.doe@example.com",
+ *   phone: "+1234567890",
+ * };
+ *
+ * const basicInfoRunnable = new RunnablePick(["name", "city"]);
+ *
+ * // Example invocation
+ * const res = await basicInfoRunnable.invoke(inputData);
+ *
+ * // { name: 'John', city: 'New York' }
+ * ```
  */
 export class RunnablePick extends Runnable {
     static lc_name() {

package/dist/runnables/router.cjs

@@ -6,6 +6,29 @@ const config_js_1 = require("./config.cjs");
 /**
  * A runnable that routes to a set of runnables based on Input['key'].
  * Returns the output of the selected runnable.
+ * @example
+ * ```typescript
+ * import { RouterRunnable, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const router = new RouterRunnable({
+ *   runnables: {
+ *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),
+ *     reverseText: RunnableLambda.from((text: string) =>
+ *       text.split("").reverse().join("")
+ *     ),
+ *   },
+ * });
+ *
+ * // Invoke the 'reverseText' runnable
+ * const result1 = router.invoke({ key: "reverseText", input: "Hello World" });
+ *
+ * // "dlroW olleH"
+ *
+ * // Invoke the 'toUpperCase' runnable
+ * const result2 = router.invoke({ key: "toUpperCase", input: "Hello World" });
+ *
+ * // "HELLO WORLD"
+ * ```
  */
 class RouterRunnable extends base_js_1.Runnable {
     static lc_name() {

package/dist/runnables/router.d.ts

@@ -8,6 +8,29 @@ export type RouterInput = {
 /**
  * A runnable that routes to a set of runnables based on Input['key'].
  * Returns the output of the selected runnable.
+ * @example
+ * ```typescript
+ * import { RouterRunnable, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const router = new RouterRunnable({
+ *   runnables: {
+ *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),
+ *     reverseText: RunnableLambda.from((text: string) =>
+ *       text.split("").reverse().join("")
+ *     ),
+ *   },
+ * });
+ *
+ * // Invoke the 'reverseText' runnable
+ * const result1 = router.invoke({ key: "reverseText", input: "Hello World" });
+ *
+ * // "dlroW olleH"
+ *
+ * // Invoke the 'toUpperCase' runnable
+ * const result2 = router.invoke({ key: "toUpperCase", input: "Hello World" });
+ *
+ * // "HELLO WORLD"
+ * ```
  */
 export declare class RouterRunnable<RunInput extends RouterInput, RunnableInput, RunOutput> extends Runnable<RunInput, RunOutput> {
     static lc_name(): string;

package/dist/runnables/router.js

@@ -3,6 +3,29 @@ import { ensureConfig } from "./config.js";
 /**
  * A runnable that routes to a set of runnables based on Input['key'].
  * Returns the output of the selected runnable.
+ * @example
+ * ```typescript
+ * import { RouterRunnable, RunnableLambda } from "@langchain/core/runnables";
+ *
+ * const router = new RouterRunnable({
+ *   runnables: {
+ *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),
+ *     reverseText: RunnableLambda.from((text: string) =>
+ *       text.split("").reverse().join("")
+ *     ),
+ *   },
+ * });
+ *
+ * // Invoke the 'reverseText' runnable
+ * const result1 = router.invoke({ key: "reverseText", input: "Hello World" });
+ *
+ * // "dlroW olleH"
+ *
+ * // Invoke the 'toUpperCase' runnable
+ * const result2 = router.invoke({ key: "toUpperCase", input: "Hello World" });
+ *
+ * // "HELLO WORLD"
+ * ```
  */
 export class RouterRunnable extends Runnable {
     static lc_name() {

package/dist/tracers/base.d.ts

@@ -56,6 +56,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     protected _endTrace(run: Run): Promise<void>;
     protected _getExecutionOrder(parentRunId: string | undefined): number;
@@ -88,6 +89,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     /**
@@ -119,6 +121,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
@@ -152,6 +155,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;
     handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
@@ -189,6 +193,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleToolEnd(output: any, runId: string): Promise<Run>;
@@ -224,6 +229,7 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         reference_example_id?: string | undefined;
         parent_run_id?: string | undefined;
         tags?: string[] | undefined;
+        attachments?: Record<string, [string, Uint8Array]> | undefined;
     };
     handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;

package/dist/tracers/tracer_langchain.cjs

@@ -39,7 +39,13 @@ class LangChainTracer extends base_js_1.BaseTracer {
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
-        this.client = client ?? new langsmith_1.Client({});
+        const clientParams = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
+            ? {
+                // LangSmith has its own backgrounding system
+                blockOnRootRunFinalization: true,
+            }
+            : {};
+        this.client = client ?? new langsmith_1.Client(clientParams);
         const traceableTree = LangChainTracer.getTraceableRunTree();
         if (traceableTree) {
             this.updateFromRunTree(traceableTree);

package/dist/tracers/tracer_langchain.js

@@ -36,7 +36,13 @@ export class LangChainTracer extends BaseTracer {
                 getEnvironmentVariable("LANGCHAIN_PROJECT") ??
                 getEnvironmentVariable("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
-        this.client = client ?? new Client({});
+        const clientParams = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
+            ? {
+                // LangSmith has its own backgrounding system
+                blockOnRootRunFinalization: true,
+            }
+            : {};
+        this.client = client ?? new Client(clientParams);
         const traceableTree = LangChainTracer.getTraceableRunTree();
         if (traceableTree) {
             this.updateFromRunTree(traceableTree);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -37,7 +37,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "^0.1.65",
+    "langsmith": "^0.2.0",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",