langchain 0.1.19-rc.0 → 0.1.19-rc.2

package/dist/document_loaders/web/couchbase.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CouchbaseDocumentLoader = void 0;
+const documents_1 = require("@langchain/core/documents");
+const base_js_1 = require("../base.cjs");
+/**
+ * loader for couchbase document
+ */
+class CouchbaseDocumentLoader extends base_js_1.BaseDocumentLoader {
+    /**
+     * construct Couchbase document loader with a requirement for couchbase cluster client
+     * @param client { Cluster } [ couchbase connected client to connect to database ]
+     * @param query { string } [ query to get results from while loading the data ]
+     * @param pageContentFields { Array<string> } [ filters fields of the document and shows these only ]
+     * @param metadataFields { Array<string> } [ metadata fields required ]
+     */
+    constructor(client, query, pageContentFields, metadataFields) {
+        super();
+        Object.defineProperty(this, "cluster", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pageContentFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadataFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!client) {
+            throw new Error("Couchbase client cluster must be provided.");
+        }
+        this.cluster = client;
+        this.query = query;
+        this.pageContentFields = pageContentFields;
+        this.metadataFields = metadataFields;
+    }
+    /**
+     * Function to load document based on query from couchbase
+     * @returns {Promise<Document[]>} [ Returns a promise of all the documents as array ]
+     */
+    async load() {
+        const documents = [];
+        for await (const doc of this.lazyLoad()) {
+            documents.push(doc);
+        }
+        return documents;
+    }
+    /**
+     * Function to load documents based on iterator rather than full load
+     * @returns {AsyncIterable<Document>} [ Returns an iterator to fetch documents ]
+     */
+    async *lazyLoad() {
+        // Run SQL++ Query
+        const result = await this.cluster.query(this.query);
+        for await (const row of result.rows) {
+            let { metadataFields, pageContentFields } = this;
+            if (!pageContentFields) {
+                pageContentFields = Object.keys(row);
+            }
+            if (!metadataFields) {
+                metadataFields = [];
+            }
+            const metadata = metadataFields.reduce((obj, field) => ({ ...obj, [field]: row[field] }), {});
+            const document = pageContentFields
+                .map((k) => `${k}: ${JSON.stringify(row[k])}`)
+                .join("\n");
+            yield new documents_1.Document({
+                pageContent: document,
+                metadata,
+            });
+        }
+    }
+}
+exports.CouchbaseDocumentLoader = CouchbaseDocumentLoader;

package/dist/document_loaders/web/couchbase.d.ts

@@ -0,0 +1,30 @@
+import { Cluster } from "couchbase";
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader, DocumentLoader } from "../base.js";
+/**
+ * loader for couchbase document
+ */
+export declare class CouchbaseDocumentLoader extends BaseDocumentLoader implements DocumentLoader {
+    private cluster;
+    private query;
+    private pageContentFields?;
+    private metadataFields?;
+    /**
+     * construct Couchbase document loader with a requirement for couchbase cluster client
+     * @param client { Cluster } [ couchbase connected client to connect to database ]
+     * @param query { string } [ query to get results from while loading the data ]
+     * @param pageContentFields { Array<string> } [ filters fields of the document and shows these only ]
+     * @param metadataFields { Array<string> } [ metadata fields required ]
+     */
+    constructor(client: Cluster, query: string, pageContentFields?: string[], metadataFields?: string[]);
+    /**
+     * Function to load document based on query from couchbase
+     * @returns {Promise<Document[]>} [ Returns a promise of all the documents as array ]
+     */
+    load(): Promise<Document[]>;
+    /**
+     * Function to load documents based on iterator rather than full load
+     * @returns {AsyncIterable<Document>} [ Returns an iterator to fetch documents ]
+     */
+    lazyLoad(): AsyncIterable<Document>;
+}

package/dist/document_loaders/web/couchbase.js

@@ -0,0 +1,84 @@
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "../base.js";
+/**
+ * loader for couchbase document
+ */
+export class CouchbaseDocumentLoader extends BaseDocumentLoader {
+    /**
+     * construct Couchbase document loader with a requirement for couchbase cluster client
+     * @param client { Cluster } [ couchbase connected client to connect to database ]
+     * @param query { string } [ query to get results from while loading the data ]
+     * @param pageContentFields { Array<string> } [ filters fields of the document and shows these only ]
+     * @param metadataFields { Array<string> } [ metadata fields required ]
+     */
+    constructor(client, query, pageContentFields, metadataFields) {
+        super();
+        Object.defineProperty(this, "cluster", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pageContentFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadataFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!client) {
+            throw new Error("Couchbase client cluster must be provided.");
+        }
+        this.cluster = client;
+        this.query = query;
+        this.pageContentFields = pageContentFields;
+        this.metadataFields = metadataFields;
+    }
+    /**
+     * Function to load document based on query from couchbase
+     * @returns {Promise<Document[]>} [ Returns a promise of all the documents as array ]
+     */
+    async load() {
+        const documents = [];
+        for await (const doc of this.lazyLoad()) {
+            documents.push(doc);
+        }
+        return documents;
+    }
+    /**
+     * Function to load documents based on iterator rather than full load
+     * @returns {AsyncIterable<Document>} [ Returns an iterator to fetch documents ]
+     */
+    async *lazyLoad() {
+        // Run SQL++ Query
+        const result = await this.cluster.query(this.query);
+        for await (const row of result.rows) {
+            let { metadataFields, pageContentFields } = this;
+            if (!pageContentFields) {
+                pageContentFields = Object.keys(row);
+            }
+            if (!metadataFields) {
+                metadataFields = [];
+            }
+            const metadata = metadataFields.reduce((obj, field) => ({ ...obj, [field]: row[field] }), {});
+            const document = pageContentFields
+                .map((k) => `${k}: ${JSON.stringify(row[k])}`)
+                .join("\n");
+            yield new Document({
+                pageContent: document,
+                metadata,
+            });
+        }
+    }
+}

