@openai/agents-core/dist/sandbox/errors.mjs

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

import { UserError } from "../errors.mjs";
export class SandboxError extends UserError {
    code;
    details;
    retryable;
    constructor(message, code = 'runtime_error', details) {
        super(message);
        this.code = code;
        this.details = details;
        this.retryable = inferSandboxErrorRetryability(code, details);
    }
}
export class SandboxConfigurationError extends SandboxError {
    constructor(message, details, code = 'configuration_error') {
        super(message, code, details);
    }
}
export class SandboxRuntimeError extends SandboxError {
    constructor(message, details, code = 'runtime_error') {
        super(message, code, details);
    }
}
export class SandboxArtifactError extends SandboxError {
    constructor(message, details, code = 'artifact_error') {
        super(message, code, details);
    }
}
export class SandboxSnapshotError extends SandboxError {
    constructor(message, details, code = 'snapshot_error') {
        super(message, code, details);
    }
}
export class SandboxArchiveError extends SandboxError {
    constructor(message, details) {
        super(message, 'archive_error', details);
    }
}
export class SandboxMountError extends SandboxError {
    constructor(message, details, code = 'mount_error') {
        super(message, code, details);
    }
}
export class SandboxLifecycleError extends SandboxError {
    constructor(message, details) {
        super(message, 'lifecycle_error', details);
    }
}
export class SandboxPtyError extends SandboxError {
    constructor(message, details, code = 'pty_error') {
        super(message, code, details);
    }
}
export class SandboxUnsupportedFeatureError extends SandboxError {
    constructor(message, details) {
        super(message, 'unsupported_feature', details);
    }
}
export class SandboxPathResolutionError extends SandboxError {
    constructor(message, details) {
        super(message, 'path_resolution_error', details);
    }
}
export class SandboxProviderError extends SandboxError {
    constructor(message, details) {
        super(message, 'provider_error', details);
    }
}
export class SandboxInvalidManifestPathError extends SandboxError {
    constructor(message, details) {
        super(message, 'invalid_manifest_path', details);
    }
}
export class SandboxInvalidCompressionSchemeError extends SandboxError {
    constructor(message, details) {
        super(message, 'invalid_compression_scheme', details);
    }
}
export class SandboxExposedPortUnavailableError extends SandboxRuntimeError {
    constructor(message, details) {
        super(message, details, 'exposed_port_unavailable');
    }
}
export class SandboxExecError extends SandboxRuntimeError {
    constructor(message, code, details) {
        super(message, details, code);
    }
}
export class SandboxExecNonZeroError extends SandboxExecError {
    constructor(message, details) {
        super(message, 'exec_nonzero', details);
    }
}
export class SandboxExecTimeoutError extends SandboxExecError {
    constructor(message, details) {
        super(message, 'exec_timeout', details);
    }
}
export class SandboxExecTransportError extends SandboxExecError {
    constructor(message, details) {
        super(message, 'exec_transport_error', details);
    }
}
export class SandboxPtySessionNotFoundError extends SandboxPtyError {
    constructor(message, details) {
        super(message, details, 'pty_session_not_found');
    }
}
export class SandboxApplyPatchError extends SandboxError {
    constructor(message, code, details) {
        super(message, code, details);
    }
}
export class SandboxApplyPatchPathError extends SandboxApplyPatchError {
    constructor(message, details) {
        super(message, 'apply_patch_invalid_path', details);
    }
}
export class SandboxApplyPatchDiffError extends SandboxApplyPatchError {
    constructor(message, details) {
        super(message, 'apply_patch_invalid_diff', details);
    }
}
export class SandboxApplyPatchFileNotFoundError extends SandboxApplyPatchError {
    constructor(message, details) {
        super(message, 'apply_patch_file_not_found', details);
    }
}
export class SandboxApplyPatchDecodeError extends SandboxApplyPatchError {
    constructor(message, details) {
        super(message, 'apply_patch_decode_error', details);
    }
}
export class SandboxWorkspaceError extends SandboxRuntimeError {
    constructor(message, code, details) {
        super(message, details, code);
    }
}
export class SandboxWorkspaceReadNotFoundError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_read_not_found', details);
    }
}
export class SandboxWorkspaceArchiveReadError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_archive_read_error', details);
    }
}
export class SandboxWorkspaceArchiveWriteError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_archive_write_error', details);
    }
}
export class SandboxWorkspaceWriteTypeError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_write_type_error', details);
    }
}
export class SandboxWorkspaceStopError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_stop_error', details);
    }
}
export class SandboxWorkspaceStartError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_start_error', details);
    }
}
export class SandboxWorkspaceRootNotFoundError extends SandboxWorkspaceError {
    constructor(message, details) {
        super(message, 'workspace_root_not_found', details);
    }
}
export class SandboxLocalArtifactError extends SandboxArtifactError {
    constructor(message, code, details) {
        super(message, details, code);
    }
}
export class SandboxLocalFileReadError extends SandboxLocalArtifactError {
    constructor(message, details) {
        super(message, 'local_file_read_error', details);
    }
}
export class SandboxLocalDirReadError extends SandboxLocalArtifactError {
    constructor(message, details) {
        super(message, 'local_dir_read_error', details);
    }
}
export class SandboxLocalChecksumError extends SandboxLocalArtifactError {
    constructor(message, details) {
        super(message, 'local_checksum_error', details);
    }
}
export class SandboxGitArtifactError extends SandboxArtifactError {
    constructor(message, code, details) {
        super(message, details, code);
    }
}
export class SandboxGitMissingInImageError extends SandboxGitArtifactError {
    constructor(message, details) {
        super(message, 'git_missing_in_image', details);
    }
}
export class SandboxGitCloneError extends SandboxGitArtifactError {
    constructor(message, details) {
        super(message, 'git_clone_error', details);
    }
}
export class SandboxGitSubpathError extends SandboxGitArtifactError {
    constructor(message, details) {
        super(message, 'git_subpath_error', details);
    }
}
export class SandboxGitCopyError extends SandboxGitArtifactError {
    constructor(message, details) {
        super(message, 'git_copy_error', details);
    }
}
export class SandboxMountToolMissingError extends SandboxMountError {
    constructor(message, details) {
        super(message, details, 'mount_missing_tool');
    }
}
export class SandboxMountCommandError extends SandboxMountError {
    constructor(message, details) {
        super(message, details, 'mount_failed');
    }
}
export class SandboxMountConfigError extends SandboxMountError {
    constructor(message, details) {
        super(message, details, 'mount_config_invalid');
    }
}
export class SandboxSkillsConfigError extends SandboxError {
    constructor(message, details) {
        super(message, 'skills_config_invalid', details);
    }
}
export class SandboxConfigError extends SandboxConfigurationError {
    constructor(message, details) {
        super(message, details, 'sandbox_config_invalid');
    }
}
export class SandboxSnapshotPersistError extends SandboxSnapshotError {
    constructor(message, details) {
        super(message, details, 'snapshot_persist_error');
    }
}
export class SandboxSnapshotRestoreError extends SandboxSnapshotError {
    constructor(message, details) {
        super(message, details, 'snapshot_restore_error');
    }
}
export class SandboxSnapshotNotRestorableError extends SandboxSnapshotError {
    constructor(message, details) {
        super(message, details, 'snapshot_not_restorable');
    }
}
function inferSandboxErrorRetryability(code, details) {
    const retryable = details?.retryable;
    if (typeof retryable === 'boolean') {
        return retryable;
    }
    const cause = details?.cause;
    if (cause instanceof SandboxError) {
        return cause.retryable;
    }
    const providerRetryability = inferProviderDetailsRetryability(details);
    if (providerRetryability !== null) {
        return providerRetryability;
    }
    switch (code) {
        case 'configuration_error':
        case 'unsupported_feature':
        case 'path_resolution_error':
        case 'invalid_manifest_path':
        case 'invalid_compression_scheme':
        case 'exposed_port_unavailable':
        case 'exec_nonzero':
        case 'exec_timeout':
        case 'pty_session_not_found':
        case 'apply_patch_invalid_path':
        case 'apply_patch_invalid_diff':
        case 'apply_patch_file_not_found':
        case 'apply_patch_decode_error':
        case 'workspace_read_not_found':
        case 'workspace_write_type_error':
        case 'workspace_root_not_found':
        case 'git_missing_in_image':
        case 'git_subpath_error':
        case 'mount_missing_tool':
        case 'mount_config_invalid':
        case 'skills_config_invalid':
        case 'sandbox_config_invalid':
        case 'snapshot_not_restorable':
            return false;
        default:
            return null;
    }
}
function inferProviderDetailsRetryability(details) {
    const status = readStatus(details);
    if (status !== undefined) {
        if ([408, 425, 429, 500, 502, 503, 504].includes(status)) {
            return true;
        }
        if ([400, 401, 403, 404, 409, 422].includes(status)) {
            return false;
        }
    }
    const code = details?.errorCode ?? details?.providerErrorCode;
    if (typeof code === 'string') {
        const normalized = code.toLowerCase();
        if (/(rate.?limit|timeout|connection|unavailable)/u.test(normalized)) {
            return true;
        }
        if (/(authentication|authorization|permission|forbidden|not.?found|validation|bad.?request|conflict|unprocessable)/u.test(normalized)) {
            return false;
        }
    }
    return null;
}
function readStatus(details) {
    if (!details) {
        return undefined;
    }
    for (const key of ['status', 'httpStatus', 'responseStatus']) {
        const value = details[key];
        if (typeof value === 'number' && Number.isInteger(value)) {
            return value;
        }
        if (typeof value === 'string' && /^\d+$/u.test(value)) {
            return Number(value);
        }
    }
    return undefined;
}
//# sourceMappingURL=errors.mjs.map