@openai/agents-core/dist/runner/siblingCancellation.js

The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.runWithSiblingCancellation = runWithSiblingCancellation;
const abortSignals_1 = require("../utils/abortSignals.js");
async function runWithSiblingCancellation(tasks, parentSignal, onFirstFailure) {
    if (tasks.length <= 1) {
        return Promise.all(tasks.map((task) => task(parentSignal)));
    }
    const siblingController = new AbortController();
    const { signal, cleanup } = (0, abortSignals_1.combineAbortSignals)(parentSignal, siblingController.signal);
    let firstFailureOwner;
    let firstFailureParentWasAborted = false;
    let firstFailure;
    const siblingFailureReason = (0, abortSignals_1.createSiblingCancellationError)();
    const cancelSiblings = () => {
        if (!siblingController.signal.aborted) {
            siblingController.abort(siblingFailureReason);
        }
    };
    const reserveFailure = (owner, hasFailure, error) => {
        const newlyReserved = firstFailureOwner === undefined;
        if (firstFailureOwner === undefined) {
            firstFailureOwner = owner;
            firstFailureParentWasAborted = parentSignal?.aborted ?? false;
        }
        if (firstFailureOwner === owner &&
            hasFailure &&
            firstFailure === undefined) {
            const parentReason = parentSignal?.reason;
            const failure = firstFailureParentWasAborted &&
                (error === parentReason || (0, abortSignals_1.isAbortError)(error))
                ? parentReason
                : error;
            firstFailure = { value: failure };
        }
        if (newlyReserved) {
            try {
                onFirstFailure?.();
            }
            finally {
                cancelSiblings();
            }
        }
    };
    const pendingTasks = tasks.map(async (task, index) => {
        try {
            return await task(signal, (...errors) => reserveFailure(index, errors.length > 0, errors[0]));
        }
        catch (error) {
            reserveFailure(index, true, error);
            throw error;
        }
    });
    try {
        const settledTasks = await Promise.allSettled(pendingTasks);
        if (firstFailureOwner !== undefined) {
            if (firstFailure === undefined) {
                const ownerResult = settledTasks[firstFailureOwner];
                if (ownerResult?.status === 'rejected') {
                    throw ownerResult.reason;
                }
                throw new Error('The task that reserved failure ownership completed.');
            }
            throw firstFailure.value;
        }
        return settledTasks.map((result) => result.value);
    }
    finally {
        cleanup();
    }
}
//# sourceMappingURL=siblingCancellation.js.map