package/dist/load/import_constants.cjs

@@ -102,6 +102,7 @@ exports.optionalImportEntrypoints = [
     "langchain/document_loaders/web/sitemap",
     "langchain/document_loaders/web/sonix_audio",
     "langchain/document_loaders/web/confluence",
+    "langchain/document_loaders/web/couchbase",
     "langchain/document_loaders/web/youtube",
     "langchain/document_loaders/fs/directory",
     "langchain/document_loaders/fs/buffer",

package/dist/load/import_constants.js

@@ -99,6 +99,7 @@ export const optionalImportEntrypoints = [
     "langchain/document_loaders/web/sitemap",
     "langchain/document_loaders/web/sonix_audio",
     "langchain/document_loaders/web/confluence",
+    "langchain/document_loaders/web/couchbase",
     "langchain/document_loaders/web/youtube",
     "langchain/document_loaders/fs/directory",
     "langchain/document_loaders/fs/buffer",

package/dist/smith/config.cjs

@@ -1,2 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingDistance = exports.LabeledCriteria = exports.Criteria = exports.isCustomEvaluator = exports.isOffTheShelfEvaluator = void 0;
+function isOffTheShelfEvaluator(evaluator) {
+    return typeof evaluator === "string" || "evaluatorType" in evaluator;
+}
+exports.isOffTheShelfEvaluator = isOffTheShelfEvaluator;
+function isCustomEvaluator(evaluator) {
+    return !isOffTheShelfEvaluator(evaluator);
+}
+exports.isCustomEvaluator = isCustomEvaluator;
+const isStringifiableValue = (value) => typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    typeof value === "bigint";
+const getSingleStringifiedValue = (value) => {
+    if (isStringifiableValue(value)) {
+        return `${value}`;
+    }
+    if (typeof value === "object" && value != null && !Array.isArray(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 1 && isStringifiableValue(entries[0][1])) {
+            return `${entries[0][1]}`;
+        }
+    }
+    console.warn("Non-stringifiable value found when coercing", value);
+    return `${value}`;
+};
+function Criteria(criteria, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            input: getSingleStringifiedValue(payload.rawInput),
+        }));
+    return {
+        evaluatorType: "criteria",
+        criteria,
+        feedbackKey: config?.feedbackKey ?? criteria,
+        llm: config?.llm,
+        formatEvaluatorInputs,
+    };
+}
+exports.Criteria = Criteria;
+function LabeledCriteria(criteria, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            input: getSingleStringifiedValue(payload.rawInput),
+            reference: getSingleStringifiedValue(payload.rawReferenceOutput),
+        }));
+    return {
+        evaluatorType: "labeled_criteria",
+        criteria,
+        feedbackKey: config?.feedbackKey ?? criteria,
+        llm: config?.llm,
+        formatEvaluatorInputs,
+    };
+}
+exports.LabeledCriteria = LabeledCriteria;
+function EmbeddingDistance(distanceMetric, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            reference: getSingleStringifiedValue(payload.rawReferenceOutput),
+        }));
+    return {
+        evaluatorType: "embedding_distance",
+        embedding: config?.embedding,
+        distanceMetric,
+        feedbackKey: config?.feedbackKey ?? "embedding_distance",
+        formatEvaluatorInputs,
+    };
+}
+exports.EmbeddingDistance = EmbeddingDistance;

package/dist/smith/config.d.ts

@@ -2,7 +2,7 @@ import { BaseLanguageModel } from "@langchain/core/language_models/base";
 import { RunnableConfig } from "@langchain/core/runnables";
 import { Example, Run } from "langsmith";
 import { EvaluationResult, RunEvaluator } from "langsmith/evaluation";
-import { Criteria } from "../evaluation/index.js";
+import { Criteria as CriteriaType, type EmbeddingDistanceEvalChainInput } from "../evaluation/index.js";
 import { LoadEvaluatorOptions } from "../evaluation/loader.js";
 import { EvaluatorType } from "../evaluation/types.js";
 export type EvaluatorInputs = {
@@ -33,6 +33,9 @@ export type RunEvaluatorLike = ((props: DynamicRunEvaluatorParams, options?: {
 }) => Promise<EvaluationResult>) | ((props: DynamicRunEvaluatorParams, options?: {
     config?: RunnableConfig;
 }) => EvaluationResult);
+export declare function isOffTheShelfEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is T | EvalConfig;
+export declare function isCustomEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is U;
+export type RunEvalType<T extends keyof EvaluatorType = "criteria" | "labeled_criteria" | "embedding_distance", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = T | EvalConfig | U;
 /**
  * Configuration class for running evaluations on datasets.
  *
@@ -42,20 +45,13 @@ export type RunEvaluatorLike = ((props: DynamicRunEvaluatorParams, options?: {
  * @typeparam T - The type of evaluators.
  * @typeparam U - The type of custom evaluators.
  */
-export type RunEvalConfig<T extends keyof EvaluatorType = keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = {
+export type RunEvalConfig<T extends keyof EvaluatorType = "criteria" | "labeled_criteria" | "embedding_distance", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = {
     /**
-     * Custom evaluators to apply to a dataset run.
-     * Each evaluator is provided with a run trace containing the model
-     * outputs, as well as an "example" object representing a record
-     * in the dataset.
-     */
-    customEvaluators?: U[];
-    /**
-     * LangChain evaluators to apply to a dataset run.
+     * Evaluators to apply to a dataset run.
      * You can optionally specify these by name, or by
      * configuring them with an EvalConfig object.
      */
-    evaluators?: (T | EvalConfig)[];
+    evaluators?: RunEvalType<T, U>[];
     /**
      * Convert the evaluation data into formats that can be used by the evaluator.
      * This should most commonly be a string.
@@ -81,9 +77,14 @@ export type RunEvalConfig<T extends keyof EvaluatorType = keyof EvaluatorType, U
      */
     formatEvaluatorInputs?: EvaluatorInputFormatter;
     /**
-     * The language model specification for evaluators that require one.
+     * Custom evaluators to apply to a dataset run.
+     * Each evaluator is provided with a run trace containing the model
+     * outputs, as well as an "example" object representing a record
+     * in the dataset.
+     *
+     * @deprecated Use `evaluators` instead.
      */
-    evalLlm?: string;
+    customEvaluators?: U[];
 };
 export interface EvalConfig extends LoadEvaluatorOptions {
     /**
@@ -147,7 +148,7 @@ export interface EvalConfig extends LoadEvaluatorOptions {
  *   }]
  * };
  */
-export type CriteriaEvalChainConfig = EvalConfig & {
+export type Criteria = EvalConfig & {
     evaluatorType: "criteria";
     /**
      * The "criteria" to insert into the prompt template
@@ -155,18 +156,14 @@ export type CriteriaEvalChainConfig = EvalConfig & {
      * https://smith.langchain.com/hub/langchain-ai/criteria-evaluator
      * for more information.
      */
-    criteria?: Criteria | Record<string, string>;
+    criteria?: CriteriaType | Record<string, string>;
     /**
-     * The feedback (or metric) name to use for the logged
-     * evaluation results. If none provided, we default to
-     * the evaluationName.
-     */
-    feedbackKey?: string;
-    /**
-     * The language model to use as the evaluator.
+     * The language model to use as the evaluator, defaults to GPT-4
      */
     llm?: BaseLanguageModel;
 };
+export type CriteriaEvalChainConfig = Criteria;
+export declare function Criteria(criteria: CriteriaType, config?: Pick<Partial<LabeledCriteria>, "formatEvaluatorInputs" | "llm" | "feedbackKey">): EvalConfig;
 /**
  * Configuration to load a "LabeledCriteriaEvalChain" evaluator,
  * which prompts an LLM to determine whether the model's
@@ -202,15 +199,19 @@ export type LabeledCriteria = EvalConfig & {
      * https://smith.langchain.com/hub/langchain-ai/labeled-criteria
      * for more information.
      */
-    criteria?: Criteria | Record<string, string>;
+    criteria?: CriteriaType | Record<string, string>;
     /**
-     * The feedback (or metric) name to use for the logged
-     * evaluation results. If none provided, we default to
-     * the evaluationName.
-     */
-    feedbackKey?: string;
-    /**
-     * The language model to use as the evaluator.
+     * The language model to use as the evaluator, defaults to GPT-4
      */
     llm?: BaseLanguageModel;
 };
+export declare function LabeledCriteria(criteria: CriteriaType, config?: Pick<Partial<LabeledCriteria>, "formatEvaluatorInputs" | "llm" | "feedbackKey">): LabeledCriteria;
+/**
+ * Configuration to load a "EmbeddingDistanceEvalChain" evaluator,
+ * which embeds distances to score semantic difference between
+ * a prediction and reference.
+ */
+export type EmbeddingDistance = EvalConfig & EmbeddingDistanceEvalChainInput & {
+    evaluatorType: "embedding_distance";
+};
+export declare function EmbeddingDistance(distanceMetric: EmbeddingDistanceEvalChainInput["distanceMetric"], config?: Pick<Partial<LabeledCriteria>, "formatEvaluatorInputs" | "embedding" | "feedbackKey">): EmbeddingDistance;

package/dist/smith/config.js

@@ -1 +1,66 @@
-export {};
+export function isOffTheShelfEvaluator(evaluator) {
+    return typeof evaluator === "string" || "evaluatorType" in evaluator;
+}
+export function isCustomEvaluator(evaluator) {
+    return !isOffTheShelfEvaluator(evaluator);
+}
+const isStringifiableValue = (value) => typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    typeof value === "bigint";
+const getSingleStringifiedValue = (value) => {
+    if (isStringifiableValue(value)) {
+        return `${value}`;
+    }
+    if (typeof value === "object" && value != null && !Array.isArray(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 1 && isStringifiableValue(entries[0][1])) {
+            return `${entries[0][1]}`;
+        }
+    }
+    console.warn("Non-stringifiable value found when coercing", value);
+    return `${value}`;
+};
+export function Criteria(criteria, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            input: getSingleStringifiedValue(payload.rawInput),
+        }));
+    return {
+        evaluatorType: "criteria",
+        criteria,
+        feedbackKey: config?.feedbackKey ?? criteria,
+        llm: config?.llm,
+        formatEvaluatorInputs,
+    };
+}
+export function LabeledCriteria(criteria, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            input: getSingleStringifiedValue(payload.rawInput),
+            reference: getSingleStringifiedValue(payload.rawReferenceOutput),
+        }));
+    return {
+        evaluatorType: "labeled_criteria",
+        criteria,
+        feedbackKey: config?.feedbackKey ?? criteria,
+        llm: config?.llm,
+        formatEvaluatorInputs,
+    };
+}
+export function EmbeddingDistance(distanceMetric, config) {
+    const formatEvaluatorInputs = config?.formatEvaluatorInputs ??
+        ((payload) => ({
+            prediction: getSingleStringifiedValue(payload.rawPrediction),
+            reference: getSingleStringifiedValue(payload.rawReferenceOutput),
+        }));
+    return {
+        evaluatorType: "embedding_distance",
+        embedding: config?.embedding,
+        distanceMetric,
+        feedbackKey: config?.feedbackKey ?? "embedding_distance",
+        formatEvaluatorInputs,
+    };
+}

