langsmith 0.2.8 → 0.2.9

package/dist/evaluation/_runner.cjs

@@ -12,11 +12,9 @@ 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");
-function evaluate(
-/**
- * The target system or function to evaluate.
- */
-target, options) {
+const evaluate_comparative_js_1 = require("./evaluate_comparative.cjs");
+// Implementation signature
+function evaluate(target, options) {
     return _evaluate(target, options);
 }
 exports.evaluate = evaluate;
@@ -381,7 +379,7 @@ class _ExperimentManager {
     // Private methods
     /**
      * Run the target function or runnable on the examples.
-     * @param {TargetT} target The target function or runnable to evaluate.
+     * @param {StandardTargetT} target The target function or runnable to evaluate.
      * @param options
      * @returns {AsyncGenerator<_ForwardResults>} An async generator of the results.
      */
@@ -630,12 +628,32 @@ class ExperimentResults {
     }
 }
 async function _evaluate(target, fields) {
+    // Add check for comparative evaluation
+    if (Array.isArray(target)) {
+        const comparativeOptions = fields;
+        if (!comparativeOptions.evaluators) {
+            throw new Error("Evaluators are required for comparative evaluation");
+        }
+        return (0, evaluate_comparative_js_1.evaluateComparative)(target, {
+            evaluators: comparativeOptions.evaluators,
+            client: comparativeOptions.client,
+            metadata: comparativeOptions.metadata,
+            experimentPrefix: comparativeOptions.experimentPrefix,
+            description: comparativeOptions.description,
+            maxConcurrency: comparativeOptions.maxConcurrency,
+            loadNested: comparativeOptions.loadNested ?? false,
+            randomizeOrder: comparativeOptions.randomizeOrder ?? false,
+        });
+    }
     const client = fields.client ?? new index_js_1.Client();
     const runs = _isCallable(target) ? null : target;
+    const standardFields = fields;
     const [experiment_, newRuns] = await _resolveExperiment(fields.experiment ?? null, runs, client);
     let manager = await new _ExperimentManager({
-        data: Array.isArray(fields.data) ? undefined : fields.data,
-        examples: Array.isArray(fields.data) ? fields.data : undefined,
+        data: Array.isArray(standardFields.data) ? undefined : standardFields.data,
+        examples: Array.isArray(standardFields.data)
+            ? standardFields.data
+            : undefined,
         client,
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,
@@ -647,13 +665,13 @@ async function _evaluate(target, fields) {
             maxConcurrency: fields.maxConcurrency,
         });
     }
-    if (fields.evaluators) {
-        manager = await manager.withEvaluators(fields.evaluators, {
+    if (standardFields.evaluators) {
+        manager = await manager.withEvaluators(standardFields.evaluators, {
             maxConcurrency: fields.maxConcurrency,
         });
     }
-    if (fields.summaryEvaluators) {
-        manager = await manager.withSummaryEvaluators(fields.summaryEvaluators);
+    if (standardFields.summaryEvaluators) {
+        manager = await manager.withSummaryEvaluators(standardFields.summaryEvaluators);
     }
     // Start consuming the results.
     const results = new ExperimentResults(manager);
@@ -743,6 +761,20 @@ async function wrapSummaryEvaluators(evaluators, optionsArray) {
         const evalName = evaluator.name || "BatchEvaluator";
         const wrapperInner = (runs, examples) => {
             const wrapperSuperInner = (0, traceable_js_1.traceable)((_runs_, _examples_) => {
+                // Check if the evaluator expects an object parameter
+                if (evaluator.length === 1) {
+                    const inputs = examples.map((ex) => ex.inputs);
+                    const outputs = runs.map((run) => run.outputs || {});
+                    const referenceOutputs = examples.map((ex) => ex.outputs || {});
+                    return Promise.resolve(evaluator({
+                        runs,
+                        examples,
+                        inputs,
+                        outputs,
+                        referenceOutputs,
+                    }));
+                }
+                // Otherwise use the traditional (runs, examples) signature
                 return Promise.resolve(evaluator(runs, examples));
             }, { ...optionsArray, name: evalName });
             return Promise.resolve(wrapperSuperInner(`Runs[] (Length=${runs.length})`, `Examples[] (Length=${examples.length})`));

package/dist/evaluation/_runner.d.ts

@@ -1,14 +1,51 @@
 import { Client } from "../index.js";
 import { Example, KVMap, Run, TracerSession } from "../schemas.js";
 import { EvaluationResult, EvaluationResults, RunEvaluator } from "./evaluator.js";
-export type TargetT<TInput = any, TOutput = KVMap> = ((input: TInput, config?: KVMap) => Promise<TOutput>) | ((input: TInput, config?: KVMap) => TOutput) | {
+import { ComparisonEvaluationResults, ComparativeEvaluator } from "./evaluate_comparative.js";
+type StandardTargetT<TInput = any, TOutput = KVMap> = ((input: TInput, config?: KVMap) => Promise<TOutput>) | ((input: TInput, config?: KVMap) => TOutput) | {
     invoke: (input: TInput, config?: KVMap) => TOutput;
 } | {
     invoke: (input: TInput, config?: KVMap) => Promise<TOutput>;
 };
+type ComparativeTargetT = Array<string> | Array<Promise<ExperimentResults> | ExperimentResults>;
+export type TargetT<TInput = any, TOutput = KVMap> = StandardTargetT<TInput, TOutput> | ComparativeTargetT;
 export type DataT = string | AsyncIterable<Example> | Example[];
-export type SummaryEvaluatorT = ((runs: Array<Run>, examples: Array<Example>) => Promise<EvaluationResult | EvaluationResults>) | ((runs: Array<Run>, examples: Array<Example>) => EvaluationResult | EvaluationResults);
-export type EvaluatorT = RunEvaluator | ((run: Run, example?: Example) => EvaluationResult | EvaluationResults) | ((run: Run, example?: Example) => Promise<EvaluationResult | EvaluationResults>);
+/** @deprecated Use object parameter version instead: (args: { runs, examples, inputs, outputs, referenceOutputs }) => ... */
+type DeprecatedSyncSummaryEvaluator = (runs: Array<Run>, examples: Array<Example>) => EvaluationResult | EvaluationResults;
+/** @deprecated Use object parameter version instead: (args: { runs, examples, inputs, outputs, referenceOutputs }) => ... */
+type DeprecatedAsyncSummaryEvaluator = (runs: Array<Run>, examples: Array<Example>) => Promise<EvaluationResult | EvaluationResults>;
+export type SummaryEvaluatorT = DeprecatedSyncSummaryEvaluator | DeprecatedAsyncSummaryEvaluator | ((args: {
+    runs: Array<Run>;
+    examples: Array<Example>;
+    inputs: Array<Record<string, any>>;
+    outputs: Array<Record<string, any>>;
+    referenceOutputs?: Array<Record<string, any>>;
+}) => EvaluationResult | EvaluationResults) | ((args: {
+    runs: Array<Run>;
+    examples: Array<Example>;
+    inputs: Array<Record<string, any>>;
+    outputs: Array<Record<string, any>>;
+    referenceOutputs?: Array<Record<string, any>>;
+}) => Promise<EvaluationResult | EvaluationResults>);
+/** @deprecated Use object parameter version instead: (args: { run, example, inputs, outputs, referenceOutputs }) => ... */
+type DeprecatedRunEvaluator = RunEvaluator;
+/** @deprecated Use object parameter version instead: (args: { run, example, inputs, outputs, referenceOutputs }) => ... */
+type DeprecatedFunctionEvaluator = (run: Run, example?: Example) => EvaluationResult | EvaluationResults;
+/** @deprecated Use object parameter version instead: (args: { run, example, inputs, outputs, referenceOutputs }) => ... */
+type DeprecatedAsyncFunctionEvaluator = (run: Run, example?: Example) => Promise<EvaluationResult | EvaluationResults>;
+export type EvaluatorT = DeprecatedRunEvaluator | DeprecatedFunctionEvaluator | DeprecatedAsyncFunctionEvaluator | ((args: {
+    run: Run;
+    example: Example;
+    inputs: Record<string, any>;
+    outputs: Record<string, any>;
+    referenceOutputs?: Record<string, any>;
+}) => EvaluationResult | EvaluationResults) | ((args: {
+    run: Run;
+    example: Example;
+    inputs: Record<string, any>;
+    outputs: Record<string, any>;
+    referenceOutputs?: Record<string, any>;
+}) => Promise<EvaluationResult | EvaluationResults>);
 interface _ForwardResults {
     run: Run;
     example: Example;
@@ -25,22 +62,7 @@ interface _ExperimentManagerArgs {
     numRepetitions?: number;
     _runsArray?: Run[];
 }
-export interface EvaluateOptions {
-    /**
-     * The dataset to evaluate on. Can be a dataset name, a list of
-     * examples, or a generator of examples.
-     */
-    data: DataT;
-    /**
-     * A list of evaluators to run on each example.
-     * @default undefined
-     */
-    evaluators?: Array<EvaluatorT>;
-    /**
-     * A list of summary evaluators to run on the entire dataset.
-     * @default undefined
-     */
-    summaryEvaluators?: Array<SummaryEvaluatorT>;
+type BaseEvaluateOptions = {
     /**
      * Metadata to attach to the experiment.
      * @default undefined
@@ -71,12 +93,42 @@ export interface EvaluateOptions {
      * @default 1
      */
     numRepetitions?: number;
+};
+export interface EvaluateOptions extends BaseEvaluateOptions {
+    /**
+     * A list of evaluators to run on each example.
+     * @default undefined
+     */
+    evaluators?: Array<EvaluatorT>;
+    /**
+     * A list of summary evaluators to run on the entire dataset.
+     * @default undefined
+     */
+    summaryEvaluators?: Array<SummaryEvaluatorT>;
+    /**
+     * The dataset to evaluate on. Can be a dataset name, a list of
+     * examples, or a generator of examples.
+     */
+    data: DataT;
 }
-export declare function evaluate(
-/**
- * The target system or function to evaluate.
- */
-target: TargetT, options: EvaluateOptions): Promise<ExperimentResults>;
+export interface ComparativeEvaluateOptions extends BaseEvaluateOptions {
+    /**
+     * A list of evaluators to run on each example.
+     */
+    evaluators: Array<ComparativeEvaluator>;
+    /**
+     * Whether to load all child runs for the experiment.
+     * @default false
+     */
+    loadNested?: boolean;
+    /**
+     * Randomize the order of outputs for each evaluation
+     * @default false
+     */
+    randomizeOrder?: boolean;
+}
+export declare function evaluate(target: ComparativeTargetT, options: ComparativeEvaluateOptions): Promise<ComparisonEvaluationResults>;
+export declare function evaluate(target: StandardTargetT, options: EvaluateOptions): Promise<ExperimentResults>;
 export interface ExperimentResultRow {
     run: Run;
     example: Example;
@@ -114,7 +166,7 @@ export declare class _ExperimentManager {
     _getProject(firstExample: Example): Promise<TracerSession>;
     protected _printExperimentStart(): Promise<void>;
     start(): Promise<_ExperimentManager>;
-    withPredictions(target: TargetT, options?: {
+    withPredictions(target: StandardTargetT, options?: {
         maxConcurrency?: number;
     }): Promise<_ExperimentManager>;
     withEvaluators(evaluators: Array<EvaluatorT | RunEvaluator>, options?: {
@@ -125,11 +177,11 @@ export declare class _ExperimentManager {
     getSummaryScores(): Promise<EvaluationResults>;
     /**
      * Run the target function or runnable on the examples.
-     * @param {TargetT} target The target function or runnable to evaluate.
+     * @param {StandardTargetT} target The target function or runnable to evaluate.
      * @param options
      * @returns {AsyncGenerator<_ForwardResults>} An async generator of the results.
      */
-    _predict(target: TargetT, options?: {
+    _predict(target: StandardTargetT, options?: {
         maxConcurrency?: number;
     }): AsyncGenerator<_ForwardResults>;
     _runEvaluators(evaluators: Array<RunEvaluator>, currentResults: ExperimentResultRow, fields: {

package/dist/evaluation/_runner.js

@@ -9,11 +9,9 @@ import { printErrorStackTrace } from "../utils/error.js";
 import { randomName } from "./_random_name.js";
 import { runEvaluator, } from "./evaluator.js";
 import { v4 as uuidv4 } from "uuid";
-export function evaluate(
-/**
- * The target system or function to evaluate.
- */
-target, options) {
+import { evaluateComparative, } from "./evaluate_comparative.js";
+// Implementation signature
+export function evaluate(target, options) {
     return _evaluate(target, options);
 }
 /**
@@ -377,7 +375,7 @@ export class _ExperimentManager {
     // Private methods
     /**
      * Run the target function or runnable on the examples.
-     * @param {TargetT} target The target function or runnable to evaluate.
+     * @param {StandardTargetT} target The target function or runnable to evaluate.
      * @param options
      * @returns {AsyncGenerator<_ForwardResults>} An async generator of the results.
      */
@@ -625,12 +623,32 @@ class ExperimentResults {
     }
 }
 async function _evaluate(target, fields) {
+    // Add check for comparative evaluation
+    if (Array.isArray(target)) {
+        const comparativeOptions = fields;
+        if (!comparativeOptions.evaluators) {
+            throw new Error("Evaluators are required for comparative evaluation");
+        }
+        return evaluateComparative(target, {
+            evaluators: comparativeOptions.evaluators,
+            client: comparativeOptions.client,
+            metadata: comparativeOptions.metadata,
+            experimentPrefix: comparativeOptions.experimentPrefix,
+            description: comparativeOptions.description,
+            maxConcurrency: comparativeOptions.maxConcurrency,
+            loadNested: comparativeOptions.loadNested ?? false,
+            randomizeOrder: comparativeOptions.randomizeOrder ?? false,
+        });
+    }
     const client = fields.client ?? new Client();
     const runs = _isCallable(target) ? null : target;
+    const standardFields = fields;
     const [experiment_, newRuns] = await _resolveExperiment(fields.experiment ?? null, runs, client);
     let manager = await new _ExperimentManager({
-        data: Array.isArray(fields.data) ? undefined : fields.data,
-        examples: Array.isArray(fields.data) ? fields.data : undefined,
+        data: Array.isArray(standardFields.data) ? undefined : standardFields.data,
+        examples: Array.isArray(standardFields.data)
+            ? standardFields.data
+            : undefined,
         client,
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,
@@ -642,13 +660,13 @@ async function _evaluate(target, fields) {
             maxConcurrency: fields.maxConcurrency,
         });
     }
-    if (fields.evaluators) {
-        manager = await manager.withEvaluators(fields.evaluators, {
+    if (standardFields.evaluators) {
+        manager = await manager.withEvaluators(standardFields.evaluators, {
             maxConcurrency: fields.maxConcurrency,
         });
     }
-    if (fields.summaryEvaluators) {
-        manager = await manager.withSummaryEvaluators(fields.summaryEvaluators);
+    if (standardFields.summaryEvaluators) {
+        manager = await manager.withSummaryEvaluators(standardFields.summaryEvaluators);
     }
     // Start consuming the results.
     const results = new ExperimentResults(manager);
@@ -738,6 +756,20 @@ async function wrapSummaryEvaluators(evaluators, optionsArray) {
         const evalName = evaluator.name || "BatchEvaluator";
         const wrapperInner = (runs, examples) => {
             const wrapperSuperInner = traceable((_runs_, _examples_) => {
+                // Check if the evaluator expects an object parameter
+                if (evaluator.length === 1) {
+                    const inputs = examples.map((ex) => ex.inputs);
+                    const outputs = runs.map((run) => run.outputs || {});
+                    const referenceOutputs = examples.map((ex) => ex.outputs || {});
+                    return Promise.resolve(evaluator({
+                        runs,
+                        examples,
+                        inputs,
+                        outputs,
+                        referenceOutputs,
+                    }));
+                }
+                // Otherwise use the traditional (runs, examples) signature
                 return Promise.resolve(evaluator(runs, examples));
             }, { ...optionsArray, name: evalName });
             return Promise.resolve(wrapperSuperInner(`Runs[] (Length=${runs.length})`, `Examples[] (Length=${examples.length})`));

package/dist/evaluation/evaluate_comparative.cjs

@@ -162,7 +162,16 @@ async function evaluateComparative(experiments, options) {
     const caller = new async_caller_js_1.AsyncCaller({ maxConcurrency: options.maxConcurrency });
     async function evaluateAndSubmitFeedback(runs, example, evaluator) {
         const expectedRunIds = new Set(runs.map((r) => r.id));
-        const result = await evaluator(options.randomizeOrder ? (0, shuffle_js_1.shuffle)(runs) : runs, example);
+        // Check if evaluator expects an object parameter
+        const result = evaluator.length === 1
+            ? await evaluator({
+                runs: options.randomizeOrder ? (0, shuffle_js_1.shuffle)(runs) : runs,
+                example,
+                inputs: example.inputs,
+                outputs: runs.map((run) => run.outputs || {}),
+                referenceOutputs: example.outputs || {},
+            })
+            : await evaluator(runs, example);
         for (const [runId, score] of Object.entries(result.scores)) {
             // validate if the run id
             if (!expectedRunIds.has(runId)) {
@@ -178,7 +187,15 @@ async function evaluateComparative(experiments, options) {
     }
     const tracedEvaluators = options.evaluators.map((evaluator) => (0, traceable_js_1.traceable)(async (runs, example) => {
         const evaluatorRun = (0, traceable_js_1.getCurrentRunTree)();
-        const result = await evaluator(runs, example);
+        const result = evaluator.length === 1
+            ? await evaluator({
+                runs: options.randomizeOrder ? (0, shuffle_js_1.shuffle)(runs) : runs,
+                example,
+                inputs: example.inputs,
+                outputs: runs.map((run) => run.outputs || {}),
+                referenceOutputs: example.outputs || {},
+            })
+            : await evaluator(runs, example);
         // sanitise the payload before sending to LangSmith
         evaluatorRun.inputs = { runs: runs, example: example };
         evaluatorRun.outputs = result;

package/dist/evaluation/evaluate_comparative.d.ts

@@ -2,11 +2,21 @@ import { Client } from "../index.js";
 import { ComparisonEvaluationResult as ComparisonEvaluationResultRow, Example, Run } from "../schemas.js";
 import { evaluate } from "./index.js";
 type ExperimentResults = Awaited<ReturnType<typeof evaluate>>;
+/** @deprecated Use ComparativeEvaluatorNew instead: (args: { runs, example, inputs, outputs, referenceOutputs }) => ... */
+export type _ComparativeEvaluatorLegacy = (runs: Run[], example: Example) => ComparisonEvaluationResultRow | Promise<ComparisonEvaluationResultRow>;
+export type _ComparativeEvaluator = (args: {
+    runs: Run[];
+    example: Example;
+    inputs: Record<string, any>;
+    outputs: Record<string, any>[];
+    referenceOutputs?: Record<string, any>;
+}) => ComparisonEvaluationResultRow | Promise<ComparisonEvaluationResultRow>;
+export type ComparativeEvaluator = _ComparativeEvaluatorLegacy | _ComparativeEvaluator;
 export interface EvaluateComparativeOptions {
     /**
      * A list of evaluators to use for comparative evaluation.
      */
-    evaluators: Array<(runs: Run[], example: Example) => ComparisonEvaluationResultRow | Promise<ComparisonEvaluationResultRow>>;
+    evaluators: Array<ComparativeEvaluator>;
     /**
      * Randomize the order of outputs for each evaluation
      * @default false

package/dist/evaluation/evaluate_comparative.js

@@ -156,7 +156,16 @@ export async function evaluateComparative(experiments, options) {
     const caller = new AsyncCaller({ maxConcurrency: options.maxConcurrency });
     async function evaluateAndSubmitFeedback(runs, example, evaluator) {
         const expectedRunIds = new Set(runs.map((r) => r.id));
-        const result = await evaluator(options.randomizeOrder ? shuffle(runs) : runs, example);
+        // Check if evaluator expects an object parameter
+        const result = evaluator.length === 1
+            ? await evaluator({
+                runs: options.randomizeOrder ? shuffle(runs) : runs,
+                example,
+                inputs: example.inputs,
+                outputs: runs.map((run) => run.outputs || {}),
+                referenceOutputs: example.outputs || {},
+            })
+            : await evaluator(runs, example);
         for (const [runId, score] of Object.entries(result.scores)) {
             // validate if the run id
             if (!expectedRunIds.has(runId)) {
@@ -172,7 +181,15 @@ export async function evaluateComparative(experiments, options) {
     }
     const tracedEvaluators = options.evaluators.map((evaluator) => traceable(async (runs, example) => {
         const evaluatorRun = getCurrentRunTree();
-        const result = await evaluator(runs, example);
+        const result = evaluator.length === 1
+            ? await evaluator({
+                runs: options.randomizeOrder ? shuffle(runs) : runs,
+                example,
+                inputs: example.inputs,
+                outputs: runs.map((run) => run.outputs || {}),
+                referenceOutputs: example.outputs || {},
+            })
+            : await evaluator(runs, example);
         // sanitise the payload before sending to LangSmith
         evaluatorRun.inputs = { runs: runs, example: example };
         evaluatorRun.outputs = result;

package/dist/evaluation/evaluator.cjs

@@ -16,7 +16,14 @@ class DynamicRunEvaluator {
         });
         this.func = ((input) => {
             const { run, example } = input.langSmithRunAndExample;
-            return evaluator(run, example);
+            return evaluator({
+                ...run,
+                run,
+                example,
+                inputs: example?.inputs,
+                outputs: run?.outputs,
+                referenceOutputs: example?.outputs,
+            }, example);
         });
     }
     isEvaluationResults(x) {

package/dist/evaluation/evaluator.d.ts

@@ -72,7 +72,19 @@ export type EvaluationResults = {
 export interface RunEvaluator {
     evaluateRun(run: Run, example?: Example, options?: Partial<RunTreeConfig>): Promise<EvaluationResult | EvaluationResults>;
 }
-export type RunEvaluatorLike = ((run: Run, example?: Example) => Promise<EvaluationResult | EvaluationResults>) | ((run: Run, example?: Example) => EvaluationResult | EvaluationResults);
+export type RunEvaluatorLike = ((run: Run, example?: Example) => Promise<EvaluationResult | EvaluationResults>) | ((run: Run, example?: Example) => EvaluationResult | EvaluationResults) | ((run: Run, example: Example) => Promise<EvaluationResult | EvaluationResults>) | ((run: Run, example: Example) => EvaluationResult | EvaluationResults) | ((args: {
+    run: Run;
+    example: Example;
+    inputs: Record<string, any>;
+    outputs: Record<string, any>;
+    referenceOutputs?: Record<string, any>;
+}) => EvaluationResult | EvaluationResults) | ((args: {
+    run: Run;
+    example: Example;
+    inputs: Record<string, any>;
+    outputs: Record<string, any>;
+    referenceOutputs?: Record<string, any>;
+}) => Promise<EvaluationResult | EvaluationResults>);
 /**
  * Wraps an evaluator function + implements the RunEvaluator interface.
  */

package/dist/evaluation/evaluator.js

@@ -13,7 +13,14 @@ export class DynamicRunEvaluator {
         });
         this.func = ((input) => {
             const { run, example } = input.langSmithRunAndExample;
-            return evaluator(run, example);
+            return evaluator({
+                ...run,
+                run,
+                example,
+                inputs: example?.inputs,
+                outputs: run?.outputs,
+                referenceOutputs: example?.outputs,
+            }, example);
         });
     }
     isEvaluationResults(x) {

package/dist/index.cjs

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () {
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 // Update using yarn bump-version
-exports.__version__ = "0.2.8";
+exports.__version__ = "0.2.9";

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { Client, type ClientConfig, type LangSmithTracingClientInterface, } from
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.2.8";
+export declare const __version__ = "0.2.9";

package/dist/index.js

@@ -2,4 +2,4 @@ export { Client, } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 // Update using yarn bump-version
-export const __version__ = "0.2.8";
+export const __version__ = "0.2.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [