langsmith 0.1.25 → 0.1.27

package/dist/client.cjs

@@ -1185,6 +1185,14 @@ class Client {
         const tenantId = await this._getTenantId();
         return `${this.getHostUrl()}/o/${tenantId}/projects/p/${project.id}`;
     }
+    async getDatasetUrl({ datasetId, datasetName, }) {
+        if (datasetId === undefined && datasetName === undefined) {
+            throw new Error("Must provide either datasetName or datasetId");
+        }
+        const dataset = await this.readDataset({ datasetId, datasetName });
+        const tenantId = await this._getTenantId();
+        return `${this.getHostUrl()}/o/${tenantId}/datasets/${dataset.id}`;
+    }
     async _getTenantId() {
         if (this._tenantId !== null) {
             return this._tenantId;
@@ -1443,7 +1451,7 @@ class Client {
         }
         await response.json();
     }
-    async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, }) {
+    async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, split, }) {
         let datasetId_ = datasetId;
         if (datasetId_ === undefined && datasetName === undefined) {
             throw new Error("Must provide either datasetName or datasetId");
@@ -1463,6 +1471,7 @@ class Client {
             created_at: createdAt_?.toISOString(),
             id: exampleId,
             metadata,
+            split,
         };
         const response = await this.caller.call(fetch, `${this.apiUrl}/examples`, {
             method: "POST",
@@ -1496,6 +1505,7 @@ class Client {
                 inputs: input,
                 outputs: outputs ? outputs[idx] : undefined,
                 metadata: metadata ? metadata[idx] : undefined,
+                split: props.splits ? props.splits[idx] : undefined,
                 id: exampleIds ? exampleIds[idx] : undefined,
                 source_run_id: sourceRunIds ? sourceRunIds[idx] : undefined,
             };
@@ -1533,7 +1543,7 @@ class Client {
         const path = `/examples/${exampleId}`;
         return await this._get(path);
     }
-    async *listExamples({ datasetId, datasetName, exampleIds, asOf, inlineS3Urls, metadata, } = {}) {
+    async *listExamples({ datasetId, datasetName, exampleIds, asOf, splits, inlineS3Urls, metadata, } = {}) {
         let datasetId_;
         if (datasetId !== undefined && datasetName !== undefined) {
             throw new Error("Must provide either datasetName or datasetId, not both");
@@ -1564,6 +1574,11 @@ class Client {
                 params.append("id", id_);
             }
         }
+        if (splits !== undefined) {
+            for (const split of splits) {
+                params.append("splits", split);
+            }
+        }
         if (metadata !== undefined) {
             const serializedMetadata = JSON.stringify(metadata);
             params.append("metadata", serializedMetadata);

package/dist/client.d.ts

@@ -145,6 +145,7 @@ export type CreateExampleOptions = {
     createdAt?: Date;
     exampleId?: string;
     metadata?: KVMap;
+    split?: string | string[];
 };
 export declare class Queue<T> {
     items: [T, () => void][];
@@ -338,6 +339,10 @@ export declare class Client {
         projectId?: string;
         projectName?: string;
     }): Promise<string>;
+    getDatasetUrl({ datasetId, datasetName, }: {
+        datasetId?: string;
+        datasetName?: string;
+    }): Promise<string>;
     private _getTenantId;
     listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree, }?: {
         projectIds?: string[];
@@ -385,11 +390,12 @@ export declare class Client {
         datasetId?: string;
         datasetName?: string;
     }): Promise<void>;
-    createExample(inputs: KVMap, outputs: KVMap, { datasetId, datasetName, createdAt, exampleId, metadata, }: CreateExampleOptions): Promise<Example>;
+    createExample(inputs: KVMap, outputs: KVMap, { datasetId, datasetName, createdAt, exampleId, metadata, split, }: CreateExampleOptions): Promise<Example>;
     createExamples(props: {
         inputs: Array<KVMap>;
         outputs?: Array<KVMap>;
         metadata?: Array<KVMap>;
+        splits?: Array<string | Array<string>>;
         sourceRunIds?: Array<string>;
         exampleIds?: Array<string>;
         datasetId?: string;
@@ -398,11 +404,12 @@ export declare class Client {
     createLLMExample(input: string, generation: string | undefined, options: CreateExampleOptions): Promise<Example>;
     createChatExample(input: KVMap[] | LangChainBaseMessage[], generations: KVMap | LangChainBaseMessage | undefined, options: CreateExampleOptions): Promise<Example>;
     readExample(exampleId: string): Promise<Example>;
-    listExamples({ datasetId, datasetName, exampleIds, asOf, inlineS3Urls, metadata, }?: {
+    listExamples({ datasetId, datasetName, exampleIds, asOf, splits, inlineS3Urls, metadata, }?: {
         datasetId?: string;
         datasetName?: string;
         exampleIds?: string[];
         asOf?: string | Date;
+        splits?: string[];
         inlineS3Urls?: boolean;
         metadata?: KVMap;
     }): AsyncIterable<Example>;

package/dist/client.js

@@ -1158,6 +1158,14 @@ export class Client {
         const tenantId = await this._getTenantId();
         return `${this.getHostUrl()}/o/${tenantId}/projects/p/${project.id}`;
     }
+    async getDatasetUrl({ datasetId, datasetName, }) {
+        if (datasetId === undefined && datasetName === undefined) {
+            throw new Error("Must provide either datasetName or datasetId");
+        }
+        const dataset = await this.readDataset({ datasetId, datasetName });
+        const tenantId = await this._getTenantId();
+        return `${this.getHostUrl()}/o/${tenantId}/datasets/${dataset.id}`;
+    }
     async _getTenantId() {
         if (this._tenantId !== null) {
             return this._tenantId;
@@ -1416,7 +1424,7 @@ export class Client {
         }
         await response.json();
     }
-    async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, }) {
+    async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, split, }) {
         let datasetId_ = datasetId;
         if (datasetId_ === undefined && datasetName === undefined) {
             throw new Error("Must provide either datasetName or datasetId");
@@ -1436,6 +1444,7 @@ export class Client {
             created_at: createdAt_?.toISOString(),
             id: exampleId,
             metadata,
+            split,
         };
         const response = await this.caller.call(fetch, `${this.apiUrl}/examples`, {
             method: "POST",
@@ -1469,6 +1478,7 @@ export class Client {
                 inputs: input,
                 outputs: outputs ? outputs[idx] : undefined,
                 metadata: metadata ? metadata[idx] : undefined,
+                split: props.splits ? props.splits[idx] : undefined,
                 id: exampleIds ? exampleIds[idx] : undefined,
                 source_run_id: sourceRunIds ? sourceRunIds[idx] : undefined,
             };
@@ -1506,7 +1516,7 @@ export class Client {
         const path = `/examples/${exampleId}`;
         return await this._get(path);
     }
-    async *listExamples({ datasetId, datasetName, exampleIds, asOf, inlineS3Urls, metadata, } = {}) {
+    async *listExamples({ datasetId, datasetName, exampleIds, asOf, splits, inlineS3Urls, metadata, } = {}) {
         let datasetId_;
         if (datasetId !== undefined && datasetName !== undefined) {
             throw new Error("Must provide either datasetName or datasetId, not both");
@@ -1537,6 +1547,11 @@ export class Client {
                 params.append("id", id_);
             }
         }
+        if (splits !== undefined) {
+            for (const split of splits) {
+                params.append("splits", split);
+            }
+        }
         if (metadata !== undefined) {
             const serializedMetadata = JSON.stringify(metadata);
             params.append("metadata", serializedMetadata);

package/dist/env.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTracingEnabled = void 0;
+const env_js_1 = require("./utils/env.cjs");
+const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => (0, env_js_1.getEnvironmentVariable)(envVar) === "true");
+};
+exports.isTracingEnabled = isTracingEnabled;

package/dist/env.d.ts

@@ -0,0 +1 @@
+export declare const isTracingEnabled: (tracingEnabled?: boolean) => boolean;

package/dist/env.js

@@ -0,0 +1,13 @@
+import { getEnvironmentVariable } from "./utils/env.js";
+export const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => getEnvironmentVariable(envVar) === "true");
+};

package/dist/evaluation/_runner.cjs

@@ -8,6 +8,7 @@ const _uuid_js_1 = require("../utils/_uuid.cjs");
 const async_caller_js_1 = require("../utils/async_caller.cjs");
 const atee_js_1 = require("../utils/atee.cjs");
 const env_js_1 = require("../utils/env.cjs");
+const error_js_1 = require("../utils/error.cjs");
 const _random_name_js_1 = require("./_random_name.cjs");
 const evaluator_js_1 = require("./evaluator.cjs");
 const uuid_1 = require("uuid");
@@ -238,15 +239,21 @@ class _ExperimentManager {
         }
         return project;
     }
-    _printExperimentStart() {
-        // @TODO log with experiment URL
+    async _printExperimentStart() {
         console.log(`Starting evaluation of experiment: ${this.experimentName}`);
+        const firstExample = this._examples?.[0];
+        const datasetId = firstExample?.dataset_id;
+        if (!datasetId || !this._experiment)
+            return;
+        const datasetUrl = await this.client.getDatasetUrl({ datasetId });
+        const compareUrl = `${datasetUrl}/compare?selectedSessions=${this._experiment.id}`;
+        console.log(`View results at ${compareUrl}`);
     }
     async start() {
         const examples = await this.getExamples();
         const firstExample = examples[0];
         const project = await this._getProject(firstExample);
-        this._printExperimentStart();
+        await this._printExperimentStart();
         return new _ExperimentManager({
             examples,
             experiment: project,
@@ -390,6 +397,7 @@ class _ExperimentManager {
             }
             catch (e) {
                 console.error(`Error running evaluator ${evaluator.evaluateRun.name} on run ${run.id}: ${e}`);
+                (0, error_js_1.printErrorStackTrace)(e);
             }
         }
         return {
@@ -458,6 +466,7 @@ class _ExperimentManager {
                 }
                 catch (e) {
                     console.error(`Error running summary evaluator ${evaluator.name}: ${JSON.stringify(e, null, 2)}`);
+                    (0, error_js_1.printErrorStackTrace)(e);
                 }
             }
             yield {
@@ -493,6 +502,21 @@ class _ExperimentManager {
             return undefined;
         return modifiedAtTime.reduce((max, current) => (current.time > max.time ? current : max), modifiedAtTime[0]).date;
     }
+    async _getDatasetSplits() {
+        const examples = await this.getExamples();
+        const allSplits = examples.reduce((acc, ex) => {
+            if (ex.metadata && ex.metadata.dataset_split) {
+                if (Array.isArray(ex.metadata.dataset_split)) {
+                    ex.metadata.dataset_split.forEach((split) => acc.add(split));
+                }
+                else if (typeof ex.metadata.dataset_split === "string") {
+                    acc.add(ex.metadata.dataset_split);
+                }
+            }
+            return acc;
+        }, new Set());
+        return allSplits.size ? Array.from(allSplits) : undefined;
+    }
     async _end() {
         const experiment = this._experiment;
         if (!experiment) {
@@ -500,6 +524,7 @@ class _ExperimentManager {
         }
         const projectMetadata = await this._getExperimentMetadata();
         projectMetadata["dataset_version"] = await this._getDatasetVersion();
+        projectMetadata["dataset_splits"] = await this._getDatasetSplits();
         // Update revision_id if not already set
         if (!projectMetadata["revision_id"]) {
             projectMetadata["revision_id"] = await (0, _git_js_1.getDefaultRevisionId)();
@@ -631,6 +656,7 @@ async function _forward(fn, example, experimentName, metadata, client) {
     }
     catch (e) {
         console.error(`Error running target function: ${e}`);
+        (0, error_js_1.printErrorStackTrace)(e);
     }
     if (!run) {
         throw new Error(`Run not created by target function.

package/dist/evaluation/_runner.d.ts

@@ -104,7 +104,7 @@ declare class _ExperimentManager {
     _getExperiment(): TracerSession;
     _getExperimentMetadata(): Promise<KVMap>;
     _getProject(firstExample: Example): Promise<TracerSession>;
-    _printExperimentStart(): void;
+    protected _printExperimentStart(): Promise<void>;
     start(): Promise<_ExperimentManager>;
     withPredictions(target: TargetNoInvoke, options?: {
         maxConcurrency?: number;
@@ -139,6 +139,7 @@ declare class _ExperimentManager {
     }): AsyncGenerator<ExperimentResultRow>;
     _applySummaryEvaluators(summaryEvaluators: Array<SummaryEvaluatorT>): AsyncGenerator<(runsArray: Run[]) => AsyncGenerator<EvaluationResults>>;
     _getDatasetVersion(): Promise<string | undefined>;
+    _getDatasetSplits(): Promise<string[] | undefined>;
     _end(): Promise<void>;
 }
 /**

package/dist/evaluation/_runner.js

@@ -5,6 +5,7 @@ import { assertUuid } from "../utils/_uuid.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { atee } from "../utils/atee.js";
 import { getLangChainEnvVarsMetadata } from "../utils/env.js";
+import { printErrorStackTrace } from "../utils/error.js";
 import { randomName } from "./_random_name.js";
 import { runEvaluator, } from "./evaluator.js";
 import { v4 as uuidv4 } from "uuid";
@@ -234,15 +235,21 @@ class _ExperimentManager {
         }
         return project;
     }
-    _printExperimentStart() {
-        // @TODO log with experiment URL
+    async _printExperimentStart() {
         console.log(`Starting evaluation of experiment: ${this.experimentName}`);
+        const firstExample = this._examples?.[0];
+        const datasetId = firstExample?.dataset_id;
+        if (!datasetId || !this._experiment)
+            return;
+        const datasetUrl = await this.client.getDatasetUrl({ datasetId });
+        const compareUrl = `${datasetUrl}/compare?selectedSessions=${this._experiment.id}`;
+        console.log(`View results at ${compareUrl}`);
     }
     async start() {
         const examples = await this.getExamples();
         const firstExample = examples[0];
         const project = await this._getProject(firstExample);
-        this._printExperimentStart();
+        await this._printExperimentStart();
         return new _ExperimentManager({
             examples,
             experiment: project,
@@ -386,6 +393,7 @@ class _ExperimentManager {
             }
             catch (e) {
                 console.error(`Error running evaluator ${evaluator.evaluateRun.name} on run ${run.id}: ${e}`);
+                printErrorStackTrace(e);
             }
         }
         return {
@@ -454,6 +462,7 @@ class _ExperimentManager {
                 }
                 catch (e) {
                     console.error(`Error running summary evaluator ${evaluator.name}: ${JSON.stringify(e, null, 2)}`);
+                    printErrorStackTrace(e);
                 }
             }
             yield {
@@ -489,6 +498,21 @@ class _ExperimentManager {
             return undefined;
         return modifiedAtTime.reduce((max, current) => (current.time > max.time ? current : max), modifiedAtTime[0]).date;
     }
+    async _getDatasetSplits() {
+        const examples = await this.getExamples();
+        const allSplits = examples.reduce((acc, ex) => {
+            if (ex.metadata && ex.metadata.dataset_split) {
+                if (Array.isArray(ex.metadata.dataset_split)) {
+                    ex.metadata.dataset_split.forEach((split) => acc.add(split));
+                }
+                else if (typeof ex.metadata.dataset_split === "string") {
+                    acc.add(ex.metadata.dataset_split);
+                }
+            }
+            return acc;
+        }, new Set());
+        return allSplits.size ? Array.from(allSplits) : undefined;
+    }
     async _end() {
         const experiment = this._experiment;
         if (!experiment) {
@@ -496,6 +520,7 @@ class _ExperimentManager {
         }
         const projectMetadata = await this._getExperimentMetadata();
         projectMetadata["dataset_version"] = await this._getDatasetVersion();
+        projectMetadata["dataset_splits"] = await this._getDatasetSplits();
         // Update revision_id if not already set
         if (!projectMetadata["revision_id"]) {
             projectMetadata["revision_id"] = await getDefaultRevisionId();
@@ -627,6 +652,7 @@ async function _forward(fn, example, experimentName, metadata, client) {
     }
     catch (e) {
         console.error(`Error running target function: ${e}`);
+        printErrorStackTrace(e);
     }
     if (!run) {
         throw new Error(`Run not created by target function.

package/dist/index.cjs

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "Client", { enumerable: true, get: function () {
 var run_trees_js_1 = require("./run_trees.cjs");
 Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () { return run_trees_js_1.RunTree; } });
 // Update using yarn bump-version
-exports.__version__ = "0.1.25";
+exports.__version__ = "0.1.27";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
-export type { Dataset, Example, TracerSession, Run, Feedback, } from "./schemas.js";
+export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
-export declare const __version__ = "0.1.25";
+export declare const __version__ = "0.1.27";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 // Update using yarn bump-version
-export const __version__ = "0.1.25";
+export const __version__ = "0.1.27";

package/dist/langchain.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnableTraceable = exports.getLangchainCallbacks = void 0;
+const manager_1 = require("@langchain/core/callbacks/manager");
+const tracer_langchain_1 = require("@langchain/core/tracers/tracer_langchain");
+const runnables_1 = require("@langchain/core/runnables");
+const traceable_js_1 = require("./traceable.cjs");
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+async function getLangchainCallbacks(currentRunTree) {
+    const runTree = currentRunTree ?? (0, traceable_js_1.getCurrentRunTree)();
+    if (!runTree)
+        return undefined;
+    // TODO: CallbackManager.configure() is only async due to LangChainTracer
+    // factory being unnecessarily async.
+    let callbacks = await manager_1.CallbackManager.configure();
+    if (!callbacks && runTree.tracingEnabled) {
+        callbacks = new manager_1.CallbackManager();
+    }
+    let langChainTracer = callbacks?.handlers.find((handler) => handler?.name === "langchain_tracer");
+    if (!langChainTracer && runTree.tracingEnabled) {
+        langChainTracer = new tracer_langchain_1.LangChainTracer();
+        callbacks?.addHandler(langChainTracer);
+    }
+    const runMap = new Map();
+    // find upward root run
+    let rootRun = runTree;
+    const rootVisited = new Set();
+    while (rootRun.parent_run) {
+        if (rootVisited.has(rootRun.id))
+            break;
+        rootVisited.add(rootRun.id);
+        rootRun = rootRun.parent_run;
+    }
+    const queue = [rootRun];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current.id))
+            continue;
+        visited.add(current.id);
+        runMap.set(current.id, current);
+        if (current.child_runs) {
+            queue.push(...current.child_runs);
+        }
+    }
+    if (callbacks != null) {
+        Object.assign(callbacks, { _parentRunId: runTree.id });
+    }
+    if (langChainTracer != null) {
+        Object.assign(langChainTracer, {
+            runMap,
+            client: runTree.client,
+            projectName: runTree.project_name || langChainTracer.projectName,
+            exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+        });
+    }
+    return callbacks;
+}
+exports.getLangchainCallbacks = getLangchainCallbacks;
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+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 (!(0, traceable_js_1.isTraceableFunction)(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);
+        return (await this.func(config, input));
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+exports.RunnableTraceable = RunnableTraceable;

package/dist/langchain.d.ts

@@ -0,0 +1,29 @@
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { RunTree } from "./run_trees.js";
+import { TraceableFunction } from "./traceable.js";
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+export declare function getLangchainCallbacks(currentRunTree?: RunTree | undefined): Promise<CallbackManager | undefined>;
+type AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    lc_serializable: boolean;
+    lc_namespace: string[];
+    protected func: AnyTraceableFunction;
+    constructor(fields: {
+        func: AnyTraceableFunction;
+    });
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
+}
+export {};

package/dist/langchain.js

@@ -0,0 +1,100 @@
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import { Runnable } from "@langchain/core/runnables";
+import { getCurrentRunTree, isTraceableFunction, } from "./traceable.js";
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+export async function getLangchainCallbacks(currentRunTree) {
+    const runTree = currentRunTree ?? getCurrentRunTree();
+    if (!runTree)
+        return undefined;
+    // TODO: CallbackManager.configure() is only async due to LangChainTracer
+    // factory being unnecessarily async.
+    let callbacks = await CallbackManager.configure();
+    if (!callbacks && runTree.tracingEnabled) {
+        callbacks = new CallbackManager();
+    }
+    let langChainTracer = callbacks?.handlers.find((handler) => handler?.name === "langchain_tracer");
+    if (!langChainTracer && runTree.tracingEnabled) {
+        langChainTracer = new LangChainTracer();
+        callbacks?.addHandler(langChainTracer);
+    }
+    const runMap = new Map();
+    // find upward root run
+    let rootRun = runTree;
+    const rootVisited = new Set();
+    while (rootRun.parent_run) {
+        if (rootVisited.has(rootRun.id))
+            break;
+        rootVisited.add(rootRun.id);
+        rootRun = rootRun.parent_run;
+    }
+    const queue = [rootRun];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current.id))
+            continue;
+        visited.add(current.id);
+        runMap.set(current.id, current);
+        if (current.child_runs) {
+            queue.push(...current.child_runs);
+        }
+    }
+    if (callbacks != null) {
+        Object.assign(callbacks, { _parentRunId: runTree.id });
+    }
+    if (langChainTracer != null) {
+        Object.assign(langChainTracer, {
+            runMap,
+            client: runTree.client,
+            projectName: runTree.project_name || langChainTracer.projectName,
+            exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+        });
+    }
+    return callbacks;
+}
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+export 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 (!isTraceableFunction(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);
+        return (await this.func(config, input));
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}