package/dist/smith/runner_utils.cjs

@@ -7,6 +7,7 @@ const tracer_langchain_1 = require("@langchain/core/tracers/tracer_langchain");
 const base_1 = require("@langchain/core/tracers/base");
 const langsmith_1 = require("langsmith");
 const loader_js_1 = require("../evaluation/loader.cjs");
+const config_js_1 = require("./config.cjs");
 const name_generation_js_1 = require("./name_generation.cjs");
 const progress_js_1 = require("./progress.cjs");
 class SingleRunIdExtractor {
@@ -114,6 +115,124 @@ class DynamicRunEvaluator {
 function isLLMStringEvaluator(evaluator) {
     return evaluator && typeof evaluator.evaluateStrings === "function";
 }
+/**
+ * Internal implementation of RunTree, which uses the
+ * provided callback manager instead of the internal LangSmith client.
+ *
+ * The goal of this class is to ensure seamless interop when intergrated
+ * with other Runnables.
+ */
+class CallbackManagerRunTree extends langsmith_1.RunTree {
+    constructor(config, callbackManager) {
+        super(config);
+        Object.defineProperty(this, "callbackManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeCallbackManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this.callbackManager = callbackManager;
+    }
+    async createChild(config) {
+        const child = new CallbackManagerRunTree({
+            ...config,
+            parent_run: this,
+            project_name: this.project_name,
+            client: this.client,
+        }, this.activeCallbackManager?.getChild() ?? this.callbackManager);
+        this.child_runs.push(child);
+        return child;
+    }
+    async postRun() {
+        // how it is translated in comparison to basic RunTree?
+        this.activeCallbackManager = await this.callbackManager.handleChainStart(typeof this.serialized !== "object" &&
+            this.serialized != null &&
+            "lc" in this.serialized
+            ? this.serialized
+            : {
+                id: ["langchain", "smith", "CallbackManagerRunTree"],
+                lc: 1,
+                type: "not_implemented",
+            }, this.inputs, this.id, this.run_type, undefined, undefined, this.name);
+    }
+    async patchRun() {
+        if (this.error) {
+            await this.activeCallbackManager?.handleChainError(this.error, this.id, this.parent_run?.id, undefined, undefined);
+        }
+        else {
+            await this.activeCallbackManager?.handleChainEnd(this.outputs ?? {}, this.id, this.parent_run?.id, undefined, undefined);
+        }
+    }
+}
+class RunnableTraceable extends runnables_1.Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isLangsmithTraceableFunction(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        const callbackManager = await (0, runnables_1.getCallbackManagerForConfig)(config);
+        const partialConfig = "langsmith:traceable" in this.func
+            ? this.func["langsmith:traceable"]
+            : { name: "<lambda>" };
+        if (!callbackManager)
+            throw new Error("CallbackManager not found");
+        const runTree = new CallbackManagerRunTree({
+            ...partialConfig,
+            parent_run: callbackManager?._parentRunId
+                ? new langsmith_1.RunTree({ name: "<parent>", id: callbackManager?._parentRunId })
+                : undefined,
+        }, callbackManager);
+        if (typeof input === "object" &&
+            input != null &&
+            Object.keys(input).length === 1) {
+            if ("args" in input && Array.isArray(input)) {
+                return (await this.func(runTree, ...input));
+            }
+            if ("input" in input &&
+                !(typeof input === "object" &&
+                    input != null &&
+                    !Array.isArray(input) &&
+                    // eslint-disable-next-line no-instanceof/no-instanceof
+                    !(input instanceof Date))) {
+                try {
+                    return (await this.func(runTree, input.input));
+                }
+                catch (err) {
+                    return (await this.func(runTree, input));
+                }
+            }
+        }
+        return (await this.func(runTree, input));
+    }
+}
 /**
  * Wraps an off-the-shelf evaluator (loaded using loadEvaluator; of EvaluatorType[T])
  * and composes with a prepareData function so the user can prepare the trace and
@@ -155,14 +274,14 @@ class PreparedRunEvaluator {
         const evalConfig = typeof config === "string" ? {} : config;
         const evaluator = await (0, loader_js_1.loadEvaluator)(evaluatorType, evalConfig);
         const feedbackKey = evalConfig?.feedbackKey ?? evaluator?.evaluationName;
-        if (!feedbackKey) {
-            throw new Error(`Evaluator of type ${evaluatorType} must have an evaluationName` +
-                ` or feedbackKey. Please manually provide a feedbackKey in the EvalConfig.`);
-        }
         if (!isLLMStringEvaluator(evaluator)) {
             throw new Error(`Evaluator of type ${evaluatorType} not yet supported. ` +
                 "Please use a string evaluator, or implement your " +
-                "evaluation logic as a customEvaluator.");
+                "evaluation logic as a custom evaluator.");
+        }
+        if (!feedbackKey) {
+            throw new Error(`Evaluator of type ${evaluatorType} must have an evaluationName` +
+                ` or feedbackKey. Please manually provide a feedbackKey in the EvalConfig.`);
         }
         return new PreparedRunEvaluator(evaluator, feedbackKey, evalConfig?.formatEvaluatorInputs);
     }
@@ -199,7 +318,7 @@ class PreparedRunEvaluator {
         }
         throw new Error("Evaluator not yet supported. " +
             "Please use a string evaluator, or implement your " +
-            "evaluation logic as a customEvaluator.");
+            "evaluation logic as a custom evaluator.");
     }
 }
 class LoadedEvalConfig {
@@ -213,7 +332,7 @@ class LoadedEvalConfig {
     }
     static async fromRunEvalConfig(config) {
         // Custom evaluators are applied "as-is"
-        const customEvaluators = config?.customEvaluators?.map((evaluator) => {
+        const customEvaluators = (config?.customEvaluators ?? config.evaluators?.filter(config_js_1.isCustomEvaluator))?.map((evaluator) => {
             if (typeof evaluator === "function") {
                 return new DynamicRunEvaluator(evaluator);
             }
@@ -221,7 +340,9 @@ class LoadedEvalConfig {
                 return evaluator;
             }
         });
-        const offTheShelfEvaluators = await Promise.all(config?.evaluators?.map(async (evaluator) => await PreparedRunEvaluator.fromEvalConfig(evaluator)) ?? []);
+        const offTheShelfEvaluators = await Promise.all(config?.evaluators
+            ?.filter(config_js_1.isOffTheShelfEvaluator)
+            ?.map(async (evaluator) => await PreparedRunEvaluator.fromEvalConfig(evaluator)) ?? []);
         return new LoadedEvalConfig((customEvaluators ?? []).concat(offTheShelfEvaluators ?? []));
     }
 }
@@ -238,6 +359,10 @@ const createWrappedModel = async (modelOrFactory) => {
         return () => modelOrFactory;
     }
     if (typeof modelOrFactory === "function") {
+        if (isLangsmithTraceableFunction(modelOrFactory)) {
+            const wrappedModel = new RunnableTraceable({ func: modelOrFactory });
+            return () => wrappedModel;
+        }
         try {
             // If it works with no arguments, assume it's a factory
             let res = modelOrFactory();
@@ -249,7 +374,7 @@ const createWrappedModel = async (modelOrFactory) => {
         }
         catch (err) {
             // Otherwise, it's a custom UDF, and we'll wrap
-            // in a lambda
+            // the function in a lambda
             const wrappedModel = new runnables_1.RunnableLambda({ func: modelOrFactory });
             return () => wrappedModel;
         }
@@ -337,11 +462,11 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  * for evaluation.
  *
  * @param options - (Optional) Additional parameters for the evaluation process:
- *   - `evaluationConfig` (RunEvalConfig): Configuration for the evaluation, including
- *     standard and custom evaluators.
+ *   - `evaluators` (RunEvalType[]): Evaluators to apply to a dataset run.
+ *   - `formatEvaluatorInputs` (EvaluatorInputFormatter): Convert the evaluation data into formats that can be used by the evaluator.
  *   - `projectName` (string): Name of the project for logging and tracking.
  *   - `projectMetadata` (Record<string, unknown>): Additional metadata for the project.
- *   - `client` (Client): Client instance for LangChain service interaction.
+ *   - `client` (Client): Client instance for LangSmith service interaction.
  *   - `maxConcurrency` (number): Maximum concurrency level for dataset processing.
  *
  * @returns A promise that resolves to an `EvalResults` object. This object includes
@@ -356,13 +481,8 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  *   const datasetName = 'example-dataset';
  *   const client = new Client(/* ...config... *\//);
  *
- *   const evaluationConfig = {
- *     evaluators: [/* ...evaluators... *\//],
- *     customEvaluators: [/* ...custom evaluators... *\//],
- *   };
- *
  *   const results = await runOnDataset(chain, datasetName, {
- *     evaluationConfig,
+ *     evaluators: [/* ...evaluators... *\//],
  *     client,
  *   });
  *
@@ -372,11 +492,19 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  * evaluateModel();
  * ```
  * In this example, `runOnDataset` is used to evaluate a language model (or a chain of models) against
- * a dataset named 'example-dataset'. The evaluation process is configured using `RunEvalConfig`, which can
+ * a dataset named 'example-dataset'. The evaluation process is configured using `RunOnDatasetParams["evaluators"]`, which can
  * include both standard and custom evaluators. The `Client` instance is used to interact with LangChain services.
  * The function returns the evaluation results, which can be logged or further processed as needed.
  */
-const runOnDataset = async (chainOrFactory, datasetName, { evaluationConfig, projectName, projectMetadata, client, maxConcurrency, }) => {
+async function runOnDataset(chainOrFactory, datasetName, options) {
+    const { projectName, projectMetadata, client, maxConcurrency, } = options ?? {};
+    const evaluationConfig = options?.evaluationConfig ??
+        (options?.evaluators != null
+            ? {
+                evaluators: options.evaluators,
+                formatEvaluatorInputs: options.formatEvaluatorInputs,
+            }
+            : undefined);
     const wrappedModel = await createWrappedModel(chainOrFactory);
     const testClient = client ?? new langsmith_1.Client();
     const testProjectName = projectName ?? (0, name_generation_js_1.randomName)();
@@ -432,5 +560,8 @@ const runOnDataset = async (chainOrFactory, datasetName, { evaluationConfig, pro
         results: evalResults ?? {},
     };
     return results;
-};
+}
 exports.runOnDataset = runOnDataset;
+function isLangsmithTraceableFunction(x) {
+    return typeof x === "function" && "langsmith:traceable" in x;
+}

package/dist/smith/runner_utils.d.ts

@@ -1,14 +1,31 @@
 import { Runnable } from "@langchain/core/runnables";
 import { Client, Feedback } from "langsmith";
-import type { RunEvalConfig } from "./config.js";
-export type ChainOrFactory = Runnable | (() => Runnable) | ((obj: any) => any) | ((obj: any) => Promise<any>) | (() => (obj: unknown) => unknown) | (() => (obj: unknown) => Promise<unknown>);
-export type RunOnDatasetParams = {
-    evaluationConfig?: RunEvalConfig;
-    projectMetadata?: Record<string, unknown>;
+import type { TraceableFunction } from "langsmith/traceable";
+import { type RunEvalConfig } from "./config.js";
+export type ChainOrFactory = Runnable | (() => Runnable) | AnyTraceableFunction | ((obj: any) => any) | ((obj: any) => Promise<any>) | (() => (obj: unknown) => unknown) | (() => (obj: unknown) => Promise<unknown>);
+type AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;
+export interface RunOnDatasetParams extends Omit<RunEvalConfig, "customEvaluators"> {
+    /**
+     * Name of the project for logging and tracking.
+     */
     projectName?: string;
+    /**
+     * Additional metadata for the project.
+     */
+    projectMetadata?: Record<string, unknown>;
+    /**
+     * Client instance for LangSmith service interaction.
+     */
     client?: Client;
+    /**
+     * Maximum concurrency level for dataset processing.
+     */
     maxConcurrency?: number;
-};
+    /**
+     * @deprecated Pass keys directly to the RunOnDatasetParams instead
+     */
+    evaluationConfig?: RunEvalConfig;
+}
 export type EvalResults = {
     projectName: string;
     results: {
@@ -35,11 +52,11 @@ export type EvalResults = {
  * for evaluation.
  *
  * @param options - (Optional) Additional parameters for the evaluation process:
- *   - `evaluationConfig` (RunEvalConfig): Configuration for the evaluation, including
- *     standard and custom evaluators.
+ *   - `evaluators` (RunEvalType[]): Evaluators to apply to a dataset run.
+ *   - `formatEvaluatorInputs` (EvaluatorInputFormatter): Convert the evaluation data into formats that can be used by the evaluator.
  *   - `projectName` (string): Name of the project for logging and tracking.
  *   - `projectMetadata` (Record<string, unknown>): Additional metadata for the project.
- *   - `client` (Client): Client instance for LangChain service interaction.
+ *   - `client` (Client): Client instance for LangSmith service interaction.
  *   - `maxConcurrency` (number): Maximum concurrency level for dataset processing.
  *
  * @returns A promise that resolves to an `EvalResults` object. This object includes
@@ -54,13 +71,8 @@ export type EvalResults = {
  *   const datasetName = 'example-dataset';
  *   const client = new Client(/* ...config... *\//);
  *
- *   const evaluationConfig = {
- *     evaluators: [/* ...evaluators... *\//],
- *     customEvaluators: [/* ...custom evaluators... *\//],
- *   };
- *
  *   const results = await runOnDataset(chain, datasetName, {
- *     evaluationConfig,
+ *     evaluators: [/* ...evaluators... *\//],
  *     client,
  *   });
  *
@@ -70,8 +82,9 @@ export type EvalResults = {
  * evaluateModel();
  * ```
  * In this example, `runOnDataset` is used to evaluate a language model (or a chain of models) against
- * a dataset named 'example-dataset'. The evaluation process is configured using `RunEvalConfig`, which can
+ * a dataset named 'example-dataset'. The evaluation process is configured using `RunOnDatasetParams["evaluators"]`, which can
  * include both standard and custom evaluators. The `Client` instance is used to interact with LangChain services.
  * The function returns the evaluation results, which can be logged or further processed as needed.
  */
-export declare const runOnDataset: (chainOrFactory: ChainOrFactory, datasetName: string, { evaluationConfig, projectName, projectMetadata, client, maxConcurrency, }: RunOnDatasetParams) => Promise<EvalResults>;
+export declare function runOnDataset(chainOrFactory: ChainOrFactory, datasetName: string, options?: RunOnDatasetParams): Promise<EvalResults>;
+export {};

package/dist/smith/runner_utils.js

@@ -1,9 +1,10 @@
 import { mapStoredMessagesToChatMessages } from "@langchain/core/messages";
-import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
+import { Runnable, RunnableLambda, getCallbackManagerForConfig, } from "@langchain/core/runnables";
 import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
 import { BaseTracer } from "@langchain/core/tracers/base";
-import { Client } from "langsmith";
+import { Client, RunTree, } from "langsmith";
 import { loadEvaluator } from "../evaluation/loader.js";
+import { isOffTheShelfEvaluator, isCustomEvaluator, } from "./config.js";
 import { randomName } from "./name_generation.js";
 import { ProgressBar } from "./progress.js";
 class SingleRunIdExtractor {
@@ -111,6 +112,124 @@ class DynamicRunEvaluator {
 function isLLMStringEvaluator(evaluator) {
     return evaluator && typeof evaluator.evaluateStrings === "function";
 }
+/**
+ * Internal implementation of RunTree, which uses the
+ * provided callback manager instead of the internal LangSmith client.
+ *
+ * The goal of this class is to ensure seamless interop when intergrated
+ * with other Runnables.
+ */
+class CallbackManagerRunTree extends RunTree {
+    constructor(config, callbackManager) {
+        super(config);
+        Object.defineProperty(this, "callbackManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeCallbackManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this.callbackManager = callbackManager;
+    }
+    async createChild(config) {
+        const child = new CallbackManagerRunTree({
+            ...config,
+            parent_run: this,
+            project_name: this.project_name,
+            client: this.client,
+        }, this.activeCallbackManager?.getChild() ?? this.callbackManager);
+        this.child_runs.push(child);
+        return child;
+    }
+    async postRun() {
+        // how it is translated in comparison to basic RunTree?
+        this.activeCallbackManager = await this.callbackManager.handleChainStart(typeof this.serialized !== "object" &&
+            this.serialized != null &&
+            "lc" in this.serialized
+            ? this.serialized
+            : {
+                id: ["langchain", "smith", "CallbackManagerRunTree"],
+                lc: 1,
+                type: "not_implemented",
+            }, this.inputs, this.id, this.run_type, undefined, undefined, this.name);
+    }
+    async patchRun() {
+        if (this.error) {
+            await this.activeCallbackManager?.handleChainError(this.error, this.id, this.parent_run?.id, undefined, undefined);
+        }
+        else {
+            await this.activeCallbackManager?.handleChainEnd(this.outputs ?? {}, this.id, this.parent_run?.id, undefined, undefined);
+        }
+    }
+}
+class RunnableTraceable extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isLangsmithTraceableFunction(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        const callbackManager = await getCallbackManagerForConfig(config);
+        const partialConfig = "langsmith:traceable" in this.func
+            ? this.func["langsmith:traceable"]
+            : { name: "<lambda>" };
+        if (!callbackManager)
+            throw new Error("CallbackManager not found");
+        const runTree = new CallbackManagerRunTree({
+            ...partialConfig,
+            parent_run: callbackManager?._parentRunId
+                ? new RunTree({ name: "<parent>", id: callbackManager?._parentRunId })
+                : undefined,
+        }, callbackManager);
+        if (typeof input === "object" &&
+            input != null &&
+            Object.keys(input).length === 1) {
+            if ("args" in input && Array.isArray(input)) {
+                return (await this.func(runTree, ...input));
+            }
+            if ("input" in input &&
+                !(typeof input === "object" &&
+                    input != null &&
+                    !Array.isArray(input) &&
+                    // eslint-disable-next-line no-instanceof/no-instanceof
+                    !(input instanceof Date))) {
+                try {
+                    return (await this.func(runTree, input.input));
+                }
+                catch (err) {
+                    return (await this.func(runTree, input));
+                }
+            }
+        }
+        return (await this.func(runTree, input));
+    }
+}
 /**
  * Wraps an off-the-shelf evaluator (loaded using loadEvaluator; of EvaluatorType[T])
  * and composes with a prepareData function so the user can prepare the trace and
@@ -152,14 +271,14 @@ class PreparedRunEvaluator {
         const evalConfig = typeof config === "string" ? {} : config;
         const evaluator = await loadEvaluator(evaluatorType, evalConfig);
         const feedbackKey = evalConfig?.feedbackKey ?? evaluator?.evaluationName;
-        if (!feedbackKey) {
-            throw new Error(`Evaluator of type ${evaluatorType} must have an evaluationName` +
-                ` or feedbackKey. Please manually provide a feedbackKey in the EvalConfig.`);
-        }
         if (!isLLMStringEvaluator(evaluator)) {
             throw new Error(`Evaluator of type ${evaluatorType} not yet supported. ` +
                 "Please use a string evaluator, or implement your " +
-                "evaluation logic as a customEvaluator.");
+                "evaluation logic as a custom evaluator.");
+        }
+        if (!feedbackKey) {
+            throw new Error(`Evaluator of type ${evaluatorType} must have an evaluationName` +
+                ` or feedbackKey. Please manually provide a feedbackKey in the EvalConfig.`);
         }
         return new PreparedRunEvaluator(evaluator, feedbackKey, evalConfig?.formatEvaluatorInputs);
     }
@@ -196,7 +315,7 @@ class PreparedRunEvaluator {
         }
         throw new Error("Evaluator not yet supported. " +
             "Please use a string evaluator, or implement your " +
-            "evaluation logic as a customEvaluator.");
+            "evaluation logic as a custom evaluator.");
     }
 }
 class LoadedEvalConfig {
@@ -210,7 +329,7 @@ class LoadedEvalConfig {
     }
     static async fromRunEvalConfig(config) {
         // Custom evaluators are applied "as-is"
-        const customEvaluators = config?.customEvaluators?.map((evaluator) => {
+        const customEvaluators = (config?.customEvaluators ?? config.evaluators?.filter(isCustomEvaluator))?.map((evaluator) => {
             if (typeof evaluator === "function") {
                 return new DynamicRunEvaluator(evaluator);
             }
@@ -218,7 +337,9 @@ class LoadedEvalConfig {
                 return evaluator;
             }
         });
-        const offTheShelfEvaluators = await Promise.all(config?.evaluators?.map(async (evaluator) => await PreparedRunEvaluator.fromEvalConfig(evaluator)) ?? []);
+        const offTheShelfEvaluators = await Promise.all(config?.evaluators
+            ?.filter(isOffTheShelfEvaluator)
+            ?.map(async (evaluator) => await PreparedRunEvaluator.fromEvalConfig(evaluator)) ?? []);
         return new LoadedEvalConfig((customEvaluators ?? []).concat(offTheShelfEvaluators ?? []));
     }
 }
@@ -235,6 +356,10 @@ const createWrappedModel = async (modelOrFactory) => {
         return () => modelOrFactory;
     }
     if (typeof modelOrFactory === "function") {
+        if (isLangsmithTraceableFunction(modelOrFactory)) {
+            const wrappedModel = new RunnableTraceable({ func: modelOrFactory });
+            return () => wrappedModel;
+        }
         try {
             // If it works with no arguments, assume it's a factory
             let res = modelOrFactory();
@@ -246,7 +371,7 @@ const createWrappedModel = async (modelOrFactory) => {
         }
         catch (err) {
             // Otherwise, it's a custom UDF, and we'll wrap
-            // in a lambda
+            // the function in a lambda
             const wrappedModel = new RunnableLambda({ func: modelOrFactory });
             return () => wrappedModel;
         }
@@ -334,11 +459,11 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  * for evaluation.
  *
  * @param options - (Optional) Additional parameters for the evaluation process:
- *   - `evaluationConfig` (RunEvalConfig): Configuration for the evaluation, including
- *     standard and custom evaluators.
+ *   - `evaluators` (RunEvalType[]): Evaluators to apply to a dataset run.
+ *   - `formatEvaluatorInputs` (EvaluatorInputFormatter): Convert the evaluation data into formats that can be used by the evaluator.
  *   - `projectName` (string): Name of the project for logging and tracking.
  *   - `projectMetadata` (Record<string, unknown>): Additional metadata for the project.
- *   - `client` (Client): Client instance for LangChain service interaction.
+ *   - `client` (Client): Client instance for LangSmith service interaction.
  *   - `maxConcurrency` (number): Maximum concurrency level for dataset processing.
  *
  * @returns A promise that resolves to an `EvalResults` object. This object includes
@@ -353,13 +478,8 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  *   const datasetName = 'example-dataset';
  *   const client = new Client(/* ...config... *\//);
  *
- *   const evaluationConfig = {
- *     evaluators: [/* ...evaluators... *\//],
- *     customEvaluators: [/* ...custom evaluators... *\//],
- *   };
- *
  *   const results = await runOnDataset(chain, datasetName, {
- *     evaluationConfig,
+ *     evaluators: [/* ...evaluators... *\//],
  *     client,
  *   });
  *
@@ -369,11 +489,19 @@ const getExamplesInputs = (examples, chainOrFactory, dataType) => {
  * evaluateModel();
  * ```
  * In this example, `runOnDataset` is used to evaluate a language model (or a chain of models) against
- * a dataset named 'example-dataset'. The evaluation process is configured using `RunEvalConfig`, which can
+ * a dataset named 'example-dataset'. The evaluation process is configured using `RunOnDatasetParams["evaluators"]`, which can
  * include both standard and custom evaluators. The `Client` instance is used to interact with LangChain services.
  * The function returns the evaluation results, which can be logged or further processed as needed.
  */
-export const runOnDataset = async (chainOrFactory, datasetName, { evaluationConfig, projectName, projectMetadata, client, maxConcurrency, }) => {
+export async function runOnDataset(chainOrFactory, datasetName, options) {
+    const { projectName, projectMetadata, client, maxConcurrency, } = options ?? {};
+    const evaluationConfig = options?.evaluationConfig ??
+        (options?.evaluators != null
+            ? {
+                evaluators: options.evaluators,
+                formatEvaluatorInputs: options.formatEvaluatorInputs,
+            }
+            : undefined);
     const wrappedModel = await createWrappedModel(chainOrFactory);
     const testClient = client ?? new Client();
     const testProjectName = projectName ?? randomName();
@@ -429,4 +557,7 @@ export const runOnDataset = async (chainOrFactory, datasetName, { evaluationConf
         results: evalResults ?? {},
     };
     return results;
-};
+}
+function isLangsmithTraceableFunction(x) {
+    return typeof x === "function" && "langsmith:traceable" in x;
+}

package/document_loaders/web/couchbase.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/document_loaders/web/couchbase.cjs');

package/document_loaders/web/couchbase.d.cts

@@ -0,0 +1 @@
+export * from '../../dist/document_loaders/web/couchbase.js'

package/document_loaders/web/couchbase.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/document_loaders/web/couchbase.js'

package/document_loaders/web/couchbase.js

@@ -0,0 +1 @@
+export * from '../../dist/document_loaders/web/couchbase.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.1.19-rc.0",
+  "version": "0.1.19-rc.2",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {
@@ -614,6 +614,10 @@
     "document_loaders/web/confluence.js",
     "document_loaders/web/confluence.d.ts",
     "document_loaders/web/confluence.d.cts",
+    "document_loaders/web/couchbase.cjs",
+    "document_loaders/web/couchbase.js",
+    "document_loaders/web/couchbase.d.ts",
+    "document_loaders/web/couchbase.d.cts",
     "document_loaders/web/searchapi.cjs",
     "document_loaders/web/searchapi.js",
     "document_loaders/web/searchapi.d.ts",
@@ -1247,6 +1251,7 @@
     "cheerio": "^1.0.0-rc.12",
     "chromadb": "^1.5.3",
     "convex": "^1.3.1",
+    "couchbase": "^4.2.10",
     "d3-dsv": "^2.0.0",
     "dotenv": "^16.0.3",
     "dpdm": "^3.12.0",
@@ -1317,6 +1322,7 @@
     "cheerio": "^1.0.0-rc.12",
     "chromadb": "*",
     "convex": "^1.3.1",
+    "couchbase": "^4.2.10",
     "d3-dsv": "^2.0.0",
     "epub2": "^3.0.1",
     "fast-xml-parser": "^4.2.7",
@@ -1411,6 +1417,9 @@
     "convex": {
       "optional": true
     },
+    "couchbase": {
+      "optional": true
+    },
     "d3-dsv": {
       "optional": true
     },
@@ -1504,8 +1513,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.9.1",
-    "@langchain/community": "~0.0.28",
-    "@langchain/core": "~0.1.28",
+    "@langchain/community": "~0.0.29",
+    "@langchain/core": "~0.1.29",
     "@langchain/openai": "~0.0.14",
     "binary-extensions": "^2.2.0",
     "expr-eval": "^2.0.2",
@@ -1513,7 +1522,7 @@
     "js-yaml": "^4.1.0",
     "jsonpointer": "^5.0.1",
     "langchainhub": "~0.0.8",
-    "langsmith": "~0.0.59",
+    "langsmith": "~0.1.1",
     "ml-distance": "^4.0.0",
     "openapi-types": "^12.1.3",
     "p-retry": "4",
@@ -2899,6 +2908,15 @@
       "import": "./document_loaders/web/confluence.js",
       "require": "./document_loaders/web/confluence.cjs"
     },
+    "./document_loaders/web/couchbase": {
+      "types": {
+        "import": "./document_loaders/web/couchbase.d.ts",
+        "require": "./document_loaders/web/couchbase.d.cts",
+        "default": "./document_loaders/web/couchbase.d.ts"
+      },
+      "import": "./document_loaders/web/couchbase.js",
+      "require": "./document_loaders/web/couchbase.cjs"
+    },
     "./document_loaders/web/searchapi": {
       "types": {
         "import": "./document_loaders/web/searchapi.d.ts",