langsmith 0.5.0 → 0.5.1

package/dist/client.cjs

@@ -495,7 +495,29 @@ class Client {
         // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
         this.cachedLSEnvVarsForMetadata = (0, env_js_1.getLangSmithEnvVarsMetadata)();
         // Initialize prompt cache
-        if (!config.disablePromptCache) {
+        // Handle backwards compatibility for deprecated `cache` parameter
+        if (config.cache !== undefined && config.disablePromptCache) {
+            (0, warn_js_1.warnOnce)("Both 'cache' and 'disablePromptCache' were provided. " +
+                "The 'cache' parameter is deprecated and will be removed in a future version. " +
+                "Using 'cache' parameter value.");
+        }
+        if (config.cache !== undefined) {
+            (0, warn_js_1.warnOnce)("The 'cache' parameter is deprecated and will be removed in a future version. " +
+                "Use 'configureGlobalPromptCache()' to configure the global cache, or " +
+                "'disablePromptCache: true' to disable caching for this client.");
+            // Handle old cache parameter
+            if (config.cache === false) {
+                this._promptCache = undefined;
+            }
+            else if (config.cache === true) {
+                this._promptCache = index_js_2.promptCacheSingleton;
+            }
+            else {
+                // Custom PromptCache instance provided
+                this._promptCache = config.cache;
+            }
+        }
+        else if (!config.disablePromptCache) {
             // Use the global singleton instance
             this._promptCache = index_js_2.promptCacheSingleton;
         }

package/dist/client.d.ts

@@ -2,6 +2,7 @@ import type { OTELContext } from "./experimental/otel/types.js";
 import { AsyncCallerParams } from "./utils/async_caller.js";
 import { ComparativeExperiment, DataType, Dataset, DatasetDiffInfo, DatasetShareSchema, Example, ExampleCreate, ExampleUpdate, ExampleUpdateWithoutId, Feedback, FeedbackConfig, FeedbackIngestToken, KVMap, LangChainBaseMessage, LangSmithSettings, LikePromptResponse, Prompt, PromptCommit, PromptSortField, Run, RunCreate, RunUpdate, ScoreType, ExampleSearch, TimeDelta, TracerSession, TracerSessionResult, ValueType, AnnotationQueue, RunWithAnnotationQueueInfo, Attachments, UploadExamplesResponse, UpdateExamplesResponse, DatasetVersion, AnnotationQueueWithDetails } from "./schemas.js";
 import { EvaluationResult, EvaluationResults } from "./evaluation/evaluator.js";
+import { PromptCache } from "./utils/prompt_cache/index.js";
 export interface ClientConfig {
     apiUrl?: string;
     apiKey?: string;
@@ -50,31 +51,39 @@ export interface ClientConfig {
      */
     fetchImplementation?: typeof fetch;
     /**
+     * Disable prompt caching for this client.
+     * By default, prompt caching is enabled globally.
+     */
+    disablePromptCache?: boolean;
+    /**
+     * @deprecated Use `configureGlobalPromptCache()` to configure caching, or
+     * `disablePromptCache: true` to disable it. This parameter is deprecated.
+     *
      * Configuration for caching. Can be:
-     * - `true`: Enable caching with default settings
-     * - `Cache` instance: Use custom cache configuration
-     * - `undefined` or `false`: Disable caching (default)
+     * - `true`: Enable caching with default settings (uses global singleton)
+     * - `Cache`/`PromptCache` instance: Use custom cache configuration
+     * - `false`: Disable caching (equivalent to `disablePromptCache: true`)
      *
      * @example
      * ```typescript
-     * import { Client, Cache } from "langsmith";
+     * import { Client, Cache, configureGlobalPromptCache } from "langsmith";
      *
      * // Enable with defaults
-     * const client1 = new Client({ cache: true });
+     * const client1 = new Client({});
      *
      * // Or use custom configuration
-     * const myCache = new Cache({
+     * import { configureGlobalPromptCache } from "langsmith";
+     * configureGlobalPromptCache({
      *   maxSize: 100,
      *   ttlSeconds: 3600, // 1 hour, or null for infinite TTL
      * });
-     * const client2 = new Client({ cache: myCache });
+     * const client2 = new Client({});
+     *
+     * // Or disable for a specific client
+     * const client3 = new Client({ disablePromptCache: true });
      * ```
      */
-    /**
-     * Disable prompt caching for this client.
-     * By default, prompt caching is enabled globally.
-     */
-    disablePromptCache?: boolean;
+    cache?: boolean | PromptCache;
 }
 /**
  * Represents the parameters for listing runs (spans) from the Langsmith server.

package/dist/client.js

@@ -457,7 +457,29 @@ export class Client {
         // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
         this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
         // Initialize prompt cache
-        if (!config.disablePromptCache) {
+        // Handle backwards compatibility for deprecated `cache` parameter
+        if (config.cache !== undefined && config.disablePromptCache) {
+            warnOnce("Both 'cache' and 'disablePromptCache' were provided. " +
+                "The 'cache' parameter is deprecated and will be removed in a future version. " +
+                "Using 'cache' parameter value.");
+        }
+        if (config.cache !== undefined) {
+            warnOnce("The 'cache' parameter is deprecated and will be removed in a future version. " +
+                "Use 'configureGlobalPromptCache()' to configure the global cache, or " +
+                "'disablePromptCache: true' to disable caching for this client.");
+            // Handle old cache parameter
+            if (config.cache === false) {
+                this._promptCache = undefined;
+            }
+            else if (config.cache === true) {
+                this._promptCache = promptCacheSingleton;
+            }
+            else {
+                // Custom PromptCache instance provided
+                this._promptCache = config.cache;
+            }
+        }
+        else if (!config.disablePromptCache) {
             // Use the global singleton instance
             this._promptCache = promptCacheSingleton;
         }

package/dist/evaluation/_runner.cjs

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._ExperimentManager = void 0;
 exports.evaluate = evaluate;
+exports._reorderResultRowsByExampleIndex = _reorderResultRowsByExampleIndex;
+exports._mapWithConcurrency = _mapWithConcurrency;
 const index_js_1 = require("../index.cjs");
 const traceable_js_1 = require("../traceable.cjs");
 const _git_js_1 = require("../utils/_git.cjs");
 const _uuid_js_1 = require("../utils/_uuid.cjs");
-const async_caller_js_1 = require("../utils/async_caller.cjs");
 const atee_js_1 = require("../utils/atee.cjs");
 const env_js_1 = require("../utils/env.cjs");
 const error_js_1 = require("../utils/error.cjs");
@@ -14,10 +15,22 @@ const _random_name_js_1 = require("./_random_name.cjs");
 const evaluator_js_1 = require("./evaluator.cjs");
 const uuid_1 = require("uuid");
 const evaluate_comparative_js_1 = require("./evaluate_comparative.cjs");
+const p_queue_js_1 = require("../utils/p-queue.cjs");
 // Implementation signature
 function evaluate(target, options) {
     return _evaluate(target, options);
 }
+function _reorderResultRowsByExampleIndex(rows) {
+    const sortedRows = [...rows].sort((a, b) => a.exampleIndex - b.exampleIndex);
+    return {
+        orderedRows: sortedRows.map(({ run, example, evaluationResults }) => ({
+            run,
+            example,
+            evaluationResults,
+        })),
+        orderedRuns: sortedRows.map((row) => row.run),
+    };
+}
 /**
  * Manage the execution of experiments.
  *
@@ -124,6 +137,12 @@ class _ExperimentManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_resultRows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_examples", {
             enumerable: true,
             configurable: true,
@@ -210,6 +229,7 @@ class _ExperimentManager {
         this._runs = args.runs;
         this._evaluationResults = args.evaluationResults;
         this._summaryResults = args.summaryResults;
+        this._resultRows = args.resultRows;
         this._numRepetitions = args.numRepetitions;
         this._includeAttachments = args.includeAttachments;
     }
@@ -304,13 +324,24 @@ class _ExperimentManager {
     }
     async withPredictions(target, options) {
         const experimentResults = this._predict(target, options);
+        const [rowsForResults, rowsForRuns] = (0, atee_js_1.atee)(experimentResults);
         return new _ExperimentManager({
             examples: await this.getExamples(),
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
+            resultRows: (async function* () {
+                for await (const pred of rowsForResults) {
+                    yield {
+                        run: pred.run,
+                        example: pred.example,
+                        evaluationResults: { results: [] },
+                        exampleIndex: pred.exampleIndex,
+                    };
+                }
+            })(),
             runs: (async function* () {
-                for await (const pred of experimentResults) {
+                for await (const pred of rowsForRuns) {
                     yield pred.run;
                 }
             })(),
@@ -320,19 +351,20 @@ class _ExperimentManager {
     async withEvaluators(evaluators, options) {
         const resolvedEvaluators = _resolveEvaluators(evaluators);
         const experimentResults = this._score(resolvedEvaluators, options);
-        const [r1, r2] = (0, atee_js_1.atee)(experimentResults);
+        const [rowsForResults, rowsForRuns, rowsForEvaluations] = (0, atee_js_1.atee)(experimentResults, 3);
         return new _ExperimentManager({
             examples: await this.getExamples(),
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
+            resultRows: rowsForResults,
             runs: (async function* () {
-                for await (const result of r1) {
+                for await (const result of rowsForRuns) {
                     yield result.run;
                 }
             })(),
             evaluationResults: (async function* () {
-                for await (const result of r2) {
+                for await (const result of rowsForEvaluations) {
                     yield result.evaluationResults;
                 }
             })(),
@@ -347,30 +379,43 @@ class _ExperimentManager {
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
-            runs: this.runs,
+            runs: this._runs,
             _runsArray: this._runsArray,
             evaluationResults: this._evaluationResults,
+            resultRows: this._resultRows,
             summaryResults: aggregateFeedbackGen,
             includeAttachments: this._includeAttachments,
         });
     }
     async *getResults() {
-        const examples = await this.getExamples();
-        const evaluationResults = [];
         if (!this._runsArray) {
             this._runsArray = [];
-            for await (const run of this.runs) {
-                this._runsArray.push(run);
-            }
         }
-        for await (const evaluationResult of this.evaluationResults) {
-            evaluationResults.push(evaluationResult);
+        if (this._resultRows) {
+            for await (const result of this._resultRows) {
+                this._runsArray.push(result.run);
+                yield result;
+            }
+            return;
         }
-        for (let i = 0; i < this._runsArray.length; i++) {
+        const examples = await this.getExamples();
+        const runsIterator = this.runs[Symbol.asyncIterator]();
+        const evaluationIterator = this.evaluationResults[Symbol.asyncIterator]();
+        for (let i = 0; i < examples.length; i++) {
+            const runResult = await runsIterator.next();
+            if (runResult.done) {
+                break;
+            }
+            const evaluationResult = await evaluationIterator.next();
+            const evaluationResults = evaluationResult.done
+                ? { results: [] }
+                : evaluationResult.value;
+            this._runsArray.push(runResult.value);
             yield {
-                run: this._runsArray[i],
+                run: runResult.value,
                 example: examples[i],
-                evaluationResults: evaluationResults[i],
+                evaluationResults,
+                exampleIndex: i,
             };
         }
     }
@@ -400,29 +445,52 @@ class _ExperimentManager {
     async *_predict(target, options) {
         const maxConcurrency = options?.maxConcurrency ?? 0;
         const examples = await this.getExamples();
-        if (maxConcurrency === 0) {
-            for (const example of examples) {
-                yield await _forward(target, example, this.experimentName, this._metadata, this.client, this._includeAttachments);
+        let hadPredictionError = false;
+        let shouldThrowEndError = false;
+        let endErrorToThrow;
+        try {
+            // maxConcurrency: 0 means sequential execution (matching Python behavior)
+            const queue = options?.queue ??
+                new p_queue_js_1.PQueue({
+                    concurrency: maxConcurrency === 0 ? 1 : maxConcurrency,
+                });
+            const examplesWithIndex = examples.map((example, i) => ({
+                example,
+                exampleIndex: i,
+            }));
+            for await (const result of _mapWithConcurrency(examplesWithIndex, queue, (item) => _forward(target, item.example, this.experimentName, this._metadata, this.client, this._includeAttachments).then((forwardResult) => ({
+                ...forwardResult,
+                exampleIndex: item.exampleIndex,
+            })))) {
+                yield result;
             }
         }
-        else {
-            const caller = new async_caller_js_1.AsyncCaller({
-                maxConcurrency,
-                debug: this.client.debug,
-            });
-            const futures = [];
-            for await (const example of examples) {
-                futures.push(caller.call(_forward, target, example, this.experimentName, this._metadata, this.client, this._includeAttachments));
+        catch (error) {
+            hadPredictionError = true;
+            throw error;
+        }
+        finally {
+            try {
+                // Always attempt to close out the project metadata, even on prediction errors.
+                await this._end();
             }
-            for await (const future of futures) {
-                yield future;
+            catch (endError) {
+                if (hadPredictionError) {
+                    console.error(`Error finalizing experiment: ${endError}`);
+                    (0, error_js_1.printErrorStackTrace)(endError);
+                }
+                else {
+                    shouldThrowEndError = true;
+                    endErrorToThrow = endError;
+                }
             }
         }
-        // Close out the project.
-        await this._end();
+        if (shouldThrowEndError) {
+            throw endErrorToThrow;
+        }
     }
     async _runEvaluators(evaluators, currentResults, fields) {
-        const { run, example, evaluationResults } = currentResults;
+        const { run, example, evaluationResults, exampleIndex } = currentResults;
         for (const evaluator of evaluators) {
             try {
                 const options = {
@@ -448,6 +516,7 @@ class _ExperimentManager {
             run,
             example,
             evaluationResults,
+            exampleIndex,
         };
     }
     /**
@@ -458,28 +527,16 @@ class _ExperimentManager {
      * @param {number} maxConcurrency
      */
     async *_score(evaluators, options) {
-        const { maxConcurrency = 0 } = options || {};
-        if (maxConcurrency === 0) {
-            for await (const currentResults of this.getResults()) {
-                yield this._runEvaluators(evaluators, currentResults, {
-                    client: this.client,
-                });
-            }
-        }
-        else {
-            const caller = new async_caller_js_1.AsyncCaller({
-                maxConcurrency,
-                debug: this.client.debug,
+        const { maxConcurrency = 0, queue: providedQueue } = options || {};
+        // maxConcurrency: 0 means sequential execution (matching Python behavior)
+        const queue = providedQueue ??
+            new p_queue_js_1.PQueue({
+                concurrency: maxConcurrency === 0 ? 1 : maxConcurrency,
             });
-            const futures = [];
-            for await (const currentResults of this.getResults()) {
-                futures.push(caller.call(this._runEvaluators, evaluators, currentResults, {
-                    client: this.client,
-                }));
-            }
-            for (const result of futures) {
-                yield result;
-            }
+        for await (const result of _mapWithConcurrency(this.getResults(), queue, (currentResults) => this._runEvaluators(evaluators, currentResults, {
+            client: this.client,
+        }))) {
+            yield result;
         }
     }
     async *_applySummaryEvaluators(summaryEvaluators) {
@@ -632,10 +689,14 @@ class ExperimentResults {
         }
     }
     async processData(manager) {
+        const unorderedResults = [];
         for await (const item of manager.getResults()) {
-            this.results.push(item);
-            this.processedCount++;
+            unorderedResults.push(item);
         }
+        const { orderedRows, orderedRuns } = _reorderResultRowsByExampleIndex(unorderedResults);
+        manager._runsArray = orderedRuns;
+        this.results = orderedRows;
+        this.processedCount = this.results.length;
         this.summaryResults = await manager.getSummaryScores();
     }
     get length() {
@@ -676,14 +737,40 @@ async function _evaluate(target, fields) {
         numRepetitions: fields.numRepetitions ?? 1,
         includeAttachments: standardFields.includeAttachments,
     }).start();
+    const targetConcurrency = standardFields.targetConcurrency ?? standardFields.maxConcurrency ?? 0;
+    const evaluationConcurrency = standardFields.evaluationConcurrency ?? standardFields.maxConcurrency ?? 0;
+    // Determine if we should use separate queues or a shared queue
+    const useSeparateQueues = standardFields.targetConcurrency !== undefined &&
+        standardFields.evaluationConcurrency !== undefined;
+    let sharedQueue;
+    let targetQueue;
+    let evaluationQueue;
+    if (useSeparateQueues) {
+        // Create separate queues for target and evaluation
+        if (targetConcurrency > 0) {
+            targetQueue = new p_queue_js_1.PQueue({ concurrency: targetConcurrency });
+        }
+        if (evaluationConcurrency > 0) {
+            evaluationQueue = new p_queue_js_1.PQueue({ concurrency: evaluationConcurrency });
+        }
+    }
+    else {
+        // Use a shared queue
+        const sharedConcurrency = standardFields.maxConcurrency ?? 0;
+        if (sharedConcurrency > 0) {
+            sharedQueue = new p_queue_js_1.PQueue({ concurrency: sharedConcurrency });
+        }
+    }
     if (_isCallable(target)) {
         manager = await manager.withPredictions(target, {
-            maxConcurrency: fields.maxConcurrency,
+            maxConcurrency: targetConcurrency,
+            queue: useSeparateQueues ? targetQueue : sharedQueue,
         });
     }
     if (standardFields.evaluators) {
         manager = await manager.withEvaluators(standardFields.evaluators, {
-            maxConcurrency: fields.maxConcurrency,
+            maxConcurrency: evaluationConcurrency,
+            queue: useSeparateQueues ? evaluationQueue : sharedQueue,
         });
     }
     if (standardFields.summaryEvaluators) {
@@ -868,6 +955,30 @@ async function _resolveExperiment(experiment, runs, client) {
     }
     return [undefined, undefined];
 }
+/**
+ * Map over an iterable with bounded concurrency using p-queue.
+ * Results are yielded as soon as they resolve (input order is not preserved).
+ * The queue handles concurrency limits internally.
+ */
+async function* _mapWithConcurrency(iterable, queue, mapper) {
+    const pending = new Set();
+    // Add all tasks to p-queue immediately (p-queue handles concurrency)
+    for await (const input of iterable) {
+        const task = queue
+            .add(() => mapper(input))
+            .then((value) => ({
+            value,
+            self: task,
+        }));
+        pending.add(task);
+    }
+    // Yield results as they complete
+    while (pending.size > 0) {
+        const { value, self } = await Promise.race(pending);
+        pending.delete(self);
+        yield value;
+    }
+}
 function _isCallable(target) {
     return Boolean(typeof target === "function" ||
         ("invoke" in target && typeof target.invoke === "function"));

package/dist/evaluation/_runner.d.ts

@@ -2,6 +2,7 @@ import { Client } from "../index.js";
 import { AttachmentInfo, Example, KVMap, Run, TracerSession } from "../schemas.js";
 import { EvaluationResult, EvaluationResults, RunEvaluator } from "./evaluator.js";
 import { ComparisonEvaluationResults, ComparativeEvaluator } from "./evaluate_comparative.js";
+import { PQueueType } from "../utils/p-queue.js";
 export type TargetConfigT = KVMap & {
     attachments?: Record<string, AttachmentInfo>;
     callbacks?: any;
@@ -55,6 +56,7 @@ export type EvaluatorT = DeprecatedRunEvaluator | DeprecatedFunctionEvaluator |
 interface _ForwardResults {
     run: Run;
     example: Example;
+    exampleIndex: number;
 }
 interface _ExperimentManagerArgs {
     data?: DataT;
@@ -67,6 +69,7 @@ interface _ExperimentManagerArgs {
     examples?: Example[];
     numRepetitions?: number;
     _runsArray?: Run[];
+    resultRows?: AsyncGenerator<_ExperimentResultRowWithIndex>;
     includeAttachments?: boolean;
 }
 type BaseEvaluateOptions = {
@@ -85,7 +88,8 @@ type BaseEvaluateOptions = {
      */
     description?: string;
     /**
-     * The maximum number of concurrent evaluations to run.
+     * The maximum concurrency to use for predictions/evaluations when a more
+     * specific concurrency option is not provided.
      * @default undefined
      */
     maxConcurrency?: number;
@@ -102,6 +106,18 @@ type BaseEvaluateOptions = {
     numRepetitions?: number;
 };
 export interface EvaluateOptions extends BaseEvaluateOptions {
+    /**
+     * The maximum number of concurrent predictions to run.
+     * If not provided, defaults to `maxConcurrency` when set.
+     * @default undefined
+     */
+    targetConcurrency?: number;
+    /**
+     * The maximum number of concurrent evaluators to run.
+     * If not provided, defaults to `maxConcurrency` when set.
+     * @default undefined
+     */
+    evaluationConcurrency?: number;
     /**
      * A list of evaluators to run on each example.
      * @default undefined
@@ -146,6 +162,13 @@ export interface ExperimentResultRow {
     example: Example;
     evaluationResults: EvaluationResults;
 }
+interface _ExperimentResultRowWithIndex extends ExperimentResultRow {
+    exampleIndex: number;
+}
+export declare function _reorderResultRowsByExampleIndex(rows: _ExperimentResultRowWithIndex[]): {
+    orderedRows: ExperimentResultRow[];
+    orderedRuns: Run[];
+};
 /**
  * Manage the execution of experiments.
  *
@@ -157,6 +180,7 @@ export declare class _ExperimentManager {
     _runs?: AsyncGenerator<Run>;
     _evaluationResults?: AsyncGenerator<EvaluationResults>;
     _summaryResults?: AsyncGenerator<(runsArray: Run[]) => AsyncGenerator<EvaluationResults, any, unknown>, any, unknown>;
+    _resultRows?: AsyncGenerator<_ExperimentResultRowWithIndex>;
     _examples?: Example[];
     _numRepetitions?: number;
     _runsArray?: Run[];
@@ -181,12 +205,14 @@ export declare class _ExperimentManager {
     start(): Promise<_ExperimentManager>;
     withPredictions(target: StandardTargetT, options?: {
         maxConcurrency?: number;
+        queue?: PQueueType;
     }): Promise<_ExperimentManager>;
     withEvaluators(evaluators: Array<EvaluatorT | RunEvaluator>, options?: {
         maxConcurrency?: number;
+        queue?: PQueueType;
     }): Promise<_ExperimentManager>;
     withSummaryEvaluators(summaryEvaluators: Array<SummaryEvaluatorT>): Promise<_ExperimentManager>;
-    getResults(): AsyncGenerator<ExperimentResultRow>;
+    getResults(): AsyncGenerator<_ExperimentResultRowWithIndex>;
     getSummaryScores(): Promise<EvaluationResults>;
     /**
      * Run the target function or runnable on the examples.
@@ -196,10 +222,11 @@ export declare class _ExperimentManager {
      */
     _predict(target: StandardTargetT, options?: {
         maxConcurrency?: number;
+        queue?: PQueueType;
     }): AsyncGenerator<_ForwardResults>;
-    _runEvaluators(evaluators: Array<RunEvaluator>, currentResults: ExperimentResultRow, fields: {
+    _runEvaluators(evaluators: Array<RunEvaluator>, currentResults: _ExperimentResultRowWithIndex, fields: {
         client: Client;
-    }): Promise<ExperimentResultRow>;
+    }): Promise<_ExperimentResultRowWithIndex>;
     /**
      * Run the evaluators on the prediction stream.
      * Expects runs to be available in the manager.
@@ -209,7 +236,8 @@ export declare class _ExperimentManager {
      */
     _score(evaluators: Array<RunEvaluator>, options?: {
         maxConcurrency?: number;
-    }): AsyncGenerator<ExperimentResultRow>;
+        queue?: PQueueType;
+    }): AsyncGenerator<_ExperimentResultRowWithIndex>;
     _applySummaryEvaluators(summaryEvaluators: Array<SummaryEvaluatorT>): AsyncGenerator<(runsArray: Run[]) => AsyncGenerator<EvaluationResults>>;
     _getDatasetVersion(): Promise<string | undefined>;
     _getDatasetSplits(): Promise<string[] | undefined>;
@@ -233,4 +261,10 @@ declare class ExperimentResults implements AsyncIterableIterator<ExperimentResul
     processData(manager: _ExperimentManager): Promise<void>;
     get length(): number;
 }
+/**
+ * Map over an iterable with bounded concurrency using p-queue.
+ * Results are yielded as soon as they resolve (input order is not preserved).
+ * The queue handles concurrency limits internally.
+ */
+export declare function _mapWithConcurrency<TInput, TOutput>(iterable: Iterable<TInput> | AsyncIterable<TInput>, queue: PQueueType, mapper: (value: TInput) => Promise<TOutput>): AsyncGenerator<TOutput>;
 export {};

package/dist/evaluation/_runner.js

@@ -2,7 +2,6 @@ import { Client } from "../index.js";
 import { isTraceableFunction, traceable } from "../traceable.js";
 import { getDefaultRevisionId, getGitInfo } from "../utils/_git.js";
 import { assertUuid } from "../utils/_uuid.js";
-import { AsyncCaller } from "../utils/async_caller.js";
 import { atee } from "../utils/atee.js";
 import { getLangSmithEnvVarsMetadata } from "../utils/env.js";
 import { printErrorStackTrace } from "../utils/error.js";
@@ -10,10 +9,22 @@ import { randomName } from "./_random_name.js";
 import { runEvaluator, } from "./evaluator.js";
 import { v4 as uuidv4 } from "uuid";
 import { evaluateComparative, } from "./evaluate_comparative.js";
+import { PQueue } from "../utils/p-queue.js";
 // Implementation signature
 export function evaluate(target, options) {
     return _evaluate(target, options);
 }
+export function _reorderResultRowsByExampleIndex(rows) {
+    const sortedRows = [...rows].sort((a, b) => a.exampleIndex - b.exampleIndex);
+    return {
+        orderedRows: sortedRows.map(({ run, example, evaluationResults }) => ({
+            run,
+            example,
+            evaluationResults,
+        })),
+        orderedRuns: sortedRows.map((row) => row.run),
+    };
+}
 /**
  * Manage the execution of experiments.
  *
@@ -120,6 +131,12 @@ export class _ExperimentManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_resultRows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_examples", {
             enumerable: true,
             configurable: true,
@@ -206,6 +223,7 @@ export class _ExperimentManager {
         this._runs = args.runs;
         this._evaluationResults = args.evaluationResults;
         this._summaryResults = args.summaryResults;
+        this._resultRows = args.resultRows;
         this._numRepetitions = args.numRepetitions;
         this._includeAttachments = args.includeAttachments;
     }
@@ -300,13 +318,24 @@ export class _ExperimentManager {
     }
     async withPredictions(target, options) {
         const experimentResults = this._predict(target, options);
+        const [rowsForResults, rowsForRuns] = atee(experimentResults);
         return new _ExperimentManager({
             examples: await this.getExamples(),
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
+            resultRows: (async function* () {
+                for await (const pred of rowsForResults) {
+                    yield {
+                        run: pred.run,
+                        example: pred.example,
+                        evaluationResults: { results: [] },
+                        exampleIndex: pred.exampleIndex,
+                    };
+                }
+            })(),
             runs: (async function* () {
-                for await (const pred of experimentResults) {
+                for await (const pred of rowsForRuns) {
                     yield pred.run;
                 }
             })(),
@@ -316,19 +345,20 @@ export class _ExperimentManager {
     async withEvaluators(evaluators, options) {
         const resolvedEvaluators = _resolveEvaluators(evaluators);
         const experimentResults = this._score(resolvedEvaluators, options);
-        const [r1, r2] = atee(experimentResults);
+        const [rowsForResults, rowsForRuns, rowsForEvaluations] = atee(experimentResults, 3);
         return new _ExperimentManager({
             examples: await this.getExamples(),
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
+            resultRows: rowsForResults,
             runs: (async function* () {
-                for await (const result of r1) {
+                for await (const result of rowsForRuns) {
                     yield result.run;
                 }
             })(),
             evaluationResults: (async function* () {
-                for await (const result of r2) {
+                for await (const result of rowsForEvaluations) {
                     yield result.evaluationResults;
                 }
             })(),
@@ -343,30 +373,43 @@ export class _ExperimentManager {
             experiment: this._experiment,
             metadata: this._metadata,
             client: this.client,
-            runs: this.runs,
+            runs: this._runs,
             _runsArray: this._runsArray,
             evaluationResults: this._evaluationResults,
+            resultRows: this._resultRows,
             summaryResults: aggregateFeedbackGen,
             includeAttachments: this._includeAttachments,
         });
     }
     async *getResults() {
-        const examples = await this.getExamples();
-        const evaluationResults = [];
         if (!this._runsArray) {
             this._runsArray = [];
-            for await (const run of this.runs) {
-                this._runsArray.push(run);
-            }
         }
-        for await (const evaluationResult of this.evaluationResults) {
-            evaluationResults.push(evaluationResult);
+        if (this._resultRows) {
+            for await (const result of this._resultRows) {
+                this._runsArray.push(result.run);
+                yield result;
+            }
+            return;
         }
-        for (let i = 0; i < this._runsArray.length; i++) {
+        const examples = await this.getExamples();
+        const runsIterator = this.runs[Symbol.asyncIterator]();
+        const evaluationIterator = this.evaluationResults[Symbol.asyncIterator]();
+        for (let i = 0; i < examples.length; i++) {
+            const runResult = await runsIterator.next();
+            if (runResult.done) {
+                break;
+            }
+            const evaluationResult = await evaluationIterator.next();
+            const evaluationResults = evaluationResult.done
+                ? { results: [] }
+                : evaluationResult.value;
+            this._runsArray.push(runResult.value);
             yield {
-                run: this._runsArray[i],
+                run: runResult.value,
                 example: examples[i],
-                evaluationResults: evaluationResults[i],
+                evaluationResults,
+                exampleIndex: i,
             };
         }
     }
@@ -396,29 +439,52 @@ export class _ExperimentManager {
     async *_predict(target, options) {
         const maxConcurrency = options?.maxConcurrency ?? 0;
         const examples = await this.getExamples();
-        if (maxConcurrency === 0) {
-            for (const example of examples) {
-                yield await _forward(target, example, this.experimentName, this._metadata, this.client, this._includeAttachments);
+        let hadPredictionError = false;
+        let shouldThrowEndError = false;
+        let endErrorToThrow;
+        try {
+            // maxConcurrency: 0 means sequential execution (matching Python behavior)
+            const queue = options?.queue ??
+                new PQueue({
+                    concurrency: maxConcurrency === 0 ? 1 : maxConcurrency,
+                });
+            const examplesWithIndex = examples.map((example, i) => ({
+                example,
+                exampleIndex: i,
+            }));
+            for await (const result of _mapWithConcurrency(examplesWithIndex, queue, (item) => _forward(target, item.example, this.experimentName, this._metadata, this.client, this._includeAttachments).then((forwardResult) => ({
+                ...forwardResult,
+                exampleIndex: item.exampleIndex,
+            })))) {
+                yield result;
             }
         }
-        else {
-            const caller = new AsyncCaller({
-                maxConcurrency,
-                debug: this.client.debug,
-            });
-            const futures = [];
-            for await (const example of examples) {
-                futures.push(caller.call(_forward, target, example, this.experimentName, this._metadata, this.client, this._includeAttachments));
+        catch (error) {
+            hadPredictionError = true;
+            throw error;
+        }
+        finally {
+            try {
+                // Always attempt to close out the project metadata, even on prediction errors.
+                await this._end();
             }
-            for await (const future of futures) {
-                yield future;
+            catch (endError) {
+                if (hadPredictionError) {
+                    console.error(`Error finalizing experiment: ${endError}`);
+                    printErrorStackTrace(endError);
+                }
+                else {
+                    shouldThrowEndError = true;
+                    endErrorToThrow = endError;
+                }
             }
         }
-        // Close out the project.
-        await this._end();
+        if (shouldThrowEndError) {
+            throw endErrorToThrow;
+        }
     }
     async _runEvaluators(evaluators, currentResults, fields) {
-        const { run, example, evaluationResults } = currentResults;
+        const { run, example, evaluationResults, exampleIndex } = currentResults;
         for (const evaluator of evaluators) {
             try {
                 const options = {
@@ -444,6 +510,7 @@ export class _ExperimentManager {
             run,
             example,
             evaluationResults,
+            exampleIndex,
         };
     }
     /**
@@ -454,28 +521,16 @@ export class _ExperimentManager {
      * @param {number} maxConcurrency
      */
     async *_score(evaluators, options) {
-        const { maxConcurrency = 0 } = options || {};
-        if (maxConcurrency === 0) {
-            for await (const currentResults of this.getResults()) {
-                yield this._runEvaluators(evaluators, currentResults, {
-                    client: this.client,
-                });
-            }
-        }
-        else {
-            const caller = new AsyncCaller({
-                maxConcurrency,
-                debug: this.client.debug,
+        const { maxConcurrency = 0, queue: providedQueue } = options || {};
+        // maxConcurrency: 0 means sequential execution (matching Python behavior)
+        const queue = providedQueue ??
+            new PQueue({
+                concurrency: maxConcurrency === 0 ? 1 : maxConcurrency,
             });
-            const futures = [];
-            for await (const currentResults of this.getResults()) {
-                futures.push(caller.call(this._runEvaluators, evaluators, currentResults, {
-                    client: this.client,
-                }));
-            }
-            for (const result of futures) {
-                yield result;
-            }
+        for await (const result of _mapWithConcurrency(this.getResults(), queue, (currentResults) => this._runEvaluators(evaluators, currentResults, {
+            client: this.client,
+        }))) {
+            yield result;
         }
     }
     async *_applySummaryEvaluators(summaryEvaluators) {
@@ -627,10 +682,14 @@ class ExperimentResults {
         }
     }
     async processData(manager) {
+        const unorderedResults = [];
         for await (const item of manager.getResults()) {
-            this.results.push(item);
-            this.processedCount++;
+            unorderedResults.push(item);
         }
+        const { orderedRows, orderedRuns } = _reorderResultRowsByExampleIndex(unorderedResults);
+        manager._runsArray = orderedRuns;
+        this.results = orderedRows;
+        this.processedCount = this.results.length;
         this.summaryResults = await manager.getSummaryScores();
     }
     get length() {
@@ -671,14 +730,40 @@ async function _evaluate(target, fields) {
         numRepetitions: fields.numRepetitions ?? 1,
         includeAttachments: standardFields.includeAttachments,
     }).start();
+    const targetConcurrency = standardFields.targetConcurrency ?? standardFields.maxConcurrency ?? 0;
+    const evaluationConcurrency = standardFields.evaluationConcurrency ?? standardFields.maxConcurrency ?? 0;
+    // Determine if we should use separate queues or a shared queue
+    const useSeparateQueues = standardFields.targetConcurrency !== undefined &&
+        standardFields.evaluationConcurrency !== undefined;
+    let sharedQueue;
+    let targetQueue;
+    let evaluationQueue;
+    if (useSeparateQueues) {
+        // Create separate queues for target and evaluation
+        if (targetConcurrency > 0) {
+            targetQueue = new PQueue({ concurrency: targetConcurrency });
+        }
+        if (evaluationConcurrency > 0) {
+            evaluationQueue = new PQueue({ concurrency: evaluationConcurrency });
+        }
+    }
+    else {
+        // Use a shared queue
+        const sharedConcurrency = standardFields.maxConcurrency ?? 0;
+        if (sharedConcurrency > 0) {
+            sharedQueue = new PQueue({ concurrency: sharedConcurrency });
+        }
+    }
     if (_isCallable(target)) {
         manager = await manager.withPredictions(target, {
-            maxConcurrency: fields.maxConcurrency,
+            maxConcurrency: targetConcurrency,
+            queue: useSeparateQueues ? targetQueue : sharedQueue,
         });
     }
     if (standardFields.evaluators) {
         manager = await manager.withEvaluators(standardFields.evaluators, {
-            maxConcurrency: fields.maxConcurrency,
+            maxConcurrency: evaluationConcurrency,
+            queue: useSeparateQueues ? evaluationQueue : sharedQueue,
         });
     }
     if (standardFields.summaryEvaluators) {
@@ -863,6 +948,30 @@ async function _resolveExperiment(experiment, runs, client) {
     }
     return [undefined, undefined];
 }
+/**
+ * Map over an iterable with bounded concurrency using p-queue.
+ * Results are yielded as soon as they resolve (input order is not preserved).
+ * The queue handles concurrency limits internally.
+ */
+export async function* _mapWithConcurrency(iterable, queue, mapper) {
+    const pending = new Set();
+    // Add all tasks to p-queue immediately (p-queue handles concurrency)
+    for await (const input of iterable) {
+        const task = queue
+            .add(() => mapper(input))
+            .then((value) => ({
+            value,
+            self: task,
+        }));
+        pending.add(task);
+    }
+    // Yield results as they complete
+    while (pending.size > 0) {
+        const { value, self } = await Promise.race(pending);
+        pending.delete(self);
+        yield value;
+    }
+}
 function _isCallable(target) {
     return Boolean(typeof target === "function" ||
         ("invoke" in target && typeof target.invoke === "function"));

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__version__ = exports.promptCacheSingleton = exports.configureGlobalPromptCache = exports.PromptCache = exports.uuid7FromTime = exports.uuid7 = exports.getDefaultProjectName = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
+exports.__version__ = exports.promptCacheSingleton = exports.configureGlobalPromptCache = exports.PromptCache = exports.Cache = exports.uuid7FromTime = exports.uuid7 = exports.getDefaultProjectName = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
 var client_js_1 = require("./client.cjs");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });
 var run_trees_js_1 = require("./run_trees.cjs");
@@ -13,8 +13,9 @@ var uuid_js_1 = require("./uuid.cjs");
 Object.defineProperty(exports, "uuid7", { enumerable: true, get: function () { return uuid_js_1.uuid7; } });
 Object.defineProperty(exports, "uuid7FromTime", { enumerable: true, get: function () { return uuid_js_1.uuid7FromTime; } });
 var index_js_1 = require("./utils/prompt_cache/index.cjs");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return index_js_1.Cache; } });
 Object.defineProperty(exports, "PromptCache", { enumerable: true, get: function () { return index_js_1.PromptCache; } });
 Object.defineProperty(exports, "configureGlobalPromptCache", { enumerable: true, get: function () { return index_js_1.configureGlobalPromptCache; } });
 Object.defineProperty(exports, "promptCacheSingleton", { enumerable: true, get: function () { return index_js_1.promptCacheSingleton; } });
 // Update using yarn bump-version
-exports.__version__ = "0.5.0";
+exports.__version__ = "0.5.1";

package/dist/index.d.ts

@@ -4,5 +4,5 @@ export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
-export { PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
-export declare const __version__ = "0.5.0";
+export { Cache, PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
+export declare const __version__ = "0.5.1";

package/dist/index.js

@@ -3,6 +3,6 @@ export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
-export { PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
+export { Cache, PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 // Update using yarn bump-version
-export const __version__ = "0.5.0";
+export const __version__ = "0.5.1";

package/dist/utils/async_caller.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncCaller = void 0;
 const index_js_1 = __importDefault(require("../utils/p-retry/index.cjs"));
-const p_queue_1 = __importDefault(require("p-queue"));
+const p_queue_js_1 = require("./p-queue.cjs");
 const STATUS_RETRYABLE = [
     408, // Request Timeout
     425, // Too Early
@@ -69,16 +69,7 @@ class AsyncCaller {
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
         this.maxQueueSizeBytes = params.maxQueueSizeBytes;
-        if ("default" in p_queue_1.default) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new p_queue_1.default.default({
-                concurrency: this.maxConcurrency,
-            });
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new p_queue_1.default({ concurrency: this.maxConcurrency });
-        }
+        this.queue = new p_queue_js_1.PQueue({ concurrency: this.maxConcurrency });
         this.onFailedResponseHook = params?.onFailedResponseHook;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/utils/async_caller.d.ts

@@ -1,3 +1,4 @@
+import { PQueueType } from "./p-queue.js";
 type ResponseCallback = (response?: Response) => Promise<boolean>;
 export interface AsyncCallerParams {
     /**
@@ -44,7 +45,7 @@ export declare class AsyncCaller {
     protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
     protected maxRetries: AsyncCallerParams["maxRetries"];
     protected maxQueueSizeBytes: AsyncCallerParams["maxQueueSizeBytes"];
-    queue: typeof import("p-queue")["default"]["prototype"];
+    queue: PQueueType;
     private onFailedResponseHook?;
     private queueSizeBytes;
     constructor(params: AsyncCallerParams);

package/dist/utils/async_caller.js

@@ -1,5 +1,5 @@
 import pRetry from "../utils/p-retry/index.js";
-import PQueueMod from "p-queue";
+import { PQueue } from "./p-queue.js";
 const STATUS_RETRYABLE = [
     408, // Request Timeout
     425, // Too Early
@@ -63,16 +63,7 @@ export class AsyncCaller {
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
         this.maxQueueSizeBytes = params.maxQueueSizeBytes;
-        if ("default" in PQueueMod) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new PQueueMod.default({
-                concurrency: this.maxConcurrency,
-            });
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new PQueueMod({ concurrency: this.maxConcurrency });
-        }
+        this.queue = new PQueue({ concurrency: this.maxConcurrency });
         this.onFailedResponseHook = params?.onFailedResponseHook;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/utils/p-queue.cjs

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PQueue = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+// Helper to handle both default and named exports of p-queue
+exports.PQueue = ("default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default);

package/dist/utils/p-queue.d.ts

@@ -0,0 +1,2 @@
+export declare const PQueue: typeof import("p-queue").default;
+export type PQueueType = InstanceType<typeof PQueue>;

package/dist/utils/p-queue.js

@@ -0,0 +1,3 @@
+import PQueueMod from "p-queue";
+// Helper to handle both default and named exports of p-queue
+export const PQueue = ("default" in PQueueMod ? PQueueMod.default : PQueueMod);

package/dist/utils/prompt_cache/index.cjs

@@ -9,7 +9,7 @@
  * that are swapped for browser builds via package.json browser field.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptCacheSingleton = exports.PromptCache = void 0;
+exports.Cache = exports.promptCacheSingleton = exports.PromptCache = void 0;
 exports.configureGlobalPromptCache = configureGlobalPromptCache;
 const fs_js_1 = require("./fs.cjs");
 /**
@@ -321,3 +321,16 @@ exports.promptCacheSingleton = new PromptCache();
 function configureGlobalPromptCache(config) {
     exports.promptCacheSingleton.configure(config);
 }
+/**
+ * @deprecated Use `PromptCache` instead. This is a deprecated alias.
+ *
+ * Deprecated alias for PromptCache. Use PromptCache instead.
+ */
+class Cache extends PromptCache {
+    constructor(config = {}) {
+        console.warn("The 'Cache' class is deprecated and will be removed in a future version. " +
+            "Use 'PromptCache' instead.");
+        super(config);
+    }
+}
+exports.Cache = Cache;

package/dist/utils/prompt_cache/index.d.ts

@@ -154,3 +154,11 @@ export declare class PromptCache {
  * ```
  */
 export declare function configureGlobalPromptCache(config: CacheConfig): void;
+/**
+ * @deprecated Use `PromptCache` instead. This is a deprecated alias.
+ *
+ * Deprecated alias for PromptCache. Use PromptCache instead.
+ */
+export declare class Cache extends PromptCache {
+    constructor(config?: CacheConfig);
+}

package/dist/utils/prompt_cache/index.js

@@ -316,3 +316,15 @@ export const promptCacheSingleton = new PromptCache();
 export function configureGlobalPromptCache(config) {
     promptCacheSingleton.configure(config);
 }
+/**
+ * @deprecated Use `PromptCache` instead. This is a deprecated alias.
+ *
+ * Deprecated alias for PromptCache. Use PromptCache instead.
+ */
+export class Cache extends PromptCache {
+    constructor(config = {}) {
+        console.warn("The 'Cache' class is deprecated and will be removed in a future version. " +
+            "Use 'PromptCache' instead.");
+        super(config);
+    }
+}

package/dist/wrappers/anthropic.cjs

@@ -207,12 +207,38 @@ const wrapAnthropic = (anthropic, options) => {
         ...options,
         metadata: restMetadata,
     };
+    /**
+     * Transform system parameter into visible message for playground editability.
+     * This provides parity with the Python SDK behavior and enables system prompts
+     * to be viewed and edited in the LangSmith playground.
+     */
+    function processSystemMessage(params) {
+        if (!params.system) {
+            return params;
+        }
+        const processed = { ...params };
+        // Handle both string and ContentBlock[] formats
+        const systemContent = Array.isArray(params.system)
+            ? params.system
+                .map((block) => typeof block === "string" ? block : block.text)
+                .join("\n")
+            : params.system;
+        // Transform into first message
+        processed.messages = [
+            { role: "system", content: systemContent },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...(params.messages || []),
+        ];
+        delete processed.system;
+        return processed;
+    }
     // Common configuration for messages.create
     const messagesCreateConfig = {
         name: "ChatAnthropic",
         run_type: "llm",
         aggregator: messageAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        processInputs: processSystemMessage,
         getInvocationParams: (payload) => {
             if (typeof payload !== "object" || payload == null)
                 return undefined;
@@ -279,6 +305,7 @@ const wrapAnthropic = (anthropic, options) => {
         run_type: "llm",
         aggregator: messageAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        processInputs: processSystemMessage,
         getInvocationParams: messagesCreateConfig.getInvocationParams,
         processOutputs: processMessageOutput,
         ...cleanedOptions,
@@ -300,6 +327,7 @@ const wrapAnthropic = (anthropic, options) => {
                 run_type: "llm",
                 aggregator: messageAggregator,
                 argsConfigPath: [1, "langsmithExtra"],
+                processInputs: processSystemMessage,
                 getInvocationParams: messagesCreateConfig.getInvocationParams,
                 processOutputs: processMessageOutput,
                 ...cleanedOptions,

package/dist/wrappers/anthropic.js

@@ -204,12 +204,38 @@ export const wrapAnthropic = (anthropic, options) => {
         ...options,
         metadata: restMetadata,
     };
+    /**
+     * Transform system parameter into visible message for playground editability.
+     * This provides parity with the Python SDK behavior and enables system prompts
+     * to be viewed and edited in the LangSmith playground.
+     */
+    function processSystemMessage(params) {
+        if (!params.system) {
+            return params;
+        }
+        const processed = { ...params };
+        // Handle both string and ContentBlock[] formats
+        const systemContent = Array.isArray(params.system)
+            ? params.system
+                .map((block) => typeof block === "string" ? block : block.text)
+                .join("\n")
+            : params.system;
+        // Transform into first message
+        processed.messages = [
+            { role: "system", content: systemContent },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ...(params.messages || []),
+        ];
+        delete processed.system;
+        return processed;
+    }
     // Common configuration for messages.create
     const messagesCreateConfig = {
         name: "ChatAnthropic",
         run_type: "llm",
         aggregator: messageAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        processInputs: processSystemMessage,
         getInvocationParams: (payload) => {
             if (typeof payload !== "object" || payload == null)
                 return undefined;
@@ -276,6 +302,7 @@ export const wrapAnthropic = (anthropic, options) => {
         run_type: "llm",
         aggregator: messageAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        processInputs: processSystemMessage,
         getInvocationParams: messagesCreateConfig.getInvocationParams,
         processOutputs: processMessageOutput,
         ...cleanedOptions,
@@ -297,6 +324,7 @@ export const wrapAnthropic = (anthropic, options) => {
                 run_type: "llm",
                 aggregator: messageAggregator,
                 argsConfigPath: [1, "langsmithExtra"],
+                processInputs: processSystemMessage,
                 getInvocationParams: messagesCreateConfig.getInvocationParams,
                 processOutputs: processMessageOutput,
                 ...cleanedOptions,

package/package.json

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