langsmith 0.1.26 → 0.1.28

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

@@ -226,6 +226,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {

package/dist/evaluation/_runner.js

@@ -222,6 +222,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {

package/dist/evaluation/langchain.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLangchainStringEvaluator = void 0;
+const evaluation_1 = require("langchain/evaluation");
+const langchain_js_1 = require("../langchain.cjs");
+function isStringifiable(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint");
+}
+// utility methods for extracting stringified values
+// from unknown inputs and records
+function getPrimitiveValue(value) {
+    if (isStringifiable(value))
+        return String(value);
+    if (!Array.isArray(value) && typeof value === "object" && value != null) {
+        const values = Object.values(value);
+        if (values.length === 1 && isStringifiable(values[0])) {
+            return String(values[0]);
+        }
+    }
+    return undefined;
+}
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+async function getLangchainStringEvaluator(type, options) {
+    const evaluator = await (0, evaluation_1.loadEvaluator)(type, options);
+    const feedbackKey = getPrimitiveValue(options.criteria) ?? type;
+    const formatEvaluatorInputs = options.formatEvaluatorInputs ??
+        ((run, example) => {
+            const prediction = getPrimitiveValue(run.outputs);
+            const reference = getPrimitiveValue(example.outputs);
+            const input = getPrimitiveValue(example.inputs);
+            if (prediction == null)
+                throw new Error("Missing prediction");
+            if (type === "criteria")
+                return { prediction, input };
+            return { prediction, reference, input };
+        });
+    return async (run, example) => {
+        const score = await evaluator.evaluateStrings(formatEvaluatorInputs(run, example), { callbacks: await (0, langchain_js_1.getLangchainCallbacks)() });
+        return { key: feedbackKey, ...score };
+    };
+}
+exports.getLangchainStringEvaluator = getLangchainStringEvaluator;

package/dist/evaluation/langchain.d.ts

@@ -0,0 +1,19 @@
+import type { Run, Example } from "../schemas.js";
+import { type LoadEvaluatorOptions } from "langchain/evaluation";
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+export declare function getLangchainStringEvaluator(type: "criteria" | "labeled_criteria", options: LoadEvaluatorOptions & {
+    formatEvaluatorInputs?: (run: Run, example: Example) => {
+        prediction: string;
+        reference?: string;
+        input?: string;
+    };
+}): Promise<(run: Run, example: Example) => Promise<{
+    key: string;
+}>>;

package/dist/evaluation/langchain.js

@@ -0,0 +1,48 @@
+import { loadEvaluator } from "langchain/evaluation";
+import { getLangchainCallbacks } from "../langchain.js";
+function isStringifiable(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint");
+}
+// utility methods for extracting stringified values
+// from unknown inputs and records
+function getPrimitiveValue(value) {
+    if (isStringifiable(value))
+        return String(value);
+    if (!Array.isArray(value) && typeof value === "object" && value != null) {
+        const values = Object.values(value);
+        if (values.length === 1 && isStringifiable(values[0])) {
+            return String(values[0]);
+        }
+    }
+    return undefined;
+}
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+export async function getLangchainStringEvaluator(type, options) {
+    const evaluator = await loadEvaluator(type, options);
+    const feedbackKey = getPrimitiveValue(options.criteria) ?? type;
+    const formatEvaluatorInputs = options.formatEvaluatorInputs ??
+        ((run, example) => {
+            const prediction = getPrimitiveValue(run.outputs);
+            const reference = getPrimitiveValue(example.outputs);
+            const input = getPrimitiveValue(example.inputs);
+            if (prediction == null)
+                throw new Error("Missing prediction");
+            if (type === "criteria")
+                return { prediction, input };
+            return { prediction, reference, input };
+        });
+    return async (run, example) => {
+        const score = await evaluator.evaluateStrings(formatEvaluatorInputs(run, example), { callbacks: await getLangchainCallbacks() });
+        return { key: feedbackKey, ...score };
+    };
+}

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.26";
+exports.__version__ = "0.1.28";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.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.26";
+export declare const __version__ = "0.1.28";

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.26";
+export const __version__ = "0.1.28";

package/dist/langchain.cjs

@@ -0,0 +1,126 @@
+"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");
+const asserts_js_1 = require("./utils/asserts.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);
+        const callbacks = await (0, runnables_1.getCallbackManagerForConfig)(config);
+        return (await this.func((0, runnables_1.patchConfig)(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if ((0, asserts_js_1.isAsyncIterable)(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if ((0, asserts_js_1.isIteratorLike)(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+exports.RunnableTraceable = RunnableTraceable;

package/dist/langchain.d.ts

@@ -0,0 +1,30 @@
+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>;
+    _streamIterator(input: RunInput, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
+    static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
+}
+export {};

package/dist/langchain.js

@@ -0,0 +1,121 @@
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import { Runnable, patchConfig, getCallbackManagerForConfig, } from "@langchain/core/runnables";
+import { getCurrentRunTree, isTraceableFunction, } from "./traceable.js";
+import { isAsyncIterable, isIteratorLike } from "./utils/asserts.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);
+        const callbacks = await getCallbackManagerForConfig(config);
+        return (await this.func(patchConfig(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if (isAsyncIterable(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if (isIteratorLike(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}

package/dist/run_trees.cjs

@@ -27,13 +27,8 @@ exports.isRunnableConfigLike = exports.isRunTree = exports.RunTree = exports.con
 const uuid = __importStar(require("uuid"));
 const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+const env_js_2 = require("./env.cjs");
+const warn_js_1 = require("./utils/warn.cjs");
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -208,34 +203,52 @@ class RunTree {
             }
         }
     }
-    static fromRunnableConfig(config, props) {
+    static fromRunnableConfig(parentConfig, props) {
         // We only handle the callback manager case for now
-        const callbackManager = config?.callbacks;
+        const callbackManager = parentConfig?.callbacks;
         let parentRun;
         let projectName;
+        let client;
+        let tracingEnabled = (0, env_js_2.isTracingEnabled)();
         if (callbackManager) {
             const parentRunId = callbackManager?.getParentRunId?.() ?? "";
             const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
+            client = langChainTracer?.client;
+            tracingEnabled = tracingEnabled || !!langChainTracer;
         }
-        const dedupedTags = [
-            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
-        ];
-        const dedupedMetadata = {
-            ...parentRun?.extra?.metadata,
-            ...config?.metadata,
-        };
-        const rt = new RunTree({
-            name: props?.name ?? "<lambda>",
-            parent_run: parentRun,
-            tags: dedupedTags,
+        if (!parentRun) {
+            return new RunTree({
+                client,
+                tracingEnabled,
+                project_name: projectName,
+                name: props.name,
+                tags: props.tags,
+                metadata: props.metadata,
+            });
+        }
+        const parentRunTree = new RunTree({
+            name: parentRun.name,
+            id: parentRun.id,
+            client,
+            tracingEnabled,
+            project_name: projectName,
+            tags: [
+                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
+            ],
             extra: {
-                metadata: dedupedMetadata,
+                metadata: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
             },
-            project_name: projectName,
         });
-        return rt;
+        return parentRunTree.createChild({
+            name: props.name,
+            tags: props.tags,
+            metadata: props.metadata,
+        });
     }
     static getDefaultConfig() {
         return {
@@ -329,7 +342,7 @@ class RunTree {
         const runCreate = await this._convertToCreate(this, runtimeEnv, true);
         await this.client.createRun(runCreate);
         if (!excludeChildRuns) {
-            warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
+            (0, warn_js_1.warnOnce)("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
             for (const childRun of this.child_runs) {
                 await childRun.postRun(false);
             }

package/dist/run_trees.d.ts

@@ -66,7 +66,7 @@ export declare class RunTree implements BaseRun {
     execution_order: number;
     child_execution_order: number;
     constructor(originalConfig: RunTreeConfig);
-    static fromRunnableConfig(config: RunnableConfigLike, props: {
+    static fromRunnableConfig(parentConfig: RunnableConfigLike, props: {
         name: string;
         tags?: string[];
         metadata?: KVMap;

package/dist/run_trees.js

@@ -1,13 +1,8 @@
 import * as uuid from "uuid";
 import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { Client } from "./client.js";
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+import { isTracingEnabled } from "./env.js";
+import { warnOnce } from "./utils/warn.js";
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -181,34 +176,52 @@ export class RunTree {
             }
         }
     }
-    static fromRunnableConfig(config, props) {
+    static fromRunnableConfig(parentConfig, props) {
         // We only handle the callback manager case for now
-        const callbackManager = config?.callbacks;
+        const callbackManager = parentConfig?.callbacks;
         let parentRun;
         let projectName;
+        let client;
+        let tracingEnabled = isTracingEnabled();
         if (callbackManager) {
             const parentRunId = callbackManager?.getParentRunId?.() ?? "";
             const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
+            client = langChainTracer?.client;
+            tracingEnabled = tracingEnabled || !!langChainTracer;
         }
-        const dedupedTags = [
-            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
-        ];
-        const dedupedMetadata = {
-            ...parentRun?.extra?.metadata,
-            ...config?.metadata,
-        };
-        const rt = new RunTree({
-            name: props?.name ?? "<lambda>",
-            parent_run: parentRun,
-            tags: dedupedTags,
+        if (!parentRun) {
+            return new RunTree({
+                client,
+                tracingEnabled,
+                project_name: projectName,
+                name: props.name,
+                tags: props.tags,
+                metadata: props.metadata,
+            });
+        }
+        const parentRunTree = new RunTree({
+            name: parentRun.name,
+            id: parentRun.id,
+            client,
+            tracingEnabled,
+            project_name: projectName,
+            tags: [
+                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
+            ],
             extra: {
-                metadata: dedupedMetadata,
+                metadata: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
             },
-            project_name: projectName,
         });
-        return rt;
+        return parentRunTree.createChild({
+            name: props.name,
+            tags: props.tags,
+            metadata: props.metadata,
+        });
     }
     static getDefaultConfig() {
         return {