langsmith 0.1.27 → 0.1.30

package/dist/evaluation/_runner.cjs

@@ -48,7 +48,16 @@ class _ExperimentManager {
             for await (const example of unresolvedData) {
                 exs.push(example);
             }
-            this.setExamples(exs);
+            if (this._numRepetitions && this._numRepetitions > 0) {
+                const repeatedExamples = [];
+                for (let i = 0; i < this._numRepetitions; i++) {
+                    repeatedExamples.push(...exs);
+                }
+                this.setExamples(repeatedExamples);
+            }
+            else {
+                this.setExamples(exs);
+            }
         }
         return this._examples;
     }
@@ -120,6 +129,12 @@ class _ExperimentManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_numRepetitions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_runsArray", {
             enumerable: true,
             configurable: true,
@@ -188,6 +203,7 @@ class _ExperimentManager {
         this._runs = args.runs;
         this._evaluationResults = args.evaluationResults;
         this._summaryResults = args.summaryResults;
+        this._numRepetitions = args.numRepetitions;
     }
     _getExperiment() {
         if (!this._experiment) {
@@ -226,6 +242,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {
@@ -254,6 +271,7 @@ class _ExperimentManager {
         const firstExample = examples[0];
         const project = await this._getProject(firstExample);
         await this._printExperimentStart();
+        this._metadata["num_repetitions"] = this._numRepetitions;
         return new _ExperimentManager({
             examples,
             experiment: project,
@@ -613,6 +631,7 @@ async function _evaluate(target, fields) {
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,
         runs: newRuns ?? undefined,
+        numRepetitions: fields.numRepetitions ?? 1,
     }).start();
     if (_isCallable(target)) {
         manager = await manager.withPredictions(convertInvokeToTopLevel(target), { maxConcurrency: fields.maxConcurrency });

package/dist/evaluation/_runner.d.ts

@@ -23,6 +23,7 @@ interface _ExperimentManagerArgs {
     evaluationResults?: AsyncGenerator<EvaluationResults>;
     summaryResults?: AsyncGenerator<(runsArray: Run[]) => AsyncGenerator<EvaluationResults, any, unknown>, any, unknown>;
     examples?: Example[];
+    numRepetitions?: number;
     _runsArray?: Run[];
 }
 export interface EvaluateOptions {
@@ -65,6 +66,12 @@ export interface EvaluateOptions {
      * @default undefined
      */
     client?: Client;
+    /**
+     * The number of repetitions to perform. Each example
+     * will be run this many times.
+     * @default 1
+     */
+    numRepetitions?: number;
 }
 export declare function evaluate(
 /**
@@ -88,6 +95,7 @@ declare class _ExperimentManager {
     _evaluationResults?: AsyncGenerator<EvaluationResults>;
     _summaryResults?: AsyncGenerator<(runsArray: Run[]) => AsyncGenerator<EvaluationResults, any, unknown>, any, unknown>;
     _examples?: Example[];
+    _numRepetitions?: number;
     _runsArray?: Run[];
     client: Client;
     _experiment?: TracerSession;

package/dist/evaluation/_runner.js

@@ -44,7 +44,16 @@ class _ExperimentManager {
             for await (const example of unresolvedData) {
                 exs.push(example);
             }
-            this.setExamples(exs);
+            if (this._numRepetitions && this._numRepetitions > 0) {
+                const repeatedExamples = [];
+                for (let i = 0; i < this._numRepetitions; i++) {
+                    repeatedExamples.push(...exs);
+                }
+                this.setExamples(repeatedExamples);
+            }
+            else {
+                this.setExamples(exs);
+            }
         }
         return this._examples;
     }
@@ -116,6 +125,12 @@ class _ExperimentManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_numRepetitions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_runsArray", {
             enumerable: true,
             configurable: true,
@@ -184,6 +199,7 @@ class _ExperimentManager {
         this._runs = args.runs;
         this._evaluationResults = args.evaluationResults;
         this._summaryResults = args.summaryResults;
+        this._numRepetitions = args.numRepetitions;
     }
     _getExperiment() {
         if (!this._experiment) {
@@ -222,6 +238,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {
@@ -250,6 +267,7 @@ class _ExperimentManager {
         const firstExample = examples[0];
         const project = await this._getProject(firstExample);
         await this._printExperimentStart();
+        this._metadata["num_repetitions"] = this._numRepetitions;
         return new _ExperimentManager({
             examples,
             experiment: project,
@@ -609,6 +627,7 @@ async function _evaluate(target, fields) {
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,
         runs: newRuns ?? undefined,
+        numRepetitions: fields.numRepetitions ?? 1,
     }).start();
     if (_isCallable(target)) {
         manager = await manager.withPredictions(convertInvokeToTopLevel(target), { maxConcurrency: fields.maxConcurrency });

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.27";
+exports.__version__ = "0.1.30";

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.27";
+export declare const __version__ = "0.1.30";

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

package/dist/langchain.cjs

@@ -5,6 +5,7 @@ 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
@@ -96,7 +97,27 @@ class RunnableTraceable extends runnables_1.Runnable {
     }
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
-        return (await this.func(config, input));
+        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 });

package/dist/langchain.d.ts

@@ -24,6 +24,7 @@ export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<Run
         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

@@ -1,7 +1,8 @@
 import { CallbackManager } from "@langchain/core/callbacks/manager";
 import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
-import { Runnable } from "@langchain/core/runnables";
+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
@@ -92,7 +93,27 @@ export class RunnableTraceable extends Runnable {
     }
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
-        return (await this.func(config, input));
+        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

@@ -28,13 +28,7 @@ const uuid = __importStar(require("uuid"));
 const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
 const env_js_2 = require("./env.cjs");
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+const warn_js_1 = require("./utils/warn.cjs");
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -45,6 +39,53 @@ function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
     return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId);
 }
 exports.convertToDottedOrderFormat = convertToDottedOrderFormat;
+/**
+ * Baggage header information
+ */
+class Baggage {
+    constructor(metadata, tags) {
+        Object.defineProperty(this, "metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.metadata = metadata;
+        this.tags = tags;
+    }
+    static fromHeader(value) {
+        const items = value.split(",");
+        let metadata = {};
+        let tags = [];
+        for (const item of items) {
+            const [key, uriValue] = item.split("=");
+            const value = decodeURIComponent(uriValue);
+            if (key === "langsmith-metadata") {
+                metadata = JSON.parse(value);
+            }
+            else if (key === "langsmith-tags") {
+                tags = value.split(",");
+            }
+        }
+        return new Baggage(metadata, tags);
+    }
+    toHeader() {
+        const items = [];
+        if (this.metadata && Object.keys(this.metadata).length > 0) {
+            items.push(`langsmith-metadata=${encodeURIComponent(JSON.stringify(this.metadata))}`);
+        }
+        if (this.tags && this.tags.length > 0) {
+            items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
+        }
+        return items.join(",");
+    }
+}
 class RunTree {
     constructor(originalConfig) {
         Object.defineProperty(this, "id", {
@@ -209,43 +250,6 @@ class RunTree {
             }
         }
     }
-    static fromRunnableConfig(parentConfig, props) {
-        // We only handle the callback manager case for now
-        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 parentRunTree = new RunTree({
-            name: parentRun?.name ?? "<parent>",
-            id: parentRun?.id,
-            client,
-            tracingEnabled,
-            project_name: projectName,
-            tags: [
-                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
-            ],
-            extra: {
-                metadata: {
-                    ...parentRun?.extra?.metadata,
-                    ...parentConfig?.metadata,
-                },
-            },
-        });
-        return parentRunTree.createChild({
-            name: props?.name ?? "<lambda>",
-            tags: props.tags,
-            metadata: props.metadata,
-        });
-    }
     static getDefaultConfig() {
         return {
             id: uuid.v4(),
@@ -338,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);
             }
@@ -363,6 +367,82 @@ class RunTree {
     toJSON() {
         return this._convertToCreate(this, undefined, false);
     }
+    static fromRunnableConfig(parentConfig, props) {
+        // We only handle the callback manager case for now
+        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;
+        }
+        if (!parentRun) {
+            return new RunTree({
+                ...props,
+                client,
+                tracingEnabled,
+                project_name: projectName,
+            });
+        }
+        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: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
+            },
+        });
+        return parentRunTree.createChild(props);
+    }
+    static fromDottedOrder(dottedOrder) {
+        return this.fromHeaders({ "langsmith-trace": dottedOrder });
+    }
+    static fromHeaders(headers, inheritArgs) {
+        const headerTrace = headers["langsmith-trace"];
+        if (!headerTrace || typeof headerTrace !== "string")
+            return undefined;
+        const parentDottedOrder = headerTrace.trim();
+        const parsedDottedOrder = parentDottedOrder.split(".").map((part) => {
+            const [strTime, uuid] = part.split("Z");
+            return { strTime, time: Date.parse(strTime + "Z"), uuid };
+        });
+        const traceId = parsedDottedOrder[0].uuid;
+        const config = {
+            ...inheritArgs,
+            name: inheritArgs?.["name"] ?? "parent",
+            run_type: inheritArgs?.["run_type"] ?? "chain",
+            start_time: inheritArgs?.["start_time"] ?? Date.now(),
+            id: parsedDottedOrder.at(-1)?.uuid,
+            trace_id: traceId,
+            dotted_order: parentDottedOrder,
+        };
+        if (headers["baggage"]) {
+            const baggage = Baggage.fromHeader(headers["baggage"]);
+            config.metadata = baggage.metadata;
+            config.tags = baggage.tags;
+        }
+        return new RunTree(config);
+    }
+    toHeaders() {
+        return {
+            "langsmith-trace": this.dotted_order,
+            baggage: new Baggage(this.extra?.metadata, this.tags).toHeader(),
+        };
+    }
 }
 exports.RunTree = RunTree;
 function isRunTree(x) {

package/dist/run_trees.d.ts

@@ -24,6 +24,8 @@ export interface RunTreeConfig {
     on_end?: (runTree: RunTree) => void;
     execution_order?: number;
     child_execution_order?: number;
+    trace_id?: string;
+    dotted_order?: string;
 }
 export interface RunnableConfigLike {
     /**
@@ -66,11 +68,6 @@ export declare class RunTree implements BaseRun {
     execution_order: number;
     child_execution_order: number;
     constructor(originalConfig: RunTreeConfig);
-    static fromRunnableConfig(parentConfig: RunnableConfigLike, props: {
-        name: string;
-        tags?: string[];
-        metadata?: KVMap;
-    }): RunTree;
     private static getDefaultConfig;
     createChild(config: RunTreeConfig): RunTree;
     end(outputs?: KVMap, error?: string, endTime?: number): Promise<void>;
@@ -78,6 +75,13 @@ export declare class RunTree implements BaseRun {
     postRun(excludeChildRuns?: boolean): Promise<void>;
     patchRun(): Promise<void>;
     toJSON(): RunCreate;
+    static fromRunnableConfig(parentConfig: RunnableConfigLike, props: RunTreeConfig): RunTree;
+    static fromDottedOrder(dottedOrder: string): RunTree | undefined;
+    static fromHeaders(headers: Record<string, string>, inheritArgs?: RunTreeConfig): RunTree | undefined;
+    toHeaders(): {
+        "langsmith-trace": string;
+        baggage: string;
+    };
 }
 export declare function isRunTree(x?: unknown): x is RunTree;
 export declare function isRunnableConfigLike(x?: unknown): x is RunnableConfigLike;

package/dist/run_trees.js

@@ -2,13 +2,7 @@ import * as uuid from "uuid";
 import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { Client } from "./client.js";
 import { isTracingEnabled } from "./env.js";
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+import { warnOnce } from "./utils/warn.js";
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -18,6 +12,53 @@ export function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
     const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
     return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId);
 }
+/**
+ * Baggage header information
+ */
+class Baggage {
+    constructor(metadata, tags) {
+        Object.defineProperty(this, "metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.metadata = metadata;
+        this.tags = tags;
+    }
+    static fromHeader(value) {
+        const items = value.split(",");
+        let metadata = {};
+        let tags = [];
+        for (const item of items) {
+            const [key, uriValue] = item.split("=");
+            const value = decodeURIComponent(uriValue);
+            if (key === "langsmith-metadata") {
+                metadata = JSON.parse(value);
+            }
+            else if (key === "langsmith-tags") {
+                tags = value.split(",");
+            }
+        }
+        return new Baggage(metadata, tags);
+    }
+    toHeader() {
+        const items = [];
+        if (this.metadata && Object.keys(this.metadata).length > 0) {
+            items.push(`langsmith-metadata=${encodeURIComponent(JSON.stringify(this.metadata))}`);
+        }
+        if (this.tags && this.tags.length > 0) {
+            items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
+        }
+        return items.join(",");
+    }
+}
 export class RunTree {
     constructor(originalConfig) {
         Object.defineProperty(this, "id", {
@@ -182,43 +223,6 @@ export class RunTree {
             }
         }
     }
-    static fromRunnableConfig(parentConfig, props) {
-        // We only handle the callback manager case for now
-        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 parentRunTree = new RunTree({
-            name: parentRun?.name ?? "<parent>",
-            id: parentRun?.id,
-            client,
-            tracingEnabled,
-            project_name: projectName,
-            tags: [
-                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
-            ],
-            extra: {
-                metadata: {
-                    ...parentRun?.extra?.metadata,
-                    ...parentConfig?.metadata,
-                },
-            },
-        });
-        return parentRunTree.createChild({
-            name: props?.name ?? "<lambda>",
-            tags: props.tags,
-            metadata: props.metadata,
-        });
-    }
     static getDefaultConfig() {
         return {
             id: uuid.v4(),
@@ -336,6 +340,82 @@ export class RunTree {
     toJSON() {
         return this._convertToCreate(this, undefined, false);
     }
+    static fromRunnableConfig(parentConfig, props) {
+        // We only handle the callback manager case for now
+        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;
+        }
+        if (!parentRun) {
+            return new RunTree({
+                ...props,
+                client,
+                tracingEnabled,
+                project_name: projectName,
+            });
+        }
+        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: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
+            },
+        });
+        return parentRunTree.createChild(props);
+    }
+    static fromDottedOrder(dottedOrder) {
+        return this.fromHeaders({ "langsmith-trace": dottedOrder });
+    }
+    static fromHeaders(headers, inheritArgs) {
+        const headerTrace = headers["langsmith-trace"];
+        if (!headerTrace || typeof headerTrace !== "string")
+            return undefined;
+        const parentDottedOrder = headerTrace.trim();
+        const parsedDottedOrder = parentDottedOrder.split(".").map((part) => {
+            const [strTime, uuid] = part.split("Z");
+            return { strTime, time: Date.parse(strTime + "Z"), uuid };
+        });
+        const traceId = parsedDottedOrder[0].uuid;
+        const config = {
+            ...inheritArgs,
+            name: inheritArgs?.["name"] ?? "parent",
+            run_type: inheritArgs?.["run_type"] ?? "chain",
+            start_time: inheritArgs?.["start_time"] ?? Date.now(),
+            id: parsedDottedOrder.at(-1)?.uuid,
+            trace_id: traceId,
+            dotted_order: parentDottedOrder,
+        };
+        if (headers["baggage"]) {
+            const baggage = Baggage.fromHeader(headers["baggage"]);
+            config.metadata = baggage.metadata;
+            config.tags = baggage.tags;
+        }
+        return new RunTree(config);
+    }
+    toHeaders() {
+        return {
+            "langsmith-trace": this.dotted_order,
+            baggage: new Baggage(this.extra?.metadata, this.tags).toHeader(),
+        };
+    }
 }
 export function isRunTree(x) {
     return (x !== undefined &&

package/dist/schemas.d.ts

@@ -308,7 +308,7 @@ export type RetrieverOutput = Array<{
 export interface InvocationParamsSchema {
     ls_provider?: string;
     ls_model_name?: string;
-    ls_model_type: "chat";
+    ls_model_type: "chat" | "text";
     ls_temperature?: number;
     ls_max_tokens?: number;
     ls_stop?: string[];

package/dist/singletons/traceable.d.ts

@@ -20,4 +20,4 @@ export declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvid
 export declare const getCurrentRunTree: () => RunTree;
 export declare const ROOT: unique symbol;
 export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;
-export {};
+export type { TraceableFunction } from "./types.js";

package/dist/traceable.cjs

@@ -5,44 +5,8 @@ const node_async_hooks_1 = require("node:async_hooks");
 const run_trees_js_1 = require("./run_trees.cjs");
 const env_js_1 = require("./env.cjs");
 const traceable_js_1 = require("./singletons/traceable.cjs");
+const asserts_js_1 = require("./utils/asserts.cjs");
 traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
-function isPromiseMethod(x) {
-    if (x === "then" || x === "catch" || x === "finally") {
-        return true;
-    }
-    return false;
-}
-function isKVMap(x) {
-    if (typeof x !== "object" || x == null) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(x);
-    return ((prototype === null ||
-        prototype === Object.prototype ||
-        Object.getPrototypeOf(prototype) === null) &&
-        !(Symbol.toStringTag in x) &&
-        !(Symbol.iterator in x));
-}
-const isAsyncIterable = (x) => x != null &&
-    typeof x === "object" &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeof x[Symbol.asyncIterator] === "function";
-const isIteratorLike = (x) => x != null &&
-    typeof x === "object" &&
-    "next" in x &&
-    typeof x.next === "function";
-const GeneratorFunction = function* () { }.constructor;
-const isGenerator = (x) => 
-// eslint-disable-next-line no-instanceof/no-instanceof
-x != null && typeof x === "function" && x instanceof GeneratorFunction;
-const isThenable = (x) => x != null &&
-    typeof x === "object" &&
-    "then" in x &&
-    typeof x.then === "function";
-const isReadableStream = (x) => x != null &&
-    typeof x === "object" &&
-    "getReader" in x &&
-    typeof x.getReader === "function";
 const handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {
@@ -51,13 +15,13 @@ const handleRunInputs = (rawInputs) => {
     if (rawInputs.length > 1) {
         return { args: rawInputs };
     }
-    if (isKVMap(firstInput)) {
+    if ((0, asserts_js_1.isKVMap)(firstInput)) {
         return firstInput;
     }
     return { input: firstInput };
 };
 const handleRunOutputs = (rawOutputs) => {
-    if (isKVMap(rawOutputs)) {
+    if ((0, asserts_js_1.isKVMap)(rawOutputs)) {
         return rawOutputs;
     }
     return { outputs: rawOutputs };
@@ -122,7 +86,7 @@ const getSerializablePromise = (arg) => {
     return promiseProxy;
 };
 const convertSerializableArg = (arg) => {
-    if (isReadableStream(arg)) {
+    if ((0, asserts_js_1.isReadableStream)(arg)) {
         const proxyState = [];
         const transform = new TransformStream({
             start: () => void 0,
@@ -136,7 +100,7 @@ const convertSerializableArg = (arg) => {
         Object.assign(pipeThrough, { toJSON: () => proxyState });
         return pipeThrough;
     }
-    if (isAsyncIterable(arg)) {
+    if ((0, asserts_js_1.isAsyncIterable)(arg)) {
         const proxyState = { current: [] };
         return new Proxy(arg, {
             get(target, prop, receiver) {
@@ -179,7 +143,7 @@ const convertSerializableArg = (arg) => {
             },
         });
     }
-    if (!Array.isArray(arg) && isIteratorLike(arg)) {
+    if (!Array.isArray(arg) && (0, asserts_js_1.isIteratorLike)(arg)) {
         const proxyState = [];
         return new Proxy(arg, {
             get(target, prop, receiver) {
@@ -207,7 +171,7 @@ const convertSerializableArg = (arg) => {
             },
         });
     }
-    if (isThenable(arg)) {
+    if ((0, asserts_js_1.isThenable)(arg)) {
         return getSerializablePromise(arg);
     }
     return arg;
@@ -389,18 +353,18 @@ function traceable(wrappedFunc, config) {
             catch (err) {
                 returnValue = Promise.reject(err);
             }
-            if (isAsyncIterable(returnValue)) {
+            if ((0, asserts_js_1.isAsyncIterable)(returnValue)) {
                 const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                 return wrapAsyncGeneratorForTracing(returnValue, snapshot);
             }
             const tracedPromise = new Promise((resolve, reject) => {
                 Promise.resolve(returnValue)
                     .then(async (rawOutput) => {
-                    if (isAsyncIterable(rawOutput)) {
+                    if ((0, asserts_js_1.isAsyncIterable)(rawOutput)) {
                         const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                         return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
                     }
-                    if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
+                    if ((0, asserts_js_1.isGenerator)(wrappedFunc) && (0, asserts_js_1.isIteratorLike)(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
                             if (!done || typeof value !== "undefined") {
@@ -437,7 +401,7 @@ function traceable(wrappedFunc, config) {
             }
             return new Proxy(returnValue, {
                 get(target, prop, receiver) {
-                    if (isPromiseMethod(prop)) {
+                    if ((0, asserts_js_1.isPromiseMethod)(prop)) {
                         return tracedPromise[prop].bind(tracedPromise);
                     }
                     return Reflect.get(target, prop, receiver);

package/dist/traceable.js

@@ -2,44 +2,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 import { isTracingEnabled } from "./env.js";
 import { ROOT, AsyncLocalStorageProviderSingleton, } from "./singletons/traceable.js";
+import { isKVMap, isReadableStream, isAsyncIterable, isIteratorLike, isThenable, isGenerator, isPromiseMethod, } from "./utils/asserts.js";
 AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
-function isPromiseMethod(x) {
-    if (x === "then" || x === "catch" || x === "finally") {
-        return true;
-    }
-    return false;
-}
-function isKVMap(x) {
-    if (typeof x !== "object" || x == null) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(x);
-    return ((prototype === null ||
-        prototype === Object.prototype ||
-        Object.getPrototypeOf(prototype) === null) &&
-        !(Symbol.toStringTag in x) &&
-        !(Symbol.iterator in x));
-}
-const isAsyncIterable = (x) => x != null &&
-    typeof x === "object" &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeof x[Symbol.asyncIterator] === "function";
-const isIteratorLike = (x) => x != null &&
-    typeof x === "object" &&
-    "next" in x &&
-    typeof x.next === "function";
-const GeneratorFunction = function* () { }.constructor;
-const isGenerator = (x) => 
-// eslint-disable-next-line no-instanceof/no-instanceof
-x != null && typeof x === "function" && x instanceof GeneratorFunction;
-const isThenable = (x) => x != null &&
-    typeof x === "object" &&
-    "then" in x &&
-    typeof x.then === "function";
-const isReadableStream = (x) => x != null &&
-    typeof x === "object" &&
-    "getReader" in x &&
-    typeof x.getReader === "function";
 const handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {

package/dist/utils/asserts.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReadableStream = exports.isThenable = exports.isGenerator = exports.isIteratorLike = exports.isAsyncIterable = exports.isKVMap = exports.isPromiseMethod = void 0;
+function isPromiseMethod(x) {
+    if (x === "then" || x === "catch" || x === "finally") {
+        return true;
+    }
+    return false;
+}
+exports.isPromiseMethod = isPromiseMethod;
+function isKVMap(x) {
+    if (typeof x !== "object" || x == null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(x);
+    return ((prototype === null ||
+        prototype === Object.prototype ||
+        Object.getPrototypeOf(prototype) === null) &&
+        !(Symbol.toStringTag in x) &&
+        !(Symbol.iterator in x));
+}
+exports.isKVMap = isKVMap;
+const isAsyncIterable = (x) => x != null &&
+    typeof x === "object" &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x[Symbol.asyncIterator] === "function";
+exports.isAsyncIterable = isAsyncIterable;
+const isIteratorLike = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
+exports.isIteratorLike = isIteratorLike;
+const GeneratorFunction = function* () { }.constructor;
+const isGenerator = (x) => 
+// eslint-disable-next-line no-instanceof/no-instanceof
+x != null && typeof x === "function" && x instanceof GeneratorFunction;
+exports.isGenerator = isGenerator;
+const isThenable = (x) => x != null &&
+    typeof x === "object" &&
+    "then" in x &&
+    typeof x.then === "function";
+exports.isThenable = isThenable;
+const isReadableStream = (x) => x != null &&
+    typeof x === "object" &&
+    "getReader" in x &&
+    typeof x.getReader === "function";
+exports.isReadableStream = isReadableStream;

package/dist/utils/asserts.d.ts

@@ -0,0 +1,7 @@
+export declare function isPromiseMethod(x: string | symbol): x is "then" | "catch" | "finally";
+export declare function isKVMap(x: unknown): x is Record<string, unknown>;
+export declare const isAsyncIterable: (x: unknown) => x is AsyncIterable<unknown>;
+export declare const isIteratorLike: (x: unknown) => x is Iterator<unknown, any, undefined>;
+export declare const isGenerator: (x: unknown) => x is Generator<unknown, any, unknown>;
+export declare const isThenable: (x: unknown) => x is Promise<unknown>;
+export declare const isReadableStream: (x: unknown) => x is ReadableStream<any>;

package/dist/utils/asserts.js

@@ -0,0 +1,37 @@
+export function isPromiseMethod(x) {
+    if (x === "then" || x === "catch" || x === "finally") {
+        return true;
+    }
+    return false;
+}
+export function isKVMap(x) {
+    if (typeof x !== "object" || x == null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(x);
+    return ((prototype === null ||
+        prototype === Object.prototype ||
+        Object.getPrototypeOf(prototype) === null) &&
+        !(Symbol.toStringTag in x) &&
+        !(Symbol.iterator in x));
+}
+export const isAsyncIterable = (x) => x != null &&
+    typeof x === "object" &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x[Symbol.asyncIterator] === "function";
+export const isIteratorLike = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
+const GeneratorFunction = function* () { }.constructor;
+export const isGenerator = (x) => 
+// eslint-disable-next-line no-instanceof/no-instanceof
+x != null && typeof x === "function" && x instanceof GeneratorFunction;
+export const isThenable = (x) => x != null &&
+    typeof x === "object" &&
+    "then" in x &&
+    typeof x.then === "function";
+export const isReadableStream = (x) => x != null &&
+    typeof x === "object" &&
+    "getReader" in x &&
+    typeof x.getReader === "function";

package/dist/utils/warn.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnOnce = void 0;
+const warnedMessages = {};
+function warnOnce(message) {
+    if (!warnedMessages[message]) {
+        console.warn(message);
+        warnedMessages[message] = true;
+    }
+}
+exports.warnOnce = warnOnce;

package/dist/utils/warn.d.ts

@@ -0,0 +1 @@
+export declare function warnOnce(message: string): void;

package/dist/utils/warn.js

@@ -0,0 +1,7 @@
+const warnedMessages = {};
+export function warnOnce(message) {
+    if (!warnedMessages[message]) {
+        console.warn(message);
+        warnedMessages[message] = true;
+    }
+}

package/dist/wrappers/openai.cjs

@@ -179,7 +179,7 @@ const wrapOpenAI = (openai, options) => {
                 undefined;
             return {
                 ls_provider: "openai",
-                ls_model_type: "chat",
+                ls_model_type: "text",
                 ls_model_name: params.model,
                 ls_max_tokens: params.max_tokens ?? undefined,
                 ls_temperature: params.temperature ?? undefined,

package/dist/wrappers/openai.js

@@ -176,7 +176,7 @@ export const wrapOpenAI = (openai, options) => {
                 undefined;
             return {
                 ls_provider: "openai",
-                ls_model_type: "chat",
+                ls_model_type: "text",
                 ls_model_name: params.model,
                 ls_max_tokens: params.max_tokens ?? undefined,
                 ls_temperature: params.temperature ?? undefined,

package/evaluation/langchain.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/evaluation/langchain.cjs');

package/evaluation/langchain.d.cts

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/evaluation/langchain.d.ts

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/evaluation/langchain.js

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.27",
+  "version": "0.1.30",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -21,6 +21,10 @@
     "evaluation.js",
     "evaluation.d.ts",
     "evaluation.d.cts",
+    "evaluation/langchain.cjs",
+    "evaluation/langchain.js",
+    "evaluation/langchain.d.ts",
+    "evaluation/langchain.d.cts",
     "schemas.cjs",
     "schemas.js",
     "schemas.d.ts",
@@ -95,8 +99,9 @@
     "@babel/preset-env": "^7.22.4",
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",
-    "@langchain/core": "^0.1.32",
-    "@langchain/langgraph": "^0.0.8",
+    "langchain": "^0.2.0",
+    "@langchain/core": "^0.2.0",
+    "@langchain/langgraph": "^0.0.19",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.1",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
@@ -118,16 +123,23 @@
   },
   "peerDependencies": {
     "openai": "*",
+    "langchain": "*",
     "@langchain/core": "*"
   },
   "peerDependenciesMeta": {
     "openai": {
       "optional": true
     },
+    "langchain": {
+      "optional": true
+    },
     "@langchain/core": {
       "optional": true
     }
   },
+  "resolutions": {
+    "@langchain/core": "0.2.0"
+  },
   "lint-staged": {
     "**/*.{ts,tsx}": [
       "prettier --write --ignore-unknown",
@@ -180,6 +192,15 @@
       "import": "./evaluation.js",
       "require": "./evaluation.cjs"
     },
+    "./evaluation/langchain": {
+      "types": {
+        "import": "./evaluation/langchain.d.ts",
+        "require": "./evaluation/langchain.d.cts",
+        "default": "./evaluation/langchain.d.ts"
+      },
+      "import": "./evaluation/langchain.js",
+      "require": "./evaluation/langchain.cjs"
+    },
     "./schemas": {
       "types": {
         "import": "./schemas.d.ts",
@@ -227,4 +248,4 @@
     },
     "./package.json": "./package.json"
   }
-}
+}