langsmith 0.5.0-rc.2 → 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 {};